def create_message(self, subject, txtMessage, htmlMessage, origMesg):
container = MIMEMultipart('mixed')
container['Subject'] = str(Header(subject, UTF8))
# --=mpj17=-- Similar to the call in MessageSender, but we
# always want the default.
container['From'] = self.from_header_from_address(None)
container['To'] = self.to_header_from_addresses(None)
messageTextContainer = MIMEMultipart('alternative')
container.attach(messageTextContainer)
txt = MIMEText(txtMessage.encode(UTF8), 'plain', UTF8)
messageTextContainer.attach(txt)
html = MIMEText(htmlMessage.encode(UTF8), 'html', UTF8)
messageTextContainer.attach(html)
msg = message_from_string(origMesg)
m = MIMEMessage(msg)
m['Content-Description'] = 'Returned Message: %s' % \
msg['Subject']
m['Content-Disposition'] = 'inline'
m.set_param('name', 'Returned message')
del m['MIME-Version']
container.attach(m)
retval = container.as_string()
assert retval
return retval
def create_message(self, subject, txtMessage, htmlMessage, origMesg):
container = MIMEMultipart('mixed')
container['Subject'] = str(Header(subject, UTF8))
# --=mpj17=-- Similar to the call in MessageSender, but we
# always want the default.
container['From'] = self.from_header_from_address(None)
container['To'] = self.to_header_from_addresses(None)
messageTextContainer = MIMEMultipart('alternative')
container.attach(messageTextContainer)
txt = MIMEText(txtMessage.encode(UTF8), 'plain', UTF8)
messageTextContainer.attach(txt)
html = MIMEText(htmlMessage.encode(UTF8), 'html', UTF8)
messageTextContainer.attach(html)
msg = message_from_string(origMesg)
m = MIMEMessage(msg)
m['Content-Description'] = 'Returned Message: %s' % \
msg['Subject']
m['Content-Disposition'] = 'inline'
m.set_param('name', 'Returned message')
del m['MIME-Version']
container.attach(m)
retval = container.as_string()
assert retval
return retval
def create_return_message(msg):
retval = MIMEMessage(msg)
s = msg.get('Subject', 'No subject').decode('ascii', 'ignore')
retval['Content-Description'] = 'Returned message: {0}'.format(s)
retval['Content-Disposition'] = 'inline'
retval.set_param('name', 'Returned message')
del retval['MIME-Version']
return retval
def test_valid_argument(self):
eq = self.assertEqual
subject = 'A sub-message'
m = Message()
m['Subject'] = subject
r = MIMEMessage(m)
eq(r.get_type(), 'message/rfc822')
self.failUnless(r.get_payload() is m)
eq(r.get_payload()['subject'], subject)
def test_valid_argument(self):
eq = self.assertEqual
subject = 'A sub-message'
m = Message()
m['Subject'] = subject
r = MIMEMessage(m)
eq(r.get_type(), 'message/rfc822')
self.failUnless(r.get_payload() is m)
eq(r.get_payload()['subject'], subject)
def _send_mail(self, msg_to, msg_subject, msg_body):
mailhost = self._get_mailhost()
from email.MIMEText import MIMEText
from email.MIMEMessage import MIMEMessage
msg = MIMEMessage(MIMEText(msg_body.encode('utf-8'), _charset='utf-8'))
msg['Subject'] = msg_subject
msg['From'] = self.noreply_mail_address
msg['To'] = msg_to
mailhost.send(msg.as_string())
def copy_email(msg, to, toUser=False, originalBcc=None):
'''
Send a copy of the given email message to the given recipient.
'''
add_headers(msg)
new = MIMEMultipart()
# get info for first part.
# Mode: if it's production, then "copy of a message", otherwise
# "this is a message that would have been sent from"
# hostname?
# django settings if debugging?
# Should this be a template?
if settings.SERVER_MODE == 'production':
explanation = "This is a copy of a message sent from the I-D tracker."
elif settings.SERVER_MODE == 'test' and toUser:
explanation = "The attached message was generated by an instance of the tracker\nin test mode. It is being sent to you because you, or someone acting\non your behalf, is testing the system. If you do not recognize\nthis action, please accept our apologies and do not be concerned as\nthe action is being taken in a test context."
else:
explanation = "The attached message would have been sent, but the tracker is in %s mode.\nIt was not sent to anybody." % settings.SERVER_MODE
if originalBcc:
explanation += (
"\nIn addition to the destinations derived from the header below, the message would have been sent Bcc to %s"
% originalBcc)
new.attach(MIMEText(explanation + "\n\n"))
new.attach(MIMEMessage(msg))
# Overwrite the From: header, so that the copy from a development or
# test server doesn't look like spam.
new['From'] = settings.DEFAULT_FROM_EMAIL
new['Subject'] = '[Django %s] %s' % (settings.SERVER_MODE,
msg.get('Subject', '[no subject]'))
new['To'] = to
send_smtp(new)
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 send_process_error_notification(to_address,
subject,
error_msg,
original_msg,
failing_command=None,
max_return_size=MAX_RETURN_MESSAGE_SIZE):
"""Send a mail about an error occurring while using the email interface.
Tells the user that an error was encountered while processing his
request and attaches the original email which caused the error to
happen. The original message will be truncated to
max_return_size bytes.
:to_address: The address to send the notification to.
:subject: The subject of the notification.
:error_msg: The error message that explains the error.
:original_msg: The original message sent by the user.
:failing_command: The command that caused the error to happen.
:max_return_size: The maximum size returned for the original message.
"""
if isinstance(failing_command, list):
failing_commands = failing_command
elif failing_command is None:
failing_commands = []
else:
failing_commands = [failing_command]
failed_commands_information = ''
if len(failing_commands) > 0:
failed_commands_information = 'Failing command:'
for failing_command in failing_commands:
failed_commands_information += '\n %s' % str(failing_command)
body = get_email_template(
'email-processing-error.txt', app='services/mail') % {
'failed_command_information': failed_commands_information,
'error_msg': error_msg
}
mailwrapper = MailWrapper(width=72)
body = mailwrapper.format(body)
error_part = MIMEText(body.encode('utf-8'), 'plain', 'utf-8')
msg = MIMEMultipart()
msg['To'] = to_address
msg['From'] = get_bugmail_error_address()
msg['Subject'] = subject
msg.attach(error_part)
original_msg_str = str(original_msg)
if len(original_msg_str) > max_return_size:
truncated_msg_str = original_msg_str[:max_return_size]
original_msg = message_from_string(truncated_msg_str)
msg.attach(MIMEMessage(original_msg))
sendmail(msg)
def ForwardMessage(self, msg, text=None, subject=None, tomoderators=True):
# Wrap the message as an attachment
if text is None:
text = _('No reason given')
if subject is None:
text = _('(no subject)')
text = MIMEText(Utils.wrap(text),
_charset=Utils.GetCharSet(self.preferred_language))
attachment = MIMEMessage(msg)
notice = Message.OwnerNotification(
self, subject, tomoderators=tomoderators)
# Make it look like the message is going to the -owner address
notice.set_type('multipart/mixed')
notice.attach(text)
notice.attach(attachment)
notice.send(self)
def process(mlist, msg, msgdata):
# This is the negation of we're wrapping because dmarc_moderation_action
# is wrap this message or from_is_list applies and is wrap.
if not (msgdata.get('from_is_list') == 2 or
(mlist.from_is_list == 2 and msgdata.get('from_is_list') == 0)):
# Now see if we need to add a From:, Reply-To: or Cc: without wrapping.
# See comments in CookHeaders.change_header for why we do this here.
a_h = msgdata.get('add_header')
if a_h:
if a_h.get('From'):
del msg['from']
msg['From'] = a_h.get('From')
if a_h.get('Reply-To'):
del msg['reply-to']
msg['Reply-To'] = a_h.get('Reply-To')
if a_h.get('Cc'):
del msg['cc']
msg['Cc'] = a_h.get('Cc')
return
# There are various headers in msg that we don't want, so we basically
# make a copy of the msg, then delete almost everything and set/copy
# what we want.
omsg = copy.deepcopy(msg)
for key in msg.keys():
if key.lower() not in KEEPERS:
del msg[key]
msg['MIME-Version'] = '1.0'
msg['Message-ID'] = Utils.unique_message_id(mlist)
# Add the headers from CookHeaders.
for k, v in msgdata['add_header'].items():
msg[k] = v
# Are we including dmarc_wrapped_message_text? I.e., do we have text and
# are we wrapping because of dmarc_moderation_action?
if mlist.dmarc_wrapped_message_text and msgdata.get('from_is_list') == 2:
part1 = MIMEText(Utils.wrap(mlist.dmarc_wrapped_message_text), 'plain',
Utils.GetCharSet(mlist.preferred_language))
part1['Content-Disposition'] = 'inline'
part2 = MIMEMessage(omsg)
part2['Content-Disposition'] = 'inline'
msg['Content-Type'] = 'multipart/mixed'
msg.set_payload([part1, part2])
else:
msg['Content-Type'] = 'message/rfc822'
msg['Content-Disposition'] = 'inline'
msg.set_payload([omsg])
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 test_generate(self):
# First craft the message to be encapsulated
m = Message()
m['Subject'] = 'An enclosed message'
m.add_payload('Here is the body of the message.\n')
r = MIMEMessage(m)
r['Subject'] = 'The enclosing message'
s = StringIO()
g = Generator(s)
g(r)
self.assertEqual(
s.getvalue(), """\
Content-Type: message/rfc822
MIME-Version: 1.0
Subject: The enclosing message
Subject: An enclosed message
Here is the body of the message.
""")
def confirmation(m, key):
recipient = wlemail.senders(m)[0]
recipient_email = recipient[1]
if not can_send_confirmation(recipient_email):
wlelog.log (3, "Not sending duplicate confirmation to %s" % \
email.Utils.formataddr (recipient))
return None
wlelog.log (3, "Sending confirmation request to %s" % \
email.Utils.formataddr (recipient))
r = MIMEMultipart()
subject = m.get('subject')
if not subject: subject = '...'
rsubject = '[confirm #%s] %s' % (key, wlemail.make_answer(subject))
r['X-WLE-confirmation'] = 'yes'
r['Precedence'] = 'bulk'
rfrom = email.Utils.formataddr \
((wleconfig.config.get ('DEFAULT', 'myname'),
confirmation_sender (m)))
rto = email.Utils.formataddr(recipient)
wlemail.complete_message(r, rfrom, rto, rsubject)
try:
r['In-Reply-To'] = m.get('message-id')
except:
pass
excuse = MIMEText(makeup_excuse(key), 'plain',
wleconfig.config.get('DEFAULT', 'charset'))
excuse['Content-Disposition'] = 'inline'
r.attach(excuse)
origin = MIMEMessage(m)
origin['Content-Disposition'] = 'attachment'
r.attach(origin)
db = wledb.connect_db()
c = db.cursor()
c.execute("insert into confirmations values ('%s', %f)" %
(recipient_email, time.time()))
db.commit()
return r
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 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)
# Copyright (C) 2001 Python Software Foundation
def mime_attach(body, attachments, charset, body_charset=None):
mimetypes.init()
message = MIMEMultipart('mixed')
bodypart = BetterMIMEText(body, _charset=(body_charset or charset))
bodypart.add_header('Content-Disposition', 'inline')
message.preamble = 'This is a multi-part MIME message sent by reportbug.\n\n'
message.epilogue = ''
message.attach(bodypart)
failed = False
for attachment in attachments:
try:
fp = file(attachment)
fp.close()
except EnvironmentError, x:
ewrite("Warning: opening '%s' failed: %s.\n", attachment,
x.strerror)
failed = True
continue
ctype = None
cset = charset
info = Popen(['file', '--mime', '--brief', attachment],
stdout=PIPE,
stderr=STDOUT).communicate()[0]
if info:
match = re.match(r'([^;, ]*)(,[^;]+)?(?:; )?(.*)', info)
if match:
ctype, junk, extras = match.groups()
match = re.search(r'charset=([^,]+|"[^,"]+")', extras)
if match:
cset = match.group(1)
# If we didn't get a real MIME type, fall back
if '/' not in ctype:
ctype = None
# If file doesn't work, try to guess based on the extension
if not ctype:
ctype, encoding = mimetypes.guess_type(attachment, strict=False)
if not ctype:
ctype = 'application/octet-stream'
maintype, subtype = ctype.split('/', 1)
if maintype == 'text':
fp = file(attachment, 'rU')
part = BetterMIMEText(fp.read(), _subtype=subtype, _charset=cset)
fp.close()
elif maintype == 'message':
fp = file(attachment, 'rb')
part = MIMEMessage(email.message_from_file(fp), _subtype=subtype)
fp.close()
elif maintype == 'image':
fp = file(attachment, 'rb')
part = MIMEImage(fp.read(), _subtype=subtype)
fp.close()
elif maintype == 'audio':
fp = file(attachment, 'rb')
part = MIMEAudio(fp.read(), _subtype=subtype)
fp.close()
else:
fp = file(attachment, 'rb')
part = MIMEBase(maintype, subtype)
part.set_payload(fp.read())
fp.close()
email.Encoders.encode_base64(part)
part.add_header('Content-Disposition',
'attachment',
filename=os.path.basename(attachment))
message.attach(part)
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.
if isinstance(exc, ClassType) 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(MIMEMessage(msg))
nmsg.attach(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
def send_i18n_digests(mlist, mboxfp):
mbox = Mailbox(mboxfp)
# Prepare common information (first lang/charset)
lang = mlist.preferred_language
lcset = Utils.GetCharSet(lang)
lcset_out = Charset(lcset).output_charset or lcset
# Common Information (contd)
realname = mlist.real_name
volume = mlist.volume
issue = mlist.next_digest_number
digestid = _('%(realname)s Digest, Vol %(volume)d, Issue %(issue)d')
digestsubj = Header(digestid, lcset, header_name='Subject')
# Set things up for the MIME digest. Only headers not added by
# CookHeaders need be added here.
# Date/Message-ID should be added here also.
mimemsg = Message.Message()
mimemsg['Content-Type'] = 'multipart/mixed'
mimemsg['MIME-Version'] = '1.0'
mimemsg['From'] = mlist.GetRequestEmail()
mimemsg['Subject'] = digestsubj
mimemsg['To'] = mlist.GetListEmail()
mimemsg['Reply-To'] = mlist.GetListEmail()
mimemsg['Date'] = formatdate(localtime=1)
mimemsg['Message-ID'] = Utils.unique_message_id(mlist)
# Set things up for the rfc1153 digest
plainmsg = StringIO()
rfc1153msg = Message.Message()
rfc1153msg['From'] = mlist.GetRequestEmail()
rfc1153msg['Subject'] = digestsubj
rfc1153msg['To'] = mlist.GetListEmail()
rfc1153msg['Reply-To'] = mlist.GetListEmail()
rfc1153msg['Date'] = formatdate(localtime=1)
rfc1153msg['Message-ID'] = Utils.unique_message_id(mlist)
separator70 = '-' * 70
separator30 = '-' * 30
# In the rfc1153 digest, the masthead contains the digest boilerplate plus
# any digest header. In the MIME digests, the masthead and digest header
# are separate MIME subobjects. In either case, it's the first thing in
# the digest, and we can calculate it now, so go ahead and add it now.
mastheadtxt = Utils.maketext(
'masthead.txt', {
'real_name': mlist.real_name,
'got_list_email': mlist.GetListEmail(),
'got_listinfo_url': mlist.GetScriptURL('listinfo', absolute=1),
'got_request_email': mlist.GetRequestEmail(),
'got_owner_email': mlist.GetOwnerEmail(),
},
mlist=mlist)
# MIME
masthead = MIMEText(mastheadtxt, _charset=lcset)
masthead['Content-Description'] = digestid
mimemsg.attach(masthead)
# RFC 1153
print >> plainmsg, mastheadtxt
print >> plainmsg
# Now add the optional digest header but only if more than whitespace.
if re.sub('\s', '', mlist.digest_header):
headertxt = decorate(mlist, mlist.digest_header, _('digest header'))
# MIME
header = MIMEText(headertxt, _charset=lcset)
header['Content-Description'] = _('Digest Header')
mimemsg.attach(header)
# RFC 1153
print >> plainmsg, headertxt
print >> plainmsg
# Now we have to cruise through all the messages accumulated in the
# mailbox file. We can't add these messages to the plainmsg and mimemsg
# yet, because we first have to calculate the table of contents
# (i.e. grok out all the Subjects). Store the messages in a list until
# we're ready for them.
#
# Meanwhile prepare things for the table of contents
toc = StringIO()
print >> toc, _("Today's Topics:\n")
# Now cruise through all the messages in the mailbox of digest messages,
# building the MIME payload and core of the RFC 1153 digest. We'll also
# accumulate Subject: headers and authors for the table-of-contents.
messages = []
msgcount = 0
msg = mbox.next()
while msg is not None:
if msg == '':
# It was an unparseable message
msg = mbox.next()
continue
msgcount += 1
messages.append(msg)
# Get the Subject header
msgsubj = msg.get('subject', _('(no subject)'))
subject = Utils.oneline(msgsubj, lcset)
# Don't include the redundant subject prefix in the toc
mo = re.match('(re:? *)?(%s)' % re.escape(mlist.subject_prefix),
subject, re.IGNORECASE)
if mo:
subject = subject[:mo.start(2)] + subject[mo.end(2):]
username = ''
addresses = getaddresses([Utils.oneline(msg.get('from', ''), lcset)])
# Take only the first author we find
if isinstance(addresses, ListType) and addresses:
username = addresses[0][0]
if not username:
username = addresses[0][1]
if username:
username = '******' % username
# Put count and Wrap the toc subject line
wrapped = Utils.wrap('%2d. %s' % (msgcount, subject), 65)
slines = wrapped.split('\n')
# See if the user's name can fit on the last line
if len(slines[-1]) + len(username) > 70:
slines.append(username)
else:
slines[-1] += username
# Add this subject to the accumulating topics
first = True
for line in slines:
if first:
print >> toc, ' ', line
first = False
else:
print >> toc, ' ', line.lstrip()
# We do not want all the headers of the original message to leak
# through in the digest messages. For this phase, we'll leave the
# same set of headers in both digests, i.e. those required in RFC 1153
# plus a couple of other useful ones. We also need to reorder the
# headers according to RFC 1153. Later, we'll strip out headers for
# for the specific MIME or plain digests.
keeper = {}
all_keepers = {}
for header in (mm_cfg.MIME_DIGEST_KEEP_HEADERS +
mm_cfg.PLAIN_DIGEST_KEEP_HEADERS):
all_keepers[header] = True
all_keepers = all_keepers.keys()
for keep in all_keepers:
keeper[keep] = msg.get_all(keep, [])
# Now remove all unkempt headers :)
for header in msg.keys():
del msg[header]
# And add back the kept header in the RFC 1153 designated order
for keep in all_keepers:
for field in keeper[keep]:
msg[keep] = field
# And a bit of extra stuff
msg['Message'] = ` msgcount `
# Get the next message in the digest mailbox
msg = mbox.next()
# Now we're finished with all the messages in the digest. First do some
# sanity checking and then on to adding the toc.
if msgcount == 0:
# Why did we even get here?
return
toctext = to_cset_out(toc.getvalue(), lcset)
# MIME
tocpart = MIMEText(toctext, _charset=lcset)
tocpart['Content-Description'] = _(
"Today's Topics (%(msgcount)d messages)")
mimemsg.attach(tocpart)
# RFC 1153
print >> plainmsg, toctext
print >> plainmsg
# For RFC 1153 digests, we now need the standard separator
print >> plainmsg, separator70
print >> plainmsg
# Now go through and add each message
mimedigest = MIMEBase('multipart', 'digest')
mimemsg.attach(mimedigest)
first = True
for msg in messages:
# MIME. Make a copy of the message object since the rfc1153
# processing scrubs out attachments.
mimedigest.attach(MIMEMessage(copy.deepcopy(msg)))
# rfc1153
if first:
first = False
else:
print >> plainmsg, separator30
print >> plainmsg
# Use Mailman.Handlers.Scrubber.process() to get plain text
try:
msg = scrubber(mlist, msg)
except Errors.DiscardMessage:
print >> plainmsg, _('[Message discarded by content filter]')
continue
# Honor the default setting
for h in mm_cfg.PLAIN_DIGEST_KEEP_HEADERS:
if msg[h]:
uh = Utils.wrap('%s: %s' % (h, Utils.oneline(msg[h], lcset)))
uh = '\n\t'.join(uh.split('\n'))
print >> plainmsg, uh
print >> plainmsg
# If decoded payload is empty, this may be multipart message.
# -- just stringfy it.
payload = msg.get_payload(decode=True) \
or msg.as_string().split('\n\n',1)[1]
mcset = msg.get_content_charset('')
if mcset and mcset <> lcset and mcset <> lcset_out:
try:
payload = unicode(payload, mcset,
'replace').encode(lcset, 'replace')
except (UnicodeError, LookupError):
# TK: Message has something unknown charset.
# _out means charset in 'outer world'.
payload = unicode(payload, lcset_out,
'replace').encode(lcset, 'replace')
print >> plainmsg, payload
if not payload.endswith('\n'):
print >> plainmsg
# Now add the footer but only if more than whitespace.
if re.sub('\s', '', mlist.digest_footer):
footertxt = decorate(mlist, mlist.digest_footer, _('digest footer'))
# MIME
footer = MIMEText(footertxt, _charset=lcset)
footer['Content-Description'] = _('Digest Footer')
mimemsg.attach(footer)
# RFC 1153
# MAS: There is no real place for the digest_footer in an RFC 1153
# compliant digest, so add it as an additional message with
# Subject: Digest Footer
print >> plainmsg, separator30
print >> plainmsg
print >> plainmsg, 'Subject: ' + _('Digest Footer')
print >> plainmsg
print >> plainmsg, footertxt
print >> plainmsg
print >> plainmsg, separator30
print >> plainmsg
# Do the last bit of stuff for each digest type
signoff = _('End of ') + digestid
# MIME
# BAW: This stuff is outside the normal MIME goo, and it's what the old
# MIME digester did. No one seemed to complain, probably because you
# won't see it in an MUA that can't display the raw message. We've never
# got complaints before, but if we do, just wax this. It's primarily
# included for (marginally useful) backwards compatibility.
mimemsg.postamble = signoff
# rfc1153
print >> plainmsg, signoff
print >> plainmsg, '*' * len(signoff)
# Do our final bit of housekeeping, and then send each message to the
# outgoing queue for delivery.
mlist.next_digest_number += 1
virginq = get_switchboard(mm_cfg.VIRGINQUEUE_DIR)
# Calculate the recipients lists
plainrecips = []
mimerecips = []
drecips = mlist.getDigestMemberKeys() + mlist.one_last_digest.keys()
for user in mlist.getMemberCPAddresses(drecips):
# user might be None if someone who toggled off digest delivery
# subsequently unsubscribed from the mailing list. Also, filter out
# folks who have disabled delivery.
if user is None or mlist.getDeliveryStatus(user) <> ENABLED:
continue
# Otherwise, decide whether they get MIME or RFC 1153 digests
if mlist.getMemberOption(user, mm_cfg.DisableMime):
plainrecips.append(user)
else:
mimerecips.append(user)
# Zap this since we're now delivering the last digest to these folks.
mlist.one_last_digest.clear()
# MIME
virginq.enqueue(mimemsg,
recips=mimerecips,
listname=mlist.internal_name(),
isdigest=True)
# RFC 1153
rfc1153msg.set_payload(to_cset_out(plainmsg.getvalue(), lcset), lcset)
virginq.enqueue(rfc1153msg,
recips=plainrecips,
listname=mlist.internal_name(),
isdigest=True)
