ezmlm 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bf46d542a4e9fdcc6a386052bbddc4156c0f7488
+  data.tar.gz: d694063ea5922829e4c163aef6a2b64b03497501
+SHA512:
+  metadata.gz: b865c3b198ebf8946d26478e330b3632448b762a78434d6d1914e99deaff0a3c91469c28871ef56b0d5a362e9704d5f7d7cb3b538809a7f90f2f9a755e4bae0a
+  data.tar.gz: 18c045e3dbbaa3b9224b90ddbb35f835c2447ae432c56aaf196d1618c6f1cd021c1fc343aee6d728c3a129e2e5dd230afc6eae7ade352f7de88c12c00ba830fc

data/ext/ezmlm/hash/extconf.rb

@@ -0,0 +1,5 @@
+
+require 'mkmf'
+
+create_makefile( 'ezmlm/hash' )
+

data/ext/ezmlm/hash/hash.c

@@ -0,0 +1,193 @@
+
+#include "hash.h"
+
+/*
+ * I originally attemped to just convert surf.c to pure Ruby, but I
+ * confess a lack of understanding surrounding the char casts from
+ * unsigned ints, etc, and screwing up a hash algo doesn't do anyone
+ * any good, least of all, me.  In other words, I don't have to fully
+ * understand DJB code to trust in it. :-)
+ *
+ * The following is copied verbatim from the ezmlm-idx source, version
+ * 7.2.2.  See: subhash.c, surf.c, and surfpcs.c.
+ *
+*/
+
+void surf(unsigned int out[8],const unsigned int in[12],const unsigned int seed[32])
+{
+  unsigned int t[12]; unsigned int x; unsigned int sum = 0;
+  int r; int i; int loop;
+
+  for (i = 0;i < 12;++i) t[i] = in[i] ^ seed[12 + i];
+  for (i = 0;i < 8;++i) out[i] = seed[24 + i];
+  x = t[11];
+  for (loop = 0;loop < 2;++loop) {
+    for (r = 0;r < 16;++r) {
+      sum += 0x9e3779b9;
+      MUSH(0,5) MUSH(1,7) MUSH(2,9) MUSH(3,13)
+      MUSH(4,5) MUSH(5,7) MUSH(6,9) MUSH(7,13)
+      MUSH(8,5) MUSH(9,7) MUSH(10,9) MUSH(11,13)
+    }
+    for (i = 0;i < 8;++i) out[i] ^= t[i + 4];
+  }
+}
+
+void surfpcs_init(surfpcs *s,const unsigned int k[32])
+{
+  int i;
+  for (i = 0;i < 32;++i) s->seed[i] = k[i];
+  for (i = 0;i < 8;++i) s->sum[i] = 0;
+  for (i = 0;i < 12;++i) s->in[i] = 0;
+  s->todo = 0;
+}
+
+void surfpcs_add(surfpcs *s,const char *x,unsigned int n)
+{
+  int i;
+  while (n--) {
+    data[end[s->todo++]] = *x++;
+    if (s->todo == 32) {
+      s->todo = 0;
+      if (!++s->in[8])
+        if (!++s->in[9])
+          if (!++s->in[10])
+            ++s->in[11];
+      surf(s->out,s->in,s->seed);
+      for (i = 0;i < 8;++i)
+	s->sum[i] += s->out[i];
+    }
+  }
+}
+
+void surfpcs_addlc(surfpcs *s,const char *x,unsigned int n)
+/* modified from surfpcs_add by case-independence and skipping ' ' & '\t' */
+{
+  unsigned char ch;
+  int i;
+  while (n--) {
+    ch = *x++;
+    if (ch == ' ' || ch == '\t') continue;
+    if (ch >= 'A' && ch <= 'Z')
+      ch -= 'a' - 'A';
+
+    data[end[s->todo++]] = ch;
+    if (s->todo == 32) {
+      s->todo = 0;
+      if (!++s->in[8])
+        if (!++s->in[9])
+          if (!++s->in[10])
+            ++s->in[11];
+      surf(s->out,s->in,s->seed);
+      for (i = 0;i < 8;++i)
+	  s->sum[i] += s->out[i];
+    }
+  }
+}
+
+void surfpcs_out(surfpcs *s,unsigned char h[32])
+{
+  int i;
+  surfpcs_add(s,".",1);
+  while (s->todo) surfpcs_add(s,"",1);
+  for (i = 0;i < 8;++i) s->in[i] = s->sum[i];
+  for (;i < 12;++i) s->in[i] = 0;
+  surf(s->out,s->in,s->seed);
+  for (i = 0;i < 32;++i) h[i] = outdata[end[i]];
+}
+
+void makehash(const char *indata,unsigned int inlen,char *hash)
+	/* makes hash[COOKIE=20] from stralloc *indata, ignoring case and */
+	/* SPACE/TAB */
+{
+  unsigned char h[32];
+  surfpcs s;
+  unsigned int seed[32];
+  int i;
+
+  for (i = 0;i < 32;++i) seed[i] = 0;
+  surfpcs_init(&s,seed);
+  surfpcs_addlc(&s,indata,inlen);
+  surfpcs_out(&s,h);
+  for (i = 0;i < 20;++i)
+    hash[i] = 'a' + (h[i] & 15);
+}
+
+unsigned int subhashb(const char *s,long len)
+{
+  unsigned long h;
+  h = 5381;
+  while (len-- > 0)
+    h = (h + (h << 5)) ^ (unsigned int)*s++;
+  return h % 53;
+}
+
+unsigned int subhashs(const char *s)
+{
+  return subhashb(s,strlen(s));
+}
+
+/* end copy of ezmlm-idx source */
+
+
+
+
+/*
+ * call­seq:
+ *   Ezmlm::Hash.address( email ) -> String
+ *
+ * Call the Surf hashing function on an +email+ address, returning
+ * the hashed string.  This is specific to how ezmlm is seeding
+ * the hash, and parsing email addresses from messages (prefixed with
+ * the '<' character.)
+ *
+ */
+VALUE
+address( VALUE klass, VALUE email ) {
+	char hash[20];
+	char *input;
+
+	Check_Type( email, T_STRING );
+
+	email = rb_str_plus( rb_str_new2("<"), email );
+	input = StringValueCStr( email );
+
+	makehash( input, strlen(input), hash );
+
+	return rb_str_new( hash, 20 );
+}
+
+
+/*
+ * call­seq:
+ *   Ezmlm::Hash.subscriber( address ) -> String
+ *
+ * Call the subscriber hashing function on an email +address+, returning
+ * the index character referring to the file containing subscriber presence.
+ *
+ */
+VALUE
+subscriber( VALUE klass, VALUE email ) {
+	unsigned int prefix;
+
+	Check_Type( email, T_STRING );
+
+	email  = rb_str_plus( rb_str_new2("T"), email);
+	prefix = subhashs( StringValueCStr(email) ) + 64;
+
+	return rb_sprintf( "%c", (char)prefix );
+}
+
+
+
+void
+Init_hash()
+{
+	rb_mEzmlm  = rb_define_module( "Ezmlm" );
+	rb_cEZHash = rb_define_class_under( rb_mEzmlm, "Hash", rb_cObject );
+
+	rb_define_module_function( rb_cEZHash, "address", address, 1 );
+	rb_define_module_function( rb_cEZHash, "subscriber", subscriber, 1 );
+
+	return;
+}
+

data/ext/ezmlm/hash/hash.h

@@ -0,0 +1,46 @@
+
+#include <ruby.h>
+
+static VALUE rb_mEzmlm;
+static VALUE rb_cEZHash;
+
+
+#ifndef SURF_H
+#define SURF_H
+
+#define ROTATE(x,b) (((x) << (b)) | ((x) >> (32 - (b))))
+#define MUSH(i,b) x = t[i] += (((x ^ seed[i]) + sum) ^ ROTATE(x,b));
+
+typedef struct {
+	unsigned int seed[32];
+	unsigned int sum[8];
+	unsigned int out[8];
+	unsigned int in[12];
+	int todo;
+} surfpcs;
+
+static const unsigned int littleendian[8] = {
+  0x03020100, 0x07060504, 0x0b0a0908, 0x0f0e0d0c,
+  0x13121110, 0x17161514, 0x1b1a1918, 0x1f1e1d1c
+} ;
+#define end ((unsigned char *) &littleendian)
+#define data ((unsigned char *) s->in)
+#define outdata ((unsigned char *) s->out)
+
+extern void surf( unsigned int out[8], const unsigned int in[12], const unsigned int seed[32] );
+extern void surfpcs_init( surfpcs *s, const unsigned int k[32] );
+extern void surfpcs_add( surfpcs *s, const char *x,unsigned int n );
+extern void surfpcs_addlc( surfpcs *s, const char *x,unsigned int n );
+extern void surfpcs_out( surfpcs *s, unsigned char h[32] );
+#endif
+
+
+#ifndef SUBHASH_H
+#define SUBHASH_H
+
+unsigned int subhashs(const char *s);
+unsigned int subhashb(const char *s,long len);
+#define subhashsa(SA) subhashb((SA)->s,(SA)->len)
+
+#endif
+

data/lib/ezmlm.rb

@@ -0,0 +1,65 @@
+# vim: set nosta noet ts=4 sw=4:
+
+
+# A Ruby interface to the ezmlm-idx mailing list system.
+#
+#   Ezmlm.find_directories( '/lists' ) #=> [ Ezmlm::List, Ezmlm::List ]
+#
+#   Ezmlm.each_list( '/lists' ) do |list|
+#       puts "\"%s\" <%s>" % [ list.name, list.address ]
+#   end
+#
+#
+# == Version
+#
+#  $Id: ezmlm.rb,v 9aaac749fd9f 2017/05/16 20:58:52 mahlon $
+#
+#---
+#
+# Please see the file LICENSE in the base directory for licensing details.
+#
+
+require 'pathname'
+
+
+### Toplevel namespace module
+module Ezmlm
+
+	# Package version
+	VERSION = '1.0.0'
+
+	# Suck in the components.
+	#
+	require 'ezmlm/hash'
+	require 'ezmlm/list'
+	require 'ezmlm/list/author'
+	require 'ezmlm/list/message'
+	require 'ezmlm/list/thread'
+
+
+	###############
+	module_function
+	###############
+
+	### Find all directories that look like an Ezmlm list directory under
+	### the specified +listsdir+ and return Pathname objects for each.
+	###
+	def find_directories( listsdir )
+		listsdir = Pathname.new( listsdir )
+		return Pathname.glob( listsdir + '*' ).sort.select do |entry|
+			entry.directory? && ( entry + 'mailinglist' ).exist?
+		end
+	end
+
+
+	### Iterate over each directory that looks like an Ezmlm list in the
+	### specified +listsdir+ and yield it as an Ezmlm::List object.
+	###
+	def each_list( listsdir )
+		find_directories( listsdir ).each do |entry|
+			yield( Ezmlm::List.new(entry) )
+		end
+	end
+
+end # module Ezmlm
+

data/lib/ezmlm/list.rb

@@ -0,0 +1,834 @@
+#!/usr/bin/ruby
+# vim: set nosta noet ts=4 sw=4:
+
+
+# A Ruby interface to a single Ezmlm-idx mailing list directory.
+#
+#    list = Ezmlm::List.new( '/path/to/listdir' )
+#
+#
+# == Version
+#
+#  $Id: list.rb,v 23c7f5c8ee39 2017/05/16 20:58:34 mahlon $
+#
+#---
+
+require 'pathname'
+require 'time'
+require 'etc'
+require 'ezmlm' unless defined?( Ezmlm )
+
+
+### A Ruby interface to an ezmlm-idx mailing list directory
+###
+class Ezmlm::List
+
+	# Valid subdirectories/sections for subscriptions.
+	SUBSCRIPTION_DIRS = %w[ deny mod digest allow ]
+
+
+	### Create a new Ezmlm::List object for the specified +listdir+, which should be
+	### an ezmlm-idx mailing list directory.
+	###
+	def initialize( listdir )
+		listdir = Pathname.new( listdir ) unless listdir.is_a?( Pathname )
+		unless listdir.directory? && ( listdir + 'mailinglist' ).exist?
+			raise ArgumentError, "%p doesn't appear to be an ezmlm-idx list." % [ listdir.to_s ]
+		end
+		@listdir = listdir
+	end
+
+	# The Pathname object for the list directory
+	attr_reader :listdir
+
+
+	### Return the configured name of the list (without the host)
+	###
+	def name
+		@name = self.read( 'outlocal' ) unless @name
+		return @name
+	end
+
+
+	### Return the configured host of the list
+	###
+	def host
+		@host = self.read( 'outhost' ) unless @host
+		return @host
+	end
+
+
+	### Return the configured address of the list (in list@host form)
+	###
+	def address
+		return "%s@%s" % [ self.name, self.host ]
+	end
+	alias_method :fullname, :address
+
+
+	### Return the email address of the list's owner.
+	###
+	def owner
+		owner = self.read( 'owner' )
+		return owner =~ /@/ ? owner : nil
+	end
+
+
+	### Returns +true+ if +address+ is a subscriber to this list.
+	###
+	def include?( addr, section: nil )
+		addr.downcase!
+		file = self.subscription_dir( section ) + Ezmlm::Hash.subscriber( addr )
+		return false unless file.exist?
+		return file.read.scan( /T([^\0]+)\0/ ).flatten.include?( addr )
+	end
+	alias_method :is_subscriber?, :include?
+
+
+	### Fetch a sorted Array of the email addresses for all of the list's
+	### subscribers.
+	###
+	def subscribers
+		return self.read_subscriber_dir
+	end
+
+
+	### Subscribe +addr+ to the list within +section+.
+	###
+	def subscribe( *addr, section: nil )
+		addr.each do |address|
+			next unless address.index( '@' )
+			address.downcase!
+
+			file = self.subscription_dir( section ) + Ezmlm::Hash.subscriber( address )
+			self.with_safety do
+				if file.exist?
+					addresses = file.read.scan( /T([^\0]+)\0/ ).flatten
+					addresses << address
+					file.open( 'w' ) do |f|
+						f.print addresses.uniq.sort.map{|a| "T#{a}\0" }.join
+					end
+
+				else
+					file.open( 'w' ) do |f|
+						f.print "T%s\0" % [ address ]
+					end
+				end
+			end
+		end
+	end
+	alias_method :add_subscriber, :subscribe
+
+
+	### Unsubscribe +addr+ from the list within +section+.
+	###
+	def unsubscribe( *addr, section: nil )
+		addr.each do |address|
+			address.downcase!
+
+			file = self.subscription_dir( section ) + Ezmlm::Hash.subscriber( address )
+			self.with_safety do
+				next unless file.exist?
+				addresses = file.read.scan( /T([^\0]+)\0/ ).flatten
+				addresses = addresses - [ address ]
+
+				if addresses.empty?
+					file.unlink
+				else
+					file.open( 'w' ) do |f|
+						f.print addresses.uniq.sort.map{|a| "T#{a}\0" }.join
+					end
+				end
+			end
+		end
+	end
+	alias_method :remove_subscriber, :unsubscribe
+
+
+	### Returns an Array of email addresses of people responsible for
+	### moderating subscription of a closed list.
+	###
+	def moderators
+		return self.read_subscriber_dir( 'mod' )
+	end
+
+	### Returns +true+ if +address+ is a moderator.
+	###
+	def is_moderator?( addr )
+		return self.include?( addr, section: 'mod' )
+	end
+
+	### Subscribe +addr+ to the list as a Moderator.
+	###
+	def add_moderator( *addr )
+		return self.subscribe( *addr, section: 'mod' )
+	end
+
+	### Remove +addr+ from the list as a Moderator.
+	###
+	def remove_moderator( *addr )
+		return self.unsubscribe( *addr, section: 'mod' )
+	end
+
+
+	### Returns an Array of email addresses denied access
+	### to the list.
+	###
+	def blacklisted
+		return self.read_subscriber_dir( 'deny' )
+	end
+
+	### Returns +true+ if +address+ is disallowed from participating.
+	###
+	def is_blacklisted?( addr )
+		return self.include?( addr, section: 'deny' )
+	end
+
+	### Blacklist +addr+ from the list.
+	###
+	def add_blacklisted( *addr )
+		return self.subscribe( *addr, section: 'deny' )
+	end
+
+	### Remove +addr+ from the blacklist.
+	###
+	def remove_blacklisted( *addr )
+		return self.unsubscribe( *addr, section: 'deny' )
+	end
+
+
+
+	### Returns an Array of email addresses that act like
+	### regular subscribers for user-post only lists.
+	###
+	def allowed
+		return self.read_subscriber_dir( 'allow' )
+	end
+
+	### Returns +true+ if +address+ is given the same benefits as a
+	### regular subscriber for user-post only lists.
+	###
+	def is_allowed?( addr )
+		return self.include?( addr, section: 'allow' )
+	end
+
+	### Add +addr+ to allow posting to user-post only lists,
+	### when +addr+ isn't a subscriber.
+	###
+	def add_allowed( *addr )
+		return self.subscribe( *addr, section: 'allow' )
+	end
+
+	### Remove +addr+ from the allowed list.
+	###
+	def remove_allowed( *addr )
+		return self.unsubscribe( *addr, section: 'allow' )
+	end
+
+
+	### Returns +true+ if the list is configured to respond
+	### to remote management requests.
+	###
+	def public?
+		return ( self.listdir + 'public' ).exist?
+	end
+
+	### Disable or enable remote management requests.
+	###
+	def public=( enable=true )
+		if enable
+			self.touch( 'public' )
+		else
+			self.unlink( 'public' )
+		end
+	end
+	alias_method :public, :public=
+
+	### Returns +true+ if the list is not configured to respond
+	### to remote management requests.
+	###
+	def private?
+		return ! self.public?
+	end
+
+	### Disable or enable remote management requests.
+	###
+	def private=( enable=false )
+		self.public = ! enable
+	end
+	alias_method :private, :private=
+
+
+	### Returns +true+ if the list supports remote administration
+	### subscribe/unsubscribe requests from moderators.
+	###
+	def remote_subscriptions?
+		return ( self.listdir + 'remote' ).exist?
+	end
+
+	### Disable or enable remote subscription requests.
+	###
+	def remote_subscriptions=( enable=false )
+		if enable
+			self.touch( 'remote' )
+		else
+			self.unlink( 'remote' )
+		end
+	end
+	alias_method :remote_subscriptions, :remote_subscriptions=
+
+
+	### Returns +true+ if list subscription requests require moderator
+	### approval.
+	###
+	def moderated_subscriptions?
+		return ( self.listdir + 'modsub' ).exist?
+	end
+
+	### Disable or enable subscription moderation.
+	###
+	def moderated_subscriptions=( enable=false )
+		if enable
+			self.touch( 'modsub' )
+		else
+			self.unlink( 'modsub' )
+		end
+	end
+	alias_method :moderated_subscriptions, :moderated_subscriptions=
+
+	### Returns +true+ if message moderation is enabled.
+	###
+	def moderated?
+		return ( self.listdir + 'modpost' ).exist?
+	end
+
+	### Disable or enable message moderation.
+	###
+	### This has special meaning when combined with user_posts_only setting.
+	### Lists act as unmoderated for subscribers, and posts from unknown
+	### addresses go to moderation.
+	###
+	def moderated=( enable=false )
+		if enable
+			self.touch( 'modpost' )
+			self.touch( 'noreturnposts' ) if self.user_posts_only?
+		else
+			self.unlink( 'modpost' )
+			self.unlink( 'noreturnposts' ) if self.user_posts_only?
+		end
+	end
+	alias_method :moderated, :moderated=
+
+
+	### Returns +true+ if posting is only allowed by moderators.
+	###
+	def moderator_posts_only?
+		return ( self.listdir + 'modpostonly' ).exist?
+	end
+
+	### Disable or enable moderation only posts.
+	###
+	def moderator_posts_only=( enable=false )
+		if enable
+			self.touch( 'modpostonly' )
+		else
+			self.unlink( 'modpostonly' )
+		end
+	end
+	alias_method :moderator_posts_only, :moderator_posts_only=
+
+
+	### Returns +true+ if posting is only allowed by subscribers.
+	###
+	def user_posts_only?
+		return ( self.listdir + 'subpostonly' ).exist?
+	end
+
+	### Disable or enable user only posts.
+	### This is easily defeated, moderated lists are preferred.
+	###
+	### This has special meaning for moderated lists.  Lists act as
+	### unmoderated for subscribers, and posts from unknown addresses
+	### go to moderation.
+	###
+	def user_posts_only=( enable=false )
+		if enable
+			self.touch( 'subpostonly' )
+			self.touch( 'noreturnposts' )if self.moderated?
+		else
+			self.unlink( 'subpostonly' )
+			self.unlink( 'noreturnposts' ) if self.moderated?
+		end
+	end
+	alias_method :user_posts_only, :user_posts_only=
+
+
+	### Returns +true+ if message archival is enabled.
+	###
+	def archived?
+		test = %w[ archived indexed threaded ].each_with_object( [] ) do |f, acc|
+			acc << self.listdir + f
+		end
+
+		return test.all?( &:exist? )
+	end
+
+	### Disable or enable message archiving (and indexing/threading.)
+	###
+	def archived=( enable=true )
+		if enable
+			self.touch( 'archived', 'indexed', 'threaded' )
+		else
+			self.unlink( 'archived', 'indexed', 'threaded' )
+		end
+	end
+	alias_method :archived, :archived=
+
+	### Returns +true+ if the message archive is accessible only to
+	### moderators.
+	###
+	def private_archive?
+		return ( self.listdir + 'modgetonly' ).exist?
+	end
+
+	### Disable or enable private access to the archive.
+	###
+	def private_archive=( enable=true )
+		if enable
+			self.touch( 'modgetonly' )
+		else
+			self.unlink( 'modgetonly' )
+		end
+	end
+	alias_method :private_archive, :private_archive=
+
+	### Returns +true+ if the message archive is accessible to anyone.
+	###
+	def public_archive?
+		return ! self.private_archive?
+	end
+
+	### Disable or enable private access to the archive.
+	###
+	def public_archive=( enable=true )
+		self.private_archive = ! enable
+	end
+	alias_method :public_archive, :public_archive=
+
+	### Returns +true+ if the message archive is accessible only to
+	### list subscribers.
+	###
+	def guarded_archive?
+		return ( self.listdir + 'subgetonly' ).exist?
+	end
+
+	### Disable or enable loimited access to the archive.
+	###
+	def guarded_archive=( enable=true )
+		if enable
+			self.touch( 'subgetonly' )
+		else
+			self.unlink( 'subgetonly' )
+		end
+	end
+	alias_method :guarded_archive, :guarded_archive=
+
+
+	### Returns +true+ if message digests are enabled.
+	###
+	def digested?
+		return ( self.listdir + 'digested' ).exist?
+	end
+
+	### Disable or enable message digesting.
+	###
+	def digest=( enable=true )
+		if enable
+			self.touch( 'digested' )
+		else
+			self.unlink( 'digested' )
+		end
+	end
+	alias_method :digest, :digest=
+
+	### If the list is digestable, trigger the digest after this amount
+	### of message body since the latest digest, in kbytes.
+	###
+	### See: ezmlm-tstdig(1)
+	###
+	def digest_kbytesize
+		size = self.read( 'digsize' ).to_i
+		return size.zero? ? 64 : size
+	end
+
+	### If the list is digestable, trigger the digest after this amount
+	### of message body since the latest digest, in kbytes.
+	###
+	### See: ezmlm-tstdig(1)
+	###
+	def digest_kbytesize=( size=64 )
+		self.write( 'digsize' ) {|f| f.puts size.to_i }
+	end
+
+	### If the list is digestable, trigger the digest after this many
+	### messages have accumulated since the latest digest.
+	###
+	### See: ezmlm-tstdig(1)
+	###
+	def digest_count
+		count = self.read( 'digcount' ).to_i
+		return count.zero? ? 30 : count
+	end
+
+	### If the list is digestable, trigger the digest after this many
+	### messages have accumulated since the latest digest.
+	###
+	### See: ezmlm-tstdig(1)
+	###
+	def digest_count=( count=30 )
+		self.write( 'digcount' ) {|f| f.puts count.to_i }
+	end
+
+	### If the list is digestable, trigger the digest after this much
+	### time has passed since the last digest, in hours.
+	###
+	### See: ezmlm-tstdig(1)
+	###
+	def digest_timeout
+		hours = self.read( 'digtime' ).to_i
+		return hours.zero? ? 48 : hours
+	end
+
+	### If the list is digestable, trigger the digest after this much
+	### time has passed since the last digest, in hours.
+	###
+	### See: ezmlm-tstdig(1)
+	###
+	def digest_timeout=( hours=48 )
+		self.write( 'digtime' ) {|f| f.puts hours.to_i }
+	end
+
+
+	### Returns +true+ if the list requires subscriptions to be
+	### confirmed.  AKA "help" mode if disabled.
+	###
+	def confirm_subscriptions?
+		return ! ( self.listdir + 'nosubconfirm' ).exist?
+	end
+
+	### Disable or enable subscription confirmation.
+	### AKA "help" mode if disabled.
+	###
+	def confirm_subscriptions=( enable=true )
+		if enable
+			self.unlink( 'nosubconfirm' )
+		else
+			self.touch( 'nosubconfirm' )
+		end
+	end
+	alias_method :confirm_subscriptions, :confirm_subscriptions=
+
+	### Returns +true+ if the list requires unsubscriptions to be
+	### confirmed.  AKA "jump" mode.
+	###
+	def confirm_unsubscriptions?
+		return ! ( self.listdir + 'nounsubconfirm' ).exist?
+	end
+
+	### Disable or enable unsubscription confirmation.
+	### AKA "jump" mode.
+	###
+	def confirm_unsubscriptions=( enable=true )
+		if enable
+			self.unlink( 'nounsubconfirm' )
+		else
+			self.touch( 'nounsubconfirm' )
+		end
+	end
+	alias_method :confirm_unsubscriptions, :confirm_unsubscriptions=
+
+
+	### Returns +true+ if the list requires regular message postings
+	### to be confirmed by the original sender.
+	###
+	def confirm_postings?
+		return ( self.listdir + 'confirmpost' ).exist?
+	end
+
+	### Disable or enable message confirmation.
+	###
+	def confirm_postings=( enable=false )
+		if enable
+			self.touch( 'confirmpost' )
+		else
+			self.unlink( 'confirmpost' )
+		end
+	end
+	alias_method :confirm_postings, :confirm_postings=
+
+
+	### Returns +true+ if the list allows moderators to
+	### fetch a subscriber list remotely.
+	###
+	def allow_remote_listing?
+		return ( self.listdir + 'modcanlist' ).exist?
+	end
+
+	### Disable or enable the ability for moderators to
+	### remotely fetch a subscriber list.
+	###
+	def allow_remote_listing=( enable=false )
+		if enable
+			self.touch( 'modcanlist' )
+		else
+			self.unlink( 'modcanlist' )
+		end
+	end
+	alias_method :allow_remote_listing, :allow_remote_listing=
+
+
+	### Returns +true+ if the list automatically manages
+	### bouncing subscriber addresses.
+	###
+	def bounce_warnings?
+		return ! ( self.listdir + 'nowarn' ).exist?
+	end
+
+	### Disable or enable automatic bounce probes and warnings.
+	###
+	def bounce_warnings=( enable=true )
+		if enable
+			self.unlink( 'nowarn' )
+		else
+			self.touch( 'nowarn' )
+		end
+	end
+	alias_method :bounce_warnings, :bounce_warnings=
+
+
+	### Return the maximum message size, in bytes.  Messages larger than
+	### this size will be rejected.
+	###
+	### See: ezmlm-reject(1)
+	###
+	def maximum_message_size
+		size = self.read( 'msgsize' )
+		return size ? size.split( ':' ).first.to_i : 0
+	end
+
+	### Set the maximum message size, in bytes.  Messages larger than
+	### this size will be rejected.  Defaults to 300kb.
+	###
+	### See: ezmlm-reject(1)
+	###
+	def maximum_message_size=( size=307200 )
+		if size.to_i.zero?
+			self.unlink( 'msgsize' )
+		else
+			self.write( 'msgsize' ) {|f| f.puts "#{size.to_i}:0" }
+		end
+	end
+
+
+
+	### Return the number of messages in the list archive.
+	###
+	def message_count
+		count = self.read( 'archnum' )
+		return count ? Integer( count ) : 0
+	end
+
+	### Returns an individual message if archiving was enabled.
+	###
+	def message( message_id )
+		raise "Message archive is empty." if self.message_count.zero?
+		return Ezmlm::List::Message.new( self, message_id ) rescue nil
+	end
+
+	### Lazy load each message ID as a Ezmlm::List::Message,
+	### yielding it to the block.
+	###
+	def each_message
+		( 1 .. self.message_count ).each do |id|
+			yield self.message( id )
+		end
+	end
+
+
+	### Return a Thread object for the given +thread_id+.
+	###
+	def thread( thread_id )
+		return Ezmlm::List::Thread.new( self, thread_id ) rescue nil
+	end
+
+
+	### Return an Author object for the given +author_id+, which
+	### could also be an email address.
+	###
+	def author( author_id )
+		author_id = Ezmlm::Hash.address(author_id) if author_id.index( '@' )
+		return Ezmlm::List::Author.new( self, author_id ) rescue nil
+	end
+
+
+	### Parse all thread indexes into a single array that can be used
+	### as a lookup table.
+	###
+	### These are not expanded into objects, use #message, #thread,
+	### and #author to do so.
+	###
+	def index
+		raise "Archiving is not enabled." unless self.archived?
+		archivedir = listdir + 'archive'
+
+		idx = ( 0 .. self.message_count / 100 ).each_with_object( [] ) do |dir, acc|
+			index = archivedir + dir.to_s + 'index'
+			next unless index.exist?
+
+			index.open( 'r', encoding: Encoding::ISO8859_1 ) do |fh|
+				fh.each_line.lazy.slice_before( /^\d+:/ ).each do |message|
+
+					match = message[0].match( /^(?<message_id>\d+): (?<thread_id>\w+)/ )
+					next unless match
+					thread_id  = match[ :thread_id ]
+
+					match = message[1].match( /^(?<date>[^;]+);(?<author_id>\w+) / )
+					next unless match
+					author_id  = match[ :author_id ]
+					date       = match[ :date ]
+
+					metadata = {
+						date:   Time.parse( date ),
+						thread: thread_id,
+						author: author_id
+					}
+					acc << metadata
+				end
+			end
+		end
+
+		return idx
+	end
+
+
+	#########
+	protected
+	#########
+
+	### Just return the contents of the provided +file+, rooted
+	### in the list directory.
+	###
+	def read( file )
+		file = self.listdir + file unless file.is_a?( Pathname )
+		return file.read.chomp
+	rescue
+		nil
+	end
+
+
+	### Overwrite +file+ safely, yielding the open filehandle to the
+	### block.  Set the new file to correct ownership and permissions.
+	###
+	def write( file, &block )
+		file = self.listdir + file unless file.is_a?( Pathname )
+		self.with_safety do
+			file.open( 'w' ) do |f|
+				yield( f )
+			end
+
+			stat = self.listdir.stat
+			file.chown( stat.uid, stat.gid )
+			file.chmod( 0600 )
+		end
+	end
+
+
+	### Simply create an empty file, safely.
+	###
+	def touch( *file )
+		self.with_safety do
+			Array( file ).flatten.each do |f|
+				f = self.listdir + f unless f.is_a?( Pathname )
+				f.open( 'w' ) {}
+			end
+		end
+	end
+
+
+	### Delete +file+ safely.
+	###
+	def unlink( *file )
+		self.with_safety do
+			Array( file ).flatten.each do |f|
+				f = self.listdir + f unless f.is_a?( Pathname )
+				next unless f.exist?
+				f.unlink
+			end
+		end
+	end
+
+
+	### Return a Pathname to a subscription directory.
+	###
+	def subscription_dir( section=nil )
+		if section
+			unless SUBSCRIPTION_DIRS.include?( section )
+				raise "Invalid subscription dir: %s, must be one of: %s" % [
+					section,
+					SUBSCRIPTION_DIRS.join( ', ' )
+				]
+			end
+			return self.listdir + section + 'subscribers'
+		else
+			return self.listdir + 'subscribers'
+		end
+	end
+
+
+	### Read the hashed subscriber email addresses from the specified
+	### +directory+ and return them in an Array.
+	###
+	def read_subscriber_dir( section=nil )
+		directory = self.subscription_dir( section )
+		rval = []
+		Pathname.glob( directory + '*' ) do |hashfile|
+			rval.push( hashfile.read.scan(/T([^\0]+)\0/) )
+		end
+
+		return rval.flatten.sort
+	end
+
+
+	### Return a Pathname object for the list owner's home directory.
+	###
+	def homedir
+		user = Etc.getpwuid( self.listdir.stat.uid )
+		return Pathname( user.dir )
+	end
+
+
+	### Safely make modifications to a file within a list directory.
+	###
+	### Mail can come in at any time.  Make changes within a list
+	### atomic -- if an incoming message hits when a sticky
+	### is set, it is deferred to the Qmail queue.
+	###
+	###   - Set sticky bit on the list directory owner's homedir
+	###   - Make changes with the block
+	###   - Unset sticky (just back to what it was previously)
+	###
+	### All writes should be wrapped in this method.
+	###
+	def with_safety( &block )
+		home = self.homedir
+		mode = home.stat.mode
+
+		home.chmod( mode | 01000 ) # enable sticky
+		yield
+
+	ensure
+		home.chmod( mode )
+	end
+
+end # class Ezmlm::List
+