gurgitate-mail 1.10.9 → 1.10.10

data/lib/gurgitate/deliver/maildir.rb

@@ -0,0 +1,104 @@
+#!/opt/bin/ruby -w
+
+#------------------------------------------------------------------------
+# Deliver mail to a maildir (also, detects maildir)
+#------------------------------------------------------------------------
+
+require "socket" # for gethostname (!)
+
+module Gurgitate
+    module Deliver
+        module Maildir
+            # Figures out if +mailbox+ is a Maildir mailbox
+            # mailbox::
+            #   A string containing the path of the mailbox to save the
+            #   message to.  If it is of the form "=mailbox", it saves
+            #   the message to +Maildir+/+mailbox+.  Otherwise, it
+            #   simply saves the message to the file +mailbox+.
+            def self::check_mailbox mailbox
+                begin
+                    if File.stat(mailbox).directory? then
+                        if File.stat(File.join(mailbox,"cur")).directory? then
+                            return Maildir
+                        end
+                    end
+                rescue Errno::ENOENT
+                    return nil
+                end
+            end
+
+            # Figures out the first available filename in the mail dir
+            # +dir+ and returns the filename to use.
+            # dir::
+            #   One of "+mailbox+/tmp" or "+mailbox+/new", but that's
+            #   only because that's what the maildir spec
+            #   (http://cr.yp.to/proto/maildir.html) says.
+            def maildir_getfilename dir
+                time=Time.now.to_f
+                counter=0
+                hostname=Socket::gethostname
+                filename=nil
+                loop do
+                    filename=File.join(dir,sprintf("%.4f.%d_%d.%s",
+                                                   time,$$,counter,hostname))
+                    break if not File.exist?(filename)
+                    counter+=1
+                end
+                return filename
+            end
+
+            # Creates a new Maildir folder +mailbox+
+            # mailbox::
+            #   The full path of the new folder to be created
+            def make_mailbox mailbox
+                Dir.mkdir(mailbox)
+                %w{cur tmp new}.each do |dir|
+                    Dir.mkdir(File.join(mailbox,dir))
+                end
+            end
+
+            # Delivers a message to the maildir-format mailbox +mailbox+.
+            # mailbox::
+            #   A string containing the path of the mailbox to save the
+            #   message to.  If it is of the form "=mailbox", it saves
+            #   the message to +Maildir+/+mailbox+.  Otherwise, it
+            #   simply saves the message to the file +mailbox+.
+            def deliver_message mailbox
+                begin
+                    File.stat(mailbox)
+                rescue Errno::ENOENT
+                    make_mailbox(mailbox)
+                end
+
+                unless File.stat(mailbox).directory?
+                    raise SystemError, 'not a directory'
+                end
+
+                tmpfilename=maildir_getfilename(File.join(mailbox,"tmp"))
+                File.open(tmpfilename,File::CREAT|File::WRONLY) do |fh|
+                    fh.write(self.to_s)
+                    fh.flush
+                    # I should put a caveat here, unfortunately.  Ruby's
+                    # IO#flush only flushes Ruby's buffers, not the
+                    # operating system's.  If anyone knows how to force
+                    # a real fflush(), I'd love to know.  Otherwise, I'm
+                    # going to hope that closing the file does the trick
+                    # for me.
+                end
+
+                # ...and link to new.
+                # (I guess Maildir mailboxes don't work too well
+                # on Windows, eh?)
+                newfilename = maildir_getfilename(
+                                        File.join(mailbox,"new"))
+                begin
+                    File.link(tmpfilename,newfilename)
+                rescue SystemCallError
+                    log("Couldn't create maildir link to \"new\"!")
+                    exit 75 # Argh, I tried, it didn't work out
+                end
+                File.delete(tmpfilename)
+            end
+        end
+    end
+end

data/lib/gurgitate/deliver/mbox.rb

@@ -0,0 +1,47 @@
+#!/opt/bin/ruby -w
+
+#------------------------------------------------------------------------
+# Delivers a message to an mbox (also includes mbox detector)
+#------------------------------------------------------------------------
+
+module Gurgitate
+    module Deliver
+        module MBox
+            # Checks to see if +mailbox+ is an mbox mailbox
+            # mailbox::
+            #   A string containing the path of the mailbox to save
+            #   the message to.  If it is of the form "=mailbox", it
+            #   saves the message to +Maildir+/+mailbox+.  Otherwise,
+            #   it simply saves the message to the file +mailbox+.
+            def self::check_mailbox mailbox
+
+                begin
+                    if File.stat(mailbox).file? then
+                        return MBox
+                    else
+                        return nil
+                    end
+                rescue Errno::ENOENT
+                    return nil
+                end
+            end
+
+            # Delivers the message to +mailbox+
+            # mailbox::
+            #   A string containing the path of the mailbox to save
+            #   the message to.  If it is of the form "=mailbox", it
+            #   saves the message to +Maildir+/+mailbox+.  Otherwise,
+            #   it simply saves the message to the file +mailbox+.
+            def deliver_message mailbox
+                File.open(mailbox,File::WRONLY |
+                                  File::APPEND |
+                                  File::CREAT) do |f|
+                    f.flock(File::LOCK_EX)
+                    message=(if f.stat.size > 0 then "\n" else "" end) + to_mbox
+                    f.print message
+                    f.flock(File::LOCK_UN)
+                end
+            end
+        end
+    end
+end

data/lib/gurgitate/deliver/mh.rb

@@ -0,0 +1,147 @@
+#!/opt/bin/ruby -w
+
+require "yaml"
+
+#------------------------------------------------------------------------
+# Delivers a message to an mbox (also includes mbox detector)
+#------------------------------------------------------------------------
+
+module Gurgitate
+    module Deliver
+        module MH
+            # Checks to see if +mailbox+ is an mbox mailbox
+            # mailbox::
+            #   A string containing the path of the mailbox to save
+            #   the message to.  If it is of the form "=mailbox", it
+            #   saves the message to +Maildir+/+mailbox+.  Otherwise,
+            #   it simply saves the message to the file +mailbox+.
+            def self::check_mailbox mailbox
+                begin
+                    # Rather annoyingly, pretty well any directory can
+                    # be a MH mailbox, but this just checks to make sure
+                    # it's not actually a Maildir by mistake.
+                    #
+                    # I could put in a check for the path given in
+                    # $HOME/.mh_profile, but Claws-Mail uses MH mailboxes and
+                    # disregards $HOME/.mh_profile.
+                    if( File.stat(mailbox).directory? and
+                        not ( File.exists?(File.join(mailbox, "cur")) or
+                              File.exists?(File.join(mailbox, "tmp")) or
+                              File.exists?(File.join(mailbox, "new")) ) ) then
+                        return MH
+                    end
+                rescue Errno::ENOENT
+                    return nil
+                end
+            end
+
+            # Delivers the message to +mailbox+
+            # mailbox::
+            #   A string containing the path of the mailbox to save
+            #   the message to.  If it is of the form "=mailbox", it
+            #   saves the message to +Maildir+/+mailbox+.  Otherwise,
+            #   it simply saves the message to the file +mailbox+.
+            def deliver_message mailbox
+                if ! File.exists? mailbox then
+                    Dir.mkdir(mailbox)
+                end
+
+                if File.exists? mailbox and not File.directory? mailbox then
+                    raise SystemError, "not a directory"
+                end
+
+                new_msgnum = next_message(mailbox) do |filehandle|
+                    filehandle.print self.to_s
+                end
+
+                update_sequences(mailbox, new_msgnum)
+            end
+
+            private
+
+            def update_sequences mailbox, msgnum
+                sequences = File.join(mailbox, ".mh_sequences")
+                lockfile = sequences + ".lock" # how quaint
+                counter=0
+                while counter < 10 do
+                    begin
+                        File.open(lockfile,
+                                  File::WRONLY |
+                                  File::CREAT |
+                                  File::EXCL ) do |lock|
+                            File.open(sequences,
+                                      File::RDWR | File::CREAT) do |seq|
+
+                                seq.flock(File::LOCK_EX)
+                                metadata = YAML.load(seq.read) || Hash.new
+
+                                metadata["unseen"] = update_unseen \
+                                    metadata["unseen"], msgnum
+
+                                seq.rewind
+                                metadata.each do |key, val|
+                                    seq.puts "#{key}: #{val}"
+                                end
+                                seq.truncate seq.tell
+                                seq.flock(File::LOCK_UN)
+                            end
+                        end
+
+                        File.unlink lockfile
+                        break
+                    rescue Errno::EEXIST
+                        # some other process is doing something, so wait a few
+                        # milliseconds until it's done
+                        counter += 1
+                        sleep(0.1)
+                    end
+                end
+
+                # If it's still around after 10 tries, then obviously 
+                # something bigger went wrong; forcibly remove it and
+                # try again.
+                if counter == 10 then
+                    File.unlink lockfile
+                    update_sequences mailbox, msgnum
+                end
+            end
+
+            def update_unseen unseen, msgnum
+                prevmsg = msgnum - 1
+                if unseen
+                    unseenstring = unseen.to_s
+
+                    if unseenstring =~ /-#{prevmsg}/ then
+                        return unseenstring.sub(/\b#{prevmsg}\b/, msgnum.to_s)
+                    end
+
+                    if unseenstring.match(/\b#{prevmsg}\b/) then
+                        return "#{unseenstring}-#{msgnum}"
+                    end
+
+                    return "#{unseenstring} #{msgnum}"
+                else
+                    return msgnum
+                end
+            end
+
+            def next_message mailbox
+                next_msgnum = Dir.open(mailbox).map { |ent| ent.to_i }.max + 1
+                loop do
+                    begin
+                        File.open(File.join(mailbox, next_msgnum.to_s),
+                                  File::WRONLY |
+                                  File::CREAT |
+                                  File::EXCL ) do |filehandle|
+                            yield filehandle
+                        end
+                        break
+                    rescue Errno::EEXIST
+                        next_msgnum += 1
+                    end
+                end
+                return next_msgnum
+            end
+        end
+    end
+end

data/lib/gurgitate/header.rb

@@ -0,0 +1,82 @@
+#!/opt/bin/ruby -w
+# -*- encoding : utf-8 -*-
+
+module Gurgitate
+    class IllegalHeader < RuntimeError ; end
+
+    # A little class for a single header
+    class Header
+        # The name of the header
+        attr_accessor :name
+        # The contents of the header
+        attr_accessor :contents
+
+        alias_method :value, :contents
+
+        # A recent rash of viruses has forced me to canonicalize
+        # the capitalization of headers.  Sigh.
+        def capitalize_words(s)
+            return s.split(/-/).map { |w| w.capitalize }.join("-")
+          rescue
+            return s
+        end
+
+        private :capitalize_words
+
+        # Creates a Header object.
+        # header::
+        #   The text of the email-message header
+        def initialize(*header)
+            name,contents=nil,nil
+            if header.length == 1 then
+                # RFC822 says that a header consists of some (printable,
+                # non-whitespace) crap, followed by a colon, followed by
+                # some more (printable, but can include whitespaces)
+                # crap.
+                if(header[0] =~ /^[\x21-\x39\x3b-\x7e]+:/) then
+                    (name,contents)=header[0].split(/:\s*/,2)
+                    if(name =~ /:$/ and contents == nil) then
+                        # It looks like someone is using Becky!
+                        name=header[0].gsub(/:$/,"")
+                        contents = ""
+                    end
+
+                    raise IllegalHeader, "Empty name" \
+                        if (name == "" or name == nil)
+                    contents="" if contents == nil
+
+                    @@lastname=name
+                else
+                    raise IllegalHeader, "Bad header syntax: no colon in #{header}"
+                end
+            elsif header.length == 2 then
+                name,contents = *header
+            end
+
+            @name=capitalize_words(name)
+            @contents=contents
+        end
+
+        # Extended header
+        def << (text)
+            @contents += "\n" + text
+        end
+
+        # Matches a header's contents.
+        # regex::
+        #   The regular expression to match against the header's contents
+        def matches (regex)
+            if String === regex
+                regex = Regexp.new(Regexp.escape(regex))
+            end
+            @contents =~ regex
+        end
+
+        alias :=~ :matches
+
+        # Returns the header, ready to put into an email message
+        def to_s
+            @name+": "+@contents
+        end
+    end
+end

data/lib/gurgitate/headers.rb

@@ -0,0 +1,283 @@
+#!/opt/bin/ruby -w
+# -*- encoding : utf-8 -*-
+
+require "gurgitate/header"
+
+module Gurgitate
+    class IllegalHeader < RuntimeError ; end
+
+# ========================================================================
+
+    class HeaderBag < Array
+        def =~(regex)
+            inject(false) do |y,x|
+                y or ( ( x =~ regex ) != nil )
+            end
+        end
+
+        def sub!(regex, replacement)
+            each do |header|
+                header.contents = header.contents.sub regex, replacement
+            end
+        end
+        
+        def sub(regex, replacement)
+            ::Gurgitate::HeaderBag.new(
+                clone.map do |header|
+                    ::Gurgitate::Header.new(
+                        "#{header.name}: " + header.contents.sub(regex, 
+                                                                 replacement)
+                    )
+                end
+            )
+        end
+
+        def to_s
+            map do |member|
+                member.to_s
+            end.join ""
+        end
+
+    end
+
+    # A slightly bigger class for all of a message's headers
+    class Headers
+
+        private
+
+        # Figures out whether the first line of a mail message is an
+        # mbox-style "From " line (say, if you get this from sendmail),
+        # or whether it's just a normal header.
+        # --
+        # If you run "fetchmail" with the -m option to feed the
+        # mail message straight to gurgitate, skipping the "local
+        # MTA" step, then it doesn't have a "From " line.  So I
+        # have to deal with that by hand.  First, check to see if
+        # there's a "From " line present in the first place.
+        def figure_out_from_line(headertext)
+            (unix_from,normal_headers)  = headertext.split(/\n/,2)
+
+            if unix_from =~ /^From /  then
+                headertext=normal_headers
+                unix_from=unix_from
+            else
+                # If there isn't, then deal with it after we've
+                # worried about the rest of the headers, 'cos we'll
+                # have to make our own.
+                unix_from=nil
+            end
+            return unix_from, headertext
+        end
+
+        def parse_headers
+            @headertext.each_line do |h|
+                h.chomp!
+                if(h=~/^\s+/) then
+                    @lastheader << h
+                else
+                    header=Header.new(h)
+                    @headers[header.name] ||= HeaderBag.new
+                    @headers[header.name].push(header)
+                    @lastheader=header
+                end
+            end
+
+            @headers_changed=false
+        end
+
+        # Get the envelope From information.  This comes with a
+        # whole category of rants: this information is absurdly hard
+        # to get your hands on.  The best you can manage is a sort
+        # of educated guess.  Thus, this horrible glob of hackiness.
+        # I don't recommend looking too closely at this code if you
+        # can avoid it, and further I recommend making sure to
+        # configure your MTA so that it sends proper sender and
+        # recipient information to gurgitate so that this code never
+        # has to be run at all.
+        def guess_sender
+            # Start by worrying about the "From foo@bar" line.  If it's
+            # not there, then make one up from the Return-Path: header.
+            # If there isn't a "Return-Path:" header (then I suspect we
+            # have bigger problems, but still) then use From: as a wild
+            # guess.  If I hope that this entire lot of code doesn't get
+            # used, then I _particularly_ hope that things never get so
+            # bad that poor gurgitate has to use the From: header as a
+            # source of authoritative information on anything.
+            #
+            # And then after all that fuss, if we're delivering to a
+            # Maildir, I have to get rid of it.  And sometimes the MTA
+            # gives me a mbox-style From line and sometimes it doesn't.
+            # It's annoying, but I have no choice but to Just Deal With
+            # It.
+            if @unix_from then
+                # If it is there, then grab the email address in it and
+                # use that as our official "from".
+                fromregex=/^From ([^ ]+@[^ ]+) /
+                fromregex.match(@unix_from)
+                @from=$+
+
+                # or maybe it's local
+                if @from == nil then
+                    @unix_from =~ /^From (\S+) /
+                    @from=$+
+                end
+            else
+                fromregex=/([^ ]+@[^ ]+) \(.*\)|[^<]*[<](.*@.*)[>]|([^ ]+@[^ ]+
+)/
+                if self["Return-Path"] != nil then
+                    fromregex.match(self["Return-Path"][0].contents)
+                else
+                    if self["From"] != nil then
+                        fromregex.match(self["From"][0].contents)
+                    end
+                end
+                address_candidate=$+
+
+                # If there STILL isn't a match, then it's probably safe to
+                # assume that it's local mail, and doesn't have an @ in its
+                # address.
+                unless address_candidate
+                    if self["Return-Path"] then
+                        self["Return-Path"][0].contents =~ /(\S+)/
+                        address_candidate=$+
+                    else
+                        if self["From"] then
+                            self["From"][0].contents =~ /(\S+)/
+                                address_candidate=$+
+                        end
+                    end
+                end
+
+                @from=address_candidate
+
+                @unix_from="From "+self.from+" "+Time.new.to_s
+            end
+        end
+
+        public
+
+        # Creates a Headers object.
+        # headertext::
+        #   The text of the message headers.
+        def initialize(headertext=nil, sender=nil, recipient=nil)
+            @from    = sender
+            @to      = recipient
+            @headers = Hash.new(nil)
+
+            if Hash === headertext
+                @headers_changed = true
+                headertext.each_key do |key|
+
+                    headername = key.to_s.gsub("_","-")
+
+                    header=Header.new(headername, headertext[key])
+                    @headers[header.name] ||= HeaderBag.new
+                    @headers[header.name].push(header)
+                end
+            else
+                if headertext
+                    @unix_from, @headertext = figure_out_from_line headertext
+                    parse_headers if @headertext
+
+                    if sender # then don't believe the mbox separator
+                        @from = sender
+                        @unix_from="From "+self.from+" "+Time.new.to_s
+                    else
+                        guess_sender
+                    end
+                end
+            end
+        end
+
+        # Grab the headers with names +names+
+        # names:: The names of the header.
+        def [](*names)
+            if names.inject(false) do |accum,name| 
+                accum or @headers.has_key? name
+            end then
+                return HeaderBag.new(names.collect { |name| 
+                        @headers[name] 
+                    }.flatten.delete_if { |e| e == nil } )
+            else
+                return nil
+            end
+        end
+
+        # Set the header named +name+ to +value+
+        # name:: The name of the header.
+        # value:: The new value of the header.
+        def []=(name,value)
+            @headers_changed = true
+            @headers[name]=HeaderBag.new([Header.new(name,value)])
+        end
+
+        # Who the message is to (the envelope to)
+        #
+        # Yet another bucket of rants.  Unix mail sucks.
+        def to
+            return @to || @headers["X-Original-To"] || nil
+        end
+
+        # Who the message is from (the envelope from)
+        def from
+            return @from || ""
+        end
+
+        # Change the envelope from line to whatever you want.  This might
+        # not be particularly neighborly, but oh well.
+        # newfrom:: An email address
+        def from=(newfrom)
+            @from=newfrom
+            @unix_from="From "+self.from+" "+Time.new.to_s
+        end
+
+        # Match header +name+ against +regex+
+        # name:: 
+        #   A string containing the name of the header to match (for example,
+        #   "From")
+        # regex:: The regex to match it against (for example, /@aol.com/)
+        def match(name,regex)
+            ret=false
+            if(@headers[name]) then
+                @headers[name].each do |h|
+                    ret |= h.matches(regex)
+                end
+            end
+            return ret
+        end
+
+        # Return true if headers +names+ match +regex+
+        # names:: An array of header names (for example, %w{From Reply-To})
+        # regex:: The regex to match the headers against.
+        def matches(names,regex)
+            ret=false
+
+            if names.class == String then
+                names=[names]
+            end
+
+            names.each do |n|
+                ret |= match(n,regex)
+            end
+            return ret
+        end
+
+        # Returns the headers properly formatted for an email
+        # message.
+        def to_mbox
+            return @unix_from+"\n"+to_s
+        end
+
+        # Returns the headers formatted for an email message (without
+        # the "From " line
+        def to_s
+            if @headers_changed then
+                return @headers.map do |name,hdr|
+                    hdr.map do |hdr_content| hdr_content.to_s end.join("\n")
+                end.join("\n")
+            else
+                return @headertext
+            end
+        end
+    end
+end