def __refuse(self, request, recip, comment, origmsg=None, lang=None): # As this message is going to the requestor, try to set the language # to his/her language choice, if they are a member. Otherwise use the # list's preferred language. realname = self.real_name if lang is None: lang = self.getMemberLanguage(recip) text = Utils.maketext('refuse.txt', { 'listname': realname, 'request': request, 'reason': comment, 'adminaddr': self.GetOwnerEmail(), }, lang=lang, mlist=self) otrans = i18n.get_translation() i18n.set_language(lang) try: # add in original message, but not wrap/filled if origmsg: text = NL.join([ text, '---------- ' + _('Original Message') + ' ----------', str(origmsg) ]) subject = _('Request to mailing list %(realname)s rejected') finally: i18n.set_translation(otrans) msg = Message.UserNotification(recip, self.GetOwnerEmail(), subject, text, lang) msg.send(self)
def __sendAdminBounceNotice(self, member, msg, did=_('disabled')): # BAW: This is a bit kludgey, but we're not providing as much # information in the new admin bounce notices as we used to (some of # it was of dubious value). However, we'll provide empty, strange, or # meaningless strings for the unused %()s fields so that the language # translators don't have to provide new templates. siteowner = Utils.get_site_email(self.host_name) text = Utils.maketext('bounce.txt', { 'listname': self.real_name, 'addr': member, 'negative': '', 'did': did, 'but': '', 'reenable': '', 'owneraddr': siteowner, }, mlist=self) subject = _('Bounce action notification') umsg = Message.UserNotification(self.GetOwnerEmail(), siteowner, subject, lang=self.preferred_language) # BAW: Be sure you set the type before trying to attach, or you'll get # a MultipartConversionError. umsg.set_type('multipart/mixed') umsg.attach( MIMEText(text, _charset=Utils.GetCharSet(self.preferred_language))) if isinstance(msg, StringType): umsg.attach(MIMEText(msg)) else: umsg.attach(MIMEMessage(msg)) umsg.send(self)
def HoldUnsubscription(self, addr): # Assure the database is open for writing self.__opendb() # Get the next unique id id = self.__nextid() # All we need to do is save the unsubscribing address self.__db[id] = (UNSUBSCRIPTION, addr) syslog('vette', '%s: held unsubscription request from %s', self.internal_name(), addr) # Possibly notify the administrator of the hold if self.admin_immed_notify: realname = self.real_name subject = _( 'New unsubscription request from %(realname)s by %(addr)s') text = Utils.maketext( 'unsubauth.txt', { 'username': addr, 'listname': self.internal_name(), 'hostname': self.host_name, 'admindb_url': self.GetScriptURL('admindb', absolute=1), }, mlist=self) # This message should appear to come from the <list>-owner so as # to avoid any useless bounce processing. owneraddr = self.GetOwnerEmail() msg = Message.UserNotification(owneraddr, owneraddr, subject, text, self.preferred_language) msg.send(self, **{'tomoderators': 1})
def SendUnsubscribeAck(self, addr, lang): realname = self.real_name msg = Message.UserNotification( self.GetMemberAdminEmail(addr), self.GetBouncesEmail(), _('You have been unsubscribed from the %(realname)s mailing list'), Utils.wrap(self.goodbye_msg), lang) msg.send(self, verp=mm_cfg.VERP_PERSONALIZED_DELIVERIES)
def test_user_notification(self): eq = self.assertEqual unless = self.failUnless msg = Message.UserNotification('*****@*****.**', '*****@*****.**', 'Your Test List', 'About your test list') msg.send(self._mlist) qmsg = email.message_from_string(self._readmsg()) eq(qmsg['subject'], 'Your Test List') eq(qmsg['from'], '*****@*****.**') eq(qmsg['to'], '*****@*****.**') # The Message-ID: header has some time-variant information msgid = qmsg['message-id'] unless(msgid.startswith('<mailman.')) unless(msgid.endswith('*****@*****.**>')) # The Sender: header is optional and addresses can be VERPed if self._mlist.include_sender_header: sender = qmsg['sender'] unless(sender.startswith('"_xtest" <_xtest-bounces')) unless(sender.endswith('@dom.ain>')) eto = qmsg['errors-to'] unless(eto.startswith('_xtest-bounces')) unless(eto.endswith('@dom.ain')) eq(qmsg['x-beenthere'], '*****@*****.**') eq(qmsg['x-mailman-version'], Version.VERSION) eq(qmsg['precedence'], 'bulk') eq(qmsg['list-id'], '<_xtest.dom.ain>') eq(qmsg['x-list-administrivia'], 'yes') eq(qmsg.get_payload(), 'About your test list')
def process(mlist, msg, msgdata): # Extract the sender's address and find them in the user database sender = msgdata.get('original_sender', msg.get_sender()) try: ack = mlist.getMemberOption(sender, mm_cfg.AcknowledgePosts) if not ack: return except Errors.NotAMemberError: return # Okay, they want acknowledgement of their post. Give them their original # subject. BAW: do we want to use the decoded header? origsubj = msgdata.get('origsubj', msg.get('subject', _('(no subject)'))) # Get the user's preferred language lang = msgdata.get('lang', mlist.getMemberLanguage(sender)) # Now get the acknowledgement template realname = mlist.real_name text = Utils.maketext( 'postack.txt', { 'subject': Utils.oneline(origsubj, Utils.GetCharSet(lang)), 'listname': realname, 'listinfo_url': mlist.GetScriptURL('listinfo', absolute=1), 'optionsurl': mlist.GetOptionsURL(sender, absolute=1), }, lang=lang, mlist=mlist, raw=1) # Craft the outgoing message, with all headers and attributes # necessary for general delivery. Then enqueue it to the outgoing # queue. subject = _('%(realname)s post acknowledgement') usermsg = Message.UserNotification(sender, mlist.GetBouncesEmail(), subject, text, lang) usermsg.send(mlist)
def MailUserPassword(self, user): listfullname = '%s@%s' % (self.real_name, self.host_name) requestaddr = self.GetRequestEmail() # find the lowercased version of the user's address adminaddr = self.GetBouncesEmail() assert self.isMember(user) if not self.getMemberPassword(user): # The user's password somehow got corrupted. Generate a new one # for him, after logging this bogosity. syslog('error', 'User %s had a false password for list %s', user, self.internal_name()) waslocked = self.Locked() if not waslocked: self.Lock() try: self.setMemberPassword(user, Utils.MakeRandomPassword()) self.Save() finally: if not waslocked: self.Unlock() # Now send the user his password cpuser = self.getMemberCPAddress(user) recipient = self.GetMemberAdminEmail(cpuser) subject = _('%(listfullname)s mailing list reminder') # Get user's language and charset lang = self.getMemberLanguage(user) cset = Utils.GetCharSet(lang) password = self.getMemberPassword(user) # TK: Make unprintables to ? # The list owner should allow users to set language options if they # want to use non-us-ascii characters in password and send it back. password = unicode(password, cset, 'replace').encode(cset, 'replace') # get the text from the template text = Utils.maketext( 'userpass.txt', { 'user': cpuser, 'listname': self.real_name, 'fqdn_lname': self.GetListEmail(), 'password': password, 'options_url': self.GetOptionsURL(user, absolute=True), 'requestaddr': requestaddr, 'owneraddr': self.GetOwnerEmail(), }, lang=lang, mlist=self) msg = Message.UserNotification(recipient, adminaddr, subject, text, lang) msg['X-No-Archive'] = 'yes' msg.send(self, verp=mm_cfg.VERP_PERSONALIZED_DELIVERIES)
def create(mlist, cgi=False, nolock=False, quiet=False): if mlist is None: return listname = mlist.internal_name() fieldsz = len(listname) + len('-unsubscribe') if cgi: # If a list is being created via the CGI, the best we can do is send # an email message to mailman-owner requesting that the proper aliases # be installed. sfp = StringIO() if not quiet: print(_(""" The mailing list `%(listname)s' has been created via the through-the-web interface. In order to complete the activation of this mailing list, the proper /etc/aliases (or equivalent) file must be updated. The program `newaliases' may also have to be run. Here are the entries for the /etc/aliases file: """), file=sfp) outfp = sfp else: if not quiet: print( C_("""\ To finish creating your mailing list, you must edit your /etc/aliases (or equivalent) file by adding the following lines, and possibly running the `newaliases' program: """)) print(C_("""\ ## %(listname)s mailing list""")) outfp = sys.stdout # Common path for k, v in makealiases(listname): print(k + ':', ((fieldsz - len(k)) * ' '), v, file=outfp) # If we're using the command line interface, we're done. For ttw, we need # to actually send the message to mailman-owner now. if not cgi: print(file=outfp) return # Send the message to the site -owner so someone can do something about # this request. siteowner = Utils.get_site_email(extra='owner') # Should this be sent in the site list's preferred language? msg = Message.UserNotification( siteowner, siteowner, _('Mailing list creation request for list %(listname)s'), sfp.getvalue(), mm_cfg.DEFAULT_SERVER_LANGUAGE) msg.send(mlist)
def notify_owner (self): """Send an email to the owner of the list of successful creation.""" siteowner = Utils.get_site_email(self.ml.host_name, 'owner') text = Utils.maketext( 'newlist.txt', {'listname' : self.ln, 'password' : '', 'admin_url' : self.ml.GetScriptURL('admin', absolute=1), 'listinfo_url': self.ml.GetScriptURL('listinfo', absolute=1), 'requestaddr' : self.ml.GetRequestEmail(), 'siteowner' : siteowner, }, mlist=self.ml) msg = Message.UserNotification( self.owner, siteowner, 'Your new mailing list: %s' % self.ln, text, self.ml.preferred_language) msg.send(self.ml)
def remove(mlist, cgi=False): listname = mlist.internal_name() fieldsz = len(listname) + len('-unsubscribe') if cgi: # If a list is being removed via the CGI, the best we can do is send # an email message to mailman-owner requesting that the appropriate # aliases be deleted. sfp = StringIO() print(_("""\ The mailing list `%(listname)s' has been removed via the through-the-web interface. In order to complete the de-activation of this mailing list, the appropriate /etc/aliases (or equivalent) file must be updated. The program `newaliases' may also have to be run. Here are the entries in the /etc/aliases file that should be removed: """), file=sfp) outfp = sfp else: print( C_(""" To finish removing your mailing list, you must edit your /etc/aliases (or equivalent) file by removing the following lines, and possibly running the `newaliases' program: ## %(listname)s mailing list""")) outfp = sys.stdout # Common path for k, v in makealiases(listname): print(k + ':', ((fieldsz - len(k)) * ' '), v, file=outfp) # If we're using the command line interface, we're done. For ttw, we need # to actually send the message to mailman-owner now. if not cgi: print(file=outfp) return siteowner = Utils.get_site_email(extra='owner') # Should this be sent in the site list's preferred language? msg = Message.UserNotification( siteowner, siteowner, _('Mailing list removal request for list %(listname)s'), sfp.getvalue(), mm_cfg.DEFAULT_SERVER_LANGUAGE) msg['Date'] = email.utils.formatdate(localtime=1) outq = get_switchboard(mm_cfg.OUTQUEUE_DIR) outq.enqueue(msg, recips=[siteowner], nodecorate=1)
def HoldSubscription(self, addr, fullname, password, digest, lang): # Assure that the database is open for writing self.__opendb() # Get the next unique id id = self.__nextid() # Save the information to the request database. for held subscription # entries, each record in the database will be one of the following # format: # # the time the subscription request was received # the subscriber's address # the subscriber's selected password (TBD: is this safe???) # the digest flag # the user's preferred language data = time.time(), addr, fullname, password, digest, lang self.__db[id] = (SUBSCRIPTION, data) # # TBD: this really shouldn't go here but I'm not sure where else is # appropriate. syslog('vette', '%s: held subscription request from %s', self.internal_name(), addr) # Possibly notify the administrator in default list language if self.admin_immed_notify: ## cpanel patch: is the str() handling still needed? i18n.set_language(self.preferred_language) realname = str(self.real_name) subject = _( 'New subscription request to list %(realname)s from %(addr)s') text = Utils.maketext( 'subauth.txt', { 'username': addr, 'listname': self.real_name, 'hostname': self.host_name, 'admindb_url': self.GetScriptURL('admindb', absolute=1), }, mlist=self) # This message should appear to come from the <list>-owner so as # to avoid any useless bounce processing. owneraddr = self.GetOwnerEmail() msg = Message.UserNotification(owneraddr, owneraddr, subject, text, self.preferred_language) msg.send(self, **{'tomoderators': 1}) # Restore the user's preferred language. i18n.set_language(lang)
def SendSubscribeAck(self, name, password, digest, text=''): pluser = self.getMemberLanguage(name) # Need to set this here to get the proper l10n of the Subject: i18n.set_language(pluser) if self.welcome_msg: welcome = Utils.wrap(self.welcome_msg) + '\n' else: welcome = '' if self.umbrella_list: addr = self.GetMemberAdminEmail(name) umbrella = Utils.wrap( _('''\ Note: Since this is a list of mailing lists, administrative notices like the password reminder will be sent to your membership administrative address, %(addr)s.''')) else: umbrella = '' # get the text from the template text += Utils.maketext( 'subscribeack.txt', { 'real_name': self.real_name, 'host_name': self.host_name, 'welcome': welcome, 'umbrella': umbrella, 'emailaddr': self.GetListEmail(), 'listinfo_url': self.GetScriptURL('listinfo', absolute=True), 'optionsurl': self.GetOptionsURL(name, absolute=True), 'password': password, 'user': self.getMemberCPAddress(name), }, lang=pluser, mlist=self) if digest: digmode = _(' (Digest mode)') else: digmode = '' realname = self.real_name msg = Message.UserNotification( self.GetMemberAdminEmail(name), self.GetRequestEmail(), _('Welcome to the "%(realname)s" mailing list%(digmode)s'), text, pluser) msg['X-No-Archive'] = 'yes' msg.send(self, verp=mm_cfg.VERP_PERSONALIZED_DELIVERIES)
def sendProbe(self, member, msg): listname = self.real_name # Put together the substitution dictionary. d = { 'listname': listname, 'address': member, 'optionsurl': self.GetOptionsURL(member, absolute=True), 'owneraddr': self.GetOwnerEmail(), } text = Utils.maketext('probe.txt', d, lang=self.getMemberLanguage(member), mlist=self) # Calculate the VERP'd sender address for bounce processing of the # probe message. token = self.pend_new(Pending.PROBE_BOUNCE, member, msg) probedict = { 'bounces': self.internal_name() + '-bounces', 'token': token, } probeaddr = '%s@%s' % ( (mm_cfg.VERP_PROBE_FORMAT % probedict), self.host_name) # Calculate the Subject header, in the member's preferred language ulang = self.getMemberLanguage(member) otrans = i18n.get_translation() i18n.set_language(ulang) try: subject = _('%(listname)s mailing list probe message') finally: i18n.set_translation(otrans) outer = Message.UserNotification(member, probeaddr, subject, lang=ulang) outer.set_type('multipart/mixed') text = MIMEText(text, _charset=Utils.GetCharSet(ulang)) outer.attach(text) outer.attach(MIMEMessage(msg)) # Turn off further VERP'ing in the final delivery step. We set # probe_token for the OutgoingRunner to more easily handling local # rejects of probe messages. outer.send(self, envsender=probeaddr, verp=False, probe_token=token)
def do_discard(mlist, msg): sender = msg.get_sender() # Do we forward auto-discards to the list owners? if mlist.forward_auto_discards: lang = mlist.preferred_language varhelp = '%s/?VARHELP=privacy/sender/discard_these_nonmembers' % \ mlist.GetScriptURL('admin', absolute=1) nmsg = Message.UserNotification(mlist.GetOwnerEmail(), mlist.GetBouncesEmail(), _('Auto-discard notification'), lang=lang) nmsg.set_type('multipart/mixed') text = MIMEText(Utils.wrap( _('The attached message has been automatically discarded.')), _charset=Utils.GetCharSet(lang)) nmsg.attach(text) nmsg.attach(MIMEMessage(msg)) nmsg.send(mlist) # Discard this sucker raise Errors.DiscardMessage
def BounceMessage(self, msg, msgdata, e=None): # Bounce a message back to the sender, with an error message if # provided in the exception argument. sender = msg.get_sender() subject = msg.get('subject', _('(no subject)')) subject = Utils.oneline(subject, Utils.GetCharSet(self.preferred_language)) if e is None: notice = _('[No bounce details are available]') else: notice = _(e.notice()) # Currently we always craft bounces as MIME messages. bmsg = Message.UserNotification(msg.get_sender(), self.GetOwnerEmail(), subject, lang=self.preferred_language) # BAW: Be sure you set the type before trying to attach, or you'll get # a MultipartConversionError. bmsg.set_type('multipart/mixed') txt = MIMEText(notice, _charset=Utils.GetCharSet(self.preferred_language)) bmsg.attach(txt) bmsg.attach(MIMEMessage(msg)) bmsg.send(self)
def process_request(doc, cgidata): # Lowercase the listname since this is treated as the "internal" name. listname = cgidata.getfirst('listname', '').strip().lower() owner = cgidata.getfirst('owner', '').strip() try: autogen = int(cgidata.getfirst('autogen', '0')) except ValueError: autogen = 0 try: notify = int(cgidata.getfirst('notify', '0')) except ValueError: notify = 0 try: moderate = int(cgidata.getfirst('moderate', mm_cfg.DEFAULT_DEFAULT_MEMBER_MODERATION)) except ValueError: moderate = mm_cfg.DEFAULT_DEFAULT_MEMBER_MODERATION password = cgidata.getfirst('password', '').strip() confirm = cgidata.getfirst('confirm', '').strip() auth = cgidata.getfirst('auth', '').strip() langs = cgidata.getvalue('langs', [mm_cfg.DEFAULT_SERVER_LANGUAGE]) if not isinstance(langs, list): langs = [langs] # Sanity check safelistname = Utils.websafe(listname) if '@' in listname: request_creation(doc, cgidata, _('List name must not include "@": %(safelistname)s')) return if Utils.list_exists(listname): # BAW: should we tell them the list already exists? This could be # used to mine/guess the existance of non-advertised lists. Then # again, that can be done in other ways already, so oh well. request_creation(doc, cgidata, _('List already exists: %(safelistname)s')) return if not listname: request_creation(doc, cgidata, _('You forgot to enter the list name')) return if not owner: request_creation(doc, cgidata, _('You forgot to specify the list owner')) return if autogen: if password or confirm: request_creation( doc, cgidata, _('''Leave the initial password (and confirmation) fields blank if you want Mailman to autogenerate the list passwords.''')) return password = confirm = Utils.MakeRandomPassword( mm_cfg.ADMIN_PASSWORD_LENGTH) else: if password != confirm: request_creation(doc, cgidata, _('Initial list passwords do not match')) return if not password: request_creation( doc, cgidata, # The little <!-- ignore --> tag is used so that this string # differs from the one in bin/newlist. The former is destined # for the web while the latter is destined for email, so they # must be different entries in the message catalog. _('The list password cannot be empty<!-- ignore -->')) return # The authorization password must be non-empty, and it must match either # the list creation password or the site admin password ok = 0 if auth: ok = Utils.check_global_password(auth, 0) if not ok: ok = Utils.check_global_password(auth) if not ok: request_creation( doc, cgidata, _('You are not authorized to create new mailing lists')) return # Make sure the web hostname matches one of our virtual domains hostname = Utils.get_domain() if mm_cfg.VIRTUAL_HOST_OVERVIEW and \ hostname not in mm_cfg.VIRTUAL_HOSTS: safehostname = Utils.websafe(hostname) request_creation(doc, cgidata, _('Unknown virtual host: %(safehostname)s')) return emailhost = mm_cfg.VIRTUAL_HOSTS.get(hostname, mm_cfg.DEFAULT_EMAIL_HOST) # We've got all the data we need, so go ahead and try to create the list # See admin.py for why we need to set up the signal handler. mlist = MailList.MailList() def sigterm_handler(signum, frame, mlist=mlist): # Make sure the list gets unlocked... mlist.Unlock() # ...and ensure we exit, otherwise race conditions could cause us to # enter MailList.Save() while we're in the unlocked state, and that # could be bad! sys.exit(0) try: # Install the emergency shutdown signal handler signal.signal(signal.SIGTERM, sigterm_handler) pw = sha_new(password.encode()).hexdigest() # Guarantee that all newly created files have the proper permission. # proper group ownership should be assured by the autoconf script # enforcing that all directories have the group sticky bit set oldmask = os.umask(0o02) try: try: mlist.Create(listname, owner, pw, langs, emailhost, urlhost=hostname) finally: os.umask(oldmask) except Errors.EmailAddressError as e: if e.args: s = Utils.websafe(e.args[0]) else: s = Utils.websafe(owner) request_creation(doc, cgidata, _('Bad owner email address: %(s)s')) return except Errors.MMListAlreadyExistsError: # MAS: List already exists so we don't need to websafe it. request_creation(doc, cgidata, _('List already exists: %(listname)s')) return except Errors.BadListNameError as e: if e.args: s = Utils.websafe(e.args[0]) else: s = Utils.websafe(listname) request_creation(doc, cgidata, _('Illegal list name: %(s)s')) return except Errors.MMListError: request_creation( doc, cgidata, _('''Some unknown error occurred while creating the list. Please contact the site administrator for assistance.''')) return # Initialize the host_name and web_page_url attributes, based on # virtual hosting settings and the request environment variables. mlist.default_member_moderation = moderate mlist.web_page_url = mm_cfg.DEFAULT_URL_PATTERN % hostname mlist.host_name = emailhost mlist.Save() finally: # Now be sure to unlock the list. It's okay if we get a signal here # because essentially, the signal handler will do the same thing. And # unlocking is unconditional, so it's not an error if we unlock while # we're already unlocked. mlist.Unlock() # Now do the MTA-specific list creation tasks if mm_cfg.MTA: modname = 'Mailman.MTA.' + mm_cfg.MTA __import__(modname) sys.modules[modname].create(mlist, cgi=1) # And send the notice to the list owner. if notify: siteowner = Utils.get_site_email(mlist.host_name, 'owner') text = Utils.maketext( 'newlist.txt', {'listname' : listname, 'password' : password, 'admin_url' : mlist.GetScriptURL('admin', absolute=1), 'listinfo_url': mlist.GetScriptURL('listinfo', absolute=1), 'requestaddr' : mlist.GetRequestEmail(), 'siteowner' : siteowner, }, mlist=mlist) msg = Message.UserNotification( owner, siteowner, _('Your new mailing list: %(listname)s'), text, mlist.preferred_language) msg.send(mlist) # Success! listinfo_url = mlist.GetScriptURL('listinfo', absolute=1) admin_url = mlist.GetScriptURL('admin', absolute=1) create_url = Utils.ScriptURL('create') title = _('Mailing list creation results') doc.SetTitle(title) table = Table(border=0, width='100%') table.AddRow([Center(Bold(FontAttr(title, size='+1')))]) table.AddCellInfo(table.GetCurrentRowIndex(), 0, bgcolor=mm_cfg.WEB_HEADER_COLOR) table.AddRow([_('''You have successfully created the mailing list <b>%(listname)s</b> and notification has been sent to the list owner <b>%(owner)s</b>. You can now:''')]) ullist = UnorderedList() ullist.AddItem(Link(listinfo_url, _("Visit the list's info page"))) ullist.AddItem(Link(admin_url, _("Visit the list's admin page"))) ullist.AddItem(Link(create_url, _('Create another list'))) table.AddRow([ullist]) doc.AddItem(table)
def send_response(self): # Helper def indent(lines): return [' ' + line for line in lines] # Quick exit for some commands which don't need a response if not self.respond: return resp = [ Utils.wrap( _("""\ The results of your email command are provided below. Attached is your original message. """)) ] if self.results: resp.append(_('- Results:')) resp.extend(indent(self.results)) # Ignore empty lines unprocessed = [ line for line in self.commands[self.lineno:] if line and line.strip() ] if unprocessed and mm_cfg.RESPONSE_INCLUDE_LEVEL >= 2: resp.append(_('\n- Unprocessed:')) resp.extend(indent(unprocessed)) if not unprocessed and not self.results: # The user sent an empty message; return a helpful one. resp.append( Utils.wrap( _("""\ No commands were found in this message. To obtain instructions, send a message containing just the word "help". """))) if self.ignored and mm_cfg.RESPONSE_INCLUDE_LEVEL >= 2: resp.append(_('\n- Ignored:')) resp.extend(indent(self.ignored)) resp.append(_('\n- Done.\n\n')) # Encode any unicode strings into the list charset, so we don't try to # join unicode strings and invalid ASCII. charset = Utils.GetCharSet(self.msgdata['lang']) encoded_resp = [] for item in resp: if isinstance(item, UnicodeType): item = item.encode(charset, 'replace') encoded_resp.append(item) results = MIMEText(NL.join(encoded_resp), _charset=charset) # Safety valve for mail loops with misconfigured email 'bots. We # don't respond to commands sent with "Precedence: bulk|junk|list" # unless they explicitly "X-Ack: yes", but not all mail 'bots are # correctly configured, so we max out the number of responses we'll # give to an address in a single day. # # BAW: We wait until now to make this decision since our sender may # not be self.msg.get_sender(), but I'm not sure this is right. recip = self.returnaddr or self.msg.get_sender() if not self.mlist.autorespondToSender(recip, self.msgdata['lang']): return msg = Message.UserNotification(recip, self.mlist.GetOwnerEmail(), _('The results of your email commands'), lang=self.msgdata['lang']) msg.set_type('multipart/mixed') msg.attach(results) if mm_cfg.RESPONSE_INCLUDE_LEVEL == 1: self.msg.set_payload( _('Message body suppressed by Mailman site configuration\n')) if mm_cfg.RESPONSE_INCLUDE_LEVEL == 0: orig = MIMEText(_( 'Original message suppressed by Mailman site configuration\n'), _charset=charset) else: orig = MIMEMessage(self.msg) msg.attach(orig) msg.send(self.mlist)
def sendNextNotification(self, member): info = self.getBounceInfo(member) if info is None: return reason = self.getDeliveryStatus(member) if info.noticesleft <= 0: # BAW: Remove them now, with a notification message self.ApprovedDeleteMember( member, 'disabled address', admin_notif=self.bounce_notify_owner_on_removal, userack=1) # Expunge the pending cookie for the user. We throw away the # returned data. self.pend_confirm(info.cookie) if reason == MemberAdaptor.BYBOUNCE: syslog('bounce', '%s: %s deleted after exhausting notices', self.internal_name(), member) syslog( 'subscribe', '%s: %s auto-unsubscribed [reason: %s]', self.internal_name(), member, { MemberAdaptor.BYBOUNCE: 'BYBOUNCE', MemberAdaptor.BYUSER: '******', MemberAdaptor.BYADMIN: 'BYADMIN', MemberAdaptor.UNKNOWN: 'UNKNOWN' }.get(reason, 'invalid value')) return # Send the next notification confirmurl = '%s/%s' % (self.GetScriptURL('confirm', absolute=1), info.cookie) optionsurl = self.GetOptionsURL(member, absolute=1) reqaddr = self.GetRequestEmail() lang = self.getMemberLanguage(member) txtreason = REASONS.get(reason) if txtreason is None: txtreason = _('for unknown reasons') else: txtreason = _(txtreason) # Give a little bit more detail on bounce disables if reason == MemberAdaptor.BYBOUNCE: date = time.strftime('%d-%b-%Y', time.localtime(Utils.midnight(info.date))) extra = _(' The last bounce received from you was dated %(date)s') txtreason += extra text = Utils.maketext('disabled.txt', { 'listname': self.real_name, 'noticesleft': info.noticesleft, 'confirmurl': confirmurl, 'optionsurl': optionsurl, 'password': self.getMemberPassword(member), 'owneraddr': self.GetOwnerEmail(), 'reason': txtreason, }, lang=lang, mlist=self) msg = Message.UserNotification(member, reqaddr, text=text, lang=lang) # BAW: See the comment in MailList.py ChangeMemberAddress() for why we # set the Subject this way. del msg['subject'] msg['Subject'] = 'confirm ' + info.cookie # Send without Precedence: bulk. Bug #808821. msg.send(self, noprecedence=True) info.noticesleft -= 1 info.lastnotice = time.localtime()[:3] # In case the MemberAdaptor stores bounce info externally to # the list, we need to tell it to update self.setBounceInfo(member, info)
def hold_for_approval(mlist, msg, msgdata, exc): # BAW: This should really be tied into the email confirmation system so # that the message can be approved or denied via email as well as the # web. # # XXX We use the weird type(type) construct below because in Python 2.1, # type is a function not a type and so can't be used as the second # argument in isinstance(). However, in Python 2.5, exceptions are # new-style classes and so are not of ClassType. # FIXME pzv if isinstance(exc, type) or isinstance(exc, type(type)): # Go ahead and instantiate it now. exc = exc() listname = mlist.real_name sender = msgdata.get('sender', msg.get_sender()) usersubject = msg.get('subject') charset = Utils.GetCharSet(mlist.preferred_language) if usersubject: usersubject = Utils.oneline(usersubject, charset) else: usersubject = _('(no subject)') message_id = msg.get('message-id', 'n/a') owneraddr = mlist.GetOwnerEmail() adminaddr = mlist.GetBouncesEmail() requestaddr = mlist.GetRequestEmail() # We need to send both the reason and the rejection notice through the # translator again, because of the games we play above reason = Utils.wrap(exc.reason_notice()) if isinstance(exc, NonMemberPost) and mlist.nonmember_rejection_notice: msgdata['rejection_notice'] = Utils.wrap( mlist.nonmember_rejection_notice.replace('%(listowner)s', owneraddr)) else: msgdata['rejection_notice'] = Utils.wrap(exc.rejection_notice(mlist)) id = mlist.HoldMessage(msg, reason, msgdata) # Now we need to craft and send a message to the list admin so they can # deal with the held message. d = { 'listname': listname, 'hostname': mlist.host_name, 'reason': _(reason), 'sender': sender, 'subject': usersubject, 'admindb_url': mlist.GetScriptURL('admindb', absolute=1), } # We may want to send a notification to the original sender too fromusenet = msgdata.get('fromusenet') # Since we're sending two messages, which may potentially be in different # languages (the user's preferred and the list's preferred for the admin), # we need to play some i18n games here. Since the current language # context ought to be set up for the user, let's craft his message first. cookie = mlist.pend_new(Pending.HELD_MESSAGE, id) if not fromusenet and ackp(msg) and mlist.respond_to_post_requests and \ mlist.autorespondToSender(sender, mlist.getMemberLanguage(sender)): # Get a confirmation cookie d['confirmurl'] = '%s/%s' % (mlist.GetScriptURL('confirm', absolute=1), cookie) lang = msgdata.get('lang', mlist.getMemberLanguage(sender)) subject = _('Your message to %(listname)s awaits moderator approval') text = Utils.maketext('postheld.txt', d, lang=lang, mlist=mlist) nmsg = Message.UserNotification(sender, owneraddr, subject, text, lang) nmsg.send(mlist) # Now the message for the list owners. Be sure to include the list # moderators in this message. This one should appear to come from # <list>-owner since we really don't need to do bounce processing on it. if mlist.admin_immed_notify: # Now let's temporarily set the language context to that which the # admin is expecting. otranslation = i18n.get_translation() i18n.set_language(mlist.preferred_language) try: lang = mlist.preferred_language charset = Utils.GetCharSet(lang) # We need to regenerate or re-translate a few values in d d['reason'] = _(reason) d['subject'] = usersubject # craft the admin notification message and deliver it subject = _('%(listname)s post from %(sender)s requires approval') nmsg = Message.UserNotification(owneraddr, owneraddr, subject, lang=lang) nmsg.set_type('multipart/mixed') text = MIMEText(Utils.maketext('postauth.txt', d, raw=1, mlist=mlist), _charset=charset) dmsg = MIMEText(Utils.wrap( _("""\ If you reply to this message, keeping the Subject: header intact, Mailman will discard the held message. Do this if the message is spam. If you reply to this message and include an Approved: header with the list password in it, the message will be approved for posting to the list. The Approved: header can also appear in the first line of the body of the reply.""")), _charset=Utils.GetCharSet(lang)) dmsg['Subject'] = 'confirm ' + cookie dmsg['Sender'] = requestaddr dmsg['From'] = requestaddr dmsg['Date'] = email.utils.formatdate(localtime=True) dmsg['Message-ID'] = Utils.unique_message_id(mlist) nmsg.attach(text) nmsg.attach(message.MIMEMessage(msg)) nmsg.attach(message.MIMEMessage(dmsg)) nmsg.send(mlist, **{'tomoderators': 1}) finally: i18n.set_translation(otranslation) # Log the held message syslog('vette', '%s post from %s held, message-id=%s: %s', listname, sender, message_id, reason) # raise the specific MessageHeld exception to exit out of the message # delivery pipeline raise exc
# And send the notice to the list owner. if notify: siteowner = Utils.get_site_email(mlist.host_name, 'owner') text = Utils.maketext( 'newlist.txt', { 'listname': listname, 'password': password, 'admin_url': mlist.GetScriptURL('admin', absolute=1), 'listinfo_url': mlist.GetScriptURL('listinfo', absolute=1), 'requestaddr': mlist.GetRequestEmail(), 'siteowner': siteowner, }, mlist=mlist) msg = Message.UserNotification( owner, siteowner, _('Your new mailing list: %(listname)s'), text, mlist.preferred_language) msg.send(mlist) # Success! listinfo_url = mlist.GetScriptURL('listinfo', absolute=1) admin_url = mlist.GetScriptURL('admin', absolute=1) create_url = Utils.ScriptURL('create') title = _('Mailing list creation results') doc.SetTitle(title) table = Table(border=0, width='100%') table.AddRow([Center(Bold(FontAttr(title, size='+1')))]) table.AddCellInfo(table.GetCurrentRowIndex(), 0, bgcolor=mm_cfg.WEB_HEADER_COLOR)
# encoded in their language. Otherwise it'll be the preferred # language of the mailing list. lang = self.getMemberLanguage(addr) else: # Throw away the realnames addr = [a for realname, a in addrs] # Which member language do we attempt to use? We could use # the first match or the first address, but in the face of # ambiguity, let's just use the list's preferred language lang = self.preferred_language otrans = i18n.get_translation() i18n.set_language(lang) try: fmsg = Message.UserNotification( addr, self.GetBouncesEmail(), _('Forward of moderated message'), lang=lang) finally: i18n.set_translation(otrans) fmsg.set_type('message/rfc822') fmsg.attach(copy) fmsg.send(self) # Log the rejection if rejection: note = '''%(listname)s: %(rejection)s posting: tFrom: %(sender)s tSubject: %(subject)s''' % { 'listname': self.internal_name(), 'rejection': rejection, 'sender': str(sender).replace('%', '%%'),
def __handlepost(self, record, value, comment, preserve, forward, addr): # For backwards compatibility with pre 2.0beta3 ptime, sender, subject, reason, filename, msgdata = record path = os.path.join(mm_cfg.DATA_DIR, filename) # Handle message preservation if preserve: parts = os.path.split(path)[1].split(DASH) parts[0] = 'spam' spamfile = DASH.join(parts) # Preserve the message as plain text, not as a pickle try: fp = open(path) except IOError as e: if e.errno != errno.ENOENT: raise return LOST try: if path.endswith('.pck'): msg = pickle.load(fp) else: assert path.endswith('.txt'), '%s not .pck or .txt' % path msg = fp.read() finally: fp.close() # Save the plain text to a .msg file, not a .pck file outpath = os.path.join(mm_cfg.SPAM_DIR, spamfile) head, ext = os.path.splitext(outpath) outpath = head + '.msg' outfp = open(outpath, 'wb') try: if path.endswith('.pck'): g = Generator(outfp) g.flatten(msg, 1) else: outfp.write(msg) finally: outfp.close() # Now handle updates to the database rejection = None fp = None msg = None status = REMOVE if value == mm_cfg.DEFER: # Defer status = DEFER elif value == mm_cfg.APPROVE: # Approved. try: msg = readMessage(path) except IOError as e: if e.errno != errno.ENOENT: raise return LOST msg = readMessage(path) msgdata['approved'] = 1 # adminapproved is used by the Emergency handler msgdata['adminapproved'] = 1 # Calculate a new filebase for the approved message, otherwise # delivery errors will cause duplicates. try: del msgdata['filebase'] except KeyError: pass # Queue the file for delivery by qrunner. Trying to deliver the # message directly here can lead to a huge delay in web # turnaround. Log the moderation and add a header. msg['X-Mailman-Approved-At'] = email.utils.formatdate(localtime=1) syslog('vette', '%s: held message approved, message-id: %s', self.internal_name(), msg.get('message-id', 'n/a')) # Stick the message back in the incoming queue for further # processing. inq = get_switchboard(mm_cfg.INQUEUE_DIR) inq.enqueue(msg, _metadata=msgdata) elif value == mm_cfg.REJECT: # Rejected rejection = 'Refused' lang = self.getMemberLanguage(sender) subject = Utils.oneline(subject, Utils.GetCharSet(lang)) self.__refuse(_('Posting of your message titled "%(subject)s"'), sender, comment or _('[No reason given]'), lang=lang) else: assert value == mm_cfg.DISCARD # Discarded rejection = 'Discarded' # Forward the message if forward and addr: # If we've approved the message, we need to be sure to craft a # completely unique second message for the forwarding operation, # since we don't want to share any state or information with the # normal delivery. try: copy = readMessage(path) except IOError as e: if e.errno != errno.ENOENT: raise raise Errors.LostHeldMessage(path) # It's possible the addr is a comma separated list of addresses. addrs = getaddresses([addr]) if len(addrs) == 1: realname, addr = addrs[0] # If the address getting the forwarded message is a member of # the list, we want the headers of the outer message to be # encoded in their language. Otherwise it'll be the preferred # language of the mailing list. lang = self.getMemberLanguage(addr) else: # Throw away the realnames addr = [a for realname, a in addrs] # Which member language do we attempt to use? We could use # the first match or the first address, but in the face of # ambiguity, let's just use the list's preferred language lang = self.preferred_language otrans = i18n.get_translation() i18n.set_language(lang) try: fmsg = Message.UserNotification( addr, self.GetBouncesEmail(), _('Forward of moderated message'), lang=lang) finally: i18n.set_translation(otrans) fmsg.set_type('message/rfc822') fmsg.attach(copy) fmsg.send(self) # Log the rejection if rejection: note = '''%(listname)s: %(rejection)s posting: tFrom: %(sender)s tSubject: %(subject)s''' % { 'listname': self.internal_name(), 'rejection': rejection, 'sender': str(sender).replace('%', '%%'), 'subject': str(subject).replace('%', '%%'), } if comment: note += '\n\tReason: ' + comment.replace('%', '%%') syslog('vette', note) # Always unlink the file containing the message text. It's not # necessary anymore, regardless of the disposition of the message. if status != DEFER: try: os.unlink(path) except OSError as e: if e.errno != errno.ENOENT: raise # We lost the message text file. Clean up our housekeeping # and inform of this status. return LOST return status
def process_form(mlist, doc, cgidata, lang): listowner = mlist.GetOwnerEmail() realname = mlist.real_name results = [] # The email address being subscribed, required email = cgidata.getfirst('email', '').strip() if not email: results.append(_('You must supply a valid email address.')) fullname = cgidata.getfirst('fullname', '') # Canonicalize the full name fullname = Utils.canonstr(fullname, lang) # Who was doing the subscribing? remote = os.environ.get( 'HTTP_FORWARDED_FOR', os.environ.get('HTTP_X_FORWARDED_FOR', os.environ.get('REMOTE_ADDR', 'unidentified origin'))) # Check reCAPTCHA submission, if enabled if mm_cfg.RECAPTCHA_SECRET_KEY: request = urllib.request.Request( url='https://www.google.com/recaptcha/api/siteverify', data=urllib.parse.urlencode({ 'secret': mm_cfg.RECAPTCHA_SECRET_KEY, 'response': cgidata.getvalue('g-recaptcha-response', ''), 'remoteip': remote })) try: httpresp = urllib.request.urlopen(request) captcha_response = json.load(httpresp) httpresp.close() if not captcha_response['success']: e_codes = COMMASPACE.join(captcha_response['error-codes']) results.append(_('reCAPTCHA validation failed: %(e_codes)s')) except urllib.error.URLError as e: e_reason = e.reason results.append(_('reCAPTCHA could not be validated: %(e_reason)s')) # Are we checking the hidden data? if mm_cfg.SUBSCRIBE_FORM_SECRET: now = int(time.time()) # Try to accept a range in case of load balancers, etc. (LP: #1447445) if remote.find('.') >= 0: # ipv4 - drop last octet remote1 = remote.rsplit('.', 1)[0] else: # ipv6 - drop last 16 (could end with :: in which case we just # drop one : resulting in an invalid format, but it's only # for our hash so it doesn't matter. remote1 = remote.rsplit(':', 1)[0] try: ftime, fhash = cgidata.getfirst('sub_form_token', '').split(':') then = int(ftime) except ValueError: ftime = fhash = '' then = 0 token = Utils.sha_new( (mm_cfg.SUBSCRIBE_FORM_SECRET + ":" + ftime + ":" + mlist.internal_name() + ":" + remote1).encode()).hexdigest() if ftime and now - then > mm_cfg.FORM_LIFETIME: results.append(_('The form is too old. Please GET it again.')) if ftime and now - then < mm_cfg.SUBSCRIBE_FORM_MIN_TIME: results.append( _('Please take a few seconds to fill out the form before submitting it.' )) if ftime and token != fhash: results.append( _("The hidden token didn't match. Did your IP change?")) if not ftime: results.append( _('There was no hidden token in your submission or it was corrupted.' )) results.append(_('You must GET the form before submitting it.')) # Was an attempt made to subscribe the list to itself? if email == mlist.GetListEmail(): syslog('mischief', 'Attempt to self subscribe %s: %s', email, remote) results.append(_('You may not subscribe a list to itself!')) # If the user did not supply a password, generate one for him password = cgidata.getfirst('pw', '').strip() confirmed = cgidata.getfirst('pw-conf', '').strip() if not password and not confirmed: password = Utils.MakeRandomPassword() elif not password or not confirmed: results.append(_('If you supply a password, you must confirm it.')) elif password != confirmed: results.append(_('Your passwords did not match.')) # Get the digest option for the subscription. digestflag = cgidata.getfirst('digest') if digestflag: try: digest = int(digestflag) except (TypeError, ValueError): digest = 0 else: digest = mlist.digest_is_default # Sanity check based on list configuration. BAW: It's actually bogus that # the page allows you to set the digest flag if you don't really get the # choice. :/ if not mlist.digestable: digest = 0 elif not mlist.nondigestable: digest = 1 if results: print_results(mlist, ERRORSEP.join(results), doc, lang) return # If this list has private rosters, we have to be careful about the # message that gets printed, otherwise the subscription process can be # used to mine for list members. It may be inefficient, but it's still # possible, and that kind of defeats the purpose of private rosters. # We'll use this string for all successful or unsuccessful subscription # results. if mlist.private_roster == 0: # Public rosters privacy_results = '' else: privacy_results = _("""\ Your subscription request has been received, and will soon be acted upon. Depending on the configuration of this mailing list, your subscription request may have to be first confirmed by you via email, or approved by the list moderator. If confirmation is required, you will soon get a confirmation email which contains further instructions.""") try: userdesc = UserDesc(email, fullname, password, digest, lang) mlist.AddMember(userdesc, remote) results = '' # Check for all the errors that mlist.AddMember can throw options on the # web page for this cgi except Errors.MembershipIsBanned: results = _("""The email address you supplied is banned from this mailing list. If you think this restriction is erroneous, please contact the list owners at %(listowner)s.""") except Errors.MMBadEmailError: results = _("""\ The email address you supplied is not valid. (E.g. it must contain an `@'.)""") except Errors.MMHostileAddress: results = _("""\ Your subscription is not allowed because the email address you gave is insecure.""") except Errors.MMSubscribeNeedsConfirmation: # Results string depends on whether we have private rosters or not if privacy_results: results = privacy_results else: results = _("""\ Confirmation from your email address is required, to prevent anyone from subscribing you without permission. Instructions are being sent to you at %(email)s. Please note your subscription will not start until you confirm your subscription.""") except Errors.MMNeedApproval as x: # Results string depends on whether we have private rosters or not if privacy_results: results = privacy_results else: # We need to interpolate into x.__str__() x = _(str(x)) results = _("""\ Your subscription request was deferred because %(x)s. Your request has been forwarded to the list moderator. You will receive email informing you of the moderator's decision when they get to your request.""") except Errors.MMAlreadyAMember: # Results string depends on whether we have private rosters or not if not privacy_results: results = _('You are already subscribed.') else: results = privacy_results # This could be a membership probe. For safety, let the user know # a probe occurred. BAW: should we inform the list moderator? listaddr = mlist.GetListEmail() # Set the language for this email message to the member's language. mlang = mlist.getMemberLanguage(email) otrans = i18n.get_translation() i18n.set_language(mlang) try: msg = Message.UserNotification(mlist.getMemberCPAddress(email), mlist.GetBouncesEmail(), _('Mailman privacy alert'), _("""\ An attempt was made to subscribe your address to the mailing list %(listaddr)s. You are already subscribed to this mailing list. Note that the list membership is not public, so it is possible that a bad person was trying to probe the list for its membership. This would be a privacy violation if we let them do this, but we didn't. If you submitted the subscription request and forgot that you were already subscribed to the list, then you can ignore this message. If you suspect that an attempt is being made to covertly discover whether you are a member of this list, and you are worried about your privacy, then feel free to send a message to the list administrator at %(listowner)s. """), lang=mlang) finally: i18n.set_translation(otrans) msg.send(mlist) # These shouldn't happen unless someone's tampering with the form except Errors.MMCantDigestError: results = _('This list does not support digest delivery.') except Errors.MMMustDigestError: results = _('This list only supports digest delivery.') else: # Everything's cool. Our return string actually depends on whether # this list has private rosters or not if privacy_results: results = privacy_results else: results = _("""\ You have been successfully subscribed to the %(realname)s mailing list.""") # Show the results print_results(mlist, results, doc, lang)
# a probe occurred. BAW: should we inform the list moderator? listaddr = mlist.GetListEmail() # Set the language for this email message to the member's language. mlang = mlist.getMemberLanguage(email) otrans = i18n.get_translation() i18n.set_language(mlang) try: msg = Message.UserNotification( mlist.getMemberCPAddress(email), mlist.GetBouncesEmail(), _('Mailman privacy alert'), _("""\ An attempt was made to subscribe your address to the mailing list %(listaddr)s. You are already subscribed to this mailing list. Note that the list membership is not public, so it is possible that a bad person was trying to probe the list for its membership. This would be a privacy violation if we let them do this, but we didn't. If you submitted the subscription request and forgot that you were already subscribed to the list, then you can ignore this message. If you suspect that an attempt is being made to covertly discover whether you are a member of this list, and you are worried about your privacy, then feel free to send a message to the list administrator at %(listowner)s. """), lang=mlang) finally: i18n.set_translation(otrans) msg.send(mlist) # These shouldn't happen unless someone's tampering with the form except Errors.MMCantDigestError: results = _('This list does not support digest delivery.') except Errors.MMMustDigestError:
def process(mlist, msg, msgdata): # Normally, the replybot should get a shot at this message, but there are # some important short-circuits, mostly to suppress 'bot storms, at least # for well behaved email bots (there are other governors for misbehaving # 'bots). First, if the original message has an "X-Ack: No" header, we # skip the replybot. Then, if the message has a Precedence header with # values bulk, junk, or list, and there's no explicit "X-Ack: yes" header, # we short-circuit. Finally, if the message metadata has a true 'noack' # key, then we skip the replybot too. ack = msg.get('x-ack', '').lower() if ack == 'no' or msgdata.get('noack'): return precedence = msg.get('precedence', '').lower() if ack <> 'yes' and precedence in ('bulk', 'junk', 'list'): return # Check to see if the list is even configured to autorespond to this email # message. Note: the owner script sets the `toowner' key, and the various # confirm, join, leave, request, subscribe and unsubscribe scripts set the # keys we use for `torequest'. toadmin = msgdata.get('toowner') torequest = msgdata.get('torequest') or msgdata.get('toconfirm') or \ msgdata.get('tojoin') or msgdata.get('toleave') if ((toadmin and not mlist.autorespond_admin) or (torequest and not mlist.autorespond_requests) or \ (not toadmin and not torequest and not mlist.autorespond_postings)): return # Now see if we're in the grace period for this sender. graceperiod <= 0 # means always autorespond, as does an "X-Ack: yes" header (useful for # debugging). sender = msg.get_sender() now = time.time() graceperiod = mlist.autoresponse_graceperiod if graceperiod > 0 and ack <> 'yes': if toadmin: quiet_until = mlist.admin_responses.get(sender, 0) elif torequest: quiet_until = mlist.request_responses.get(sender, 0) else: quiet_until = mlist.postings_responses.get(sender, 0) if quiet_until > now: return # # Okay, we know we're going to auto-respond to this sender, craft the # message, send it, and update the database. realname = mlist.real_name subject = _( 'Auto-response for your message to the "%(realname)s" mailing list') # Do string interpolation d = SafeDict({'listname' : realname, 'listurl' : mlist.GetScriptURL('listinfo'), 'requestemail': mlist.GetRequestEmail(), # BAW: Deprecate adminemail; it's not advertised but still # supported for backwards compatibility. 'adminemail' : mlist.GetBouncesEmail(), 'owneremail' : mlist.GetOwnerEmail(), }) # Just because we're using a SafeDict doesn't mean we can't get all sorts # of other exceptions from the string interpolation. Let's be ultra # conservative here. if toadmin: rtext = mlist.autoresponse_admin_text elif torequest: rtext = mlist.autoresponse_request_text else: rtext = mlist.autoresponse_postings_text # Using $-strings? if getattr(mlist, 'use_dollar_strings', 0): rtext = Utils.to_percent(rtext) try: text = rtext % d except Exception: syslog('error', 'Bad autoreply text for list: %s\n%s', mlist.internal_name(), rtext) text = rtext # Wrap the response. text = Utils.wrap(text) outmsg = Message.UserNotification(sender, mlist.GetBouncesEmail(), subject, text, mlist.preferred_language) outmsg['X-Mailer'] = _('The Mailman Replybot') # prevent recursions and mail loops! outmsg['X-Ack'] = 'No' outmsg.send(mlist) # update the grace period database if graceperiod > 0: # graceperiod is in days, we need # of seconds quiet_until = now + graceperiod * 24 * 60 * 60 if toadmin: mlist.admin_responses[sender] = quiet_until elif torequest: mlist.request_responses[sender] = quiet_until else: mlist.postings_responses[sender] = quiet_until