Initial Alpine Version

author: Eduardo Chappa <echappa@gmx.com> 2013-02-03 00:59:38 -0700
committer: Eduardo Chappa <echappa@gmx.com> 2013-02-03 00:59:38 -0700
commit: 094ca96844842928810f14844413109fc6cdd890 (patch)
tree: e60efbb980f38ba9308ccb4fb2b77b87bbc115f3 /contrib
download: alpine-094ca96844842928810f14844413109fc6cdd890.tar.xz
42 files changed, 11763 insertions, 0 deletions
diff --git a/contrib/bitmaps/pine.icon b/contrib/bitmaps/pine.icon
new file mode 100644
index 00000000..e5cd051b
--- /dev/null
+++ b/contrib/bitmaps/pine.icon
@@ -0,0 +1,43 @@
+#define icon_width 60
+#define icon_height 60
+static char icon_bits[] = {
+   0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xe3, 0x50,
+   0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x50, 0x01, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x1c, 0xe8, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0xd8,
+   0x02, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0xe8, 0x05, 0x00, 0x00, 0x00,
+   0x80, 0x71, 0x00, 0x5c, 0x05, 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0xf4,
+   0x02, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x6a, 0x05, 0x00, 0x00, 0x00,
+   0x00, 0x02, 0x00, 0xf4, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6f,
+   0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xfa, 0x0c, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x76, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x77,
+   0x07, 0x00, 0x18, 0x07, 0x00, 0x00, 0x80, 0xec, 0x0a, 0x00, 0xe0, 0x01,
+   0x00, 0x00, 0xe0, 0xff, 0x13, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x30, 0xfb,
+   0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x7c, 0x35, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0xef, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xfd,
+   0x3b, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xfe, 0x45, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0xe0, 0xff, 0x9c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0xf9,
+   0x2f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x98, 0xfe, 0xfd, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x80, 0xf7, 0xce, 0x01, 0x00, 0x00, 0x00, 0x00, 0x40, 0xee,
+   0x35, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xf9, 0xc9, 0x01, 0x00, 0x00,
+   0x00, 0x00, 0x7c, 0xfe, 0x1f, 0x06, 0x00, 0x00, 0x00, 0x00, 0x8e, 0xff,
+   0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe3, 0xf7, 0xbf, 0x07, 0x00, 0x00,
+   0x00, 0x00, 0xc0, 0xed, 0xf7, 0x7f, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xf3,
+   0xcf, 0xf0, 0x01, 0x00, 0x00, 0x00, 0xfc, 0xff, 0x7c, 0x01, 0x00, 0x00,
+   0x00, 0x00, 0xef, 0xf8, 0xe7, 0x07, 0x00, 0x00, 0x00, 0xc0, 0x33, 0xff,
+   0xf9, 0x1d, 0x00, 0x00, 0x00, 0x60, 0xde, 0xfd, 0x8e, 0xf6, 0x03, 0x00,
+   0x00, 0x00, 0xfa, 0xf3, 0xff, 0x39, 0x06, 0x00, 0x00, 0x00, 0xfe, 0xff,
+   0xf6, 0x40, 0x00, 0x00, 0x00, 0x80, 0xf7, 0xfc, 0xdb, 0x0f, 0x00, 0x00,
+   0x00, 0x70, 0x8f, 0xfb, 0xfb, 0x3f, 0x00, 0x00, 0x00, 0xfc, 0x60, 0xff,
+   0xff, 0xe0, 0x00, 0x00, 0x00, 0x8f, 0x7d, 0xff, 0xff, 0x3f, 0x00, 0x00,
+   0x00, 0x00, 0xef, 0xfc, 0xec, 0xf7, 0x01, 0x00, 0x00, 0xe0, 0x9e, 0xff,
+   0xfd, 0xdd, 0x03, 0x00, 0x00, 0xf8, 0xf1, 0xff, 0x0f, 0xff, 0x3f, 0x00,
+   0x00, 0x5c, 0xcc, 0xfe, 0x7f, 0x0c, 0x00, 0x00, 0x80, 0xb3, 0xfb, 0xfb,
+   0xbf, 0x73, 0x00, 0x00, 0xc0, 0x60, 0xff, 0xf5, 0xfb, 0x9c, 0x01, 0x00,
+   0x00, 0xfc, 0xfc, 0xfb, 0xed, 0xe1, 0x06, 0x00, 0x80, 0x0f, 0x8e, 0xff,
+   0xc5, 0x03, 0x1f, 0x00, 0xe0, 0x81, 0x83, 0xf2, 0x69, 0x07, 0x70, 0x00,
+   0x18, 0xc0, 0x00, 0xf0, 0x09, 0x1c, 0x80, 0x01, 0x00, 0x00, 0x00, 0xf0,
+   0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x01, 0x40, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0,
+   0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x01, 0x00, 0x00, 0x00};
diff --git a/contrib/bitmaps/pine2.icon b/contrib/bitmaps/pine2.icon
new file mode 100755
index 00000000..ae5fa74f
--- /dev/null
+++ b/contrib/bitmaps/pine2.icon
@@ -0,0 +1,33 @@
+#define crow_width 50
+#define crow_height 50
+static char crow_bits[] = {
+   0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x38,
+   0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x7c, 0x00, 0x00, 0x80, 0x08, 0x00,
+   0x00, 0xfe, 0x00, 0x00, 0x40, 0x10, 0x00, 0x00, 0xff, 0x01, 0x00, 0x80,
+   0x08, 0x80, 0x00, 0xfe, 0x00, 0x00, 0x40, 0x10, 0xc0, 0x01, 0xff, 0x01,
+   0x00, 0x20, 0x20, 0xe0, 0x83, 0xff, 0x03, 0x00, 0x10, 0x40, 0xf0, 0xc7,
+   0xff, 0x07, 0x00, 0x22, 0x20, 0xf8, 0xef, 0xff, 0x0f, 0x00, 0x17, 0x40,
+   0xe0, 0xc3, 0xfd, 0x87, 0x00, 0x0f, 0x80, 0xf0, 0xe7, 0xf8, 0xcf, 0x01,
+   0x07, 0x00, 0xf9, 0x7f, 0xf0, 0xff, 0x03, 0x0f, 0x80, 0xfc, 0x3f, 0xf0,
+   0xff, 0x03, 0x07, 0x00, 0xff, 0x7f, 0xf8, 0xff, 0x03, 0x03, 0x00, 0xff,
+   0x7f, 0xf0, 0xff, 0x03, 0x01, 0x00, 0xfe, 0x1f, 0xe0, 0xfd, 0x03, 0x02,
+   0x00, 0xfe, 0x3f, 0xc0, 0xf8, 0x03, 0x01, 0x00, 0xff, 0x7f, 0x40, 0xf0,
+   0x03, 0x00, 0x80, 0xff, 0xff, 0x80, 0xf8, 0x03, 0x00, 0xc0, 0xff, 0xff,
+   0x41, 0xf0, 0x03, 0x00, 0xe0, 0xff, 0xff, 0x23, 0xe0, 0x03, 0x00, 0x80,
+   0xff, 0xff, 0x40, 0xf0, 0x03, 0x00, 0xc0, 0xff, 0xff, 0x21, 0xe0, 0x03,
+   0x00, 0xe0, 0xff, 0xff, 0x13, 0xc0, 0x03, 0x00, 0xf0, 0xff, 0xff, 0x27,
+   0xe0, 0x03, 0x00, 0xf8, 0xff, 0xff, 0x1f, 0xc0, 0x03, 0x10, 0xfc, 0xff,
+   0xff, 0x1f, 0x80, 0x03, 0x28, 0xf0, 0xff, 0xff, 0x0f, 0xc0, 0x03, 0x44,
+   0xf8, 0xff, 0xff, 0x0f, 0x80, 0x03, 0x82, 0xfc, 0xff, 0xff, 0x1f, 0x00,
+   0x03, 0x44, 0xfe, 0xff, 0xff, 0x3f, 0x80, 0x03, 0x82, 0xff, 0xff, 0xff,
+   0x7f, 0x00, 0x03, 0x01, 0xff, 0xff, 0xff, 0xff, 0x00, 0x02, 0x00, 0xfe,
+   0xff, 0xff, 0x3f, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x02,
+   0x00, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff,
+   0x01, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0xfc, 0xff,
+   0xff, 0xff, 0x07, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00,
+   0xf0, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0xe0, 0xff, 0xff, 0xff, 0xff,
+   0x03, 0x00, 0xf0, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x00, 0xe0, 0xff, 0xff,
+   0xff, 0x1f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00};
diff --git a/contrib/bitmaps/unixware/README b/contrib/bitmaps/unixware/README
new file mode 100644
index 00000000..685a45bb
--- /dev/null
+++ b/contrib/bitmaps/unixware/README
@@ -0,0 +1,20 @@
+
+
+Tim Rice	tim@trr.metro.net	Fri Apr 26 17:16:54 PDT 1996
+
+Here are the files needed to have the pine icon show up on the desktop.
+
+pine.cdb
+pine.icon
+pine48.icon
+
+--------< cut here for install script >-------
+:
+# quick & nasty install script
+cp pine.cdb /usr/X/lib/classdb
+cp pine.icon /usr/X/lib/pixmaps
+cp pine48.icon /usr/X/lib/pixmaps
+# tune permissions so "system owners" can modify
+chgrp dtadmin /usr/X/lib/classdb/pine.cdb /usr/X/lib/pixmaps/pine.icon /usr/X/lib/pixmaps/pine48.icon
+chmod g+w /usr/X/lib/classdb/pine.cdb /usr/X/lib/pixmaps/pine.icon /usr/X/lib/pixmaps/pine48.icon
+echo "INCLUDE pine.cdb;" >> /usr/X/lib/classdb/system
diff --git a/contrib/bitmaps/unixware/pine.cdb b/contrib/bitmaps/unixware/pine.cdb
new file mode 100644
index 00000000..a9e02d07
--- /dev/null
+++ b/contrib/bitmaps/unixware/pine.cdb
@@ -0,0 +1,11 @@
+CLASS 'Pine'
+BEGIN
+	_CLASSNAME	"Pine";
+	_FILETYPE	"EXEC";
+	_PROG_TYPE	"UNIX Character";
+	_ICONFILE	"pine.icon";
+	_MINIMIZED_ICONFILE	"pine48.icon";
+	MENU _Open	'exec xterm -e "%F" &';
+	_LPATTERN	"pine";
+END
+
diff --git a/contrib/bitmaps/unixware/pine.icon b/contrib/bitmaps/unixware/pine.icon
new file mode 100644
index 00000000..84b0f70c
--- /dev/null
+++ b/contrib/bitmaps/unixware/pine.icon
@@ -0,0 +1,45 @@
+#define pine_format 1
+#define pine_width 32
+#define pine_height 32
+#define pine_ncolors 4
+#define pine_chars_per_pixel 1
+static char * pine_colors[] = {
+" " , "#FFFFFFFFFFFF",
+"." , "#0000CF3C0000",
+"X" , "#30C234D33CF3",
+"o" , "#5D7555555144"
+} ;
+static char * pine_pixels[] = {
+"                .               ",
+"                .               ",
+"               ...              ",
+"               ...              ",
+"XXXX   XXX    . . .             ",
+"   XX XX      . . .             ",
+"    XXX      . ... .            ",
+"     X       .. .. .            ",
+"             . .... .           ",
+"            ... . . .           ",
+"            . .oo. .            ",
+"           . . oo . .   XXX   XX",
+"            . .oo. . .     XXXX ",
+"          .... oo ...       XX  ",
+"         . . ..oo.  ..          ",
+"           .. .oo .  .          ",
+"          ... .oo ...           ",
+"         .  .. oo. . .          ",
+"       ........oo...  .         ",
+"      ..  .. ..oo.....          ",
+"         .  ...oo . . ..        ",
+"          .... oo. . .. .       ",
+"         .. ...oo... ...        ",
+"        .. ....oo.. .   .       ",
+"       ........oo.  ...  .      ",
+"      ... .  ..oo..... .        ",
+"         .... .oo. ...  ...     ",
+"      .. ..  ..oo..  .  ...     ",
+"    .....  ....oo......    ..   ",
+"   ...   ......oo.. ......      ",
+"               oo               ",
+"               oo               "
+} ;
diff --git a/contrib/bitmaps/unixware/pine48.icon b/contrib/bitmaps/unixware/pine48.icon
new file mode 100644
index 00000000..ac9d18d3
--- /dev/null
+++ b/contrib/bitmaps/unixware/pine48.icon
@@ -0,0 +1,59 @@
+#define pine48_format 1
+#define pine48_width 48
+#define pine48_height 48
+#define pine48_ncolors 2
+#define pine48_chars_per_pixel 1
+static char * pine48_colors[] = {
+" " , "#FFFFFFFFFFFF",
+"." , "#000000000000"
+} ;
+static char * pine48_pixels[] = {
+"                                    .           ",
+"         .                         ...          ",
+"        . .                       .....         ",
+"       .   .                     .......        ",
+"      .     .                   .........       ",
+"       .   .           .         .......        ",
+"      .     .         ...       .........       ",
+"     .       .       .....     ...........      ",
+"    .         .     .......   .............     ",
+" .   .       .     ......... ...............    ",
+"... .         .      .....    ... .........    .",
+"....           .    .......  ...   .........  ..",
+"...             .  ............     ............",
+"....           .  ............      ............",
+"...             ...............    .............",
+"..              ...............     ............",
+".                ............        .... ......",
+" .               .............        ..   .....",
+".               ...............       .     ....",
+"               .................       .   .....",
+"              ...................     .     ....",
+"             .....................   .       ...",
+"               .................      .     ....",
+"              ...................    .       ...",
+"             .....................  .         ..",
+"            .......................  .       ...",
+"           ..........................         ..",
+"    .     ...........................          .",
+"   . .      ........................          ..",
+"  .   .    .........................           .",
+" .     .  ...........................           ",
+"  .   .  .............................         .",
+" .     ................................         ",
+".       ................................        ",
+"         .............................          ",
+"        ...............................         ",
+"         ...............................        ",
+"          ...............................       ",
+"           ...............................      ",
+"          .................................     ",
+"           ..............................       ",
+"            ..............................      ",
+"             ...................................",
+"            ................................    ",
+"             ................................   ",
+"              ................................  ",
+"                                                ",
+"                                                "
+} ;
diff --git a/contrib/carmel/README b/contrib/carmel/README
new file mode 100644
index 00000000..f893ad78
--- /dev/null
+++ b/contrib/carmel/README
@@ -0,0 +1,34 @@
+Further details on the Carmel driver and the modifications for
+the X-BWC-Glyph character set are under the doc directory.
+
+Building the Carmel driver
+--------------------------
+1. Build pine, the c-client and imapd as you would normally so
+   all machine dependent source directory links get set up correctly
+
+2. Copy all files from contrib/carmel/c-client into the Pine c-client
+   directory
+
+3. run "patch < Makefile.patch" to modify the Makefile.
+
+4. If you want the X-BWC-GLYPH character set stuff turned on in the
+   c-client for mail generated before 1994 make sure that
+   EXTRACFLAGS=-DBWC in the Makefile
+
+5. If you want the carmel driver to be the default for non-fully 
+   qualified names, change that in the Makefile for your system.
+
+6. If you want the X-BWC-Glyph display code turned on some patches
+   have to be applied to Pine.  If not, these steps can be skipped.
+   6a. Copy all the files from carmel/pine into the pine source 
+       directory.
+   6b. Run patch on each of them: "patch < makefile.ult", 
+       "patch < filter.c.pathc".
+   6c. You may have to add a -DBWC to the CFLAGS= line in the makefile
+       for your system if there is no patch file for your system.
+
+7. Remove the imapd executable imapd/imapd from the Pine source tree
+   to force it to be rebuilt (Make won't figure it out).
+
+8. Run build again from the top level directory
+
diff --git a/contrib/carmel/c-client/Makefile.patch b/contrib/carmel/c-client/Makefile.patch
new file mode 100644
index 00000000..9134d31a
--- /dev/null
+++ b/contrib/carmel/c-client/Makefile.patch
@@ -0,0 +1,49 @@
+*** Makefile	Tue Aug 23 16:42:37 1994
+--- Makefile.new	Wed Aug 31 18:40:39 1994
+***************
+*** 31,43 ****
+  # WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+  
+  
+  ARCHIVE=c-client.a
+  ARRC=ar rc
+  BINARIES=mail.o bezerk.o mtx.o tenex2.o mbox.o mh.o mmdf.o imap2.o pop3.o \
+  	news.o nntpcunx.o phile.o dummy.o smtp.o nntp.o rfc822.o misc.o \
+! 	osdep.o sm_unix.o
+  CFLAGS=$(EXTRACFLAGS)
+! DEFAULTDRIVERS=imap nntp pop3 mh mtx tenex mmdf bezerk news phile dummy
+  LDFLAGS=$(EXTRALDFLAGS)
+  LN=ln -s
+  MAKE=make
+--- 31,44 ----
+  # WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+  
+  
++ EXTRACFLAGS=-DBWC
+  ARCHIVE=c-client.a
+  ARRC=ar rc
+  BINARIES=mail.o bezerk.o mtx.o tenex2.o mbox.o mh.o mmdf.o imap2.o pop3.o \
+  	news.o nntpcunx.o phile.o dummy.o smtp.o nntp.o rfc822.o misc.o \
+! 	osdep.o sm_unix.o carmel.o carmel2.o
+  CFLAGS=$(EXTRACFLAGS)
+! DEFAULTDRIVERS=imap carmel carmel2 nntp pop3 mh mtx tenex mmdf bezerk news phile dummy
+  LDFLAGS=$(EXTRALDFLAGS)
+  LN=ln -s
+  MAKE=make
+***************
+*** 207,213 ****
+  
+  ult:	# Ultrix
+  	$(MAKE) mtest OS=$@ EXTRADRIVERS="$(EXTRADRIVERS)" \
+! 		STDPROTO=bezerkproto \
+  		CFLAGS="-g3 -O2 -Olimit 800 -Dconst= $(EXTRACFLAGS)" \
+  		LDFLAGS="-lauth $(EXTRALDFLAGS)"
+  
+--- 208,214 ----
+  
+  ult:	# Ultrix
+  	$(MAKE) mtest OS=$@ EXTRADRIVERS="$(EXTRADRIVERS)" \
+! 		STDPROTO=carmelproto \
+  		CFLAGS="-g3 -O2 -Olimit 800 -Dconst= $(EXTRACFLAGS)" \
+  		LDFLAGS="-lauth $(EXTRALDFLAGS)"
+  
diff --git a/contrib/carmel/c-client/bzk2cml.c b/contrib/carmel/c-client/bzk2cml.c
new file mode 100644
index 00000000..fcff6438
--- /dev/null
+++ b/contrib/carmel/c-client/bzk2cml.c
@@ -0,0 +1,103 @@
+#include <stdio.h>
+#include <ctype.h>
+#include <pwd.h>
+#include <sys/dir.h>
+#include "mail.h"
+#include "osdep.h"
+#include "carmel2.h"
+#include "carmel.h"
+
+char *last_path(), *cpystr();
+void carmel2_bezerk_mail();
+extern DRIVER carmeldriver;
+
+extern char carmel_20k_buf[20000];
+
+
+main(argc, argv)
+     int argc;
+     char **argv;
+{
+    char carmel_folder[500], *bezerk_folder;
+    MAILSTREAM *stream;
+
+    if(argc <= 1) {
+        fprintf(stderr, "Usage: bzk2cml <folder>\n");
+        exit(-1);
+    }
+
+    for(argv++; *argv != NULL; argv++) {
+        bezerk_folder = last_path(*argv);  /* Only last component of path */
+        sprintf(carmel_folder, "#carmel#%s", bezerk_folder);
+
+        if(carmel_create(NULL, carmel_folder) == 0) {
+            continue;
+        }
+
+
+        stream          = (MAILSTREAM *)fs_get(sizeof(MAILSTREAM));
+        stream->dtb     = &carmeldriver;
+        stream->mailbox = cpystr(carmel_folder);
+	stream->local   = NULL;
+
+        if(carmel_open(stream) == NULL) {
+            continue;
+        }
+
+        if(carmel2_lock(stream, stream->mailbox, WRITE_LOCK) < 0) {
+            fprintf(stderr, "Carmel folder %s locked\n", carmel_folder);
+            carmel_close(stream);
+            continue;
+        }
+          
+        carmel2_spool_mail(stream, *argv, stream->mailbox, 0);
+        carmel2_unlock(stream, stream->mailbox, WRITE_LOCK);
+        fprintf(stderr, "Folder \"%s\" copied to \"%s\"\n", *argv,
+                carmel_folder);
+        carmel_close(stream);
+    }
+}
+            
+
+        
+        
+        
+
+    
+
+char *last_path(path)
+     char *path;
+{
+    char *p;
+
+    p = path + strlen(path) - 1;
+
+    while(p > path && *p != '/')
+      p--;
+
+    if(*p == '/')
+      p++;
+    return(p);
+}
+     
+void
+mm_log(mess, code)
+     char *mess;
+     int code;
+{
+    fprintf(stderr, "%s\n", mess);
+}
+
+void
+mm_fatal()
+{
+    abort();
+}
+
+void mm_mailbox() {}
+void mm_critical() {}
+void mm_nocritical() {}
+void mm_searched() {}
+void mm_exists() {}
+void mm_expunged() {}
+
diff --git a/contrib/carmel/c-client/carmel-purge.sh b/contrib/carmel/c-client/carmel-purge.sh
new file mode 100644
index 00000000..87d35ceb
--- /dev/null
+++ b/contrib/carmel/c-client/carmel-purge.sh
@@ -0,0 +1,89 @@
+#!/bin/csh -f
+# vmail.purge - zaps all unindexed mail messages.
+#
+# The_Epoch             vick created this.
+# 1988 Nov 10 Thu 12:00 bob added code to allow a pathname for $1.
+# 1988 Nov 14 Mon 10:14 bob rewrote the code that was breaking inside `quotes`.
+# 1988 Nov 15 Tue 16:44 bob added code to track spurious .vmail files
+# 1988 Nov 16 Wed 10:44 bob redirected error messages to stderr.
+# 1989 Feb 14 Tue 13:37 bob add exceptions for corrupt indexes
+# 1991 Sun Nov 24 10:30 Shoa add removal of RECOVER index.
+# 1992 Oct 21 Wed 17:01 bob check for Pine read lock files, and abort.
+
+#
+# Usage: vmail.purge [ username | somepath/username/.vmail ]
+
+
+set pname = $0
+set pname = ${pname:t}	    # name of this script for error messages
+
+set indexed =	/tmp/VMprg_idx.$$	# a list of indexed messages
+set messages =	/tmp/VMprg_msg.$$	# a list of all messages
+set unindexed = /tmp/VMprg_Csh.$$	# script to remove unindexed messages
+
+if ( 1 <= $#argv ) then
+    if ( ".vmail" == $1:t ) then	# assume /u/dp/bob/.vmail
+        set vpath = $1:h		# /u/dp/bob
+	setenv USER $vpath:t		# bob
+    else
+        setenv USER $1
+    endif
+endif
+
+if ( ! -d ~$USER/.vmail ) then
+    echo -n "${pname}: "
+    if ( 1 <= $#argv ) then
+    	sh -c "echo 1>&2  ${pname}: invalid argument $1"
+    else
+    	sh -c "echo 1>&2  ${pname}: $USER has no .vmail directory"
+    endif
+    exit 1
+endif
+
+cd ~$USER/.vmail
+
+if (!( -d index && -d msg)) then
+    sh -c "echo 1>&2 ${pname}: $cwd is missing required components"
+    exit 1
+endif
+#
+# check for Pine inbox read lock file
+if ( -e index/.MAIL.rl ) then
+    sh -c "echo 1>&2 ${pname}: $cwd is now running Pine"
+    exit 1
+endif
+#
+#
+#remove the temporary RECOVER index *must* be done before deletion of messages
+# start.
+if ( -e index/RECOVER ) then
+   rm index/RECOVER
+   if ( -e  ~$USER/.inda ) rm ~$USER/.inda
+   if ( -e  ~$USER/.indf ) rm ~$USER/.indf
+endif
+#
+#
+# create the shell script
+#
+awk '$1 ~ /^[0-9]/ {print  substr($1,1,6)}' index/* | sort | uniq > $indexed
+if ( $status ) then
+    	sh -c "echo 1>&2  ${pname}: some index probably corrupt"
+	exit 1
+endif
+
+ls msg | awk '{ print substr($1,1,6) }' > $messages
+comm -23 $messages $indexed | awk '{ print "rm -f " $1 " " $1 ".wid" }' > $unindexed
+
+# provide verbose statistics
+#
+echo $USER " total:" `wc -l < $messages` " indexed:" `wc -l < $indexed`\
+  " purging: " `wc -l < $unindexed`
+
+# do the work
+#
+cd msg
+csh -f $unindexed
+
+# cleanup
+#
+rm $messages $indexed $unindexed
diff --git a/contrib/carmel/c-client/carmel.c b/contrib/carmel/c-client/carmel.c
new file mode 100644
index 00000000..5265097d
--- /dev/null
+++ b/contrib/carmel/c-client/carmel.c
@@ -0,0 +1,1232 @@
+/*----------------------------------------------------------------------
+
+         T H E   C A R M E L   M A I L   D R I V E R
+
+  Author(s):   Laurence Lundblade
+               Baha'i World Centre
+               Data Processing
+               Haifa, Israel
+ 	       Internet: lgl@cac.washington.edu or laurence@bwc.org
+               September 1992
+
+  Last Edited: Aug 31, 1994
+
+The "Carmel" mail format is cutsom mail file format that has messages
+saved in individual files and an index file that references them. It
+has also been called the "pod" or "vmail" format. This is probably not
+of interest to anyone away from it's origin, though the Carmel2 format
+might be.
+
+This driver reads and writes the format in conjunction with the carmel2
+driver. The carmel2 file driver does most of the work as most of the
+operations are done on the created auxiliary carmel2 index and the
+carmel index is updated when the mail file is closed.
+
+  ----------------------------------------------------------------------*/
+
+
+#include <stdio.h>
+#include <ctype.h>
+#include <pwd.h>
+#include <netdb.h>
+#include <errno.h>
+extern int errno;		/* just in case */
+#include "mail.h"
+#include "osdep.h"
+#include <sys/dir.h>
+#include <sys/file.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include "carmel2.h"
+#include "carmel.h"
+#include "rfc822.h"
+#include "misc.h"
+
+
+/* Driver dispatch used by MAIL. The carmel 2driver shares most of
+   its data structures and functions with the carmel driver
+ */
+
+DRIVER carmeldriver = {
+  "carmel",
+  (DRIVER *) NIL,		/* next driver */
+  carmel_valid,			/* mailbox is valid for us */
+  carmel_parameters,            /* Set parameters */
+  carmel_find,			/* find mailboxes */
+  carmel_find_bboards,		/* find bboards */
+  carmel_find_all,              /* find all mailboxes */
+  carmel_find_bboards,          /* find all the bboards ; just a noop here  */
+  carmel_subscribe,	        /* subscribe to mailbox */
+  carmel_unsubscribe,	        /* unsubscribe from mailbox */
+  carmel_subscribe_bboard,	/* subscribe to bboard */
+  carmel_unsubscribe_bboard,    /* unsubscribe from bboard */
+  carmel_create,		/* create mailbox */
+  carmel_delete,		/* delete mailbox */
+  carmel_rename,		/* rename mailbox */
+  carmel_open,			/* open mailbox */
+  carmel_close,			/* close mailbox */
+  carmel2_fetchfast,		/* fetch message "fast" attributes */
+  carmel2_fetchflags,		/* fetch message flags */
+  carmel2_fetchstructure,	/* fetch message envelopes */
+  carmel2_fetchheader,		/* fetch message header only */
+  carmel2_fetchtext,		/* fetch message body only */
+  carmel2_fetchbody,		/* fetch message body section */
+  carmel2_setflag,		/* set message flag */
+  carmel2_clearflag,		/* clear message flag */
+  carmel2_search,		/* search for message based on criteria */
+  carmel2_ping,			/* ping mailbox to see if still alive */
+  carmel_check,	                /* check for new messages */
+  carmel_expunge,		/* expunge deleted messages */
+  carmel2_copy,			/* copy messages to another mailbox */
+  carmel2_move,			/* move messages to another mailbox */
+  carmel_append,                /* Append message to a mailbox */
+  carmel2_gc,			/* garbage collect stream */
+};
+
+MAILSTREAM carmelproto ={&carmeldriver}; /* HACK for default_driver in pine.c*/
+
+#ifdef ANSI
+static int   carmel_sift_files(struct direct *); 
+static void  carmel_recreate_index(MAILSTREAM *);
+static char  *carmel_calc_paths(int, char *, int);
+static int   vmail2carmel(char *, char *, MAILSTREAM *, char *, char *);
+static int   write_carmel_index(FILE *, MESSAGECACHE *, ENVELOPE *);
+static int   carmel_reset_index_list();
+static void  carmel_kill_locks(char *);
+#else
+static int   carmel_sift_files(); 
+static void  carmel_recreate_index();
+static char  *carmel_calc_paths();
+static int   vmail2carmel();
+static int   write_carmel_index();
+static int   carmel_reset_index_list();
+static void  carmel_kill_locks();
+#endif
+
+
+
+extern char carmel_20k_buf[20000], carmel_path_buf[], carmel_error_buf[];
+
+static int   disk_setup_checked = 0;
+
+/*----------------------------------------------------------------------
+  Carmel mail validate mailbox
+
+Args: name -- name to check
+
+Returns: our driver if name is valid, otherwise calls valid in next driver
+ ---*/
+
+DRIVER *carmel_valid (name)
+	char *name;
+{
+    return(carmel_isvalid(name) ? &carmeldriver : NIL);
+}
+
+
+
+/*----------------------------------------------------------------------
+    Check and see if a named mailbox is a valid carmel mail index
+
+Args: name -- name or path of mail file. It is a FQN, e.g. #carmel#sent-mail
+
+Returns:  0 if it is not a valid mailbox
+          1 if it is.
+      
+   A carmel index must be a regular file, readable, and have the second word in
+the file be "index", upper or lower case.
+  ----*/
+int 
+carmel_isvalid (name)
+	char *name;
+{
+    struct stat     sbuf;
+    int             fd;
+    char           *p, *carmel_index_file;
+    struct carmel_mb_name *parsed_name;
+
+    if(!disk_setup_checked){
+       disk_setup_checked = 1;
+       carmel_init(NULL);
+    }
+
+    /* Don't accept plain "inbox".  If we do then the carmel driver
+       takes over all other drivers linked after it.  This way the 
+       inbox-path in Pine can be set to #carmel#MAIL to make the
+       inbox the carmel one 
+      */
+
+    parsed_name = carmel_parse_mb_name(name, '\0');
+    if(parsed_name == NULL)
+      return(0);
+
+    carmel_free_mb_name(parsed_name);
+
+    carmel_index_file = carmel_calc_paths(CalcPathCarmelIndex, name, 0);
+
+    if(carmel_index_file == NULL)
+      return(0); /* Will get two error messages here, one from dummy driver */
+
+    if(stat(carmel_index_file, &sbuf) < 0)
+      return(1); /* If the name matches and it doesn't exist, it's OK */
+  
+    if(!(sbuf.st_mode & S_IFREG))
+      return(0);
+  
+    fd = open(carmel_index_file, O_RDONLY);
+    if(fd < 0)
+      return(0);
+  
+    if(read(fd, carmel_20k_buf, 200) <= 0)
+      return(0);
+    carmel_20k_buf[199] = '\0';
+  
+    close(fd);
+  
+    for(p = carmel_20k_buf; *p && !isspace(*p); p++); /* frist word */
+    for(; *p && isspace(*p); p++);  /* space */
+    lcase(p);                       /* lower case the "index" */
+    if(!*p || strncmp(p, "index", 5))  
+      return(0);
+  
+    return(1);
+}
+
+
+
+
+/*----------------------------------------------------------------------
+
+  ----*/
+void *
+carmel_parameters(function, value)
+     long  function;
+     char *value;
+{}
+
+
+
+/*----------------------------------------------------------------------
+   This is used by scandir to determine which files in the directory
+ are treated as mail files
+  ----*/
+static char *sift_pattern = NULL;
+static int
+carmel_sift_files(dir)
+     struct direct *dir;
+{
+    if(dir->d_name[0] == '.')
+      return(0);
+    else if(strcmp(dir->d_name, "MAIL") == 0) 
+     /* Never return the inbox. "INBOX" is always included by default */
+      return(0);
+    else if(pmatch(dir->d_name, sift_pattern))
+      return(1);
+    else
+      return(0);
+}
+
+int alphasort();
+
+/* ----------------------------------------------------------------------
+  Carmel find list of mail boxes
+  Args: mail stream
+        pattern to search
+ 
+  This scans the ".vmail/index" directory for a list of folders
+  (indexes in vmail terms).
+
+BUG -- doesn't really match patterns (yet)
+ ----*/
+void 
+carmel_find(stream, pat)
+	MAILSTREAM *stream;
+	char *pat;
+{
+    char            tmp[MAILTMPLEN];
+    struct direct **namelist, **n;
+    int             num;
+    struct carmel_mb_name *parsed_name;
+    struct passwd         *pw;
+
+    parsed_name = carmel_parse_mb_name(pat, '\0');
+
+    if(parsed_name == NULL)
+      return;
+
+    if(parsed_name->user == NULL) {
+        sprintf(tmp, "%s/%s", myhomedir(), CARMEL_INDEX_DIR);
+    } else {
+        pw = getpwnam(parsed_name->user);
+        if(pw == NULL) {
+            sprintf(carmel_error_buf,
+                  "Error accessing mailbox \"%s\". No such user name \"%s\"\n",
+                    pat, parsed_name->user);
+            mm_log(carmel_error_buf, ERROR);
+            return;
+        }
+        sprintf(tmp, "%s/%s", pw->pw_dir, CARMEL_INDEX_DIR);
+    }
+
+    sift_pattern = parsed_name->mailbox;
+
+    num = scandir(tmp, &namelist, carmel_sift_files, alphasort);
+
+    if(num <= 0) {
+/*        sprintf(carmel_error_buf, "Error finding mailboxes \"%s\": %s",
+                pat, strerror(errno));
+        mm_log(carmel_error_buf, ERROR);*/
+        return;
+    }
+
+    for(n = namelist; num > 0; num--, n++) {
+        if(parsed_name->user == NULL) {
+            sprintf(tmp, "%s%s%c%s", CARMEL_NAME_PREFIX, parsed_name->version,
+                    CARMEL_NAME_CHAR, (*n)->d_name);
+        } else {
+            sprintf(tmp, "%s%s%c%s%c%s", CARMEL_NAME_PREFIX,
+                    parsed_name->version, CARMEL_NAME_CHAR,
+                    parsed_name->user, CARMEL_NAME_CHAR,
+                    (*n)->d_name);
+        }
+	mm_mailbox(tmp);
+	free(*n); 
+    }
+    free(namelist);
+    carmel_free_mb_name(parsed_name);
+}
+
+
+/*----------------------------------------------------------------------
+     Find_all is the same for find in the carmel driver; there is no 
+difference between subscribed and unsubscribed mailboxes
+  ----*/     
+void 
+carmel_find_all (stream, pat)
+	MAILSTREAM *stream;
+	char *pat;
+{
+   carmel_find(stream, pat);
+}
+
+
+/*----------------------------------------------------------------------
+   Find bulliten boards is a no-op for carmel, there are none (yet)
+ */
+void 
+carmel_find_bboards (stream,pat)
+     MAILSTREAM *stream;
+     char *pat;
+{
+  /* Always a no-op */
+}
+
+
+/*----------------------------------------------------------------------
+   No subscription management for the carmel format. Probably should work
+ with the .mailbox list format, but that's probably implemented in mail.c
+ ----*/
+long carmel_subscribe() {}
+long carmel_unsubscribe() {}
+long carmel_subscribe_bboard() {}
+long carmel_unsubscribe_bboard() {}
+
+
+
+/*----------------------------------------------------------------------
+    Create a carmel folder
+
+Args:  stream --  Unused here
+       mailbox -- the FQN of mailbox to create
+
+Returns:  T on success, NIL on failure. 
+
+An error message is logged on failure.
+  ----*/
+long
+carmel_create(stream, mailbox)
+     MAILSTREAM *stream;
+     char       *mailbox;
+{
+    char       *carmel_index_file, *carmel2_index_file;
+    struct stat sb;
+    FILE       *f;
+
+    carmel_index_file = carmel_calc_paths(CalcPathCarmelIndex, mailbox, 0);
+
+    if(carmel_index_file == NULL)
+      return(NIL);
+
+    /*--- Make sure it doesn't already exist ---*/
+    if(stat(carmel_index_file, &sb) >= 0)
+      return(NIL);
+
+    /*--- The carmel index ----*/
+    f = fopen(carmel_index_file, "w");
+    if(f == NULL) 
+      goto bomb;
+
+    if(fprintf(f, "%-13.13s index.....\n",carmel_pretty_mailbox(mailbox))==EOF)
+      goto bomb;
+
+    if(fclose(f) == EOF)
+      goto bomb;
+
+    /*--- The carmel2 index ----*/
+    carmel2_index_file = carmel_calc_paths(CalcPathCarmel2Index, mailbox,0);
+    f = fopen(carmel2_index_file, "w");
+    if(f == NULL)
+      goto bomb;
+
+    if(fprintf(f, "\254\312--CARMEL-MAIL-FILE-INDEX--\n") == EOF)
+      goto bomb;
+
+    if(fclose(f) == EOF)
+      goto bomb;
+
+
+    carmel_kill_locks(mailbox); /* Get rid of any left over locks */
+    carmel_reset_index_list();
+    return(T);
+
+  bomb:
+    unlink(carmel_calc_paths(CalcPathCarmelIndex, mailbox, 0));
+    sprintf(carmel_error_buf, "Error creating mailbox %s: %s",
+	    carmel_pretty_mailbox(mailbox), strerror(errno));
+    mm_log(carmel_error_buf, ERROR);
+    return(NIL);
+}
+
+
+
+/*----------------------------------------------------------------------
+    Delete a carmel mailbox, and it's carmel2 index
+
+Args: stream --  unsed here
+      mailbox -- FQN of mailbox to delete
+
+Returns: NIL -- if delete fails 
+         T   -- if successful
+  ----*/
+long
+carmel_delete(stream, mailbox)
+     MAILSTREAM *stream;
+     char       *mailbox;
+{
+    char *carmel_index_file, *carmel2_index_file;
+
+    carmel_index_file = carmel_calc_paths(CalcPathCarmelIndex, mailbox, 0);
+    if(carmel_index_file == NULL)
+      return(NIL);
+
+    if(unlink(carmel_index_file) < 0) {
+	sprintf(carmel_error_buf, "Error deleting mailbox %s: %s",
+		carmel_pretty_mailbox(mailbox), strerror(errno));
+	mm_log(carmel_error_buf, ERROR); 
+	return(NIL);
+    }
+
+    /*------ Second the carmel2 index, quietly -----*/
+    carmel2_index_file = carmel_calc_paths(CalcPathCarmel2Index, mailbox, 0);
+
+    unlink(carmel2_index_file);
+
+    carmel_kill_locks(mailbox); /* Make sure all locks are clear */
+    carmel_reset_index_list();
+    return(T);
+}
+
+
+
+/*----------------------------------------------------------------------
+   Rename a carmel index, and its carmel2 index
+
+Args:  stream -- unused
+       orig   -- FQN of original mailbox 
+       new    -- FQN of new name
+
+Returns: NIL if rename failed, T if it succeeded.
+
+BUG: theoretically this could rename a folder from one user name 
+to another. Either that should be disallowed here, or code to make
+it work should be written.
+  ----*/
+long
+carmel_rename(stream, orig, new)
+     MAILSTREAM *stream;
+     char       *orig;
+     char       *new;
+{
+    char path_buf[CARMEL_PATHBUF_SIZE], *new_path, *orig_index_file;
+
+    /*---- First the Carmel index -----*/
+    orig_index_file = carmel_calc_paths(CalcPathCarmelIndex, orig, 0);
+    if(orig_index_file == NULL)
+      return(NIL);
+    strcpy(path_buf, orig_index_file);
+    new_path = carmel_calc_paths(CalcPathCarmelIndex, new, 0);
+    if(new_path == NULL)
+      return(NIL);
+
+    if(rename(path_buf, new_path) < 0) {
+	sprintf(carmel_error_buf, "Error renaming mailbox %s: %s",
+		carmel_pretty_mailbox(orig), strerror(errno));
+	mm_log(carmel_error_buf, ERROR); 
+	return(NIL);
+    }
+
+    /*----- Next the Carmel index, quietly ------*/
+    strcpy(path_buf, carmel_calc_paths(CalcPathCarmel2Index, orig, 0));
+    new_path = carmel_calc_paths(CalcPathCarmel2Index, new, 0);
+
+    rename(path_buf, new_path);
+
+    carmel_reset_index_list();
+    return(T);
+}
+
+
+
+/*----------------------------------------------------------------------
+  Carmel mail open
+
+ Args: stream 
+
+ Returns: stream on success, NIL on failure.
+
+The complex set of comparison determine if we get it for read, write or not
+at all.
+
+The folder will be open for write if:
+   - It is not locked
+   - The carmel index is writeable 
+   - The carmel index is writeable
+   - The carmel index is openable and not corrupt
+
+The folder open will fail if:
+   - The carmel index does exist
+   - The carmel carmel index is missing
+        AND the folder is locked or unwritable
+
+The folder is opened readonly if:
+   - It is locked
+   - The carmel index is not writable
+   - The carmel index is not writable
+
+ ----*/
+
+MAILSTREAM *
+carmel_open(stream)
+	MAILSTREAM *stream;
+{
+    char            carmel_index_path[CARMEL_PATHBUF_SIZE];
+    char            carmel2_index_path[CARMEL_PATHBUF_SIZE];
+    char            tmp[MAILTMPLEN], tmp2[MAILTMPLEN];
+    struct stat     carmel_stat, carmel2_stat;
+    int             carmel2_up_to_date;
+
+    if(!stream) 
+      return(&carmelproto); /* Must be a OP_PROTOTYPE call */
+
+    mailcache = carmel2_cache;
+
+    /* close old file if stream being recycled */
+    if (LOCAL) {
+        carmel_close (stream);		/* dump and save the changes */
+        stream->dtb = &carmeldriver;	/* reattach this driver */
+        mail_free_cache (stream);	/* clean up cache */
+    }
+
+    /* Allocate local stream */
+    stream->local              = fs_get (sizeof (CARMEL2LOCAL));
+    LOCAL->carmel              = 1;
+    LOCAL->msg_buf             = NULL;
+    LOCAL->msg_buf_size        = 0;
+    LOCAL->buffered_file       = NULL;
+    LOCAL->msg_buf_text_start  = NULL;
+    LOCAL->msg_buf_text_offset = 0;
+    LOCAL->stdio_buf           = NULL;
+    LOCAL->dirty               = NIL;
+    stream->msgno              = -1;
+    stream->env                = NULL;
+    stream->body               = NULL;
+    stream->scache             = 1;
+    LOCAL->calc_paths          = carmel_calc_paths;
+    LOCAL->aux_copy            = carmel_copy;
+    LOCAL->index_stream        = NULL;
+    LOCAL->new_file_on_copy    = 0;
+
+    /*------ Figure out the file paths -------*/
+    if(carmel_calc_paths(CalcPathCarmelIndex,stream->mailbox,0) == NULL) 
+      return(NULL);
+    strcpy(carmel_index_path,
+	   carmel_calc_paths(CalcPathCarmelIndex,stream->mailbox,0));
+    strcpy(carmel2_index_path,
+	   carmel_calc_paths(CalcPathCarmel2Index,stream->mailbox,0));
+
+    /*------ Does the CARMEL index exist? Fail if not ------*/
+    if(stat(carmel_index_path, &carmel_stat) < 0) {
+	sprintf(carmel_error_buf, "Can't open mailbox: %s", strerror(errno));
+	mm_log(carmel_error_buf, ERROR);
+        return(NULL);  /* FAIL, no carmel index */
+    }
+
+    /*----- Determine if carmel index is up to date -----*/
+    if(stat(carmel2_index_path, &carmel2_stat) >= 0 &&
+       carmel2_stat.st_mtime >= carmel_stat.st_mtime)
+      carmel2_up_to_date = 1;
+    else
+      carmel2_up_to_date = 0;
+
+    /*------ Do we have write access to the Carmel mail index? ----*/
+    if(access(carmel2_index_path, W_OK) != 0 && errno != ENOENT)
+      stream->readonly = 1; /* fail later if dir index is uncreatable */
+
+    /*------ If CARMEL index R/O and Carmel out of date then fail -----*/
+    if(stream->readonly && !carmel2_up_to_date) {
+	mm_log("Can't open mailbox; Unable to write carmel index", ERROR);
+        return(NULL);
+    }
+
+    /*-------- Case for R/O stream or failed lock ---------*/
+    if(stream->readonly ||
+       carmel2_lock(stream->local, stream->mailbox, READ_LOCK)< 0){
+	/* If carmel is out of date here that's OK, we just will see old data*/
+	if(access(carmel_index_path, R_OK) == 0) {
+	    stream->readonly = 1;
+  	    goto open_it;
+	} else {
+	    /*-- Can't lock, and there's no carmel index, best to fail -*/
+	    mm_log("Can't open mailbox, can't lock to create carmel index",
+		   ERROR);
+  	    return(NULL);
+        }
+    } 
+    /* Index is now read locked */
+
+    /*---- Got an up to date carmel index and write access too ----*/
+    if(carmel2_up_to_date)
+      if(access(carmel2_index_path, W_OK) == 0) {
+          goto open_it;
+      } else {
+	  stream->readonly = 1;
+	  goto open_it;
+      }
+
+    /*---- If needed recreation of carmel index fails, go readonly -----*/
+    if(vmail2carmel(carmel_index_path, carmel2_index_path, stream,
+                     stream->mailbox) < 0) {
+	carmel2_unlock(stream->local, stream->mailbox, READ_LOCK);
+        stream->readonly = 1;
+    }
+
+  open_it:
+    /*-- carmel_open2 shouldn't fail after all this check, but just in case -*/
+    if(carmel_open2(stream, carmel2_index_path) < 0) {
+	/* carmel_open2 will take care of the error message */
+	carmel2_unlock(stream->local, stream->mailbox, READ_LOCK);
+	if (LOCAL->msg_buf) fs_give ((void **) &LOCAL->msg_buf);
+				    /* nuke the local data */
+	fs_give ((void **) &stream->local);
+        return(NULL);
+    }
+
+    if(stream->readonly)
+	mm_log("Mailbox opened READONLY", WARN);
+
+    mail_exists (stream,stream->nmsgs);
+    mail_recent (stream,stream->recent);
+
+    return(stream);
+}
+
+
+
+/*----------------------------------------------------------------------
+   Create a carmel2 index for a carmel index
+  
+ Args: folder        -- the full UNIX path name existing carmel folder
+       carmel_folder -- the full UNIX path name of carmel index to create
+       stream        -- MAILSTREAM to operate on
+       
+ Returns: 0 if all is OK
+         -1 if it failed 
+
+  This reads the Carmel index, and the headers of the carmel messages to 
+construct entries for a carmel index.
+ ----*/
+static
+vmail2carmel(folder, carmel2_folder, stream, mailbox)
+     MAILSTREAM *stream;
+     char       *folder, *carmel2_folder;
+     char       *mailbox;
+{
+    FILE        *carmel_stream;
+    FILE        *carmel2_stream;
+    ENVELOPE    *e;
+    BODY        *b;
+    MESSAGECACHE mc;
+    char         pathbuf[CARMEL_PATHBUF_SIZE], *message, *p, *save_subject;
+    struct stat  st;
+    STRING       string_struct;
+
+    sprintf(pathbuf, "Recreating Carmel2 index for \"%s\"...",
+            carmel_pretty_mailbox(mailbox));
+    mm_log(pathbuf, WARN);
+
+    mm_critical(stream);
+    if(carmel2_lock(stream->local, mailbox, WRITE_LOCK) < 0)
+      return(-1);
+    
+    carmel_stream = fopen(folder,"r");
+    if(carmel_stream == NULL) {
+	carmel2_unlock(stream->local, mailbox, WRITE_LOCK);
+        mm_nocritical(stream);
+        return(-1);
+    }
+
+    carmel2_stream = fopen(carmel2_folder, "w");
+    if(carmel2_stream == NULL) {
+	carmel2_unlock(stream->local, mailbox, WRITE_LOCK);	
+        mm_nocritical(stream);
+        return(-1);
+    }
+
+    fprintf(carmel2_stream, "\254\312--CARMEL-MAIL-FILE-INDEX--\n");
+
+    /* The first ....  line */
+    fgets(carmel_20k_buf, sizeof(carmel_20k_buf), carmel_stream); 
+
+    /*---- Loop through all entries in carmel index -----*/
+    while(fgets(carmel_20k_buf,sizeof(carmel_20k_buf),carmel_stream) != NULL){
+
+	mc.data1      = 0L;
+	mc.data2      = atol(carmel_20k_buf); /* The file name/number */
+	mc.deleted    = 0;
+	mc.seen       = 1;
+	mc.flagged    = 0;
+	mc.answered   = 0;
+	mc.recent     = 0;
+	mc.user_flags = 0;
+
+	strcpy(pathbuf,carmel_calc_paths(CalcPathCarmel2Data,
+					 mailbox, mc.data2));
+
+	if(stat(pathbuf, &st) >= 0 ||
+	   stat(strcat(pathbuf, ".wid"), &st) >= 0) {
+	    save_subject = cpystr(carmel_20k_buf + 27);
+	    save_subject[strlen(save_subject) - 1] = '\0';
+            mc.rfc822_size = st.st_size;
+            message = carmel2_readmsg(stream, 1, 0, mc.data2);
+            INIT(&string_struct, mail_string, (void *)"", 0);
+	    rfc822_parse_msg(&e, &b, message, strlen(message), &string_struct,
+			     mylocalhost(), carmel_20k_buf);
+	    carmel2_parse_bezerk_status(&mc, message);
+	    carmel2_rfc822_date(&mc, message);
+	    if(e->subject == NULL ||
+	     strncmp(save_subject,e->subject,strlen(save_subject))){
+		if(e->subject != NULL)
+		  fs_give((void **)(&(e->subject)));
+		if(strlen(save_subject))
+		  e->subject = cpystr(save_subject);
+		else
+		  e->subject = NULL;
+	    }
+	} else {
+            /* Data file is missing; copy record as best we can */
+	    carmel_20k_buf[strlen(carmel_20k_buf) - 1] = '\0';
+            e = mail_newenvelope();
+	    e->subject = cpystr(carmel_20k_buf+27);
+	    e->from  = mail_newaddr();
+	    e->from->mailbox = cpystr(carmel_20k_buf+17);
+	    for(p = e->from->mailbox; *p && !isspace(*p); p++);
+	    *p = '\0';
+	    mc.hours     = 1;
+	    mc.minutes   = 0;
+	    mc.seconds   = 0;
+	    mc.zoccident = 0;
+	    mc.zhours    = 0;
+	    mc.zminutes  = 0;
+	    mc.day       = 1;
+	    mc.month     = 1;
+	    mc.year      = 1;
+	}
+	carmel2_write_index(e, &mc, carmel2_stream);
+	mail_free_envelope(&e);
+    }
+
+    fclose(carmel_stream);
+    fclose(carmel2_stream);
+
+    carmel2_unlock(stream->local, mailbox, WRITE_LOCK);
+    mm_nocritical(stream);
+
+    mm_log("Recreating Carmel2 index.....Done", WARN);
+
+    return(1);
+}
+
+
+
+#define TESTING /* Make a copy of carmel index before rewriting */
+
+/*----------------------------------------------------------------------`
+   Close a carmel mail folder
+
+Args: stream -- Mail stream to close
+
+This will cause the carmel index to be recreated
+
+  ----*/
+void 
+carmel_close(stream)
+	MAILSTREAM *stream;
+{
+    if (LOCAL && LOCAL->index_stream != NULL) {
+        /* only if a file is open */
+        if(!stream->readonly) {
+    	    carmel_check (stream);		/* dump final checkpoint */
+            carmel2_unlock(stream->local, stream->mailbox, READ_LOCK);
+        }
+
+        fclose(LOCAL->index_stream);
+        if (LOCAL->msg_buf) fs_give ((void **) &LOCAL->msg_buf);
+          if(LOCAL->stdio_buf)
+          fs_give ((void **) &LOCAL->stdio_buf);
+	fs_give ((void **) &stream->local);
+
+    }
+    stream->dtb = NIL;		/* log out the DTB */
+}
+
+
+
+/*----------------------------------------------------------------------
+  Check for new mail and write out the indexes as a checkpoint
+
+Args -- The stream to checkpoint
+ ----*/
+void
+carmel_check(stream)
+     MAILSTREAM *stream;
+{
+    if(carmel2_check2(stream))
+      carmel_recreate_index(stream); /* only if carmel2 index changed */
+}
+
+
+
+
+/*----------------------------------------------------------------------
+   Expunge the mail stream
+
+Args -- The stream to checkpoint
+
+Here we expunge the carmel2 index and then recreate the carmel index from
+it. 
+ ----*/
+void
+carmel_expunge(stream)
+     MAILSTREAM *stream;
+{
+    carmel2_expunge(stream);
+    carmel_recreate_index(stream); 
+}
+
+
+
+/*----------------------------------------------------------------------
+   Rewrite the carmel index from the carmel2 index
+ 
+Args: -- stream  to be recreated
+
+BUG: could probably use some error checking here
+  ----*/
+static void
+carmel_recreate_index(stream)
+     MAILSTREAM *stream;
+{
+#ifdef TESTING
+    char          copy1[CARMEL_PATHBUF_SIZE];
+    char          copy2[CARMEL_PATHBUF_SIZE];
+#define MAXBACKUPS 4
+    int nback;
+#endif
+    long          msgno;
+    MESSAGECACHE *mc;
+    ENVELOPE     *envelope;
+    FILE         *carmel_index;
+    struct stat   sb;
+    char         *cm_index_file;
+    struct timeval tp[2];
+
+    mm_critical(stream);
+
+    /*---- calculate the carmel index path -----*/
+    strcpy(carmel_path_buf,
+           (*(LOCAL->calc_paths))(CalcPathCarmelIndex, stream->mailbox, 0));
+
+    /*---- Get the first index line out of old index ----*/
+    *carmel_20k_buf = '\0';
+    carmel_index = fopen(carmel_path_buf, "r");
+    if(carmel_index != NULL) {
+        fgets(carmel_20k_buf,sizeof(carmel_20k_buf), carmel_index);
+        fclose(carmel_index);
+    }
+
+#ifdef TESTING
+    /*--- rotate Backup copies of the index --- crude*/
+    for (nback = MAXBACKUPS; 1 < nback; --nback) {
+      strcpy(copy2,
+           (*(LOCAL->calc_paths))(CalcPathCarmelBackup, stream->mailbox, nback));
+      strcpy(copy1,
+           (*(LOCAL->calc_paths))(CalcPathCarmelBackup, stream->mailbox, nback-1));
+      unlink(copy2);
+      link(copy1,copy2);
+      }
+    unlink(copy1);
+    link(carmel_path_buf, copy1);
+    unlink(carmel_path_buf);
+#endif		
+
+    /*---- Reopen the carmel index for write, truncating it ------*/	    
+    carmel_index = fopen(carmel_path_buf, "w");
+
+    if(carmel_index == NULL) 
+	goto bomb;
+	
+    if(fputs(carmel_20k_buf, carmel_index) == EOF)
+      goto bomb;
+
+    /*---- Loop through all the message the stream has ----*/	    
+    for(msgno = 1; msgno <= stream->nmsgs; msgno++) {
+        mc = MC(msgno);
+    	envelope = carmel2_fetchstructure(stream, msgno, NULL);
+    	if(write_carmel_index(carmel_index, mc, envelope) < 0)
+    	  goto bomb;
+    }
+    if(fclose(carmel_index) == EOF)
+      goto bomb;
+
+    /*---- Get mod time of carmel index ---*/
+    cm_index_file = (*(LOCAL->calc_paths))(CalcPathCarmelIndex,
+					   stream->mailbox, 0);
+    if(stat(cm_index_file, &sb) >= 0) {
+	tp[0].tv_sec  = sb.st_atime;
+	tp[0].tv_usec = 0;
+	tp[1].tv_sec  = sb.st_mtime;
+	tp[1].tv_usec = 0;
+    
+	/*---- Set Carmel index to have same mod time ---*/
+	utimes(stream->mailbox, tp);
+    }
+    mm_nocritical(stream);
+
+#ifdef CHATTY
+    sprintf(carmel_error_buf, "Rewrote Carmel index \"%s\" with %d messages",
+	    carmel_pretty_mailbox(stream->mailbox), msgno-1);
+    mm_log(carmel_error_buf, WARN);
+#endif
+
+    return;
+
+  bomb:
+    mm_nocritical(stream);
+    sprintf(carmel_error_buf, "Error recreating carmel index: %s",
+   	    strerror(errno));
+    mm_log(carmel_error_buf, ERROR);
+}
+
+
+
+/*----------------------------------------------------------------------
+  Do all the file name generation for the carmel driver
+
+Args: operation -- The type of calculation to perform
+      mailbox   -- The canonical mailbox name
+      data_file_num -- For calculating the name of a file storing a message
+
+Returns:  string with the path name in static storage or NULL on error
+
+The Path passed in will be in the format #carmel#user-id#folder or
+                                         #carmel#folder
+
+The only that error occurs is in looking up the user-id. A error is logged
+when that happens.
+  ----*/
+static char *
+carmel_calc_paths(operation, mailbox, data_file_num)
+     char *mailbox;
+     int   data_file_num, operation;
+{
+    static char    path[CARMEL_PATHBUF_SIZE];
+    char          *home_dir, *end_user_name;
+    struct passwd *pw;
+    struct carmel_mb_name *parsed_name;
+
+    parsed_name = carmel_parse_mb_name(mailbox, '\0');
+
+    if(parsed_name == NULL) {
+        mm_log("Internal error (bug). Invalid Carmel folder name",ERROR);
+        return(NULL);
+    }
+
+    if(parsed_name->user != NULL) {
+        /*---- has a user in mailbox name -----*/
+        pw = getpwnam(parsed_name->user);
+        if(pw == NULL) {
+            sprintf(carmel_error_buf,
+                  "Error accessing mailbox \"%s\". No such user name \"%s\"\n",
+                    mailbox, parsed_name->user);
+            mm_log(carmel_error_buf, ERROR);
+            carmel_free_mb_name(parsed_name);
+            return(NULL);
+        }
+        home_dir = pw->pw_dir;
+    } else {
+        home_dir = myhomedir();
+    }
+    mailbox  = parsed_name->mailbox;
+
+    if(strucmp2(mailbox, "inbox") == 0) /* Map "inbox" into "MAIL" */
+      mailbox = "MAIL";
+    
+
+    switch(operation) {
+
+      case CalcPathCarmelIndex:
+        sprintf(path, "%s/%s/%s", home_dir, CARMEL_INDEX_DIR, mailbox);
+        break;
+
+      case CalcPathCarmelBackup:
+        sprintf(path, "%s/%s/.%s.COD-FUR-%d", home_dir, CARMEL_INDEX_DIR,
+                mailbox, data_file_num);
+        break;
+
+      case CalcPathCarmel2Data:
+	sprintf(path, "%s/%s/%d", home_dir, CARMEL_MSG_DIR, data_file_num);
+	break;
+
+      case CalcPathCarmel2Index:
+        sprintf(path, "%s/%s/.%s.cx", home_dir, CARMEL_INDEX_DIR, mailbox);
+        break;
+
+      case CalcPathCarmel2MAXNAME:
+        sprintf(path, "%s/%s", home_dir, CARMEL_MAXFILE);
+        break;
+
+      case CalcPathCarmel2WriteLock:
+        sprintf(path, "%s/%s/.%s.wl", home_dir, CARMEL_INDEX_DIR, mailbox);
+        break;
+
+      case CalcPathCarmel2ReadLock:
+        sprintf(path, "%s/%s/.%s.rl", home_dir, CARMEL_INDEX_DIR, mailbox);
+        break;
+    }
+
+/*    sprintf(carmel_debug, "CARMEL: calc_paths returning \"%s\"\n", path);
+    mm_dlog(carmel_debug);   */
+
+    carmel_free_mb_name(parsed_name);
+
+    return(path);
+}
+
+
+
+/*----------------------------------------------------------------------
+    Copy carmel messages, this is the auxiliary copy, called from carmel2_copy
+
+Args:  local -- Fake CARMELLOCAL structure
+       mailbox -- Destination mailbox, in FQN format, e.g. #carmel#fooo
+       e       -- envelope
+       mc      -- MESSAGECACHE entry
+
+Retuns: -1 on failure
+  ----*/
+long
+carmel_copy(local, mailbox, e, mc)
+     CARMEL2LOCAL *local;
+     char         *mailbox;
+     ENVELOPE     *e;
+     MESSAGECACHE *mc;
+{
+    FILE       *carmel_index;
+    int         new;
+    struct stat sb;
+    char        *carmel_index_file;
+
+    carmel_index_file = (*(local->calc_paths))(CalcPathCarmelIndex, mailbox,0);
+    if(carmel_index_file == NULL)
+      return(-1);
+    
+    if(stat(carmel_index_file, &sb) < 0)
+      new = 1;
+    else
+      new = 0;
+
+    carmel_index = fopen(carmel_index_file, "a+");
+    if(carmel_index == NULL)
+      return(-1);
+    
+    if(new)
+      fprintf(carmel_index, "%-13.13s index.....\n",
+              carmel_pretty_mailbox(mailbox));
+
+    if(write_carmel_index(carmel_index, mc, e) < 0) {
+	fclose(carmel_index);
+	return(-1);
+    }
+
+    if(fclose(carmel_index) == EOF)
+      return(-1);
+
+    return(0);
+}
+
+
+    
+/*----------------------------------------------------------------------
+    Make sure all the directories are there and writable for carmel
+
+Args: folders_dir   - suggested directory, ignored by carmel
+
+Result: returns 0 if OK, -1 if not
+ ----*/
+carmel_init(folders_dir)
+     char *folders_dir;
+{
+    char  *p;
+    FILE  *mail_file;
+    struct stat sb;
+
+    /*----- The ~/.vmail directory ----*/
+    sprintf(carmel_path_buf, "%s/%s", myhomedir(), CARMEL_DIR);
+    carmel2_check_dir(carmel_path_buf);
+
+    /*---- The ~/.vmail/.MAXNAME file ------*/
+    sprintf(carmel_path_buf,"%s/%s", myhomedir(), CARMEL_MAXFILE);
+    if(stat(carmel_path_buf, &sb) < 0) {
+	mail_file = fopen(carmel_path_buf, "w");
+	if(mail_file == NULL) {
+	    mm_log("Error creating .MAXNAME file", ERROR);
+	} else {
+	    fprintf(mail_file, "100000");
+	    fclose(mail_file);
+	}
+    }
+
+    /*----- The ~/.vmail/index directory -----*/
+    sprintf(carmel_path_buf,"%s/%s",myhomedir(),CARMEL_INDEX_DIR);
+    carmel2_check_dir(carmel_path_buf);
+
+    /*----- The ~/.vmail/msg directory -----/*
+    sprintf(carmel_path_buf,"%s/%s",myhomedir(),CARMEL_MSG_DIR);
+    carmel2_check_dir(carmel_path_buf);
+
+    /*----- The ~/.vmail/MAIL file -----*/
+    sprintf(carmel_path_buf, "%s/%s/MAIL", myhomedir(),  CARMEL_INDEX_DIR);
+    if(stat(carmel_path_buf, &sb) < 0) {
+        mail_file = fopen(carmel_path_buf, "w");
+	if(mail_file == NULL) {
+	    mm_log("Error creating \"MAIL\" folder", WARN);
+	} else {
+ 	    fprintf(mail_file, "MAIL          index.....\n");
+	    fclose(mail_file);
+	}
+    }
+
+    return(0);
+}
+
+
+
+/*----------------------------------------------------------------------
+   Write an entry into a carmel index
+ 
+Args: file -- The open file stream
+      mc   -- the MESSAGECACHE 
+      envelope -- The envelope to write
+
+Returns: 0 if all is OK, -1 if not
+  ----*/	
+static 	
+write_carmel_index(file, mc, envelope)
+     FILE         *file;
+     MESSAGECACHE *mc;
+     ENVELOPE     *envelope;
+{
+    if(fprintf(file, "%6d %02d %-.3s %2d %-9.9s %-.50s\n",
+	       mc->data2, mc->day,
+	       month_abbrev2(mc->month),
+	       (mc->year + 1969) % 100,
+	       envelope != NULL && envelope->from != NULL &&
+	       envelope->from->mailbox != NULL ?
+	         envelope->from->mailbox :  "",
+	       envelope != NULL && envelope->subject != NULL ?
+	         envelope->subject : "") == EOF)
+      return(-1);
+    else
+      return(0);
+}
+
+
+
+/*----------------------------------------------------------------------
+    Append a message to a carmel mailbox
+
+Args: stream  --  a suggested stream, ignored here
+      mailbox --  FQN of mailbox to append message to
+      message --  Text string of message
+
+Returns: T on success, NIL on failure
+  ----*/    
+long
+carmel_append(stream, mailbox, flags, date, message)
+     MAILSTREAM *stream;
+     char       *mailbox, *flags, *date;
+     STRING     *message;
+{
+    CARMEL2LOCAL local;
+
+    /*---- A fake local data structure to pass to other functions---*/
+    local.calc_paths = carmel_calc_paths;
+    local.carmel     = 1;
+    local.aux_copy   = carmel_copy;
+
+
+    return(carmel2_append2(stream, &local, mailbox, flags, date, message));
+}
+
+
+
+
+
+/*----------------------------------------------------------------------
+  This really just removes the file Carmel uses for the list of 
+ folders, because Carmel will just recreate it from the indexes themselves.
+  ----*/
+static 
+carmel_reset_index_list()
+{
+    sprintf(carmel_path_buf, "%s/.inda", myhomedir());
+    unlink(carmel_path_buf);
+
+    sprintf(carmel_path_buf, "%s/.indf", myhomedir());
+    unlink(carmel_path_buf);
+}
+
+
+
+/*----------------------------------------------------------------------
+    Used to make sure there are no old locks of any sort left around 
+ when a folder is deleted or when one is created. 
+  --*/
+static void   
+carmel_kill_locks(mailbox)
+     char *mailbox;
+{
+    unlink(carmel_calc_paths(CalcPathCarmel2WriteLock, mailbox, 0));
+    unlink(carmel_calc_paths(CalcPathCarmel2ReadLock, mailbox, 0));
+    unlink(carmel_calc_paths(CalcPathCarmel2Expunge, mailbox, 0));
+}
diff --git a/contrib/carmel/c-client/carmel.h b/contrib/carmel/c-client/carmel.h
new file mode 100644
index 00000000..ffdabaaa
--- /dev/null
+++ b/contrib/carmel/c-client/carmel.h
@@ -0,0 +1,77 @@
+/*----------------------------------------------------------------------
+
+         T H E   C A R M E L    M A I L   D R I V E R
+
+  Author(s):   Laurence Lundblade
+               Baha'i World Centre
+               Data Processing
+               Haifa, Israel
+ 	       Internet: lgl@cac.washington.edu or laurence@bwc.org
+               September 1992
+ Last edited:  Aug 31, 1994               
+  
+  ----------------------------------------------------------------------*/
+
+
+/* Most of the real stuff is defined in carmel2.h */
+
+/* Function prototypes */
+
+#ifdef ANSI
+DRIVER	   *carmel_valid(char *);
+int	    carmel_isvalid(char *);
+void       *carmel_parameters();
+char	   *carmel_file  (char *, char *);
+void        carmel_find(MAILSTREAM *, char *);
+void        carmel_find_all(MAILSTREAM *, char *);
+void        carmel_find_bboards(MAILSTREAM *, char *);
+long	    carmel_subscribe();
+long	    carmel_unsubscribe();
+long	    carmel_subscribe_bboard();
+long	    carmel_unsubscribe_bboard();
+long        carmel_create(MAILSTREAM *, char *);
+long        carmel_delete(MAILSTREAM *, char *);
+long        carmel_rename(MAILSTREAM *, char *, char *);
+MAILSTREAM *carmel_open(MAILSTREAM *);
+void        carmel_close(MAILSTREAM *);
+void        carmel_check(MAILSTREAM *);
+void        carmel_void(MAILSTREAM *);
+long        carmel_copy(CARMEL2LOCAL *, char *, ENVELOPE *, MESSAGECACHE *);
+int         carmel_init(char *);
+long        carmel_append(MAILSTREAM *, char *, char *, char *, STRING *);
+#else
+DRIVER	   *carmel_valid();
+int	    carmel_isvalid();
+void       *carmel_parameters();
+char	   *carmel_file  ();
+void        carmel_find();
+void        carmel_find_all();
+void        carmel_find_bboards();
+long	    carmel_subscribe();
+long	    carmel_unsubscribe();
+long	    carmel_subscribe_bboard();
+long	    carmel_unsubscribe_bboard();
+long        carmel_create();
+long        carmel_delete();
+long        carmel_rename();
+MAILSTREAM *carmel_open();
+void        carmel_close();
+void        carmel_check();
+void        carmel_expunge();
+long        carmel_copy();
+int         carmel_init();
+long        carmel_append();
+#endif
+
+
+/* These are all relative to the users home directory */
+#define CARMEL_INDEX_DIR  ".vmail/index"
+#define CARMEL_DIR        ".vmail"
+#define CARMEL_MSG_DIR    ".vmail/msg"
+#define CARMEL_MAXFILE    ".vmail/.MAXNAME"
+
+/* operations for carmel_calc_path -- must mesh with operations for 
+   carmel2_calc_path in carmel2.h
+ */
+#define CalcPathCarmelIndex  100
+#define CalcPathCarmelBackup 101
diff --git a/contrib/carmel/c-client/carmel2.c b/contrib/carmel/c-client/carmel2.c
new file mode 100644
index 00000000..c56f8900
--- /dev/null
+++ b/contrib/carmel/c-client/carmel2.c
@@ -0,0 +1,4412 @@
+#define TESTING
+/*----------------------------------------------------------------------
+
+    T H E   C A R M E L   M A I L   F I L E   D R I V E R
+
+ Author(s):   Laurence Lundblade
+              Baha'i World Centre
+              Data Processing
+              Haifa, Israel
+              Internet: lgl@cac.washington.edu or laurence@bwc.org
+              September 1992
+
+ Last edited: Aug 31, 1994
+
+The Carmel2 mail file stores messages in individual files and
+implements folders or mailboxes with index files that contain
+references to the files a nd a full c-client envelope in an easily
+parsed form. It was written as a needed part of the pod mail file
+driver with hopes that it might be useful otherwise some day. It has
+only been run with the carmel driver.
+
+Advantages over Berkeley format and driver:
+  + Opening mail folder is very fast
+  + Expunge is fast
+  + Check point is very fast
+  + Memory usage is much lower
+  + Search of message headers is fast
+Disadvantages:
+  - Fetching a large message is slow
+  - Searching the message bodies is slow
+  - Sorting the mailbox is slow
+
+         Index File Format
+         -----------------
+
+The first line of the file is always:
+  "\254\312--CARMEL2-MAIL-FILE-INDEX--\n"
+
+It is followed by index entries which are of the format:
+---START-OF-MESSAGE---\007\001nnnnnnnnnn     
+Ufrads______________________________
+Zxxxxxx
+D..... <Many fields here, labeled by the first letter in the line>
+       <Fields may be repeated>
+
+
+The index is almost an ASCII file. With the first version of this
+driver it is not advisable to edit this file, lest the byte counts get
+disrupted.  In the future it will be editable. The file starts with
+two binary bytes so the file(1) utility will report it as "data" to
+discourage would be hackers from messing with it. The ^G is also in
+each index entry for the same reason. If you are reading this source you
+probably know enough to edit the index file without destroying it.
+Other parts of the format are designed for the easiest possible
+parsing. The idea was to have a file format that was reasonable to
+fiddle for debugging, to discourage inexperienced folks for fiddling
+it and to be efficient for use by the program.
+
+
+      Routines and data structures
+      ----------------------------
+
+C-CLIENT INTERFACE FUCTIONS
+  carmel2_valid       - check to see if a mailbox is valid for carmel2 mail files
+  carmel2_isvalid     - actual work of checking
+  carmel2_find        - generate list of carmel2 mailboxes
+  carmel2_sift_files  - select mailboxes out of list, used with scandir
+  carmel2_find_bboars - dummy routine, doesn't do anything
+
+  carmel2_open        - initial phase of opening a mailbox
+  carmel2_open2       - real work of opening mailbox, shared with carmel driver
+  carmel2_close       - close a mail stream
+
+  carmel2_fetchfast   - fetch "fast" message info, noop for this driver
+  carmel2_fetchflags  - fetch the flags, a noop for this driver
+  carmel2_fetchstructure - fetch and envelope and possibly body  
+
+  carmel2_fetchheader - fetch the text header of the message
+  carmel2_fetchtext   - fetch the text of the message (no header included)
+  carmel2_fetchbody   - fetch the text of a body part of a message
+
+  carmel2_setflag     - Set a flag for a message sequence
+  carmel2_clearflag   - Clear a flag for a message sequence
+  
+  carmel2_search      - Invoke the search facilities
+
+  carmel2_ping        - Check for new mail and see if still alive
+  carmel2_check       - Checkpoint the message statuses to the disk
+  carmel2_expunge     - Delete all the messages marked for delete 
+  
+  carmel2_copy        - Copy a message to another mailbox
+  carmel2_move        - Move a message to another mailbox
+  
+  carmel_gc          - Garbage collection, a noop for this driver
+  carmel_cache       - The required c-client cache handler, doesn't do much
+
+  carmel2_append      - Append a message to a mail folder
+
+SUPPORT FUNCTIONS
+  carmel_bodystruct  - Fetch the body structure for a carmel message
+  carmel_parse_address - Parse the address out of a carmel index
+  carmel_parse_addr_field - Parse individual address field out of carmel index
+  carmel2_write_index - Write an entry into a carmel index
+  carmel2_index_address - Write an address into a carmel index
+
+  carmel_readmsg     - Read a message file into memory, header text or both
+  carmel_spool_mail  - Get new mail out of spoold mail file
+  carmel_copy_msg_file - Make copy of messsage file when copying (unused)
+  
+  carmel2_lock        - Lock a carmel index for read or write
+  carmel2_unlock      - Unlock a carmel index
+  carmel2_update_lock - Touch lock mod time, marking it as active
+  carmel2_bezerk_lock - Lock the spool mail file Berkeley style
+  carmel2_bezerk_unlock - Unlock the spool mail file
+  
+  carmel2_check_dir   - Check that directory exists and is writeable 
+  carmel2_new_data_file - Get file number for new message file
+  carmel2_calc_paths  - Calculate path names for carmel driver
+
+  carmel_parse_bezerk_status - Parse the "Status: OR" field in mail headers
+  carmel2_getflags    - Turn the named flags into a bit mask
+  carmel_new_mc      - Get pointer to new MESSAGECACHE, allocating if needed
+
+  carmel_append2     - The real work of append a message to a mailbox
+  
+  carmel2_search-*    - A bunch of search support routines
+ 
+  month_abbrev2      - Returns three letter month abbreviation given a name
+  carmel2_rfc822_date - Parse a date string, into MESSAGECACHE structure
+  carmel2_date2string - Generate a date string from MESSAGECACHE
+  carmel2_parse_date  - Parse date out of a carmel index
+  next_num           - Called to parse dates
+ 
+  strucmp2           - Case insensitive strcmp()
+  struncmp2          - Case insensitive strncmp()
+  
+ ----------------------------------------------------------------------*/
+
+#include <stdio.h>
+#include <ctype.h>
+#include <pwd.h>
+#include <netdb.h>
+#include <errno.h>
+extern int errno;               /* just in case */
+#include "mail.h"
+#include "osdep.h"
+#include <sys/dir.h>
+#include <sys/file.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include "carmel2.h"
+#include "rfc822.h"
+#include "misc.h"
+
+
+char *strindex2(), *strchr();
+
+#ifdef ANSI
+static int      carmel2_sift_files(struct direct *);
+static BODY    *carmel2_bodystruct(MAILSTREAM *, MESSAGECACHE *);
+static ADDRESS *carmel2_parse_address(char *, ADDRESS *, char *);
+static char    *carmel2_parse_addr_field(char **);
+static int      carmel2_index_address(ADDRESS *, int , FILE *);
+static int      carmel2_parse_mail(MAILSTREAM *, long);
+void            carmel2_spool_mail(MAILSTREAM *, char *, char *, int);
+static int      carmel2_copy_msg_file(MAILSTREAM *, int, char *);
+static int      carmel2_bezerk_lock(char *, char *);
+static void     carmel2_bezerk_unlock(int, char *);
+static int      carmel2_new_data_file(CARMEL2LOCAL *, char *);
+static char    *carmel2_calc_paths(int, char *, int);
+static short    carmel2_getflags(MAILSTREAM *, char *);
+static MESSAGECACHE *carmel2_new_mc(MAILSTREAM *, int);
+static char     carmel2_search_all(MAILSTREAM *, long, char *, long);
+static char     carmel2_search_answered(MAILSTREAM *, long, char *, long);
+static char     carmel2_search_deleted(MAILSTREAM *, long, char *, long);
+static char     carmel2_search_flagged(MAILSTREAM *, long, char *, long);
+static char     carmel2_search_keyword(MAILSTREAM *, long, char *, long);
+static char     carmel2_search_new(MAILSTREAM *, long, char *, long);
+static char     carmel2_search_old(MAILSTREAM *, long, char *, long);
+static char     carmel2_search_recent(MAILSTREAM *, long, char *, long);
+static char     carmel2_search_seen(MAILSTREAM *, long, char *, long);
+static char     carmel2_search_unanswered(MAILSTREAM *, long, char *, long);
+static char     carmel2_search_undeleted(MAILSTREAM *, long, char *, long);
+static char     carmel2_search_unflagged(MAILSTREAM *, long, char *, long);
+static char     carmel2_search_unkeyword(MAILSTREAM *, long, char *, long);
+static char     carmel2_search_unseen(MAILSTREAM *, long, char *, long);
+static char     carmel2_search_before(MAILSTREAM *, long, char *, long);
+static char     carmel2_search_on(MAILSTREAM *, long, char *, long);
+static char     carmel2_search_since(MAILSTREAM *, long, char *, long);
+static unsigned long carmel2_msgdate(MAILSTREAM *, long);
+static char     carmel2_search_body(MAILSTREAM *, long, char *, long);
+static char     carmel2_search_subject(MAILSTREAM *, long, char *, long);
+static char     carmel2_search_text(MAILSTREAM *, long, char *, long);
+static char     carmel2_search_bcc(MAILSTREAM *, long, char *, long);
+static char     carmel2_search_cc(MAILSTREAM *, long, char *, long);
+static char     carmel2_search_from(MAILSTREAM *, long, char *, long);
+static char     carmel2_search_to(MAILSTREAM *, long, char *, long);
+typedef char (*search_t)  ();
+static search_t carmel2_search_date(search_t, long *);
+static search_t carmel2_search_flag(search_t, char **);
+static search_t carmel2_search_string(search_t, char **, long *);
+static void     carmel2_date2string(char *, MESSAGECACHE *);
+static void     carmel2_parse_date(MESSAGECACHE *, char *);
+static int      next_num(char **);
+#else
+static int      carmel2_sift_files();
+static BODY    *carmel2_bodystruct();
+static ADDRESS *carmel2_parse_address();
+static char    *carmel2_parse_addr_field();
+static int      carmel2_index_address();
+static int      carmel2_parse_mail();
+void            carmel2_spool_mail();
+static int      carmel2_copy_msg_file();
+static int      carmel2_bezerk_lock();
+static void     carmel2_bezerk_unlock();
+static int      carmel2_new_data_file();
+static char    *carmel2_calc_paths();
+static short    carmel2_getflags();
+static MESSAGECACHE *carmel2_new_mc();
+static char     carmel2_search_all();
+static char     carmel2_search_answered();
+static char     carmel2_search_deleted();
+static char     carmel2_search_flagged();
+static char     carmel2_search_keyword();
+static char     carmel2_search_new();
+static char     carmel2_search_old();
+static char     carmel2_search_recent();
+static char     carmel2_search_seen();
+static char     carmel2_search_unanswered();
+static char     carmel2_search_undeleted();
+static char     carmel2_search_unflagged();
+static char     carmel2_search_unkeyword();
+static char     carmel2_search_unseen();
+static char     carmel2_search_before();
+static char     carmel2_search_on();
+static char     carmel2_search_since();
+static unsigned long carmel2_msgdate();
+static char     carmel2_search_body();
+static char     carmel2_search_subject();
+static char     carmel2_search_text();
+static char     carmel2_search_bcc();
+static char     carmel2_search_cc();
+static char     carmel2_search_from();
+static char     carmel2_search_to();
+typedef char (*search_t)  ();
+static search_t carmel2_search_date();
+static search_t carmel2_search_flag();
+static search_t carmel2_search_string();
+static void     carmel2_date2string();
+static void     carmel2_parse_date();
+static int      next_num();
+#endif
+
+
+/*------ Driver dispatch used by MAIL -------*/
+
+DRIVER carmel2driver = {
+  "carmel2",
+  (DRIVER *) NIL,               /* next driver */
+  carmel2_valid,                /* mailbox is valid for us */
+  carmel2_parameters,           /* manipulate parameters */
+  carmel2_find,                 /* find mailboxes */
+  carmel2_find_bboards,         /* find bboards */
+  carmel2_find_all,             /* find all mailboxes */
+  carmel2_find_bboards,         /* find all bboards ; just a noop here */
+  carmel2_subscribe,            /* subscribe to mailbox */
+  carmel2_unsubscribe,          /* unsubscribe from mailbox */
+  carmel2_subscribe_bboard,     /* subscribe to bboard */
+  carmel2_unsubscribe_bboard,   /* unsubscribe from bboard */
+  carmel2_create,
+  carmel2_delete,
+  carmel2_rename,
+  carmel2_open,                 /* open mailbox */
+  carmel2_close,                /* close mailbox */
+  carmel2_fetchfast,            /* fetch message "fast" attributes */
+  carmel2_fetchflags,           /* fetch message flags */
+  carmel2_fetchstructure,       /* fetch message envelopes */
+  carmel2_fetchheader,          /* fetch message header only */
+  carmel2_fetchtext,            /* fetch message body only */
+  carmel2_fetchbody,            /* fetch message body section */
+  carmel2_setflag,              /* set message flag */
+  carmel2_clearflag,            /* clear message flag */
+  carmel2_search,               /* search for message based on criteria */
+  carmel2_ping,                 /* ping mailbox to see if still alive */
+  carmel2_check,                /* check for new messages */
+  carmel2_expunge,              /* expunge deleted messages */
+  carmel2_copy,                 /* copy messages to another mailbox */
+  carmel2_move,                 /* move messages to another mailbox */
+  carmel2_append,                /* Append message to a mailbox */
+  carmel2_gc,                   /* garbage collect stream */
+};
+
+MAILSTREAM carmel2proto ={&carmel2driver};/*HACK for default_driver in pine.c*/
+
+/*-- Some string constants used in carmel2 indexes --*/
+char *carmel2_s_o_m     = "---START-OF-MESSAGE---";
+int   carmel2_s_o_m_len = 22;
+char *carmel2_s_o_f     =   "\254\312--CARMEL2-MAIL-FILE-INDEX--\n";
+
+
+
+/*-- Buffers used for various reasons, also used by carmel driver --*/
+char carmel_20k_buf[20000], carmel_path_buf[CARMEL_PATHBUF_SIZE],
+     carmel_error_buf[200];
+
+
+/*----------------------------------------------------------------------
+    Carmel mail validate mailbox
+
+Args: - mailbox name
+
+Returns: our driver if name is valid, otherwise calls valid in next driver
+ ---*/
+
+DRIVER *carmel2_valid (name)
+        char *name;
+{
+    return (carmel2_isvalid (name) ? &carmel2driver : NIL);
+}
+
+
+
+/*----------------------------------------------------------------------
+  Open the mailbox and see if it's the correct format
+
+Args: name -- name of the mailbox, not fully qualified path
+
+Returns: 0 if is is not valid, 1 if it is valid
+
+The file must be a regular file and start with the string in the
+variable carmel2_s_o_f. It has a magic number of sorts
+  ----*/
+int
+carmel2_isvalid (name)
+        char *name;
+{
+    char           *carmel_index_file;
+    struct stat     sbuf;
+    int             fd;
+    struct carmel_mb_name *parsed_name;
+
+    /*---- Must match FQN name of carmel mailboxes ----*/
+    parsed_name = carmel_parse_mb_name(name, '2');
+    if(parsed_name == NULL)
+      return;
+    carmel_free_mb_name(parsed_name);
+       
+    carmel_index_file = carmel2_calc_paths(CalcPathCarmel2Index, name, 0);
+    if(carmel_index_file == NULL)
+      return(0); /* Will get two error messages here, one from dummy driver */
+    
+    if(stat(carmel_index_file, &sbuf) < 0)
+      return(1); /* If the names match and it doesn't exist, it's valid */
+
+    if(!(sbuf.st_mode & S_IFREG))
+      return(0);
+
+    fd = open(carmel_index_file, O_RDONLY);
+    if(fd < 0)
+      return(0);
+
+    if(read(fd, carmel_20k_buf, 200) <= 0)
+      return(0);
+
+    close(fd);
+
+    if(strncmp(carmel_20k_buf, carmel2_s_o_f, strlen(carmel2_s_o_f)))
+       return(0);
+
+    return(1);
+}
+
+
+
+/*----------------------------------------------------------------------
+   Set parameters for the carmel driver.
+ 
+   Currently does nothing
+  ----*/
+void *
+carmel2_parameters()
+{
+}
+
+
+
+
+/*----------------------------------------------------------------------
+   Carmel mail find list of mailboxes
+
+Args:  stream -- mail stream to find mailboxes for
+       pat    -- wildcard pattern to match (currently unused)
+
+Returns nothing, the results are passed back by calls to mm_log
+
+This needs testing
+ ----*/
+
+void 
+carmel2_find (stream, pat)
+    MAILSTREAM *stream;
+    char *pat;
+{
+    char                   tmp[MAILTMPLEN];
+    struct direct        **namelist, **n;
+    int                    num;
+    extern int             alphasort();
+    struct carmel_mb_name *parsed_name;
+    struct passwd         *pw;
+
+    parsed_name = carmel_parse_mb_name(pat, '2');
+    if(parsed_name == NULL)
+      return;
+
+    if(parsed_name->user == NULL) {
+        sprintf(tmp, "%s/%s", myhomedir(), CARMEL2_INDEX_DIR);
+    } else {
+        pw = getpwnam(parsed_name->user);
+        if(pw == NULL) {
+            sprintf(carmel_error_buf,
+                  "Error accessing mailbox \"%s\". No such user name \"%s\"\n",
+                    pat, parsed_name->user);
+            mm_log(carmel_error_buf, ERROR);
+            return;
+        }
+        sprintf(tmp, "%s/%s", pw->pw_dir, CARMEL2_INDEX_DIR);
+    }
+
+    sprintf(tmp, "%s/%s", myhomedir(), CARMEL2_INDEX_DIR);
+
+    num = scandir(tmp, &namelist, carmel2_sift_files, alphasort);
+
+    if(num <= 0) {
+/*  Seems this error message should not be logged
+        sprintf(carmel_error_buf, "Error finding mailboxes \"%s\": %s",
+                pat, strerror(errno));
+        mm_log(carmel_error_buf, ERROR); */
+        return;
+    }
+
+    for(n = namelist; num > 0; num--, n++) {
+        if(parsed_name->user == NULL) {
+            sprintf(tmp, "%s%s%c%s", CARMEL_NAME_PREFIX, parsed_name->version,
+                    CARMEL_NAME_CHAR, (*n)->d_name);
+        } else {
+            sprintf(tmp, "%s%s%c%s%c%s", CARMEL_NAME_PREFIX,
+                    parsed_name->version, CARMEL_NAME_CHAR,
+                    parsed_name->user, CARMEL_NAME_CHAR,
+                    (*n)->d_name);
+        }
+        mm_mailbox(tmp);
+        free(*n); 
+    }
+    free(namelist);   
+    carmel_free_mb_name(parsed_name);
+}
+
+
+
+/*----------------------------------------------------------------------
+   Find_all is the same as find for the carmel2 format -- no notion
+   of subscribed and unsubscribed
+  ---*/
+void 
+carmel2_find_all (stream, pat)
+    MAILSTREAM *stream;
+    char *pat;
+{
+  carmel2_find(stream, pat);
+}
+
+
+
+/*----------------------------------------------------------------------
+  Carmel2 mail find list of bboards; always NULL, no bboards 
+ ----*/
+void carmel2_find_bboards (stream,pat)
+        MAILSTREAM *stream;
+        char *pat;
+{
+  /* Always a no-op, Carmel2 file format doesn't do news */
+}
+
+
+
+/*----------------------------------------------------------------------
+  Carmel2 mail find list of bboards; always NULL, no bboards 
+ ----*/
+void carmel2_find_all_bboards (stream,pat)
+        MAILSTREAM *stream;
+        char *pat;
+{
+  /* Always a no-op, Carmel2 file format doesn't do news */
+}
+
+
+
+/*----------------------------------------------------------------------
+   This is used by scandir to determine which files in the directory
+ are treated as mail files
+  ----*/
+static int
+carmel2_sift_files(dir)
+     struct direct *dir;
+{
+    if(dir->d_name[0] == '.')
+      return(0);
+    else
+      return(1);
+}
+
+
+
+/*----------------------------------------------------------------------
+    Dummy subscribe/unsubscribe routines.  
+    Carmel driver does support this. Maybe it should support the UNIX
+    sm sometime
+  ----*/
+long carmel2_subscribe() {}
+long carmel2_unsubscribe() {}
+long carmel2_subscribe_bboard() {}
+long carmel2_unsubscribe_bboard() {}
+
+
+
+/*----------------------------------------------------------------------
+  ----*/
+long
+carmel2_create(stream, mailbox)
+     MAILSTREAM *stream;
+     char       *mailbox;
+{
+}
+
+
+
+/*----------------------------------------------------------------------
+  ----*/
+long
+carmel2_delete(stream, mailbox)
+     MAILSTREAM *stream;
+     char       *mailbox;
+{
+}
+
+
+
+/*----------------------------------------------------------------------
+  ----*/
+long
+carmel2_rename(stream, orig_mailbox, new_mailbox)
+     MAILSTREAM *stream;
+     char       *orig_mailbox, *new_mailbox;
+{
+}
+
+
+/*----------------------------------------------------------------------
+  Open a carmel2 mail folder/stream
+
+Args: stream -- stream to by fully opened
+
+Returns: it's argument or NULL of the open fails
+
+This needs testing and more code, see pod_open for examples
+  ----*/
+
+MAILSTREAM *
+carmel2_open (stream)
+        MAILSTREAM *stream;
+{
+    char tmp[MAILTMPLEN];
+    struct hostent *host_name;
+
+    if(!stream) return &carmel2proto; /* Must be a OP_PROTOTYPE call */
+
+    /* close old file if stream being recycled */
+    if (LOCAL) {
+        carmel2_close (stream);         /* dump and save the changes */
+        stream->dtb = &carmel2driver;   /* reattach this driver */
+        mail_free_cache (stream);       /* clean up cache */
+    }
+
+    mailcache = carmel2_cache;
+
+    /* Allocate local stream */
+    stream->local = fs_get (sizeof (CARMEL2LOCAL));
+
+    stream->readonly = 1; /* Read-only till more work is done */
+
+    LOCAL->msg_buf             = NULL;
+    LOCAL->msg_buf_size        = 0;
+    LOCAL->buffered_file       = NULL;
+    LOCAL->msg_buf_text_start  = NULL;
+    LOCAL->msg_buf_text_offset = 0;
+    LOCAL->stdio_buf           = NULL;
+    stream->msgno              = -1;
+    stream->env                = NULL;
+    stream->body               = NULL;
+    stream->scache             = 1;
+    LOCAL->calc_paths          = carmel2_calc_paths;
+    LOCAL->aux_copy            = NULL;
+    LOCAL->new_file_on_copy    = 1;
+
+    if(carmel_open2(stream,
+       (*(LOCAL->calc_paths))(CalcPathCarmel2Index, stream->mailbox,0)) < 0)
+      return(NULL);
+
+    mail_exists (stream,stream->nmsgs);
+    mail_recent (stream,stream->recent);
+
+    return(stream);
+}
+
+
+
+/*----------------------------------------------------------------------
+    Do the real work of opening a Carmel folder. 
+
+Args: stream -- The mail stream being opened
+      file   -- Path name of the actual Carmel index file
+
+Returns: -1 if the open fails
+          0 if it succeeds
+
+This is shared between the Carmel driver and the Pod driver.
+
+Here, the status, size and date (fast info) of a message entry
+is read out of the index file into the MESSAGECACHE structures.
+To make the reading efficient these items are at the beginning 
+of each entry and there is a byte offset to the next entry.
+If the byte offset is wrong (as detected by looking for the
+start of message string) then the index is read line by line
+until it synchs up. This allows manual editing of the index.
+However, the first two lines of an index entry cannot be
+edited because mail_check() writes them in place. If these
+lines have been edited it is detected here and the folder is
+deemed corrupt.
+  ---*/
+carmel_open2(stream, file)
+     MAILSTREAM *stream;
+     char       *file;
+{
+    long          file_pos, recent;
+    MESSAGECACHE *mc;
+    struct stat   sb;
+
+    if(stat(file, &sb) < 0) {
+        sprintf(carmel_error_buf, "Can't open mailbox: %s", strerror(errno));
+        mm_log(carmel_error_buf, ERROR);
+        return(-1);
+    }
+
+    LOCAL->index_stream = fopen(file, stream->readonly ? "r" : "r+");
+    LOCAL->stdio_buf    = fs_get(CARMEL2_INDEX_BUF_SIZE);
+    setbuffer(LOCAL->index_stream, LOCAL->stdio_buf, CARMEL2_INDEX_BUF_SIZE);
+    if(LOCAL->index_stream == NULL) {
+        sprintf(carmel_error_buf, "Can't open mailbox: %s", strerror(errno));
+        mm_log(carmel_error_buf, ERROR);
+        return(-1);
+    }
+
+    recent            = 0;
+    stream->nmsgs     = 0;
+    LOCAL->cache_size = 0;
+    LOCAL->mc_blocks  = NULL;
+    LOCAL->index_size = sb.st_size;
+
+    /*---- Read line with magic number, which we already checked ------*/
+    if(fgets(carmel_20k_buf,sizeof(carmel_20k_buf),LOCAL->index_stream)==NULL){
+        fclose(LOCAL->index_stream);
+        mm_log("Mailbox is corrupt. Open failed", ERROR);
+        return(-1);
+    }
+
+    file_pos = ftell(LOCAL->index_stream);  
+    if(carmel2_parse_mail(stream, file_pos) < 0) {
+        fclose(LOCAL->index_stream);
+        mm_log("Mailbox is corrupt. Open failed", ERROR);
+        return(-1);
+    }
+
+    /* Bug, this doesn't really do the recent correctly */
+
+    stream->recent    = recent;
+    return(0);
+}
+
+
+
+/*----------------------------------------------------------------------
+     Carmel mail close
+
+Args: stream -- stream to close
+
+ ----*/
+
+void
+carmel2_close (stream)
+        MAILSTREAM *stream;
+{
+    if (LOCAL) {                        /* only if a file is open */
+        carmel2_check (stream);         /* dump final checkpoint */
+        if(LOCAL->msg_buf)
+          fs_give ((void **) &LOCAL->msg_buf);
+        if(LOCAL->stdio_buf)
+          fs_give ((void **) &LOCAL->stdio_buf);
+                                    /* nuke the local data */
+        fs_give ((void **) &stream->local);
+        stream->dtb = NIL;              /* log out the DTB */
+    }
+}
+
+
+
+/*----------------------------------------------------------------------
+    Carmel mail fetch fast information.
+
+This is a no-op because the data is always available as it is read in to
+the message cache blocks when the folder is opened
+----*/
+void
+carmel2_fetchfast (stream, sequence)
+        MAILSTREAM *stream;
+        char *sequence;
+{
+    return;
+}
+
+
+
+/*----------------------------------------------------------------------
+    Carmel2 mail fetch flags.
+
+This is a no-op because the data is always available as it is read in to
+the message cache blocks when the folder is opened
+----*/
+void
+carmel2_fetchflags(stream, sequence)
+        MAILSTREAM *stream;
+        char *sequence;
+{
+    return;                     /* no-op for local mail */
+}
+
+
+
+/*----------------------------------------------------------------------
+  Carmel mail fetch message structure
+ Args: stream -- stream to get structure for
+       msgno  -- Message number to fetch data for
+       body   -- Pointer to place to return body strucuture, may be NULL
+
+If the request is the for the same msgno as last time, the saved copy
+of the envelope and/or body structure is returned.
+
+To get the envelope the Carmel index file itself must be read and parsed,
+but this is fast because it is easy to parse (by design) and the amount of
+data is small.
+
+To get the body, the whole message is read into memory and then parsed
+by routines called from here. Doing this for a large message can be slow,
+so it is best not to request the body if it is not needed. (body == NULL)
+ ----*/
+
+ENVELOPE *
+carmel2_fetchstructure (stream, msgno, body)
+        MAILSTREAM *stream;
+        long        msgno;
+        BODY      **body;
+{
+    MESSAGECACHE *mc;
+    ENVELOPE    **env;
+    BODY        **b;
+  
+    env = &stream->env;         
+    b   = &stream->body;
+
+    if (msgno != stream->msgno){
+        /* flush old poop if a different message */
+        mail_free_envelope (env);
+        mail_free_body (b);
+    }
+    stream->msgno = msgno;
+
+    mc = MC(msgno);
+
+    if(*env == NULL) {
+        *env = mail_newenvelope();
+      
+        fseek(LOCAL->index_stream, mc->data1, 0);
+        fgets(carmel_20k_buf, sizeof(carmel_20k_buf), LOCAL->index_stream);
+        if(strncmp(carmel_20k_buf, carmel2_s_o_m, carmel2_s_o_m_len))
+          return(NULL); /* Oh ooo */
+      
+         carmel2_date2string(carmel_20k_buf, mc);
+         (*env)->date = cpystr(carmel_20k_buf);
+      
+         while(fgets(carmel_20k_buf, sizeof(carmel_20k_buf),
+                     LOCAL->index_stream) != NULL &&
+               strncmp(carmel_20k_buf, carmel2_s_o_m, carmel2_s_o_m_len)) {
+             carmel_20k_buf[strlen(carmel_20k_buf) - 1] = '\0';
+             switch(*carmel_20k_buf) {
+               case 'F':
+                 (*env)->from = carmel2_parse_address(carmel_20k_buf,
+                                                     (*env)->from,
+                                                     mylocalhost());
+                 break;
+               case 'T':
+                 (*env)->to = carmel2_parse_address(carmel_20k_buf,
+                                                   (*env)->to,
+                                                   mylocalhost());
+                 break;
+               case 'C':
+                 (*env)->cc = carmel2_parse_address(carmel_20k_buf,
+                                                   (*env)->cc,
+                                                   mylocalhost());
+                 break;
+               case 'B':
+                 (*env)->bcc = carmel2_parse_address(carmel_20k_buf,
+                                                    (*env)->bcc,
+                                                    mylocalhost());
+                 break;
+               case 'E':
+                 (*env)->sender = carmel2_parse_address(carmel_20k_buf,
+                                                       (*env)->sender,
+                                                       mylocalhost());
+                 break;
+               case 'R':
+                 (*env)->reply_to = carmel2_parse_address(carmel_20k_buf,
+                                                         (*env)->reply_to,
+                                                         mylocalhost());
+                 break;
+               case 'H':
+                 (*env)->return_path =carmel2_parse_address(carmel_20k_buf,
+                                                           (*env)->return_path,
+                                                           mylocalhost());
+                 break;
+               case 'J':
+                 (*env)->subject     = cpystr(carmel_20k_buf+1);
+                 break;
+               case 'I':
+                 (*env)->message_id  = cpystr(carmel_20k_buf+1);
+                 break;
+               case 'L':
+                 (*env)->in_reply_to = cpystr(carmel_20k_buf+1);
+                 break;
+               case 'N':
+                 (*env)->newsgroups  = cpystr(carmel_20k_buf+1);
+                 break;
+               case 'r':
+                 (*env)->remail      = cpystr(carmel_20k_buf+1);
+                 break;
+               default:
+                 break;
+             }
+         }
+    }
+
+    if(body != NULL) {
+        if(*b == NULL) {
+            /* Have to fetch the body structure too */
+            *b  = carmel2_bodystruct(stream, mc);
+        }
+        *body = *b;
+    }
+  
+    return(*env);    /* return the envelope */
+}
+
+
+
+
+/*----------------------------------------------------------------------
+  Carmel mail fetch message header
+
+Args: stream -- 
+      msgno
+
+Returns: pointer to text of mail header. Returned string is null terminated
+         and consists of internel storage. It will be valid till the next
+         call to mail_fetchheader() or mail_fetchtext(). An empty
+         string is returned if the fetch fails.
+ ----*/
+
+char *
+carmel2_fetchheader (stream, msgno)
+        MAILSTREAM *stream;
+        long msgno;
+{
+    char          *header;
+    MESSAGECACHE  *mc;
+
+    mc     = MC(msgno);
+    header = carmel2_readmsg(stream, 1, 0, mc->data2);
+
+    return(header == NULL ? "" : header);
+}
+
+
+
+/*----------------------------------------------------------------------
+  Carmel mail fetch message text (only)
+
+Args: stream -- 
+      msgno
+
+Returns: pointer to text of mail message. Returned string is null terminated
+         and consists of internel storage. It will be valid till the next
+         call to mail_fetchheader() or mail_fetchtext(). An empty
+         string is returned if the fetch fails.
+ ----*/
+
+char *
+carmel2_fetchtext(stream, msgno)
+        MAILSTREAM *stream;
+        long msgno;
+{
+    MESSAGECACHE *mc;
+    char         *m;
+
+    mc = MC(msgno);
+
+    if (!mc->seen) {            /* if message not seen before */
+        mc->seen = T;           /* mark as seen */
+        LOCAL->dirty = T;       /* and that stream is now dirty */
+    }
+
+    m = carmel2_readmsg(stream, 0, mc->rfc822_size, mc->data2);
+
+    return(m);
+}
+
+
+
+/*----------------------------------------------------------------------
+    Fetch MIME body parts
+
+Args: stream
+      msgno
+      section -- string section number spec. i.e. "1.3.4"
+      len     -- pointer to return len in
+
+Returns: The contents of the body part, or NULL
+ ---*/
+
+char *
+carmel2_fetchbody (stream, msgno, section, len)
+        MAILSTREAM    *stream;
+        long           msgno;
+        char          *section;
+        unsigned long *len;
+{
+    char         *base;
+    BODY         *b;
+    PART         *part;
+    int           part_num;
+    long          offset;
+    MESSAGECACHE *mc;
+
+    if (carmel2_fetchstructure(stream, msgno, &b) == NULL || b == NULL)
+      return(NULL);
+
+    if(section == NULL || *section == '\0')
+      return(NULL);
+
+    part_num = strtol(section, &section, 10);
+    if(part_num <= 0)
+      return(NULL);
+
+    base   = carmel2_fetchtext(stream, msgno);
+    if(base == NULL)
+      base = "";
+    offset = 0;
+
+    do {                         /* until find desired body part */
+        if (b->type == TYPEMULTIPART) {
+            part = b->contents.part;    /* yes, find desired part */
+            while (--part_num && (part = part->next));
+            if (!part) 
+              return (NIL);     /* bad specifier */
+
+            /* Found part, get ready to go further */
+            b = &part->body;
+            if(b->type == TYPEMULTIPART && *section == '\0')
+              return(NULL); /* Ran out of section numbers, needed more */
+               
+            offset = part->offset;      /* and its offset */
+
+        } else if (part_num != 1) {
+            return NIL; /* Not Multipart, better be part 1 */
+        }
+
+                                    /* need to go down further? */
+
+        if(*section == 0) {
+            break;
+        } else { 
+            switch (b->type) {
+              case TYPEMESSAGE: /* embedded message, calculate new base */
+                offset = b->contents.msg.offset;
+                b = b->contents.msg.body;
+                /* got its body, drop into multipart case*/
+  
+              case TYPEMULTIPART:            /* multipart, get next section */
+                if ((*section++ == '.') &&
+                    (part_num = strtol (section, &section,10)) > 0)
+                  break; /* Found the part */
+  
+              default:                  /* bogus subpart specification */
+                return(NULL);
+            }
+        }
+    } while (part_num);
+
+    mc = MC(msgno);
+                                  /* lose if body bogus */
+    if ((!b) || b->type == TYPEMULTIPART)
+      return(NULL);
+
+    if (!mc->seen) {            /* if message not seen before */
+      mc->seen = T;             /* mark as seen */
+      LOCAL->dirty = T;         /* and that stream is now dirty */
+    }
+
+    *len = b->size.ibytes;
+    return(base + offset);
+}
+
+
+
+/*----------------------------------------------------------------------
+ *  Carmel mail set flag
+ * Accepts: MAIL stream
+ *          sequence
+ *          flag(s)
+ */
+
+void
+carmel2_setflag (stream,sequence,flag)
+        MAILSTREAM *stream;
+        char *sequence;
+        char *flag;
+{
+  MESSAGECACHE *elt;
+  long i;
+  short f = carmel2_getflags (stream,flag);
+  if (!f) return;               /* no-op if no flags to modify */
+                                /* get sequence and loop on it */
+  if (mail_sequence (stream,sequence))
+    for (i = 1; i <= stream->nmsgs; i++){
+        elt = MC(i);
+        if (elt->sequence) {
+                                    /* set all requested flags */
+          if (f&fSEEN) elt->seen = T;
+          if (f&fDELETED) elt->deleted = T;
+          if (f&fFLAGGED) elt->flagged = T;
+          if (f&fANSWERED) elt->answered = T;
+          /* Could be more creative about keeping track to see if something
+             really changed */
+          LOCAL->dirty = T;
+        }
+    }
+}
+
+
+
+/*----------------------------------------------------------------------
+ * Carmel mail clear flag
+ * Accepts: MAIL stream
+ *          sequence
+ *          flag(s)
+ */
+
+void
+carmel2_clearflag (stream,sequence,flag)
+        MAILSTREAM *stream;
+        char *sequence;
+        char *flag;
+{
+  MESSAGECACHE *elt;
+  long i = stream->nmsgs;
+  short f = carmel2_getflags (stream,flag);
+  if (!f) return;               /* no-op if no flags to modify */
+                                /* get sequence and loop on it */
+  if (mail_sequence (stream,sequence))
+    for(i = 1; i <= stream->nmsgs; i++) {
+        elt = MC(i);
+        if (elt->sequence) {
+                                    /* clear all requested flags */
+          if (f&fSEEN) elt->seen = NIL;
+          if (f&fDELETED) elt->deleted = NIL;
+          if (f&fFLAGGED) elt->flagged = NIL;
+          if (f&fANSWERED) elt->answered = NIL;
+                            /* clearing either seen or deleted does this */
+          /* Could be more creative about keeping track to see if something
+             really changed */
+          LOCAL->dirty = T;     /* mark stream as dirty */
+        }
+    }
+}
+
+
+
+/* Carmel mail search for messages
+ * Accepts: MAIL stream
+ *          search criteria
+ */
+
+void 
+carmel2_search (stream,criteria)
+        MAILSTREAM *stream;
+        char *criteria;
+{
+  long i,n;
+  char *d;
+  search_t f;
+
+                                /* initially all searched */
+  for (i = 1; i <= stream->nmsgs; ++i) mail_elt (stream,i)->searched = T;
+                                /* get first criterion */
+  if (criteria && (criteria = strtok (criteria," "))) {
+                                /* for each criterion */
+    for (; criteria; (criteria = strtok (NIL," "))) {
+      f = NIL; d = NIL; n = 0;  /* init then scan the criterion */
+      switch (*ucase (criteria)) {
+      case 'A':                 /* possible ALL, ANSWERED */
+        if (!strcmp (criteria+1,"LL")) f = carmel2_search_all;
+        else if (!strcmp (criteria+1,"NSWERED")) f = carmel2_search_answered;
+        break;
+      case 'B':                 /* possible BCC, BEFORE, BODY */
+        if (!strcmp (criteria+1,"CC"))
+          f = carmel2_search_string (carmel2_search_bcc,&d,&n);
+        else if (!strcmp (criteria+1,"EFORE"))
+          f = carmel2_search_date (carmel2_search_before,&n);
+        else if (!strcmp (criteria+1,"ODY"))
+          f = carmel2_search_string (carmel2_search_body,&d,&n);
+        break;
+      case 'C':                 /* possible CC */
+        if (!strcmp (criteria+1,"C"))
+          f = carmel2_search_string (carmel2_search_cc,&d,&n);
+        break;
+      case 'D':                 /* possible DELETED */
+        if (!strcmp (criteria+1,"ELETED")) f = carmel2_search_deleted;
+        break;
+      case 'F':                 /* possible FLAGGED, FROM */
+        if (!strcmp (criteria+1,"LAGGED")) f = carmel2_search_flagged;
+        else if (!strcmp (criteria+1,"ROM"))
+          f = carmel2_search_string (carmel2_search_from,&d,&n);
+        break;
+      case 'K':                 /* possible KEYWORD */
+        if (!strcmp (criteria+1,"EYWORD"))
+          f = carmel2_search_flag (carmel2_search_keyword,&d);
+        break;
+      case 'N':                 /* possible NEW */
+        if (!strcmp (criteria+1,"EW")) f = carmel2_search_new;
+        break;
+
+      case 'O':                 /* possible OLD, ON */
+        if (!strcmp (criteria+1,"LD")) f = carmel2_search_old;
+        else if (!strcmp (criteria+1,"N"))
+          f = carmel2_search_date (carmel2_search_on,&n);
+        break;
+      case 'R':                 /* possible RECENT */
+        if (!strcmp (criteria+1,"ECENT")) f = carmel2_search_recent;
+        break;
+      case 'S':                 /* possible SEEN, SINCE, SUBJECT */
+        if (!strcmp (criteria+1,"EEN")) f = carmel2_search_seen;
+        else if (!strcmp (criteria+1,"INCE"))
+          f = carmel2_search_date (carmel2_search_since,&n);
+        else if (!strcmp (criteria+1,"UBJECT"))
+          f = carmel2_search_string (carmel2_search_subject,&d,&n);
+        break;
+      case 'T':                 /* possible TEXT, TO */
+        if (!strcmp (criteria+1,"EXT"))
+          f = carmel2_search_string (carmel2_search_text,&d,&n);
+        else if (!strcmp (criteria+1,"O"))
+          f = carmel2_search_string (carmel2_search_to,&d,&n);
+        break;
+      case 'U':                 /* possible UN* */
+        if (criteria[1] == 'N') {
+          if (!strcmp (criteria+2,"ANSWERED")) f = carmel2_search_unanswered;
+          else if (!strcmp (criteria+2,"DELETED")) f = carmel2_search_undeleted;
+          else if (!strcmp (criteria+2,"FLAGGED")) f = carmel2_search_unflagged;
+          else if (!strcmp (criteria+2,"KEYWORD"))
+            f = carmel2_search_flag (carmel2_search_unkeyword,&d);
+          else if (!strcmp (criteria+2,"SEEN")) f = carmel2_search_unseen;
+        }
+        break;
+      default:                  /* we will barf below */
+        break;
+      }
+      if (!f) {                 /* if can't determine any criteria */
+        sprintf(carmel_error_buf,"Unknown search criterion: %s",criteria);
+        mm_log (carmel_error_buf,ERROR);
+        return;
+      }
+                                /* run the search criterion */
+      for (i = 1; i <= stream->nmsgs; ++i)
+        if (mail_elt (stream,i)->searched && !(*f) (stream,i,d,n))
+          mail_elt (stream,i)->searched = NIL;
+    }
+                                /* report search results to main program */
+    for (i = 1; i <= stream->nmsgs; ++i)
+      if (mail_elt (stream,i)->searched) mail_searched (stream,i);
+  }
+}
+
+
+
+
+/*----------------------------------------------------------------------
+ * Carmel mail ping mailbox
+ * Accepts: MAIL stream
+ * Returns: T if stream alive, else NIL
+ */
+
+long
+carmel2_ping (stream)
+    MAILSTREAM *stream;
+{
+    struct stat sb;
+    char path[1000], *mailfile;
+#ifdef TESTING
+    char debug_buf[1000];
+#endif
+
+    if(!stream->readonly &&
+       carmel2_update_lock(stream->local, stream->mailbox, READ_LOCK) < 0) {
+        /* Yuck! Someone messed up our lock file, this stream is hosed */
+        mm_log("Mailbox updated unexpectedly! Mailbox closed", ERROR);
+        stream->readonly = 1;
+        return NIL;
+    }
+
+    /*--- First check to see if the Carmel index grew ----*/
+    /* BUG, will this really work on NFS since the file is held open? */
+    stat((*LOCAL->calc_paths)(CalcPathCarmel2Index, stream->mailbox, 0), &sb);
+    if(sb.st_size > LOCAL->index_size) {
+#ifdef TESTING
+        mm_log("!!!!! Carmel index grew", NIL);
+#endif
+        /* Pull in the new mail.... */
+#ifdef MAY_NEED_FOR_NFS
+        /*---- First close and reopen the mail file -----*/
+        fclose(LOCAL->index_stream);
+        LOCAL->index_stream = fopen((*LOCAL->calc_paths)(CalcPathCarmel2Index,
+                                                         stream->mailbox, 0),
+                                    stream->readonly ? "r" : "r+");
+        if(LOCAL->index_stream == NULL) {
+            mm_log("Mailbox stolen. Mailbox closed", ERROR);
+            stream->readonly = 1;
+            return NIL;
+        } 
+#endif
+        if(carmel2_parse_mail(stream, LOCAL->index_size) < 0) {
+            mm_log("Mailbox corrupted. Mailbox closed", ERROR);
+            stream->readonly = 1;
+            return NIL;
+        }
+        LOCAL->index_size = sb.st_size;
+    }
+
+    if(sb.st_size < LOCAL->index_size) {
+        /* Something bad happened, mail box shrunk on us, shutdown */
+        stream->readonly = 1;
+        mm_log("Mailbox shrank unexpectedly! Mailbox closed", ERROR);
+        return NIL;
+    }
+
+#ifdef TESTING
+    sprintf(debug_buf, "!!!!! Mailbox:\"%s\"  pretty_mailbox:\"%s\"",
+            stream->mailbox, carmel_pretty_mailbox(stream->mailbox));
+    mm_log(debug_buf, NIL);
+    sprintf(debug_buf, "!!!! Readonly:%d, Carmel:%d", stream->readonly,
+            LOCAL->carmel);
+    mm_log(debug_buf, NIL);
+#endif    
+
+    if(!stream->readonly &&
+       ((LOCAL->carmel &&
+         strcmp(carmel_pretty_mailbox(stream->mailbox), "MAIL") == 0) ||
+        strucmp2(carmel_pretty_mailbox(stream->mailbox), "inbox") == 0)) {
+        /* If it's the inbox we've got to check the spool file */
+        mailfile = getenv("MAIL") == NULL ? MAILFILE : getenv("MAIL");
+        sprintf(path, mailfile, myhomedir());
+#ifdef TESTING
+        sprintf(debug_buf, "!!!!! Checking spool mail\"%s\"", path);
+        mm_log(debug_buf, NIL);
+#endif    
+        if(stat(path, &sb) < 0)
+          return(T);  /* No new mail...*/
+        if(sb.st_size > 0) {
+            mm_critical(stream);
+            if(carmel2_lock(stream->local, stream->mailbox, WRITE_LOCK) < 0) {
+                mm_nocritical(stream);
+                return(T);
+            }
+            mm_log("!!!! Inbox locked, sucking in mail", NIL);
+            carmel2_spool_mail(stream, path, stream->mailbox, 1); /*go get it*/
+            carmel2_unlock(stream->local, stream->mailbox, WRITE_LOCK);
+            mm_nocritical(stream);
+            stat((*LOCAL->calc_paths)(CalcPathCarmel2Index, stream->mailbox,0),
+                 &sb);
+            LOCAL->index_size = sb.st_size;
+        }
+    } 
+    
+    return T;                   
+}
+
+
+
+
+
+/*----------------------------------------------------------------------
+    This checks for new mail and checkpoints the mail file
+
+Args -- The stream to check point
+
+ ----*/
+void 
+carmel2_check(stream)
+        MAILSTREAM *stream;
+{
+    (void)carmel2_check2(stream);
+}
+
+
+
+/*----------------------------------------------------------------------
+    Do actual work of a check on carmel2 index, returning status
+
+Returns: 0 if no checkpoint was done, 1 if it was done.
+  ----*/
+carmel2_check2(stream)
+     MAILSTREAM *stream;
+{
+    int msgno;
+    MESSAGECACHE *mc;
+
+    if(stream->readonly || LOCAL == NULL)
+      return(0); /* Nothing to do in readonly or closed case */
+
+    carmel2_ping(stream); /* check for new mail (Ping always checks) */
+
+    if(!LOCAL->dirty)
+      return(0); /* Nothing to do */
+
+    mm_critical(stream);
+    if(carmel2_lock(stream->local, stream->mailbox, WRITE_LOCK) < 0) {
+        mm_nocritical(stream);
+        return(0); /* Couldn't get a write lock, nothing we can do */
+    }
+
+    for(msgno = 1; msgno <= stream->nmsgs; msgno++) {
+        mc = MC(msgno);
+        fseek(LOCAL->index_stream, mc->data1 +  carmel2_s_o_m_len  + 13, 0);
+        if(fprintf(LOCAL->index_stream,
+                   "U%c%c%c%c%c____________________________\n",
+                   mc->flagged  ? 'F' : 'f',
+                   mc->recent   ? 'R' : 'r',
+                   mc->answered ? 'A' : 'a',
+                   mc->deleted  ? 'D' : 'd',
+                   mc->seen     ? 'S' : 's') == EOF) {
+            /* BUG .. Need some error check here */
+        }
+    }
+    fflush(LOCAL->index_stream);
+
+    carmel2_unlock(stream->local, stream->mailbox, WRITE_LOCK);
+    mm_nocritical(stream);
+    mm_log("Check completed", NIL);
+     return(1);
+}
+    
+
+
+
+
+/*----------------------------------------------------------------------
+  Carmel2 mail expunge mailbox
+
+Args: stream  -- mail stream to expunge
+
+ ----*/
+
+void carmel2_expunge (stream)
+        MAILSTREAM *stream;
+{
+    char        *index_file;
+    long         msgno, new_msgno;
+    FILE         *new_index;
+    MESSAGECACHE *mc, *new_mc;
+    ENVELOPE     *envelope;
+    int           save_e;
+    struct stat   sb;
+    
+    if (stream->readonly) {
+        if(!stream->silent)
+          mm_log ("Expunge ignored on readonly mailbox",NIL);
+        return;
+    }
+    
+    mm_critical(stream);
+    carmel2_lock(stream->local, stream->mailbox, WRITE_LOCK);
+
+    strcpy(carmel_path_buf,
+           (*LOCAL->calc_paths)(CalcPathCarmel2Expunge, stream->mailbox, 0));
+
+    new_index = fopen(carmel_path_buf, "w");
+    if(new_index == NULL) {
+        goto fail;
+    }
+    if(fprintf(new_index, carmel2_s_o_f) == EOF)
+      goto fail;
+
+    new_msgno = 1;
+    for(msgno = 1; msgno <= stream->nmsgs; msgno++) {
+        mc = MC(msgno);
+        if(mc->deleted) {
+            mm_expunged(stream, new_msgno);
+            continue;
+        }
+
+        if(msgno != new_msgno) {
+            new_mc        = MC(new_msgno);
+            *new_mc       = *mc;
+            new_mc->msgno = new_msgno;
+            mc            = new_mc;
+        }
+
+        envelope = carmel2_fetchstructure(stream, msgno, NULL);
+        if(envelope == NULL)
+          goto fail;
+
+        /* get this after envelope to offset is still valid in old file */
+        mc->data1 = ftell(new_index); 
+
+        if(carmel2_write_index(envelope, mc, new_index) < 0)
+          goto fail;
+        new_msgno++;
+    }
+
+    index_file = (*LOCAL->calc_paths)(CalcPathCarmel2Index, stream->mailbox, 0);
+
+    /*--- Close it to make sure bits are really on disk across NFS. ---*/
+    if(fclose(new_index) != EOF) {
+        /*--- copy of index was a success, rename it ---*/
+        unlink(index_file);
+        link(carmel_path_buf, index_file); 
+
+        /*--- Save the mail index size ----*/
+        stat(index_file, &sb);
+        LOCAL->index_size = sb.st_size;
+
+        stream->nmsgs = new_msgno - 1;
+        mm_exists(stream, stream->nmsgs);
+        
+        fclose(LOCAL->index_stream);
+        LOCAL->index_stream = fopen(index_file, "r+");
+    }
+    unlink(carmel_path_buf); 
+    carmel2_unlock(stream->local, stream->mailbox, WRITE_LOCK);
+    mm_nocritical(stream);
+    return;
+
+  fail:
+    save_e = errno;
+    if(new_index != NULL)
+      fclose(new_index);
+    unlink(carmel_path_buf); 
+    sprintf(carmel_error_buf, "Expunge failed: %s", strerror(save_e));
+    mm_log(carmel_error_buf, WARN);
+    carmel2_unlock(stream->local, stream->mailbox, WRITE_LOCK);
+    mm_nocritical(stream);
+    return;
+}
+
+
+
+/*----------------------------------------------------------------------
+   Carmel2 mail copy message(s)
+
+ Args: stream    - mail stream
+       sequence  - message sequence
+       mailbox   - destination mailbox, FQN
+
+ Returns: T if copy successful, else NIL
+  ----*/
+long 
+carmel2_copy(stream, sequence, mailbox)
+        MAILSTREAM *stream;
+        char       *sequence;
+        char       *mailbox;
+{
+    ENVELOPE     *e;
+    MESSAGECACHE *mc, new_mc;
+    long          msgno, file_no, file_pos;
+    int           fail;
+    char         *file_name, *line;
+    FILE         *dest_stream;
+    struct stat   sb;
+
+    if (!mail_sequence (stream,sequence)) /* get sequence to do */
+      return(NIL);
+
+    /*--- Get the file open (creating if needed) first ----*/
+    file_name = (*LOCAL->calc_paths)(CalcPathCarmel2Index, mailbox, 0, 0);
+    if(file_name == NULL) 
+      return(NIL);
+
+    if(stat(file_name, &sb) < 0) {
+        mm_notify (stream,"[TRYCREATE] Must create mailbox before copy", NIL);
+        return(NIL);
+    }
+
+    dest_stream = fopen(file_name, "a+");
+    if(dest_stream == NULL) {
+        sprintf(carmel_error_buf, "Can't copy message to %s: %s",
+                mailbox, strerror(errno));
+        mm_log(carmel_error_buf, ERROR);
+        return(NIL);
+    }
+
+    mm_critical(stream);
+
+    if(carmel2_lock(stream->local, mailbox, WRITE_LOCK) < 0) {
+        mm_nocritical(stream);
+        sprintf(carmel_error_buf,
+                "Mailbox %s locked, can't copy messages to it",
+                mailbox);
+        mm_log(carmel_error_buf, ERROR);
+        fclose(dest_stream);
+        return(NIL);
+    }
+
+
+    /*--- Get the destination Carmel index open ----*/
+    file_pos = ftell(dest_stream);
+    fail = 0;
+
+
+    for(msgno = 1; msgno <= stream->nmsgs; msgno++) {
+        mc = MC(msgno);
+        if(!mc->sequence)
+          continue;
+
+        new_mc = *mc;
+
+        if(LOCAL->new_file_on_copy) {
+            new_mc.data2 = carmel2_copy_msg_file(stream, mc->data2, mailbox);
+            if((long)new_mc.data2 < 0) {
+                fail = 1;
+                break;
+            }
+        }
+
+        e = carmel2_fetchstructure(stream, msgno, NULL);
+        if(carmel2_write_index(e, &new_mc, dest_stream) < 0) {
+            fail = 1;
+            break;
+        }
+
+        if(LOCAL->carmel && LOCAL->aux_copy != NULL) {
+            if((*LOCAL->aux_copy)(stream->local, mailbox, e, &new_mc)) {
+                fail = 1;
+                break;
+            }
+        }
+    }
+
+    if(fail) {
+        ftruncate(fileno(dest_stream), file_pos);
+    }
+
+    fclose(dest_stream);
+
+    carmel2_unlock(stream->local, mailbox, WRITE_LOCK);
+
+    mm_nocritical(stream);
+
+    return(fail ? NIL : T);
+}
+
+
+
+/*----------------------------------------------------------------------
+   Carmel2 mail move message(s)
+
+
+  Returns: T if move successful, else NIL
+ ----*/
+
+long
+carmel2_move (stream,sequence,mailbox)
+        MAILSTREAM *stream;
+        char *sequence;
+        char *mailbox;
+{
+  long          i;
+  MESSAGECACHE *elt;
+
+  if (!(mail_sequence (stream,sequence) &&
+        carmel2_copy (stream,sequence,mailbox))) return NIL;
+                                /* delete all requested messages */
+  for (i = 1; i <= stream->nmsgs; i++)
+    elt = MC(i);
+    if (elt->sequence) {
+      elt->deleted = T;         /* mark message deleted */
+      LOCAL->dirty = T;         /* mark mailbox as dirty */
+    }
+  return T;
+}
+
+
+
+/*----------------------------------------------------------------------
+ * Carmel2 garbage collect stream
+ * Accepts: Mail stream
+ *          garbage collection flags
+ */
+
+void carmel2_gc (stream, gcflags)
+        MAILSTREAM *stream;
+        long gcflags;
+{
+    /* No garbage collection in Carmel2 driver, not much to collect */
+}
+
+
+
+/*----------------------------------------------------------------------
+    Handle MessageCache for carmel2 mail driver
+
+Args: stream --
+      msgno -- message number
+      op    -- operation code
+
+The carmel2 format keeps MESSAGECACHE entries in core for all messages
+in the open mail folder so there isn't any cache flushing and rereading
+that has to go on.
+  ----*/
+void *
+carmel2_cache(stream, msgno, op)
+        MAILSTREAM *stream;
+        long msgno;
+        long op;
+{
+  /* It's a carmel driver if first 6 letters of name are carmel */
+  if(stream->dtb == NULL)
+    return(0);
+
+  if(struncmp2(stream->dtb->name, "carmel", 6) == 0) { 
+    if(op == CH_MAKEELT)
+      return(MC(msgno));
+    else
+      return(0);
+  }
+
+  /* Not a carmel2 or carmel driver, call the standard function. This works
+     as long as there is only one other driver since we know it must be
+     mm_cache().
+   */
+  return(mm_cache(stream, msgno, op));
+}
+        
+
+
+/*----------------------------------------------------------------------
+    Append a message to a mailbox
+
+Args: mailbox -- The message to append the mail folder too
+      message -- Message header and text in rfc822 \r\n format to append
+
+Returns: T if all went OK, NIL if not
+ ----*/
+long
+carmel2_append(stream, mailbox, flags, date, message)
+     MAILSTREAM *stream;
+     char       *mailbox, *flags, *date;
+     STRING     *message;
+{
+    CARMEL2LOCAL local;
+
+    /*---- A fake local data structure to pass to other functions---*/
+    local.calc_paths = carmel2_calc_paths;
+    local.carmel     = 0;
+    local.aux_copy   = NULL;
+
+    return(carmel2_append2(stream, &local, mailbox, flags, date, message));
+}
+      
+
+
+
+/*----------------------------------------------------------------------
+    Fetch the body structure for a camel message
+
+Args: stream -- MAILSTREAM
+      mc     -- The incore message cache entry for the message
+
+Returns: body structure
+
+Note, the envelope that results from the parse here is ignored. Only
+the envelope from the index is actually used in the Carmel2 format.
+ ----*/
+static BODY *
+carmel2_bodystruct(stream, mc)
+     MESSAGECACHE *mc;
+     MAILSTREAM   *stream;
+{
+    char     *header, *text, *file, *p;
+    ENVELOPE *e_place_holder;
+    BODY     *b;
+    STRING    string_struct;
+
+    header = carmel2_readmsg(stream, 1,  mc->rfc822_size, mc->data2);
+    if(header == NULL)
+      return(NULL);
+
+    text = carmel2_readmsg(stream, 0, mc->rfc822_size, mc->data2);
+    if(text == NULL)
+      return(NULL);
+
+    INIT(&string_struct, mail_string, (void *)text, strlen(text));
+    rfc822_parse_msg(&e_place_holder, &b, header, strlen(header),
+                     &string_struct, mylocalhost(), carmel_20k_buf);
+
+    mail_free_envelope(&e_place_holder);
+
+#ifdef BWC 
+    /* If there's no content type in the header and it's the carmel
+       driver at the BWC set the type X-BWC-Glyph
+     */
+    for(p = header; *p; p++) 
+      if(*p=='\n' && (*(p+1)=='C' || *(p+1)=='c') &&
+        struncmp2(p+1,"content-type:", 13) == 0)
+          break;
+
+    if(!*p && LOCAL->carmel &&    /* Carmel, not Carmel2 */
+       b->type == TYPETEXT &&     /* Type text */
+       (b->subtype == NULL || strcmp(b->subtype,"PLAIN") == 0) && 
+       ((int)mc->year) + 1969 < 1994) {
+        /* Most mail in a pod mail store is in the BWC-Glyph character
+           set, but there is no tag in the data on disk, so we fake it here.
+           We expect after 1994 all mail generated in BWC-Glyph format
+           will have proper tags!
+         */
+        b->subtype = cpystr("X-BWC-Glyph");
+    }
+#endif 
+
+    return(b);
+}
+
+
+
+/*----------------------------------------------------------------------
+    Parse an address in a Carmel2 format mail index
+
+Args: line  -- The line from the index to parse
+      addr  -- The address list to add to (if there is one)
+
+Returns: address list
+ ----*/
+static ADDRESS *
+carmel2_parse_address(line, addr, localhost)
+     char    *line, *localhost;
+     ADDRESS *addr;
+{
+    ADDRESS *a;
+
+    if(addr == NULL) {
+        addr = mail_newaddr();
+        a = addr;
+    } else {
+        for(a = addr; a!= NULL && a->next != NULL; a = a->next);
+        a->next = mail_newaddr();
+        a = a->next;
+    }
+
+    line++;  /* Skip the tag chacater */
+    a->personal = carmel2_parse_addr_field(&line);
+    a->mailbox  = carmel2_parse_addr_field(&line);
+    a->host     = carmel2_parse_addr_field(&line);
+    a->adl      = carmel2_parse_addr_field(&line);
+/*    if(a->host == NULL)
+      a->host = cpystr(localhost); */ /* host can't be NULL */
+      /* Yes it can for Internet group syntax */
+    return(addr);
+}
+
+
+
+/*----------------------------------------------------------------------
+   Parse the next address field out of a carmel address index entry
+
+Args: string -- pointer to pointer to string
+
+Returns: field in malloced string or NULL
+
+Input string is a bunch of substrings separated by ^A. This function scans 
+for the next ^A or end of string, cuts it out and returns it. The original
+strings passed in is mangled
+----*/
+static char *
+carmel2_parse_addr_field(string)
+     char **string;
+{
+    char *p, end, *start;
+
+    start = p  = *string;
+    while(*p > '\001')  /* Find end of sub string or string */
+      p++;
+    if((p - *string) == 0) {
+        if(*p) p++;
+        *string = p;
+        return(NULL); /* If nothing found return nothing */
+    }
+    end = *p;       /* Save terminating character (^A or \0) */
+    *p = '\0';     
+    if(end)         /* If not end of string, get ready for next call */
+      p++;
+    *string = p;    /* Return pointer to next substring */
+    return(cpystr(start));
+}
+
+
+    
+    
+/*----------------------------------------------------------------------
+     Write an entry into a carmel2 index
+
+Args: e      -- Envelope
+      mc     -- Message Cache element
+      stream -- File stream to write to
+
+Returns: 0 if OK, -1 if failed
+----*/
+carmel2_write_index(e, mc, stream)
+     ENVELOPE     *e;
+     MESSAGECACHE *mc;
+     FILE         *stream;
+{
+    long f_start, f_end;
+
+    f_start = ftell(stream);
+
+    if(fprintf(stream, "%s\007\001xxxxxxxxxx\n", carmel2_s_o_m) == EOF)
+      goto blah;
+    if(fprintf(stream, "U%c%c%c%c%c____________________________\n",
+            mc->flagged  ? 'F' : 'f',
+            mc->recent   ? 'R' : 'r',
+            mc->answered ? 'A' : 'a',
+            mc->deleted  ? 'D' : 'd',
+            mc->seen     ? 'S' : 's') == EOF)
+      goto blah;
+    if(fprintf(stream, "Z%d\n", mc->rfc822_size) == EOF)
+      goto blah;
+    if(fprintf(stream, "D%d\001%d\001%d\001%d\001%d\001%d\001%d\001%d\n",
+            mc->year+1969, mc->month, mc->day, mc->hours, mc->minutes,
+            mc->seconds, mc->zhours * (mc->zoccident ? 1 : -1),
+               mc->zminutes) == EOF)
+       goto blah;
+    if(fprintf(stream, "Svmail\n") == EOF)
+       goto blah;
+    if(fprintf(stream, "P%d\n",mc->data2) == EOF)
+       goto blah;
+    if(carmel2_index_address(e->to,   'T', stream) < 0)
+       goto blah;
+    if(carmel2_index_address(e->from, 'F', stream) < 0)
+       goto blah;
+    if(carmel2_index_address(e->cc,   'C', stream) < 0)
+       goto blah;
+    if(carmel2_index_address(e->bcc,  'B', stream) < 0)
+       goto blah;
+#ifdef HAVE_RESENT
+    if(carmel2_index_address(e->resent_to,   't', stream) < 0)
+       goto blah;
+    if(carmel2_index_address(e->resent_from, 'f', stream) < 0)
+       goto blah;
+    if(carmel2_index_address(e->resent_cc,   'c', stream) < 0)
+       goto blah;
+    if(carmel2_index_address(e->resent_bcc,  'b', stream) < 0)
+       goto blah;
+#endif
+    if(carmel2_index_address(e->return_path, 'H', stream) < 0)
+       goto blah;
+    if(carmel2_index_address(e->sender,      'E', stream) < 0)
+       goto blah;
+    if(carmel2_index_address(e->reply_to,    'R', stream) < 0)
+       goto blah;
+    if(e->in_reply_to != NULL)
+      if(fprintf(stream, "L%s\n", e->in_reply_to) == EOF)
+       goto blah;
+    if(e->remail != NULL)
+      if(fprintf(stream, "r%s\n", e->remail) == EOF)
+       goto blah;
+    if(e->message_id != NULL)
+      if(fprintf(stream, "I%s\n", e->message_id) == EOF)
+       goto blah;
+    if(e->newsgroups != NULL)
+      if(fprintf(stream, "N%s\n", e->newsgroups) == EOF)
+       goto blah;
+    if(e->subject != NULL)
+      if(fprintf(stream, "J%s\n", e->subject) == EOF)
+        goto blah;
+
+    /*--- figure out and write the offset ---*/
+    f_end = ftell(stream);
+    if(fseek(stream, f_start, 0) < 0)
+      goto blah;
+    if(fprintf(stream, "%s\007\001%10d\n", carmel2_s_o_m, f_end - f_start)==EOF)
+      goto blah;
+    if(fseek(stream, f_end, 0) < 0)
+      goto blah;
+
+    return(0);
+
+  blah:
+    /* Index entry is a bit of a mess now. Maybe we should try to truncate */
+    return(-1);
+}
+
+
+
+/*----------------------------------------------------------------------
+    Write an address entry into a carmel2 index
+
+Args: addr   -- addresslist
+      field  -- Field character specifier
+      stream -- File stream to write to
+
+Returns 0 if OK, -1 on error writing
+ ---*/ 
+static
+carmel2_index_address(addr, field, stream)
+    ADDRESS *addr;
+    int      field;
+    FILE    *stream;
+{
+    ADDRESS *a;
+
+    for(a = addr; a != NULL; a = a->next) {
+        if(fprintf(stream, "%c%s\001%s\001%s\001%s\n",
+                   field,
+                   a->personal == NULL ? "" : a->personal,
+                   a->mailbox  == NULL ? "" : a->mailbox,
+                   a->host     == NULL ? "" : a->host,
+                   a->adl      == NULL ? "" : a->adl) == EOF)
+          return(-1);
+    }
+    return(0);
+}
+    
+
+
+/*----------------------------------------------------------------------
+   Real work of reading mail data files
+
+Args: stream 
+      header_only -- return header if set, text if not
+      file_size   -- The file size if known (saves a stat)
+      file        -- name of the file to read
+
+Returns buffer with text stored in internel buffer. The Carmel2 format
+buffers the text of the current message and header in an internal
+buffer. The buffer never shrinks and is expanded as needed, up to a
+maximum. The text in the buffer is in CRLF format and is read in line
+by line using stdio. It is believed this will be efficient on whatever
+machine it is running on and will not use too much memory.  (There's
+some extra memory used for buffering in stdio.) If a request is made
+first for only the header, then only the header will be read in.  This
+is a big efficiency win when the file is large and only the header is
+needed. (In the Carmel2 format the header is genera lly not used, and
+when it is it is with the body to do a MIME parse, but the pod format
+does read the headers in to create the Carmel2 index.) An estimate is
+made of the size needed to expand the file to convert the line ends
+from LF to CRLF. The estimate alloca tes 10% extra space. If it
+doesn't fit, the whole buffer will be expanded by 50% and the whole
+read done over. When the header is read in a 30K buffer is allocated
+initially (if the buffer is smaller than that initially). The 50%
+increase is applied to the buffer when reading only the header.
+  ----*/
+
+char *
+carmel2_readmsg(stream, header_only, file_size, file_num)
+     MAILSTREAM *stream;
+     int         header_only;
+     int         file_num;
+     long        file_size;
+{
+    FILE       *msg_stream;
+    char       *p, *p_end, *file_name;
+    int         past_header, not_eof;
+    long        max_read;
+    struct stat st;
+#define DEBUGDEBUG 1
+#ifdef DEBUGDEBUG
+    char        debug_buf[500];
+#endif
+
+    file_name = (*LOCAL->calc_paths)(CalcPathCarmel2Data,
+                                     stream->mailbox, file_num);
+    if(file_name == NULL)
+      return(NULL); /* Just in case; should never be invalid if open */
+#ifdef DEBUGDEBUG
+    sprintf(debug_buf, "READ RQ:\"%s\" HV:\"%s\"  RQ_HD:%d  HV_TXT:%d\n",
+            file_name,
+            LOCAL->buffered_file == NULL ? "" : LOCAL->buffered_file,
+            header_only, LOCAL->buffered_header_and_text);
+    mm_log(debug_buf, NIL);
+#endif
+
+    /*---- Check out what we have read already -----*/
+    if(LOCAL->buffered_file != NULL &&
+       strcmp(LOCAL->buffered_file, file_name) == 0) {
+        /* The file is the same. Now have we read in the part
+           that is wanted? If so return it.
+         */
+        if(header_only || LOCAL->buffered_header_and_text) {
+            if(header_only) {
+#ifdef DEBUGDEBUG
+                mm_log("....Returning buffered header\n", NIL);
+#endif
+                return(LOCAL->msg_buf);
+            } else {
+#ifdef DEBUGDEBUG
+                mm_log("....Returning buffered text\n", NIL);
+#endif
+                return(LOCAL->msg_buf_text_start);
+            }
+        }
+    } else {
+        /*-- Different file than last time, reset a few things --*/
+        LOCAL->buffered_header_and_text = 0;
+        LOCAL->msg_buf_text_offset      = 0L;
+        if(LOCAL->buffered_file != NULL)
+          fs_give((void **)&(LOCAL->buffered_file));
+    }
+
+#ifdef DEBUGDEBUG
+     mm_log("....Reading file\n", NIL);
+#endif
+
+    /*----- Open the file ------*/
+    /* Would actually be more efficient not to use stdio here */
+    msg_stream = fopen(file_name, "r");
+    if(msg_stream == NULL) {
+        strcat(file_name, ".wid");
+        msg_stream = fopen(file_name, "r");
+        if(msg_stream == NULL)
+           return(NULL);
+    }
+
+    /*---- Check the size of the file ----*/
+    if(file_size == 0 && stat(file_name, &st) >= 0)
+      file_size = st.st_size;
+
+
+    /* ------Pick an amount to read -------
+       Assume the header is less than MAX_HEADER. We don't want to
+       allocate buffer for the whole message if we are just getting
+       the header. 
+     */
+    max_read    = (file_size * 11) / 10;
+    past_header = 0;
+    p           = LOCAL->msg_buf;
+    if(header_only) {
+        max_read = min(max_read, CARMEL_MAX_HEADER);
+    } else if(LOCAL->msg_buf_text_offset > 0) {
+        past_header = 1;
+        p = LOCAL->msg_buf_text_start;
+        fseek(msg_stream, LOCAL->msg_buf_text_offset, 0);
+    }
+    if(max_read > CARMEL_MAXMESSAGESIZE)
+      max_read = CARMEL_MAXMESSAGESIZE;
+    if(max_read == 0)
+      max_read = 1;  /* Forces buffer allocation below */
+
+
+    /*----- Loop (re)reading the whole file 'till it fits ---*/
+    /* This will fit the first time for all but the 
+       strangest cases.
+     */
+    do {
+        /*---- Make sure buffer is the right size ----*/              
+        if(LOCAL->msg_buf_size < max_read) {
+            /* Buffer not big, enough start whole read over */
+            if(LOCAL->msg_buf != NULL)
+              fs_give((void **)&(LOCAL->msg_buf));
+            LOCAL->msg_buf      = fs_get(max_read);
+            LOCAL->msg_buf_size = max_read;
+            fseek(msg_stream, 0, 0);
+            past_header = 0;
+            p = LOCAL->msg_buf;
+        }
+    
+        p_end = LOCAL->msg_buf + LOCAL->msg_buf_size - 3;
+
+        while(p < p_end && (not_eof =(fgets(p, p_end-p, msg_stream) != NULL))){
+            if(*p == '\n' && !past_header) {
+                *p++ = '\r';
+                *p++ = '\n';
+                *p++ = '\0';
+                past_header = 1;
+                LOCAL->msg_buf_text_offset = ftell(msg_stream);
+                LOCAL->msg_buf_text_start  = p;
+                if(header_only)
+                  goto done;
+                else
+                  continue;
+            }
+            p += strlen(p) - 1;    
+            *p++ = '\r';
+            *p++ = '\n';  
+        }
+        *p = '\0';
+        if(!not_eof)
+          goto done;
+
+        /* If we're here, the buffer wasn't big enough, which
+           is due to a message with most lines less than 10 characters 
+           (the 10% addition for turning LF to CRLF wasn't enough).
+           Increase it by 50% and try again, till we hit
+           the largest message we can read 
+          */
+        max_read = min(CARMEL_MAXMESSAGESIZE, (max_read * 15) / 10);
+        fseek(msg_stream, 0, 0);
+    } while (1);
+  done:
+    if(p == p_end) 
+      mm_log("Message truncated. It's is too large", WARN);
+
+    fclose(msg_stream);
+
+    /*---- Save the name of the file buffered file ----*/
+    LOCAL->buffered_file             = cpystr(file_name);
+    LOCAL->buffered_header_and_text |= !header_only;
+
+    return(header_only ? LOCAL->msg_buf : LOCAL->msg_buf_text_start);
+}
+
+
+/*----------------------------------------------------------------------
+    Parse basic/quick entries in a Carmel mailbox
+
+Args: stream -- stream for mailbox
+      file_pos -- File position in the index to start parsing at
+
+Returns:  0 if parse succeeds
+         -1 if it fails
+ ----*/
+static int
+carmel2_parse_mail(stream, file_pos)
+     MAILSTREAM *stream;
+     long        file_pos;
+{
+    MESSAGECACHE *mc;
+    long          nmsgs, next, last_line_read;
+    int           found;
+
+    nmsgs = stream->nmsgs;
+
+    /*---- Get the start-of-message record ------*/
+    fseek(LOCAL->index_stream, file_pos, 0);
+    if(fgets(carmel_20k_buf,sizeof(carmel_20k_buf),LOCAL->index_stream)==NULL)
+       goto done_reading;
+    if(strncmp(carmel_20k_buf, carmel2_s_o_m, carmel2_s_o_m_len) != 0)
+      goto bomb;
+
+    while(1) {
+        if(strlen(carmel_20k_buf) != carmel2_s_o_m_len + 13)
+          goto bomb;
+
+        nmsgs++;
+        next      = atol(carmel_20k_buf+24);
+        mc        = carmel2_new_mc(stream, nmsgs);
+        mc->data1 = file_pos;
+
+        /*-- Get the status line, It must be the first line in the entry ----*/
+        if(fgets(carmel_20k_buf,sizeof(carmel_20k_buf),
+                 LOCAL->index_stream) == NULL)
+          goto done_reading;
+        if(*carmel_20k_buf != 'U' || strlen(carmel_20k_buf) != 35)
+          goto bomb; /* Invalid format! */
+        mc->flagged  = carmel_20k_buf[1] == 'F';
+        mc->answered = carmel_20k_buf[3] == 'A';
+        mc->deleted  = carmel_20k_buf[4] == 'D';
+        mc->seen     = carmel_20k_buf[5] == 'S';
+        mc->recent   = 0;
+
+        /*---- Get the rest of the other interesting entries -----*/
+        found = 0;
+        while(fgets(carmel_20k_buf,sizeof(carmel_20k_buf),
+                    LOCAL->index_stream) != NULL &&
+              found < 3 &&
+              strncmp(carmel_20k_buf, carmel2_s_o_m, carmel2_s_o_m_len))
+          if (*carmel_20k_buf == 'Z') {
+              mc->rfc822_size = atol(carmel_20k_buf+1);
+              found++;
+          } else if(*carmel_20k_buf == 'D') {
+              carmel2_parse_date(mc, carmel_20k_buf+1);
+              found++;
+          } else if(*carmel_20k_buf == 'P') {
+              mc->data2 = atoi(carmel_20k_buf+1);
+              found++;
+          }
+
+        /*-------- Now find the next index entry ---------*/
+        last_line_read = ftell(LOCAL->index_stream);
+        file_pos += next;
+        fseek(LOCAL->index_stream, file_pos, 0); /* try the offset first */
+        if(fgets(carmel_20k_buf, sizeof(carmel_20k_buf),
+                 LOCAL->index_stream) == NULL) 
+           break;
+        if(strncmp(carmel_20k_buf, carmel2_s_o_m, carmel2_s_o_m_len) != 0){
+            /*-- Didn't match what was seeked to, back off and read lines --*/ 
+            fseek(LOCAL->index_stream, last_line_read, 0);
+            do {
+                file_pos = ftell(LOCAL->index_stream);
+                if(fgets(carmel_20k_buf, sizeof(carmel_20k_buf),
+                         LOCAL->index_stream) == NULL)
+                  goto done_reading;
+            }while(strncmp(carmel_20k_buf,carmel2_s_o_m,carmel2_s_o_m_len)!=0);
+        }
+    }
+  done_reading:
+    if(stream->nmsgs != nmsgs) {
+        stream->nmsgs = nmsgs;
+        mm_exists(stream, nmsgs);
+    }
+    return(0);
+
+  bomb:
+   return(-1);
+}
+
+
+
+/* This killer macro is from bezerk.h. It's only needed at sites that don't
+ * escape "From " lines with ">From " unless absolutely necessary (The UW).
+ */
+
+/* Validate line known to start with ``F''
+ * Accepts: pointer to candidate string to validate as a From header
+ *          return pointer to end of date/time field
+ *          return pointer to offset from t of time (hours of ``mmm dd hh:mm'')
+ *          return pointer to offset from t of time zone (if non-zero)
+ * Returns: T if valid From string, t,ti,zn set; else NIL
+ */
+
+#define VALID(s,x,ti,zn) \
+  (s[1] == 'r') && (s[2] == 'o') && (s[3] == 'm') && (s[4] == ' ') && \
+  (x = strchr (s+5,'\n')) && \
+  ((x-s < 41) || ((ti = ((x[-2] == ' ') ? -14 : (x[-3] == ' ') ? -15 : \
+                         (x[-4] == ' ') ? -16 : (x[-5] == ' ') ? -17 : \
+                         (x[-6] == ' ') ? -18 : (x[-7] == ' ') ? -19 : \
+                         (x[-8] == ' ') ? -20 : (x[-9] == ' ') ? -21 : \
+                         (x[-10]== ' ') ? -22 : (x[-11]== ' ') ? -23 : 0)) && \
+                  (x[ti]   == ' ') && (x[ti+1] == 'r') && (x[ti+2] == 'e') && \
+                  (x[ti+3] == 'm') && (x[ti+4] == 'o') && (x[ti+5] == 't') && \
+                  (x[ti+6] == 'e') && (x[ti+7] == ' ') && (x[ti+8] == 'f') && \
+                  (x[ti+9] == 'r') && (x[ti+10]== 'o') && (x[ti+11]== 'm') && \
+                  (x += ti)) || T) && \
+  (x-s >= 27) && \
+  ((x[ti = -5] == ' ') ? ((x[-8] == ':') ? !(zn = 0) : \
+                          ((x[ti = zn = -9] == ' ') || \
+                           ((x[ti = zn = -11] == ' ') && \
+                            ((x[-10] == '+') || (x[-10] == '-'))))) : \
+   ((x[zn = -4] == ' ') ? (x[ti = -9] == ' ') : \
+    ((x[zn = -6] == ' ') && ((x[-5] == '+') || (x[-5] == '-')) && \
+     (x[ti = -11] == ' ')))) && \
+  (x[ti - 3] == ':') && (x[ti -= ((x[ti - 6] == ':') ? 9 : 6)] == ' ') && \
+  (x[ti - 3] == ' ') && (x[ti - 7] == ' ') && (x[ti - 11] == ' ')
+
+
+/* You are not expected to understand this macro, but read the next page if
+ * you are not faint of heart.
+ *
+ * Known formats to the VALID macro are:
+ *              From user Wed Dec  2 05:53 1992
+ * BSD          From user Wed Dec  2 05:53:22 1992
+ * SysV         From user Wed Dec  2 05:53 PST 1992
+ * rn           From user Wed Dec  2 05:53:22 PST 1992
+ *              From user Wed Dec  2 05:53 -0700 1992
+ *              From user Wed Dec  2 05:53:22 -0700 1992
+ *              From user Wed Dec  2 05:53 1992 PST
+ *              From user Wed Dec  2 05:53:22 1992 PST
+ *              From user Wed Dec  2 05:53 1992 -0700
+ * Solaris      From user Wed Dec  2 05:53:22 1992 -0700
+ *
+ * Plus all of the above with `` remote from xxx'' after it. Thank you very
+ * much, smail and Solaris, for making my life considerably more complicated.
+ */
+
+/*
+ * What?  You want to understand the VALID macro anyway?  Alright, since you
+ * insist.  Actually, it isn't really all that difficult, provided that you
+ * take it step by step.
+ *
+ * Line 1       Validates that the 2-5th characters are ``rom ''.
+ * Line 2       Sets x to point to the end of the line.
+ * Lines 3-12   First checks to see if the line is at least 41 characters long.
+ *              If so, it scans backwards up to 10 characters (the UUCP system
+ *              name length limit due to old versions of UNIX) to find a space.
+ *              If one is found, it backs up 12 characters from that point, and
+ *              sees if the string from there is `` remote from''.  If so, it
+ *              sets x to that position.  The ``|| T'' is there so the parse
+ *              will still continue.
+ * Line 13      Makes sure that there are at least 27 characters in the line.
+ * Lines 14-17  Checks if the date/time ends with the year.  If so, It sees if
+ *              there is a colon 3 characters further back; this would mean
+ *              that there is no timezone field and zn is set to 0 and ti is
+ *              left in front of the year.  If not, then it expects there to
+ *              either to be a space four characters back for a three-letter
+ *              timezone, or a space six characters back followed by a + or -
+ *              for a numeric timezone.  If a timezone is found, both zn and
+ *              ti are the offset of the space immediately before it.
+ * Lines 18-20  Are the failure case for a date/time not ending with a year in
+ *              line 14.  If there is a space four characters back, it is a
+ *              three-letter timezone; there must be a space for the year nine
+ *              characters back.  Otherwise, there must be a space six
+ *              characters back and a + or - five characters back to indicate a
+ *              numeric timezone and a space eleven characters back to indicate
+ *              a year.  zn and ti are set appropriately.
+ * Line 21      Make sure that the string before ti is of the form hh:mm or
+ *              hh:mm:ss.  There must be a colon three characters back, and a
+ *              space six or nine characters back (depending upon whether or
+ *              not the character six characters back is a colon).  ti is set
+ *              to be the offset of the space immediately before the time.
+ * Line 22      Make sure the string before ti is of the form www mmm dd.
+ *              There must be a space three characters back (in front of the
+ *              day), one seven characters back (in front of the month), and
+ *              one eleven characters back (in front of the day of week).
+ *
+ * Why a macro?  It gets invoked a *lot* in a tight loop.  On some of the
+ * newer pipelined machines it is faster being open-coded than it would be if
+ * subroutines are called.
+ *
+ * Why does it scan backwards from the end of the line, instead of doing the
+ * much easier forward scan?  There is no deterministic way to parse the
+ * ``user'' field, because it may contain unquoted spaces!  Yes, I tested it to
+ * see if unquoted spaces were possible.  They are, and I've encountered enough
+ * evil mail to be totally unwilling to trust that ``it will never happen''.
+ */
+
+
+/*----------------------------------------------------------------------
+    Get the new mail out of the spooled mail file
+  
+ Args: stream  -- The inbox stream to add mail too
+       spool   -- The path name of the spool file
+       mailbox -- Name user sees for this, used only for error reporting
+
+ Result:
+
+ - Lock the spool mail file with bezerk_lock
+ - Get the carmel2 index open and remember where we started in it
+ - Make buffer big enough for biggest header we'll mess with
+ - Loop reading all the message out of the spool file:
+   - Get a new data file for the message and open it
+   - Read the header of the message into the big buffer while...
+    - writing the message into the new data file
+   - finish writing the text of the message into the data file
+   - If all went well bump the message count and say it exists
+   - Parse the header of the message to get an envelope, date and size
+   - Write an entry into the carmel2 index
+ - Unlink and create (to zero) the spool file and unlock it
+
+The carmel inbox should be locked when this is called and mm_critical
+should be called around this function.
+ ----*/
+void
+carmel2_spool_mail(stream, spool, mailbox, clear_spool_file) 
+     MAILSTREAM *stream;
+     char       *spool, *mailbox;
+     int         clear_spool_file;
+{
+    char         *p, *eof, *from_p;
+    int           n, size, fd, in_header, from_i1, from_i2;
+    long          file_pos, index_file_pos, byte_count, start_of_append;
+    FILE         *spool_stream, *data_stream;
+    ENVELOPE     *envelope;
+    BODY         *b;
+    MESSAGECACHE *mc;
+    STRING        string_struct;
+#ifdef BWC
+    int           is_wide;
+#endif    
+
+    /*--- Get the locks set and files open-----*/
+    fd = carmel2_bezerk_lock(spool, mailbox);
+    if(fd < 0) {
+        return;
+    }
+    spool_stream = fdopen(fd, "r");
+    fseek(LOCAL->index_stream, 0L, 2);
+    start_of_append = ftell(LOCAL->index_stream);
+
+    /*--- Make buffer big enough for largest allowable header ----*/
+    if(LOCAL->msg_buf_size < CARMEL_MAX_HEADER) {
+        if(LOCAL->msg_buf != NULL)
+          fs_give((void **)&(LOCAL->msg_buf));
+        LOCAL->msg_buf_size = CARMEL_MAX_HEADER;
+        LOCAL->msg_buf = fs_get(CARMEL_MAX_HEADER);
+    }
+    LOCAL->buffered_header_and_text = 0;
+    LOCAL->msg_buf_text_offset      = 0L;
+    if(LOCAL->buffered_file != NULL)
+      fs_give((void **)&(LOCAL->buffered_file));
+
+
+    /*---- Read (and ignore) the first line with the "From " in it ----*/
+    eof = fgets(carmel_20k_buf, sizeof(carmel_20k_buf), spool_stream); 
+
+    /*----- Loop getting messages ----*/
+    while(eof != NULL) {
+
+        /*----- get a data file for the new message ----*/
+        n = carmel2_new_data_file(stream->local, stream->mailbox);
+        data_stream = fopen((*LOCAL->calc_paths)(CalcPathCarmel2Data,
+                                                 stream->mailbox, n),"w");
+        if(data_stream == NULL)
+          goto backout;
+        file_pos  = ftell(spool_stream);
+        p         = LOCAL->msg_buf;
+        in_header = 1;
+        byte_count = 0L;
+#ifdef BWC
+        is_wide = 0;
+#endif
+        
+
+        /*--------------------------------------------------------------------
+            Read the message in line by line, writing it out to the
+            new data file. Also acculamuate a copy of the header in
+            a buffer for parsing
+          ---*/
+        eof = fgets(carmel_20k_buf, sizeof(carmel_20k_buf), spool_stream);
+        while(eof != NULL){
+            if(VALID(carmel_20k_buf, from_p, from_i1, from_i2))
+              break;
+    
+            if(in_header) {
+#ifdef BWC
+                is_wide |= carmel_match_glyph_wide(carmel_20k_buf);
+#endif
+                if(*carmel_20k_buf == '\n') {
+                    /* Encountered first blank line, end of header */
+                    in_header = 0;
+                    *p = '\0';
+                } else {
+                    if(p - LOCAL->msg_buf + strlen(carmel_20k_buf) >
+                       LOCAL->msg_buf_size){
+                        /* out of room in buffer, end it */
+                        in_header = 0;
+                        *p = '\0';
+                    } else {
+                        strcpy(p, carmel_20k_buf);
+                        p +=strlen(p);
+                    }
+                }
+            }
+
+            /*----- Write the message into the file -----*/
+            byte_count += strlen(carmel_20k_buf);
+            if(carmel_20k_buf[0] == '>' && carmel_20k_buf[1] == 'F' &&
+               carmel_20k_buf[2] == 'r' && carmel_20k_buf[3] == 'o' &&
+               carmel_20k_buf[4] == 'm' && carmel_20k_buf[5] == ' ')  {
+                if(fputs(carmel_20k_buf + 1, data_stream) == EOF)
+                  goto backout;
+                byte_count -= 1;
+            } else {
+                if(fputs(carmel_20k_buf, data_stream) == EOF)
+                  goto backout;
+            }
+            eof = fgets(carmel_20k_buf, sizeof(carmel_20k_buf), spool_stream);
+        }
+        fclose(data_stream);
+#ifdef BWC
+        if(is_wide) {
+            sprintf(carmel_path_buf, "%s.wid",
+                    (*LOCAL->calc_paths)(CalcPathCarmel2Data,stream->mailbox,n)
+                    );
+            rename((*LOCAL->calc_paths)(CalcPathCarmel2Data,stream->mailbox,n),
+                   carmel_path_buf);
+        }
+#endif
+
+        /*---- get a new MESSAGECACHE to store it in -----*/
+        mc = carmel2_new_mc(stream, stream->nmsgs + 1);
+
+        /*------ Parse the message header ------*/
+        INIT(&string_struct, mail_string, (void *)"", 0);
+        rfc822_parse_msg(&envelope, &b, LOCAL->msg_buf, strlen(LOCAL->msg_buf),
+                         &string_struct, mylocalhost(), carmel_20k_buf);
+        carmel2_parse_bezerk_status(mc, LOCAL->msg_buf);
+        carmel2_rfc822_date(mc, LOCAL->msg_buf);
+        mc->rfc822_size = byte_count; 
+        mc->data2 = n;
+        mc->data1 = ftell(LOCAL->index_stream);
+        mc->recent = 1;
+
+        /*----- Now add the message to the Carmel2 index ------*/
+        if(carmel2_write_index(envelope, mc, LOCAL->index_stream) < 0)
+          goto backout;
+
+        /*----- Write message into auxiliary index (plain carmel) ----*/
+        if(LOCAL->carmel && LOCAL->aux_copy != NULL) {
+            if((*LOCAL->aux_copy)(stream->local, mailbox, envelope, mc)) {
+                /* BUG - this error may leave things half done, but will
+                   only result in duplicated mail */
+                goto backout; 
+            }
+        }
+
+        /*---- All went well, let the user know -----*/
+        stream->nmsgs++;
+        mm_exists(stream, stream->nmsgs);
+
+        mail_free_envelope(&envelope);
+    }
+
+    fflush(LOCAL->index_stream); /* Force new index entries onto disk */
+    fclose(spool_stream);
+    if(clear_spool_file) {
+        unlink(spool);
+        close(creat(spool, 0600));
+    }
+    carmel2_bezerk_unlock(fd, spool);
+    return;
+
+  backout:
+    sprintf(carmel_error_buf, "Error incorporating new mail into \"%s\": %s",
+            carmel_parse_mb_name(mailbox,'\0')->mailbox, strerror(errno));
+    /* bug in above call to parse_mb -- should have version passed in */
+    mm_log(carmel_error_buf, ERROR);
+    fflush(LOCAL->index_stream);
+    ftruncate(fileno(LOCAL->index_stream), start_of_append);
+    carmel2_bezerk_unlock(fd, spool);
+}
+
+
+
+/*----------------------------------------------------------------------
+   Copy the actual data file when copying a message
+
+Returns: -1 for failure
+            otherwise the number of the new file, 
+
+  ----*/        
+static  
+carmel2_copy_msg_file(stream, orig_file_number, new_mailbox)
+     MAILSTREAM *stream;
+     int         orig_file_number;
+     char       *new_mailbox;
+{
+    char *file_name;
+    int   wide, e, new_file_num, n, orig_fd, new_fd;
+
+    /*---- Open the orginal file ----*/
+    wide = 0;
+    file_name = (*LOCAL->calc_paths)(CalcPathCarmel2Data,
+                                     new_mailbox,orig_file_number);
+    if(file_name == NULL)
+      return(-1);
+
+    orig_fd = open(file_name, O_RDONLY);
+    if(orig_fd < 0 && LOCAL->carmel) {
+        strcat(file_name, ".wid");
+        orig_fd = open(file_name, O_RDONLY);
+        if(orig_fd < 0)
+          goto bomb;
+        wide = 1;
+    } else {
+        goto bomb;
+    }
+
+    /*----- Open and create the new file ------*/
+    new_file_num = carmel2_new_data_file(stream->local, new_mailbox);
+    if(new_file_num < 0)
+      goto bomb;
+    file_name = (*LOCAL->calc_paths)(CalcPathCarmel2Data,
+                                     new_mailbox, new_file_num);
+    if(wide)
+      strcat(file_name, ".wid");
+    new_fd = open(file_name, O_WRONLY | O_CREAT, 0600);
+    if(new_fd < 0) {
+        goto bomb;
+    }
+
+    /*---- Copy the bits ------*/
+    e = 0;
+    while((n = read(orig_fd, carmel_20k_buf, sizeof(carmel_20k_buf))) >0) {
+        if(write(new_fd, carmel_20k_buf, n) < 0) {
+            e = errno;
+            break;
+        }
+    }
+
+    /*---- Close the streams and handle any errors ----*/
+    close(orig_fd);
+    close(new_fd);
+
+    if(e == 0)
+      return(new_file_num);  /* All is OK */
+    
+    /*--- something didn't go right ---*/
+  bomb:
+    unlink(file_name);
+    sprintf(carmel_error_buf, "Error copying message to %s: %s",
+            new_mailbox, strerror(errno));
+    mm_log(carmel_error_buf, ERROR);
+    return(-1);
+}
+
+
+
+
+
+
+/*----------------------------------------------------------------------
+       Locking for Carmel and Pod formats
+
+Args: stream --  Mail stream we're operating on
+      file   --  Mail file name
+      write  --  Flag indicating we want write access
+
+Retuns: -1 if lock fails, 0 if it succeeds
+
+- There are two locks. Plain locks and write locks. They are created
+  about the same way, but have different names. The time out on the write
+  locks is much shorter, because it should never be held for very long.
+
+- Hitching (links in file system) post locking is used so it will work
+  across NFS. Flock() could be used as it has two advantages. First it
+  is more efficient, second the locks will disolve automatically when the 
+  process dies. The efficiency is not of great concern, and the
+  process should not (theoretically) die unless it crashes due to a bug
+  or it is abnormally terminated. The advantage of locking across NFS
+  is considered greater than the advantages of flock().
+
+- The mod time of the lock file is updated everytime mail_check()
+  or mail_ping() is called and the mod time on the lock file is recorded.
+  This is so it can be determined that the lock file is current.
+
+- When a read lock file over 30 or a write lock over 5 minutes old is
+  encountered it is assumed the lock is old and should be overridden
+  (because the process crashed or was killed). 
+
+- Everytime the mod time on the lock file is updated (on calls to
+  mail_check() and mail_ping()), the mod time of the lock file is
+  checked against the record of what it was last set to. If the mod times 
+  don't match the lock has been broken and overridden. Then the original
+  Pine should go into read-only mode.... This is only likely to happen if
+  someone suspends (^Z's) the process for more than 30 minutes, and another
+  process is started.
+  ----*/
+int
+carmel2_lock(local, file, write)
+     CARMEL2LOCAL *local;
+     char         *file;
+     int           write;
+{
+    char        *hitch, lock[CARMEL_PATHBUF_SIZE], error_mess[200], *l_path;
+    struct stat sb;
+    int         n, link_result, hitch_fd, timer_set, l;
+    long        override, timer;
+
+    /* Set the length of time for override. It is 5 minutes for a 
+       write lock (no process should have it for that long) and
+       30 minutes for a read lock, that's 30 minutes since the
+       lock file was last touched. */
+    override = 60 * (write ? 5 : 30);
+    timer    = -1;
+
+    /*----- Get the lock file and hitch names -----*/
+    l_path = (*local->calc_paths)(write ? CalcPathCarmel2WriteLock:
+                                              CalcPathCarmel2ReadLock,
+                                      file, 0);
+    if(l_path == NULL)
+      return(-1);
+    strcpy(lock, l_path);
+    /* copy lock file into bufferl call it hitch, unique thing added below */
+    hitch = carmel_path_buf;
+    hitch = strcpy(hitch, lock);
+    l = strlen(hitch);
+    
+    do {
+        /*--- First create hitching post ----*/
+        for(n = time(0) % 6400; ; n += 10007) {
+            /* Get random file name, that's not too long */
+            sprintf(hitch + l, "_%c%c", '0' + (n % 80) , '0' + (n/80));
+            if(stat(hitch, &sb) < 0)
+              break; /* Got a name that doesn't exist */
+        }
+        hitch_fd = open(hitch, O_CREAT, 0666);
+        if(hitch_fd < 0) {
+            sprintf(error_mess, "Error creating lock file \"%s\": %s",
+                    hitch, strerror(errno));
+            mm_log(error_mess, WARN);
+            return(-1);
+        }
+        close(hitch_fd);
+    
+        /*----- Got a hitching post, now try link -----*/
+        link_result = link(hitch, lock);
+        stat(lock, &sb);
+        unlink(hitch);
+        if(link_result == 0 && sb.st_nlink == 2) {
+            /*------ Got the lock! ------*/
+            stat(lock, &sb);
+            if(write)
+              local->write_lock_mod_time = sb.st_mtime;
+            else
+              local->read_lock_mod_time = sb.st_mtime;
+            return(0);
+        }
+
+        /*----- Check and override if lock is too old -----*/
+        if(sb.st_mtime + override < time(0)) {
+            unlink(lock); /* Lock is old, override it */
+            timer = 100; /* Get us around the loop again */
+            continue;
+        } else {
+            if(timer < 0) /* timer not set */
+              timer = sb.st_mtime + override - time(0);
+        }
+
+        /*----- Will user wait till time for override? -----*/
+        if(!write || timer > 5 * 60) {
+            return(-1); /* Not more that 5 minutes */
+        }
+
+        /*----- Try again, and tell user we're trying -------*/
+        if(!(timer % 15)) {
+            sprintf(error_mess,
+                    "Please wait. Mailbox %s is locked for %d more seconds",
+                    file, timer);
+            mm_log(error_mess, WARN);
+        }
+        timer--;
+        sleep(1);
+    } while(timer > 0);
+
+    return(-1);
+}
+
+
+
+/*----------------------------------------------------------------------
+   Unlock a carmel mail stream
+
+Args: stream -- The mailstream that is locked
+      mailbox -- FQN of mailbox to lock ( e.g. #carmel#foo )
+      write   -- flag to set if it is a write lock
+
+Nothing is returned
+  ----*/
+void
+carmel2_unlock(local, mailbox, write)
+     CARMEL2LOCAL *local;
+     char         *mailbox;
+     int           write;
+{
+    char        lock[CARMEL_PATHBUF_SIZE];
+    struct stat sb;
+
+    strcpy(lock, (*local->calc_paths)(write ? CalcPathCarmel2WriteLock:
+                                              CalcPathCarmel2ReadLock,
+                                      mailbox, 0));
+
+    if(stat(lock, &sb) < 0)
+      return; /* Hmmm... lock already broken */
+
+    if(sb.st_mtime !=
+       (write ? local->write_lock_mod_time : local->read_lock_mod_time))
+      return; /* Hmmm... not our lock */
+    
+    unlink(lock);
+}
+
+    
+    
+/*----------------------------------------------------------------------
+    Keep the mod date on the lock file fresh 
+
+Args: stream --
+      file   -- the name of the mailbox the lock is for
+      write  -- set if this is a write lock
+
+Returns: 0 if update was OK
+        -1 if something bad happened, like the lock was stolen
+ ----*/
+static int 
+carmel2_update_lock(local, file, write)
+     CARMEL2LOCAL *local;
+     char         *file;
+     int           write;
+{
+    char        lock[CARMEL_PATHBUF_SIZE];
+    struct      timeval tp[2];
+    struct stat sb;
+
+    strcpy(lock, (*local->calc_paths)(write ? CalcPathCarmel2WriteLock:
+                                              CalcPathCarmel2ReadLock,
+                                      file, 0));
+
+    if(stat(lock, &sb) < 0) {
+        /* Lock file stolen, oh oh */
+        return(-1);
+    }
+
+    if(sb.st_mtime !=
+       (write ? local->write_lock_mod_time : local->read_lock_mod_time)) {
+        /* Not our lock anymore , oh oh */
+        return(-1);
+    }
+
+    gettimeofday (&tp[0],NIL);  /* set atime to now */
+    gettimeofday (&tp[1],NIL);  /* set mtime to now */
+    utimes(lock, tp);
+
+    if(write)
+      local->write_lock_mod_time = tp[1].tv_sec;
+    else
+      local->read_lock_mod_time = tp[1].tv_sec;
+    return(0);
+}
+
+
+
+/*----------------------------------------------------------------------
+   Berkeley open and lock mailbox
+
+This is mostly ripped off from the Bezerk driver
+ ----*/
+
+static int 
+carmel2_bezerk_lock (spool, file)
+        char *spool, *file;
+{
+  int fd,ld,j;
+  int i = BEZERKLOCKTIMEOUT * 60 - 1;
+  struct timeval tp;
+  struct stat sb;
+  char *hitch, *lock;
+
+  lock = carmel_path_buf;
+  sprintf(lock, "%s.lock", spool);
+  do {                          /* until OK or out of tries */
+    gettimeofday (&tp,NIL);     /* get the time now */
+#ifdef NFSKLUDGE
+  /* SUN-OS had an NFS, As kludgy as an albatross;
+   * And everywhere that it was installed, It was a total loss.  -- MRC 9/25/91
+   */
+                                /* build hitching post file name */
+    hitch = carmel_20k_buf;
+    sprintf(hitch, "%s.%d.%d.",carmel_path_buf,time (0),getpid ());
+    j = strlen (hitch); /* append local host name */
+    gethostname (hitch + j,(MAILTMPLEN - j) - 1);
+                                /* try to get hitching-post file */
+    if ((ld = open (hitch, O_WRONLY|O_CREAT|O_EXCL,0666)) < 0) {
+                                /* prot fail & non-ex, don't use lock files */
+      if ((errno == EACCES) && (stat (hitch, &sb))) *lock = '\0';
+      else {                    /* otherwise something strange is going on */
+        sprintf (carmel_20k_buf,"Error creating %s: %s",lock,strerror (errno));
+        mm_log (carmel_20k_buf, WARN);  /* this is probably not good */
+                                /* don't use lock files if not one of these */
+        if ((errno != EEXIST) && (errno != EACCES)) *lock = '\0';
+      }
+    }
+    else {                      /* got a hitching-post */
+      chmod (hitch,0666);       /* make sure others can break the lock */
+      close (ld);               /* close the hitching-post */
+      link (hitch,lock);        /* tie hitching-post to lock, ignore failure */
+      stat (hitch, &sb);        /* get its data */
+      unlink (hitch);           /* flush hitching post */
+      /* If link count .ne. 2, hitch failed.  Set ld to -1 as if open() failed
+         so we try again.  If extant lock file and time now is .gt. file time
+         plus timeout interval, flush the lock so can win next time around. */
+      if ((ld = (sb.st_nlink != 2) ? -1 : 0) && (!stat (lock,&sb)) &&
+          (tp.tv_sec > sb.st_ctime + BEZERKLOCKTIMEOUT * 60)) unlink (lock);
+    }
+
+#else
+  /* This works on modern Unix systems which are not afflicted with NFS mail.
+   * "Modern" means that O_EXCL works.  I think that NFS mail is a terrible
+   * idea -- that's what IMAP is for -- but some people insist upon losing...
+   */
+                                /* try to get the lock */
+    if ((ld = open (lock,O_WRONLY|O_CREAT|O_EXCL,0666)) < 0) switch (errno) {
+    case EEXIST:                /* if extant and old, grab it for ourselves */
+      if ((!stat (lock,&sb)) && tp.tv_sec > sb.st_ctime + LOCKTIMEOUT * 60)
+        ld = open (lock,O_WRONLY|O_CREAT,0666);
+      break;
+    case EACCES:                /* protection fail, ignore if non-ex or old */
+      if (stat (lock,&sb) || (tp.tv_sec > sb.st_ctime + LOCKTIMEOUT * 60))
+        *lock = '\0';           /* assume no world write mail spool dir */
+      break;
+    default:                    /* some other failure */
+      sprintf (tmp,"Error creating %s: %s",lock,strerror (errno));
+      mm_log (tmp,WARN);        /* this is probably not good */
+      *lock = '\0';             /* don't use lock files */
+      break;
+    }
+    if (ld >= 0) {              /* if made a lock file */
+      chmod (tmp,0666);         /* make sure others can break the lock */
+      close (ld);               /* close the lock file */
+    }
+#endif
+    if ((ld < 0) && *lock) {    /* if failed to make lock file and retry OK */
+      if (!(i%15)) {
+        sprintf (carmel_20k_buf,"Mailbox %s is locked, will override in %d seconds...",
+                 file,i);
+        mm_log (carmel_20k_buf, WARN);
+      }
+      sleep (1);                /* wait 1 second before next try */
+    }
+  } while (i-- && ld < 0 && *lock);
+                                /* open file */
+  if ((fd = open (spool, O_RDONLY)) >= 0) flock (fd, LOCK_SH);
+  else {                        /* open failed */
+    j = errno;                  /* preserve error code */
+    if (*lock) unlink (lock);   /* flush the lock file if any */
+    errno = j;                  /* restore error code */
+  }
+  return(fd);
+}
+
+
+
+/*----------------------------------------------------------------------
+   Berkeley unlock and close mailbox
+ ----*/
+static void 
+carmel2_bezerk_unlock (fd, spool)
+        int fd;
+        char *spool;
+{
+    sprintf(carmel_path_buf, "%s.lock", spool);
+    
+    flock (fd, LOCK_UN);          /* release flock'ers */
+    close (fd);                   /* close the file */
+                                  /* flush the lock file if any */
+    if (*carmel_path_buf) unlink (carmel_path_buf);
+}
+
+
+
+/*----------------------------------------------------------------------
+    Make sure directory exists and is writable
+
+Args: dir  - directory to check, should be full path
+      
+Result: returns -1 if not OK along with mm_logging a message
+                 0 if OK
+----*/
+
+carmel2_check_dir(dir)
+     char *dir;
+{
+    struct stat sb;
+    char   error_mess[150];
+
+    if(stat(dir, &sb) < 0) {
+        if(mkdir(dir, 0700) < 0) {
+            sprintf(error_mess, "Error creating directory %-.30s %s",
+                    dir, strerror(errno));
+            mm_log(error_mess, WARN);
+            return(-1);
+        }
+    } else if(!(sb.st_mode & S_IFDIR)) {
+        sprintf(error_mess, "Warning: %s is not a directory",dir);
+        mm_log(error_mess, WARN);
+        return(-1);
+
+    } else if(access(dir, W_OK) != 0) {
+        sprintf(error_mess, "Warning: unable to write to %-.30s %s",
+                dir, strerror(errno));
+        mm_log(error_mess, WARN);
+        return(-1);
+    }
+    return(0);
+}
+
+    
+    
+/*----------------------------------------------------------------------
+    Return the number for the next message file
+
+Args: stream  -- the Mail stream for the new data file
+      mailbox -- The FQN of mailbox data file is for
+
+Returns: file number or -1
+  ----*/
+static 
+carmel2_new_data_file(local, mailbox)
+     CARMEL2LOCAL *local;
+     char         *mailbox;
+{
+    char *path, num_buf[50], e_buf[100];
+    int   fd, num, bytes_read;
+
+    /*---- Get the full path of the .MAXNAME file for index ----*/
+    path = (*local->calc_paths)(CalcPathCarmel2MAXNAME, mailbox, 0);
+    if(path == NULL)
+      return(-1);
+
+    fd = open(path, O_RDWR|O_CREAT, 0666);
+    if(fd < 0) {
+        sprintf(e_buf, "Error getting next number of mail file: %s",
+                strerror(errno));
+        mm_log(e_buf, ERROR);
+        return(-1);
+    }
+
+    bytes_read = read(fd, num_buf, sizeof(num_buf));
+    if(bytes_read < 6) {
+        num  = 100000;
+    } else {
+        num = atoi(num_buf) + 1;
+        if(num >= 999999)
+          num = 100000;
+    }
+    sprintf(num_buf, "%-6d\n", num);
+    lseek(fd, 0, 0);
+    write(fd, num_buf, strlen(num_buf));
+    close(fd);
+    return(num);
+}
+
+
+
+/*----------------------------------------------------------------------
+   Do all the file name generation for carmel2 driver
+
+   The mailbox passed in is in either the format: #carmel2#folder or
+                                                  #carmel2#user%folder
+This generates that absolute paths for an index, or a data file or
+the .MAXNAME file.
+
+Bug: This is untested!
+  ----*/
+static char *
+carmel2_calc_paths(operation, mailbox, data_file_num)
+     int         operation;
+     char       *mailbox;
+     int         data_file_num;
+{
+    static char            path[CARMEL_PATHBUF_SIZE], num[20];
+    char                  *p, *home_dir;
+    struct carmel_mb_name *parsed_name;
+    struct passwd         *pw;
+
+    parsed_name = carmel_parse_mb_name(mailbox,'2');
+
+    if(parsed_name == NULL) {
+        mm_log("Internal error (bug). Invalid Carmel folder name",ERROR);
+        return(NULL);
+    }
+    
+
+    if(parsed_name->user != NULL) {
+        /*---- has a user in mailbox name -----*/
+        pw = getpwnam(parsed_name->user);
+        if(pw == NULL) {
+            sprintf(carmel_error_buf,
+                  "Error accessing mailbox \"%s\". No such user name \"%s\"\n",
+                    mailbox, parsed_name->user);
+            mm_log(carmel_error_buf, ERROR);
+            carmel_free_mb_name(parsed_name);
+            return(0);
+        }
+        home_dir = pw->pw_dir;
+    } else {
+        home_dir = myhomedir();
+    }
+    mailbox  = parsed_name->mailbox;
+
+    switch(operation) {
+
+      case CalcPathCarmel2Data:
+        sprintf(path, "%s/%s/%d", home_dir, CARMEL2_MSG_DIR, data_file_num);
+        
+
+      case CalcPathCarmel2Index:
+        sprintf(path, "%s/%s/%s", home_dir, CARMEL2_INDEX_DIR, mailbox);
+        break;
+
+      case CalcPathCarmel2MAXNAME:
+        sprintf(path, "%s/%s", home_dir, CARMEL2_MAXFILE);
+        break;
+
+      case CalcPathCarmel2WriteLock:
+        sprintf(path, "%s/%s/.%s.wl", home_dir, CARMEL2_INDEX_DIR, mailbox);
+        break;
+
+      case CalcPathCarmel2ReadLock:
+        sprintf(path, "%s/%s/.%s.rl", home_dir, CARMEL2_INDEX_DIR, mailbox);
+        break;
+    }
+
+    carmel_free_mb_name(parsed_name);
+    return(path);
+}
+
+
+
+/*----------------------------------------------------------------------
+   Find and parse the status line in a mail header
+
+Args:  mc     -- the message cache where status is to be stored
+       header -- the message header to parsen
+ ----*/
+void
+carmel2_parse_bezerk_status(mc, header)
+     MESSAGECACHE *mc;
+     char *header;
+{
+    register char *p;
+    for(p = header; *p; p++) {
+        if(*p != '\n')
+          continue;
+        p++;
+        if(*p != 'S' && *p != 'X')
+          continue;
+        if(strncmp(p, "Status: ",  8) == 0 || strncmp(p,"X-Status: ",10)== 0) {
+            mc->recent = 1;
+            for(p += *p == 'X' ? 10: 8; *p && *p != '\n'; p++)
+              switch(*p) {
+                case 'R': mc->seen    = 1; break;
+                case 'O': mc->recent  = 0; break;
+                case 'D': mc->deleted = 1; break;
+                case 'F': mc->flagged = 1; break;
+                case 'A': mc->flagged = 1; break;
+              }
+        }
+    }
+}
+        
+
+
+/*----------------------------------------------------------------------
+  Turn a string of describing flags into a bit mask
+
+Args:  stream -- mail stream, unused
+       flag   -- string flag list
+
+Returns:  returns short with bits set; bits are defined in carmel2.h
+ ----*/
+static short
+carmel2_getflags (stream, flag)
+        MAILSTREAM *stream;
+        char *flag;
+{
+  char *t, tmp[100];
+  short f = 0;
+  short i,j;
+  if (flag && *flag) {          /* no-op if no flag string */
+                                /* check if a list and make sure valid */
+    if ((i = (*flag == '(')) ^ (flag[strlen (flag)-1] == ')')) {
+      mm_log ("Bad flag list",ERROR);
+      return NIL;
+    }
+                                /* copy the flag string w/o list construct */
+    strncpy (tmp,flag+i,(j = strlen (flag) - (2*i)));
+    tmp[j] = '\0';
+    t = ucase (tmp);    /* uppercase only from now on */
+
+    while (*t) {                /* parse the flags */
+      if (*t == '\\') {         /* system flag? */
+        switch (*++t) {         /* dispatch based on first character */
+        case 'S':               /* possible \Seen flag */
+          if (t[1] == 'E' && t[2] == 'E' && t[3] == 'N') i = fSEEN;
+          t += 4;               /* skip past flag name */
+          break;
+        case 'D':               /* possible \Deleted flag */
+          if (t[1] == 'E' && t[2] == 'L' && t[3] == 'E' && t[4] == 'T' &&
+              t[5] == 'E' && t[6] == 'D') i = fDELETED;
+          t += 7;               /* skip past flag name */
+          break;
+        case 'F':               /* possible \Flagged flag */
+          if (t[1] == 'L' && t[2] == 'A' && t[3] == 'G' && t[4] == 'G' &&
+              t[5] == 'E' && t[6] == 'D') i = fFLAGGED;
+          t += 7;               /* skip past flag name */
+          break;
+        case 'A':               /* possible \Answered flag */
+          if (t[1] == 'N' && t[2] == 'S' && t[3] == 'W' && t[4] == 'E' &&
+              t[5] == 'R' && t[6] == 'E' && t[7] == 'D') i = fANSWERED;
+          t += 8;               /* skip past flag name */
+          break;
+        case 'R':               /* possible \Answered flag */
+          if (t[1] == 'E' && t[2] == 'C' && t[3] == 'E' && t[4] == 'N' &&
+              t[5] == 'T') i = fRECENT;
+          t += 6;               /* skip past flag name */
+          break;
+        default:                /* unknown */
+          i = 0;
+          break;
+        }
+                                /* add flag to flags list */
+        if (i && ((*t == '\0') || (*t++ == ' '))) f |= i;
+        else {                  /* bitch about bogus flag */
+          mm_log ("Unknown system flag",ERROR);
+          return NIL;
+        }
+      }
+      else {                    /* no user flags yet */
+        mm_log ("Unknown flag",ERROR);
+        return NIL;
+      }
+    }
+  }
+  return f;
+}
+
+
+/*----------------------------------------------------------------------
+   Get a pointer to a MESSAGECACHE entry, allocating if needed
+ 
+Args: stream -- message stream
+      num    -- Message number to allocate on for
+
+Returns: The MESSAGECACHE entry
+
+The message caches are allocated in blocks of 256 to save space taken up by
+pointers in a linked list and allocation overhead. The mc_blocks 
+data structure is an array that points to each block. The macro MC() 
+defined in carmel.h returns a pointer to a MESSAGECACHE given
+a message number. This function here can be called when a MESSAGECACHE
+is needed to a message number that might be new. It allocates a new
+block if needed and clears the MESSAGECACHE returned.
+
+The MESSAGECACHE entries are currently about 28 bytes which implies 28Kb
+must be used per 1000 messages. If memory is limited this driver will be 
+limited in the number of messages it can handle, and the limit is due to
+the fact that these MESSAGECACHEs must be in core.
+
+It might be possible to reduce the size of each entry by a few bytes if
+the message numbers were reduced to a short, and the mostly unused keywords
+were removed. It would also be nice to add a day of the week (3 bits)
+  ----*/
+static MESSAGECACHE *
+carmel2_new_mc(stream, num)
+     MAILSTREAM *stream;
+     int num;
+{
+    MESSAGECACHE *mc;
+      
+    /* Make sure we've got a cache_entry */
+    if(num >= LOCAL->cache_size) {
+        if(LOCAL->mc_blocks == NULL)
+          LOCAL->mc_blocks=(MESSAGECACHE **)fs_get(sizeof(MESSAGECACHE *));
+        else
+          fs_resize((void **)&(LOCAL->mc_blocks), ((num >>8) + 1) *
+                                                  sizeof(MESSAGECACHE *));
+        LOCAL->mc_blocks[num >> 8] = (MESSAGECACHE *)
+          fs_get(256 * sizeof(MESSAGECACHE));
+        LOCAL->cache_size = ((num >> 8) + 1) * 256;
+    }
+    
+    mc = MC(num);
+
+    mc->user_flags = 0;
+    mc->lockcount  = 0;
+    mc->seen       = 0;
+    mc->deleted    = 0;
+    mc->flagged    = 0;
+    mc->answered   = 0;
+    mc->recent     = 0;
+    mc->searched   = 0;
+    mc->sequence   = 0;
+    mc->spare      = 0;
+    mc->spare2     = 0;
+    mc->spare3     = 0;
+    mc->msgno      = num;
+    
+   /* Don't set the date, the size and the extra data,
+      assume they will be set 
+    */
+    return(mc);
+}
+
+
+
+/*----------------------------------------------------------------------
+  Do the real work of appending a message to a mailbox
+ 
+Args: local -- The carmel2 local data structure, (a some what fake incomplete
+               one, set up for the purposes here)
+      mailbox -- Name of mailbox to append to
+      message -- The rfc822 format of the message with \r\n's
+
+Returns: T if all went OK, NIL if it did not
+
+ - Make sure index exists or can be created
+ - lock index for write
+ - get a data file name
+ - Put the text in the file
+ - Parse the string to get envelope and message cache
+ - Write the entry into the index
+ - Unlock the index
+
+BUG: This needs some locking and some error messages
+
+  ----*/
+carmel2_append2(stream, local, mailbox, flags, date, message)
+     char         *mailbox, *flags, *date;
+     CARMEL2LOCAL *local;
+     STRING       *message;
+     MAILSTREAM   *stream;
+{
+    char         *index_name, *data_name, *p, c, *header_string;
+    ENVELOPE     *envelope;
+    BODY         *b;
+    MESSAGECACHE  mc;
+    FILE         *index_file, *data_file;
+    struct stat   sb;
+    int           last_was_crlf, saved_errno;
+    STRING        string_struct;
+    long          size;
+    short         flagbits;
+
+    /*------ Lock the mailbox for write ------*/
+    if(carmel2_lock(local, mailbox, WRITE_LOCK) < 0) {
+        sprintf(carmel_error_buf,
+                "Mailbox \"%s\" is locked. Can't append to it.",
+                mailbox);
+        mm_log(carmel_error_buf, ERROR);
+        return(NIL);
+    }
+
+    /*----- Get the file name of carmel2 index -----*/
+    index_name = (*local->calc_paths)(CalcPathCarmel2Index, mailbox, 0);
+    if(index_name == NULL) {
+        saved_errno = 0;
+        goto bomb;
+    }
+
+    /*------ See if it exists already or not ------*/
+    if(stat(index_name, &sb) < 0) {
+        mm_notify (stream,"[TRYCREATE] Must create mailbox before copy", NIL);
+        carmel2_unlock(local, mailbox, WRITE_LOCK);
+        return(NIL);
+    }
+
+    index_file = fopen(index_name, "a");
+    if(index_file == NULL)
+      goto bomb;
+
+    mc.data2 = carmel2_new_data_file(local, mailbox);
+
+    flagbits = carmel2_getflags(NULL, flags);
+
+    if(flagbits & fSEEN)     mc.seen     = T;
+    if(flagbits & fDELETED)  mc.deleted  = T;
+    if(flagbits & fFLAGGED)  mc.flagged  = T;
+    if(flagbits & fANSWERED) mc.answered = T;
+    if(flagbits & fRECENT)   mc.recent   = T;
+    mc.user_flags  = 0;
+
+    /*----- Open the data file -----*/
+    data_name = (*local->calc_paths)(CalcPathCarmel2Data, mailbox, mc.data2);
+    if(data_name == NULL)  {
+        errno = 0; /* Don't generate an error message at all */
+        goto bomb;
+    }
+    data_file = fopen(data_name, "w");
+    if(data_file == NULL)
+      goto bomb; 
+
+    /*--- accumulate header as we go for later parsing ---*/
+    header_string = carmel_20k_buf;
+
+    /*------ Write the message to the file, and get header in a string -----*/
+    for(size = SIZE(message); size > 0; size--){
+        c = SNX(message);
+        if(c == '\r' && size > 1) {
+            /* Turn CRLF into LF for UNIX */
+            c = SNX(message);
+            size--;
+            if(c != '\n') {
+                if(fputc('\r', data_file) < 0 || fputc(c, data_file) < 0) 
+                  goto bomb;
+                if(header_string != NULL) {
+                    *header_string++ = '\r';
+                    *header_string++ = c;
+                }
+            } else {
+                if(fputc('\n', data_file) < 0)
+                  goto bomb;
+                if(header_string != NULL) {
+                    if(last_was_crlf) {
+                        *header_string = '\0';
+                        header_string = NULL;
+                    }  else {
+                      *header_string++ = '\r';
+                      *header_string++ = '\n';
+                    }
+                }
+                last_was_crlf = 1;
+              }
+        } else {
+            if(fputc(c, data_file) == EOF) 
+              goto bomb;
+            if(header_string != NULL)
+              *header_string++ = c;
+            last_was_crlf = 0;
+        }
+    }
+    if(fclose(data_file) == EOF) 
+      goto bomb;
+    data_file = NULL;
+
+    
+    /*----Get the size that we actually wrote -----*/
+    stat(data_name, &sb);
+    mc.rfc822_size = sb.st_size;
+
+    /* This blows the nice tight memory usage for the carmel2 driver :-( */
+    header_string = cpystr(carmel_20k_buf); 
+
+#ifdef BWC
+    /*--- For MIME type x-bwc-glyph-wide, store in a nnnn.wid file ----*/
+    for(p = header_string; *p; p++) {
+        if((p == header_string  && carmel_match_glyph_wide(p)) ||
+           (*p == '\r' && *(p+1) == '\n' && carmel_match_glyph_wide(p+2))) {
+            sprintf(carmel_path_buf, "%s.wid", data_name);
+            rename(data_name, carmel_path_buf);
+            break;
+        }
+    }
+#endif
+
+    /*------ Parse the message to get envelope and message cache ----*/
+    INIT(&string_struct, mail_string, (void *)"", 0);
+    rfc822_parse_msg(&envelope, &b, header_string, strlen(header_string),
+                     &string_struct, mylocalhost(), carmel_20k_buf);
+    carmel2_parse_bezerk_status(&mc, header_string);
+    carmel2_rfc822_date(&mc, header_string);
+
+    /*------ Write the entry into the index ------*/
+    if(carmel2_write_index(envelope, &mc, index_file) < 0)
+      goto bomb;
+
+    if(local->aux_copy != NULL) /* Write carmel index if needed */
+      (*local->aux_copy)(local, mailbox, envelope, &mc);
+
+    mail_free_envelope(&envelope);
+    fs_give((void **)&header_string);
+
+    if(fclose(index_file) == EOF)
+      goto bomb;
+    carmel2_unlock(local, mailbox, WRITE_LOCK);
+    return(T);
+
+  bomb:
+    saved_errno = errno;
+    if(index_file != NULL) {
+        fclose(index_file);
+    }
+    if(data_file != NULL) {
+        fclose(data_file);
+        unlink(data_name);
+    }
+    carmel2_unlock(local, mailbox, WRITE_LOCK);
+    if(saved_errno != 0) {
+        sprintf(carmel_error_buf,"Message append failed: %s",
+                strerror(saved_errno));
+        mm_log(carmel_error_buf, ERROR);
+    }
+    return(NIL);
+}
+
+
+
+
+/* Search support routines
+ * Accepts: MAIL stream
+ *          message number
+ *          pointer to additional data
+ *          pointer to temporary buffer
+ * Returns: T if search matches, else NIL
+ */
+
+static char 
+carmel2_search_all (stream,msgno,d,n)
+        MAILSTREAM *stream;
+        long msgno;
+        char *d;
+        long n;
+{
+  return T;                     /* ALL always succeeds */
+}
+
+
+static char 
+carmel2_search_answered (stream,msgno,d,n)
+        MAILSTREAM *stream;
+        long msgno;
+        char *d;
+        long n;
+{
+  return MC(msgno)->answered ? T : NIL;
+}
+
+
+static char 
+carmel2_search_deleted (stream,msgno,d,n)
+        MAILSTREAM *stream;
+        long msgno;
+        char *d;
+        long n;
+{
+  return MC(msgno)->deleted ? T : NIL;
+}
+
+
+static char 
+carmel2_search_flagged (stream,msgno,d,n)
+        MAILSTREAM *stream;
+        long msgno;
+        char *d;
+        long n;
+{
+  return MC(msgno)->flagged ? T : NIL;
+}
+
+
+static char 
+carmel2_search_keyword (stream,msgno,d,n)
+        MAILSTREAM *stream;
+        long msgno;
+        char *d;
+        long n;
+{
+  return NIL;                   /* keywords not supported yet */
+}
+
+
+static char 
+carmel2_search_new (stream,msgno,d,n)
+        MAILSTREAM *stream;
+        long msgno;
+        char *d;
+        long n;
+{
+  MESSAGECACHE *elt = MC(msgno);
+  return (elt->recent && !elt->seen) ? T : NIL;
+}
+
+static char 
+carmel2_search_old (stream,msgno,d,n)
+        MAILSTREAM *stream;
+        long msgno;
+        char *d;
+        long n;
+{
+  return MC(msgno)->recent ? NIL : T;
+}
+
+
+static char 
+carmel2_search_recent (stream,msgno,d,n)
+        MAILSTREAM *stream;
+        long msgno;
+        char *d;
+        long n;
+{
+  return MC(msgno)->recent ? T : NIL;
+}
+
+
+static char 
+carmel2_search_seen (stream,msgno,d,n)
+        MAILSTREAM *stream;
+        long msgno;
+        char *d;
+        long n;
+{
+  return MC(msgno)->seen ? T : NIL;
+}
+
+
+static char 
+carmel2_search_unanswered (stream,msgno,d,n)
+        MAILSTREAM *stream;
+        long msgno;
+        char *d;
+        long n;
+{
+  return MC(msgno)->answered ? NIL : T;
+}
+
+
+static char 
+carmel2_search_undeleted (stream,msgno,d,n)
+        MAILSTREAM *stream;
+        long msgno;
+        char *d;
+        long n;
+{
+  return MC(msgno)->deleted ? NIL : T;
+}
+
+
+static char 
+carmel2_search_unflagged (stream,msgno,d,n)
+        MAILSTREAM *stream;
+        long msgno;
+        char *d;
+        long n;
+{
+  return MC(msgno)->flagged ? NIL : T;
+}
+
+
+static char 
+carmel2_search_unkeyword (stream,msgno,d,n)
+        MAILSTREAM *stream;
+        long msgno;
+        char *d;
+        long n;
+{
+  return T;                     /* keywords not supported yet */
+}
+
+
+static char 
+carmel2_search_unseen (stream,msgno,d,n)
+        MAILSTREAM *stream;
+        long msgno;
+        char *d;
+        long n;
+{
+  return MC(msgno)->seen ? NIL : T;
+}
+
+static char 
+carmel2_search_before (stream,msgno,d,n)
+        MAILSTREAM *stream;
+        long msgno;
+        char *d;
+        long n;
+{
+  return (char) (carmel2_msgdate (stream,msgno) < n);
+}
+
+
+static char 
+carmel2_search_on (stream,msgno,d,n)
+        MAILSTREAM *stream;
+        long msgno;
+        char *d;
+        long n;
+{
+  return (char) (carmel2_msgdate (stream,msgno) == n);
+}
+
+
+static char 
+carmel2_search_since (stream,msgno,d,n)
+        MAILSTREAM *stream;
+        long msgno;
+        char *d;
+        long n;
+{
+                                /* everybody interprets "since" as .GE. */
+  return (char) (carmel2_msgdate (stream,msgno) >= n);
+}
+
+
+static unsigned long 
+carmel2_msgdate (stream,msgno)
+        MAILSTREAM *stream;
+        long msgno;
+{
+  struct stat sbuf;
+  struct tm *tm;
+  MESSAGECACHE *elt = MC(msgno);
+
+  return (long) (elt->year << 9) + (elt->month << 5) + elt->day;
+}
+
+/*----------------------------------------------------------------------
+    Search only the body of the text.
+  BUG, probably need to unencode before searching
+  ---*/
+static char 
+carmel2_search_body (stream,msgno, pat, pat_len)
+        MAILSTREAM *stream;
+        long msgno,pat_len;
+        char *pat;
+{
+  char *t =  carmel2_fetchtext(stream, msgno);
+  return (t && search (t,strlen(t), pat, pat_len));
+}
+
+
+/*----------------------------------------------------------------------
+    Search the subject field
+  ----*/
+static char 
+carmel2_search_subject (stream,msgno, pat, pat_len)
+        MAILSTREAM *stream;
+        long msgno, pat_len;
+        char *pat;
+{
+  char *t = carmel2_fetchstructure (stream,msgno,NULL)->subject;
+  return t ? search (t, strlen(t), pat, pat_len) : NIL;
+}
+
+
+/*----------------------------------------------------------------------
+    Search the full header and body text of the message
+  ---*/
+static char 
+carmel2_search_text (stream, msgno, pat, pat_len)
+        MAILSTREAM *stream;
+        long        msgno, pat_len;
+        char       *pat;
+{
+  char *t = carmel2_fetchheader(stream,msgno);
+  return (t && search(t, strlen(t), pat, pat_len)) ||
+    carmel2_search_body(stream,msgno, pat, pat_len);
+}
+
+
+/*----------------------------------------------------------------------
+   Search the Bcc field
+  ---*/
+static char 
+carmel2_search_bcc (stream,msgno,d,n)
+        MAILSTREAM *stream;
+        long msgno;
+        char *d;
+        long n;
+{
+  carmel_20k_buf[0] = '\0';
+                                /* get text for address */
+  rfc822_write_address (carmel_20k_buf,
+                        carmel2_fetchstructure (stream,msgno,NULL)->bcc);
+  return search (carmel_20k_buf, strlen(carmel_20k_buf),d,n);
+}
+
+
+static char 
+carmel2_search_cc (stream,msgno,d,n)
+        MAILSTREAM *stream;
+        long msgno;
+        char *d;
+        long n;
+{
+  carmel_20k_buf[0] = '\0';
+                                /* get text for address */
+  rfc822_write_address (carmel_20k_buf,
+                        carmel2_fetchstructure (stream, msgno, NULL)->cc);
+  return search (carmel_20k_buf, strlen(carmel_20k_buf),d,n);
+}
+
+
+static char 
+carmel2_search_from (stream,msgno,d,n)
+        MAILSTREAM *stream;
+        long msgno;
+        char *d;
+        long n;
+{
+  carmel_20k_buf[0] = '\0';
+                                /* get text for address */
+  rfc822_write_address (carmel_20k_buf,
+                        carmel2_fetchstructure (stream,msgno,NULL)->from);
+  return search (carmel_20k_buf, strlen(carmel_20k_buf),d,n);
+}
+
+
+static char 
+carmel2_search_to (stream,msgno, pat, pat_len)
+        MAILSTREAM *stream;
+        long msgno;
+        char *pat;
+        long pat_len;
+{
+  carmel_20k_buf[0] = '\0';
+                                /* get text for address */
+  rfc822_write_address (carmel_20k_buf,
+                        carmel2_fetchstructure (stream, msgno, NULL)->to);
+  return(search(carmel_20k_buf,strlen(carmel_20k_buf), pat, pat_len));
+}
+
+/* Search parsers */
+
+
+/* Parse a date
+ * Accepts: function to return
+ *          pointer to date integer to return
+ * Returns: function to return
+ */
+
+static search_t
+carmel2_search_date (f, n)
+        search_t f;
+        long *n;
+{
+  long i;
+  char *s;
+  MESSAGECACHE elt;
+                                /* parse the date and return fn if OK */
+  return (carmel2_search_string (f,&s,&i) && mail_parse_date (&elt,s) &&
+          (*n = (elt.year << 9) + (elt.month << 5) + elt.day)) ? f : NIL;
+}
+
+/* Parse a flag
+ * Accepts: function to return
+ *          pointer to string to return
+ * Returns: function to return
+ */
+
+static search_t 
+carmel2_search_flag (f,d)
+        search_t f;
+        char **d;
+{
+                                /* get a keyword, return if OK */
+  return (*d = strtok (NIL," ")) ? f : NIL;
+}
+
+
+/* Parse a string
+ * Accepts: function to return
+ *          pointer to string to return
+ *          pointer to string length to return
+ * Returns: function to return
+ */
+
+static search_t 
+carmel2_search_string (f,d,n)
+        search_t f;
+        char **d;
+        long *n;
+{
+  char *c = strtok (NIL,"");    /* remainder of criteria */
+  if (c) {                      /* better be an argument */
+    switch (*c) {               /* see what the argument is */
+    case '\0':                  /* catch bogons */
+    case ' ':
+      return NIL;
+    case '"':                   /* quoted string */
+      if (!(strchr (c+1,'"') && (*d = strtok (c,"\"")) && (*n = strlen (*d))))
+        return NIL;
+      break;
+    case '{':                   /* literal string */
+      *n = strtol (c+1,&c,10);  /* get its length */
+      if (*c++ != '}' || *c++ != '\015' || *c++ != '\012' ||
+          *n > strlen (*d = c)) return NIL;
+      c[*n] = '\255';           /* write new delimiter */
+      strtok (c,"\255");        /* reset the strtok mechanism */
+      break;
+    default:                    /* atomic string */
+      *n = strlen (*d = strtok (c," "));
+      break;
+    }
+    return f;
+  }
+  else return NIL;
+}
+
+
+
+
+
+   
+/*----------------------------------------------------------------------
+   Some stuff to help out with the date parsing
+ ---*/  
+char *xdays2[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", NULL};
+
+char *
+month_abbrev2(month_num)
+     int month_num;
+{
+    static char *xmonths[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
+                "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", NULL};
+    if(month_num < 1 || month_num > 12)
+      return("xxx");
+    return(xmonths[month_num - 1]);
+}
+
+struct time_zone_names {
+    char *name;
+    int   hours;
+    int    minutes;
+} tz_names[]  = {
+    {"GMT",   0,   0},
+    {"PST",  -8,   0},
+    {"PDT",  -7,   0},
+    {"MST",  -7,   0},
+    {"MDT",  -6,   0},
+    {"CST",  -6,   0},
+    {"CDT",  -5,   0},
+    {"EST",  -5,   0},
+    {"EDT",  -4,   0},
+    {"JST",   9,   0},
+    {"IST",   2,   0},
+    {"IDT",   3,   0},
+    {NULL,    0,   0}};
+    
+/*----------------------------------------------------------------------
+   Parse a date string into into a structure
+ 
+Args: mc -- mesage cache to with structure to receive data
+      given_date -- full header with date string somewhere to be found
+
+This parses a number of date formats and produces a cannonical date in
+a structure. The basic format is:
+   
+ dd mm yy hh:mm:ss.t tz   
+
+It will also handle:
+  ww dd mm yy hh:mm:ss.t tz     mm dd yy hh:mm:ss.t tz
+  ww dd mm hh:mm:ss.t yy tz     mm dd hh:mm:ss.t yy tz
+
+It knows many abbreviations for timezones, but is not complete.
+In general absolute time zones in hours +/- GMT are best.
+  ----*/
+void
+carmel2_rfc822_date(mc, given_date)
+     char        *given_date;
+     MESSAGECACHE *mc;
+{
+    char *p, **i, *q;
+    int   month, year;
+    struct time_zone_names *tz;
+
+    mc->seconds  = 0;
+    mc->minutes  = 0;
+    mc->hours    = 30;
+    mc->day      = 0;
+    mc->month    = 0;
+    mc->year     = 0;
+    mc->zhours   = 0;
+    mc->zminutes = 0;
+
+    if(given_date == NULL)
+      return;
+
+    p = given_date;
+
+    if(*p != 'D' && strncmp(p, "Date:",5))
+      while(*p) {
+          if(*p == '\n' && *(p+1) == 'D' && strncmp(p+1, "Date:", 5) == 0)
+            break;
+         p++;
+      }
+    if(!*p)
+      return;
+
+    p += 6; /* Skip "\nDate: " */
+    while(isspace(*p))
+      p++;
+           
+    /* Start with month, weekday or day ? */
+    for(i = xdays2; *i != NULL; i++) 
+      if(struncmp2(p, *i, 3) == 0) /* Match first 3 letters */
+        break;
+    if(*i != NULL) {
+        /* Started with week day .. buz over it*/
+        while(*p && !isspace(*p) && *p != ',')
+          p++;
+        while(*p && (isspace(*p) || *p == ','))
+          p++;
+    }
+    if(isdigit(*p)) {
+        mc->day = atoi(p);
+        while(*p && isdigit(*p))
+          p++;
+        while(*p && (*p == '-' || *p == ',' || isspace(*p)))
+          p++;
+    }
+    for(month = 1; month <= 12; month++)
+      if(struncmp2(p, month_abbrev2(month), 3) == 0)
+        break;
+    if(month < 13) {
+        mc->month = month;
+
+    } 
+    /* Move over month, (or whatever is there) */
+    while(*p && !isspace(*p) && *p != ',' && *p != '-')
+       p++;
+    while(*p && (isspace(*p) || *p == ',' || *p == '-'))
+       p++;
+
+    /* Check again for day */
+    if(isdigit(*p) && mc->day == -1) {
+        mc->day = atoi(p);
+        while(*p && isdigit(*p))
+          p++;
+        while(*p && (*p == '-' || *p == ',' || isspace(*p)))
+          p++;
+    }
+
+    /*-- Check for time --*/
+    for(q = p; *q && isdigit(*q); q++);
+    if(*q == ':') {
+        /* It's the time (out of place) */
+        mc->hours = atoi(p);
+        while(*p && *p != ':' && !isspace(*p))
+          p++;
+        if(*p == ':') {
+            mc->minutes = atoi(p);
+            while(*p && *p != ':' && !isspace(*p))
+              p++;
+            if(*p == ':') {
+                mc->seconds = atoi(p);
+                while(*p && !isspace(*p))
+                  p++;
+            }
+        }
+        while(*p && isspace(*p))
+          p++;
+    }
+    
+    /* Get the year 0-50 is 2000-2050; 50-100 is 1950-1999 and
+                                           101-9999 is 101-9999 */
+    if(isdigit(*p)) {
+        year = atoi(p);
+        if(year < 50)   
+          year += 2000;
+        else if(year < 100)
+          year += 1900;
+        mc->year = year - 1969; 
+        while(*p && isdigit(*p))
+          p++;
+        while(*p && (*p == '-' || *p == ',' || isspace(*p)))
+          p++;
+    } else {
+        /* Something wierd, skip it and try to resynch */
+        while(*p && !isspace(*p) && *p != ',' && *p != '-')
+          p++;
+        while(*p && (isspace(*p) || *p == ',' || *p == '-'))
+          p++;
+    }
+
+    /*-- Now get hours minutes, seconds and ignore tenths --*/
+    for(q = p; *q && isdigit(*q); q++);
+    if(*q == ':' && mc->hours == 30) {
+        mc->hours = atoi(p);
+        while(*p && *p != ':' && !isspace(*p))
+          p++;
+        if(*p == ':') {
+            p++;
+            mc->minutes = atoi(p);
+            while(*p && *p != ':' && !isspace(*p))
+              p++;
+            if(*p == ':') {
+                p++;
+                mc->seconds = atoi(p);
+                while(*p && !isspace(*p) && *p != '+' && *p != '-')
+                  p++;
+            }
+        }
+    }
+    while(*p && isspace(*p))
+      p++;
+
+
+    /*-- The time zone --*/
+    if(*p) {
+        if(*p == '+' || *p == '-') {
+            char tmp[3];
+            mc->zoccident = (*p == '+' ? 1 : 0);
+            p++;
+            tmp[0] = *p++;
+            tmp[1] = *p++;
+            tmp[2] = '\0';
+            mc->zhours = atoi(tmp);
+            tmp[0] = *p++;
+            tmp[1] = *p++;
+            tmp[2] = '\0';
+            mc->zminutes *= atoi(tmp);
+        } else {
+            for(tz = tz_names; tz->name != NULL; tz++) {
+                if(struncmp2(p, tz->name, strlen(tz->name)) ==0) {
+                    if(tz->hours >= 0) {
+                        mc->zhours = tz->hours;
+                        mc->zoccident = 1;
+                    } else {
+                        mc->zhours    = -tz->hours;
+                        mc->zoccident = 0;
+                    }
+                    mc->zminutes = tz->minutes;
+                    break;
+                }
+            }
+        }
+    }
+    if(mc->hours == 30)
+      mc->hours = 0;
+}
+
+
+      
+/*----------------------------------------------------------------------
+    Print the date from the MESSAGECACHE into the string
+ ----*/
+static void
+carmel2_date2string(string, mc)
+     char         *string;
+     MESSAGECACHE *mc;
+{
+    sprintf(string, "%d %s %d %d:%02d:%02d %s%04d",
+            mc->day, month_abbrev2(mc->month), 1969+mc->year,
+            mc->hours, mc->minutes, mc->seconds, mc->zoccident ? "-" : "",
+            mc->zhours * 100 + mc->zminutes);
+}
+
+
+
+/*----------------------------------------------------------------------
+    Read the date into a structure from line in Carmel index
+
+ Args: mc     -- The structure to contain the date (and other things)
+       string -- String to be parsed. Format is:
+                  "yyyy^Amm^Add^Ahh^Amm^Ass^Azh^Azm"
+
+ ----*/
+static void
+carmel2_parse_date(mc, string)
+     MESSAGECACHE *mc;
+     char         *string;
+{
+    int n;
+    mc->year    = next_num(&string) - 1969;
+    mc->month   = next_num(&string);
+    mc->day     = next_num(&string);
+    mc->hours   = next_num(&string);
+    mc->minutes = next_num(&string);
+    mc->seconds = next_num(&string);
+
+    n = next_num(&string);
+    if(n < 0) {
+        mc->zoccident = 0;
+        mc->zhours    = -n;
+    } else {
+        mc->zoccident = 1;
+        mc->zhours    = n;
+    }
+    mc->zminutes = next_num(&string);      
+}
+
+
+
+/*----------------------------------------------------------------------
+   Read the next number out of string and return it, advancing the string
+  ----*/
+static
+next_num(string)
+     char **string;
+{
+    int   n;
+    char *p;
+
+    if(string == NULL)
+      return(0);
+
+    p = *string;
+    n = atoi(p);
+    while(*p > '\001')
+      p++;
+    if(*p)
+      *string = p+1;
+    else
+      *string = NULL;
+    return(n);
+}
+
+
+/*----------------------------------------------------------------------
+     Take a (slightly ugly) FQ mailbox and and return the prettier 
+  last part of it
+  ----*/
+char *
+carmel_pretty_mailbox(mailbox)
+     char *mailbox;
+{
+    char *pretty_mb;
+ 
+    for(pretty_mb = mailbox + strlen(mailbox) - 1;
+        *pretty_mb != '#' && pretty_mb > mailbox;
+        pretty_mb--)
+      ;
+    if(*pretty_mb == '#')
+      pretty_mb++;
+    return(pretty_mb);
+}
+
+/*----------------------------------------------------------------------
+    Parse a carmel mailbox name into its parts
+
+Args: fq_name: The name to parse
+      given_version: The version that must match; currently either \0 or '2'
+
+Returns: NULL if not a valid carmel name, version of name and given_version
+         do not match, or a malloced structure if it is.
+  ----*/
+struct carmel_mb_name *
+carmel_parse_mb_name(fq_name, given_version)
+     char *fq_name;
+     char  given_version;
+{
+    char                  *p, *q, version[2];
+    struct carmel_mb_name *parsed_name;
+
+    if(struncmp2(fq_name, CARMEL_NAME_PREFIX, strlen(CARMEL_NAME_PREFIX))!= 0){
+        return(0);   /* BUG -- we won't work with non-FQN names for now */
+        p = fq_name;
+	version[0] = given_version;
+	version[1] = '\0';
+    } else {
+	if(fq_name[7] == CARMEL_NAME_CHAR) {
+	    version[0] = '\0';
+	    p = fq_name + 8;
+	} else if(fq_name[8] == CARMEL_NAME_CHAR) {
+	    version[0] = fq_name[7];
+	    version[1] = '\0';
+	    p = fq_name + 9;
+	} else {
+	    return(NULL);
+	}
+    }
+
+    if(given_version != version[0])
+      return(NULL);
+
+    parsed_name=(struct carmel_mb_name *)fs_get(sizeof(struct carmel_mb_name));
+    parsed_name->version[0] = version[0];
+    parsed_name->version[1] = version[1];
+
+    /*---- Find second # if there is one ---*/
+    for(q = p; *q && *q != CARMEL_NAME_CHAR; q++);
+
+    if(*q == CARMEL_NAME_CHAR) {
+        /*----- There is a user name -----*/
+        parsed_name->user = fs_get((q - p) + 1);
+        strncpy(parsed_name->user, p, q - p);
+        parsed_name->user[q - p] = '\0';
+        p = q + 1;
+    } else {
+        parsed_name->user = NULL;
+    }
+
+    parsed_name->mailbox = cpystr(p);
+
+    return(parsed_name);
+}
+
+
+void
+carmel_free_mb_name(mb_name)
+     struct carmel_mb_name *mb_name;
+{
+    if(mb_name->user != NULL)
+      fs_give((void **)(&(mb_name->user)));
+    fs_give((void **)(&(mb_name->mailbox)));
+    fs_give((void **)&mb_name);
+}
+    
+    
+
+    
+    
+        
+        
+    
+
+    
+/*--------------------------------------------------
+     A case insensitive strcmp()     
+  
+   Args: o, r -- The two strings to compare
+
+ Result: integer indicating which is greater
+  ---*/
+strucmp2(o, r)
+     register char *r, *o;
+{
+    if(r == NULL && o == NULL)
+      return(0);
+    if(o == NULL)
+      return(1);
+    if(r == NULL)
+      return(-1);
+
+    while(*o && *r && (isupper(*o) ? tolower(*o) : *o) ==
+                      (isupper(*r) ? tolower(*r) : *r)) {
+        o++, r++;
+    }
+    return((isupper(*o) ? tolower(*o): *o)-(isupper(*r) ? tolower(*r) : *r));
+}
+
+
+
+/*----------------------------------------------------------------------
+     A case insensitive strncmp()     
+  
+   Args: o, r -- The two strings to compare
+         n    -- length to stop comparing strings at
+
+ Result: integer indicating which is greater
+   
+  ----*/
+struncmp2(o, r, n)
+     register char *r, *o;
+     register int   n;
+{
+    if(r == NULL && o == NULL)
+      return(0);
+    if(o == NULL)
+      return(1);
+    if(r == NULL)
+      return(-1);
+
+    n--;
+    while(n && *o && *r &&
+          (isupper(*o)? tolower(*o): *o) == (isupper(*r)? tolower(*r): *r)) {
+        o++; r++; n--;
+    }
+    return((isupper(*o)? tolower(*o): *o) - (isupper(*r)? tolower(*r): *r));
+}
+
+/*----------------------------------------------------------------------
+    A replacement for strchr or index ...
+
+ ....so we don't have to worry if it's there or not. We bring our own.
+If we really care about efficiency and think the local one is more
+efficient the local one can be used, but most of the things that take
+a long time are in the c-client and not in pine.
+ ----*/
+char *
+strindex2(buffer, ch)
+    char *buffer;
+    int ch;
+{
+    /** Returns a pointer to the first occurance of the character
+        'ch' in the specified string or NULL if it doesn't occur **/
+
+    do
+      if(*buffer == ch)
+        return(buffer);
+    while (*buffer++ != '\0');
+
+    return(NULL);
+}
+
+
+/*======================================================================
+ */
+
+xopen(file, mode)
+     char *file, *mode;
+{}
+
+
+xclose(stream)
+     FILE *stream;
+{}
+
+xread() {}
+
+xwrite() {}
+
+xlseek() {}
+
+#ifdef BWC
+carmel_match_glyph_wide(string)
+     char *string;
+{
+    extern char *ptspecials;
+    char *s;
+
+    if(struncmp2(string, "content-type", 12))
+      return(0);  /* Nope */
+    string += 12;
+    while(*string && isspace(*string)) string++;
+    if(*string != ':')
+      return(0);
+    string++;
+    while(*string && isspace(*string)) string++;
+    s = string;
+    string = rfc822_parse_word(string, ptspecials);
+    if(string == NULL)
+      return(0);
+    if(struncmp2(s, "text", 4))
+      return(0);
+    while(*string && isspace(*string)) string++;
+    if(*string != '/')
+      return;
+    string++;
+    while(*string && isspace(*string)) string++;
+    s = string;
+    string = rfc822_parse_word(string, ptspecials);
+    if(string == NULL)
+      return(0);
+    if(struncmp2(s, "x-bwc-glyph-wide", 16))
+      return(0);
+    return(1);
+}
+#endif    
+    
diff --git a/contrib/carmel/c-client/carmel2.h b/contrib/carmel/c-client/carmel2.h
new file mode 100644
index 00000000..550a4bf3
--- /dev/null
+++ b/contrib/carmel/c-client/carmel2.h
@@ -0,0 +1,200 @@
+/*----------------------------------------------------------------------
+
+    T H E   C A R M E L 2   M A I L   F I L E   D R I V E R
+
+ Author(s):   Laurence Lundblade
+              Baha'i World Centre
+              Data Processing
+              Haifa, Israel
+	      Internet: lgl@cac.washington.edu or laurence@bwc.org
+              September 1992
+
+ Last Edited: Aug 31, 1994
+  ----------------------------------------------------------------------*/
+
+/* Command bits from carmel2_getflags() */
+
+#define fSEEN     1
+#define fDELETED  2
+#define fFLAGGED  4
+#define fANSWERED 8
+#define fRECENT  16
+
+/* Kinds of locks for carmel2_lock() */
+
+#define READ_LOCK   0
+#define WRITE_LOCK  1
+
+
+/* Carmel2 I/O stream local data */
+
+typedef struct _local2 {
+  MESSAGECACHE **mc_blocks;
+  long           cache_size;
+  FILE          *index_stream;
+  char          *stdio_buf;
+  char          *msg_buf;
+  unsigned long  msg_buf_size;
+  unsigned long  msg_buf_text_offset;
+  char          *msg_buf_text_start;
+  char          *buffered_file;
+  long           read_lock_mod_time, write_lock_mod_time;
+  long           index_size;
+  unsigned int   dirty:1;
+  unsigned int   carmel:1;  /* It's a carmel file instead of carmel2 */
+  unsigned int   buffered_header_and_text:1;
+  unsigned int   new_file_on_copy:1;
+  char        *(*calc_paths)();
+  long         (*aux_copy)();
+} CARMEL2LOCAL;
+
+
+struct carmel_mb_name {
+    char  version[2]; /* \0 for version 1, ASCII digit  and \0 for other */
+    char *user;    /* String of userid for other user names */
+    char *mailbox; /* Mailbox name */
+};
+
+
+#define MC(x) (&(LOCAL->mc_blocks[(x) >> 8][(x) & 0xff]))
+#define LOCAL ((CARMEL2LOCAL *) stream->local)
+#define CARMEL_MAXMESSAGESIZE (20000000)  /* 20Mb */
+#define CARMEL_MAX_HEADER        (64000)  /* 64K for DOS (someday?) */
+#define CARMEL_PATHBUF_SIZE       (1024)
+#define CARMEL2_INDEX_BUF_SIZE   (20000)  /* Size for carmel2 index FILE buf */
+#define CARMEL_NAME_CHAR           ('#')  /* Separator for carmel names */
+#define CARMEL_NAME_PREFIX     "#carmel"  /* Prefix for all mailbox names */
+
+
+/* Kinds of paths that for carmel_calc_path */
+
+#define CalcPathCarmel2Index     1
+#define CalcPathCarmel2Data      2
+#define CalcPathCarmel2MAXNAME   3
+#define CalcPathCarmel2WriteLock 4
+#define CalcPathCarmel2ReadLock  5
+#define CalcPathCarmel2Expunge   6
+
+
+/* These are all relative to the users home directory */
+
+#define CARMEL2_INDEX_DIR  "Carmel2Mail"
+#define CARMEL2_DIR        "Carmel2Mail"
+#define CARMEL2_MSG_DIR    "Carmel2Mail/.Messages"
+#define CARMEL2_MAXFILE    "Carmel2Mail/.MAXNAME"
+
+
+#define BEZERKLOCKTIMEOUT 5
+
+/* Function prototypes */
+
+#ifdef ANSI
+DRIVER	    *carmel2_valid(char *);
+int	     carmel2_isvalid(char *);
+char	    *carmel2_file(char *, char *);
+void        *carmel2_parameters();
+void	     carmel2_find(MAILSTREAM *, char *);
+void	     carmel2_find_bboards(MAILSTREAM *, char *);
+void         carmel2_find_all(MAILSTREAM *, char *);
+void         carmel2_find_all_bboards(MAILSTREAM *, char *);
+long         carmel2_subscribe();
+long         carmel2_unsubscribe();
+long         carmel2_subscribe_bboard();
+long         carmel2_unsubscribe_bboard();
+long         carmel2_create(MAILSTREAM *, char *);
+long         carmel2_delete(MAILSTREAM *, char *);
+long         carmel2_rename(MAILSTREAM *, char *, char *);
+MAILSTREAM  *carmel2_open(MAILSTREAM *);
+int          carmel2_open2(MAILSTREAM *, char *);
+void         carmel2_close(MAILSTREAM *);
+void         carmel2_fetchfast(MAILSTREAM *, char *);
+void         carmel2_fetchflags(MAILSTREAM *, char *);
+ENVELOPE    *carmel2_fetchstructure(MAILSTREAM *, long, BODY **);
+char        *carmel2_fetchheader(MAILSTREAM *, long);
+char        *carmel2_fetchtext(MAILSTREAM *, long);
+char        *carmel2_fetchbody(MAILSTREAM *, long, char *, unsigned long *);
+void         carmel2_setflag(MAILSTREAM *, char *, char *);
+void         carmel2_clearflag(MAILSTREAM *, char *, char *);
+void         carmel2_search(MAILSTREAM *, char *);
+long         carmel2_ping(MAILSTREAM *);
+void         carmel2_check(MAILSTREAM *);
+void         carmel2_expunge(MAILSTREAM *);
+long         carmel2_copy(MAILSTREAM *, char *, char *);
+long         carmel2_move(MAILSTREAM *, char *, char *);
+void         carmel2_gc(MAILSTREAM *, long);
+void        *carmel2_cache(MAILSTREAM *, long, long);
+long         carmel2_append(MAILSTREAM *, char *, STRING *);
+int          carmel2_write_index(ENVELOPE *, MESSAGECACHE *, FILE *);
+char        *carmel2_readmsg(MAILSTREAM *, int, long, int);
+int          carmel2_lock(CARMEL2LOCAL *, char *, int);
+void         carmel2_unlock(CARMEL2LOCAL *, char *, int);
+int          carmel2_update_lock(CARMEL2LOCAL *, char *, int);
+int          carmel2_check_dir(char *);
+void         carmel2_parse_bezerk_status(MESSAGECACHE *, char *);
+int          carmel2_append2(MAILSTREAM *, CARMEL2LOCAL *, char *, char *,
+                             char *, STRING *);
+char        *month_abbrev2(int);
+void         carmel2_rfc822_date(MESSAGECACHE *, char *);
+char        *carmel_pretty_mailbox(char *);
+struct carmel_mb_name *
+             carmel_parse_mb_name(char *, char);
+void         carmel_free_mb_name(struct carmel_mb_name *);
+int          strucmp2(char *, char *);
+int          struncmp2(char *, char *, int);
+
+#else  /* ANSI */
+
+
+DRIVER	    *carmel2_valid();
+int	     carmel2_isvalid();
+char	    *carmel2_file();
+void        *carmel2_parameters();
+void	     carmel2_find();
+void	     carmel2_find_bboards();
+void         carmel2_find_all();
+void         carmel2_find_all_bboards();
+long         carmel2_subscribe();
+long         carmel2_unsubscribe();
+long         carmel2_subscribe_bboard();
+long         carmel2_unsubscribe_bboard();
+long         carmel2_create();
+long         carmel2_delete();
+long         carmel2_rename();
+MAILSTREAM  *carmel2_open();
+int          carmel2_open2();
+void         carmel2_close();
+void         carmel2_fetchfast();
+void         carmel2_fetchflags();
+ENVELOPE    *carmel2_fetchstructure();
+char        *carmel2_fetchheader();
+char        *carmel2_fetchtext();
+char        *carmel2_fetchbody();
+void         carmel2_setflag();
+void         carmel2_clearflag();
+void         carmel2_search();
+long         carmel2_ping();
+void         carmel2_check();
+void         carmel2_expunge();
+long         carmel2_copy();
+long         carmel2_move();
+void         carmel2_gc();
+void        *carmel2_cache();
+long         carmel2_append();
+int          carmel2_write_index();
+char        *carmel2_readmsg();
+int          carmel2_lock();
+void         carmel2_unlock();
+int          carmel2_update_lock();
+int          carmel2_check_dir();
+void         carmel2_parse_bezerk_status();
+int          carmel2_append2();
+char        *month_abbrev2();
+void         carmel2_rfc822_date();
+char        *carmel_pretty_mailbox();
+struct carmel_mb_name *
+             carmel_parse_mb_name();
+void         carmel_free_mb_name();
+int          strucmp2();
+int          struncmp2();
+
+#endif  /* ANSI */
diff --git a/contrib/carmel/doc/carmel-driver b/contrib/carmel/doc/carmel-driver
new file mode 100644
index 00000000..aa157cf8
--- /dev/null
+++ b/contrib/carmel/doc/carmel-driver
@@ -0,0 +1,157 @@
+
+
+Carmel driver notes
+-------------------
+Set folder-collections=#carmel#[] to configure Pine to use the
+carmel driver. You may include other colllections like a directory full
+of Berkeley mail folder
+
+
+
+Be sure you don't have a file called ".mailboxlist" in your home
+directory. If you do the list of mailboxes presented to be by
+the c-client will be out of that file rather than by querying each
+driver.
+
+If you have files in your home or mail directory, be sure they aren't
+called anything that starts with "#carmel#" or %carmel%. They will be
+incorrectly included by mail_find for the bezerk and other drivers.
+
+The carmel driver doesn't grab "inbox". This is to allow other drivers
+a shot at it. This may or may not work out in the long run.  With the
+current version of Pine you must set your inbox-path=#carmel#inbox to
+cause the carmel inbox to be used.
+
+
+Patching/Compilation for Pine
+-----------------------------
+
+This set of files and patches was created for Pine 3.85 and the
+corresponding version 3.0 of the c-client and 7.63 of imapd. Hopefully
+they will continue to work with future versions of all of these. To
+apply the patches copy all the files in the subdirectories here (pine,
+c-client and imapd) to the corresponding directories in the Pine
+source. The run patch on each of the patch files and finally run the
+build script in Pine source root directory. This should result in a
+pine, pico and imapd binary in the bin directory ready to be
+installed. In the c-client directory there will be a bzk2cml binary
+for converting a Berkeley format mailbox to a Carmel format mailbox
+for the user running the program.
+
+The modifications to the Pine source are minimal. The two parts are
+the calls to link in the carmel driver, and the patches to display
+BWC-GLYPH text. Nearly all the patches are for the later. One
+additional patch is needed to specify the right driver for creating
+new mailboxes. This is currently a bit of a hack in Pine and will
+hopefully be fixed future versions of Pine. The patches to imapd are
+of exactly the same nature as those to Pine.
+
+If some of these patches fail, it's probably due to changes made in
+Pine (applying them to some other version than 3.85).  In that cases
+the patches will have to be made manually. 
+
+
+   
+Fixed since the version of Sept '92.
+------------------------------------
+* Updated to conform with the changes in UW internal changes from
+  version 3.5X to 3.84. With these changes all the internal Pine calls
+  to the c-client are stabilized, possibly except some changes for
+  mail_create. This makes the carmel driver trivial to integrate with
+  future versions of Pine.
+
+* Driver now checkpoints both carmel and carmel2 indexes. This should
+  save the nightly from deleting mail that it shouldn't.
+
+* The driver only defaults messages without any content-type to
+  X-bwc-glyph instead of messages that were tagged text/plain. This will
+  cause the the glyph to richtext translations not to be applied when
+  the message already has a MIME header.
+
+* Some bug fixes to display of BWC-GLYPH text, including bug causing
+  periodic core dumps. 
+
+* Handles case where data file for a message is missing properly
+
+* Bug fixes so critical code in driver is properly protected from
+  signals and interrupts.
+
+* Bzk2cml utility included to convert Berkeley mail folder into carmel
+  folders. 
+
+* Fixed bug causing text of currently viewed message to be redisplayed
+  incorrectly after the arrival of new mail.
+
+* Carmel text served up by imapd is tagged type "plain" instead of
+  "X-bwc-glyph", though the text is not yet converted to richtext
+  and quoted-printable encoded like it should be to work with other
+  clients. 
+
+
+Fixed in the Aug 1 version
+--------------------------
+* Only creates a maximum of four Carmel index backup files (COD.FUR files)
+ 
+* Folder listing now works with standard IMAP patterns
+  
+* Carmel index is check-pointed on expunges
+ 
+* Carmel driver checks for new mail with folder name #carmel#inbox
+ 
+* New mail is incorporated on other than inbox
+
+* MIME decoding works properly now
+
+* Safer incorporation of new mail from /usr/spool/mail (carmel2 writes flushed)
+
+
+Fixed in Aug 23 version
+-----------------------
+ 
+* Fetchheader includes the separator so append will work
+
+* Fixed append to get size right and not insert random NULL's, \n's...
+
+* Conversion of glyph format to rich text in imapd
+
+
+Fixed in Aug 29 version
+-----------------------
+* Further fixes to append, including full locking
+
+* The #carmel#user#folder syntax now works properly
+
+* Further fixes to imapd to convert to richtext only when appropriate
+
+
+Fixed in Sep 2 version
+----------------------
+* Nearly complete conversion from glyph to richtext
+
+* Fixed bug causing lost new mail on quick in/out Pine sessions
+
+* A few related Pine bugs fixed: sorting, wrapping
+  
+
+Fixed in Sep 25 version
+-----------------------
+
+* Recognizes all messages with subtype beginning with x-bwc-glyph as Glyph text. 
+* Saves messages of type x-bwc-glyph-wide in files ending with .wid
+
+* When saving messages, the link is used rather than making a new file
+
+* Glyph messages after 1994 must have the x-bwc-glyph tag to be recognized
+
+* Bug fix to properly display '@' in glyph text
+
+* Incorporation of latest version of c-client (minor bug fixes)
+
+
+
+General Features
+----------------
+* The driver checks the MAIL environment variable for the place to
+look for new incoming mail for the "inbox".
+
+(There's a lot more than this, but it's not documented yet)
diff --git a/contrib/carmel/doc/todo b/contrib/carmel/doc/todo
new file mode 100644
index 00000000..acf99f19
--- /dev/null
+++ b/contrib/carmel/doc/todo
@@ -0,0 +1,43 @@
+Legend:  P - Pine, C - Carmel, W - BWC specific hacks, I - Imapd
+         Capitial letters are bugs, small are feature additions
+
+Size is in days it will take LL to accomplish. A * means the UW or
+other are interested and might actually do this for us if we wait.
+
+Size   Where   What
+----   -----   -------------
+ 3       c     Make readonly mode parameters work
+ 3       C     Occaisional problem/error message with Fcc
+ 6       W     Copying/recognizing wide documents as wide (a new mime type?)
+ 2       b     Can't handle _ in folder names
+ 4       c     Testing to make sure all works in disk full conditions
+ 1       c     Quick hacks to work with ECS mail
+ 5*      i     Imapd modifications to work with ECS mail properly
+ 2       b/p   A default Bcc to oneself instead of Fcc (can you Fcc:inbox?)
+ 2*      p     Better handling of non-recognized attachment
+ 5       w     Printing wide documents
+ 2       W     Problems with glyph text column alignment for torture test
+15             Gateway to convert glyph to standard format as leaving BWC
+ 3       c     Initial account set up
+10       c     Kiss of death to steal write access from another running Pine
+ 6       C     Full IMAP searching in Carmel (not used by Pine yet)
+ 6       c     Carmel driver performance enhancments (for folders > 500 msgs)
+ 6*      ci    Auto updating deleted status for folder open by several users
+ 3       C     Doesn't incorporate new mail on start up like other IMAPware
+ 6       I/C   Handling of non-FQN's via IMAP (will solve ECS problems above)
+
+Things fixed for Aug 31 version
+-------------------------------
+- fixed bug with 1994 cut off date for forcing Carmel mail to x-bwc-glyph
+- fixed bugs in text header searching
+- changed to new c-client way of looking up hostname
+- works with new c-client for remote creates with FQNs
+- now works with new c-client scheme for including new mail file drivers
+- integrated x-bwc-glyph stuff with Pine 3.90
++ (Fixed in by UW) Handles passwords for multiple imap servers/accounts
+- Implemented TRYCREATE protocol for IMAP copies and appends
+
+Previous fixes
+--------------
+- Better handling of case of full disk
+
diff --git a/contrib/carmel/imapd/imapd.c.patch.old b/contrib/carmel/imapd/imapd.c.patch.old
new file mode 100644
index 00000000..16ed2981
--- /dev/null
+++ b/contrib/carmel/imapd/imapd.c.patch.old
@@ -0,0 +1,110 @@
+*** imapd.c	Sun Jul 18 21:48:29 1993
+--- imapd.c.new	Sun Jul 18 21:47:53 1993
+***************
+*** 109,115 ****
+--- 109,119 ----
+  extern DRIVER bezerkdriver,tenexdriver,imapdriver,newsdriver,nntpdriver,
+    dummydriver;
+  
++ #ifdef BWC
++ extern DRIVER carmeldriver, carmel2driver;
++ #endif
+  
++ 
+  /* Function prototypes */
+  
+  void main  ();
+***************
+*** 135,140 ****
+--- 139,148 ----
+  long cstring  ();
+  long caddr  ();
+  
++ #ifdef BWC
++ char *glyph2richtext();
++ #endif
++ 
+  extern char *crypt  ();
+  
+  /* Main program */
+***************
+*** 147,152 ****
+--- 155,164 ----
+    char *s,*t = "OK",*u,*v;
+    struct hostent *hst;
+    void (*f) () = NIL;
++ #ifdef BWC
++   mail_link (&carmeldriver);
++   mail_link (&carmel2driver);
++ #endif  
+    mail_link (&tenexdriver);	/* install the Tenex mail driver */
+    mail_link (&bezerkdriver);	/* install the Berkeley mail driver */
+    mail_link (&imapdriver);	/* install the IMAP driver */
+***************
+*** 164,170 ****
+--- 176,186 ----
+      state = SELECT;		/* enter select state */
+      t = "PREAUTH";		/* pre-authorized */
+    }
++ #ifdef BWC
++   printf ("* %s %s IMAP2bis Service %sBWC at %s\015\012",t,host,version,cmdbuf);
++ #else
+    printf ("* %s %s IMAP2bis Service %s at %s\015\012",t,host,version,cmdbuf);
++ #endif
+    fflush (stdout);		/* dump output buffer */
+    signal (SIGALRM,clkint);	/* prepare for clock interrupt */
+    signal (SIGUSR2,kodint);	/* prepare for Kiss Of Death */
+***************
+*** 782,788 ****
+--- 798,817 ----
+    if (body && (s = mail_fetchbody (stream,i,s,&j))) {
+  				/* and literal string */
+      printf ("{%d}\015\012",j);
++ #ifdef BWC_NOT_WORKING_YET
++     {
++         char *ss;
++         s[j] = '\0';
++         s = glyph2richtext(s);
++         j = strlen(s);
++         ss = rfc822_8bit(s, j, &j);
++         fs_give((void **)&s);
++         while (j -= k) k = fwrite (ss += k,1,j,stdout);
++         fs_give((void **)&ss);
++     }
++ #else    
+      while (j -= k) k = fwrite (s += k,1,j,stdout);
++ #endif
+      changed_flags (i,f);	/* output changed flags */
+    }
+    else fputs ("NIL",stdout);	/* can't output anything at all */
+***************
+*** 983,995 ****
+--- 1012,1039 ----
+      else {			/* non-multipart body type */
+        pstring ((char *) body_types[body->type]);
+        putchar (' ');
++ #ifdef BWC
++       if(body->type == TYPETEXT && strcmp(lcase(body->subtype), "x-bwc-glyph") == 0)
++         pstring("plain"); /* Make it plain now, richtext later when fixed */
++       else
++         pstring (body->subtype);
++ #else
+        pstring (body->subtype);
++ #endif
+        if (param = body->parameter) {
+  	fputs (" (",stdout);
+  	do {
+  	  pstring (param->attribute);
+  	  putchar (' ');
++ #ifdef BWC_NOT_WORKING_YET
++           if(strucmp2(param->attribute, "charset") == 0) {
++               pstring("ISO-8859-1");
++           } else {
++     	      pstring (param->value);
++           }
++ #else
+  	  pstring (param->value);
++ #endif
+  	  if (param = param->next) putchar (' ');
+  	} while (param);
+  	fputs (") ",stdout);
diff --git a/contrib/carmel/pine/filter.c.patch b/contrib/carmel/pine/filter.c.patch
new file mode 100644
index 00000000..094fc9ae
--- /dev/null
+++ b/contrib/carmel/pine/filter.c.patch
@@ -0,0 +1,409 @@
+*** filter.c	Fri Aug  5 18:44:21 1994
+--- filter.c.new	Wed Aug 31 18:31:47 1994
+***************
+*** 1937,1939 ****
+--- 1937,2340 ----
+  
+      fflush(stdout);
+  }
++ 
++ 
++ #ifdef BWC
++ #ifdef NODEF
++ /*-*/
++ #include <stdio.h>
++ #include <sys/types.h>
++ #include <sys/stat.h>
++ #include <sys/file.h>
++ struct stat buf;
++ char *malloc();
++ char *glyph2richtext();
++ int convert2graph();
++ #endif
++ 
++ char *glyph2richtext();
++ 
++ 
++ char *gf_glyph2richtext(f, c, flg)
++      FILTER_S *f;
++      int       c, flg;
++ {
++   char *line, *p;
++   if(flg == GF_RESET){
++     f->linep = f->line = (char *)fs_get(1000 * sizeof(char ));
++ 
++   } else if(flg == GF_DATA) {
++       if(c == '\n' && *(f->linep - 1) == '\r'){
++           *(f->linep)++ = '\n'; /* Tie of line */
++           *(f->linep) = '\0'; /* Tie of line */
++ 	  line = glyph2richtext(f->line);
++ 	  for(p = line; *p; p++)
++ 	    (*f->next->f)(f->next, *p, GF_DATA);
++   	  fs_give((void **)&line);
++ 	  f->linep = f->line;
++       } else {
++ 	*(f->linep)++ = c;
++       }
++   } else if(flg == GF_EOD) {
++       *(f->linep) = '\0'; /* Tie of line */
++       line = glyph2richtext(f->line);
++       for(p = line; *p; p++)
++         (*f->next->f)(f->next, *p, GF_DATA);
++       fs_give((void **)&line);
++       f->linep = f->line;
++       
++       fs_give((void **)&(f->line)); 
++       (*f->next->f)(f->next, 0 , GF_EOD);
++     }
++ }
++ 
++ 
++ char *glyph2richtext(textin)
++   char *textin;
++ {
++     register char *p, *textout; 
++     int          stack=10, underline=0, bold=0, graphics=0,i=0,two_underline=0 ;
++     int          memory_aloc=0;
++     char         stack_str[10][20];
++   
++     memory_aloc = max(strlen(textin)*8, 80);
++     textout     = malloc(memory_aloc+1);
++     *textout    = '\0';
++     dprint(9, (debugfile, "GLYPH2RICH strlen: %d   allocated: %d\n",
++                strlen(textin), memory_aloc + 1));
++   
++     while (stack--) stack_str[stack][0] = '\0';  /*Initialize the array */
++     stack=0;
++   
++     for(p=textout; *textin;){    /*everything is done in the loop */
++      
++         if ((p -textout) >(memory_aloc -200)){  /*allocate more memory before */
++             realloc(textout,(memory_aloc +=1024)); /*we ran out of it */
++             dprint(9, (debugfile, "GLYPH2RICH left: %d   reallocated: %d\n",
++                   p - textout, memory_aloc));
++         }
++     
++         /*======= THE LINE AND PAGE BREAKS =======*/
++         if(*textin == '\r' && *(textin+1)=='\n'){ /*---- LINE BREAK -----*/
++             while (stack--){                         /*End attributes*/
++                 sprintf(p, "</%s>", stack_str[stack]);
++                 p += strlen(p);
++                 stack_str[stack][0] = '\0';
++             }
++             if(two_underline) { /* In case '_' occured near end of line */
++                 strcpy(p, "<\\underline>");
++                 p += strlen(p);
++             }
++                
++             strcpy(p,"\r\n\r\n");                        /*Add richtext newline */
++             p += strlen(p);
++             textin += 2;
++     
++             stack=underline=bold=graphics=two_underline=0;
++             continue;
++         }
++     
++         if( *textin    == '{'  &&         /*-------- PAGE BREAK --------*/
++            *(textin+1) == '~'){ 
++             strcpy(p,"<np>");
++             p      += strlen(p);
++             textin +=2;
++             continue;
++         }
++     
++         /*==================== ATTRIBUTES ===============*/
++     
++         if(*textin == '_'){  /*------next two characters are underlined-----*/
++             if(underline){
++                 *textin++;  /*skip if already underlined*/
++             } else {
++                 two_underline=2;
++                 strcpy(p,"<underline>");
++                 p += strlen(p);
++                 *textin++;
++             }
++             continue;
++         }
++           
++         if( *textin    == '{'  && 
++            *(textin+1) == '\\'){           /*Some type of attribute found*/
++             textin += 2;
++            
++             while (stack--){                         /*End previous attributes*/
++                 sprintf(p, "</%s>", stack_str[stack]);
++                 p += strlen(p);
++                 stack_str[stack][0] = '\0';	
++             }
++     
++             stack=underline=bold=0;
++             if ( (*textin - 0x20)       & 0x01){
++               strcpy(stack_str[stack++],"bold");               /*bold*/
++               bold=1;
++             }
++             if (((*textin - 0x20) >> 1) & 0x01){               /*underline*/
++               strcpy(stack_str[stack++],"underline");
++               underline=1;
++             }
++             if (((*textin - 0x20) >> 2) & 0x01){              /*blinking*/
++               if(bold) strcpy(stack_str[stack++],"superscript");
++               else if (underline) strcpy(stack_str[stack++],"subscript");
++               else strcpy(stack_str[stack++],"no-op"); /*can't do blinking alone!*/
++             }
++             if (((*textin - 0x20) >> 3) & 0x01){              /*reverse video*/
++               strcat(stack_str[stack++],"italic");            /*Italic on paper*/
++             }
++             if (((*textin - 0x20) >> 4) & 0x01){              /*graphics*/
++               graphics=1;
++             } else graphics=0;
++     
++             
++             for(i=0; i<stack; i++){                /*write the staring attributes*/
++                 sprintf(p, "<%s>", stack_str[i]);
++                 p += strlen(p);
++             }
++             textin++;
++             continue;
++         }
++     
++         /*========== SPECIAL CHARACTERS ===========*/
++         if(two_underline){
++             /* Time to turn off underline? */
++             if(--two_underline ==0 && underline == 0){
++                 strcpy(p,"</underline>");
++                 p += strlen(p);
++             }
++         }
++     
++         if(*textin == '<'){
++             /*add richtext smaller sign */
++             strcpy(p,"<lt>");
++             p += strlen(p);
++             *textin++;
++     
++         } else if(graphics){               /*convert  graphics */
++           if    ( *textin == 'j' ||
++                   *textin == 'k' ||
++                   *textin == 'l' ||
++                   *textin == 'm' ||
++                   *textin == 'n' ||
++                   *textin == 't' ||
++                   *textin == 'u' ||
++                   *textin == 'v' ||
++                   *textin == 'w' )   { *p = '+'; *textin++;}
++           else if ( *textin == 'q' ) { *p = '-'; *textin++;}
++           else if ( *textin == 'x' ) { *p = '|'; *textin++;}
++           else *p= *textin++;
++           p++;
++         } else if(*textin == '^'){    /* Accent (similar to \a notation)*/
++             textin++;
++             if     (*textin == 'A' ){*p='\301'; textin++;}
++             else if(*textin == 'E' ){*p='\311'; textin++;}
++             else if(*textin == 'I' ){*p='\315'; textin++;}
++             else if(*textin == 'O' ){*p='\323'; textin++;}
++             else if(*textin == 'U' ){*p='\332'; textin++;}
++             else if(*textin == 'a' ){*p='\341'; textin++;}
++             else if(*textin == 'e' ){*p='\351'; textin++;}
++             else if(*textin == 'i' ){*p='\355'; textin++;}
++             else if(*textin == 'o' ){*p='\363'; textin++;}
++             else if(*textin == 'u' ){*p='\372'; textin++;}
++             else *p= '^';
++             *++p = '\0';
++             
++         } else if(*textin == '|') {   /* Dot under letter */
++             textin++;
++             switch(*textin) {
++               case 'd':
++               case 'D':
++               case 's':
++               case 'S':
++               case 'T':
++               case 't':
++               case 'Z':
++               case 'z':
++                 *p = *textin++; break;
++               default:
++                 *p = '|'; break;
++             }
++             *++p = '\0';
++     
++         } else if( *textin == '\\'){  /* Decode \ notation for 8 bit chars */
++             switch(*(textin+1)){
++               case '@':
++                 *p = '@';   textin+=2; /* *textin++;*textin++; */
++                 break;
++               case '\\':                         /* back slash*/
++                 *p = '\\';  textin+=2;
++                 break;
++               case '!':                          /* reverse exclaimation */
++                 *p = '\241'; textin+=2;
++                 break;
++               case '#':                          /* superscript 1 2 3 */
++                 if     (*(textin+2) == '1' ){*p='\271'; textin += 3;}
++                 else if(*(textin+2) == '2' ){*p='\262'; textin += 3;}
++                 else if(*(textin+2) == '3' ){*p='\263'; textin += 3;}
++                 else *p= *textin++; 
++                 break;
++               case '$':                         /* cent*/
++                 *p = '\242'; textin+=2;
++                 break;
++               case '&':                         /* ligature*/
++                 *p = '\247'; textin+=2;
++                 break;
++               case '*':                         /* crossed o*/
++                 *p = '\250'; textin+=2;
++                 break;
++               case '-':                         /* minus*/
++                 *p = '-'; textin+=2;
++                 break;
++               case '.':                         /* degree*/
++                 *p = '\260'; textin+=2;
++                 break;
++               case '/':                         /* o slashed*/
++                 if     (*(textin+2) == 'O' ){*p='\330'; textin += 3;}
++                 else if(*(textin+2) == 'o' ){*p='\370'; textin += 3;}
++                 else *p= *textin++; 
++                 break;
++               case '<':                         /* double <*/
++                 *p = '\253'; textin+=2;
++                 break;
++               case 'n':                         /* back quote (ayn)*/
++                 *p = '`'; textin+=2;
++                 break;
++               case '>':                         /* double >*/
++                 *p = '\273'; textin+=2;
++                 break;
++               case '=':                         /* ligature*/
++                 if     (*(textin+2) == 'A' &&
++                         *(textin+3) == 'E' )   {*p='\306';  *(textin+=4);}
++                 else if(*(textin+2) == 'O' &&
++                         *(textin+3) == 'E' )   {*p='\327';  *(textin+=4);}
++                 else if(*(textin+2) == 'a' &&
++                         *(textin+3) == 'e' )   {*p='\346';  *(textin+=4);}
++                 else if(*(textin+2) == 'o' &&
++                         *(textin+3) == 'e' )   {*p='\367';  *(textin+=4);}
++                 
++                 else *p= *textin++; 
++                 break;
++               case '?':                         /* reverse question mark*/
++                 *p = '\277'; textin+=2;
++                 break;
++               case 'B':                         /* german SS (B)*/
++                 *p = '\337'; textin+=2;
++                 break;
++               case 'C':                         /* underlined a & o */
++                 if     (*(textin+2) == 'a' ){*p='\252'; textin += 3;}
++                 else if(*(textin+2) == 'o' ){*p='\272'; textin += 3;}
++                 else *p= *textin++; 
++                 break;
++               case 'H':                         /* One half (1/2) */
++                 *p = '\275'; textin+=2;
++                 break;
++               case 'P':                         /* paragrph marker */
++                 *p = '\266'; textin+=2;
++                 break;
++               case 'Q':                         /* One quarter (1/4)*/
++                 *p = '\274'; textin+=2;
++                 break;
++               case 'U':                         /* greek mu */
++                 *p = '\265'; textin+=2;
++                 break;
++               case 'Y':                         /* Yen */
++                 *p = '\245'; textin+=2;
++                 break;
++               case 'a':                         /* Accent*/
++                 if     (*(textin+2) == 'A' ){*p='\301'; textin += 3;}
++                 else if(*(textin+2) == 'E' ){*p='\311'; textin += 3;}
++                 else if(*(textin+2) == 'I' ){*p='\315'; textin += 3;}
++                 else if(*(textin+2) == 'O' ){*p='\323'; textin += 3;}
++                 else if(*(textin+2) == 'U' ){*p='\332'; textin += 3;}
++                 else if(*(textin+2) == 'a' ){*p='\341'; textin += 3;}
++                 else if(*(textin+2) == 'e' ){*p='\351'; textin += 3;}
++                 else if(*(textin+2) == 'i' ){*p='\355'; textin += 3;}
++                 else if(*(textin+2) == 'o' ){*p='\363'; textin += 3;}
++                 else if(*(textin+2) == 'u' ){*p='\372'; textin += 3;}
++                 else *p= *textin++; 
++                 break;
++               case 'c':                         /* C cedilla*/
++                 if     (*(textin+2) == 'C' ){*p='\307'; textin += 3;}
++                 else if(*(textin+2) == 'c' ){*p='\347'; textin += 3;}
++                 else *p= *textin++; 
++                 break;
++               case 'g':                         /* Grave */
++                 if     (*(textin+2) == 'A' ){*p='\300'; textin += 3;}
++                 else if(*(textin+2) == 'E' ){*p='\310'; textin += 3;}
++                 else if(*(textin+2) == 'I' ){*p='\314'; textin += 3;}
++                 else if(*(textin+2) == 'O' ){*p='\322'; textin += 3;}
++                 else if(*(textin+2) == 'U' ){*p='\331'; textin += 3;}
++                 else if(*(textin+2) == 'a' ){*p='\340'; textin += 3;}
++                 else if(*(textin+2) == 'e' ){*p='\350'; textin += 3;}
++                 else if(*(textin+2) == 'i' ){*p='\354'; textin += 3;}
++                 else if(*(textin+2) == 'o' ){*p='\362'; textin += 3;}
++                 else if(*(textin+2) == 'u' ){*p='\371'; textin += 3;}
++                 else *p= *textin++; 
++                 break;
++               case 'm':                         /* A angstrom*/
++                 if     (*(textin+2) == 'A' ){*p='\305'; textin += 3;}
++                 else if(*(textin+2) == 'a' ){*p='\345'; textin += 3;}
++                 else *p= *textin++; 
++                 break;
++               case 'p':                         /* pound sterling */
++                 *p = '\243'; textin+=2;
++                 break;
++               case 's':                         /*  solidus */
++                 *p = '\267'; textin+=2;
++                 break;
++               case 't':                         /* Tilda */
++                 if     (*(textin+2) == 'A' ){*p='\303'; textin += 3;}
++                 else if(*(textin+2) == 'N' ){*p='\321'; textin += 3;}
++                 else if(*(textin+2) == 'O' ){*p='\325'; textin += 3;}
++                 else if(*(textin+2) == 'a' ){*p='\343'; textin += 3;}
++                 else if(*(textin+2) == 'n' ){*p='\361'; textin += 3;}
++                 else if(*(textin+2) == 'o' ){*p='\365'; textin += 3;}
++                 else *p= *textin++; 
++                 break;
++               case 'u':                         /* Umlaut */
++                 if     (*(textin+2) == 'A' ){*p='\304'; textin += 3;}
++                 else if(*(textin+2) == 'E' ){*p='\313'; textin += 3;}
++                 else if(*(textin+2) == 'I' ){*p='\317'; textin += 3;}
++                 else if(*(textin+2) == 'O' ){*p='\326'; textin += 3;}
++                 else if(*(textin+2) == 'U' ){*p='\334'; textin += 3;}
++                 else if(*(textin+2) == 'Y' ){*p='\335'; textin += 3;}
++                 else if(*(textin+2) == 'a' ){*p='\344'; textin += 3;}
++                 else if(*(textin+2) == 'e' ){*p='\353'; textin += 3;}
++                 else if(*(textin+2) == 'i' ){*p='\357'; textin += 3;}
++                 else if(*(textin+2) == 'o' ){*p='\366'; textin += 3;}
++                 else if(*(textin+2) == 'u' ){*p='\374'; textin += 3;}
++                 else if(*(textin+2) == 'y' ){*p='\375'; textin += 3;}
++                 else *p= *textin++; 
++                 break;
++               case 'x':                         /*  Circumflex */
++                 if     (*(textin+2) == 'A' ){*p='\302'; textin += 3;}
++                 else if(*(textin+2) == 'E' ){*p='\312'; textin += 3;}
++                 else if(*(textin+2) == 'I' ){*p='\316'; textin += 3;}
++                 else if(*(textin+2) == 'O' ){*p='\324'; textin += 3;}
++                 else if(*(textin+2) == 'U' ){*p='\333'; textin += 3;}
++                 else if(*(textin+2) == 'a' ){*p='\342'; textin += 3;}
++                 else if(*(textin+2) == 'e' ){*p='\352'; textin += 3;}
++                 else if(*(textin+2) == 'i' ){*p='\356'; textin += 3;}
++                 else if(*(textin+2) == 'o' ){*p='\364'; textin += 3;}
++                 else if(*(textin+2) == 'u' ){*p='\373'; textin += 3;}
++                 else *p= *textin++;
++                 break;
++               default:
++                 textin +=2; /* Skip the \x and ignore it */
++                 *p      = *textin++; /* Copy third character in group */
++                 break;
++             } /*End switch */
++             p++;
++         } else{
++             *p++ = *textin++; /* Finally a plain ordinary ASCII character */
++         }
++     } /* End for loop over string */
++     
++     *p=0;  /*end of string or file */
++   
++     return textout;
++ }
++ 
++ #endif
++ 
diff --git a/contrib/carmel/pine/mailview.c.patch b/contrib/carmel/pine/mailview.c.patch
new file mode 100644
index 00000000..5dc9c9af
--- /dev/null
+++ b/contrib/carmel/pine/mailview.c.patch
@@ -0,0 +1,39 @@
+*** mailview.c	Wed Aug 17 17:19:56 1994
+--- mailview.c.new	Wed Aug 31 19:04:19 1994
+***************
+*** 132,139 ****
+--- 132,147 ----
+  void	   redraw_scroll_text();
+  #endif
+  
++ #ifdef BWC
++ #ifdef ANSI
++ void	 gf_glyph2richtext(FILTER_S *, int, int);
++ #else
++ void	 gf_glyph2richtext();
++ #endif
++ #endif
+  
+  
++ 
+  /*----------------------------------------------------------------------
+       Format a buffer with the text of the current message for browser
+  
+***************
+*** 892,897 ****
+--- 900,914 ----
+      filter_t	       aux_filter[4];
+      int		       filtcnt = 0, error_found = 0;
+      char	      *err;
++ 
++ #ifdef BWC
++     if(att->body->subtype != NULL &&
++        strucmp(att->body->subtype, "X-bwc-glyph") == 0) {
++         aux_filter[filtcnt++] = gf_glyph2richtext;
++         gf_enriched2plain_opt(0);	/* don't strip everything! */
++ 	aux_filter[filtcnt++] = gf_enriched2plain;
++     }
++ #endif    
+  
+      if(att->body->subtype){
+  	if(!strucmp(att->body->subtype, "richtext")) {
diff --git a/contrib/carmel/pine/makefile.sun.patch b/contrib/carmel/pine/makefile.sun.patch
new file mode 100644
index 00000000..cab73d4a
--- /dev/null
+++ b/contrib/carmel/pine/makefile.sun.patch
@@ -0,0 +1,19 @@
+*** makefile.sun	Mon Jul 25 15:21:59 1994
+--- makefile.sun.new	Wed Aug 31 19:08:25 1994
+***************
+*** 59,65 ****
+  MAKE=        make
+  OPTIMIZE=    # -O
+  PROFILE=     # -pg
+! DEBUG=       -g -DDEBUG
+  
+  IMAPDIR=     ../c-client
+  PICODIR=     ../pico
+--- 59,65 ----
+  MAKE=        make
+  OPTIMIZE=    # -O
+  PROFILE=     # -pg
+! DEBUG=       -DBWC -g -DDEBUG
+  
+  IMAPDIR=     ../c-client
+  PICODIR=     ../pico
diff --git a/contrib/carmel/pine/makefile.ult.patch b/contrib/carmel/pine/makefile.ult.patch
new file mode 100644
index 00000000..a50e504d
--- /dev/null
+++ b/contrib/carmel/pine/makefile.ult.patch
@@ -0,0 +1,19 @@
+*** makefile.ult	Mon Jul 25 15:22:01 1994
+--- makefile.ult.new	Wed Aug 31 18:19:59 1994
+***************
+*** 67,73 ****
+  LIBES=       -ltermlib -lauth
+  LOCLIBES=    $(PICODIR)/libpico.a $(IMAPDIR)/c-client.a
+  
+! CFLAGS= -DULT $(OPTIMIZE) $(PROFILE) $(DEBUG) -DSYSTYPE=\"ULT\"
+  
+  obj=    addrbook.o adrbklib.o args.o context.o filter.o \
+  	folder.o help.o helptext.o imap.o init.o mailcap.o mailcmd.o \
+--- 67,73 ----
+  LIBES=       -ltermlib -lauth
+  LOCLIBES=    $(PICODIR)/libpico.a $(IMAPDIR)/c-client.a
+  
+! CFLAGS= -DBWC -DULT $(OPTIMIZE) $(PROFILE) $(DEBUG) -DSYSTYPE=\"ULT\"
+  
+  obj=    addrbook.o adrbklib.o args.o context.o filter.o \
+  	folder.o help.o helptext.o imap.o init.o mailcap.o mailcmd.o \
diff --git a/contrib/keypad.enable/ReadMe b/contrib/keypad.enable/ReadMe
new file mode 100644
index 00000000..927519ce
--- /dev/null
+++ b/contrib/keypad.enable/ReadMe
@@ -0,0 +1,7 @@
+These context diffs when applied to pico/tcap.c enable entrance
+and exit of "keypad mode".  This mode is especially useful (and 
+necessary!) for HP terminals which require this mode to make the 
+arrow keys useful.
+
+These changes are based on a bug report submitted by Jochiam Richter
+(zjr@rz.uni-jena.de).
diff --git a/contrib/keypad.enable/keypad.enable.diff b/contrib/keypad.enable/keypad.enable.diff
new file mode 100644
index 00000000..80643f0d
--- /dev/null
+++ b/contrib/keypad.enable/keypad.enable.diff
@@ -0,0 +1,122 @@
+*** pine/ttyout.c.REAL	Thu Dec 21 02:08:20 1995
+--- pine/ttyout.c	Sat Feb 10 15:47:12 1996
+***************
+*** 131,137 ****
+              *_startinsert, *_endinsert, *_insertchar, *_deletechar,
+              *_deleteline, *_insertline,
+              *_scrollregion, *_scrollup, *_scrolldown,
+!             *_termcap_init, *_termcap_end;
+  char  term_name[40];
+  #ifndef USE_TERMINFO
+  static char  _terminal[1024];         /* Storage for terminal entry */
+--- 131,138 ----
+              *_startinsert, *_endinsert, *_insertchar, *_deletechar,
+              *_deleteline, *_insertline,
+              *_scrollregion, *_scrollup, *_scrolldown,
+!             *_termcap_init, *_termcap_end,
+! 	    *_keypad_init, *_keypad_end;
+  char  term_name[40];
+  #ifndef USE_TERMINFO
+  static char  _terminal[1024];         /* Storage for terminal entry */
+***************
+*** 228,233 ****
+--- 229,236 ----
+      _termcap_end       = tigetstr("rmcup");
+      _lines	       = tigetnum("lines");
+      _columns	       = tigetnum("cols");
++     _keypad_init       = tigetnum("smkx");
++     _keypad_end	       = tigetnum("rmkx");
+      _ku                = tigetstr("kcuu1");
+      _kd                = tigetstr("kcud1");
+      _kl                = tigetstr("kcub1");
+***************
+*** 295,300 ****
+--- 298,305 ----
+      _termcap_end       = tgetstr("te", &ptr);
+      _lines	       = tgetnum("li");
+      _columns	       = tgetnum("co");
++     _keypad_init       = tgetstr("ks", &ptr);
++     _keypad_end	       = tgetstr("ke", &ptr);
+      _ku                = tgetstr("ku", &ptr);
+      _kd                = tgetstr("kd", &ptr);
+      _kl                = tgetstr("kl", &ptr);
+***************
+*** 435,440 ****
+--- 440,448 ----
+  	BeginScroll(0, ps_global->ttyo->screen_rows);
+  	fflush(stdout);
+      }
++ 
++     if(_keypad_init)
++       tputs(_keypad_init, 1, outchar);
+  }
+          
+  
+***************
+*** 510,515 ****
+--- 518,526 ----
+      MoveCursor(_lines - 2, 0);
+      if(_termcap_end != NULL)
+        tputs(_termcap_end, 1, outchar);
++ 
++     if(_keypad_end != NULL)
++       tputs(_keypad_end, 1, outchar);
+  
+      if(message){
+  	StartInverse();
+*** pico/tcap.c.REAL	Thu Dec 21 01:54:35 1995
+--- pico/tcap.c	Sat Feb 10 16:08:47 1996
+***************
+*** 92,98 ****
+  	*SF,			/* scroll text up */
+  	*SR,			/* scroll text down */
+  	*TI,			/* string to start termcap */
+!         *TE;			/* string to end termcap */
+  
+  
+  TERM term = {
+--- 92,100 ----
+  	*SF,			/* scroll text up */
+  	*SR,			/* scroll text down */
+  	*TI,			/* string to start termcap */
+!         *TE,			/* string to end termcap */
+! 	*KS,			/* string to enter application keypad mode */
+! 	*KE;			/* string to end application keypad mode */
+  
+  
+  TERM term = {
+***************
+*** 178,183 ****
+--- 180,187 ----
+      SR = tgetstr("sr", &p);
+      TI = tgetstr("ti", &p);
+      TE = tgetstr("te", &p);
++     KS = tgetstr("ks", &p);
++     KE = tgetstr("ke", &p);
+  
+      row = tgetnum("li");
+      if(row == -1){
+***************
+*** 399,404 ****
+--- 403,411 ----
+  	if (CS)
+  	  putpad(tgoto(CS, term.t_nrow, 0)) ;
+      }
++ 
++     if(KS && !Pmaster)			/* enter app/keypad mode (cursor) */
++       putpad(KS);
+  }
+  
+  
+***************
+*** 410,415 ****
+--- 417,425 ----
+  
+  	if(TE)				/* any cleanup termcap requires */
+  	  putpad(TE);
++ 
++ 	if(KE)
++ 	  putpad(KE);			/* end app/keypad mode */
+      }
+  
+      kbdestroy(pico_kbesc);		/* clean up key board sequence trie */
diff --git a/contrib/ports/aos/README b/contrib/ports/aos/README
new file mode 100644
index 00000000..6503853f
--- /dev/null
+++ b/contrib/ports/aos/README
@@ -0,0 +1,20 @@
+From tenser@snafu.eec.psu.edu Tue May  7 10:14:10 1996
+Date: Tue, 16 Apr 1996 14:57:45 -0000
+From: Dan Cross <tenser@snafu.eec.psu.edu>
+To: pine@cac.washington.edu
+Subject: Pine patches for the IBM RT (Pine 3.93, 4.3BSD)
+
+Hi there!
+   I ported pine 3.93 to the IBM RT running AOS using the BSD port.  (AOS
+is IBM's port of 4.3BSD to the RT architecture.)  There were only minor
+changes that had to be made to the source to get it running under AOS, so
+I just stuck with the BSD port.  (It seemed like a waste to change, since
+there was so much duplication between the BSD port and an AOS port.)
+   I wanted to send back the patches to you all to get them re-integrated
+into the main distribution so that the RT becomes a supported architecture.
+So, without further inane babble by myself, here they are.  Thanks!
+
+	- Dan C.
+
+(ps- if you would like my binaries to put up for FTP, let me know and I'll
+pack them up for ya'll!)
diff --git a/contrib/ports/aos/aos.diff b/contrib/ports/aos/aos.diff
new file mode 100644
index 00000000..a8858529
--- /dev/null
+++ b/contrib/ports/aos/aos.diff
@@ -0,0 +1,125 @@
+*** os_bsd.c.orig	Mon Apr 15 17:46:29 1996
+--- pine3.93/imap/non-ANSI/c-client/os_bsd.c	Mon Apr 15 14:02:14 1996
+***************
+*** 67,72 ****
+--- 67,74 ----
+  #include "memmove.c"
+  #include "strerror.c"
+  #include "strstr.c"
++ #ifndef	ibm032
+  #include "strtol.c"
++ #endif	/*  !ibm032  */
+  #include "strtoul.c"
+  #include "tz_bsd.c"
+*** os_bsd.h.orig	Mon Apr 15 17:46:31 1996
+--- pine3.93/imap/non-ANSI/c-client/os_bsd.h	Mon Apr 15 13:45:22 1996
+***************
+*** 40,46 ****
+--- 40,48 ----
+  #include <fcntl.h>
+  #include <syslog.h>
+  #include <sys/file.h>
++ #ifndef	ibm032
+  #include <machine/endian.h>	/* needed for htons() prototypes */
++ #endif	/*  !ibm032  */
+  
+  
+  char *getenv ();
+*** tz_bsd.c.orig	Mon Apr 15 17:46:32 1996
+--- pine3.93/imap/non-ANSI/c-client/tz_bsd.c	Mon Apr 15 16:22:38 1996
+***************
+*** 42,47 ****
+--- 42,61 ----
+  	char *s;
+  	void *t;
+  {
++ #ifndef	ibm032
+  				/* append timezone from tm struct */
+    sprintf (s + strlen (s)," (%s)",((struct tm *) t)->tm_zone);
++ #else
++ 	struct timeval	tv;
++ 	struct timezone	tz;
++ 
++ 	(void)memset((char *)&tv, 0, sizeof(tv));
++ 	(void)memset((char *)&tz, 0, sizeof(tz));
++ 
++ 	if (gettimeofday(&tv, &tz) < 0)
++ 		return;		/*  Silent error.  */
++ 
++ 	(void)sprintf(s + strlen(s), " (%s)",
++ 		timezone(tz.tz_minuteswest, tz.tz_dsttime));
++ #endif	/*  !ibm032  */
+  }
+*** other.c.orig	Mon Apr 15 17:47:02 1996
+--- pine3.93/pine/other.c	Mon Apr 15 15:18:02 1996
+***************
+*** 353,359 ****
+      pbuf.exittest      = sigedit_exit_for_pico;
+      pbuf.upload	       = (ps_global->VAR_UPLOAD_CMD
+  			  && ps_global->VAR_UPLOAD_CMD[0])
+! 			   ? upload_msg_to_pico : NULL;
+      pbuf.keybinit      = init_keyboard;
+      pbuf.helper        = helper;
+      pbuf.resize	       = resize_for_pico;
+--- 353,359 ----
+      pbuf.exittest      = sigedit_exit_for_pico;
+      pbuf.upload	       = (ps_global->VAR_UPLOAD_CMD
+  			  && ps_global->VAR_UPLOAD_CMD[0])
+! 			   ? (int(*)())upload_msg_to_pico : NULL;
+      pbuf.keybinit      = init_keyboard;
+      pbuf.helper        = helper;
+      pbuf.resize	       = resize_for_pico;
+*** send.c.orig	Mon Apr 15 17:47:12 1996
+--- pine3.93/pine/send.c	Mon Apr 15 15:36:46 1996
+***************
+*** 1656,1662 ****
+  #else
+      pbuf.upload	       = (ps_global->VAR_UPLOAD_CMD
+  			  && ps_global->VAR_UPLOAD_CMD[0])
+! 			  ? upload_msg_to_pico : NULL;
+  #endif
+  
+      pbuf.raw_io        = Raw;
+--- 1656,1662 ----
+  #else
+      pbuf.upload	       = (ps_global->VAR_UPLOAD_CMD
+  			  && ps_global->VAR_UPLOAD_CMD[0])
+! 			  ? (int (*)())upload_msg_to_pico : NULL;
+  #endif
+  
+      pbuf.raw_io        = Raw;
+*** tempfile.orig	Mon Apr 15 17:48:22 1996
+--- pine3.93/pine/osdep/tempfile	Mon Apr 15 15:39:52 1996
+***************
+*** 2,11 ****
+--- 2,31 ----
+     Create a temporary file, the name of which we don't care about 
+  and that goes away when it is closed.  Just like ANSI C tmpfile.
+    ----*/
++ #ifdef	ibm032
++ #define	FILENAMESIZE	20
++ #define	FILETMPLATE	"/tmp/ptmpXXXXXX"
++ #endif	/*  ibm032  */
++ 
+  FILE  *
+  create_tmpfile()
+  {
++ #ifndef	ibm032
+      return(tmpfile());
++ #else
++ 	char	buf[FILENAMESIZE];
++ 	int	fd;
++ 
++ 	(void)memset(buf, 0, FILENAMESIZE);
++ 	(void)strcpy(buf, FILETMPLATE);
++ 
++ 	if ((fd = mkstemp(buf)) < 0)
++ 		return(NULL);
++ 
++ 	(void)unlink(buf);
++ 
++ 	return(fdopen(fd, "w+"));
++ #endif	/*  !ibm032  */
+  }
+  
+  
diff --git a/contrib/ports/sequent_ptx_4.4.6 b/contrib/ports/sequent_ptx_4.4.6
new file mode 100644
index 00000000..064ed460
--- /dev/null
+++ b/contrib/ports/sequent_ptx_4.4.6
@@ -0,0 +1,188 @@
+
+Larry Mascarenhas <lmascare@cscinfo.com> found he had to make some changesx
+to get Pine 4.21 to compile on Sequent ptx v4.4.6. We didn't have time to
+integrate these into the distribution. He was kind enough to send us the
+diffs of what he had to do to make it work.
+
+
+
+diff -cr pine.dist/imap/src/osdep/unix/Makefile pine4.20/imap/src/osdep/unix/Makefile
+*** pine.dist/imap/src/osdep/unix/Makefile	Thu Sep 30 01:54:13 1999
+--- pine4.20/imap/src/osdep/unix/Makefile	Fri Nov 12 15:26:40 1999
+***************
+*** 418,424 ****
+  	 MAILSPOOL=/usr/mail \
+  	 RSHPATH=/usr/bin/resh \
+  	 BASECFLAGS="-Wc,-O3 -Wc,-seq -Dprivate=PRIVATE -DNFSKLUDGE" \
+! 	 BASELDFLAGS="-lseq -lsec -lsocket -linet -lnsl -lgen" \
+  	 RANLIB=true
+  
+  pyr:	# Pyramid
+--- 418,424 ----
+  	 MAILSPOOL=/usr/mail \
+  	 RSHPATH=/usr/bin/resh \
+  	 BASECFLAGS="-Wc,-O3 -Wc,-seq -Dprivate=PRIVATE -DNFSKLUDGE" \
+! 	 BASELDFLAGS="-lseq -lsec -lsocket -lnsl -lgen" \
+  	 RANLIB=true
+  
+  pyr:	# Pyramid
+diff -cr pine.dist/pico/makefile.ptx pine4.20/pico/makefile.ptx
+*** pine.dist/pico/makefile.ptx	Mon Jun 29 18:23:52 1998
+--- pine4.20/pico/makefile.ptx	Fri Nov 12 15:37:28 1999
+***************
+*** 42,48 ****
+  LIBARGS=	ru
+  RANLIB=		true
+  
+! LIBS=		$(EXTRALIBES) -ltermlib -linet
+  
+  OFILES=		attach.o basic.o bind.o browse.o buffer.o \
+  		composer.o display.o file.o fileio.o line.o pico_os.o \
+--- 42,48 ----
+  LIBARGS=	ru
+  RANLIB=		true
+  
+! LIBS=		$(EXTRALIBES) -ltermlib -lsocket -l nsl
+  
+  OFILES=		attach.o basic.o bind.o browse.o buffer.o \
+  		composer.o display.o file.o fileio.o line.o pico_os.o \
+diff -cr pine.dist/pine/cmplhelp.sh pine4.20/pine/cmplhelp.sh
+*** pine.dist/pine/cmplhelp.sh	Fri Feb 20 19:50:38 1998
+--- pine4.20/pine/cmplhelp.sh	Fri Nov 12 15:16:17 1999
+***************
+*** 49,55 ****
+  	s/-sed-backslash-quote-/\\"/g
+      ' |
+  
+! awk 'BEGIN         {in_text = 0;
+                      count = 0;
+                      printf("#include <stdio.h>\n#include \"headers.h\"\n\n\n");
+                     }
+--- 49,55 ----
+  	s/-sed-backslash-quote-/\\"/g
+      ' |
+  
+! nawk 'BEGIN         {in_text = 0;
+                      count = 0;
+                      printf("#include <stdio.h>\n#include \"headers.h\"\n\n\n");
+                     }
+diff -cr pine.dist/pine/cmplhlp2.sh pine4.20/pine/cmplhlp2.sh
+*** pine.dist/pine/cmplhlp2.sh	Wed Feb 18 20:46:52 1998
+--- pine4.20/pine/cmplhlp2.sh	Fri Nov 12 15:16:28 1999
+***************
+*** 44,50 ****
+  #
+  
+  
+! awk  ' BEGIN	{  printf("\n\n\t\t/*\n");
+                     printf("\t\t * AUTMATICALLY GENERATED FILE!\n");
+                     printf("\t\t * DO NOT EDIT!!\n\t\t */\n\n\n");
+                     printf("#define\tHelpType\tchar **\n");
+--- 44,50 ----
+  #
+  
+  
+! nawk  ' BEGIN	{  printf("\n\n\t\t/*\n");
+                     printf("\t\t * AUTMATICALLY GENERATED FILE!\n");
+                     printf("\t\t * DO NOT EDIT!!\n\t\t */\n\n\n");
+                     printf("#define\tHelpType\tchar **\n");
+diff -cr pine.dist/pine/mailtrfc.sh pine4.20/pine/mailtrfc.sh
+*** pine.dist/pine/mailtrfc.sh	Fri Mar 15 02:14:43 1996
+--- pine4.20/pine/mailtrfc.sh	Fri Nov 12 15:18:35 1999
+***************
+*** 47,53 ****
+  
+  
+  
+! org=`awk '/^domain/ {print $2}' < /etc/resolv.conf`
+  domain=`echo $org | sed -e 's/^[^.]*\.//'`
+  host=`hostname`".$org"
+  
+--- 47,53 ----
+  
+  
+  
+! org=`nawk '/^domain/ {print $2}' < /etc/resolv.conf`
+  domain=`echo $org | sed -e 's/^[^.]*\.//'`
+  host=`hostname`".$org"
+  
+***************
+*** 56,62 ****
+  echo "Hostname: $host"
+  
+  sed -n -e '/message-id/s/^.*</</p' |
+! awk 'BEGIN {mailers[0] =  "Other";
+              mailers[1] =  "Pine";
+              mailers[2] =  "MailManager";
+              mailers[3] =  "sendmail";
+--- 56,62 ----
+  echo "Hostname: $host"
+  
+  sed -n -e '/message-id/s/^.*</</p' |
+! nawk 'BEGIN {mailers[0] =  "Other";
+              mailers[1] =  "Pine";
+              mailers[2] =  "MailManager";
+              mailers[3] =  "sendmail";
+***************
+*** 115,121 ****
+  
+  
+  echo $host $org $domain | \
+!   awk '{printf("     %.17s %.11s %.11s  Off Campus        Total\n", $1, $2, $3)}'
+  egrep -v 'TOTAL|----|^-->' /tmp/syslogx.$$ | sort +0.60rn 
+  egrep  'TOTAL|----' /tmp/syslogx.$$
+  grep  '^-->' /tmp/syslogx.$$ | sed -e 's/-->//' > other-traffic
+--- 115,121 ----
+  
+  
+  echo $host $org $domain | \
+!   nawk '{printf("     %.17s %.11s %.11s  Off Campus        Total\n", $1, $2, $3)}'
+  egrep -v 'TOTAL|----|^-->' /tmp/syslogx.$$ | sort +0.60rn 
+  egrep  'TOTAL|----' /tmp/syslogx.$$
+  grep  '^-->' /tmp/syslogx.$$ | sed -e 's/-->//' > other-traffic
+diff -cr pine.dist/pine/send.c pine4.20/pine/send.c
+*** pine.dist/pine/send.c	Wed Oct  6 16:18:27 1999
+--- pine4.20/pine/send.c	Mon Nov 15 12:46:22 1999
+***************
+*** 50,56 ****
+  #include "../c-client/smtp.h"
+  #include "../c-client/nntp.h"
+  
+- 
+  #ifndef TCPSTREAM
+  #define TCPSTREAM void
+  #endif
+--- 50,55 ----
+***************
+*** 3933,3940 ****
+  		if((ps_global->post->pid = fork()) == 0){
+  		    /*
+  		     * Put us in new process group...
+- 		     */
+  		    setpgrp(0, ps_global->post->pid);
+  
+  		    /* BUG: should fix argv[0] to indicate what we're up to */
+  
+--- 3932,3940 ----
+  		if((ps_global->post->pid = fork()) == 0){
+  		    /*
+  		     * Put us in new process group...
+  		    setpgrp(0, ps_global->post->pid);
++ 		     */
++ 		    setpgrp();
+  
+  		    /* BUG: should fix argv[0] to indicate what we're up to */
+  
+diff -cr pine.dist/pine/signals.c pine4.20/pine/signals.c
+*** pine.dist/pine/signals.c	Tue Apr 20 20:25:18 1999
+--- pine4.20/pine/signals.c	Mon Nov 15 12:46:59 1999
+***************
+*** 53,58 ****
+--- 53,59 ----
+   ====*/
+  
+  #include "headers.h"
++ #undef sigmask
+  
+  /*
+   * call used by TERM and HUP handlers to quickly close streams
diff --git a/contrib/ports/vms/readme.1st b/contrib/ports/vms/readme.1st
new file mode 100644
index 00000000..42652494
--- /dev/null
+++ b/contrib/ports/vms/readme.1st
@@ -0,0 +1,9 @@
+
+To build the VMS version of pine, just move the VMSBUILD.COM command
+script into the top level pine directory.  If the script fails moving
+the pine-specific c-client build script (VMSBUILD_CCLIENT.COM) into
+place, just copy it by hand into the C-CLIENT.DIR it creates.  This
+RENAME was added just prior to release by the pine team and was not
+part of the contributed port.
+
+- The Pine Team
diff --git a/contrib/ports/vms/readme.vms b/contrib/ports/vms/readme.vms
new file mode 100644
index 00000000..da14481f
--- /dev/null
+++ b/contrib/ports/vms/readme.vms
@@ -0,0 +1,102 @@
+                    VMS readme for PINE/C-CLEINT/PICO
+                         ========================
+
+Building
+========
+
+  There are three executables:
+Pico/PICO.EXE: This is the stand-alone version of the editor.
+C-Client/MTEST: Testing program for debugging purposes.
+Pine/PINE: The pine...
+
+In order to build SET DEF into the top directory (i.e. the one above PINE.DIR,
+PICO.DIR, etc.) and then @VMSBUILD. It will rename the C-CLient directory and
+then compile Pico, C-Client and Pine.
+
+Optional parameters to the VMSBUILD command:
+
+NETLIB - Use the Netlib library. It must be preloaded into [.NETLIB]NETLIB.OLB
+MULTINET - Call Multinet's transport directly.
+
+If more than one option is used - separate them with coma and no spaces.
+
+There are a few warnnings during the link - ignore them...
+On VAX we have to link the objects themselves and can't use libraries since the
+linker/librarian lose the global variables; on AXP it is ok...
+
+
+Using
+=====
+  All the user needs is the PINE.EXE; Pine reads the mail from the user's
+VMS/MAIL files and send outgoing mail either via mail routines using some
+foreign protocol or via direct SMTP to some SMTP server (I preffer this
+metod). You use the latter by defining SMTP-SERVER field with some host.
+If you do not set it you must define PINE_MAIL_PROTOCOL to the prefix of
+the foreign protocol used. For example, if you use SMTP% you have to define
+it to SMTP.
+  The global PINE configuration file (if needed) is located at UTIL$:PINE.CONF;
+if you want to recompile it with a different name then modify PINE/OS.H;
+
+
+Why TcpIp communication is needed?
+==================================
+  It is not really needed, but helps much. It is needed in three places:
+1. Sending mail: You can either send mail using the xxx% mechanism by defning
+   PINE_MAIL_PROTOCOL; in this case no TcpIp is needed.
+   you can use another mechanism: Don't define the above but set some SMTP
+   server node name in PINE.CONF or .PINERC. In this case you need some
+   SMTP package.
+2. PINE can read NEWS via the NNTP protocol which runs over TcpIp...
+3. Remote nodes (usually PC) can access the IMAP daemon and PINE can access
+   remote IMAP servers using TcpIp.
+
+
+Restrictions
+============
+1. In order to not modify the source too much the handling of the special
+   INBOX folder was not modified. Hence, it always try to open the (empty)
+   INBOX folder instead of NEWMAIL.
+   It is possible to define in the system's wide PINE.CONF that
+   inbox-path=NEWMAIL. In this case NEWMAIL will be opened when PINE is
+   started. However, the user must not then switch to another folder as long
+   as NEWMAIL has items.
+2. WASTEBASKET folder is not used.
+3. .PINERC and .ADDRBOOK are fixed to the user's login directory and cannot
+   be defined to be elsewhere (the definition is ignored).
+4-100. Probably exists and I forgot to mention :-)
+
+
+IMAPD
+=====
+  IMAPD of version 3.89 is available with the old Pine VMS port from
+VMS.HUJI.AC.IL; the current version of IMAPD will be ported soon.
+
+
+NETLIB
+======
+  NETLIB can be obtained from PUBLIC.TGV.COM:/MADISON/NETLIB. NETLIB supports
+all the common TcpIp packages like Multinet, UCX, Fusion, Wollongong, etc.
+
+
+Suggested PINE.CONF file.
+=========================
+here is the PINE.CONF file we use here:
+
+# Our fully-qualified machine name:
+user-domain=vms.huji.ac.il
+
+# Where to connect to send outputgoing mail.
+smtp-server=vms.huji.ac.il
+
+# Which viewer to see GIF/JPEG/etc.
+image-viewer=xv
+
+# Which folder will be opened automatically when entering PINE. See note above.
+inbox-path=NEWMAIL
+
+
+Notes:
+=====
+1. Due to the readonly definition in the source files we use an external
+   #define to redefine it to something else. Due to that CTYPE.H fails, so
+   we use a private copy of it.
diff --git a/contrib/ports/vms/vms_link.opt b/contrib/ports/vms/vms_link.opt
new file mode 100644
index 00000000..0f454490
--- /dev/null
+++ b/contrib/ports/vms/vms_link.opt
@@ -0,0 +1 @@
+SYS$SHARE:VAXCRTL/SHARE
diff --git a/contrib/ports/vms/vms_multinet_link.opt b/contrib/ports/vms/vms_multinet_link.opt
new file mode 100644
index 00000000..5eb99104
--- /dev/null
+++ b/contrib/ports/vms/vms_multinet_link.opt
@@ -0,0 +1 @@
+MULTINET:MULTINET_SOCKET_LIBRARY/SHARE
diff --git a/contrib/ports/vms/vms_netlib_link.opt b/contrib/ports/vms/vms_netlib_link.opt
new file mode 100644
index 00000000..4bec72f1
--- /dev/null
+++ b/contrib/ports/vms/vms_netlib_link.opt
@@ -0,0 +1 @@
+netlib_shr/share
diff --git a/contrib/ports/vms/vmsbuild.com b/contrib/ports/vms/vmsbuild.com
new file mode 100644
index 00000000..e3f58ebc
--- /dev/null
+++ b/contrib/ports/vms/vmsbuild.com
@@ -0,0 +1,31 @@
+$! VMSBUILD.COM - Calls the subdirectories VMSBUILD.
+$! Can be called with options separated with commas and no spaces. The
+$! options are:
+$!
+$! NETLIB - For linking with Netlib. NETLIB.OLB must be pre-loaded into
+$!          [.NETLIb]NETLIB.OLB
+$! MULTINET - Used with Multinet transport (no NETLIB is used).
+$! HEBREW - Build the Hebrew version.
+$!
+$!
+$ IF F$EXISTS("[.IMAP.ANSI]C-CLIENT.DIR") THEN RENAME [.IMAP.ANSI]C-CLIENT.DIR [];
+$ IF F$EXISTS("[.CONTRIB.VMS]VMSBUILD_CCLIENT.COM") THEN RENAME [.CONTRIB.VMS]VMSBUILD_CCLIENT.COM [.C-CLIENT]VMSBUILD.COM;
+$ SET DEF [.PICO]
+$@VMSBUILD 'P1'
+$ SET DEF [-.C-CLIENT]
+$@VMSBUILD 'P1'
+$ SET DEF [-.PINE]
+$@VMSBUILD 'P1'
+$ SET DEF [-]
+$!
+$ TYPE SYS$INPUT:
+Executables can be found in:
+
+PICO/PICO.EXE - The stand-alone editor (not needed).
+C-CLIENT/MTEST.EXE - Interactive testing program (not needed).
+C-CLIENT/IMAPD.EXE - the IMAP daemon. Should be copied elsewhere and defined
+                     in the INETD.CONF file or equivalent.
+PINE/PINE.EXE - What you waited for...
+
+$!
+$ EXIT
diff --git a/contrib/ports/vms/vmsbuild_cclient.com b/contrib/ports/vms/vmsbuild_cclient.com
new file mode 100644
index 00000000..7d4c0a20
--- /dev/null
+++ b/contrib/ports/vms/vmsbuild_cclient.com
@@ -0,0 +1,103 @@
+$! Program:	Operating-system dependent routines -- VMS version
+$!
+$! Author:	Yehavi Bourvine, The Hebrew University of Jerusalem.
+$!		Internet: Yehavi@VMS.huji.ac.il
+$!
+$! Date:	2 August 1994
+$! Last Edited:	2 August 1994
+$!
+$! Copyright 1994 by the University of Washington
+$!
+$!  Permission to use, copy, modify, and distribute this software and its
+$! documentation for any purpose and without fee is hereby granted, provided
+$! that the above copyright notice appears in all copies and that both the
+$! above copyright notice and this permission notice appear in supporting
+$! documentation, and that the name of the University of Washington not be
+$! used in advertising or publicity pertaining to distribution of the software
+$! without specific, written prior permission.	This software is made available
+$! "as is", and
+$! THE UNIVERSITY OF WASHINGTON DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED,
+$! WITH REGARD TO THIS SOFTWARE, INCLUDING WITHOUT LIMITATION ALL IMPLIED
+$! WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, AND IN
+$! NO EVENT SHALL THE UNIVERSITY OF WASHINGTON BE LIABLE FOR ANY SPECIAL,
+$! INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+$! LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, TORT
+$! (INCLUDING NEGLIGENCE) OR STRICT LIABILITY, ARISING OUT OF OR IN CONNECTION
+$! WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+$!
+$! VMSBUILD.COM for C-CLIENT.
+$ CREATE LINKAGE.H
+$ DECK
+extern DRIVER imapdriver, nntpdriver, vmsmaildriver;
+$ EOD
+$ CREATE LINKAGE.C
+$ DECK
+    mail_link((DRIVER *)&imapdriver);
+    mail_link((DRIVER *)&nntpdriver);
+    mail_link((DRIVER *)&vmsmaildriver);
+$ EOD
+$!
+$ DEFINE SYS SYS$LIBRARY:		! Normal .H location.
+$ DEFINE NETINET SYS$LIBRARY:
+$ DEFINE ARPA SYS$LIBRARY:
+$!
+$ COPY OS_VMS.H OSDEP.H;
+$ COPY TCP_VMSN.C TCP_VMS.C;	! Default - no TcpIp support.
+$!
+$ CC_DEF = ",''P1'"
+$ LINK_OPT = ""
+$ IF P1 .EQS. "" THEN CC_DEF=""
+$ IF F$LOCATE("MULTINET", P1) .LT. F$LENGTH(P1)
+$ THEN
+$	DEFINE SYS MULTINET_ROOT:[MULTINET.INCLUDE.SYS],sys$library
+$	DEFINE NETINET MULTINET_ROOT:[MULTINET.INCLUDE.NETINET]
+$	DEFINE ARPA MULTINET_ROOT:[MULTINET.INCLUDE.ARPA]
+$	COPY TCP_VMSM.C TCP_VMS.C;	! Multinet support.
+$	LINK_OPT = ",[-.CONTRIB.VMS]VMS_MULTINET_LINK/OPTION"
+$ ENDIF
+$ IF F$LOCATE("NETLIB", P1) .LT. F$LENGTH(P1)
+$ THEN
+$	LINK_OPT = ",[-.CONTRIB.VMS]VMS_NETLIB_LINK/OPTION"
+$	COPY TCP_VMSL.C TCP_VMS.C;	! Netlib support.
+$ ENDIF
+$!
+$ CC_PREF = ""
+$ IF F$LOCATE("VAX", F$GETSYI("HW_NAME")) .EQS. F$LENGTH(F$GETSYI("HW_NAME"))
+$ THEN
+$	CC_PREF = "/PREFIX=(ALL,EXCEPT=(SOCKET,CONNECT,BIND,LISTEN,SOCKET_READ,SOCKET_WRITE,SOCKET_CLOSE,SELECT,ACCEPT,BCMP,BCOPY,BZERO,GETHOSTBYNAME,"
+$	CC_PREF = CC_PREF + "GETHOSTBYADDR,GETPEERNAME,GETDTABLESIZE,HTONS,HTONL,NTOHS,NTOHL,SEND,SENDTO,RECV,RECVFROM))"
+$	CC_PREF = CC_PREF + "/STANDARD=VAXC"
+$ ELSE
+$	CC_PREF = "/INCLUDE=[]"
+$	LINK_OPT = LINK_OPT + ",[-.CONTRIB.VMS]VMS_LINK/OPTION"
+$	COPY SYS$LIBRARY:CTYPE.H *.*;
+$	EDIT/EDT CTYPE.H
+s/readonly// w
+exit
+$ ENDIF
+$ SET VERIFY
+$ CC/NOOPTIMIZE'CC_PREF'/define=("readonly"="ReadOnly"'cc_def') OS_VMS
+$ CC/NOOPTIMIZE'CC_PREF'/define=("readonly"="ReadOnly"'cc_def') vms_mail
+$ CC/NOOPTIMIZE'CC_PREF'/define=("readonly"="ReadOnly"'cc_def') MAIL
+$ CC/NOOPTIMIZE'CC_PREF'/define=("readonly"="ReadOnly"'cc_def') SMTP
+$ CC/NOOPTIMIZE'CC_PREF'/define=("readonly"="ReadOnly"'cc_def') RFC822
+$ CC/NOOPTIMIZE'CC_PREF'/define=("readonly"="ReadOnly"'cc_def') NNTP
+$ CC/NOOPTIMIZE'CC_PREF'/define=("readonly"="ReadOnly"'cc_def') nntpcvms
+$ CC/NOOPTIMIZE'CC_PREF'/define=("readonly"="ReadOnly"'cc_def') MISC
+$ CC/NOOPTIMIZE'CC_PREF'/define=("readonly"="ReadOnly"'cc_def') IMAP2
+$ CC/NOOPTIMIZE'CC_PREF'/define=("readonly"="ReadOnly"'cc_def', -
+  L_SET=0) SM_VMS
+$!
+$ CC/NOOPTIMIZE'CC_PREF'/define=("readonly"="ReadOnly"'cc_def') MTEST
+$! CC/NOOPTIMIZE'CC_PREF'/define=("readonly"="ReadOnly"'cc_def') IMAPD
+$!
+$ LIBRARY/OBJECT/CREATE/INSERT C-CLIENT OS_VMS,vms_mail,MAIL,SMTP,RFC822,-
+	NNTP,nntpcvms,MISC,IMAP2,SM_VMS
+$!
+$ SET NOVERIFY
+$ LINK MTEST,IMAP2,MAIL,MISC,NNTP,nntpcvms,OS_VMS,RFC822,SMTP,-
+  SM_VMS,VMS_MAIL,SYS$INPUT:/OPTION'LINK_OPT'
+PSECT=_CTYPE_,NOWRT
+$! LINK IMAPD,imapd_vms,IMAP2,MAIL,MISC,NNTP,nntpcvms,OS_VMS,RFC822,SMTP,-
+$!   SM_VMS,VMS_MAIL'LINK_OPT'
+$ EXIT
diff --git a/contrib/smime/README b/contrib/smime/README
new file mode 100644
index 00000000..fc9c7895
--- /dev/null
+++ b/contrib/smime/README
@@ -0,0 +1,65 @@
+S/MIME capabilities in Pine
+
+Patch Author: Jonathan Paisley
+Contact Info: paisleyj@dcs.gla.ac.uk
+WWW: http://www.dcs.gla.ac.uk/~paisleyj/
+
+This patch adds S/MIME functionality to Pine.  It was
+last tested thoroughly with Pine 4.33, and it has been updated
+to work with the latest version (4.52).
+
+Check out the unix 'patch' command.  An example of using
+patch would be:
+
+$ cd ../..  # Change to top level directory (containing contrib, pine, etc)
+$ patch -p1 < contrib/smime/pine-smime-151101.diff
+
+*** After patching, read pine/README.smime for more details. ***
+
+The patch will create the following files:
+
+pine/README.smime
+pine/TODO.smime
+pine/bss_so.c
+pine/bss_so.h
+pine/smime.c
+pine/smime.h
+pine/smkeys.c
+pine/smkeys.h
+
+It will modify the following files:
+
+imap/src/c-client/mail.c
+imap/src/c-client/mail.h
+pine/filter.c
+pine/init.c
+pine/mailcmd.c
+pine/mailpart.c
+pine/mailview.c
+pine/makefile.lnx
+pine/makefile.so5
+pine/pine.h
+pine/pine.hlp
+pine/send.c
+
+Note that this patch has only been tested on Solaris and Linux (thus only
+those makefiles have been patched). The changes that have been made to
+the makefiles are as follows:
+
+    Add these SSL variables (these were roughly lifted from imap/src/osdep/unix/Makefile)
+
+    SSLDIR=      $(HOME)/local/ssl
+    SSLCERTS=    $(SSLDIR)/certs
+    SSLINCLUDE=  $(SSLDIR)/include
+    SSLLIB=      $(SSLDIR)/lib
+
+    SSLCFLAGS=   -I$(SSLINCLUDE) \
+	       -DSSL_CERT_DIRECTORY=\"$(SSLCERTS)\" \
+	       -DSMIME
+    SSLLDFLAGS=  -L$(SSLLIB) -lcrypto
+
+    Add $(SSLLDFLAGS) to the LIBS variable.
+    Add $(SSLCFLAGS) to the CFLAGS variable.
+    Add bss_so.o smime.o smkeys.o to the OFILES= variable.
+
+Similar changes would have to be made to the makefile for other ports.
diff --git a/contrib/smime/pine-smime-20030115.diff b/contrib/smime/pine-smime-20030115.diff
new file mode 100644
index 00000000..5744ce0d
--- /dev/null
+++ b/contrib/smime/pine-smime-20030115.diff
@@ -0,0 +1,3265 @@
+diff -Ncr pine4.53/imap/src/c-client/mail.c pine4.53-smime/imap/src/c-client/mail.c
+*** pine4.53/imap/src/c-client/mail.c	Thu Jan  2 17:28:42 2003
+--- pine4.53-smime/imap/src/c-client/mail.c	Wed Jan 15 12:48:15 2003
+***************
+*** 5198,5203 ****
+--- 5198,5207 ----
+  
+  void mail_free_body_data (BODY *body)
+  {
++   /* cleanup body if requested by application */
++   if (body->cleanup)
++     (*body->cleanup)(body);
++ 
+    switch (body->type) {		/* free contents */
+    case TYPEMULTIPART:		/* multiple part */
+      mail_free_body_part (&body->nested.part);
+diff -Ncr pine4.53/imap/src/c-client/mail.h pine4.53-smime/imap/src/c-client/mail.h
+*** pine4.53/imap/src/c-client/mail.h	Tue Jan  7 12:33:50 2003
+--- pine4.53-smime/imap/src/c-client/mail.h	Wed Jan 15 12:48:15 2003
+***************
+*** 655,660 ****
+--- 655,663 ----
+      unsigned long bytes;	/* size of text in octets */
+    } size;
+    char *md5;			/* MD5 checksum */
++ 
++   void *sparep;     	    	/* spare pointer reserved for main program */
++   void (*cleanup)(BODY *);  	/* cleanup function */
+  };
+  
+  
+diff -Ncr pine4.53/pine/README.smime pine4.53-smime/pine/README.smime
+*** pine4.53/pine/README.smime	Wed Dec 31 16:00:00 1969
+--- pine4.53-smime/pine/README.smime	Wed Jan 15 12:48:15 2003
+***************
+*** 0 ****
+--- 1,129 ----
++ Quick Start
++ ===========
++ 
++ To enable S/MIME support, ensure the SSL related lines in the platform
++ makefile are uncommented (they're all next to one another).
++ 
++ CA certificates are expected to be found in the OpenSSL 'cert' dir, in the
++ standard hashed format.
++ 
++ User Configuration
++ ==================
++ 
++ A directory '~/.pine-smime' must be created. Within this, a further 
++ three directories are required:
++ 
++     ~/.pine-smime/
++                   ca/
++                   private/
++                   public/
++ 
++ Other people's certificate files should be copied into the 'public' directory.
++ Your certificate file(s) should be copied into the 'private' directory.
++ Certificates for any additional trusted CAs should be put in the 'ca' directory.
++ 
++ There are three extra configuration options:
++ 
++     sign-default-on
++     encrypt-default-on
++     remember-smime-passphrase
++ 
++ Certificates
++ ============
++ 
++ The certificate files specified above should have the following form:
++ 
++     public certificates: user@emaildomain.crt
++     private keys:        user@emaildomain.key
++ 
++ Thus, a typical installation might look like this:
++ 
++     ~/.pine-smime/
++                   ca/
++                           [additional trusted CAs here]
++                   private/
++                           paisleyj@dcs.gla.ac.uk.crt
++                           paisleyj@dcs.gla.ac.uk.key			  
++                   public/
++                           myfriend@dcs.gla.ac.uk.crt
++                           myotherfriend@dcs.gla.ac.uk.crt
++ 
++ Implementation Details
++ ======================
++ 
++ Link with the OpenSSL crypto library for PKCS7 support.
++ Only tested on linux (slx) and solaris (so5).
++ 
++ Added three extra source files (+headers):
++ 
++     smime.c 	Main S/MIME support code
++     smkeys.c	Very basic X509 key handling/storage (using the above dirs)
++     bss_so.c	OpenSSL BIO using pine STORE_S objects
++ 
++ Patches to existing pine sources:
++ 
++     init.c
++     	    	Add references to new configuration options.
++ 
++     mailcmd.c
++     	    	Add implementation of MC_DECRYPT command which prompts
++ 		the user for a passphrase if it's required.
++  
++     mailpart.c
++     	    	Comment added to help me remember what I'd done.
++     
++     mailview.c
++     	    	Added description of Decrypt menu option.
++ 		Make calls out to smime.c functions to handle the decryption.
++ 		This is done shortly after the BODY of a message is 
++ 		obtained.
++ 		Added function to describe encrypted messages when they're
++ 		being displayed.
++ 		Added code to describe the special case of PKCS7 attachments.
++     
++     makefile.lnx
++     makefile.so5
++     	    	Added SSL variables etc.
++ 
++     pine.h
++     	    	Add enumerations for new configuration options and definition
++ 		of MC_DECRYPT command
++     	    	Exported the prototype of pine_write_body_header,
++ 		pine_rfc822_output_body and pine_encode_body since they're
++ 		needed in smime.c.
++     
++     pine.hlp
++     	    	Added help info for new configuration options.
++     
++     send.c
++     	    	Added 'Encrypt' and 'Sign' menu options when sending email.
++     	    	Make calls to smime.c functions to fiddle message on the 
++ 		way out.
++ 		Extend pine_encode_body so it makes a few more checks
++ 		before adding a boundary.
++ 
++ Basic method:
++ 
++     Incoming
++ 
++     Scan BODY of viewed message before it is formatted. If it contains 
++     PKCS7 parts, decode them and attempt to decrypt/verify signatures. The
++     original BODY is fiddled in place and turned into a multipart body
++     with one subpart -- the decrypted data. This may consist of a multipart
++     with attachments, for example.
++     
++     This all depends on stashing a pointer to the decrypted data in 
++     body->contents.text.data and relying on the fact that the mail_* routines
++     will use this data in preference to fetching it over the network. We
++     also depend on it not being garbage collected while the message is 
++     being viewed!
++     
++     Outgoing
++     
++     smime.c pre-builds the message using pine_encode_body, pine_write_body_header
++     and pine_rfc822_output_body, encrypting/signing the resulting data. The
++     body that was going to be sent is then fiddled appropriately after
++     the PKCS7 objects have been built.
++     
++ paisleyj@dcs.gla.ac.uk
++ Mar 7 2001
+diff -Ncr pine4.53/pine/TODO.smime pine4.53-smime/pine/TODO.smime
+*** pine4.53/pine/TODO.smime	Wed Dec 31 16:00:00 1969
+--- pine4.53-smime/pine/TODO.smime	Wed Jan 15 12:48:15 2003
+***************
+*** 0 ****
+--- 1,31 ----
++ 
++     Need to be able to view stored certificates to see details
++     (particularly the fingerprint for comparing over the phone, say)
++     	--> proper key management system
++ 
++     Add client private key and certificate request generation.
++ 
++     Send certificate for CA along with certificate of signer.
++ 
++     Verify recipient certificate before sending encrypted message.
++ 
++     Verify certificates in general.
++ 
++     Cache the result of pre-formatting the message during the send/encrypt/sign
++     phase rather than letting call_mailer re-format it all over again.
++ 
++     Tidy up the use of global variables considerably.
++ 
++     Intelligently pick a certificate for signing purposes based on the
++     From address rather than just picking the first one on the list.
++ 
++     Figure out platform dependancies from using readdir() in smkeys.c
++ 
++     Handle message/rfc822 sub-parts!
++ 
++     Consider what happens with all our cached data.
++     
++     S/MIME info screen help.
++ 
++ paisleyj@dcs.gla.ac.uk
++ Mar 7 2001
+diff -Ncr pine4.53/pine/bss_so.c pine4.53-smime/pine/bss_so.c
+*** pine4.53/pine/bss_so.c	Wed Dec 31 16:00:00 1969
+--- pine4.53-smime/pine/bss_so.c	Wed Jan 15 12:48:15 2003
+***************
+*** 0 ****
+--- 1,184 ----
++ #ifdef SMIME
++ 
++ /*
++     bss_so.c
++     
++     Basic implementation of an OpenSSL BIO which is
++     backed by a pine STORE_S object
++  */
++ 
++ #include "headers.h"
++ 
++ #include <stdio.h>
++ #include <errno.h>
++ #include <openssl/bio.h>
++ #include <openssl/err.h>
++ 
++ static int bss_so_write(BIO *h, char *buf, int num);
++ static int bss_so_read(BIO *h, char *buf, int size);
++ static int bss_so_puts(BIO *h, char *str);
++ static int bss_so_gets(BIO *h, char *str, int size);
++ static long bss_so_ctrl(BIO *h, int cmd, long arg1, char *arg2);
++ static int bss_so_new(BIO *h);
++ static int bss_so_free(BIO *data);
++ static BIO_METHOD methods_sop =
++     {
++ 	BIO_TYPE_MEM,
++ 	"Storage Object",
++ 	bss_so_write,
++ 	bss_so_read,
++ 	bss_so_puts,
++ 	bss_so_gets,
++ 	bss_so_ctrl,
++ 	bss_so_new,
++ 	bss_so_free,
++ 	NULL,
++     };
++ 
++ BIO *BIO_new_so(STORE_S *so)
++ {
++     BIO *ret;
++ 
++     if ((ret = BIO_new(&methods_sop)) == NULL)
++         return (NULL);
++ 
++     BIO_set_fp(ret, (FILE*) so, 0);
++     return (ret);
++ }
++ 
++ 
++ static int bss_so_new(BIO *bi)
++ {
++     bi->init = 0;
++     bi->num = 0;
++     bi->ptr = NULL;
++     return (1);
++ }
++ 
++ static int bss_so_free(BIO *a)
++ {
++     if (a == NULL) return (0);
++     if (a->shutdown) {
++         if ((a->init) && (a->ptr != NULL)) {
++             a->ptr = NULL;
++         }
++         a->init = 0;
++     }
++     return (1);
++ }
++ 
++ static int bss_so_read(BIO *b, char *out, int outl)
++ {
++     int ret = 0;
++     STORE_S *so = (STORE_S*) b->ptr;
++ 
++     if (b->init && (out != NULL)) {
++ 
++         while (ret < outl) {
++             if (!so->readc((unsigned char *)out, so))
++                 break;
++             out++;
++             ret++;
++         }
++ 
++     }
++     return (ret);
++ }
++ 
++ static int bss_so_write(BIO *b, char *in, int inl)
++ {
++     int ret = 0;
++ 
++     if (b->init && (in != NULL)) {
++         if (so_nputs((STORE_S *)b->ptr, in, inl))
++             ret = inl;
++ 
++     }
++     return (ret);
++ }
++ 
++ static long bss_so_ctrl(BIO *b, int cmd, long num, char *ptr)
++ {
++     long ret = 1;
++     STORE_S *so = (STORE_S *)b->ptr;
++     FILE **fpp;
++     char p[4];
++ 
++     switch (cmd) {
++         case BIO_C_FILE_SEEK:
++         case BIO_CTRL_RESET:
++             ret = so_seek(so, num, 0);
++             break;
++         case BIO_CTRL_EOF:
++             ret = 0;
++             break;
++         case BIO_C_FILE_TELL:
++         case BIO_CTRL_INFO:
++             ret = 0;
++             break;
++         case BIO_C_SET_FILE_PTR:
++             bss_so_free(b);
++             b->shutdown = (int)num & BIO_CLOSE;
++             b->ptr = (char *)ptr;
++             b->init = 1;
++             break;
++         case BIO_C_SET_FILENAME:
++             ret = 0;
++             break;
++         case BIO_C_GET_FILE_PTR:
++             if (ptr != NULL) {
++                 fpp = (FILE **)ptr;
++                 *fpp = (FILE *)NULL;
++             }
++             break;
++         case BIO_CTRL_GET_CLOSE:
++             ret = (long)b->shutdown;
++             break;
++         case BIO_CTRL_SET_CLOSE:
++             b->shutdown = (int)num;
++             break;
++         case BIO_CTRL_FLUSH:
++             break;
++         case BIO_CTRL_DUP:
++             ret = 1;
++             break;
++ 
++         case BIO_CTRL_WPENDING:
++         case BIO_CTRL_PENDING:
++         case BIO_CTRL_PUSH:
++         case BIO_CTRL_POP:
++         default:
++             ret = 0;
++             break;
++     }
++     return (ret);
++ }
++ 
++ static int bss_so_gets(BIO *bp, char *buf, int size)
++ {
++     int ret = 0;
++     char	*b = buf;
++     char	*bend = buf + size - 1;
++     STORE_S *so = (STORE_S*) bp->ptr;
++ 
++     do {
++         if (!so->readc((unsigned char *)b, so))
++             break;
++         b++;
++     } while (b < bend && b[ -1] != '\n');
++ 
++     *b = 0;
++ 
++     ret = b - buf;
++     return (ret);
++ }
++ 
++ static int bss_so_puts(BIO *bp, char *str)
++ {
++     STORE_S *so = (STORE_S*) bp->ptr;
++ 
++     return so->puts(so, str);
++ }
++ 
++ 
++ #endif /* SMIME */
+diff -Ncr pine4.53/pine/bss_so.h pine4.53-smime/pine/bss_so.h
+*** pine4.53/pine/bss_so.h	Wed Dec 31 16:00:00 1969
+--- pine4.53-smime/pine/bss_so.h	Wed Jan 15 12:48:15 2003
+***************
+*** 0 ****
+--- 1 ----
++ BIO *BIO_new_so(STORE_S *so);
+diff -Ncr pine4.53/pine/filter.c pine4.53-smime/pine/filter.c
+*** pine4.53/pine/filter.c	Wed Jan  8 12:13:50 2003
+--- pine4.53-smime/pine/filter.c	Wed Jan 15 12:48:15 2003
+***************
+*** 903,909 ****
+  
+  
+  /* get a character from a file */
+! /* assumes gf_out struct is filled in */
+  int
+  gf_freadc(c)
+  unsigned char *c;
+--- 903,909 ----
+  
+  
+  /* get a character from a file */
+! /* assumes gf_in struct is filled in */
+  int
+  gf_freadc(c)
+  unsigned char *c;
+***************
+*** 938,944 ****
+  
+  
+  /* get a character from a string, return nonzero if things OK */
+! /* assumes gf_out struct is filled in */
+  int
+  gf_sreadc(c)
+  unsigned char *c;
+--- 938,944 ----
+  
+  
+  /* get a character from a string, return nonzero if things OK */
+! /* assumes gf_in struct is filled in */
+  int
+  gf_sreadc(c)
+  unsigned char *c;
+diff -Ncr pine4.53/pine/init.c pine4.53-smime/pine/init.c
+*** pine4.53/pine/init.c	Mon Jan  6 19:39:16 2003
+--- pine4.53-smime/pine/init.c	Wed Jan 15 12:48:15 2003
+***************
+*** 2445,2451 ****
+  	 F_MARK_FCC_SEEN, h_config_mark_fcc_seen, PREF_SEND},
+  	{"use-sender-not-x-sender",
+  	 F_USE_SENDER_NOT_X, h_config_use_sender_not_x, PREF_SEND},
+! 
+  /* Folder */
+  	{"combined-subdirectory-display",
+  	 F_CMBND_SUBDIR_DISP, h_config_combined_subdir_display, PREF_FLDR},
+--- 2445,2458 ----
+  	 F_MARK_FCC_SEEN, h_config_mark_fcc_seen, PREF_SEND},
+  	{"use-sender-not-x-sender",
+  	 F_USE_SENDER_NOT_X, h_config_use_sender_not_x, PREF_SEND},
+! #ifdef SMIME
+! 	{"sign-default-on",
+! 	 F_SIGN_DEFAULT_ON, h_config_sign_default_on, PREF_SEND},
+! 	{"encrypt-default-on",
+! 	 F_ENCRYPT_DEFAULT_ON, h_config_encrypt_default_on, PREF_SEND},
+! 	{"remember-smime-passphrase",
+! 	 F_REMEMBER_SMIME_PASSPHRASE, h_config_remember_smime_passphrase, PREF_SEND},
+! #endif
+  /* Folder */
+  	{"combined-subdirectory-display",
+  	 F_CMBND_SUBDIR_DISP, h_config_combined_subdir_display, PREF_FLDR},
+diff -Ncr pine4.53/pine/mailcmd.c pine4.53-smime/pine/mailcmd.c
+*** pine4.53/pine/mailcmd.c	Fri Jan 10 15:29:29 2003
+--- pine4.53-smime/pine/mailcmd.c	Wed Jan 15 12:48:15 2003
+***************
+*** 53,58 ****
+--- 53,59 ----
+  #include "headers.h"
+  #include "../c-client/imap4r1.h"
+  
++ #include "smime.h"
+  
+  /*
+   * Internal Prototypes
+***************
+*** 1439,1444 ****
+--- 1440,1458 ----
+  	break;
+  
+  
++ #ifdef SMIME
++           /*------- Try to decrypt message -----------*/
++ 	case MC_DECRYPT:
++ 	    if (g_need_passphrase)
++ 		get_passphrase();
++ 	    a_changed = TRUE;
++ 	break;
++ 
++ 	case MC_SECURITY:
++     	    state->next_screen = smime_info_screen;
++ 	break;
++ #endif
++ 		
+            /*------- Bounce -----------*/
+        case MC_BOUNCE :
+  	cmd_bounce(state, msgmap, 0);
+diff -Ncr pine4.53/pine/mailpart.c pine4.53-smime/pine/mailpart.c
+*** pine4.53/pine/mailpart.c	Wed Nov 27 15:22:54 2002
+--- pine4.53-smime/pine/mailpart.c	Wed Jan 15 12:48:15 2003
+***************
+*** 4534,4539 ****
+--- 4534,4545 ----
+      frd->flags   = flags;
+      frd->size    = size;
+      frd->readc	 = fetch_readc;
++ 	
++     /*	The call to imap_cache below will return true in the case where
++ 	we've already stashed fake data in the content of the part.
++ 	This happens when an S/MIME message is decrypted.
++      */
++ 	
+      if(modern_imap_stream(stream)
+         && !imap_cache(stream, msgno, section, NULL, NULL)
+         && size > INIT_FETCH_CHUNK
+diff -Ncr pine4.53/pine/mailview.c pine4.53-smime/pine/mailview.c
+*** pine4.53/pine/mailview.c	Tue Jan  7 16:17:00 2003
+--- pine4.53-smime/pine/mailview.c	Wed Jan 15 12:48:15 2003
+***************
+*** 47,52 ****
+--- 47,53 ----
+  
+  
+  #include "headers.h"
++ #include "smime.h"
+  
+  
+  /*----------------------------------------------------------------------
+***************
+*** 207,214 ****
+--- 208,220 ----
+  
+  	HELP_MENU,
+  	OTHER_MENU,
++ #ifdef SMIME
++ 	{"^D","Decrypt", {MC_DECRYPT,1,{ctrl('d')},KS_NONE}},
++ 	{"^E","Security", {MC_SECURITY,1,{ctrl('e')},KS_NONE}},
++ #else
+  	NULL_MENU,
+  	NULL_MENU,
++ #endif
+  	RCOMPOSE_MENU,
+  	NULL_MENU,
+  	NULL_MENU,
+***************
+*** 227,232 ****
+--- 233,240 ----
+  #define BOUNCE_KEY		33
+  #define FLAG_KEY		34
+  #define VIEW_PIPE_KEY		35
++ #define DECRYPT_KEY		(VIEW_PIPE_KEY + 3)
++ #define SECURITY_KEY		(DECRYPT_KEY + 1)
+  
+  static struct key simple_text_keys[] =
+         {HELP_MENU,
+***************
+*** 432,437 ****
+--- 440,447 ----
+  	else
+  	  ps->unseen_in_view = !mc->seen;
+  
++ 	flags = 0;
++ 
+  #if	defined(DOS) && !defined(WIN32)
+  	/* 
+  	 * Handle big text for DOS here.
+***************
+*** 459,465 ****
+  			 ps->ttyo->screen_rows - (SCROLL_LINES_ABOVE(ps)
+  						  + SCROLL_LINES_BELOW(ps)));
+  
+! 	flags = FM_DISPLAY;
+  	if((last_message_viewed != mn_get_cur(ps->msgmap)
+  	    || last_was_full_header == 1))
+  	  flags |= FM_NEW_MESS;
+--- 469,475 ----
+  			 ps->ttyo->screen_rows - (SCROLL_LINES_ABOVE(ps)
+  						  + SCROLL_LINES_BELOW(ps)));
+  
+! 	flags |= FM_DISPLAY;
+  	if((last_message_viewed != mn_get_cur(ps->msgmap)
+  	    || last_was_full_header == 1))
+  	  flags |= FM_NEW_MESS;
+***************
+*** 467,472 ****
+--- 477,488 ----
+  	if(offset)		/* no pre-paint during resize */
+  	  view_writec_killbuf();
+  
++ #ifdef SMIME
++ 	/* Attempt to handle S/MIME bodies */
++ 	if (fiddle_smime_message(body,raw_msgno,(flags&FM_NEW_MESS)!=0))
++ 	 flags |= FM_NEW_MESS; /* body was changed, force a reload */
++ #endif
++ 
+  #ifdef _WINDOWS
+  	mswin_noscrollupdate(1);
+  #endif
+***************
+*** 541,546 ****
+--- 557,567 ----
+  
+  	if(F_OFF(F_ENABLE_FULL_HDR, ps_global))
+  	  clrbitn(VIEW_FULL_HEADERS_KEY, scrollargs.keys.bitmap);
++ 	  
++ #ifdef SMIME
++ 	if (!g_need_passphrase)
++ 	  clrbitn(DECRYPT_KEY, scrollargs.keys.bitmap);
++ #endif
+  
+  	if(!handles){
+  	    /*
+***************
+*** 754,760 ****
+--- 775,821 ----
+  }
+  
+  
++ #ifdef SMIME
++ /*----------------------------------------------------------------------
++     Add descriptive lines to the top of a message being formatted
++     that describe the status of any S/MIME enclosures that
++     have been encountered.
++     
++   Args: body   -- top-level body of the message being described
++         pc -- output function for writing to the message display
++ 
++   ----*/
++ static int describe_smime_bodies(BODY *body,gf_io_t pc)
++ {
++     PART      *part;
++     int result = 0;
++    
++     if (!body)
++     	return result;
++     
++     if (body->type == TYPEMULTIPART) {
++     
++     	if (body->subtype && strucmp(body->subtype,"x-pkcs7-enclosure")==0) {
++ 
++     	    if (body->description) {
++         	format_editorial(body->description,ps_global->ttyo->screen_cols,pc);
++ 		gf_puts(NEWLINE,pc);
++ 		result = 1;
++ 	    }
+  
++ 	    for (part=body->nested.part; part; part=part->next) {
++ 		result |= describe_smime_bodies(&(part->body),pc);
++ 	    }
++ 	
++ 	}
++     } else if (body->type == TYPEMESSAGE && 
++     	    body->subtype && strucmp(body->subtype, "rfc822")==0) {
++ 	result |= describe_smime_bodies(body->nested.msg->body,pc);
++     }
++     
++     return result;
++ }
++ #endif
+  
+  /*----------------------------------------------------------------------
+      Add lines to the attachments structure
+***************
+*** 1677,1682 ****
+--- 1738,1751 ----
+  
+      show_parts = 0;
+  
++ #ifdef SMIME
++     if (flgs & FM_DISPLAY) {
++         if (describe_smime_bodies(body,pc)) {
++ 	    gf_puts(NEWLINE, pc);
++ 	}
++     }
++ #endif
++ 
+      /*======== Now loop through formatting all the parts =======*/
+      for(a = ps_global->atmts; a->description != NULL; a++) {
+  
+***************
+*** 6150,6155 ****
+--- 6219,6236 ----
+  
+      t = &tmp_20k_buf[strlen(tmp_20k_buf)];
+  
++ #ifdef SMIME
++     if (is_pkcs7_body(body) && type!=3) { /* if smime and not attempting print */
++ 
++     	sstrcpy(&t,"\015\012");
++ 	
++     	sstrcpy(&t,
++     	"This part is a PKCS7 S/MIME enclosure. "
++ 	"You may be able to view it by entering the correct passphrase "
++     	"with the \"^D\" command. Press \"^E\" for more information.");
++     
++     } else 
++ #endif
+      if(type){
+  	sstrcpy(&t, "\015\012");
+  	switch(type) {
+diff -Ncr pine4.53/pine/makefile.lnx pine4.53-smime/pine/makefile.lnx
+*** pine4.53/pine/makefile.lnx	Tue Sep 10 14:34:39 2002
+--- pine4.53-smime/pine/makefile.lnx	Wed Jan 15 12:48:15 2003
+***************
+*** 60,79 ****
+  LDAPOFILES=   addrbook.o adrbkcmd.o args.o bldaddr.o init.o \
+  	      mailview.o other.o pine.o strings.o takeaddr.o
+  
+  STDLIBS=     -lncurses
+  LOCLIBS=     $(PICODIR)/libpico.a $(CCLIENTDIR)/c-client.a
+  LIBS=        $(LOCLIBS) $(LDAPLIBS) $(STDLIBS) \
+               `cat $(CCLIENTDIR)/LDFLAGS`
+  
+  STDCFLAGS=   -DLNX -DSYSTYPE=\"LNX\" -DMOUSE
+  CFLAGS=      $(OPTIMIZE) $(PROFILE) $(DEBUG) $(EXTRACFLAGS) $(LDAPCFLAGS) \
+  	     $(STDCFLAGS)
+  
+  OFILES=	addrbook.o adrbkcmd.o adrbklib.o args.o bldaddr.o context.o filter.o \
+  	folder.o help.o helptext.o imap.o init.o mailcap.o mailcmd.o \
+  	mailindx.o mailpart.o mailview.o newmail.o other.o pine.o \
+  	reply.o screen.o send.o signals.o status.o strings.o takeaddr.o \
+! 	os.o
+  
+  HFILES=	headers.h os.h pine.h context.h helptext.h \
+  	$(PICODIR)/headers.h $(PICODIR)/estruct.h \
+--- 60,92 ----
+  LDAPOFILES=   addrbook.o adrbkcmd.o args.o bldaddr.o init.o \
+  	      mailview.o other.o pine.o strings.o takeaddr.o
+  
++ SSLDIR=      $(HOME)/local/ssl
++ SSLCERTS=    $(SSLDIR)/certs
++ SSLINCLUDE=  $(SSLDIR)/include
++ SSLLIB=      $(SSLDIR)/lib
++ 
++ SSLCFLAGS=   -I$(SSLINCLUDE) \
++ 	     -DSSL_CERT_DIRECTORY=\"$(SSLCERTS)\" \
++ 	     -DSMIME
++ SSLLDFLAGS=  -L$(SSLLIB) -lcrypto
++ 
++ 
+  STDLIBS=     -lncurses
+  LOCLIBS=     $(PICODIR)/libpico.a $(CCLIENTDIR)/c-client.a
+  LIBS=        $(LOCLIBS) $(LDAPLIBS) $(STDLIBS) \
++              $(SSLLDFLAGS) \
+               `cat $(CCLIENTDIR)/LDFLAGS`
+  
+  STDCFLAGS=   -DLNX -DSYSTYPE=\"LNX\" -DMOUSE
+  CFLAGS=      $(OPTIMIZE) $(PROFILE) $(DEBUG) $(EXTRACFLAGS) $(LDAPCFLAGS) \
++  	     $(SSLCFLAGS) \
+  	     $(STDCFLAGS)
+  
+  OFILES=	addrbook.o adrbkcmd.o adrbklib.o args.o bldaddr.o context.o filter.o \
+  	folder.o help.o helptext.o imap.o init.o mailcap.o mailcmd.o \
+  	mailindx.o mailpart.o mailview.o newmail.o other.o pine.o \
+  	reply.o screen.o send.o signals.o status.o strings.o takeaddr.o \
+! 	os.o bss_so.o smime.o smkeys.o
+  
+  HFILES=	headers.h os.h pine.h context.h helptext.h \
+  	$(PICODIR)/headers.h $(PICODIR)/estruct.h \
+***************
+*** 135,137 ****
+--- 148,154 ----
+  		osdep/sendmail osdep/execview \
+  		osdep/postreap.wtp osdep/os-lnx.ic
+  		cd osdep; $(MAKE) includer os-lnx.c; cd ..
++ 
++ jon.o: jon.c
++ 	$(CC) $(CFLAGS) -Wall -Wstrict-prototypes  -c $< -o $@
++ 
+diff -Ncr pine4.53/pine/makefile.so5 pine4.53-smime/pine/makefile.so5
+*** pine4.53/pine/makefile.so5	Tue Oct 23 15:24:51 2001
+--- pine4.53-smime/pine/makefile.so5	Wed Jan 15 12:48:15 2003
+***************
+*** 62,67 ****
+--- 62,78 ----
+  LDAPOFILES=   addrbook.o adrbkcmd.o args.o bldaddr.o init.o \
+  	      mailview.o other.o pine.o strings.o takeaddr.o
+  
++ SSLDIR=      $(HOME)/local/ssl
++ SSLCERTS=    $(SSLDIR)/certs
++ SSLINCLUDE=  $(SSLDIR)/include
++ SSLLIB=      $(SSLDIR)/lib
++ 
++ SSLCFLAGS=   -I$(SSLINCLUDE) \
++              -DSSL_CERT_DIRECTORY=\"$(SSLCERTS)\" \
++ 	     -DSMIME
++ SSLLDFLAGS=  -L$(SSLLIB) -lcrypto
++ 
++ 
+  # LDCC= /usr/bin/cc
+  # If you don't have /usr/bin/cc (our Solaris 2.2 doesn't seem to have it,
+  # it only has /usr/ucb/cc) then change LDCC to the following line and
+***************
+*** 72,88 ****
+  STDLIBS=     -ltermlib
+  LOCLIBS=     $(PICODIR)/libpico.a $(CCLIENTDIR)/c-client.a
+  LIBS=        $(LOCLIBS) $(LDAPLIBS) $(STDLIBS) \
+               `cat $(CCLIENTDIR)/LDFLAGS`
+  
+  STDCFLAGS=   -Dconst= -DSV4 -DSYSTYPE=\"SOL\" -DMOUSE
+  CFLAGS=      $(OPTIMIZE) $(PROFILE) $(DEBUG) $(EXTRACFLAGS) $(LDAPCFLAGS) \
+  	     $(STDCFLAGS)
+  
+  OFILES=	addrbook.o adrbkcmd.o adrbklib.o args.o bldaddr.o context.o filter.o \
+  	folder.o help.o helptext.o imap.o init.o mailcap.o mailcmd.o \
+  	mailindx.o mailpart.o mailview.o newmail.o other.o pine.o \
+  	reply.o screen.o send.o signals.o status.o strings.o takeaddr.o \
+! 	os.o
+  
+  HFILES=	headers.h os.h pine.h context.h helptext.h \
+  	$(PICODIR)/headers.h $(PICODIR)/estruct.h \
+--- 83,101 ----
+  STDLIBS=     -ltermlib
+  LOCLIBS=     $(PICODIR)/libpico.a $(CCLIENTDIR)/c-client.a
+  LIBS=        $(LOCLIBS) $(LDAPLIBS) $(STDLIBS) \
++              $(SSLLDFLAGS) \
+               `cat $(CCLIENTDIR)/LDFLAGS`
+  
+  STDCFLAGS=   -Dconst= -DSV4 -DSYSTYPE=\"SOL\" -DMOUSE
+  CFLAGS=      $(OPTIMIZE) $(PROFILE) $(DEBUG) $(EXTRACFLAGS) $(LDAPCFLAGS) \
++  	     $(SSLCFLAGS) \
+  	     $(STDCFLAGS)
+  
+  OFILES=	addrbook.o adrbkcmd.o adrbklib.o args.o bldaddr.o context.o filter.o \
+  	folder.o help.o helptext.o imap.o init.o mailcap.o mailcmd.o \
+  	mailindx.o mailpart.o mailview.o newmail.o other.o pine.o \
+  	reply.o screen.o send.o signals.o status.o strings.o takeaddr.o \
+! 	os.o bss_so.o smime.o smkeys.o
+  
+  HFILES=	headers.h os.h pine.h context.h helptext.h \
+  	$(PICODIR)/headers.h $(PICODIR)/estruct.h \
+diff -Ncr pine4.53/pine/pine.h pine4.53-smime/pine/pine.h
+*** pine4.53/pine/pine.h	Fri Jan 10 15:25:55 2003
+--- pine4.53-smime/pine/pine.h	Wed Jan 15 12:48:15 2003
+***************
+*** 1134,1139 ****
+--- 1134,1144 ----
+  	F_DISABLE_SHARED_NAMESPACES,
+  	F_EXPOSE_HIDDEN_CONFIG,
+  	F_ALT_COMPOSE_MENU,
++ #ifdef SMIME
++ 	F_SIGN_DEFAULT_ON,
++ 	F_ENCRYPT_DEFAULT_ON,
++ 	F_REMEMBER_SMIME_PASSPHRASE,
++ #endif
+  	F_ALWAYS_SPELL_CHECK,
+  	F_QUELL_TIMEZONE,
+  	F_COLOR_LINE_IMPORTANT,
+***************
+*** 2031,2036 ****
+--- 2036,2043 ----
+      } cmdline_val;		/* user typed as cmdline arg                */
+  };
+  
++ #define MC_DECRYPT 800
++ #define MC_SECURITY 801
+  
+  
+  /*
+***************
+*** 4368,4373 ****
+--- 4375,4383 ----
+  char	   *pine_send_status PROTO((int, char *, char *, int *));
+  void	    phone_home PROTO((char *));
+  void	    pine_free_body PROTO((BODY **));
++ int	    pine_write_body_header PROTO((BODY *, soutr_t, TCPSTREAM *));
++ long        pine_rfc822_output_body PROTO((BODY *,soutr_t,TCPSTREAM *));
++ void       pine_encode_body PROTO((BODY *));
+  void	    simple_header_parse PROTO((char *, char **, char **));
+  int	    valid_subject PROTO((char *, char **, char **,BUILDER_ARG *,int *));
+  long	    new_mail_for_pico PROTO((int, int));
+diff -Ncr pine4.53/pine/pine.hlp pine4.53-smime/pine/pine.hlp
+*** pine4.53/pine/pine.hlp	Wed Jan 15 11:55:09 2003
+--- pine4.53-smime/pine/pine.hlp	Wed Jan 15 12:48:15 2003
+***************
+*** 24338,24340 ****
+--- 24338,24347 ----
+  ========== h_select_by_smaller_size ==========
+  Enter a number or ^C to cancel. All messages less than this many characters
+  in size will be selected. Examples: 2176, 1.53K (1530), or 3M (3000000).
++ ========== h_config_sign_default_on ==========
++ If enabled, the 'Sign' option will default to on when sending messages.
++ ========== h_config_encrypt_default_on ==========
++ If enabled, the 'Encrypt' option will default to on when sending messages.
++ ========== h_config_remember_smime_passphrase ==========
++ If enabled, you will only have to enter your passphrase for your private key
++ once during a pine session.
+diff -Ncr pine4.53/pine/send.c pine4.53-smime/pine/send.c
+*** pine4.53/pine/send.c	Tue Jan 14 13:22:59 2003
+--- pine4.53-smime/pine/send.c	Wed Jan 15 12:48:15 2003
+***************
+*** 50,55 ****
+--- 50,56 ----
+  #include "../c-client/smtp.h"
+  #include "../c-client/nntp.h"
+  
++ #include "smime.h"
+  
+  #ifndef TCPSTREAM
+  #define TCPSTREAM void
+***************
+*** 5490,5495 ****
+--- 5491,5513 ----
+  	opts[i++].label = "";
+      }
+  
++ #ifdef SMIME
++     {
++     	opts[i].ch  	= 'e';
++ 	opts[i].rval	= 'e';
++ 	opts[i].name	= "E";
++ 	opts[i++].label	= "Encrypt";
++     
++     	opts[i].ch  	= 'g';
++ 	opts[i].rval	= 'g';
++ 	opts[i].name	= "G";
++ 	opts[i++].label	= "Sign";
++     
++ 	g_do_encrypt = F_ON(F_ENCRYPT_DEFAULT_ON,ps_global);
++ 	g_do_sign = F_ON(F_SIGN_DEFAULT_ON,ps_global);
++     }		
++ #endif
++ 
+      opts[i].ch = -1;
+      no_help = (i >= 12);
+  
+***************
+*** 5574,5579 ****
+--- 5592,5627 ----
+  	    sstrcpy(&optp, dsn_string);
+  	}
+  
++ #ifdef SMIME
++     	if (g_do_encrypt) {
++ 	    if(!lparen){
++ 	      *optp++ = ' ';
++ 	      *optp++ = '(';
++ 	      lparen++;
++ 	    }
++ 	    else{
++ 		*optp++ = ',';
++ 		*optp++ = ' ';
++ 	    }
++ 
++ 	    sstrcpy(&optp, "Encrypted");
++ 	}
++ 	
++     	if (g_do_sign) {
++ 	    if(!lparen){
++ 	      *optp++ = ' ';
++ 	      *optp++ = '(';
++ 	      lparen++;
++ 	    }
++ 	    else{
++ 		*optp++ = ',';
++ 		*optp++ = ' ';
++ 	    }
++ 
++ 	    sstrcpy(&optp, "Signed");
++ 	}
++ #endif
++ 
+  	if(lparen)
+  	  *optp++ = ')';
+  
+***************
+*** 5675,5680 ****
+--- 5723,5734 ----
+  	     * body on failure.
+  	     */
+  	    dsn_requested = (DSN_SHOW | DSN_SUCCESS | DSN_DELAY | DSN_FULL);
++ #ifdef SMIME
++ 	} else if (rv=='e') {
++ 	    g_do_encrypt = !g_do_encrypt;
++ 	} else if (rv=='g') {
++ 	    g_do_sign = !g_do_sign;
++ #endif
+  	}
+  
+  	sprintf(dsn_string, "DSN requested[%s%s%s%s]",
+***************
+*** 6418,6423 ****
+--- 6472,6478 ----
+      char	*verbose_file = NULL;
+      BODY	*bp = NULL;
+      PINEFIELD	*pf;
++     BODY    	*origBody = body;
+  
+  #define MAX_ADDR_ERROR 2  /* Only display 2 address errors */
+  
+***************
+*** 6434,6439 ****
+--- 6489,6518 ----
+  	return(0);
+      }
+  
++ 
++ #ifdef SMIME
++     if (g_do_encrypt || g_do_sign) {
++     	int result;
++ 	
++     	STORE_S *so = lmc.so;
++ 	lmc.so = NULL;
++     
++     	result = 1;
++     
++     	if (g_do_encrypt)
++     	    result = encrypt_outgoing_message(header,&body);
++ 	
++ 	/* need to free new body from encrypt if sign fails? */
++ 	if (result && g_do_sign)
++ 	    result = sign_outgoing_message(header,&body,g_do_encrypt);
++ 	
++ 	lmc.so = so;
++ 	
++ 	if (!result)
++ 	    return 0;
++     }
++ #endif
++ 
+      /* set up counts and such to keep track sent percentage */
+      send_bytes_sent = 0;
+      gf_filter_init();				/* zero piped byte count, 'n */
+***************
+*** 6742,6747 ****
+--- 6821,6844 ----
+        mail_free_envelope(&fake_env);
+  
+    done:
++   
++ #ifdef SMIME
++     /* Free replacement encrypted body */
++     if (body != origBody) {
++     
++     	if (body->type==TYPEMULTIPART) {
++ 	    /* Just get rid of first part, it's actually origBody */
++ 	    void *x = body->nested.part;
++ 	    
++ 	    body->nested.part = body->nested.part->next;
++ 	    
++ 	    fs_give(&x);
++ 	}
++     
++     	pine_free_body(&body);
++     }
++ #endif
++   
+      if(we_cancel)
+        cancel_busy_alarm(0);
+  
+***************
+*** 8721,8733 ****
+    dprint(4, (debugfile, "-- pine_encode_body: %d\n", body ? body->type : 0));
+    if (body) switch (body->type) {
+    case TYPEMULTIPART:		/* multi-part */
+!     if (!body->parameter) {	/* cookie not set up yet? */
+        char tmp[MAILTMPLEN];	/* make cookie not in BASE64 or QUOTEPRINT*/
+        sprintf (tmp,"%ld-%ld-%ld=:%ld",gethostid (),random (),time (0),
+  	       getpid ());
+!       body->parameter = mail_newbody_parameter ();
+!       body->parameter->attribute = cpystr ("BOUNDARY");
+!       body->parameter->value = cpystr (tmp);
+      }
+      part = body->nested.part;	/* encode body parts */
+      do pine_encode_body (&part->body);
+--- 8818,8834 ----
+    dprint(4, (debugfile, "-- pine_encode_body: %d\n", body ? body->type : 0));
+    if (body) switch (body->type) {
+    case TYPEMULTIPART:		/* multi-part */
+!     if (!body->parameter || strucmp(body->parameter->attribute,"BOUNDARY")!=0) {	/* cookie not set up yet? */
+        char tmp[MAILTMPLEN];	/* make cookie not in BASE64 or QUOTEPRINT*/
++       PARAMETER *param;
++       
+        sprintf (tmp,"%ld-%ld-%ld=:%ld",gethostid (),random (),time (0),
+  	       getpid ());
+!       param = mail_newbody_parameter ();
+!       param->next = body->parameter;
+!       param->attribute = cpystr ("BOUNDARY");
+!       param->value = cpystr (tmp);
+!       body->parameter = param;
+      }
+      part = body->nested.part;	/* encode body parts */
+      do pine_encode_body (&part->body);
+diff -Ncr pine4.53/pine/smime.c pine4.53-smime/pine/smime.c
+*** pine4.53/pine/smime.c	Wed Dec 31 16:00:00 1969
+--- pine4.53-smime/pine/smime.c	Wed Jan 15 12:48:15 2003
+***************
+*** 0 ****
+--- 1,1776 ----
++ /*
++     File:   	    smime.c
++     Author: 	    paisleyj@dcs.gla.ac.uk
++     Date:   	    01/2001
++     
++     Description:
++     	    	    This file contains all the low-level functions
++ 		    required for dealing with S/MIME objects.
++ 		    
++ 		    References are made to the functions in this file 
++ 		    from the following locations:
++ 		    
++ 		    	mailview.c:part_desc()  -> is_pkcs7_body()
++ 			send.c:call_mailer()	-> encrypt_outgoing_message()
++ 			send.c:call_mailer()	-> sign_outgoing_message()
++ 			mailcmd.c:process_cmd() -> get_passphrase()
++ 			mailcmd.c:process_cmd() -> smime_info_screen()
++  */
++ 
++ #ifdef SMIME
++ 
++ #include "headers.h"
++ 
++ #include <stdio.h>
++ #include <stdlib.h>
++ #include <string.h>
++ #include <time.h>
++ 
++ #include <openssl/err.h>
++ #include <openssl/objects.h>
++ #include <openssl/evp.h>
++ 
++ #include <openssl/x509.h>
++ #include <openssl/pkcs7.h>
++ #include <openssl/pem.h>
++ #include <openssl/rand.h>
++ 
++ #include "bss_so.h"
++ #include "smkeys.h"
++ #include "smime.h"
++ 
++ #define PINE_SMIME_DIRNAME ".pine-smime"
++ 
++ /*  Set true if loading a key failed due to lack of passphrase.
++     Queried in mailcmd.c:process_cmd() before calling get_passphrase()
++  */
++ int 	    	g_need_passphrase = 0;
++ /*  User has entered a passphrase */
++ static int 	s_entered_passphrase = 0;
++ /*  Storage for the entered passphrase */
++ static char	    	s_passphrase[80];
++ static char	    	*s_passphrase_emailaddr;
++ 
++ /*  Set true if encrypting/signing (respectively)
++     Referenced from send.c:call_mailer() and send.c:send_exit_for_pico
++  */
++ int 	    	g_do_encrypt;
++ int 	    	g_do_sign;
++ 
++ /*  Full pathname to ~/.pine-smime */
++ static char 	*g_pine_smime_dir;
++ 
++ static BIO	*bio_err;
++ 
++ /*  Linked list of PERSONAL_CERT objects */
++ static PERSONAL_CERT *s_personal_certs;
++ 
++ static X509_STORE   *s_cert_store;
++ 
++ /* State management for randomness functions below */
++ static int seeded = 0;
++ static int egdsocket = 0;
++ 
++ /* Forget any cached private keys */
++ static void forget_private_keys()
++ {
++     PERSONAL_CERT   *pcert;
++     
++     for (pcert=s_personal_certs; pcert; pcert=pcert->next) {
++     	
++     	if (pcert->key) {
++ 	    EVP_PKEY_free(pcert->key);
++ 	    pcert->key = NULL;
++ 	}
++     }
++ }
++ 
++ /* taken from openssl/apps/app_rand.c */
++ static int app_RAND_load_file(const char *file, BIO *bio_e, int dont_warn)
++ {
++     int consider_randfile = (file == NULL);
++     char buffer[200];
++ 
++     if (file == NULL)
++ 	    file = RAND_file_name(buffer, sizeof buffer);
++     else if (RAND_egd(file) > 0)
++     {
++ 	/* we try if the given filename is an EGD socket.
++ 	   if it is, we don't write anything back to the file. */
++ 	egdsocket = 1;
++ 	return 1;
++     }
++     if (file == NULL || !RAND_load_file(file, -1))
++     {
++ 	if (RAND_status() == 0 && !dont_warn)
++ 	{
++ 	    BIO_printf(bio_e,"unable to load 'random state'\n");
++ 	    BIO_printf(bio_e,"This means that the random number generator has not been seeded\n");
++ 	    BIO_printf(bio_e,"with much random data.\n");
++ 	    if (consider_randfile) /* explanation does not apply when a file is explicitly named */
++ 	    {
++ 		BIO_printf(bio_e,"Consider setting the RANDFILE environment variable to point at a file that\n");
++ 		BIO_printf(bio_e,"'random' data can be kept in (the file will be overwritten).\n");
++ 	    }
++ 	}
++ 	return 0;
++     }
++     seeded = 1;
++     return 1;
++ }
++ 
++ /* copied and fiddled from pine/imap/src/osdep/unix/auth_ssl.c */
++ static void openssl_extra_randomness(void)
++ {
++ #if !defined(WIN32)
++     int fd;
++     unsigned long i;
++     char tmp[MAXPATH];
++     struct stat sbuf;
++ 				/* if system doesn't have /dev/urandom */
++     if (stat ("/dev/urandom",&sbuf)) {
++       if ((fd = open (tmpnam (tmp),O_WRONLY|O_CREAT,0600)) < 0)
++ 	i = (unsigned long) tmp;
++       else {
++ 	unlink (tmp);		/* don't need the file */
++ 	fstat (fd,&sbuf);	/* get information about the file */
++ 	i = sbuf.st_ino;	/* remember its inode */
++ 	close (fd);		/* or its descriptor */
++       }
++ 				/* not great but it'll have to do */
++       sprintf (tmp + strlen (tmp),"%.80s%lx%lx%lx",
++ 	       tcp_serverhost (),i,
++ 	       (unsigned long) (time (0) ^ gethostid ()),
++ 	       (unsigned long) getpid ());
++       RAND_seed (tmp,strlen (tmp));
++     }
++ #endif
++ }
++ 
++ /* taken from openssl/apps/app_rand.c */
++ static int app_RAND_write_file(const char *file, BIO *bio_e)
++ {
++     char buffer[200];
++ 
++     if (egdsocket || !seeded)
++ 	/* If we did not manage to read the seed file,
++ 	 * we should not write a low-entropy seed file back --
++ 	 * it would suppress a crucial warning the next time
++ 	 * we want to use it. */
++ 	return 0;
++ 
++     if (file == NULL)
++ 	    file = RAND_file_name(buffer, sizeof buffer);
++     if (file == NULL || !RAND_write_file(file))
++     {
++ 	BIO_printf(bio_e,"unable to write 'random state'\n");
++ 	return 0;
++     }
++     return 1;
++ }
++ 
++ /* Installed as an atexit() handler to save the random data */
++ static void openssl_deinit(void)
++ {
++     app_RAND_write_file(NULL, bio_err);
++ }
++ 
++ /* Initialise openssl stuff if needed */
++ static void openssl_init(void)
++ {
++     static int inited = 0;
++ 
++     if (!inited) {
++ 
++         char	*p;
++         char	buf[MAXPATH];
++ 
++     	/* Find where that .pine-smime thing is */
++ 	/* Perhaps we should just use the user's home directory as a start? */
++         p = last_cmpnt(ps_global->pinerc);
++         buf[0] = '\0';
++         if(p != NULL) {
++             strncpy(buf, ps_global->pinerc, min(p - ps_global->pinerc, sizeof(buf)-1));
++             buf[min(p - ps_global->pinerc, sizeof(buf)-1)] = '\0';
++         }
++ 
++         strncat(buf, PINE_SMIME_DIRNAME, sizeof(buf)-1-strlen(buf));
++     	buf[sizeof(buf)-1] = 0;
++ 
++         if (can_access(buf, ACCESS_EXISTS)==0) {
++ 
++             g_pine_smime_dir = cpystr(buf);
++             s_cert_store = get_ca_store(g_pine_smime_dir);
++             s_personal_certs = get_personal_certs(g_pine_smime_dir);
++ 	    
++         } else g_pine_smime_dir = ""; /* prevent null dereference later */
++ 
++         SSLeay_add_all_algorithms();
++         ERR_load_crypto_strings();
++ 
++     	/* this won't make any sense (since the terminal's in a funny mode) */
++         if ((bio_err=BIO_new(BIO_s_file())) != NULL)
++             BIO_set_fp(bio_err,stderr,BIO_NOCLOSE|BIO_FP_TEXT);
++ 
++ 	app_RAND_load_file(NULL, bio_err, 1);
++ 
++     	openssl_extra_randomness();
++ 
++     	/* save the rand file when we're done */
++ 	atexit(openssl_deinit);
++ 
++         inited = 1;
++     }
++     
++     ERR_clear_error();
++ }
++ 
++ /*  Get a pointer to a string describing the most recent OpenSSL error.
++     It's statically allocated, so don't change or attempt to free it.
++  */
++ static const char *openssl_error_string(void)
++ {
++     char	*errs;
++     const char	*data = NULL;
++     long errn;
++ 
++     errn = ERR_peek_error_line_data(NULL, NULL, &data, NULL);
++     errs = (char*)ERR_reason_error_string(ERR_GET_REASON(errn));
++ 
++     if (errs)
++     	return errs;
++     else if (data)
++     	return data;
++ 
++     return "unknown error";
++ }
++ 
++ /* Return true if the body looks like a PKCS7 object */
++ int is_pkcs7_body(BODY *body)
++ {
++     int result;
++ 
++     result = body->type==TYPEAPPLICATION &&
++              body->subtype &&
++              (strucmp(body->subtype,"pkcs7-mime")==0 ||
++               strucmp(body->subtype,"x-pkcs7-mime")==0 ||
++ 	      strucmp(body->subtype,"pkcs7-signature")==0 ||
++ 	      strucmp(body->subtype,"x-pkcs7-signature")==0);
++ 
++     return result;
++ }
++ 
++ /* debug utility to dump the contents of a BIO to a file */
++ static void dump_bio_to_file(BIO *in,char *filename)
++ {
++     char iobuf[4096];
++     int len;
++     BIO *out;
++     
++     out = BIO_new_file(filename,"w");
++     
++     if (out) {
++     	BIO_reset(in);
++     
++ 	while ((len = BIO_read(in, iobuf, sizeof(iobuf))) > 0)
++ 	    BIO_write(out, iobuf, len);
++     	BIO_free(out);
++     }
++ }
++ 
++ /* prompt the user for their passphrase 
++     (possibly prompting with the email address in s_passphrase_emailaddr)
++  */
++ int get_passphrase(void)
++ {
++     int rc;
++     int	flags;
++     char prompt[50];
++     HelpType help = NO_HELP;
++ 
++     sprintf(prompt,
++             "Enter passphrase for <%s>: ",s_passphrase_emailaddr ? s_passphrase_emailaddr : "unknown");
++ 
++     do {
++         flags = OE_PASSWD | OE_DISALLOW_HELP;
++         rc =  optionally_enter(s_passphrase, -FOOTER_ROWS(ps_global), 0, sizeof(s_passphrase),
++                                prompt, NULL, help, &flags);
++     } while (rc!=0 && rc!=1 && rc>0);
++ 
++     if (rc==0)
++         s_entered_passphrase = 1;
++ 
++     return rc==0;
++ }
++ 
++ /*  Recursively stash a pointer to the decrypted data in our
++     manufactured body.
++  */
++ static void create_local_cache(char *base,BODY *b)
++ {
++     if (b->type==TYPEMULTIPART) {
++         PART	*p;
++ 
++ #if 0 
++         cpytxt(&b->contents.text, base + b->contents.offset, b->size.bytes);
++ #else
++     	/* don't really want to copy the real body contents. It shouldn't be
++ 	   used, and in the case of a message with attachments, we'll be 
++ 	   duplicating the files multiple times
++ 	 */
++     	cpytxt(&b->contents.text, "BODY UNAVAILABLE", 16);
++ #endif
++ 
++         for (p=b->nested.part;p;p=p->next) {
++             create_local_cache(base,(BODY*) p);
++         }
++     } else {
++         cpytxt(&b->contents.text, base + b->contents.offset, b->size.bytes);
++     }
++ }
++ 
++ static long rfc822_output_func(void *stream,char *string)
++ {
++     STORE_S *so = (STORE_S*) stream;
++ 
++     return so_puts(so,string)!=0;
++ }
++ 
++ /*  Load a private key from the given file */
++ static EVP_PKEY *load_key(char *file, char *pass)
++ {
++     BIO *in;
++     EVP_PKEY *key;
++     if(!(in = BIO_new_file(file, "r"))) return NULL;
++     key = PEM_read_bio_PrivateKey(in, NULL,NULL,pass);
++     BIO_free(in);
++     return key;
++ }
++ 
++ /*  Attempt to load the private key for the given PERSONAL_CERT.
++     This sets the appropriate passphrase globals in order to
++     interact with the user correctly.
++  */
++ static int load_private_key(PERSONAL_CERT *pcert)
++ {
++     if (!pcert->key) {
++     
++     	/* Try empty password by default */
++     	char	*password = "";
++     
++     	if (g_need_passphrase) {
++ 	    /* We've already been in here and discovered we need a different password */
++ 	    
++ 	    if (s_entered_passphrase)
++     	    	password = s_passphrase; /* Use the passphrase if it's been entered */
++ 	    else return 0;
++ 	}
++ 
++         ERR_clear_error();
++ 
++         if(!(pcert->key = load_key(pcert->file, password))) {
++             long err = ERR_get_error();
++ 
++     	    /* Couldn't load key... */
++ 
++     	    if (s_entered_passphrase) {
++ 
++     	    	/* The user got the password wrong maybe? */
++ 
++         	if ((ERR_GET_LIB(err)==ERR_LIB_EVP && ERR_GET_REASON(err)==EVP_R_BAD_DECRYPT) ||
++                 	(ERR_GET_LIB(err)==ERR_LIB_PEM && ERR_GET_REASON(err)==PEM_R_BAD_DECRYPT))
++                     q_status_message(SM_ORDER | SM_DING,1,1,"Wrong password");
++         	else q_status_message1(SM_ORDER,1,1,"Couldn't read key: %s",(char*)openssl_error_string());
++     	    	
++ 		/* This passphrase is no good; forget it */
++ 		s_entered_passphrase = 0;
++ 	    }
++ 	    
++ 	    /* Indicate to the UI that we need re-entry (see mailcmd.c:process_cmd())*/
++ 	    g_need_passphrase = 1;
++ 	    
++ 	    fs_give((void**) &s_passphrase_emailaddr);
++ 	    s_passphrase_emailaddr = get_x509_subject_email(pcert->cert);
++             return 0;
++         } else {
++ 	    /* This key will be cached, so we won't be called again */
++ 	    s_entered_passphrase = 0;
++ 	    g_need_passphrase = 0;
++ 	}
++ 	
++ 	return 1;
++     }
++     
++     return 0;
++ }
++ 
++ static void setup_pkcs7_body_for_signature(BODY *b,char *description,char *type,char *filename)
++ {
++     b->type = TYPEAPPLICATION;
++     b->subtype = cpystr(type);
++     b->encoding = ENCBINARY;
++ 
++     b->description = cpystr(description);
++ 
++     b->disposition.type = cpystr("attachment");
++     b->disposition.parameter = mail_newbody_parameter();
++     b->disposition.parameter->attribute = cpystr("filename");
++     b->disposition.parameter->value = cpystr(filename);
++ 
++     b->parameter = mail_newbody_parameter();
++     b->parameter->attribute = cpystr("name");
++     b->parameter->value = cpystr(filename);
++ }
++ 
++ /*
++     Look for a personal certificate matching the 
++     given address
++  */
++ PERSONAL_CERT *match_personal_cert_to_email(ADDRESS *a)
++ {
++     PERSONAL_CERT   *pcert;
++     char	buf[MAXPATH];
++     char    	*email;
++ 
++     if (!a || !a->mailbox || !a->host)
++     	return NULL;
++     
++     snprintf(buf,sizeof(buf),"%s@%s",a->mailbox,a->host);
++     
++     for (pcert=s_personal_certs;pcert;pcert=pcert->next) {
++     
++     	if (!pcert->cert)
++ 	    continue;
++     
++         email = get_x509_subject_email(pcert->cert);
++ 
++     	if (email && strucmp(email,buf)==0) {
++     	    fs_give((void**) &email);
++ 	    break;
++ 	}
++ 
++     	fs_give((void**) &email);
++     }
++     
++     return pcert;
++ }
++ 
++ /*
++     Look for a personal certificate matching the from
++     (or reply_to? in the given envelope)
++  */
++ PERSONAL_CERT *match_personal_cert(ENVELOPE *env)
++ {
++     PERSONAL_CERT   *pcert;
++     
++     pcert = match_personal_cert_to_email(env->reply_to);
++     if (!pcert)
++     	pcert = match_personal_cert_to_email(env->from);
++         
++     return pcert;
++ }
++ 
++ /*
++     Flatten the given body into its MIME representation.
++     Return the result in a CharStar STORE_S.
++  */
++ static STORE_S *body_to_store(BODY *body)
++ {
++     STORE_S   *store;
++     store = so_get(CharStar, NULL, EDIT_ACCESS);
++     if (!store)
++     	return NULL;
++     
++     pine_encode_body(body); /* this attaches random boundary strings to multiparts */
++     pine_write_body_header (body, rfc822_output_func,store);
++     pine_rfc822_output_body(body, rfc822_output_func,store);
++ 
++     /*  now need to truncate by two characters since the above
++     	appends CRLF to the stream
++      */
++ 
++     /** Eek! No way of telling size of a STORE_S. We depend on knowing it's
++     	a CharStar */
++     so_truncate(store,((char*)store->eod-(char*)store->txt)-2);
++ 
++     so_seek(store,0,SEEK_SET);
++     
++     return store;
++ }
++ 
++ 
++ 
++ /*
++     Sign a message. Called from call_mailer in send.c.
++     
++     This takes the header for the outgoing message as well as a pointer
++     to the current body (which may be reallocated).
++  */
++ int sign_outgoing_message(METAENV *header,BODY **bodyP,int dont_detach)
++ {
++     STORE_S *store = NULL;
++     STORE_S *outs = NULL;
++     BODY    *body = *bodyP;
++     BODY    *newBody = NULL;
++     PART    *p1 = NULL;
++     PART    *p2 = NULL;
++     PERSONAL_CERT   *pcert;
++     BIO *in = NULL;
++     BIO *out = NULL;
++     PKCS7   *p7 = NULL;
++     int result = 0;
++     PARAMETER	*param;
++     
++     int flags = dont_detach ? 0 : PKCS7_DETACHED;
++ 
++     openssl_init();
++ 
++     store = body_to_store(body);
++ 
++     /* Look for a private key matching the sender address... */
++     
++     pcert = match_personal_cert(header->env);
++     
++     if (!pcert) {
++         q_status_message(SM_ORDER,1,1,"Couldn't find the certificate needed to sign.");
++ 	goto end;
++     }
++     
++     if (!load_private_key(pcert) && g_need_passphrase) {
++     	/* Couldn't load key with blank password, try again */
++     	get_passphrase();
++ 	load_private_key(pcert);
++     }
++     
++     if (!pcert->key)
++ 	goto end;
++     
++     in = BIO_new_so(store);
++ 
++ #if 0
++     dump_bio_to_file(in,"/tmp/signed-data");
++ #endif
++ 
++     BIO_reset(in);
++ 
++     p7 = PKCS7_sign(pcert->cert, pcert->key, NULL, in, flags);
++     if (!p7) {
++         q_status_message(SM_ORDER,1,1,"Error creating PKCS7 object.");
++ 	goto end;
++     }
++    
++     outs = so_get(CharStar,NULL,EDIT_ACCESS);
++     out = BIO_new_so(outs);
++ 
++     i2d_PKCS7_bio(out, p7);
++     BIO_flush(out);
++     
++     so_seek(outs,0,SEEK_SET);
++     
++     if ((flags&PKCS7_DETACHED)==0) {
++    
++     	/* the simple case: the signed data is in the pkcs7 object */
++     
++ 	newBody = mail_newbody();
++     	
++ 	setup_pkcs7_body_for_signature(newBody,"S/MIME Cryptographically Signed Message","x-pkcs7-mime","smime.p7m");
++ 
++     	newBody->contents.text.data = (char*) outs;
++ 	*bodyP = newBody;
++ 
++ 	result = 1;
++     } else {
++     
++ 	/*  OK.
++     	    We have to create a new body as follows:
++ 
++ 	    multipart/signed; blah blah blah
++ 		reference to existing body
++ 
++ 		pkcs7 object
++ 	 */
++ 
++ 	newBody = mail_newbody();
++ 
++ 	newBody->type = TYPEMULTIPART;
++ 	newBody->subtype = cpystr("signed");
++ 	newBody->encoding = ENC7BIT;
++ 
++ 	newBody->parameter = param = mail_newbody_parameter();
++ 	param->attribute = cpystr("protocol");
++ 	param->value = cpystr("application/x-pkcs7-signature");
++ 
++ 	newBody->parameter->next = param = mail_newbody_parameter();
++ 	param->attribute = cpystr("micalg");
++ 	param->value = cpystr("sha1");
++ 
++ 	p1 = mail_newbody_part();
++ 	p2 = mail_newbody_part();
++ 
++     	/*  this is nasty. We're just copying the body in here,
++ 	    but since our newBody is freed at the end of call_mailer,
++ 	    we mustn't let this body (the original one) be freed twice.
++ 	 */
++ 	p1->body = *body; /* ARRGH. This is special cased at the end of call_mailer */
++ 
++ 	p1->next = p2;
++ 
++ 	setup_pkcs7_body_for_signature(&p2->body,"S/MIME Cryptographic Signature","x-pkcs7-signature","smime.p7s");
++     	p2->body.contents.text.data = (char*) outs;
++ 
++     	newBody->nested.part = p1;
++ 
++ 	*bodyP = newBody;
++ 	
++ 	result = 1;
++     }
++ 
++ end:
++ 
++     PKCS7_free(p7);
++     BIO_free(in);
++     BIO_free(out);
++     if (store)
++     	so_give(&store);
++ 
++     return result;
++ }
++ 
++ /*
++     Encrypt a message on the way out. Called from call_mailer in send.c
++     The body may be reallocated.
++  */
++ int encrypt_outgoing_message(METAENV *header,BODY **bodyP)
++ {
++     PKCS7 *p7 = NULL;
++     BIO	*in = NULL;
++     BIO *out = NULL;
++     EVP_CIPHER *cipher = NULL;
++     STACK_OF(X509) *encerts = NULL;
++     STORE_S *store = NULL;
++     STORE_S *outs = NULL;
++     PINEFIELD	*pf;
++     ADDRESS		*a;
++     BODY	*body = *bodyP;
++     BODY	*newBody = NULL;
++     int		result = 0;
++ 
++     openssl_init();
++ 
++     cipher = EVP_des_cbc();
++ 
++     encerts = sk_X509_new_null();
++ 
++     /* Look for a certificate for each of the recipients */
++     for(pf = header->local; pf && pf->name; pf = pf->next)
++         if(pf->type == Address && pf->rcptto && pf->addr && *pf->addr) {
++ 
++             for (a=*pf->addr;a;a=a->next) {
++                 X509	*cert;
++                 char	buf[MAXPATH];
++ 
++                 snprintf(buf,sizeof(buf),"%s@%s",a->mailbox,a->host);
++ 
++                 cert = get_cert_for(g_pine_smime_dir,buf);
++                 if (cert)
++                     sk_X509_push(encerts,cert);
++                 else {
++                     q_status_message2(SM_ORDER,1,1,
++                                       "Unable to find certificate for <%s@%s>",a->mailbox,a->host);
++                     goto end;
++                 }
++             }
++         }
++ 
++ 
++     store = body_to_store(body);
++ 
++     in = BIO_new_so(store);
++ 
++     p7 = PKCS7_encrypt(encerts, in, cipher, 0);
++ 
++     outs = so_get(CharStar,NULL,EDIT_ACCESS);
++     out = BIO_new_so(outs);
++ 
++     i2d_PKCS7_bio(out, p7);
++     BIO_flush(out);
++     so_seek(outs,0,SEEK_SET);
++ 
++     newBody = mail_newbody();
++ 
++     newBody->type = TYPEAPPLICATION;
++     newBody->subtype = cpystr("x-pkcs7-mime");
++     newBody->encoding = ENCBINARY;
++ 
++     newBody->description = cpystr("S/MIME Encrypted Message");
++ 
++     newBody->contents.text.data = (char*) outs;
++ 
++     *bodyP = newBody;
++ 
++     result = 1;
++ 
++ end:
++ 
++     BIO_free(in);
++     BIO_free(out);
++     PKCS7_free(p7);
++     sk_X509_pop_free(encerts, X509_free);
++     if (store)
++         so_give(&store);
++ 
++     return result;
++ }
++ 
++ /*
++     Plonk the contents (mime headers and body) of the given
++     section of a message to a CharStar STORE_S object.
++  */
++ static STORE_S *get_raw_part(int msgno,const char *section)
++ {
++     long len;
++     STORE_S *store = NULL;
++     char	*text;
++ 
++     store = so_get(CharStar, NULL, EDIT_ACCESS);
++     if (store) {
++ 
++         /* First grab headers of the chap */
++         text = mail_fetch_mime(ps_global->mail_stream, msgno, (char*) section, &len, 0);
++ 
++         if (text) {
++             so_nputs(store,text,len);
++ 
++             /** Now grab actual body */
++             text = mail_fetch_body (ps_global->mail_stream, msgno, (char*) section, &len, 0);
++             if (text) {
++                 so_nputs(store,text,len);
++ 
++                 so_seek(store,0,SEEK_SET);
++ 
++             } else so_give(&store);
++ 
++         } else so_give(&store);
++ 
++     }
++     return store;
++ }
++ 
++ /*
++     Get (and decode) the body of the given section of msg
++  */
++ static STORE_S *get_part_contents(int msgno,const char *section)
++ {
++     long len;
++     gf_io_t     pc;
++     STORE_S *store = NULL;
++     char	*err;
++ 
++     store = so_get(CharStar, NULL, EDIT_ACCESS);
++     if (store) {
++         gf_set_so_writec(&pc,store);
++ 
++         err = detach(ps_global->mail_stream, msgno, (char*) section,&len, pc, NULL);
++ 
++         gf_clear_so_writec(store);
++ 
++         so_seek(store,0,SEEK_SET);
++ 
++         if (err)
++             so_give(&store);
++     }
++     return store;
++ }
++ 
++ static PKCS7 *get_pkcs7_from_part(int msgno,const char *section)
++ {
++     STORE_S *store = NULL;
++     PKCS7 *p7 = NULL;
++     BIO	*in = NULL;
++ 
++     store = get_part_contents(msgno,section);
++ 
++     if (store) {
++         in = BIO_new_so(store);
++         if (in) {
++             p7=d2i_PKCS7_bio(in,NULL);
++         }
++     }
++ 
++     if (store)
++         so_give(&store);
++ 
++     BIO_free(in);
++ 
++     return p7;
++ }
++ 
++ /*
++     Try to verify a signature.
++     
++     p7  - the pkcs7 object to verify
++     in  - the plain data to verify (NULL if not detached)
++     out - BIO to which to write the opaque data
++  */
++ static int do_signature_verify(PKCS7 *p7,BIO *in,BIO *out)
++ {
++     STACK_OF(X509)	*otherCerts = NULL;
++     int	result;
++     const char    *data;
++     long    err;
++     
++ #if 0
++     dump_bio_to_file(in,"/tmp/verified-data");
++ #endif
++ 
++     BIO_reset(in);
++     
++ #if 0
++     /* testing verification stuff */
++     {
++     	X509	*c;
++ 	
++         c = get_cert_for(g_pine_smime_dir,"xx");
++ 	if (c) {
++     	    X509_add1_reject_object(c, OBJ_nid2obj(NID_email_protect));
++ 
++     	    X509_STORE_add_cert(s_cert_store,c);
++ 	    
++ 	    save_cert_for(g_pine_smime_dir,cpystr("yy"),c);
++ 	}
++     
++     
++     	ERR_clear_error();
++     
++     }
++ #endif
++     
++     result = PKCS7_verify(p7, otherCerts, s_cert_store,
++                       in, out, 0);
++     
++     if (result) {
++ 	q_status_message(SM_ORDER,1,1,"S/MIME signature verified ok");
++     } else {
++ 	err = ERR_peek_error_line_data(NULL, NULL, &data, NULL);
++ 
++ 	if (out && err==ERR_PACK(ERR_LIB_PKCS7,PKCS7_F_PKCS7_VERIFY,PKCS7_R_CERTIFICATE_VERIFY_ERROR)) {
++ 
++ 	    /* Retry verification so we can get the plain text */
++ 	    /* Might be better to reimplement PKCS7_verify here? */
++ 	    
++ 	    PKCS7_verify(p7, otherCerts, s_cert_store,
++                       in, out, PKCS7_NOVERIFY);
++ 
++ 	}
++ 
++ 	q_status_message1(SM_ORDER | SM_DING,1,1,"Couldn't verify S/MIME signature: %s",(char*) openssl_error_string());
++ 
++     	return result;
++     }
++ 
++     /* now try to extract the certificates of any signers */
++     {
++         STACK_OF(X509)	*signers;
++         int	i;
++ 
++         signers = PKCS7_get0_signers(p7, NULL, 0);
++ 
++         if (signers)
++             for (i=0;i<sk_X509_num(signers);i++) {
++ 		char	*email;
++                 X509	*x = sk_X509_value(signers,i);
++ 		X509	*cert;
++ 		
++                 if (!x)
++                     continue;
++ 
++     	    	email = get_x509_subject_email(x);
++     	    	
++ 		if (email) {
++                     cert = get_cert_for(g_pine_smime_dir,email);
++ 		    if (cert) {
++ 		    	X509_free(cert);
++ 		    } else {
++     	    	    	save_cert_for(g_pine_smime_dir,email,x);
++     	    	    }
++ 		    fs_give((void**) &email);
++     	    	}
++             }
++ 
++         sk_X509_free(signers);
++     }
++ 
++     return result;
++ }
++ 
++ /*  Hook inside BODY structure for cleaning up S/MIME message bodies */
++ static void smime_body_cleanup(BODY *b)
++ {
++ #if 0
++     q_status_message(SM_ORDER,1,1,"smime_body_cleanup called");
++ #endif
++ 
++     if (b->sparep) {
++     	PKCS7_free((PKCS7*) b->sparep);
++         b->sparep = NULL;
++     }
++ }
++ 
++ /*
++     Given a multipart body of type multipart/signed, attempt to verify
++     it
++  */
++ static int do_detached_signature_verify(BODY *b,int msgno,char *section)
++ {
++     STORE_S *toVerify = NULL;
++     PKCS7   *p7 = NULL;
++     BIO	    *in = NULL;
++     PART    *p;
++     int	    result = 0;
++     char    seq[100];
++     char    *what_we_did;
++ 
++     openssl_init();
++ 
++     snprintf(seq,sizeof(seq),"%s1",section);
++     toVerify = get_raw_part(msgno,seq);
++ 
++     if (toVerify) {
++ 
++         in = BIO_new_so(toVerify);
++         if (!in)
++             goto end;
++ 
++         snprintf(seq,sizeof(seq),"%s2",section);
++         p7 = get_pkcs7_from_part(msgno,seq);
++ 
++         if (!p7)
++             goto end;
++ 
++     	result = do_signature_verify(p7,in,NULL);
++ 
++         if (b->subtype) fs_give((void**) &b->subtype);
++         b->subtype = cpystr("x-pkcs7-enclosure");
++         b->encoding = ENC8BIT;
++ 
++     	if (b->description) fs_give ((void**) &b->description);
++ 
++    	what_we_did = result ? 	"This message was cryptographically signed." :
++ 	    	    	    	"This message was cryptographically signed but the signature could not be verified.";
++ 
++ 	b->description = cpystr(what_we_did);
++ 
++     	b->sparep = p7;
++ 	p7 = NULL;
++ 	b->cleanup = smime_body_cleanup;
++ 
++     	p = b->nested.part;
++ 	
++ 	/* p is signed plaintext */
++ 	if (p && p->next)
++ 	    mail_free_body_part(&p->next); /* hide the pkcs7 from the viewer */
++ 
++         result = 0;
++     }
++ end:
++     BIO_free(in);
++ 
++     PKCS7_free(p7);
++ 
++     if (toVerify)
++         so_give(&toVerify);
++ 
++     return result;
++ }
++ 
++ static PERSONAL_CERT *find_certificate_matching_recip_info(PKCS7_RECIP_INFO *ri)
++ {
++     PERSONAL_CERT	*x;
++ 
++     for (x=s_personal_certs;x;x=x->next) {
++         X509	*mine;
++ 
++         mine = x->cert;
++ 
++         if (!X509_NAME_cmp(ri->issuer_and_serial->issuer,mine->cert_info->issuer) &&
++                 !ASN1_INTEGER_cmp(ri->issuer_and_serial->serial,mine->cert_info->serialNumber)) {
++             break;
++         }
++     }
++     
++     return x;
++ }
++ 
++ static PERSONAL_CERT *find_certificate_matching_pkcs7(PKCS7 *p7)
++ {
++     int i;
++     STACK_OF(PKCS7_RECIP_INFO) *recips;
++     PERSONAL_CERT *x = NULL;
++ 
++     recips = p7->d.enveloped->recipientinfo;
++ 
++     for (i=0; i<sk_PKCS7_RECIP_INFO_num(recips); i++) {
++         PKCS7_RECIP_INFO	*ri;
++ 
++         ri=sk_PKCS7_RECIP_INFO_value(recips,i);
++ 
++         if ((x=find_certificate_matching_recip_info(ri))!=0) {
++             break;
++         }
++     }
++     
++     return x;
++ }
++ 
++ /*
++     Try to decode (decrypt or verify a signature) a PKCS7 body
++  */
++ static int do_decoding(BODY *b,int msgno,const char *section)
++ {
++     STORE_S	*outs = NULL;
++     int result = 0;
++ 
++     BIO *out = NULL;
++     PKCS7 *p7 = NULL;
++     X509 *recip = NULL;
++     EVP_PKEY *key = NULL;
++     PERSONAL_CERT 	*pcert = NULL;
++     
++     char    *what_we_did = "";
++ 
++     openssl_init();
++ 
++     /*
++     	Extract binary data from part to an in-memory store
++      */
++ 
++     if (b->sparep) {
++     
++     	p7 = (PKCS7*) b->sparep;
++ 	
++     } else {
++ 
++ 	p7 = get_pkcs7_from_part(msgno,section);
++ 	if (p7 == NULL) {
++             q_status_message1(SM_ORDER,1,1,"Couldn't load PKCS7 object: %s",(char*)openssl_error_string());
++             goto end;
++ 	}
++ 
++     	/*  Save the PKCS7 object for later dealings by the user interface.
++ 	    It will be cleaned up when the body is garbage collected
++ 	 */
++ 	b->sparep = p7;
++ 	b->cleanup = smime_body_cleanup;
++     }
++ 
++     if (PKCS7_type_is_signed(p7)) {
++     	int 	sigok;
++ 	
++ 	outs = so_get(CharStar, NULL, EDIT_ACCESS);
++ 	so_puts(outs,"MIME-Version: 1.0\r\n"); /* needed so rfc822_parse_msg_full believes it's MIME */
++     	out = BIO_new_so(outs);
++ 
++     	sigok = do_signature_verify(p7,NULL,out);
++     	
++ 	/* shouldn't really duplicate these messages */
++    	what_we_did = sigok ? 	"This message was cryptographically signed." :
++ 	    	    	    	"This message was cryptographically signed but the signature could not be verified.";
++ 	
++     } else if (!PKCS7_type_is_enveloped(p7)) {
++         q_status_message(SM_ORDER,1,1,"PKCS7 object not recognised.");
++         goto end;
++     } else { /* It *is* enveloped */
++ 
++ 	what_we_did = "This message was encrypted.";
++ 
++ 	/*
++     	    Now need to find a cert that can decrypt this boy
++ 	 */
++ 	pcert = find_certificate_matching_pkcs7(p7);
++ 
++ 	if (!pcert) {
++             q_status_message(SM_ORDER,1,1,"Couldn't find the certificate needed to decrypt.");
++             goto end;
++ 	}
++ 
++ 	recip = pcert->cert;
++ 
++ 	load_private_key(pcert);
++ 
++ 	key = pcert->key;
++ 	if (!key)	
++     	    goto end;
++ 
++ 	outs = so_get(CharStar, NULL, EDIT_ACCESS);
++ 	so_puts(outs,"MIME-Version: 1.0\r\n");
++ 
++ 	out = BIO_new_so(outs);
++ 
++ 	if(!PKCS7_decrypt(p7, key, recip, out, 0)) {
++             q_status_message1(SM_ORDER,1,1,"Error decrypting PKCS7: %s",(char*) openssl_error_string());
++             goto end;
++ 	}
++     
++     }
++ 
++     /*	We've now produced a flattened MIME object in store outs.
++     	It needs to be turned back into a BODY
++      */
++ 
++     {
++         BODY	*body;
++         ENVELOPE	*env;
++         char	*h;
++         char	*bstart;
++         STRING	s;
++ 
++         h = so_text(outs);
++ 
++         /* look for start of body */
++         bstart = strstr(h,"\r\n\r\n");
++ 
++         if (!bstart) {
++             q_status_message(SM_ORDER,1,1,"Encrypted data couldn't be parsed.");
++      	} else {
++             bstart += 4; /* skip over CRLF*2 */
++ 
++             INIT(&s,mail_string,bstart,strlen(bstart));
++             rfc822_parse_msg_full(&env,&body,h,bstart-h-2,&s,BADHOST,0,0);
++             mail_free_envelope(&env); /* Don't care about this */
++ 
++             /*
++             	Now convert original body (application/pkcs7-mime)
++             	to a multipart body with one sub-part (the decrypted body)
++ 		Note that the sub-part may also be multipart!
++              */
++ 
++             b->type = TYPEMULTIPART;
++             if (b->subtype) fs_give((void**) &b->subtype);
++ 
++     	    /*  This subtype is used in mailview.c to annotate the display of
++ 	    	encrypted or signed messages. We know for sure then that it's a PKCS7
++ 		part because the sparep field is set to the PKCS7 object (see above)
++ 	     */
++             b->subtype = cpystr("x-pkcs7-enclosure");
++             b->encoding = ENC8BIT;
++ 
++     	    if (b->description) fs_give ((void**) &b->description);
++ 	    b->description = cpystr(what_we_did);
++ 
++             if (b->disposition.type) fs_give ((void **) &b->disposition.type);
++ 
++             if (b->contents.text.data) fs_give ((void **) &b->contents.text.data);
++ 
++     	    if (b->parameter) mail_free_body_parameter(&b->parameter);
++ 
++             /* Allocate mem for the sub-part, and copy over the contents of our parsed body */
++             b->nested.part = fs_get(sizeof (PART));
++             b->nested.part->body = *body;
++             b->nested.part->next = NULL;
++ 
++             fs_give((void**) &body);
++ 
++             /* 	IMPORTANT BIT: set the body->contents.text.data elements to contain the decrypted
++             	data. Otherwise, it'll try to load it from the original data. Eek.
++              */
++             create_local_cache(bstart,&b->nested.part->body);
++ 
++             result = 1;
++         }
++     }
++ 
++ end:
++ 
++     BIO_free(out);
++ 
++     if (outs)
++         so_give(&outs);
++ 
++     return result;
++ }
++ 
++ /*
++     Recursively handle PKCS7 bodies in our message.
++ 
++     Returns non-zero if some fiddling was done.
++  */
++ static int do_fiddle_smime_message(BODY *b,int msgno,char *section)
++ {
++     int result = 0;
++ 
++     if (is_pkcs7_body(b)) {
++     
++         if (do_decoding(b,msgno,*section ? section : "1")) {
++             /*
++             	b should now be a multipart message: fiddle it too in case it's been multiply-encrypted!
++              */
++ 
++             /* fallthru */
++             result = 1;
++         }
++     }
++ 
++     if (b->type==TYPEMULTIPART) {
++ 
++         PART	*p;
++         int		partNum;
++         char	newSec[100];
++ 
++         if (b->subtype && strucmp(b->subtype,"signed")==0) {
++ 
++             /* Ahah. We have a multipart signed entity. */
++ 
++             /*	part 1 (signed thing)
++             	part 2 (the pkcs7 object)
++              */
++ 
++             do_detached_signature_verify(b,msgno,section);
++ 
++         } else {
++ 
++             for (p=b->nested.part,partNum=1;p;p=p->next,partNum++) {
++ 
++                 /* Append part number to the section string */
++ 
++                 snprintf(newSec,sizeof(newSec),"%s%s%d",section,*section ? "." : "",partNum);
++ 
++                 result |= do_fiddle_smime_message(&p->body,msgno,newSec);
++             }
++ 
++         }
++ 
++     }
++ 
++     return result;
++ }
++ 
++ /*
++     Fiddle a message in-place by decrypting/verifying S/MIME entities.
++     Returns non-zero if something was changed.
++  */
++ 
++ int fiddle_smime_message(BODY *b,int msgno,int is_new_message)
++ {
++     if (F_OFF(F_REMEMBER_SMIME_PASSPHRASE,ps_global))
++         forget_private_keys();
++     return do_fiddle_smime_message(b,msgno,"");
++ }
++ 
++ 
++ /********************************************************************************/
++ 
++ static struct key smime_info_keys[] = 
++        {HELP_MENU,
++     	OTHER_MENU,
++ 	{"<","Back",{MC_VIEW_TEXT,2,{'<',','}},KS_EXITMODE},
++     	NULL_MENU,
++     	NULL_MENU,
++     	NULL_MENU,
++ 	PREVPAGE_MENU,
++ 	NEXTPAGE_MENU,
++     	NULL_MENU,
++     	NULL_MENU,
++     	NULL_MENU,
++     	NULL_MENU,
++ 
++ 	HELP_MENU,
++ 	OTHER_MENU,
++ 	MAIN_MENU,
++ 	QUIT_MENU,
++     	NULL_MENU,
++     	NULL_MENU,
++     	NULL_MENU,
++     	NULL_MENU,
++     	NULL_MENU,
++ 	INDEX_MENU,
++     	NULL_MENU,
++     	NULL_MENU,
++ };
++ INST_KEY_MENU(smime_info_keymenu, smime_info_keys);
++ 
++ #define SMIME_PARENT_KEY 2
++ 
++ static void get_fingerprint(X509 *cert,const EVP_MD *type,char *buf,int maxLen)
++ {
++     unsigned char    md[128];
++     char    *b;
++     int     len,i;
++ 
++     len = sizeof(md);
++ 
++     X509_digest(cert,type,md,&len);
++ 
++     b = buf;
++     *b = 0;
++     for (i=0; i<len; i++)
++     {
++     	if (b-buf+3>=maxLen)
++ 	    break;
++ 	
++ 	if (i != 0)
++ 	    *b++ = ':';
++ 	sprintf(b,"%02x",md[i]);
++     	b+=2;
++     }
++ }
++ 
++ static void output_X509_NAME(X509_NAME *name,gf_io_t pc)
++ {
++     int i,c;
++     int nid;
++     char    buf[256];
++     
++     c = X509_NAME_entry_count(name);
++     
++     for (i=c-1;i>=0;i--) {
++     	X509_NAME_ENTRY *e;
++ 	
++     	e = X509_NAME_get_entry(name,i);
++ 	if (!e) continue;
++ 	
++     	X509_NAME_get_text_by_OBJ(name, e->object,buf,sizeof(buf));
++ 	
++     	gf_puts(buf,pc);
++ 	gf_puts(NEWLINE,pc);    
++     }
++ 
++ }
++ 
++ /*
++     Output a string in a distinctive style
++  */
++ static void gf_puts_uline(const char *txt,gf_io_t pc)
++ {
++ #if 0
++     pc(TAG_EMBED); pc(TAG_ULINEON);
++     gf_puts(txt,pc);
++     pc(TAG_EMBED); pc(TAG_ULINEOFF);
++ #else
++     pc(TAG_EMBED); pc(TAG_BOLDON);
++     gf_puts(txt,pc);
++     pc(TAG_EMBED); pc(TAG_BOLDOFF);
++ #endif
++ }
++ 
++ /*
++     Get a line from the given store (including \n)
++  */
++ static int so_gets(STORE_S *store,char *buf,int len)
++ {
++     unsigned char   c;
++     char   *bend = buf + len - 1;
++     char    *b = buf;
++     
++     do {
++         if (!store->readc(&c,store)) {
++ 	    *b = 0;
++ 	    return b!=buf;
++ 	}
++ 	*b++ = c;
++     } while (c!='\n' && b<bend);
++ 
++     *b = 0;
++ 
++     return 1;
++ }
++ 
++ /*
++     Wrap the text in the given store to the given width.
++     A new store is created for the result.
++  */
++ static STORE_S *wrap_store(STORE_S *in,int width)
++ {
++     STORE_S *result;
++     void  *ws;
++     gf_io_t ipc,opc;
++     
++     if (width<10)
++     	width = 10;
++     
++     result = so_get(CharStar,NULL,EDIT_ACCESS);
++     ws = gf_wrap_filter_opt(width,width,0,0);
++ 
++     gf_filter_init();
++     gf_link_filter(gf_wrap,ws);
++ 
++     gf_set_so_writec(&opc,result);
++     gf_set_so_readc(&ipc,in);
++ 
++     gf_pipe(ipc,opc);
++     
++     gf_clear_so_readc(in);
++     gf_clear_so_writec(result);
++     
++     return result;
++ }
++ 
++ /*
++     Output the contents of the given stores (left and right)
++     to the given gf_io_t.
++     The width of the terminal is inspected and two columns
++     are created to fit the stores into. They are then wrapped
++     and merged.
++  */
++ static void side_by_side(STORE_S *left,STORE_S *right,gf_io_t pc)
++ {
++     STORE_S *left_wrapped;
++     STORE_S *right_wrapped;
++ 
++     char    buf_l[256];
++     char    buf_r[256];
++     char    *b;
++     int i;
++     int w = ps_global->ttyo->screen_cols/2 - 1;
++     
++     so_seek(left,0,0);
++     so_seek(right,0,0);
++     
++     left_wrapped = wrap_store(left,w);
++     right_wrapped = wrap_store(right,w);
++     
++     so_seek(left_wrapped,0,0);
++     so_seek(right_wrapped,0,0);
++ 
++     for (;;) {
++     
++     	i = so_gets(left_wrapped,buf_l,sizeof(buf_l));
++     	i += so_gets(right_wrapped,buf_r,sizeof(buf_r));
++     
++     	if (i==0)
++ 	    break;
++     
++ 	for (i=0, b=buf_l;i<w && *b && *b!='\r' && *b!='\n';i++,b++) {
++ 	    pc(*b);
++ 	    /* reduce accumulated width if an embed tag is discovered */
++ 	    if (*b==TAG_EMBED)
++ 	    	i-=2;
++ 	}
++ 
++ 	if (buf_r[0]) {
++ 
++     	    while (i<w) {
++ 	    	pc(' ');
++ 		i++;
++ 	    }
++ 
++ 	    for (i=0, b=buf_r;i<w && *b && *b!='\r' && *b!='\n';i++,b++) {
++ 		pc(*b);
++ 	    }
++ 	}
++ 
++ 	gf_puts(NEWLINE,pc);
++     }
++     
++     so_give(&left_wrapped);
++     so_give(&right_wrapped);
++ }
++ 
++ static void print_separator_line(int percent,int ch,gf_io_t pc)
++ {
++     int i;
++     int start,len;
++     
++     len = ps_global->ttyo->screen_cols * percent / 100;
++     start = (ps_global->ttyo->screen_cols - len)/2;
++     
++     for (i=0;i<start;i++)
++     	pc(' ');
++     for (i=start;i<start+len;i++)
++     	pc(ch);
++     gf_puts(NEWLINE,pc);
++ }
++ 
++ static void output_cert_info(X509 *cert,gf_io_t pc)
++ {
++     char    buf[256];
++     STORE_S *left,*right;
++     gf_io_t spc;
++     int i;
++         
++     left = so_get(CharStar,NULL,EDIT_ACCESS);
++     right = so_get(CharStar,NULL,EDIT_ACCESS);
++ 
++     gf_set_so_writec(&spc,left);
++ 
++     if (!cert->cert_info) {
++     	gf_puts("Couldn't find certificate info.",spc);
++ 	gf_puts(NEWLINE,spc);
++     } else {
++ 
++ 	gf_puts_uline("Subject (whose certificate it is)",spc);
++ 	gf_puts(NEWLINE, spc);
++ 
++ 	output_X509_NAME(cert->cert_info->subject,spc);
++ 	gf_puts(NEWLINE,spc);
++ 
++ 	gf_puts_uline("Serial Number",spc);
++ 	gf_puts(NEWLINE,spc);
++ 
++ 	sprintf(buf,"%d",ASN1_INTEGER_get(cert->cert_info->serialNumber));
++ 	gf_puts(buf,spc);
++ 	gf_puts(NEWLINE,spc);
++ 	gf_puts(NEWLINE,spc);
++ 
++ 	gf_puts_uline("Validity",spc);
++ 	gf_puts(NEWLINE,spc);
++     	{
++     	    BIO *mb = BIO_new_so(left);
++ 	    
++ 	    gf_puts("Not Before: ",spc);
++ 	    ASN1_UTCTIME_print(mb,cert->cert_info->validity->notBefore);
++ 	    BIO_flush(mb);
++ 	    gf_puts(NEWLINE,spc);
++ 
++ 	    gf_puts("Not After:  ",spc);
++ 	    ASN1_UTCTIME_print(mb,cert->cert_info->validity->notAfter);
++ 	    BIO_flush(mb);
++     	    
++ 	    gf_puts(NEWLINE,spc);
++ 	    gf_puts(NEWLINE,spc);
++ 	    	    
++ 	    BIO_free(mb);
++ 	}
++ 
++     }
++ 
++     gf_clear_so_writec(left);
++ 
++     gf_set_so_writec(&spc,right);
++ 
++     if (!cert->cert_info) {
++     	gf_puts("Couldn't find certificate info.",spc);
++ 	gf_puts(NEWLINE,spc);
++     } else {
++ 	gf_puts_uline("Issuer",spc);
++ 	gf_puts(NEWLINE, spc);
++ 
++ 	output_X509_NAME(cert->cert_info->issuer,spc);
++ 	gf_puts(NEWLINE,spc);
++     }
++     
++     gf_clear_so_writec(right);
++     
++     side_by_side(left,right,pc);
++ 
++     gf_puts_uline("SHA1 Fingerprint",pc);
++     gf_puts(NEWLINE,pc);
++     get_fingerprint(cert,EVP_sha1(),buf,sizeof(buf));
++     gf_puts(buf,pc);
++     gf_puts(NEWLINE,pc);
++ 
++     gf_puts_uline("MD5 Fingerprint",pc);
++     gf_puts(NEWLINE,pc);
++     get_fingerprint(cert,EVP_md5(),buf,sizeof(buf));
++     gf_puts(buf,pc);
++     gf_puts(NEWLINE,pc);
++     
++     so_give(&left);
++     so_give(&right);
++ }
++ 
++ void format_smime_info(int pass,BODY *body,int msgno,gf_io_t pc)
++ {
++     PKCS7   *p7;
++     int i;
++     
++     if (body->type==TYPEMULTIPART) {
++     	PART	*p;    
++ 
++         for (p=body->nested.part;p;p=p->next) {
++             format_smime_info(pass,&p->body,msgno,pc);
++         }
++     }
++     
++     p7 = body->sparep;
++     if (p7) {
++ 
++     	if (PKCS7_type_is_signed(p7)) {
++             STACK_OF(X509)	*signers;
++ 
++     	    switch (pass) {
++ 	    	case 1:
++     		    gf_puts("This message was cryptographically signed." NEWLINE,pc);
++     	    	    break;
++ 		case 2:
++ 		
++         	    signers = PKCS7_get0_signers(p7, NULL, 0);
++ 
++         	    if (signers) {
++ 
++     	    	    	sprintf(tmp_20k_buf,"Certificate%s used for signing",plural(sk_X509_num(signers)));
++     	    		gf_puts_uline(tmp_20k_buf,pc);
++ 			gf_puts(NEWLINE,pc);
++ 			print_separator_line(100,'-',pc);
++ 
++         		for (i=0;i<sk_X509_num(signers);i++) {
++                 	    X509	*x = sk_X509_value(signers,i);
++ 
++                 	    if (x) {
++ 				output_cert_info(x,pc);
++ 				gf_puts(NEWLINE,pc);
++ 			    }
++ 
++         		}
++ 		    }
++ 
++         	    sk_X509_free(signers);
++ 	    	    break;
++ 	    }
++     	
++ 	} else if (PKCS7_type_is_enveloped(p7)) {
++ 	
++     	    switch (pass) {
++ 	    	case 1:
++     		    gf_puts("This message was encrypted." NEWLINE,pc);
++     	    	    break;
++ 	    	case 2:
++ 		
++ 		    if (p7->d.enveloped && p7->d.enveloped->enc_data) {
++ 			X509_ALGOR *alg = p7->d.enveloped->enc_data->algorithm;
++ 			STACK_OF(PKCS7_RECIP_INFO) *ris = p7->d.enveloped->recipientinfo;
++     	    		int found = 0;
++ 
++     	    		gf_puts("The algorithm used to encrypt was ",pc);
++ 
++ 
++ 			if (alg) {
++ 			    char    *n = OBJ_nid2sn( OBJ_obj2nid(alg->algorithm ));
++ 
++ 			    gf_puts(n ? n : "<unknown>",pc);
++ 
++ 			} else gf_puts("<unknown>",pc);
++ 
++ 			gf_puts("." NEWLINE NEWLINE,pc);
++ 
++     	    	    	sprintf(tmp_20k_buf,"Certificate%s for decrypting",plural(sk_PKCS7_RECIP_INFO_num(ris)));
++     	    		gf_puts_uline(tmp_20k_buf,pc);
++ 			gf_puts(NEWLINE,pc);
++ 			print_separator_line(100,'-',pc);
++ 
++ 			for (i=0;i<sk_PKCS7_RECIP_INFO_num(ris);i++) {
++ 			    PKCS7_RECIP_INFO	*ri;
++ 			    PERSONAL_CERT    *pcert;
++ 
++ 			    ri = sk_PKCS7_RECIP_INFO_value(ris,i);
++ 			    if (!ri) continue;
++ 
++     	    		    pcert = find_certificate_matching_recip_info(ri);
++ 
++     	    		    if (pcert) {
++ 
++     	    	    	    	if (found) {
++ 				    print_separator_line(25,'*',pc);
++ 			    	    gf_puts(NEWLINE,pc);
++ 				}
++ 				found = 1;
++ 
++ 				output_cert_info(pcert->cert,pc);
++ 			    	gf_puts(NEWLINE,pc);
++ 
++ 			    }
++ 			}
++ 
++     	    		if (!found) {
++ 			    gf_puts("No certificate capable of decrypting could not be found.",pc);
++ 			}
++ 		    }
++ 		    break;
++ 	    }
++ 	
++ 	}
++     }
++ }
++ 
++ void view_writec();
++ 
++ void smime_info_screen(struct pine *ps)
++ {
++     int msgno;
++     OtherMenu     what;
++     int cmd;
++     char    backtag[64];
++     BODY    *body;
++     ENVELOPE	*env;
++     HANDLE_S	   *handles = NULL;
++     SCROLL_S	    scrollargs;
++     STORE_S 	*store = NULL;
++     int     offset = 0;
++     
++     ps->prev_screen = smime_info_screen;
++     ps->next_screen = SCREEN_FUN_NULL;
++ 
++     if(mn_total_cur(ps->msgmap) > 1L){
++ 	q_status_message(SM_ORDER | SM_DING, 0, 3,
++ 			 "Can only view one message's information at a time.");
++ 	return;
++     }
++     /* else check for existence of smime bits */
++ 
++     msgno	       = mn_m2raw(ps->msgmap, mn_get_cur(ps->msgmap));
++     
++     env = mail_fetch_structure (ps->mail_stream,msgno,
++ 				&body,0);
++     if (!env || !body) {
++ 	q_status_message(SM_ORDER, 0, 3,
++ 			 "Can't fetch body of message.");
++ 	return;
++     }
++     
++     what	       = FirstMenu;
++ 
++     store = so_get(CharStar, NULL, EDIT_ACCESS);
++ 
++     while(ps->next_screen == SCREEN_FUN_NULL){
++ 
++     	ClearLine(1);
++ 
++ 	so_truncate(store,0);
++ 	
++ 	view_writec_init(store, &handles, HEADER_ROWS(ps),
++ 			 HEADER_ROWS(ps) + 
++ 			 ps->ttyo->screen_rows - (HEADER_ROWS(ps)
++ 						  + HEADER_ROWS(ps)));
++ 
++     	gf_puts_uline("Overview",view_writec);
++     	gf_puts(NEWLINE,view_writec);
++ 
++ 	format_smime_info(1,body,msgno,view_writec);
++ 	gf_puts(NEWLINE,view_writec);
++ 	format_smime_info(2,body,msgno,view_writec);
++ 
++ 	view_writec_destroy();
++ 
++ 
++ 	ps->next_screen = SCREEN_FUN_NULL;
++ 
++ 	memset(&scrollargs, 0, sizeof(SCROLL_S));
++ 	scrollargs.text.text	= so_text(store);
++ 	scrollargs.text.src	= CharStar;
++ 	scrollargs.text.desc	= "S/MIME information";
++ 	scrollargs.body_valid = 1;
++ 
++ 	if(offset){		/* resize?  preserve paging! */
++ 	    scrollargs.start.on		= Offset;
++ 	    scrollargs.start.loc.offset = offset;
++ 	    offset = 0L;
++ 	}
++ 
++ 	scrollargs.bar.title	= "S/MIME INFORMATION";
++ /*	scrollargs.end_scroll	= view_end_scroll; */
++ 	scrollargs.resize_exit	= 1;
++ 	scrollargs.help.text	= NULL;
++ 	scrollargs.help.title	= "HELP FOR S/MIME INFORMATION VIEW";
++ 	scrollargs.keys.menu	= &smime_info_keymenu;
++ 	scrollargs.keys.what    = what;
++ 	setbitmap(scrollargs.keys.bitmap);
++ 
++ 	if(scrolltool(&scrollargs) == MC_RESIZE)
++ 	  offset = scrollargs.start.loc.offset;
++     }
++ 
++     so_give(&store);
++ 
++ }
++ 
++ 
++ #endif /* SMIME */
+diff -Ncr pine4.53/pine/smime.h pine4.53-smime/pine/smime.h
+*** pine4.53/pine/smime.h	Wed Dec 31 16:00:00 1969
+--- pine4.53-smime/pine/smime.h	Wed Jan 15 12:48:15 2003
+***************
+*** 0 ****
+--- 1,17 ----
++ #ifdef SMIME
++ 
++ int is_pkcs7_body(BODY *b);
++ 
++ int fiddle_smime_message(BODY *b,int msgno,int is_new_message);
++ 
++ int encrypt_outgoing_message(METAENV *header,BODY **bodyP);
++ int sign_outgoing_message(METAENV *header,BODY **bodyP,int dont_detach);
++ int get_passphrase(void);
++ void smime_info_screen(struct pine *ps);
++ 
++ extern int g_need_passphrase;
++ 
++ extern int g_do_encrypt;
++ extern int g_do_sign;
++ 
++ #endif /* SMIME */
+diff -Ncr pine4.53/pine/smkeys.c pine4.53-smime/pine/smkeys.c
+*** pine4.53/pine/smkeys.c	Wed Dec 31 16:00:00 1969
+--- pine4.53-smime/pine/smkeys.c	Wed Jan 15 12:48:15 2003
+***************
+*** 0 ****
+--- 1,343 ----
++ #ifdef SMIME
++ 
++ #include "headers.h"
++ 
++ #include <openssl/err.h>
++ #include <openssl/objects.h>
++ #include <openssl/evp.h>
++ #include <openssl/x509.h>
++ #include <openssl/pkcs7.h>
++ #include <openssl/pem.h>
++ 
++ #include "smkeys.h"
++ 
++ /*---------------------------------------------------
++      Remove leading whitespace, trailing whitespace and convert 
++      to lowercase. Also remove slash characters
++ 
++    Args: s, -- The string to clean
++ 
++  Result: the cleaned string
++   ----*/
++ static char *
++ emailstrclean(string)
++      char *string;
++ {
++     char *s = string, *sc = NULL, *p = NULL;
++ 
++     for(; *s; s++){				/* single pass */
++ 	if(!isspace((unsigned char)*s)){
++ 	    p = NULL;				/* not start of blanks   */
++ 	    if(!sc)				/* first non-blank? */
++ 	      sc = string;			/* start copying */
++ 	}
++ 	else if(!p)				/* it's OK if sc == NULL */
++ 	  p = sc;				/* start of blanks? */
++ 
++ 	if(sc && *s!='/' && *s!='\\')		/* if copying, copy */
++ 	  *sc++ = isupper((unsigned char)(*s))
++ 			  ? (unsigned char)tolower((unsigned char)(*s))
++ 			  : (unsigned char)(*s);
++     }
++ 
++     if(p)					/* if ending blanks  */
++       *p = '\0';				/* tie off beginning */
++     else if(!sc)				/* never saw a non-blank */
++       *string = '\0';				/* so tie whole thing off */
++ 
++     return(string);
++ }
++ 
++ /*
++     Add a lookup for each "*.crt" file in the given directory.
++  */
++ static void add_certs_in_dir(X509_LOOKUP *lookup,const char *path)
++ {
++     char	buf[MAXPATH];
++     struct direct *d;
++     DIR	*dirp;
++     PERSONAL_CERT *result;
++ 
++     result = NULL;
++ 
++     dirp = opendir(path);
++     if (dirp) {
++ 
++         while (d=readdir(dirp)) {
++             BIO *in;
++             X509 *cert;
++ 
++             if (srchrstr(d->d_name,".crt")) {
++ 
++     	    	build_path(buf,(char*) path,d->d_name,sizeof(buf));
++ 
++     	    	X509_LOOKUP_load_file(lookup,buf,X509_FILETYPE_PEM);
++             }
++ 
++         }
++ 
++         closedir(dirp);
++     }
++ }
++ 
++ /*  Get an X509_STORE. This consists of the system
++     certs directory and any certificates in the user's
++     ~/.pine-smime/ca directory.
++  */
++ X509_STORE *get_ca_store(const char *path)
++ {
++     X509_LOOKUP	*lookup;
++     char	buf[MAXPATH];
++ 
++     X509_STORE *store;
++ 
++     store=X509_STORE_new();
++ 
++     lookup=X509_STORE_add_lookup(store,X509_LOOKUP_file());
++     
++     build_path(buf,(char*) path,"ca",sizeof(buf));
++ 
++     add_certs_in_dir(lookup,buf);
++     
++ /*    X509_LOOKUP_load_file(lookup,NULL,X509_FILETYPE_DEFAULT); */
++ 
++     lookup = X509_STORE_add_lookup(store,X509_LOOKUP_hash_dir());
++ 
++     X509_LOOKUP_add_dir(lookup,SSL_CERT_DIRECTORY,X509_FILETYPE_PEM);
++ 
++     /*			X509_STORE_set_default_paths(cert_store);
++     	X509_STORE_load_locations(cert_store,NULL,"../../certs");
++     	X509_STORE_set_verify_cb_func(cert_store,verify_callback);
++     */
++ 
++     return store;
++ }
++ 
++ static EVP_PKEY *load_key(char *file, char *pass)
++ {
++     BIO *in;
++     EVP_PKEY *key;
++     if(!(in = BIO_new_file(file, "r"))) return NULL;
++     key = PEM_read_bio_PrivateKey(in, NULL,NULL,pass);
++     BIO_free(in);
++     return key;
++ }
++ 
++ char *get_x509_name_entry(const char *key,X509_NAME *name)
++ {
++     int i,c,n;
++     char    buf[256];
++     char	*id;
++ 	
++  	if (!name)
++ 		return NULL;
++  
++     c = X509_NAME_entry_count(name);
++     
++     for (i=0;i<c;i++) {
++     	X509_NAME_ENTRY *e;
++ 	
++     	e = X509_NAME_get_entry(name,i);
++     	if (!e) continue;
++ 
++     	buf[0] = 0;
++ 		id = buf;
++ 		
++         n = OBJ_obj2nid(e->object);
++         if ((n == NID_undef) || ((id=(char*) OBJ_nid2sn(n)) == NULL)) {
++             i2t_ASN1_OBJECT(buf,sizeof(buf),e->object);
++             id = buf;
++         }
++ 
++ 		if ((strucmp(id,"email")==0) || (strucmp(id,"emailAddress")==0)) {
++ 			X509_NAME_get_text_by_OBJ(name, e->object,(char*) buf,sizeof(buf)-1);
++ 			return cpystr(buf);
++ 		}
++     }
++     return NULL;
++ }
++ 
++ char *get_x509_subject_email(X509 *x)
++ {
++ 	char* result;
++ 	result = get_x509_name_entry("email",X509_get_subject_name(x));
++ 	if ( !result ) {
++ 		result = get_x509_name_entry("emailAddress",X509_get_subject_name(x));
++ 	}
++ 
++ 	return result;
++ }
++ 
++ /*  Save the certificate for the given email address in
++     ~/.pine-smime/public.
++ 
++     Should consider the security hazards in making a file with
++     the email address that has come from the certificate.
++ 
++     The argument email is destroyed.
++  */
++ 
++ void save_cert_for(const char *path,char *email,X509 *cert)
++ {
++     char    sf[MAXPATH];
++     char    sf2[MAXPATH];
++     BIO 	*tmp;
++     
++     build_path(sf,(char*) path,"public",sizeof(sf));
++ 
++     build_path(sf2,sf,emailstrclean(email),sizeof(sf2));
++     strncat(sf2,".crt",sizeof(sf2)-1-strlen(sf2));
++     sf2[sizeof(sf2)-1] = 0;
++ 
++     tmp = BIO_new_file(sf2, "w");
++     if (tmp) {
++         X509_print(tmp,cert);
++         PEM_write_bio_X509_AUX(tmp, cert);
++         BIO_free(tmp);
++        	q_status_message1(SM_ORDER,1,1,"Saved certificate for <%s>",(char*)email);
++     } else {
++        	q_status_message1(SM_ORDER,1,1,"Couldn't save certificate for <%s>",(char*)email);
++     }
++ }
++ 
++ /*
++     Try to retrieve the certificate for the given email address.
++  */
++ X509 *get_cert_for(const char *path,const char *email)
++ {
++     char	buf[MAXPATH];
++     char	buf2[MAXPATH];
++     char    	buf3[MAXPATH];
++     char    	*p;
++     X509 *cert = NULL;
++     BIO	*in;
++ 
++     strncpy(buf3,email,sizeof(buf3)-1);
++     buf3[sizeof(buf3)-1] = 0;
++     
++     /* clean it up (lowercase, space removal) */
++     emailstrclean(buf3);
++ 
++     build_path(buf,(char*)path,"public",sizeof(buf));
++     build_path(buf2,buf,buf3,sizeof(buf2));
++     strncat(buf2,".crt",sizeof(buf2)-1-strlen(buf2));
++     buf2[sizeof(buf2)-1] = 0;
++ 	
++     if((in = BIO_new_file(buf2, "r"))!=0) {
++ 
++         cert = PEM_read_bio_X509(in, NULL, NULL,NULL);
++ 
++         if (cert) {
++             /* could check email addr in cert matches */
++         }
++     }
++     BIO_free(in);
++ 
++     return cert;
++ }
++ 
++ EVP_PKEY *get_key_for(const char *path,const char *email,const char *pass)
++ {
++     char	buf[MAXPATH];
++     char	buf2[MAXPATH];
++     char    	buf3[MAXPATH];
++     char    	*p;
++     EVP_PKEY	*key = NULL;
++     BIO	*in;
++ 
++     strncpy(buf3,email,sizeof(buf3)-1);
++     buf3[sizeof(buf3)-1] = 0;
++     
++     /* clean it up (lowercase, space removal) */
++     emailstrclean(buf3);
++ 
++     build_path(buf,(char*)path,"private",sizeof(buf));
++     build_path(buf2,buf,buf3,sizeof(buf2));
++     strncat(buf2,".key",sizeof(buf2)-1-strlen(buf2));
++     buf2[sizeof(buf2)-1] = 0;
++ 
++ 	key = load_key(buf2,pass);
++ 	
++     return key;
++ }
++ 
++ /*
++     Load the user's personal certificates from
++     ~/.pine-smime/private
++  */
++ PERSONAL_CERT *get_personal_certs(const char *path)
++ {
++     char	buf[MAXPATH];
++     char	buf2[MAXPATH];
++     struct direct *d;
++     DIR	*dirp;
++     PERSONAL_CERT *result;
++ 
++     result = NULL;
++ 
++     build_path(buf,(char*) path,"private",sizeof(buf));
++ 
++     dirp = opendir(buf);
++     if (dirp) {
++ 
++         while (d=readdir(dirp)) {
++             BIO *in;
++             X509 *cert;
++ 
++             if (srchrstr(d->d_name,".key")) {
++ 
++ 				/* copy file name to temp buffer */
++ 				strcpy(buf2,d->d_name);
++ 				/* chop off ".key" trailier */
++ 				buf2[strlen(buf2)-4] = 0;
++ 				/* Look for certificate */
++ 				cert = get_cert_for(path,buf2);
++ 
++                 if (cert) {
++                     PERSONAL_CERT	*pc;
++ 
++ 					/* create a new PERSONAL_CERT, fill it in */
++ 
++                     pc = fs_get(sizeof(PERSONAL_CERT));
++                     pc->cert = cert;
++     	    		build_path(buf2,buf,d->d_name,sizeof(buf2));
++                     pc->file = cpystr(buf2);
++ 
++                     strcpy(pc->file + strlen(pc->file) - 4, ".key");
++ 
++                     /* Try to load the key with an empty password */
++                     pc->key = load_key(pc->file,"");
++ 
++                     pc->next = result;
++                     result = pc;
++                 }
++             }
++ 
++         }
++ 
++         closedir(dirp);
++     }
++ 
++     return result;
++ }
++ 
++ void personal_cert_free(PERSONAL_CERT **pcp)
++ {
++     if (pcp && *pcp) {
++ 
++         PERSONAL_CERT	*pc = *pcp;
++ 
++         fs_give((void**) &pc->file);
++ 
++         X509_free(pc->cert);
++ 
++         if (pc->key)
++             EVP_PKEY_free(pc->key);
++ 
++         personal_cert_free(&pc->next);
++ 
++         fs_give((void**) pcp);
++     }
++ }
++ 
++ #endif /* SMIME */
+diff -Ncr pine4.53/pine/smkeys.h pine4.53-smime/pine/smkeys.h
+*** pine4.53/pine/smkeys.h	Wed Dec 31 16:00:00 1969
+--- pine4.53-smime/pine/smkeys.h	Wed Jan 15 12:48:15 2003
+***************
+*** 0 ****
+--- 1,20 ----
++ 
++ #define PERSONAL_CERT struct personal_cert
++ 
++ PERSONAL_CERT {
++     X509    	    	*cert;
++     EVP_PKEY	    	*key;
++     char    	    	*file;
++     PERSONAL_CERT   	*next;
++ };
++ 
++ X509_STORE *get_ca_store(const char *d);
++ 
++ PERSONAL_CERT *get_personal_certs(const char *d);
++ 
++ X509 *get_cert_for(const char *path,const char *email);
++ void save_cert_for(const char *path,char *email,X509 *cert);
++ 
++ void personal_cert_free(PERSONAL_CERT **pc);
++ 
++ char *get_x509_subject_email(X509 *x);
diff --git a/contrib/utils/ansiprt.c b/contrib/utils/ansiprt.c
new file mode 100755
index 00000000..17d6e068
--- /dev/null
+++ b/contrib/utils/ansiprt.c
@@ -0,0 +1,60 @@
+/*
+ * ansiprt.c
+ *
+ * Simple filter to wrap ANSI media copy escape sequences around 
+ * text on stdin.  Writes /dev/tty to get around things that might be
+ * trapping stdout.  This is actually a feature because it was written
+ * to be used with pine's personal print option set up to take "enscript"
+ * output and send it displayward to be captured/printed to a postscript 
+ * device.  Pine, of course, uses popen() to invoke the personal print
+ * command, and interprets stdout as diagnostic messages from the command.
+ *
+ * Michael Seibel, mikes@cac.washington.edu
+ *
+ * 21 Apr 92
+ *
+ */
+#include <stdio.h>
+#include <sys/file.h>
+
+#define	BUFSIZ	8192
+
+main(argc, argv)
+int  argc;
+char **argv;
+{
+    char c[BUFSIZ];
+    int  n, d;
+    int  ctrld = 0;
+
+    if(argc > 1){
+        n = 0;
+	while(argc > ++n){
+	    if(argv[n][0] == '-'){
+		switch(argv[n][1]){
+		  case 'd':
+		    ctrld++;
+		    break;
+		  default :
+		    fprintf(stderr,"unknown option: %c\n", argv[n][1]);
+		    break;
+		}
+	    }
+        }
+    }
+
+    if((d=open("/dev/tty",O_WRONLY)) < 0){
+        perror("/dev/tty");
+	exit(1);
+    }
+
+    write(d,"\033[5i", 4);
+    while((n=read(0, c, BUFSIZ)) > 0)
+	write(d, c, n);
+
+    if(ctrld)
+	write(d, "\004", 1);
+
+    write(d,"\033[4i", 4);
+    close(d);
+}
diff --git a/contrib/utils/brk2pine.sh b/contrib/utils/brk2pine.sh
new file mode 100755
index 00000000..fab1f885
--- /dev/null
+++ b/contrib/utils/brk2pine.sh
@@ -0,0 +1,74 @@
+#!/bin/sh
+#
+#            T H E    P I N E    M A I L   S Y S T E M
+#
+#   Laurence Lundblade and Mike Seibel
+#   Networks and Distributed Computing
+#   Computing and Communications
+#   University of Washington
+#   Administration Building, AG-44
+#   Seattle, Washington, 98195, USA
+#   Internet: lgl@CAC.Washington.EDU
+#             mikes@CAC.Washington.EDU
+#
+#   Please address all bugs and comments to "pine-bugs@cac.washington.edu"
+#      
+#   Copyright 1989, 1990, 1991, 1992  University of Washington
+#
+#    Permission to use, copy, modify, and distribute this software and its
+#   documentation for any purpose and without fee to the University of
+#   Washington is hereby granted, provided that the above copyright notice
+#   appears in all copies and that both the above copyright notice and this
+#   permission notice appear in supporting documentation, and that the name of
+#   the University of Washington not be used in advertising or publicity
+#   pertaining to distribution of the software without specific, written prior
+#   permission.  This software is made available "as is", and
+#   THE UNIVERSITY OF WASHINGTON DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED,
+#   WITH REGARD TO THIS SOFTWARE, INCLUDING WITHOUT LIMITATION ALL IMPLIED
+#   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, AND IN
+#   NO EVENT SHALL THE UNIVERSITY OF WASHINGTON BE LIABLE FOR ANY SPECIAL,
+#   INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+#   LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, TORT
+#   (INCLUDING NEGLIGENCE) OR STRICT LIABILITY, ARISING OUT OF OR IN CONNECTION
+#   WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+#  
+#
+#   Pine is in part based on The Elm Mail System:
+#    ***********************************************************************
+#    *  The Elm Mail System  -  $Revision: 2.13 $   $State: Exp $          *
+#    *                                                                     *
+#    * 			Copyright (c) 1986, 1987 Dave Taylor              *
+#    * 			Copyright (c) 1988, 1989 USENET Community Trust   *
+#    ***********************************************************************
+# 
+#
+
+
+
+#
+# A filter to convert personal mail aliases in a .mailrc file into
+# pine address book format.
+#
+# Usage: program [.mailrc] >> .addressbook
+#
+# Corey Satten, corey@cac.washington.edu, 9/25/91
+#
+sed -n '
+# first fold continued lines (ending in \) into a single long line
+    /\\[ 	]*$/ {
+	    : more
+	    s/\\//g
+	    N
+	    s/\n/ /
+	    /\\/b more
+	    }
+# next convert all sequences of whitespace into single space
+    s/[ 	][ 	]*/ /g
+# finally, reformat and print lines containing alias as the first word
+    /^ *alias / {
+	    s/^ *alias \([!-~][!-~]*\) \(.*\)$/\1	\1	(\2)/
+	    s/ /,/g
+	    s/(\([^,]*\))/\1/
+	    p
+	    }
+' ${*-$HOME/.mailrc}
diff --git a/contrib/utils/mailtrfc.sh b/contrib/utils/mailtrfc.sh
new file mode 100755
index 00000000..2ef69cdc
--- /dev/null
+++ b/contrib/utils/mailtrfc.sh
@@ -0,0 +1,130 @@
+#!/bin/sh
+#
+#            T H E    P I N E    M A I L   S Y S T E M
+#
+#   Laurence Lundblade and Mike Seibel
+#   Networks and Distributed Computing
+#   Computing and Communications
+#   University of Washington
+#   Administration Building, AG-44
+#   Seattle, Washington, 98195, USA
+#   Internet: lgl@CAC.Washington.EDU
+#             mikes@CAC.Washington.EDU
+#
+#   Please address all bugs and comments to "pine-bugs@cac.washington.edu"
+#      
+#   Copyright 1991, 1992  University of Washington
+#
+#    Permission to use, copy, modify, and distribute this software and its
+#   documentation for any purpose and without fee is hereby granted, provided
+#   that the above copyright notice appears in all copies and that both the
+#   above copyright notice and this permission notice appear in supporting
+#   documentation, and that the name of the University of Washington not be
+#   used in advertising or publicity pertaining to distribution of the software
+#   without specific, written prior permission.  This software is made
+#   available "as is", and
+#   THE UNIVERSITY OF WASHINGTON DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED,
+#   WITH REGARD TO THIS SOFTWARE, INCLUDING WITHOUT LIMITATION ALL IMPLIED
+#   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, AND IN
+#   NO EVENT SHALL THE UNIVERSITY OF WASHINGTON BE LIABLE FOR ANY SPECIAL,
+#   INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+#   LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, TORT
+#   (INCLUDING NEGLIGENCE) OR STRICT LIABILITY, ARISING OUT OF OR IN CONNECTION
+#   WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+#  
+#
+#   Pine is in part based on The Elm Mail System:
+#    ***********************************************************************
+#    *  The Elm Mail System  -  $Revision: 2.13 $   $State: Exp $          *
+#    *                                                                     *
+#    * 			Copyright (c) 1986, 1987 Dave Taylor              *
+#    * 			Copyright (c) 1988, 1989 USENET Community Trust   *
+#    ***********************************************************************
+# 
+#
+
+
+# 
+# mailtrfc.sh -- A shell script to analyze the mail traffic as logged in
+# /usr/spool/mqueue/syslog*. This currently as the University of Washington
+# domains wired in and needs to be made more general. Also, lots more
+# formats of message ID's could be added.
+#
+
+
+
+org=`awk '/^domain/ {print $2}' < /etc/resolv.conf`
+domain=`echo $org | sed -e 's/^[^.]*\.//'`
+host=`hostname`".$org"
+
+echo "Domain: $domain"
+echo "Organization: $org"
+echo "Hostname: $host"
+
+sed -n -e '/message-id/s/^.*</</p' |
+awk 'BEGIN {mailers[0] =  "Other";
+            mailers[1] =  "Pine";
+            mailers[2] =  "MailManager";
+            mailers[3] =  "sendmail";
+            mailers[4] =  "BITNET";
+            mailers[5] =  "? news ?";
+            mailers[6] =  "Sprint";
+            mailers[7] =  "X.400";
+            mailers[8] =  "Mac MS";
+            mailers[9] =  "MMDF";
+            mailers[10] = "Andrew";
+            mailers[11] = "Columbia MM";
+            mailers[12] = "Unknown #1";
+            mailers[13] = "EasyMail";
+            mailers[14] = "CompuServe";
+            mailers[15] = "smail";
+            mailers[16] = "MCI Mail";
+            mailers[17] = "VAX MAIL(?)";
+            mailers[18] = "Gator Mail (?)";
+            mailers[19] =  "TOTAL";
+            max = 19;}
+                                      {mailer = 0;}
+     /^<Pine/                         {mailer = 1;}
+     /^<MailManager/                  {mailer = 2;}
+     /^<[12]?[90]?9[0-9]1?[0-9][1-3]?[0-9]+\.[AaBb][AaBb][0-9]+@/ {mailer = 3;}
+     /^<[0-9A-Z]+@/                   {mailer = 4;}
+     /^<199[0-9][A-Za-z]..[0-9]*\./   {mailer = 5;}
+     /@sprint.com/                    {mailer = 6;}
+     /\/[A-Z]*=.*\/[A-Z]*=.*/         {mailer = 7;}
+     /^<MacMS\.[0-9]+\.[0-9]+\.[a-z]+@/ {mailer = 8;}
+     /^<MAILQUEUE-[0-9]+\.[0-9]+/           {mailer = 9;}
+     /^<.[d-l][A-Z0-9a-z=_]+00[A-Za-z0-9_=]+@/ {mailer = 10;}
+     /^<CMM\.[0-9]+\.[0-9]+\.[0-9]+/    {mailer = 11 ;}
+     /^<9[0-9][JFMASOND][aepuco][nbrylgptvc][0-9][0-9]?\.[0-9]+[a-z]+\./ {mailer = 12;}
+     /^<EasyMail\.[0-9]+/               {mailer = 13;}
+     /@CompuServe.COM/                  {mailer = 14;}
+     /^<m[A-Za-z0-9].....-[0-9A-Za-z].....C@/       {mailer = 15;}
+     /@mcimail.com/                     {mailer = 16;}
+     /^<9[0-9][01][0-9][0-3][0-9][0-2][0-9][0-5][0-9][0-5][0-9].[0-9a-z]*@/ {mailer = 17;}
+     /^<0[0-9][0-9]+\.[0-9][0-9][0-9][0-9]+\.[0-9][0-9]+@/ {mailer=18;}
+
+    
+
+     '"/$domain>/"'              {campus[mailer]++; campus[max]++}
+     '"/$org>/"'                 {u[mailer]++; u[max]++}
+     '"/$host>/"'                {milton[mailer]++; milton[max]++}
+                                 {total[mailer]++; total[max]++}
+                                 {if(mailer == 0) printf("-->%s\n",$0)}
+     END {
+            for(m = 0; m <= max; m++)  {
+                printf("%-10.10s", mailers[m]);
+                printf(" %11d %11d %11d %11d %11d (%3d%%)\n",  milton[m], u[m] - milton[m], campus[m] -u[m], total[m] - campus[m], total[m], (total[m]*100)/total[max]);
+            }
+            printf(" ----           (%3d%%)      (%3d%%)      (%3d%%)      (%3d%%)\n", (milton[max]*100)/total[max], ((u[max] - milton[max])*100)/total[max], ((campus[max] - u[max])*100)/total[max], ((total[max] - campus[max])*100)/total[max], (u[max]*100)/total[max]);
+
+        }' > /tmp/syslogx.$$
+
+
+echo $host $org $domain | \
+  awk '{printf("     %.17s %.11s %.11s  Off Campus        Total\n", $1, $2, $3)}'
+egrep -v 'TOTAL|----|^-->' /tmp/syslogx.$$ | sort +0.60rn 
+egrep  'TOTAL|----' /tmp/syslogx.$$
+grep  '^-->' /tmp/syslogx.$$ | sed -e 's/-->//' > other-traffic
+rm -f /tmp/syslogx.$$
+
+
diff --git a/contrib/utils/pwd2pine b/contrib/utils/pwd2pine
new file mode 100755
index 00000000..49b3de65
--- /dev/null
+++ b/contrib/utils/pwd2pine
@@ -0,0 +1,73 @@
+#!/usr/local/bin/perl
+#
+# passwd2pine - translate passwd to pine addressbook
+#
+# Author: Paul J Murphy <pjm@dcs.ed.ac.uk>
+#
+# The fullname field will end up falling into one of the following cases:
+#
+#   Last, First		- A person
+#   }group: fullname	- A non-person (determined by group or uid/gid < 1024)
+#   ~user: fullname	- A non-person (determined by username or fullname)
+#
+# This allows the output to be sorted by fullname, with administrative
+# accounts left to last (ie the real people come first).
+#
+# The comment field will contain the groupname of the user, followed by
+#   anything from the gecos field which seems to be a comment and not part
+#   of the name.
+
+### Start of configurable stuff
+
+$domain = "dcs.ed.ac.uk";
+
+# Regular expression for groups which don't contain people
+#   Case is significant.
+#   The expression must match the entire groupname string.
+$non_people_groups = "local|misc|aliens|cs_dept|\\d*";
+
+# Regular expression for users which are not people
+#   Case is significant.
+#   The expression must match the entire username string.
+$non_people_users = ".*\\d.*";
+
+# Regular expression for words within a fullname which signify a non-person
+#   Case is not significant.
+#   The expression must match an entire word within the gecos fullname.
+$non_people_names = "account|admin|user|system|crew|test|dummy|\
+unit|department|student|project|.*\\d.*";
+
+### End of configurable stuff
+
+while(<>) {
+    chop;
+    ($user, $passwd, $uid, $gid, $gecos, $homedir, $shell) = split(/:/, $_, 7);
+    unless ($gr_name = getgrgid($gid)) {
+	$gr_name = $gid;
+    }
+
+    $nickname = $user;
+
+    $fullname = $gecos;
+    $fullname =~ s/,.*//g;	# Reduce gecos to fullname
+    $fullname =~ s/[._]/ /g;	# Translate alternate name separators to space
+    if ($uid < 1024 ||
+	$gid < 1024 ||
+	$gr_name =~ /^($non_people_groups)$/o) {
+	$fullname = "}$gr_name: $fullname";
+    } elsif ($user =~ /^($non_people_users)$/o ||
+	     $fullname =~ /\b($non_people_names)\b/io) {
+	$fullname = "~$user: $fullname";
+    } elsif (($firstname, $lastname, $gecos_comment) =
+	     ($fullname =~ /^(.*)[._ ]([^._ \d(][^._ \d]+)( *\(.*)?$/)) {
+	$fullname = "$lastname, $firstname";
+    }
+
+    $address = "$user\@$domain";
+
+#   $fcc = "";
+
+    $comment = "$gr_name$gecos_comment";
+
+    print "$nickname\t$fullname\t$address\t$fcc\t$comment\n";
+}
diff --git a/contrib/utils/sendit.sh b/contrib/utils/sendit.sh
new file mode 100755
index 00000000..a8600f00
--- /dev/null
+++ b/contrib/utils/sendit.sh
@@ -0,0 +1,49 @@
+#! /bin/sh
+#
+# $Id:$
+#
+#            T H E    P I N E    M A I L   S Y S T E M
+#
+#   Mike Seibel
+#   Networks and Distributed Computing
+#   Computing and Communications
+#   University of Washington
+#   Administration Building, AG-44
+#   Seattle, Washington, 98195, USA
+#   Internet: mikes@CAC.Washington.EDU
+#
+#   Please address all bugs and comments to "pine-bugs@cac.washington.edu"
+#
+#
+#   Pine and Pico are registered trademarks of the University of Washington.
+#   No commercial use of these trademarks may be made without prior written
+#   permission of the University of Washington.
+#
+#   Pine, Pico, and Pilot software and its included text are Copyright
+#   1989-1996 by the University of Washington.
+#
+#   The full text of our legal notices is contained in the file called
+#   CPYRIGHT, included with this distribution.
+#
+
+
+#
+#  Simple script to expedite mail posting at the expense of timely
+#  error reporting and 8BITMIME support.
+#
+# NOTE: If for any reason POSTFILE below is created on an nfs mounted
+#       file system, the trap statement below must get removed or
+#       altered, and the last line must get replaced with:
+#
+#       ( ${POSTTOOL} ${POSTARGS} < ${POSTFILE} ; rm -f ${POSTFILE} ) &
+#
+
+POSTFILE=/tmp/send$$
+POSTTOOL=/usr/lib/sendmail
+POSTARGS="-oi -oem -t"
+
+umask 077
+trap "rm -f ${POSTFILE}; exit 0" 0 1 2 13 15
+
+cat > ${POSTFILE}
+${POSTTOOL} ${POSTARGS} < ${POSTFILE} & 
diff --git a/contrib/utils/sendtoall b/contrib/utils/sendtoall
new file mode 100644
index 00000000..f929f527
--- /dev/null
+++ b/contrib/utils/sendtoall
@@ -0,0 +1,49 @@
+Date: 13 Sep 1996 22:49:40 GMT
+From: William Burrow <aa126@fan1.fan.nb.ca>
+To: pine-info@cac.washington.edu
+Subject: Re: Composing mail to all entries in addressbook
+
+Ari Y. Weintraub (aweintra@umabnet.ab.umd.edu) wrote:
+: Is there any way in Pine 3.94 to compose mail to all of the entries in my
+: addressbook. For example, I recently changed my phone number and would
+: like to send one message to everybody with the new number. I can't find a
+: way to do this - does anyone out there have any idea? TIA
+
+This would be a nice suggestion for Pine, however, you can do pretty much
+the same in Unix using the following awk script.  Copy everything between the
+lines into a file named:  everyone 
+
+-------------%< clip --------------
+{
+    printf("everyone\tEveryone\t(");  
+  
+    if ( $0 ~ /\(/ )
+        continue
+    else
+        printf("%s", $1);  
+
+    while ( getline > 0 ) {
+        if ( $0 ~ /\(/ )
+            continue
+        else
+            printf(",%s", $1);
+    }
+    printf(")\n"); 
+}
+-------------%< clip --------------
+
+Now, type the following exactly at the Unix prompt:
+
+awk -f everyone < ~/.addressbook >> ~/.addressbook && echo Done.
+
+You may wish to first copy your ~/.addressbook file to a backup file, 
+before executing this command. 
+
+If everything went well, it should say Done.  When you start Pine, there
+should now be a list in your address book with the name:  everyone,
+containing all of your address book nicknames (but NOT other lists). 
+
+
+--
+--
+William Burrow  --  Fredericton Area Network
diff --git a/contrib/utils/txtcc.sh b/contrib/utils/txtcc.sh
new file mode 100755
index 00000000..0d1bb8c9
--- /dev/null
+++ b/contrib/utils/txtcc.sh
@@ -0,0 +1,85 @@
+#!/bin/sh
+
+# On ultrix, this will compile string constants into the text segment
+# where they can be shared.  Use to build pine by saying:
+#
+#	build CC=txtcc gul
+#
+# As of Pine4.03, this moves about 675k per process into sharable memory
+#
+# Corey Satten, corey@cac.washington.edu, 9/11/98
+
+TMP1=/tmp/cc$$.s
+TMP2=/tmp/cc$$.delayed
+trap "rm -f $TMP1 $TMP2" 0 1 2 13 15
+
+
+for i in "$@"; do
+    case "$oflag//$i" in
+	 //-c)  cflag=1;;
+	 //-o)  oflag=1;;
+	 //-g)	gflag=1;;
+	1//*)   ofile="$i"; oflag=;;
+	 //*.c) cfile="$i"; : ${ofile=`basename $i .c`.o};;
+    esac
+done
+    
+case "$cflag" in
+     1) sfile=`basename $ofile .o`.s
+	gcc -S "$@"
+
+	# Postprocess assembly language to move strings to .text segment.
+	#
+	# Use sed to collect .ascii statements and their preceding label
+	# and .align and emit those to $TMP2, the rest to $TMP1.
+	#
+	# Start in state0
+	# In state0:  if .align is seen  -> state1; else print, -> state0
+	# In state1:  if a label is seen -> state2; else -> punt
+	# In state2:  if .ascii is seen  -> state3; else -> punt
+	# In state3:  if .ascii is seen  -> state4; else write TMP2, -> state0
+	# In state4:  append to buffer,  -> state3
+	# In state punt:  print unprinted lines, -> state0
+	# 
+	sed '
+	    : state0
+	    /^[ 	][ 	]*\.align/ b state1
+	    b
+
+	    : state1
+	    h
+	    N; s/^[^\n]*\n//; H
+	    /^[!-~]*:/ b state2
+	    b punt
+
+	    : state2
+	    N; s/^[^\n]*\n//; H
+	    /^[ 	][ 	]*\.ascii/ b state3
+	    b punt
+
+	    : state3
+	    N; s/^[^\n]*\n//
+	    /^[ 	][ 	]*\.ascii/ b state4
+	    x
+	    w '"$TMP2"'
+	    x
+	    b state0
+
+	    : state4
+	    H
+	    b state3
+
+	    : punt
+	    x
+	    ' $sfile > $TMP1
+
+	# now add the deferred .ascii statements to .text segment in $TMP1
+	echo '	.text' >> $TMP1
+	cat $TMP2 >> $TMP1
+
+	rm `basename $ofile .o`.s
+	gcc ${gflag+"-g"} -c -o $ofile $TMP1
+	;;
+    *)  gcc "$@"
+	;;
+esac
author	Eduardo Chappa <echappa@gmx.com>	2013-02-03 00:59:38 -0700
committer	Eduardo Chappa <echappa@gmx.com>	2013-02-03 00:59:38 -0700
commit	094ca96844842928810f14844413109fc6cdd890 (patch)
tree	e60efbb980f38ba9308ccb4fb2b77b87bbc115f3 /contrib
download	alpine-094ca96844842928810f14844413109fc6cdd890.tar.xz