def _sendmail(self, to_addrs, msg):
# Import twisted.mail here because it is not available in python3
from twisted.internet import reactor
from twisted.mail.smtp import ESMTPSenderFactory
msg = BytesIO(msg)
d = defer.Deferred()
factory = ESMTPSenderFactory(
self.smtpuser,
self.smtppass,
self.mailfrom,
to_addrs,
msg,
d,
heloFallback=True,
requireAuthentication=False,
requireTransportSecurity=self.smtptls,
)
factory.noisy = False
if self.smtpssl:
reactor.connectSSL(self.smtphost, self.smtpport, factory,
ssl.ClientContextFactory())
else:
reactor.connectTCP(self.smtphost, self.smtpport, factory)
return d
def send_plain_email(smtphost, username, password, fromEmail, toEmail, content, headers,
senderDomainName=None, port=25, requireSSL=True):
requireAuth = bool(password)
msg = MIMEText(content)
# Setup the mail headers
for (header, value) in headers.items():
msg[header] = value
headkeys = [k.lower() for k in headers.keys()]
# Add required headers if not present
if "message-id" not in headkeys:
msg["Message-ID"] = messageid()
if "date" not in headkeys:
msg["Date"] = rfc822date()
if "from" not in headkeys and "sender" not in headkeys:
msg["From"] = fromEmail
if "to" not in headkeys and "cc" not in headkeys and "bcc" not in headkeys:
msg["To"] = toEmail
# send message
f = StringIO(msg.as_string())
d = defer.Deferred()
factory = ESMTPSenderFactory(username, password, fromEmail, toEmail, f, d,
requireAuthentication=requireAuth,
requireTransportSecurity=requireSSL)
if senderDomainName is not None:
factory.domain = senderDomainName
connectTCP(smtphost, port, factory)
return d
def _sendmail(self, to_addrs, msg):
msg = StringIO(msg)
d = defer.Deferred()
factory = ESMTPSenderFactory(self.smtpuser, self.smtppass, self.mailfrom, \
to_addrs, msg, d, heloFallback=True, requireAuthentication=False, \
requireTransportSecurity=False)
factory.noisy = False
reactor.connectTCP(self.smtphost, self.smtpport, factory)
return d
def _sendmail(self, to_addrs, msg):
msg = StringIO(msg)
d = defer.Deferred()
factory = ESMTPSenderFactory(self.smtpuser, self.smtppass, self.mailfrom, \
to_addrs, msg, d, heloFallback=True, requireAuthentication=False, \
requireTransportSecurity=True)
factory.noisy = False
reactor.connectTCP(self.smtphost, self.smtpport, factory)
return d
def sendMessage(config):
# Make a message
msg = Message.Message()
msgid = Utils.make_msgid()
# remember the msgid so we can find it later
config.msgid = msgid
msg['To'] = config.toAddress
msg['From'] = config.fromAddress
msg['Message-ID'] = msgid
msg['X-Zenoss-Time-Sent'] = str(config.sent)
msg['Subject'] = 'Zenoss Round-Trip Mail Message'
msg.set_payload(config.messageBody)
log.debug("Message id %s's length is %s bytes" %
(msgid, len(msg.as_string())))
msgIO = StringIO(msg.as_string())
result = defer.Deferred()
# figure out how we should connect
connect = reactor.connectTCP
port = 25
kwargs = {}
args = ()
if ssl and config.smtpAuth == 'SSL':
port = 465
connect = reactor.connectSSL
kwargs.update(dict(requireTransportSecurity=False))
args = (ssl.ClientContextFactory(), )
elif ssl and config.smtpAuth == 'TLS':
pass
else:
kwargs.update(dict(requireTransportSecurity=False))
if config.smtpUsername:
log.debug("ESMTP login as %s/%s" %
(config.smtpUsername, "*" * len(config.smtpPassword)))
factory = ESMTPSenderFactory(config.smtpUsername, config.smtpPassword,
config.fromAddress, (config.toAddress, ),
msgIO, result, **kwargs)
else:
factory = SMTPSenderFactory(config.fromAddress, (config.toAddress, ),
msgIO, result)
def clientConnectionFailed(self, why):
result.errback(why)
factory.clientConnectionFailed = clientConnectionFailed
# initiate the message send
log.debug("Sending message to %s:%s with args: %s" %
(config.smtpHost, config.smtpPort or port, args))
connect(config.smtpHost, config.smtpPort or port, factory, *args)
return result
def _sendmail(self, to_addrs, msg):
msg = StringIO(msg)
d = defer.Deferred()
factory = ESMTPSenderFactory(self.smtpuser, self.smtppass, self.mailfrom,
to_addrs, msg, d, heloFallback=True, requireAuthentication=False,
requireTransportSecurity=self.smtptls)
factory.noisy = False
if self.smtpssl:
reactor.connectSSL(self.smtphost, self.smtpport, factory, ssl.ClientContextFactory())
else:
reactor.connectTCP(self.smtphost, self.smtpport, factory)
return d
def _sendmail(self, to_addrs, msg):
msg = StringIO(msg)
d = defer.Deferred()
factory = ESMTPSenderFactory(self.smtpuser, self.smtppass, self.mailfrom, to_addrs, msg, d, heloFallback=True,
requireAuthentication=False,
requireTransportSecurity=self.smtptls)
factory.noisy = False
if self.smtpssl:
reactor.connectSSL(self.smtphost, self.smtpport, factory, ssl.ClientContextFactory())
else:
reactor.connectTCP(self.smtphost, self.smtpport, factory)
return d
def sendmail(config, to, messageFile):
"""
Sends an email
"""
contextFactory = ClientContextFactory()
# evilaliv3:
# in order to understand and before change this settings please
# read the comment inside tor2web.utils.tls
contextFactory.method = SSL.SSLv23_METHOD
resultDeferred = defer.Deferred()
senderFactory = ESMTPSenderFactory(
config.smtpuser.encode('utf-8'),
config.smtppass.encode('utf-8'),
config.smtpmail,
to,
messageFile,
resultDeferred,
contextFactory=contextFactory,
requireAuthentication=True,
requireTransportSecurity=(config.smtpsecurity != 'SSL'),
retries=0,
timeout=15)
if config.security == "SSL":
senderFactory = tls.TLSMemoryBIOFactory(contextFactory, True, senderFactory)
reactor.connectTCP(config.smtpdomain, config.smtpport, senderFactory)
return resultDeferred
def send(self, mail):
# mail is of email module
d = defer.Deferred()
senderArgs = {
'username': self.username,
'password': self.password,
'fromEmail': self.address,
'toEmail': self._getRawAddress(mail['To']),
'file': StringIO(str(mail)),
'deferred': d,
'retries': 5,
}
if self.ssl:
senderArgs['contextFactory'] = ClientContextFactory()
sender = ESMTPSenderFactory(**senderArgs)
if self.ssl:
port = self.port or 465
reactor.connectSSL(self.server, port, sender,
ClientContextFactory())
else:
port = self.port or 25
reactor.connectTCP(self.server, port, sender)
d.addCallback(self.sent)
d.addErrback(self.fail)
def _get_factory(self, to, message, deferred):
"""
"""
sender_factory = ESMTPSenderFactory(
self._user,
self._passwd,
self._from_email,
to,
message,
deferred,
heloFallback=True,
requireAuthentication=False,
requireTransportSecurity=self._starttls)
sender_factory.noisy = self._noisy
return sender_factory
def sendmail(authenticationUsername, authenticationSecret, fromAddress, toAddress, messageFile, smtpHost, smtpPort=25):
"""
Sends an email using SSLv3 over SMTP
@param authenticationUsername: account username
@param authenticationSecret: account password
@param fromAddress: the from address field of the email
@param toAddress: the to address field of the email
@param messageFile: the message content
@param smtpHost: the smtp host
@param smtpPort: the smtp port
"""
contextFactory = ClientContextFactory()
contextFactory.method = SSL.SSLv3_METHOD
resultDeferred = defer.Deferred()
senderFactory = ESMTPSenderFactory(
authenticationUsername,
authenticationSecret,
fromAddress,
toAddress,
messageFile,
resultDeferred,
contextFactory=contextFactory)
reactor.connectTCP(smtpHost, smtpPort, senderFactory)
return resultDeferred
def do_connect():
"""Connect and authenticate."""
result_deferred = Deferred()
context_factory = None
if use_tls:
from twisted.internet import ssl as twisted_ssl
context_factory = twisted_ssl.ClientContextFactory()
body = MIMEText(message)
body['Subject'] = subject
factory = ESMTPSenderFactory(username,
password,
from_address,
to_address,
StringIO(body.as_string()),
result_deferred,
contextFactory=context_factory,
requireTransportSecurity=use_tls,
requireAuthentication=True,
heloFallback=helo_fallback)
if use_tls:
reactor.connectSSL(host, port, factory, context_factory)
else:
reactor.connectTCP(host, port, factory)
result = yield result_deferred
if result[0] == 0:
raise RuntimeError("failed to send email via smtp")
def _sendmail(self, to_addrs, msg):
# Import twisted.mail here because it is not available in python3
from twisted.mail.smtp import ESMTPSenderFactory
msg = StringIO(msg)
d = defer.Deferred()
factory = ESMTPSenderFactory(self.smtpuser, self.smtppass, self.mailfrom, \
to_addrs, msg, d, heloFallback=True, requireAuthentication=False, \
requireTransportSecurity=self.smtptls)
factory.noisy = False
if self.smtpssl:
reactor.connectSSL(self.smtphost, self.smtpport, factory, ssl.ClientContextFactory())
else:
reactor.connectTCP(self.smtphost, self.smtpport, factory)
return d
def sendmail(authenticationUsername,
authenticationSecret,
fromAddress,
toAddress,
messageFile,
smtpHost,
smtpPort=25):
"""
"""
contextFactory = ClientContextFactory()
contextFactory.method = SSL.SSLv3_METHOD
resultDeferred = Deferred()
senderFactory = ESMTPSenderFactory(authenticationUsername,
authenticationSecret,
fromAddress,
toAddress,
messageFile,
resultDeferred,
contextFactory=contextFactory)
reactor.connectTCP(smtpHost, smtpPort, senderFactory)
return resultDeferred
def sendMail(self, m, recipients):
s = m.as_string()
twlog.msg("sending mail (%d bytes) to" % len(s), recipients)
result = defer.Deferred()
useAuth = self.smtpUser and self.smtpPassword
s = unicode2bytes(s)
sender_factory = ESMTPSenderFactory(
self.smtpUser,
self.smtpPassword,
self.fromaddr,
recipients,
BytesIO(s),
result,
requireTransportSecurity=self.useTls,
requireAuthentication=useAuth)
if self.useSmtps:
reactor.connectSSL(self.relayhost, self.smtpPort, sender_factory,
ssl.ClientContextFactory())
else:
reactor.connectTCP(self.relayhost, self.smtpPort, sender_factory)
return result
def send_mail(self, mailto, topic, content, tls=False, **kwargs):
message = email.MIMEText.MIMEText(content, 'html', 'utf-8')
message["Subject"] = email.Header.Header(topic, 'utf-8')
message["From"] = self.from_addr
message["To"] = mailto
message["Accept-Language"] = "zh-CN"
message["Accept-Charset"] = "ISO-8859-1,utf-8"
if not tls:
logger.info('send mail:%s:%s:%s' %
(self.smtp_server, self.smtp_port, mailto))
return sendmail(self.smtp_server,
self.from_addr,
mailto,
message,
port=self.smtp_port,
username=self.smtp_user,
password=self.smtp_pwd)
else:
logger.info('send tls mail:%s:%s:%s' %
(self.smtp_server, self.smtp_port, mailto))
contextFactory = ContextFactory()
resultDeferred = Deferred()
senderFactory = ESMTPSenderFactory(
self.smtp_user,
self.smtp_pwd,
self.from_addr,
mailto,
StringIO(message.as_string()),
resultDeferred,
contextFactory=contextFactory,
requireAuthentication=(self.smtp_user and self.smtp_pwd),
requireTransportSecurity=tls)
reactor.connectTCP(self.smtp_server, self.smtp_port, senderFactory)
return resultDeferred
def sendmail(self, s, recipients):
result = defer.Deferred()
if self.smtpUser and self.smtpPassword:
useAuth = True
else:
useAuth = False
sender_factory = ESMTPSenderFactory(
self.smtpUser,
self.smtpPassword,
self.fromaddr,
recipients,
StringIO(s),
result,
requireTransportSecurity=self.useTls,
requireAuthentication=useAuth)
if self.useSmtps:
reactor.connectSSL(self.relayhost, self.smtpPort, sender_factory,
ssl.ClientContextFactory())
else:
reactor.connectTCP(self.relayhost, self.smtpPort, sender_factory)
return result
def sendmail(username,
password,
fromAddress,
toAddress,
message,
smtpHost,
smtpPort=25):
"""
@param username: The username with which to authenticate.
@param password: The password with which to authenticate.
@param fromAddress: The SMTP reverse path (ie, MAIL FROM)
@param toAddress: The SMTP forward path (ie, RCPT TO)
@param message: text containing the headers and body of the message to send.
@param smtpHost: The MX host to which to connect.
@param smtpPort: The port number to which to connect.
@return: A Deferred which will be called back when the message has been
sent or which will errback if it cannot be sent.
"""
# Create a context factory which only allows SSLv3 and does not verify
# the peer's certificate.
contextFactory = ClientContextFactory()
contextFactory.method = SSLv3_METHOD
d = Deferred()
senderFactory = ESMTPSenderFactory(username,
password,
fromAddress,
toAddress,
StringIO(message),
d,
contextFactory=contextFactory)
reactor.connectTCP(smtpHost, smtpPort, senderFactory)
return d
def sendmail(self, s, recipients):
result = defer.Deferred()
if have_ssl and self.useTls:
client_factory = ssl.ClientContextFactory()
client_factory.method = SSLv3_METHOD
else:
client_factory = None
if self.smtpUser and self.smtpPassword:
useAuth = True
else:
useAuth = False
sender_factory = ESMTPSenderFactory(
self.smtpUser,
self.smtpPassword,
self.fromaddr,
recipients,
StringIO(s),
result,
contextFactory=client_factory,
requireTransportSecurity=self.useTls,
requireAuthentication=useAuth)
reactor.connectTCP(self.relayhost, self.smtpPort, sender_factory)
return result
def send_html(cls, to, topic, message):
config = ApplicationConfig.get_current_config()
email = MIMEMultipart('alternative')
email['Subject'] = topic
email['From'] = config.google_user_email
email['To'] = to
email.attach(MIMEText(message,'html', 'utf-8'))
formatted_mail = email.as_string()
messageFile = StringIO(formatted_mail)
resultDeferred = Deferred()
senderFactory = ESMTPSenderFactory(
config.google_user_email, # user
config.google_user_password, # secret
config.google_user_email, # from
to, # to
messageFile, # message
resultDeferred, # deferred
contextFactory=cls.contextFactory)
reactor.connectTCP(cls.SMTP_SERVER, cls.SMTP_PORT, senderFactory)
return resultDeferred
def send_with_file(cls, to, topic, message, file_path):
config = ApplicationConfig.get_current_config()
email = MIMEMultipart()
email['Subject'] = topic
email['From'] = config.google_user_email
email['To'] = to
part = MIMEBase('application', "octet-stream")
part.set_payload(open(file_path, "rb").read())
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % file_path.split('/')[-1])
email.attach(part)
email.attach(MIMEText(message))
formatted_mail = email.as_string()
messageFile = StringIO(formatted_mail)
resultDeferred = Deferred()
senderFactory = ESMTPSenderFactory(
config.google_user_email, # user
config.google_user_password, # secret
config.google_user_email, # from
to, # to
messageFile, # message
resultDeferred, # deferred
contextFactory=cls.contextFactory)
reactor.connectTCP(cls.SMTP_SERVER, cls.SMTP_PORT, senderFactory)
return resultDeferred
def send_plain_email(fromEmail, toEmail, content, headers):
if REQUIRE_AUTH:
password = FilePath(SMTP_PASSWORD_PATH).getContent().strip()
else:
password = None
msgstr = compose_plain_email(fromEmail, toEmail, content, headers)
f = StringIO(msgstr)
d = defer.Deferred()
factory = ESMTPSenderFactory(SMTP_USERNAME, password, fromEmail, toEmail, f, d,
requireAuthentication=REQUIRE_AUTH,
requireTransportSecurity=REQUIRE_TRANSPORT_SECURITY)
factory.domain = SENDER_DOMAIN
connectTCP(SMTP_HOST, SMTP_PORT, factory)
return d
def sendMail(self, m, recipients):
s = m.as_string()
twlog.msg("sending mail ({} bytes) to".format(len(s)), recipients)
if self.dumpMailsToLog: # pragma: no cover
twlog.msg("mail data:\n{0}".format(s))
result = defer.Deferred()
useAuth = self.smtpUser and self.smtpPassword
s = unicode2bytes(s)
recipients = [parseaddr(r)[1] for r in recipients]
sender_factory = ESMTPSenderFactory(
unicode2bytes(self.smtpUser),
unicode2bytes(self.smtpPassword),
parseaddr(self.fromaddr)[1],
recipients,
BytesIO(s),
result,
requireTransportSecurity=self.useTls,
requireAuthentication=useAuth)
if self.useSmtps:
reactor.connectSSL(self.relayhost, self.smtpPort, sender_factory,
ssl.ClientContextFactory())
else:
reactor.connectTCP(self.relayhost, self.smtpPort, sender_factory)
return result
def sendMail(self, res):
log.debug("In sendMail function")
print res
self.agi.email = res[0]['email']
self.agi.indcn = res[0]['indcn']
self.agi.infib = res[0]['infib']
self.agi.emdcn = res[0]['emdcn']
self.agi.emfib = res[0]['emfib']
self.agi.attendance = res[0]['attendance']
txt = "Hello ,\n\nInternal Marks:\n Data Communication Network :%(indc)s\n Fundamental Of Image Processing :%(infp)s\n\nExternal Marks:\n Data Communication Network :%(emdc)s\n Fundamental Of Image Processing :%(emfp)s\n\nAttendance :%(att)s\n\nThank you.\n- STUDENT INFORMATION SYSTEM"
data = {
"indc": self.agi.indcn,
"infp": self.agi.infib,
"emdc": self.agi.emdcn,
"emfp": self.agi.emfib,
"att": self.agi.attendance
}
msg = MIMEMultipart()
msg['Subject'] = "University Student Information"
msg['To'] = self.agi.email
msg['From'] = "GIT <*****@*****.**>"
textmsg = MIMEText(txt % data)
msg.attach(textmsg)
msg = StringIO(msg.as_string())
df = defer.Deferred()
df.addCallback(self.hangup)
f = ESMTPSenderFactory(mailuser,
mailpasswd,
frommail,
self.agi.email,
msg,
df,
requireTransportSecurity=False,
requireAuthentication=True)
reactor.connectTCP(mailhost, mailport, f)
def send_plain_email(fromEmail, toEmail, content, headers):
if REQUIRE_AUTH:
password = FilePath(SMTP_PASSWORD_PATH).getContent().strip()
else:
password = None
msg = MIMEText(content)
# Setup the mail headers
for (header, value) in headers.items():
msg[header] = value
headkeys = [k.lower() for k in headers.keys()]
# Add required headers if not present
if "message-id" not in headkeys:
msg["Message-ID"] = messageid()
if "date" not in headkeys:
msg["Date"] = rfc822date()
if "from" not in headkeys and "sender" not in headkeys:
msg["From"] = fromEmail
if "to" not in headkeys and "cc" not in headkeys and "bcc" not in headkeys:
msg["To"] = toEmail
if "reply-to" not in headkeys:
msg["Reply-To"] = SUPPORT_ADDRESS
if "user-agent" not in headkeys:
msg["User-Agent"] = USER_AGENT
if "content-type" not in headkeys:
msg["Content-Type"] = CONTENT_TYPE
# send message
f = StringIO(msg.as_string())
d = defer.Deferred()
factory = ESMTPSenderFactory(
SMTP_USERNAME,
password,
fromEmail,
toEmail,
f,
d,
requireAuthentication=REQUIRE_AUTH,
requireTransportSecurity=REQUIRE_TRANSPORT_SECURITY)
factory.domain = SENDER_DOMAIN
connectTCP(SMTP_HOST, SMTP_PORT, factory)
return d
def _get_factory(self, to, message, deferred):
"""
"""
sender_factory = ESMTPSenderFactory(
self._user,
self._passwd,
self._from_email,
to,
message,
deferred,
heloFallback=True,
requireAuthentication=False,
requireTransportSecurity=self._starttls
)
sender_factory.noisy = self._noisy
return sender_factory
def sendmail(mailconf, message):
"""Takes a regular dictionary as mailconf, as follows.
Example::
mailconf = dict(
host="smtp.gmail.com", # required
port=25, # optional, default 25 or 587 for SSL/TLS
username=foo, # optional, no default
password=bar, # optional, no default
tls=True, # optional, default False
)
d = mail.sendmail(mailconf, msg)
d.addCallback(on_response)
"""
if not isinstance(mailconf, types.DictType):
raise TypeError("mailconf must be a regular python dictionary")
if not isinstance(message, Message):
raise TypeError("message must be an instance of cyclone.mail.Message")
host = mailconf.get("host")
if isinstance(host, unicode):
host = str(unicode)
if not isinstance(host, types.StringType):
raise ValueError("mailconf requires a 'host' configuration")
use_tls = mailconf.get("tls")
if use_tls:
port = mailconf.get("port", 587)
contextFactory = ClientContextFactory()
contextFactory.method = SSLv3_METHOD
else:
port = mailconf.get("port", 25)
contextFactory = None
if not isinstance(port, types.IntType):
raise ValueError("mailconf requires a proper 'port' configuration")
result = Deferred()
u = mailconf.get("username")
p = mailconf.get("password")
factory = ESMTPSenderFactory(u,
p,
quoteaddr(message.from_addr),
message.to_addrs,
message.render(),
result,
contextFactory=contextFactory,
requireAuthentication=(u and p),
requireTransportSecurity=use_tls)
reactor.connectTCP(host, port, factory)
return result
def send_email(self, to_addr, subject, content):
msg = self.message(to_addr, subject, content)
d = defer.Deferred()
factory = ESMTPSenderFactory(self.username,
self.password,
self.from_addr,
to_addr,
msg,
d,
requireTransportSecurity=False)
if self.senderDomainName is not None:
factory.domain = self.senderDomainName
reactor.connectTCP(self.smtphost, self.port, factory)
return d
def sendMail(self, view, message):
account = view[self.account].smtp
authRequired = account.useAuth
heloFallback = not authRequired
securityRequired = account.connectionSecurity == 'TLS'
if authRequired:
username = account.username
password = account.password
else:
username = None
password = None
retries = account.numRetries
timeout = account.timeout
deferred = Deferred()
deferred.addCallback(self._sendSuccess)
deferred.addErrback(self._sendFailure)
class _protocol(_TwistedESMTPSender):
def connectionMade(_self):
self.output("smtp: connected to %s" % (account.host))
_TwistedESMTPSender.connectionMade(_self)
# the code below comes from osaf.mail.smtp
factory = ESMTPSenderFactory(username, password,
message['From'], message['To'],
StringIO(str(message)), deferred, retries,
timeout, 1, heloFallback, authRequired,
securityRequired)
factory.protocol = _protocol
factory.testing = False
if account.connectionSecurity == 'SSL':
reactor.callFromThread(ssl.connectSSL, account.host, account.port,
factory, view)
else:
reactor.callFromThread(ssl.connectTCP, account.host, account.port,
factory, view)
def sendMail(self, view, message):
account = view[self.account].smtp
authRequired = account.useAuth
heloFallback = not authRequired
securityRequired = account.connectionSecurity == 'TLS'
if authRequired:
username = account.username
password = account.password
else:
username = None
password = None
retries = account.numRetries
timeout = account.timeout
deferred = Deferred()
deferred.addCallback(self._sendSuccess)
deferred.addErrback(self._sendFailure)
class _protocol(_TwistedESMTPSender):
def connectionMade(_self):
self.output("smtp: connected to %s" %(account.host))
_TwistedESMTPSender.connectionMade(_self)
# the code below comes from osaf.mail.smtp
factory = ESMTPSenderFactory(username, password, message['From'],
message['To'], StringIO(str(message)),
deferred, retries, timeout,
1, heloFallback, authRequired,
securityRequired)
factory.protocol = _protocol
factory.testing = False
if account.connectionSecurity == 'SSL':
reactor.callFromThread(ssl.connectSSL, account.host, account.port,
factory, view)
else:
reactor.callFromThread(ssl.connectTCP, account.host, account.port,
factory, view)
def __init__(self, id, request, deferred):
# Create a context factory which only allows SSLv3 and does not verify
# the peer's certificate.
contextFactory = ClientContextFactory()
contextFactory.method = SSLv3_METHOD
self.id = id
self.request = request
self.deferred = deferred
self.sentDeferred = Deferred()
self.sentDeferred.addErrback(self.deferred.errback)
username = request.args.get("username", [request.getUser()])[0]
password = request.args.get("password", [request.getPassword()])[0]
fromEmail = request.args.get("from", username)[0]
toEmail = request.args.get("to")[0]
subject = request.args.get("subject")[0]
message = StringIO.StringIO(
"""\
Date: Fri, 6 Feb 2004 10:14:39 -0800
From: %s
To: %s
Subject: %s
%s
"""
% (fromEmail, toEmail, subject, request.args.get("body", [""])[0])
)
ESMTPSenderFactory.__init__(
self,
username,
password,
fromEmail,
toEmail,
message,
self.sentDeferred,
retries=0,
contextFactory=contextFactory,
requireAuthentication=False,
requireTransportSecurity=False,
)
def sendmail(mailconf, message):
"""Takes a regular dictionary as mailconf, as follows:
mailconf["host"] = "your.smtp.com" (required)
mailconf["port"] = 25 (optional, default 25 or 587 for TLS)
mailconf["username"] = "******" (optional)
mailconf["password"] = "******" (optional)
mailconf["ssl"] = True | False (optional, default False)
mailconf["tls"] = True | False (optional, default False)
mailconf["retries"] = 0 (optional, default 0)
mailconf["timeout"] = 30 (optional, default 30)
"""
if not isinstance(mailconf, types.DictType):
raise TypeError("mailconf must be a regular python dictionary")
if not isinstance(message, Message):
raise TypeError("message must be an instance of nuswit.mail.Message")
host = mailconf.get("host")
if not isinstance(host, types.StringType):
raise ValueError("mailconf requires a 'host' configuration")
ssl = mailconf.get("ssl", True)
tls = mailconf.get("tls", True)
if ssl is True:
port = mailconf.get("port", 587)
contextFactory = ClientContextFactory()
contextFactory.method = SSLv3_METHOD
else:
port = mailconf.get("port", 25)
contextFactory = None
retries = mailconf.get("retries", 0)
timeout = mailconf.get("timeout", 30)
if not isinstance(port, types.IntType):
raise ValueError("mailconf requires a proper 'port' configuration")
deferred = Deferred()
username, password = mailconf.get("username"), mailconf.get("password")
factory = ESMTPSenderFactory(
username, password,
message.from_addr, message.to_addrs, message.render(),
deferred, contextFactory=contextFactory,
requireAuthentication=(username and password),
requireTransportSecurity=tls,
retries=retries, timeout=timeout)
if not ssl:
connector = reactor.connectTCP(host, port, factory, timeout=timeout)
else:
connector = reactor.connectSSL(host, port, factory, contextFactory, timeout=timeout)
return deferred, connector
def send_plain_email(fromEmail, toEmail, content, headers):
if REQUIRE_AUTH:
password = FilePath(SMTP_PASSWORD_PATH).getContent().strip()
else:
password = None
msg = MIMEText(content)
# Setup the mail headers
for (header, value) in headers.items():
msg[header] = value
headkeys = [k.lower() for k in headers.keys()]
# Add required headers if not present
if "message-id" not in headkeys:
msg["Message-ID"] = messageid()
if "date" not in headkeys:
msg["Date"] = rfc822date()
if "from" not in headkeys and "sender" not in headkeys:
msg["From"] = fromEmail
if "to" not in headkeys and "cc" not in headkeys and "bcc" not in headkeys:
msg["To"] = toEmail
if "reply-to" not in headkeys:
msg["Reply-To"] = SUPPORT_ADDRESS
if "user-agent" not in headkeys:
msg["User-Agent"] = USER_AGENT
if "content-type" not in headkeys:
msg["Content-Type"] = CONTENT_TYPE
# send message
f = StringIO(msg.as_string())
d = defer.Deferred()
factory = ESMTPSenderFactory(SMTP_USERNAME, password, fromEmail, toEmail, f, d,
requireAuthentication=REQUIRE_AUTH,
requireTransportSecurity=REQUIRE_TRANSPORT_SECURITY)
factory.domain = SENDER_DOMAIN
connectTCP(SMTP_HOST, SMTP_PORT, factory)
return d
def send_plain_email(fromEmail, toEmail, content, headers):
if REQUIRE_AUTH:
password = FilePath(SMTP_PASSWORD_PATH).getContent().strip()
else:
password = None
msgstr = compose_plain_email(fromEmail, toEmail, content, headers)
f = StringIO(msgstr)
d = defer.Deferred()
factory = ESMTPSenderFactory(
SMTP_USERNAME,
password,
fromEmail,
toEmail,
f,
d,
requireAuthentication=REQUIRE_AUTH,
requireTransportSecurity=REQUIRE_TRANSPORT_SECURITY)
factory.domain = SENDER_DOMAIN
connectTCP(SMTP_HOST, SMTP_PORT, factory)
return d
def __init__(self, id, request, deferred):
# Create a context factory which only allows SSLv3 and does not verify
# the peer's certificate.
contextFactory = ClientContextFactory()
contextFactory.method = SSLv3_METHOD
self.id = id
self.request = request
self.deferred = deferred
self.sentDeferred = Deferred()
self.sentDeferred.addErrback(self.deferred.errback)
username = request.args.get('username', [request.getUser()])[0]
password = request.args.get('password', [request.getPassword()])[0]
fromEmail = request.args.get('from', username)[0]
toEmail = request.args.get('to')[0]
subject = request.args.get('subject')[0]
message = StringIO.StringIO('''\
Date: Fri, 6 Feb 2004 10:14:39 -0800
From: %s
To: %s
Subject: %s
%s
''' % (fromEmail, toEmail, subject, request.args.get('body', [''])[0]))
ESMTPSenderFactory.__init__(
self,
username,
password,
fromEmail,
toEmail,
message,
self.sentDeferred,
retries=0,
contextFactory=contextFactory,
requireAuthentication=False,
requireTransportSecurity=False,
)
def sendMail(authUsername, authPassword, SMTPHost, SMTPPort, fromEmail, fromDisplayEmail, msg, reactor=None):
if reactor == None:
from twisted.internet import reactor
contextFactory = ClientContextFactory()
contextFactory.method = SSLv3_METHOD
resultDeferred = Deferred()
msg.replace_header("From", fromDisplayEmail)
msgstring = msg.as_string(unixfrom=True)
fp = StringIO(msgstring)
senderFactory = ESMTPSenderFactory(
authUsername, authPassword, fromEmail, msg.get("To"), fp, resultDeferred, contextFactory=contextFactory)
senderFactory.noisy = False
reactor.connectTCP(SMTPHost, SMTPPort, senderFactory)
return resultDeferred
def build_sender_factory(**kwargs: Any) -> ESMTPSenderFactory:
return ESMTPSenderFactory(
username,
password,
from_addr,
to_addr,
msg,
d,
heloFallback=True,
requireAuthentication=require_auth,
requireTransportSecurity=require_tls,
**kwargs,
)
def sendMessage(self, fromAddr, toAddr, msgId, message):
log.debug("Sending: {msg}", msg=message)
def _success(result, msgId, fromAddr, toAddr):
log.info(
"Sent IMIP message {id} from {fr} to {to}",
id=msgId,
fr=fromAddr,
to=toAddr,
)
return True
def _failure(failure, msgId, fromAddr, toAddr):
log.error(
"Failed to send IMIP message {id} from {fr} to {to} (Reason: {err})",
id=msgId,
fr=fromAddr,
to=toAddr,
err=failure.getErrorMessage(),
)
from OpenSSL.SSL import Error as TLSError
if failure.type is TLSError:
from calendarserver.tap.util import AlertPoster
AlertPoster.postAlert("MailCertificateAlert", 7 * 24 * 60 * 60,
[])
return False
deferred = defer.Deferred()
if self.useSSL:
contextFactory = simpleClientContextFactory(self.server)
else:
contextFactory = None
factory = ESMTPSenderFactory(
self.username,
self.password,
fromAddr,
toAddr,
# per http://trac.calendarserver.org/ticket/416 ...
StringIO(message.replace("\r\n", "\n")),
deferred,
contextFactory=contextFactory,
requireAuthentication=False,
requireTransportSecurity=self.useSSL)
connect(GAIEndpoint(_reactor, self.server, self.port), factory)
deferred.addCallback(_success, msgId, fromAddr, toAddr)
deferred.addErrback(_failure, msgId, fromAddr, toAddr)
return deferred
def sendmail_async(authenticationUsername,
authenticationSecret,
fromAddress,
toAddress,
messageFile,
smtpHost,
smtpPort=25):
"""
@param authenticationUsername: The username with which to authenticate.
@param authenticationSecret: The password with which to authenticate.
@param fromAddress: The SMTP reverse path (ie, MAIL FROM)
@param toAddress: The SMTP forward path (ie, RCPT TO)
@param messageFile: A file-like object containing the headers and body of
the message to send.
@param smtpHost: The MX host to which to connect.
@param smtpPort: The port number to which to connect.
@return: A Deferred which will be called back when the message has been
sent or which will errback if it cannot be sent.
"""
# Create a context factory which only allows SSLv3 and does not verify
# the peer's certificate.
contextFactory = ClientContextFactory()
contextFactory.method = SSLv3_METHOD
resultDeferred = defer.Deferred()
senderFactory = ESMTPSenderFactory(authenticationUsername,
authenticationSecret,
fromAddress,
toAddress,
messageFile,
resultDeferred,
contextFactory=contextFactory,
heloFallback=True,
requireTransportSecurity=False,
requireAuthentication=False)
#pylint: disable-msg=E1101
s = reactor.connectTCP(smtpHost, smtpPort, senderFactory)
#pylint: enable-msg=E1101
def close_socket(d):
s.disconnect()
return d
return resultDeferred.addBoth(close_socket)
def tls_sendmail(self, s, recipients):
client_factory = ssl.ClientContextFactory()
client_factory.method = SSLv3_METHOD
result = defer.Deferred()
sender_factory = ESMTPSenderFactory(
self.smtpUser, self.smtpPassword,
self.fromaddr, recipients, StringIO(s),
result, contextFactory=client_factory)
reactor.connectTCP(self.relayhost, self.smtpPort, sender_factory)
return result
def buildProtocol(self, addr):
p = pdroid.connections[self.id] = ESMTPSenderFactory.buildProtocol(self, addr)
p.factory = self
return p