gurgitate-mail 1.10.9 → 1.10.10

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 578b870727d42aad907a83379eff2df9dab9c704
+  data.tar.gz: f76eaacb28f9cbc0582241dacc17f82db06a5013
+SHA512:
+  metadata.gz: b636bf531b2c0a5d217d9a673d9b52e3cd7fa01ae8306380f7a8d3e0cb97778dfcc0eec7e0b1774fb247c1b542da34899b5612bdb2e176f0ea7887ce08326434
+  data.tar.gz: a99dacff953b461fce793845509976505e9e2840d272dd18a4c96e1427810c4d94a794b0d7d949250dedd6c9eeed273872d9a380e3db58a5034834ff2d1cf0cb

data/lib/gurgitate-mail.rb

@@ -0,0 +1,386 @@
+#!/opt/bin/ruby
+# -*- encoding : utf-8 -*-
+#------------------------------------------------------------------------
+# Mail filter package
+#------------------------------------------------------------------------
+
+require 'etc'
+
+require 'gurgitate/mailmessage'
+require 'gurgitate/deliver'
+
+module Gurgitate
+    # This is the actual gurgitator; it reads a message and then it can
+    # do other stuff with it, like saving it to a mailbox or forwarding
+    # it somewhere else.
+    #
+    # To set configuration parameters for gurgitate-mail, use a keyword-
+    # based system.  It's almost like an attribute, only if you give the
+    # accessor a parameter, it will set the configuration parameter to
+    # the parameter's value.  For instance:
+    #
+    #  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 <code>self.name = value</code>, which [I think] is ugly.
+    #
+    # In the interests of promoting harmony, of course,
+    # <code>self.name = value</code> still works.)
+    #
+    # The attributes you can define are:
+    #
+    # homedir ::  Your home directory.  This defaults to what your
+    #             actual home directory is.
+    #
+    # maildir :: The directory you store your mail in.  This defaults
+    #            to the "Mail" directory in your home dir.
+    #
+    # logfile :: The path to your gurgitate-mail log file.  If you
+    #            set this to +nil+, gurgitate-mail won't log anything.
+    #            The default value is ".gurgitate.log" in your home
+    #            directory.
+    #
+    # The following parameters are more likely to be interesting to the
+    # system administrator than the everyday user.
+    #
+    # sendmail :: The full path of your "sendmail" program, or at least
+    #             a program that provides functionality equivalent to
+    #             sendmail.
+    #
+    # spoolfile :: The default location to store mail messages, for the
+    #              messages that have been unaffected by your gurgitate
+    #              rules.  If an exception is raised by your rules, the
+    #              message will be delivered to the spoolfile.
+    #
+    # spooldir :: The location where users' system mail boxes live.
+    #
+    # folderstyle :: The style of mailbox to create (and to expect,
+    #                although gurgitate-mail automatically detects the
+    #                type of existing mailboxes).  See the separate
+    #                documentation for folderstyle for more details.
+    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.  Treat this like a
+        # configuration parameter.  If no argument is given, then
+        # return the current default type.
+        #
+        # Depending on what you set this to, some other configuration
+        # parameters change.  You can set this to the following things:
+        #
+        # <code>Maildir</code> :: Create Maildir mailboxes.
+        #
+        #                         This sets +spooldir+ to your home
+        #                         directory, +spoolfile+ to
+        #                         $HOME/Maildir and creates
+        #                         mail folders underneath that.
+        #
+        # <code>MH</code> :: Create MH mail boxes.
+        #
+        #                    This reads your <code>.mh_profile</code>
+        #                    file to find out where you've told MH to
+        #                    find its mail folders, and uses that value.
+        #                    If it can't find that in your .mh_profile,
+        #                    it will assume you want mailboxes in
+        #                    $HOME/Mail.  It sets +spoolfile+ to
+        #                    "inbox" in your mail directory.
+        #
+        # <code>Mbox</code> :: Create +mbox+ mailboxes.
+        #
+        #                      This sets +spooldir+ to
+        #                      <code>/var/spool/mail</code> and
+        #                      +spoolfile+ to a file with your username
+        #                      in <code>/var/spool/mail</code>.
+        def folderstyle(*style)
+            if style.length == 0 then
+                @folderstyle
+            elsif style.length == 1 then
+                if style[0] == Maildir then
+                    spooldir homedir
+                    spoolfile File.join(spooldir,"Maildir")
+                    maildir spoolfile
+                elsif style[0] == MH then
+                    mh_profile_path = File.join(ENV["HOME"],".mh_profile")
+                    if File.exists?(mh_profile_path) then
+                        mh_profile = YAML.load(File.read(mh_profile_path))
+                        maildir mh_profile["Path"]
+                    else
+                        maildir File.join(ENV["HOME"],"Mail")
+                    end
+                    spoolfile File.join(maildir,"inbox")
+                else
+                    spooldir "/var/spool/mail"
+                    spoolfile File.join(spooldir, @passwd.name)
+                end
+
+                @folderstyle = style[0]
+            else
+                raise ArgumentError, "wrong number of arguments "+
+                                     "(#{style.length} for 0 or 1)"
+            end
+            @folderstyle
+        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
+        # recipient::
+        #   The contents of the envelope recipient parameter
+        # sender::
+        #   The envelope sender parameter
+        # spooldir::
+        #   The location of the mail spools directory.
+        def initialize(input=nil,
+                       recipient=nil,
+                       sender=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_line do |l| input_text << l end
+            super(input_text, recipient, sender)
+            instance_eval(&block) if block_given?
+        end
+
+        def add_rules(filename, options = {}) #:nodoc:
+            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 (discards) the current message.
+        def delete
+            # Well, nothing here, really.
+        end
+
+        # This is kind of neat.  You can get a header by calling its
+        # name as a method.  For example, 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 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
+        end
+
+        # Pipes the message through +program+, and returns another
+        # +Gurgitate+ object containing the output of the filter
+        #
+        # Use it like this:
+        #
+        #  filter "bogofilter -p" do
+        #    if x_bogosity =~ /Spam/ then
+        #      log "Found spam"
+        #      delete
+        #      return
+        #    end
+        #  end
+        #
+        def filter(program,&block)
+            self.log "Filtering with "+program
+            IO.popen("-","w+") do |filter|
+                unless filter then
+                    begin
+                        exec(program)
+                    rescue
+                        exit! # should not get here anyway
+                    end
+                else
+                    if fork
+                        filter.close_write
+                        g=Gurgitate.new(filter)
+                        g.instance_eval(&block) if block_given?
+                        return g
+                    else
+                        begin
+                            filter.close_read
+                            filter.print to_s
+                            filter.close
+                        rescue
+                            nil
+                        ensure
+                            exit!
+                        end
+                    end
+                end
+            end
+        end
+
+        def process(&block) #:nodoc:
+            begin
+                if @rules.size > 0 or block
+                    @rules.each do |configfilespec|
+                        begin
+                            eval File.new(configfilespec).read, nil,
+                                configfilespec
+                        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
+                    log "Mail not covered by rules, saving to default spool"
+                    save(spoolfile)
+                else
+                    save(spoolfile)
+                end
+            rescue Exception
+                log "Error while executing rules: #{$!}"
+                $@.each { |tr| log "Backtrace: #{tr}" }
+                log "Attempting to save to spoolfile after error"
+                folderstyle MBox
+                save(spoolfile)
+            end
+        end
+    end
+end

data/lib/gurgitate/deliver.rb

@@ -0,0 +1,87 @@
+#!/opt/bin/ruby -w
+# -*- encoding : utf-8 -*-
+
+#------------------------------------------------------------------------
+# 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"
+require "gurgitate/deliver/mh"
+
+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
+                if @folderstyle == Maildir and mailbox !~ /^=\./ then
+                    mailbox["="]=@maildir+"/."
+                else
+                    mailbox["="]=@maildir+"/"
+                end
+            end
+
+            if mailbox[0,1] != '/' then
+                log("Cannot save to relative filenames!  Saving to spool file");
+                mailbox=spoolfile
+            end
+
+            begin
+                [MBox,Maildir,MH].each do |mod|
+                    if mod::check_mailbox(mailbox) then
+                        extend mod
+                        raise MailboxFound
+                    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 Module === @folderstyle then
+                    #
+                    # Careful we don't get the wrong instance variable 
+                    folderstyle=@folderstyle 
+
+                    extend folderstyle
+                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
+                        extend Maildir
+                    else
+                        extend 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: " + $!.to_s
+                raise
+                # exit 75
+            end
+        end
+    end
+end