def _route_msg(self): """ Sends the msg using the ESMTPSenderFactory. """ log.msg("Connecting to SMTP server %s:%s" % (self._host, self._port)) msg = self._msg.as_string(False) # we construct a defer to pass to the ESMTPSenderFactory d = defer.Deferred() d.addCallbacks(self.sendSuccess, self.sendError) # we don't pass an ssl context factory to the ESMTPSenderFactory # because ssl will be handled by reactor.connectSSL() below. factory = smtp.ESMTPSenderFactory( "", # username is blank because server does not use auth. "", # password is blank because server does not use auth. self._fromAddress.addrstr, self._user.dest.addrstr, StringIO(msg), d, heloFallback=True, requireAuthentication=False, requireTransportSecurity=True) factory.domain = __version__ signal(proto.SMTP_SEND_MESSAGE_START, self._user.dest.addrstr) reactor.connectSSL(self._host, self._port, factory, contextFactory=SSLContextFactory( self._cert, self._key))
def sendMessage(self): """ Send the message. This method will prepare the message (headers and possibly encrypted body) and send it using the ESMTPSenderFactory. @return: A deferred with callbacks for error and success of this message send. @rtype: twisted.internet.defer.Deferred """ msg = self._message.as_string(False) d = defer.Deferred() factory = smtp.ESMTPSenderFactory( self._config[USERNAME_KEY], self._config[PASSWORD_KEY], self._fromAddress.addrstr, self._user.dest.addrstr, StringIO(msg), d, requireAuthentication=False, # for now do unauth, see issue #2474 ) # TODO: Change this to connectSSL when cert auth is in place in the platform reactor.connectTCP( self._config[HOST_KEY], self._config[PORT_KEY], factory ) d.addCallback(self.sendSuccess) d.addErrback(self.sendError) return d
def _route_msg(self, encrypt_and_sign_result): """ Sends the msg using the ESMTPSenderFactory. :param encrypt_and_sign_result: A tuple containing the 'maybe' encrypted message and the recipient :type encrypt_and_sign_result: tuple """ message, recipient = encrypt_and_sign_result log.msg("Connecting to SMTP server %s:%s" % (self._host, self._port)) msg = message.as_string(False) # we construct a defer to pass to the ESMTPSenderFactory d = defer.Deferred() d.addCallbacks(self.sendSuccess, self.sendError) # we don't pass an ssl context factory to the ESMTPSenderFactory # because ssl will be handled by reactor.connectSSL() below. factory = smtp.ESMTPSenderFactory( "", # username is blank, no client auth here "", # password is blank, no client auth here self._from_address, recipient.dest.addrstr, StringIO(msg), d, heloFallback=True, requireAuthentication=False, requireTransportSecurity=True) factory.domain = __version__ emit(catalog.SMTP_SEND_MESSAGE_START, recipient.dest.addrstr) reactor.connectSSL(self._host, self._port, factory, contextFactory=SSLContextFactory( self._cert, self._key))
def send(self, recipient, message): self.log.info('Connecting to SMTP server %s:%s' % (self._host, self._port)) # we construct a defer to pass to the ESMTPSenderFactory d = defer.Deferred() # we don't pass an ssl context factory to the ESMTPSenderFactory # because ssl will be handled by reactor.connectSSL() below. factory = smtp.ESMTPSenderFactory( "", # username is blank, no client auth here "", # password is blank, no client auth here self._from_address, recipient.dest.addrstr, StringIO(message), d, heloFallback=True, requireAuthentication=False, requireTransportSecurity=True) factory.domain = bytes('leap.bitmask.mail-' + __version__) reactor.connectSSL(self._host, self._port, factory, contextFactory=SSLContextFactory( self._key, self._key)) d.addCallback(lambda result: result[1][0][0]) d.addErrback(self._send_errback) return d
def __call__(self, sender, recipients, msg): print "Hello!" deferred = Deferred() msg['From'] = sender msg['To'] = ', '.join(recipients) factory = smtp.ESMTPSenderFactory( self.config.username, self.config.password, sender, recipients, cStringIO.StringIO(msg.as_string()), deferred, contextFactory=self.context, requireTransportSecurity=False, retries=0, ) deferred.addErrback(self._on_error) if self.config.use_ssl: reactor.connectSSL( self.config.host, self.config.port, factory, self.context ) else: reactor.connectTCP( self.config.host, self.config.port, factory )
def send(self, sender, recipient, content): d = defer.Deferred() args = self._authentication + [sender, recipient, content, d] factory = smtp.ESMTPSenderFactory(*args, **self._factoryKwargs) return self.endpoint.connect(factory).addCallback(lambda _ign: d)
def testESMTPClient(self): onDone = defer.Deferred() clientFactory = smtp.ESMTPSenderFactory('username', 'password', 'source@address', 'recipient@address', StringIO("Message body"), onDone, retries=0, timeout=0.5) return self._timeoutTest(onDone, clientFactory)
def test_ESMTPClient(self): """ Test timeout for L{smtp.ESMTPSenderFactory}: the response L{Deferred} should be errback with a L{smtp.SMTPTimeoutError}. """ onDone = defer.Deferred() clientFactory = smtp.ESMTPSenderFactory( 'username', 'password', 'source@address', 'recipient@address', StringIO("Message body"), onDone, retries=0, timeout=0.5) return self._timeoutTest(onDone, clientFactory)
def send(host, user=None, pw=None, require_security=False): msg = MIMEText(msg_) msg['From'] = "\"{}\" <{}>".format(from_name, from_) msg['To'] = to msg['Subject'] = subject msgfile = StringIO(msg.as_string()) d = Deferred() factory = smtp.ESMTPSenderFactory(user, pw, from_, to, msgfile, d, requireAuthentication=(user is not None), requireTransportSecurity=require_security) reactor.connectTCP(host, self.smtp_port, factory) self.wait(d) return d
def __sendMail(self, from_addr, to_addrs, messageText, deferred, testing=False): if __debug__: self.parent.printCurrentView("transport.__sendMail") account = self.parent.account username = None password = None authRequired = False securityRequired = False heloFallback = True if account.useAuth: username = account.username password = account.password authRequired = True heloFallback = False if testing: retries = 0 timeout = constants.TESTING_TIMEOUT else: retries = account.numRetries timeout = account.timeout if account.connectionSecurity == 'TLS': securityRequired = True msg = StringIO.StringIO(messageText) # Note that we cheat with the context factory here (value=1), # because ssl.connectSSL does it automatically, and in the # case of STARTTLS we override esmtpState_starttls above # to supply the correct SSL context. factory = smtp.ESMTPSenderFactory(username, password, from_addr, to_addrs, msg, deferred, retries, timeout, 1, heloFallback, authRequired, securityRequired) factory.protocol = _TwistedESMTPSender factory.testing = testing if account.connectionSecurity == 'SSL': ssl.connectSSL(account.host, account.port, factory, self.parent.view) else: ssl.connectTCP(account.host, account.port, factory, self.parent.view)
def callback(password): # Note that we cheat with the context factory here (value=1), # because ssl.connectSSL does it automatically, and in the # case of STARTTLS we override esmtpState_starttls above # to supply the correct SSL context. factory = smtp.ESMTPSenderFactory(username, password, from_addr, to_addrs, msg, deferred, retries, timeout, 1, heloFallback, authRequired, securityRequired) factory.protocol = _TwistedESMTPSender factory.testing = testing # Convert the Unicode hostname to an str # before passing to twisted since twisted uses # a repr of the hostname in error messages. host = self.account.host.encode("utf-8", "ignore") if self.account.connectionSecurity == 'SSL': ssl.connectSSL(host, self.account.port, factory, self.view) else: ssl.connectTCP(host, self.account.port, factory, self.view)
def _esmtpSendmail(username, password, smtphost, port, from_addr, to_addrs, msg, reactor=None): """ This should be the only function in this module that uses the reactor. """ d = defer.Deferred() f = smtp.ESMTPSenderFactory(username, password, from_addr, to_addrs, msg, d, requireTransportSecurity=False) if reactor is None: from twisted.internet import reactor reactor.connectTCP(smtphost, port, f) return d