sugoi-mail 0.0.0

data/app/models/address.rb

@@ -0,0 +1,110 @@
+# The addresses table is where all the email addresses are stored, and
+# Address is the interface to that.
+# 
+# Address has the following data members:
+# +id+::                 The row ID in the database.
+# +address+::            The actual email address
+# +active+::             Whether the address is active or not.  This should
+#                        be reset to false upon a bounce, but currently
+#                        isn't because there isn't a standard format for
+#                        bounce messages and I haven't yet written the
+#                        code to figure out which address I attempted to
+#                        send mail to failed.
+# +delivery_attempts+::  The number of delivery attempts.  This is also
+#                        related to bouncing, and is thus a stub.
+# +bounces+::            The number of times email sent to this address
+#                        has bounced.  Like the other two bounce-related
+#                        members, this is merely a stub.
+# 
+# Address is also joined with other classes:
+# Mailinglist::    The join between Mailinglist and Address reflects
+#                  addresses are subscribed to a mailing list.
+# User::           The join between Mailinglist and User reflects
+#                  addresses that the User can send email to via the
+#                  proxy in order to trigger email-address rewriting.
+# Message::        Messages that were received from this Address.
+
+class Address < ActiveRecord::Base
+    # The mailing lists that the address is a subscriber to
+    has_and_belongs_to_many :mailinglists
+    has_many :proxy_links
+
+    # The messages that were sent to this address
+    has_many :messages
+
+    # Parses the address string in +addrstr+ for an actual email address.
+    # This handles addresses of the forms:
+    #
+    #    Dave Brown <dagbrown@mailman.jp>
+    #    "Dave A. Brown" <dagbrown@mailman.jp>
+    #    dagbrown@mailman.jp (Dave Brown)
+    #    dagbrown@mailman.jp
+    #
+    # In other words, things that are likely to be in the From: and To: headers
+    # in an average email message.
+    #
+    # addrstr::
+    #   The email address string.
+    def self.parse(addrstr) # not really OO, this
+        matches = /\s*([^@]+\@\S+) \((.*)\)/.match(addrstr)
+        if matches
+            return matches[1], matches[2]
+        end
+        
+        matches = /(\".*\") \<([^@]+\@\S+)\>/.match(addrstr)
+        if matches
+            return matches[2], matches[1]
+        end
+
+        matches = /((?:\w|\s)*) \<([^@]+\@\S+)\>/.match(addrstr)
+        if matches
+            return matches[2], matches[1]
+        end
+        
+        matches = /(\S+@\S+)/.match(addrstr)
+        if matches
+            return matches[1],nil
+        end
+        
+        return addrstr, nil # and this is being probably needlessly optimistic
+    end
+
+    # If the address in +addrstr+ has a proxy address, returns the proxy
+    # address.
+    #
+    # addrstr::
+    #   The address string to search for a proxy address for
+    def self.proxyaddress(addrstr)
+        a = Address.find_or_create_by_address(addrstr) and a.proxyaddress
+    end
+
+    # If the current address has a proxy address, return that.
+    def proxyaddress
+        user && user.address
+    end
+
+    def outside?
+        not user
+    end
+
+    # Returns an anonymous proxy address for this user and a mailing list
+    def proxified ml
+        ProxyLink.find_or_create_by_address_id_and_mailinglist_id(
+            id, ml.id
+        ).proxy_address
+    end
+
+    # If the address has a proxy address, then return the user that
+    # the proxy address belongs to.
+    def user
+        ml = mailinglists.find_all do |ml| 
+            ml.id == ml.user.mailinglist_id && !ml.user.virtual?
+        end[0]
+        if ml then ml.user end
+    end
+    
+    # Return a string representation of the address.
+    def to_s
+        address
+    end
+end

data/app/models/admin_message.rb

@@ -0,0 +1,45 @@
+require "net/smtp"
+
+# Admin messages are the messages that are sent out when people are joining
+# or leaving a mailing list.
+class AdminMessage < ActiveRecord::Base
+    # The regular expression defining what templates look like.  The
+    # templates are the things like {address} that are replaced with
+    # an actual address.
+    TemplateRegex = /\{(\w+)\}/
+
+    # Renders the current administration message, filling in the template with
+    # the values with the values in +template_values+.  For example, if the
+    # message is:
+    #
+    #   Thank you for subscribing to the "{mldesc}" mailing list.
+    #
+    # You might call #render as such:
+    #
+    #   adminmsg.render :mldesc => "quick example"
+    #
+    # This would return:
+    #
+    #   Thank you for subscribing to the "quick example" mailing list.
+    #
+    # template_values::
+    #   A Hash containing as keys, template keys, and as values, the
+    #   values to replace the template keys with.
+    def render template_values
+        template_values.each_key do |k|
+            template_values[k.to_s]=template_values[k]
+        end
+        self.message.gsub(TemplateRegex) do |text|
+            template_values[ text.match(TemplateRegex)[1] ]
+        end
+    end
+
+    # Sends out an admin message with with the +from+ address in the
+    # envelope "From" string, the +to+ address in the envelope "To" string,
+    # and with with +template_values+ expanded as in +render+.1
+    def send_mail from, to, template_values
+        Net::SMTP.start("localhost", 25) do |smtp|
+            smtp.send_message render(template_values), from, to
+        end
+    end
+end

data/app/models/confirmationcode.rb

@@ -0,0 +1,59 @@
+require "net/smtp"
+
+# The Confirmation code is a sort of join table that links mailing lists
+# with addresses, and also stores confirmation status.
+class Confirmationcode < ActiveRecord::Base
+    belongs_to :mailinglist
+    belongs_to :address
+
+    # Creates a new confirmation code, and then freezes it so that it
+    # can't be modified.
+    def initialize
+        super
+        @attributes["code"]=("%16s" % rand(36**16).to_s(36)).gsub(/ /,"0")
+        @attributes["code"].freeze
+    end
+
+    validates_presence_of :mailinglist
+    validates_presence_of :address
+
+    def code= _
+        raise TypeError, "can't modify code string"
+    end
+
+    # Given a +mailinglist_id+ and an +address_id+, returns whether the
+    # address has been confirmed for that mailing list or not.
+    def self.confirmed? mailinglist_id, address_id
+        confirmation_record = find( :first, :conditions => 
+            [ 'mailinglist_id = ? and address_id = ?', 
+                mailinglist_id, address_id ] )
+        if confirmation_record then
+            confirmation_record.confirmed
+        else
+            nil
+        end
+    end
+
+    # Given a +mailinglist+, an +address+ and a confirmation code in
+    # +code+, it confirms the address in that mailing list if the
+    # confirmation code is correct.
+    # 
+    # If the confirmation code is incorrect, returns false.
+    def self.confirm mailinglist, address, code
+        confirmation_record = 
+            find(:first, :conditions => [
+                 'mailinglist_id = ? and address_id = ? and code = ?',
+                 mailinglist.id,
+                 address.id,
+                 code
+        ])
+
+        if confirmation_record then
+            confirmation_record.confirmed = true
+            if confirmation_record.save then
+                true
+            end
+        end
+
+    end
+end

data/app/models/domain.rb

@@ -0,0 +1,76 @@
+require 'digest/sha1'
+
+# = Domain
+#
+# This is actually nothing more than a User class generated by the
+# standard Rails login generator.
+#
+# Its data structure is very basic, as a result:
+# name::     The domain's name.
+# password:: A SHA1 hash of the domain's password.
+#
+# Its use as a login service is mainly for the purposes of the
+# Mailservice web service--the middle layer (the SOAP client) logs into
+# the domain, and then the users can log into _that_.
+class Domain < ActiveRecord::Base
+
+    #----------------------------------------
+    # First of all, email address stuff
+    #----------------------------------------
+    has_many :users
+
+    # Please change the salt to something else, 
+    # Every application should use a different one 
+    @@salt = 'thuchpog10.?guf'
+    cattr_accessor :salt
+
+    # Authenticate a user. 
+    #
+    # Example:
+    #   @user = User.authenticate('bob', 'bobpass')
+    #
+    def self.authenticate(name, pass)
+        find_first(["name = ? AND password = ?", name, sha1(pass)])
+    end  
+
+
+    protected
+
+    # Apply SHA1 encryption to the supplied password. 
+    # We will additionally surround the password with a salt 
+    # for additional security. 
+    def self.sha1(pass)
+        Digest::SHA1.hexdigest("#{salt}--#{pass}--")
+    end
+
+    before_create :crypt_password
+
+    # Before saving the record to database we will crypt the password 
+    # using SHA1. 
+    # We never store the actual password in the DB.
+    def crypt_password
+        write_attribute "password", self.class.sha1(password)
+    end
+
+    before_update :crypt_unless_empty
+
+    # If the record is updated we will check if the password is empty.
+    # If its empty we assume that the user didn't want to change his
+    # password and just reset it to the old value.
+    def crypt_unless_empty
+        if password.empty?      
+            user = self.class.find(self.id)
+            self.password = user.password
+        else
+            write_attribute "password", self.class.sha1(password)
+        end        
+    end  
+
+    validates_uniqueness_of :name, :on => :create
+
+    validates_confirmation_of :password
+    validates_length_of :name, :within => 3..40
+    validates_length_of :password, :within => 5..40
+    validates_presence_of :name, :password, :password_confirmation, 
+        :on => :create
+end

data/app/models/mailinglist.rb

@@ -0,0 +1,336 @@
+# Mailing lists are what make Sugoi-Mail go.  Which makes sense, I suppose, 
+# since Sugoi-Mail is a mailing list manager.
+# 
+# A Mailing List has the following structure:
+#
+# (from the schema)
+#
+# name:                         The name of the mailing list.  This will
+#                               become the local part of the list's email
+#                               address.
+# description::                 The description of the mailing list.  This
+#                               go into the "real name" portion of the mailing
+#                               list's email address listed in the "From:"
+#                               header in messages that are sent out to
+#                               subscribers.
+# user::                        The Sugoi-Mail user who owns and manages the
+#                               mailing list--this is a User object.  The domain
+#                               of the mailing list is the domain that the user
+#                               is a member of.
+# mailinglist_class::           The kind of mailing list that this is.  This is
+#                               a MailinglistClass object.
+# welcome_admin_message::       The message that is sent out to a new member
+#                               when a subscription is received.  This is an
+#                               AdminMessage object.
+# confirmed_admin_message::     The message that is sent out to a new member
+#                               when the subscription confirmation message
+#                               is confirmed.  This is also an AdminMessage
+#                               object.
+# sayonara_admin_message_id::   The final AdminMessage object (as of the moment
+#                               anyway--couriermlm mailing lists have many more
+#                               administrative messages, and I suspect I may
+#                               have to implement all those at some point).
+#                               This is the message that is sent out to a
+#                               subscriber when she unsubscribes from the
+#                               mailing list.
+
+class Mailinglist < ActiveRecord::Base
+    belongs_to :user
+    has_and_belongs_to_many :addresses
+    has_many :messages
+    has_many :proxy_links
+    validates_each :name, :on => :create do |record, attr, value|
+        if record.user
+            if Mailinglist.find_by_sql(
+                ['select * from mailinglists m, users u
+                     where u.id = m.user_id
+                         and u.domain_id = ?
+                         and m.name = ?',
+                    record.user.domain_id,
+                    value ]).length > 0 then
+                record.errors.add("name", 
+                                  "Address already exists: #{record.address}")
+            end
+        end
+    end
+
+    validates_associated :user, :on => :create
+
+    validates_presence_of :user
+    belongs_to :mailinglist_class
+
+    # Since rails's has_one interface apparently DOESN'T WORK, I
+    # have to do all these by hand.
+    
+    %w{welcome confirmed sayonara}.each do |msgtype|
+        eval <<-EOT
+            def #{msgtype}_admin_message
+                AdminMessage.find #{msgtype}_admin_message_id
+            end
+
+            def #{msgtype}_admin_message=(msg)
+                self.#{msgtype}_admin_message_id = msg.id
+            end
+        EOT
+    end
+
+    # Returns true if this mailing list's address is the canonical address of a
+    # User.
+    def canonical_address?
+        id == user.mailinglist_id
+    end
+
+    # Returns true if the address +addr+ is subscribed to this mailing list.
+    def has_address? addr
+        expand_addresses.map { |a| a.address }.member? addr
+    end
+
+    def before_save
+        welcome_admin_message   ||= AdminMessage.find 1
+        confirmed_admin_message ||= AdminMessage.find 2
+        sayonara_admin_message  ||= AdminMessage.find 3
+    end
+
+    #------------------------------------------------------------------------
+    # Passthroughs to the mailinglist_class
+    #------------------------------------------------------------------------
+    [ :public?, :closed?, :moderated?, 
+        :confirmation?, :joinable?, :archived?, :proxify? ].each do |m|
+        define_method m do
+            mailinglist_class.send m
+        end
+    end
+
+    #------------------------------------------------------------------------
+    # These are all to make it work with rumble (as a replacement for
+    # rumble's mailing-list class).
+    #------------------------------------------------------------------------
+
+    def address; "#{name}@#{user.domain.name}"; end
+    def bounceaddress; "#{name}-bounce@#{user.domain.name}"; end
+    def requestaddress; "#{name}-request@#{user.domain.name}"; end
+
+    def self.find_by_address addr
+        if ml = find_by_basic_address(addr) then
+            return [ml,:mail]
+        elsif info = find_by_proxy_address(addr) then
+            ml, address_id = info
+            return [ml, :proxy, address_id]
+        elsif(ml = find_by_bounces_address(addr)) then
+            return [ml, :bounces]
+        elsif(ml = find_by_request_address(addr)) then
+            return [ml, :request]
+        end
+    end
+
+    def self.find_by_basic_address addr
+        (ml_name, domain_name) = addr.split "@"
+        domain=Domain.find_by_name domain_name
+        if domain
+            ml=Mailinglist.find_all_by_name(ml_name).find do |ml|
+                ml.domain.id == domain.id
+            end
+        end
+    end
+
+    def self.find_by_proxy_address addr
+        if matchdata=addr.match(/-([0-9]+)\@/) then
+            proxy_id=matchdata[1].to_i
+            if ml=find_by_basic_address(addr.sub(/-[0-9]+\@/,"@")) then
+                begin
+                    proxy=ProxyLink.find(proxy_id)
+                    return ml, proxy.address
+                rescue
+                    nil
+                end
+            end
+        end
+    end
+
+    def self.find_by_bounces_address bounces_addr
+        find_by_basic_address bounces_addr.sub(/-bounces\@/,"@")
+    end
+
+    def self.find_by_request_address request_addr
+        find_by_basic_address request_addr.sub(/-request\@/,"@")
+    end
+
+    def confirmed? addr
+        if confirmation? then
+            Confirmationcode.confirmed? self.id, addr.id
+        else 
+            true
+        end
+    end
+
+    def confirmed_addresses
+        addresses.find_all { |addr| confirmed? addr }
+    end
+
+    def pending_addresses
+        addresses.find_all { |addr| not confirmed? addr }
+    end
+
+    alias unconfirmed_addresses pending_addresses 
+
+    def expand_addresses
+        address_list = addresses
+        expanded = false
+        until expanded
+            foundsome = false
+            new_address_list = address_list.map do |addr|
+                if ml = Mailinglist.find_by_address(addr.address) then
+                    foundsome = true
+                    ml[0].addresses
+                else
+                    addr
+                end
+            end.flatten
+            expanded = ! foundsome
+            address_list = new_address_list
+        end
+        address_list
+    end
+
+    def domain; user.domain; end
+
+    def store_message message; messages << message; end
+
+    def send_message message
+        message.deliver
+    end
+
+    def subscribe(address,confirmationcode = nil)
+        addr=Address.find_or_create_by_address(address)
+        if confirmation?
+            if confirmed_addresses.member? addr
+                true
+            else
+                if confirmationcode then
+                    confirm addr, confirmationcode
+                else
+                    send_welcome_message(addr)
+                    addresses << addr
+                end
+            end
+        else
+            if addresses.member? addr
+                true
+            else
+                addresses << addr
+            end
+        end
+    end
+
+    def send_welcome_message(address)
+        if Address === address then
+            addr = address
+        else
+            addr=Address.find_or_create_by_address(address) 
+        end
+        c=Confirmationcode.find_by_address_id_and_mailinglist_id addr.id, id
+        unless c
+            c=Confirmationcode.new
+            c.address_id=addr.id
+            c.mailinglist_id=id
+            c.save
+        end
+
+        unless c.confirmed?
+            welcome_admin_message.send_mail bounceaddress, addr.address,
+                :address => addr.address,
+                :command => "subscribe #{addr.address} #{c.code}",
+                :domain => domain.name,
+                :name => name,
+                :description => description,
+                :requestaddress => requestaddress
+            end
+    end
+
+    def confirm address,confirmationcode
+        addr=nil
+
+        if Address === address
+            addr=address
+        else
+            addr=Address.find_by_address(address)
+        end
+
+        if addr then
+            if confirmation? then
+                if Confirmationcode.confirm(self, addr, confirmationcode) then
+                    save
+                    confirmed_admin_message.send_mail bounceaddress, 
+                        addr.address,
+                        :address => addr.address,
+                        :domain => domain.name,
+                        :name => name, 
+                        :description => description,
+                        :requestaddress => requestaddress
+                    return true
+                else
+                    return false
+                end
+            else
+                return true
+            end
+        end
+    end
+
+    def unsubscribe(address, send_mail = true)
+        addr=nil
+
+        unless Address === address
+            addr=Address.find_by_address address
+        else
+            addr=address
+        end
+
+        if addresses.member? addr then
+            if send_mail
+                sayonara_admin_message.send_mail bounceaddress, 
+                    addr.address,
+                    :address => addr.address,
+                    :domain => domain.name,
+                    :name => name, 
+                    :description => description,
+                    :requestaddress => requestaddress
+            end
+            remove_addresses addr
+        end
+    end
+
+    def handle_request requestmessage
+        subject=requestmessage.headers["Subject"][0].contents
+        matches=requestmessage.body.match(/^\W*subscribe\s+(\S+@[a-z0-9.-]+)
+                           (?:\s+([a-z0-9]{16}))?$/x)
+        if matches then
+            # puts "Found subscription request: #{matches[0]}"
+            
+            addresscandidate=matches[1]
+            confirmationcode=matches[2] # returns nil if there isn'tone
+            
+            # Since you can have mailing lists that require confirmation, but
+            # they're not joinable, check for the confirmationcode case first.
+            if confirmationcode then
+                return subscribe(addresscandidate, confirmationcode)
+            else
+                if joinable? then
+                    return subscribe(addresscandidate)
+                end
+            end
+        end
+        
+        # TODO: actually implement confirmed unsubscribing down in the
+        # model.  (This is, of course, to prevent pranksters from
+        # unsubscribing you from a mailing list behind your back.)
+        matches=requesmessage.body.match(/^\W*unsubscribe\s+(\S+@[a-z0-9.-]+)
+                            (?:\s+([a-z0-9]{16}))?$/x)
+        if matches then
+            addresscandidate=matches[1]
+            confirmationcode=matches[2]
+            
+            return unsubscribe(addresscandidate, confirmationcode)
+        end
+    end
+end

data/app/models/mailinglist_class.rb

@@ -0,0 +1,39 @@
+# The mailing classes table is the table defining the behaviour of the
+# mailing lists, and is, in a way, the heart of how sugoi-mail works.
+#
+# Rather than simply making a distinction between, say, email-address
+# forwarding (the service offered by pobox.com) and mailing list
+# management, everything in Sugoi-Mail is a mailing list.  What _kind_
+# of mailing list it is, is defined in the mailing list classes table.
+#
+# Delivery Attributes
+# +public+:: Whether the list is open to the public or not.
+#  true:    anyone can post to it (spammy!)
+#  false:   only members can post to it   <-- DEFAULT
+# +closed+:: Determines who can send mail to the mailing list
+#  true:    only the owner can post to it
+#  false:   other people can post to it   <-- DEFAULT
+# +moderated+::  Determines whether mail goes straight to all addressees,
+#                or needs to be approved by the owner first.
+#  true:    posted messages go to the owner first
+#  false:   posted messages are broadcast <-- DEFAULT
+#
+# Address List Editing Attributes
+# +confirmation+:: Whether subscription requests need to be confirmed,
+#                  via an opt-in mechanism or not.
+#  true:    subscriptions have to be confirmed <-- DEFAULT
+#  false:   subscriptions happen automatically
+# joinable:: Whether the general public can join a mailing list or not.
+#            If not, then only the owner can edit the address list.
+#  true:    people can subscribe to the list at will <- DEFAULT
+#  false:   only the owner can subscribe or unsubscribe people
+#
+# Other Attributes
+# +archived+:: Whether messages are retained after delivery or not.
+#  true:    Messages will be stored after they're delivered (useful for
+#           mailing list archives online)
+#  false:   Messages will be discarded after delivery (probably what
+#           people who want to use sugoi-mail for forwarding want)
+class MailinglistClass < ActiveRecord::Base
+    has_many :mailinglists
+end