gurgitate-mail 1.7.2

data/bin/gurgitate-mail

@@ -0,0 +1,40 @@
+#!./bin/ruby -w
+
+#------------------------------------------------------------------------
+# Mail filter invocation script
+#------------------------------------------------------------------------
+
+require "gurgitate-mail"
+require 'optparse'
+
+# change this on installation to taste
+GLOBAL_RULES="/etc/gurgitate-rules"
+GLOBAL_RULES_POST="/etc/gurgitate-rules-default"
+
+commandline_files = []
+
+opts = OptionParser.new do |o|
+  o.on("-f FILE", "--file FILE", "Use FILE as a rules file") do |file|
+    commandline_files << file
+  end
+  o.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+end
+
+opts.parse!(ARGV)
+
+gurgitate = Gurgitate::Gurgitate.new(STDIN)
+
+if commandline_files.length > 0
+  commandline_files.each do |file|
+    gurgitate.add_rules(file, :user => true)
+  end
+else
+  gurgitate.add_rules(GLOBAL_RULES, :system => true)
+  gurgitate.add_rules(:default)
+  gurgitate.add_rules(GLOBAL_RULES_POST, :system => true)
+end
+
+gurgitate.process

data/lib/gurgitate-mail.rb

@@ -0,0 +1,262 @@
+#!/opt/bin/ruby
+#------------------------------------------------------------------------
+# Mail filter package
+#------------------------------------------------------------------------
+
+require 'etc'
+
+require 'gurgitate/mailmessage'
+require 'gurgitate/deliver'
+
+module Gurgitate
+    #========================================================================
+    # The actual gurgitator; reads a message and then it can do
+    # other stuff with it, like save to a mailbox or forward
+    # it somewhere else.
+    class Gurgitate < Mailmessage
+        include Deliver
+
+        # Instead of the usual attributes, I went with a
+        # reader-is-writer type thing (as seen quite often in Perl and
+        # C++ code) so that in your .gurgitate-rules, you can say
+        # 
+        # maildir "#{homedir}/Mail"
+        # sendmail "/usr/sbin/sendmail"
+        # spoolfile "Maildir"
+        # spooldir homedir
+        #
+        # This is because of an oddity in Ruby where, even if an
+        # accessor exists in the current object, if you say:
+        #    name = value
+        # it'll always create a local variable.  Not quite what you
+        # want when you're trying to set a config parameter.  You have
+        # to say "self.name = value", which (I think) is ugly.
+        #
+        # In the interests of promoting harmony, of course, the previous
+        # syntax will continue to work.
+        def self.attr_configparam(*syms)
+            syms.each do |sym|
+                class_eval %{
+                    def #{sym} (*vals)
+                        if vals.length == 1
+                            @#{sym} = vals[0]
+                        elsif vals.length == 0
+                            @#{sym}
+                        else
+                            raise ArgumentError, 
+                                "wrong number of arguments " +
+                                "(\#{vals.length} for 0 or 1)"
+                        end
+                    end
+
+                    # Don't break it for the nice people who use 
+                    # old-style accessors though.  Breaking people's
+                    # .gurgitate-rules is a bad idea.
+                    attr_writer :#{sym}
+                }
+            end
+        end
+
+        # The directory you want to put mail folders into
+        attr_configparam :maildir
+
+        # The path to your log file
+        attr_configparam :logfile
+
+        # The full path of your "sendmail" program
+        attr_configparam :sendmail
+
+        # Your home directory
+        attr_configparam :homedir 
+
+        # Your default mail spool
+        attr_configparam :spoolfile
+
+        # The directory where user mail spools live
+        attr_configparam :spooldir
+
+        # What kind of mailboxes you prefer
+        # attr_configparam :folderstyle
+
+        # What kind of mailboxes you prefer
+        def folderstyle(*style)
+            if style.length == 0 then
+                style[0]
+            elsif style.length == 1 then
+                if style[0] == Maildir then
+                    spooldir homedir
+                    spoolfile File.join(spooldir,"Maildir")
+                else
+                    spooldir "/var/spool/mail"
+                    spoolfile File.join(spooldir, @passwd.name)
+                end
+            else
+                raise ArgumentError, "wrong number of arguments "+
+                                     "(#{style.length} for 0 or 1)"
+            end
+
+            @folderstyle = style[0]
+        end
+
+        # Set config params to defaults, read in mail message from
+        # +input+
+        # input::
+        #   Either the text of the email message in RFC-822 format,
+        #   or a filehandle where the email message can be read from
+        # spooldir::
+        #   The location of the mail spools directory.
+        def initialize(input=nil,spooldir="/var/spool/mail",&block)
+            @passwd      = Etc.getpwuid
+            @homedir     = @passwd.dir;
+            @maildir     = File.join(@passwd.dir,"Mail")
+            @logfile     = File.join(@passwd.dir,".gurgitate.log")
+            @sendmail    = "/usr/lib/sendmail"
+            @spooldir    = spooldir
+            @spoolfile   = File.join(@spooldir,@passwd.name )
+            @folderstyle = MBox
+            @rules       = []
+
+            input_text = ""
+            input.each do |l| input_text << l end
+            super(input_text)
+            instance_eval(&block) if block_given?
+        end
+
+        def add_rules(filename, options = {})
+            if not Hash === options
+                raise ArgumentError.new("Expected hash of options")
+            end
+            if filename == :default
+                filename=homedir+"/.gurgitate-rules"
+            end
+            if not FileTest.exist?(filename)
+                filename = filename + '.rb'
+            end
+            if not FileTest.exist?(filename)
+              if options.has_key?(:user)
+                log("#{filename} does not exist.")
+              end
+              return false
+            end
+            if FileTest.file?(filename) and
+                ( ( not options.has_key? :system and
+                    FileTest.owned?(filename) ) or
+                  ( options.has_key? :system and
+                    options[:system] == true and
+                    File.stat(filename).uid == 0 ) ) and
+                FileTest.readable?(filename)
+                @rules << filename
+            else
+                log("#{filename} has bad permissions or ownership, not using rules")
+                return false
+            end
+        end
+
+        # Deletes the current message.
+        def delete
+            # Well, nothing here, really.
+        end
+
+        # This is a neat one.  You can get any header as a method.
+        # Say, if you want the header "X-Face", then you call
+        # x_face and that gets it for you.  It raises NameError if
+        # that header isn't found.
+        # meth::
+        #   The method that the caller tried to call which isn't
+        #   handled any other way.
+        def method_missing(meth)
+            headername=meth.to_s.split(/_/).map {|x| x.capitalize}.join("-")
+            if defined?(headers[headername]) then
+                return headers[headername]
+            else
+                raise NameError,"undefined local variable or method, or header not found `#{meth}' for #{self}:#{self.class}"
+            end
+        end
+
+        # Forwards the message to +address+.
+        # address::
+        #   A valid email address to forward the message to.
+        def forward(address)
+            self.log "Forwarding to "+address
+            IO.popen(@sendmail+" "+address,"w") do |f|
+                f.print(self.to_s)
+            end
+        end
+
+        # Writes +message+ to the log file.
+        def log(message)
+            if(@logfile)then
+                File.open(@logfile,"a") do |f|
+                    f.flock(File::LOCK_EX)
+                    f.print(Time.new.to_s+" "+message+"\n")
+                    f.flock(File::LOCK_UN)
+                end
+            end
+        end
+
+        # Pipes the message through +program+.  If +program+
+        # fails, puts the message into +spoolfile+
+        def pipe(program)
+            self.log "Piping through "+program
+            IO.popen(program,"w") do |f|
+                f.print(self.to_s)
+            end
+            return $?>>8
+          rescue SystemCallError
+            save(spoolfile())
+            return -1
+        end
+
+        # Pipes the message through +program+, and returns another
+        # +Gurgitate+ object containing the output of the filter
+        def filter(program,&block)
+            self.log "Filtering with "+program
+            IO.popen("-","w+") do |filter|
+                if filter.nil? then
+                    exec(program)
+                else
+                    if fork
+                        filter.close_write
+                        g=Gurgitate.new(filter)
+                        g.instance_eval(&block) if block_given?
+                        return g
+                    else
+                        filter.close_read
+                        filter.print(self.to_s)
+                        filter.close
+                        exit
+                    end
+                end
+            end
+          rescue SystemCallError
+            save(Spoolfile)
+            return nil
+        end
+
+        # Processes your .gurgitate-rules.rb.
+        def process(&block)
+            if @rules.size > 0 or block
+                @rules.each do |configfilespec|
+                    begin
+                        eval File.new(configfilespec).read, nil,
+                            configfilespec
+                        save(spoolfile)
+                    rescue ScriptError
+                        log "Couldn't load #{configfilespec}: "+$!
+                        save(spoolfile)
+                    rescue Exception
+                        log "Error while executing #{configfilespec}: #{$!}"
+                        $@.each { |tr| log "Backtrace: #{tr}" }
+                        folderstyle = MBox
+                        save(spoolfile)
+                    end
+                end
+                if block
+                    instance_eval(&block)
+                end
+            else
+                save(spoolfile)
+            end
+        end
+    end
+end

data/lib/gurgitate/deliver.rb

@@ -0,0 +1,84 @@
+#!/opt/bin/ruby -w
+
+#------------------------------------------------------------------------
+# Code to handle saving a message to a mailbox (and a framework for detecting
+# what kind of mailbox it is)
+#------------------------------------------------------------------------
+
+require "gurgitate/deliver/mbox"
+require "gurgitate/deliver/maildir"
+
+module Gurgitate
+    module Deliver
+
+        class MailboxFound < Exception
+            # more of a "flag" than an exception really
+        end
+
+        # Saves a message to +mailbox+, after detecting what the mailbox's
+        # format is.
+        # 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 save(mailbox)
+
+            if mailbox[0,1]=='=' and @maildir != nil then
+                mailbox["="]=@maildir+"/"
+            end
+
+            if mailbox[0,1] != '/' then
+                log("Cannot save to relative filenames!  Saving to spool file");
+                mailbox=spoolfile
+            end
+
+            begin
+                [MBox,Maildir].each do |mod|
+                    if mod::check_mailbox(mailbox) then
+                        self.class.instance_eval do 
+                            include mod
+                            raise MailboxFound
+                        end
+                    end
+                end
+
+                # Huh, nothing could find anything.  Oh well,
+                # let's default to whatever's in @folderstyle.  (I
+                # guess we'll be making a new mailbox, eh?)
+
+                if defined? @folderstyle then
+                    #
+                    # Careful we don't get the wrong instance variable 
+                    folderstyle=@folderstyle 
+
+                    self.class.instance_eval do
+                        include folderstyle
+                    end
+                else
+                    # No hints from the user either.  Let's guess!
+                    # I'll use the same heuristic that Postfix uses--if the
+                    # mailbox name ends with a /, then make it a Maildir,
+                    # otherwise make it a mail file
+                    if mailbox =~ /\/$/ then
+                        include Maildir
+                    else
+                        include MBox
+                    end
+                end
+                
+            rescue MailboxFound
+                # Don't need to do anything--we only have to worry
+                # about it if there wasn't a mailbox there.
+                nil
+            end
+
+            begin
+                deliver_message(mailbox)
+            rescue SystemCallError
+                self.log "Gack!  Something went wrong: "+$!
+                exit 75
+            end
+        end
+    end
+end

data/lib/gurgitate/deliver/maildir.rb

@@ -0,0 +1,100 @@
+#!/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.exists?(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
+
+                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