rubymta 0.0.1

data/lib/rubymta/extended_classes.rb

@@ -0,0 +1,168 @@
+require 'resolv'
+require 'base64'
+require 'unix_crypt'
+
+class QueryError < StandardError; end
+
+class NilClass
+
+  # these defs allow for the case where something wasn't found to
+  # give a nil response rather than crashing--for example:
+  #  mx = "example.com" # => nil (because example.com has no MX record)
+  #  ip = mx.dig_a # => nil, without crashing
+  # otherwise, it would be necessary to write:
+  #  mx = "example.com" # => nil (because example.com has no MX record)
+  #  ip = if mx then ip = mx.dig_a else ip = nil end
+  def dig_a; nil; end
+  def dig_aaaa; nil; end
+  def dig_mx; nil; end
+  def dig_dk; nil; end
+  def dig_ptr; nil; end
+  def mta_live?(port); nil; end
+  def validate_plain; return "", false; end
+
+end
+
+class String
+
+  # returns list of IPV4 addresses, or nil
+  # (there should only be one IPV4 address)
+  def dig_a
+    Resolv::DNS.open do |dns|
+      txts = dns.getresources(self,Resolv::DNS::Resource::IN::A).collect { |r| r.address.to_s }
+      if txts.empty? then nil else txts[0] end
+    end
+  end
+
+  # returns list of IPV6 addresses, or nil
+  # (there should only be one IPV6 address)
+  def dig_aaaa
+    Resolv::DNS.open do |dns|
+      txts = dns.getresources(self,Resolv::DNS::Resource::IN::AAAA).collect { |r| r.address.to_s.downcase }
+      if txts.empty? then nil else txts[0] end
+    end
+  end
+
+  # returns list of MX names, or nil
+  # (there may be multiple MX names for a domain)
+  # WARNING: use the #dig_mxs to get the preferences also
+  def dig_mx
+    Resolv::DNS.open do |dns|
+      txts = dns.getresources(self,Resolv::DNS::Resource::IN::MX).collect { |r| r.exchange.to_s }
+      if txts.empty? then nil else txts end
+    end
+  end
+
+  # returns a hash of { <preference> => [ <mx,ip>, ... ] }
+  # preferences sorted in numerical order from low-->high
+  # (IOW, highest preference to lowest preference)
+  # if there is no mx, returns {}
+  # ex: {10=>[["aspmx.l.google.com", "173.194.78.26"]],
+  #      20=>[["alt1.aspmx.l.google.com", "173.194.219.27"]],
+  #      30=>[["alt2.aspmx.l.google.com", "74.125.192.27"], ["alt3.aspmx.l.google.com", "74.125.141.27"]],
+  #      40=>[["alt4.aspmx.l.google.com", "64.233.190.26"]]}
+  def dig_mxs
+    mxs = {}
+    Resolv::DNS.open do |dns|
+      res = dns.getresources(self,Resolv::DNS::Resource::IN::MX)
+      if res.size>0
+        res = res.sort {|a,b| a.preference<=>b.preference }
+        res.each do |mx|
+          mxs[mx.preference] ||= []
+          domain = mx.exchange.to_s
+          ip = domain.dig_a
+          mxs[mx.preference] << [domain,ip]
+        end
+      end
+    end
+    return mxs
+  end
+
+  # returns a publibdomainkey, or nil
+  # (there should only be one DKIM public key)
+  def dig_dk
+    Resolv::DNS.open do |dns|
+      txts = dns.getresources(self,Resolv::DNS::Resource::IN::TXT).collect { |r| r.strings }
+      if txts.empty? then nil else txts[0][0] end
+    end
+  end
+
+  # returns a reverse DNS hostname or nil
+  def dig_ptr
+    begin
+      Resolv.new.getname(self.downcase)
+    rescue Resolv::ResolvError
+      nil
+    end
+  end
+
+  # returns true if the IP is blacklisted; otherwise false
+  # examples:
+  # barracuda = 'b.barracudacentral.org'.blacklisted?(ip)
+  # spamhaus = 'zen.spamhaus.org'.blacklisted?(ip)
+  def blacklisted?(dx)
+    domain = dx.split('.').reverse.join('.')+"."+self
+    a = []
+    Resolv::DNS.open do |dns|
+      begin
+        a = dns.getresources(domain, Resolv::DNS::Resource::IN::A)
+      rescue Resolv::NXDomainError
+        a=[]
+      end
+    end
+    if a.size>0 then true else false end
+  end
+
+  # returns a UTF-8 encoded string -- be carefule using this with email:
+  # email has to be received and transported with NO changes, except the
+  # addition of extra headers at the beginning (before any DKIM headers)
+  def utf8
+    self.encode('UTF-8', 'binary', :invalid => :replace, :undef => :replace, :replace => '?')
+  end
+
+  # opens a socket to the IP/port to see if there is an SMTP server
+  # there - returns "250 ..." if the server is there, or 
+  # times out in 5 seconds to prevent hanging the process
+  def mta_live?(port)
+    tcp_socket = nil
+    welcome = nil
+    begin
+      Timeout.timeout(60) do
+        begin
+          tcp_socket = TCPSocket.open(self,port)
+        rescue Errno::ECONNREFUSED => e
+          return "421 Service not available (port closed)"
+        end
+        begin
+          welcome = tcp_socket.gets
+          return welcome if welcome[1]!='2'
+          tcp_socket.write("QUIT\r\n")
+          line = tcp_socket.gets
+          return line if line[1]!='2'
+        ensure
+          tcp_socket.close if tcp_socket
+        end
+      end
+      return "250 #{welcome.chomp[4..-1]}"
+    rescue SocketError => e
+      return "421 Service not available (#{e.to_s})"
+    rescue Timeout::Error => e
+      return "421 Service not available (#{e.to_s})"
+    end
+  end
+
+  # this validates a password with the base64 plaintext in an AUTH command
+  # encoded -> AGNvY29AY3phcm1haWwuY29tAG15LXBhc3N3b3Jk => ["coco@example.com", "my-password"]
+  # call UnixCrypt::SHA256.build("my-password")
+  # "my-password" --> "$5$BsHk6IIvndgdBmo9$iuO6WMaXzgzpGmGreV4uiH72VRGG1USNK/e5tL7P9jC"
+  # "AGNvY29AY3phcm1haWwuY29tAG15LXBhc3N3b3Jk".validate_plain { "$5$BsHk6IIvndgdBmo9$iuO6WMaXzgzpGmGreV4uiH72VRGG1USNK/e5tL7P9jC" } => "coco@example.com", true
+  def validate_plain
+    # decode and split up the username and password)
+    username, password = Base64::decode64(self).split("\x00")[1..-1]
+    return "", false if username.nil? || password.nil?
+    passwd_hash = yield(username) # get the hash
+    return username, false if passwd_hash.nil?
+    return username, UnixCrypt.valid?(password, passwd_hash)
+  end
+
+end

data/lib/rubymta/item_of_mail.rb

@@ -0,0 +1,113 @@
+require_relative 'base-x'
+require_relative 'deepclone'
+require "./config" # config.rb is in user space
+
+class SaveError < StandardError; end
+
+class ItemOfMail < Hash
+
+  include Config
+
+  def initialize(mail=nil)
+    if mail
+      # clone, if a mail is provided
+      mail.each {|k,v| self[k]=v.deepclone }
+    else
+      # assign a new message id for new mail
+      new_id = []
+      new_id[0] = Time.now.tv_sec.to_b(MessageIdBase)
+      new_id[1] = ("00000"+(2176782336*rand).to_i.to_b(MessageIdBase))[-6..-1]
+      new_id[2] = ("00"+(Time.now.usec/1000).to_i.to_b(MessageIdBase))[-2..-1]
+      self[:mail_id] = new_id.join("-")
+    end
+
+    # always set the time of creation
+    self[:time] = Time.now.strftime("%a, %d %b %Y %H:%M:%S %z")
+    self[:saved] = nil
+    self[:accepted] = nil
+  end
+
+  def parse_headers
+    self[:data][:headers] = {}
+    header = ""
+    self[:data][:text].each do |line|
+      case
+      when line.nil?
+        break
+      when line =~ /^[ \t]/
+        header << String::new(line)
+      when line.empty?
+        break
+      when !header.empty?
+        keyword, value = header.split(":", 2)
+        self[:data][:headers][keyword.downcase.gsub("-","_").to_sym] = value.strip
+        header = String::new(line)
+      else
+        header = String::new(line)
+      end
+    end
+    if !header.empty?
+      keyword, value = header.split(":", 2)
+      self[:data][:headers][keyword.downcase.gsub("-","_").to_sym] = if !value.nil? then value.strip else "" end
+    end
+  end
+
+  def insert_parcels
+    begin
+      return true if !self[:rcptto]
+      self[:rcptto].each do |rcptto|
+        # make entries into the database for tracking the deliveries
+        parcel = {}
+        parcel[:id] = nil
+        parcel[:mail_id] = self[:mail_id]
+        parcel[:from_url] = self[:mailfrom][:url]
+        parcel[:to_url] = rcptto[:url]
+        parcel[:delivery_msg] = rcptto[:message]
+        parcel[:retry_at] = nil
+        parcel[:delivery] = if rcptto[:accepted] then rcptto[:delivery].to_s else "none" end
+        parcel[:created_at] = parcel[:updated_at] = Time.now.strftime("%Y-%m-%d %H:%M:%S")
+        rcptto[:parcel_id] = S3DB[:parcels].insert(parcel)
+      end
+      return true
+    rescue => e
+      LOG.error(self[:mail_id]) {e.to_s}
+      e.backtrace.each { |line| LOG.error(self[:mail_id]) {line} }
+      return false
+    end
+  end
+
+  def update_parcels(parcels)
+    parcels.each { |parcel| S3DB[:parcels].where(:id=>parcel[:id]).update(parcel) }
+  end
+
+  def save_mail_into_queue_folder
+    begin
+      # save the mail in the Queue folder
+      File::open("#{MailQueue}/#{self[:mail_id]}","w") do |f|
+        self[:saved] = true
+        f.write(self.pretty_inspect)
+      end
+      return true
+    rescue => e
+      LOG.error(self[:mail_id]) {e.to_s}
+      e.backtrace.each { |line| LOG.error(self[:mail_id]) {line} }
+      return false
+    end
+  end
+
+  def self::retrieve_mail_from_queue_folder(mail_id)
+    item = nil
+    begin
+      mail = nil
+      File::open("#{MailQueue}/#{mail_id}","r") do |f|
+        mail = eval(f.read)
+        item = ItemOfMail::new(mail)
+      end
+    rescue => e
+      LOG.error(self[:mail_id]) {e.to_s}
+      e.backtrace.each { |line| LOG.error(self[:mail_id]) {line} }
+    end
+    return item
+  end
+
+end

data/lib/rubymta/queue_runner.rb

@@ -0,0 +1,376 @@
+require 'timeout'
+require 'pretty_inspect'
+require 'openssl'
+require 'logger'
+require 'pdkim'
+
+def manually_run_queue_runner
+  exit unless File::open(LockFilePath,"w").flock(File::LOCK_NB | File::LOCK_EX)
+  QueueRunner.new.run_queue
+end
+
+class QueueRunner
+
+  include Socket::Constants
+  include PDKIM
+
+  RetryInterval = 5*60;
+
+  def initialize
+  end
+
+  # send text to the client
+  def send_text(text,echo=:command)
+    puts "<-  #{text.inspect}" if DisplayQueueRunnerDialog
+    if text.class==Array
+      text.each do |line|
+        @connection.write(line+CRLF)
+        LOG.info(@mail_id) {"<-  %s"%text} if LogQueueRunnerConversation
+      end
+    else
+      @connection.write(text+CRLF)
+      LOG.info(@mail_id) {"<-  %s"%text} if LogQueueRunnerConversation
+    end
+  end
+
+  # receive text from the client
+  def recv_text
+    begin
+    lines = []
+    Timeout.timeout(QueueRunnerTimeout) do
+      tmp = @connection.gets
+      lines << (line = if tmp.nil? then "" else tmp.chomp end)
+      LOG.info((@mail_id)) {" -> %s"%line} if LogQueueRunnerConversation
+      while line[3]=='-'
+        tmp = @connection.gets
+        lines << (line = if tmp.nil? then "" else tmp.chomp end)
+        LOG.info((@mail_id)) {" -> %s"%line} if LogQueueRunnerConversation
+      end
+      ok = lines.last[0]
+      lines.each {|line| puts " -> #{line.inspect}"} if DisplayQueueRunnerDialog
+      return ok, lines
+    end
+    rescue Timeout::Error => e
+      raise "Fix this in transporter.rb::recv_text rescue"
+    end
+  end
+
+  def run_queue
+    @mail_id = nil
+    LOG.info(Time.now.strftime("%Y-%m-%d %H:%M:%S")) {"Queue runner started"}
+    n=3 # used for a sanity check
+    while true
+      # sqlite3 has a bug: "<=" doesn't work with time, ex. "retry_at<='#{Time.now}'"
+      # we have to add 1 second and use "<"; ex. "retry_at<'#{Time.now+1}'"
+      parcels = S3DB[:parcels].where("(delivery<>'none') and (delivery_at is null) and ((retry_at is null) or (retry_at<'#{Time.now + 1}'))").all
+      return if parcels.empty?
+
+      # aggregate the emails by destination domain
+      deliver = {}
+      parcels.each do |parcel|
+        if parcel[:delivery]!='none' && !parcel[:delivery_at]
+          mail_id = deliver[parcel[:mail_id]] ||= {}
+          domain = mail_id[parcel[:to_url].split('@')[1]] ||= {}
+          domain[parcel[:to_url]] = parcel
+        end
+      end
+
+      # send mail to each domain--success or failure will be
+      # handled in the respective mail routine
+      mail = {}
+      deliver.each do |mail_id, domains|
+        (mail = ItemOfMail::retrieve_mail_from_queue_folder(mail_id)) if mail[:mail_id]!=mail_id
+        domains.each do |domain, parcels|
+
+#=== compare before and after ======================================
+#puts "--> *2* domain=>#{domain.inspect}"
+#parcels.values.each { |parcel| puts "--> *3* #{parcel.inspect}" }
+#===================================================================
+
+          @mail_id = mail[:mail_id]
+          deliver_and_save_status(mail, domain, parcels.values)
+          @mail_id = nil
+
+#===================================================================
+#parcels.values.each { |parcel| puts "--> *4* #{parcel.inspect}" }
+#===================================================================
+        end
+      end
+      if (n-=1)<0
+        LOG.info(Time.now.strftime("%Y-%m-%d %H:%M:%S")) {"In QueueRunner, the loop repeated 3 times. Is somthing wrong?"}
+        return nil
+      end
+    end
+  ensure
+    LOG.info(Time.now.strftime("%Y-%m-%d %H:%M:%S")) {"Queue runner finished"}
+  end
+
+  def deliver_and_save_status(mail,domain,parcels)
+    # the methods lmtp_delivery and smtp_delivery will change
+    # the status upon successful delivery
+
+    # get the certificates, if any; they're needed for STARTTLS
+    $prv = if PrivateKey then OpenSSL::PKey::RSA.new File.read(PrivateKey) else nil end
+    $crt = if Certificate then OpenSSL::X509::Certificate.new File.read(Certificate) else nil end
+
+    # establish an SSL context
+    $ctx = OpenSSL::SSL::SSLContext.new
+    $ctx.key = $prv
+    $ctx.cert = $crt
+
+    begin
+      case parcels.first[:delivery]
+#==================================================
+      when "local"
+        begin
+          ssl_socket = TCPSocket.open('localhost',LocalLMTPPort)
+          @connection = OpenSSL::SSL::SSLSocket.new(ssl_socket, $ctx);
+          lmtp_delivery('localhost',LocalLMTPPort,mail,domain,parcels)
+          mail.update_parcels(parcels)
+        rescue Errno::ECONNREFUSED => e
+          LOG.info(@mail_id) {"Connection to localhost failed: #{e}"}
+          mark_parcels(parcels, "441 4.0.0 Connection to localhost failed")
+        end
+#==================================================
+      when "remote"
+        # this looks through the list of MXs and finds the
+        # first one that can communicate
+        mail[:rcptto].each do |rcptto|
+          if rcptto[:domain]==domain
+            rcptto[:mxs].each do |preference,pairs|
+              pairs.each do |mx,ip|
+                begin
+                  # open the connection
+                  ssl_socket = TCPSocket.open(mx,RemoteSMTPPort)
+                  @connection = OpenSSL::SSL::SSLSocket.new(ssl_socket, $ctx);
+                  smtp_delivery(mx, RemoteSMTPPort, mail, domain, parcels)
+                  mail.update_parcels(parcels)
+                  return
+                rescue Errno::ETIMEDOUT => e
+                  LOG.info(@mail_id) {"Service for #{mx} not available (timeout)"}
+                rescue Errno::ECONNREFUSED => e
+                  LOG.info(@mail_id) {"Service for #{mx} not available (refused)"}
+                end
+              end
+              # delivery was remote, and no MX was connectable
+              mark_parcels(parcels, "441 4.0.0 No MX for <#{domain}> has an operational mail server")
+            end
+          end
+        end
+#==================================================
+      when 'none'
+        # just ignore the email--it will not be delivered
+      else
+        # we didn't program a delivery option, so it got here
+        mark_parcels(parcels, "500 5.0.0 Delivery option '#{parcel[:delivery]} not supported")
+      end
+    rescue => e
+      LOG.info(@mail_id) {"Rescue #{e.inspect}"}
+      e.backtrace.each { |line| LOG.fatal(mail[:mail_id]) { line } }
+      mark_parcels(parcels, "441 4.0.0 Rescue #{e.inspect}")
+    end
+  ensure
+    if @connection
+      send_text("QUIT")
+      ok, lines = recv_text # ignore returns
+      @connection.close
+    end
+  end
+
+  def mark_parcels(parcels, responses)
+    response = if responses.kind_of?(Array) then responses.last else responses end
+    parcels.each do |parcel|
+      parcel[:delivery_at] = if response[0]!='4' then Time.now else nil end
+      parcel[:delivery_msg] = response
+      parcel[:retry_at] = if response[0]=='4' then Time.now + RetryInterval else nil end
+    end
+    nil
+  end
+
+# SAMPLE SMTP TRANSFER
+# <-  220 2.0.0 mail.xyz.com ESMTP Xyz, LLC 0.01 THU, 24 NOV 2016 20:22:39 +0000
+#  -> EHLO foo.com
+# <-  250-2.0.0 mail.xyz.com Hello foo.com at 213.33.76.136
+# <-  250-AUTH PLAIN
+# <-  250-STARTTLS
+# <-  250 HELP
+#---- This part is only if there is a logon/password supplied ----
+#  -> STARTTLS
+# <-  220 2.0.0 TLS go ahead
+# === TLS started with cipher TLSv1.2:DHE-RSA-AES256-GCM-SHA384:256
+# === TLS no local certificate set
+# === TLS peer DN="/C=US/ST=CA/L=Los Angeles/O=Xyz, LLC/CN=xyz.com/emailAddress=admin@xyz.com"
+#  ~> EHLO foo.com
+# <~  250-2.0.0 mail.xyz.com Hello foo.com at 213.33.76.136
+# <~  250-AUTH PLAIN
+# <~  250 HELP
+#  ~> MAIL FROM:John Q. Public <JQP@foo.com>
+# <~  250 2.0.0 OK
+#  ~> RCPT TO:<Jones@xyz.com>
+# <~  250 2.0.0 OK
+#  ~> DATA
+# <~  354 Enter message, ending with "." on a line by itself
+#  ~> Date: Thu, 24 Nov 2016 12:22:39 -0800
+#  ~> To: Jones@xyz.com
+#  ~> From: John Q. Public <JQP@bar.com>
+#  ~> Subject: test Thu, 24 Nov 2016 12:22:39 -0800
+#  ~> 
+#  ~> Bill:
+#  ~>  The next meeting of the board of directors will be
+#  ~>  on Tuesday.
+#  ~>                          John.
+#  ~> .
+# <~  250 OK
+#  ~> QUIT
+# <~  221 2.0.0 OK mail.xyz.com closing connection
+
+  def smtp_delivery(host, port, mail, domain, parcels, username=nil, password=nil)
+    LOG.info(@mail_id) {"Beginning delivery of #{mail[:id]} to remote server at #{host}"}
+
+    # receive the server's welcome message
+    ok, lines = recv_text
+    return mark_parcels(parcels, lines) if ok!='2'
+
+    # send the EHLO
+    send_text("EHLO #{mail[:local_hostname]}")
+    ok, lines = recv_text
+    return mark_parcels(parcels, lines) if ok!='2'
+
+    # check for STARTTLS supported by server
+    if !lines.select{ |line| line.index("STARTTLS") }.empty?
+      send_text("STARTTLS")
+      ok, lines = recv_text
+      return mark_parcels(parcels, lines) if ok!='2'
+
+      # enable TLS
+      @connection.connect
+      LOG.info(@mail_id) {"<-> (handshake)"}
+
+      send_text("EHLO #{mail[:local_hostname]}")
+      ok, lines = recv_text
+      return mark_parcels(parcels, lines) if ok!='2'
+    end
+
+    # AUTH PLAIN -- log onto server
+    if username
+      user_pass = Base64::encode64("\0#{username}\0#{password}").chomp
+      send_text("AUTH PLAIN #{user_pass}")
+      ok, lines = recv_text
+      return mark_parcels(parcels, lines) if ok!='2'
+    end
+
+    # MAIL FROM
+    send_text("MAIL FROM:<#{mail[:mailfrom][:url]}>")
+    ok, lines = recv_text
+    return mark_parcels(parcels, lines) if ok!='2'
+
+    # RCPT TO
+    parcels.each do |parcel|
+      send_text("RCPT TO:<#{parcel[:to_url]}>")
+      ok, lines = recv_text
+      # if there's a problem, we mark this parcel (recipient), but keep processing others
+      mark_parcels(parcels, lines) if ok!='2'
+    end
+
+    # DATA -- send the email
+    send_text("DATA")
+    ok, lines = recv_text
+    return mark_parcels(parcels, lines) if ok!='3'
+
+    LOG.info(@mail_id) {"<-  (data)"} if LogQueueRunnerConversation
+    mail[:data][:text].each do |line|
+      send_text(line, :data)
+    end
+
+    # send the end of the message prompt
+    send_text(".", :data)
+
+    # get one final message for all parcels (recipients)
+    ok, lines = recv_text
+    return mark_parcels(parcels, lines)
+  end
+
+# SAMPLE LMTP TRANSFER
+# <-  220 foo.edu LMTP server ready
+#  -> LHLO foo.edu
+# <-  250-foo.edu
+# <-  250-PIPELINING
+# <-  250 SIZE
+#  -> MAIL FROM:<chris@bar.com>
+# <-  250 OK
+#  -> RCPT TO:<pat@foo.edu>
+# <-  250 OK
+#  -> RCPT TO:<jones@foo.edu>
+# <-  550 No such user here
+#  -> RCPT TO:<green@foo.edu>
+# <-  250 OK
+#  -> DATA
+# <~  354 Enter message, ending with "." on a line by itself
+#  ~> Date: Thu, 24 Nov 2016 12:22:39 -0800
+#  ~> To: Jones@xyz.com
+#  ~> From: John Q. Public <JQP@bar.com>
+#  ~> Subject: test Thu, 24 Nov 2016 12:22:39 -0800
+#  ~> 
+#  ~> Bill:
+#  ~>  The next meeting of the board of directors will be
+#  ~>  on Tuesday.
+#  ~>                          John.
+#  ~> .
+# <~  250 OK
+# <-  452 <green@foo.edu> is temporarily over quota (reply for <green@foo.edu>)
+#  -> QUIT
+# <-  221 foo.edu closing connection
+#
+# Note: there was no reply for <jones@foo.edu> because it failed in the RCPT TO command
+
+  # domain (for local) is 'localhost', and parcels is an array of hashes (recipients) --
+  # the single key is the domain to which to send the email -- since all recipients
+  # are in the same domain, we can send only one email with all recipients named in
+  # RCPT TOs -- this delivery is for Dovecot, so we believe the domain is 'ServerName'
+  def lmtp_delivery(host, port, mail, domain, parcels)
+    LOG.info(@mail_id) {"Beginning delivery of #{mail[:mail_id]} to Dovecot at #{ServerName}"}
+
+    # receive the server's welcome message
+    ok, lines = recv_text
+    return mark_parcels(parcels, lines) if ok!='2'
+
+    # send the LHLO
+    send_text("LHLO #{mail[:local_hostname]}")
+    ok, lines = recv_text
+    return mark_parcels(parcels, lines) if ok!='2'
+
+    # MAIL FROM
+    send_text("MAIL FROM:<#{mail[:mailfrom][:url]}>")
+    ok, lines = recv_text
+    return mark_parcels(parcels, lines) if ok!='2'
+
+    # RCPT TO
+    parcels.each do |parcel|
+      send_text("RCPT TO:<#{parcel[:to_url]}>")
+      ok, lines = recv_text
+      # if there's a problem, we mark this pacel (recipient), but keep processing others
+      mark_parcels([parcel], lines) if ok!='2'
+    end
+
+    # DATA -- send the email
+    send_text("DATA")
+    ok, lines = recv_text
+    return mark_parcels(parcels, lines) if ok!='3'
+
+    LOG.info(@mail_id) {"<-  (data)"} if LogQueueRunnerConversation
+    mail[:data][:text].each do |line|
+      send_text(line, :data)
+    end
+
+    # send the end of the message prompt
+    send_text(".", :data)
+
+    # get one final message for each recipient
+    parcels.each do |parcel|
+      # get the response from DoveCot
+      ok, lines = recv_text
+      mark_parcels([parcel], lines)
+    end
+  end
+
+end