255 lines
7.1 KiB
Python
Executable File
255 lines
7.1 KiB
Python
Executable File
#! /usr/bin/env python3
|
|
|
|
# (C) Olivier Berger 2001-2002
|
|
# (C) François Poulain 2019
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful, but
|
|
# WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
# General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
|
|
# 02111-1307, USA.
|
|
#
|
|
|
|
# This program is used to mail a message to several recipients, thus
|
|
# providing customization for each recipient.
|
|
|
|
import argparse, csv, sys, re
|
|
import smtplib, time, mimetypes
|
|
from email.header import Header
|
|
from email.message import EmailMessage
|
|
|
|
|
|
def parse_args():
|
|
parser = argparse.ArgumentParser(description="Simple mailing script.")
|
|
ma = parser.add_argument_group(title="mandatory arguments", description=None)
|
|
ma.add_argument(
|
|
"-t",
|
|
"--tofile",
|
|
type=str,
|
|
required=True,
|
|
help="CSV file containing recipients data.",
|
|
)
|
|
ma.add_argument(
|
|
"-b",
|
|
"--bodyfile",
|
|
metavar="BODY.FILE",
|
|
type=str,
|
|
required=True,
|
|
help="Template of the mail to be sent",
|
|
)
|
|
parser.add_argument(
|
|
"-d",
|
|
"--dry-run",
|
|
action="store_true",
|
|
help="Load data but don't send anything.",
|
|
)
|
|
parser.add_argument(
|
|
"-v", "--verbose", action="store_true",
|
|
)
|
|
parser.add_argument(
|
|
"-a", "--attachement", type=str, nargs="+", help="Optionnal attachments.",
|
|
)
|
|
return parser.parse_args()
|
|
|
|
|
|
def read_recipients_datas(args):
|
|
with open(args.tofile) as csv_file:
|
|
csv_soup = csv.reader(csv_file)
|
|
first = [(s.split(":", 1)) for s in csv_soup.__next__()]
|
|
header = [
|
|
(h[0].strip().lower(), h[1].strip() if len(h) == 2 else None) for h in first
|
|
]
|
|
datas = [[s.strip() for s in d] for d in csv_soup]
|
|
full_datas = []
|
|
for data in datas:
|
|
try:
|
|
full_data = {
|
|
h[0]: data[i] if i < len(data) or not h[1] else h[1]
|
|
for i, h in enumerate(header)
|
|
}
|
|
full_datas.append(full_data)
|
|
except Exception:
|
|
print("Ligne mal renseignée:", data, file=sys.stderr)
|
|
return full_datas
|
|
|
|
|
|
def read_body(args):
|
|
bodyfile = open(args.bodyfile)
|
|
body = ""
|
|
for line in bodyfile.readlines():
|
|
body = body + line
|
|
return body
|
|
|
|
|
|
def read_join(args):
|
|
r = []
|
|
for attachement in args.attachement:
|
|
try:
|
|
with open(attachement, "rb") as fp:
|
|
ctype, encoding = mimetypes.guess_type(attachement)
|
|
if ctype is None or encoding is not None:
|
|
ctype = "application/octet-stream"
|
|
maintype, subtype = ctype.split("/", 1)
|
|
metadata = {
|
|
"filename": attachement,
|
|
"maintype": maintype,
|
|
"subtype": subtype,
|
|
}
|
|
r.append((fp.read(), metadata))
|
|
except Exception as e:
|
|
print("read error: %s" % e)
|
|
exit(1)
|
|
return r
|
|
|
|
|
|
def replace_values(bodytemplate, values):
|
|
body = bodytemplate
|
|
|
|
for i in range(len(values)):
|
|
i = i + 1
|
|
pattern = "${{%02d}}" % i
|
|
|
|
body = body.replace(pattern, values[i - 1])
|
|
|
|
return body
|
|
|
|
|
|
# patterns for header of the mail
|
|
FROMPATTERN = re.compile(r"^From: *(.*)")
|
|
SUBJECTPATTERN = re.compile(r"^Subject: *(.*)")
|
|
CCPATTERN = re.compile(r"^Cc: *(.*)")
|
|
BCCPATTERN = re.compile(r"^Bcc: *(.*)")
|
|
REPLYTOPATTERN = re.compile(r"^Reply-To: *(.*)")
|
|
|
|
|
|
def qencode_subject(message):
|
|
subjectmatches = re.search(r"^Subject: *(.*)$", message, re.MULTILINE)
|
|
if subjectmatches == None:
|
|
return message
|
|
subjectstr = subjectmatches.group(1)
|
|
h = Header(subjectstr, "utf-8")
|
|
qsubjectstr = h.encode()
|
|
return message.replace(subjectstr, qsubjectstr, 1)
|
|
|
|
|
|
def send_message(message, to, attachments, args):
|
|
|
|
lines = message.split("\n")
|
|
|
|
# identify headers in the template
|
|
fromvalue = None
|
|
subjectvalue = None
|
|
ccvalue = None
|
|
bccvalue = None
|
|
replytovalue = None
|
|
|
|
for index, line in enumerate(lines):
|
|
if not line:
|
|
body = "\n".join(lines[index + 1 :])
|
|
break
|
|
|
|
frommatches = FROMPATTERN.match(line)
|
|
subjectmatches = SUBJECTPATTERN.match(line)
|
|
ccmatches = CCPATTERN.match(line)
|
|
bccmatches = BCCPATTERN.match(line)
|
|
replytomatches = REPLYTOPATTERN.match(line)
|
|
|
|
if frommatches:
|
|
fromvalue = frommatches.group(1)
|
|
if subjectmatches:
|
|
subjectvalue = subjectmatches.group(1)
|
|
if ccmatches:
|
|
ccvalue = ccmatches.group(1)
|
|
if bccmatches:
|
|
bccvalue = bccmatches.group(1)
|
|
if replytomatches:
|
|
replytovalue = replytomatches.group(1)
|
|
|
|
# lists all addresses to which the mail will be sent
|
|
dests = [to]
|
|
|
|
if ccvalue:
|
|
dests.append(ccvalue)
|
|
if bccvalue:
|
|
dests.append(bccvalue)
|
|
|
|
msg = EmailMessage()
|
|
msg["Subject"] = subjectvalue
|
|
msg["From"] = fromvalue
|
|
msg["To"] = to
|
|
if replytovalue:
|
|
msg["Reply-To"] = replytovalue
|
|
if ccvalue:
|
|
msg["Cc"] = ccvalue
|
|
msg.set_content(body)
|
|
if attachments:
|
|
for attachment in attachments:
|
|
msg.add_attachment(attachment[0], **attachment[1])
|
|
|
|
if args.verbose:
|
|
print(msg)
|
|
print("-" * 80)
|
|
else:
|
|
print(
|
|
"Sending : %s, from %s to %s, dests : %s"
|
|
% (subjectvalue, fromvalue, dests[0], repr(dests))
|
|
)
|
|
|
|
if not args.dry_run:
|
|
# sending the mail to its recipients using the local mailer via SMTP
|
|
server = smtplib.SMTP("localhost", "25")
|
|
server.set_debuglevel(1)
|
|
server.send_message(msg)
|
|
server.quit()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
|
|
args = parse_args()
|
|
|
|
# read the recipients file
|
|
datas = read_recipients_datas(args)
|
|
print(datas)
|
|
exit(0)
|
|
|
|
# read the template of the mail
|
|
bodytemplate = read_body(args)
|
|
|
|
# optionnaly read the attachment of the mail
|
|
attachment = None
|
|
if args.attachement:
|
|
attachments = read_join(args)
|
|
|
|
# counter to be able to pause each 10 mails send
|
|
counter = 0
|
|
|
|
# send mail to each recipient
|
|
for set in sets:
|
|
|
|
values = set
|
|
|
|
# the recipient is always in first column
|
|
recipient = values[0]
|
|
|
|
# replace substitution variables in the template for each recipient
|
|
body = replace_values(bodytemplate, values)
|
|
|
|
# send message
|
|
send_message(body, recipient, attachments, args)
|
|
|
|
# pause every 10 mails for 5 secs so that the MTA doesn't explode
|
|
counter = counter + 1
|
|
if counter >= 10:
|
|
counter = 0
|
|
print("suspending execution for 5 secs")
|
|
time.sleep(5)
|