Changeset e2cbbbe

Timestamp:

Apr 8, 2010, 10:00:41 PM (14 years ago)

Author:

Nelson Elhage <nelhage@mit.edu>

Branches:

master, release-1.10, release-1.6, release-1.7, release-1.8, release-1.9

Children:

b094191

Parents:

8a5b5a1 (diff), 9a7b4f2 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'refactor-zcrypt'

Files:

• .gitignore (modified) (1 diff)
• Makefile.am (modified) (2 diffs)
• barnowl (modified) (1 diff)
• commands.c (modified) (2 diffs)
• configure.ac (modified) (3 diffs)
• filterproc.c (added)
• filterproc.h (added)
• functions.c (modified) (4 diffs)
• message.c (modified) (2 diffs)
• tester.c (modified) (3 diffs)
• util.c (modified) (1 diff)
• zcrypt.c (modified) (8 diffs)
• editwin.c (modified) (11 diffs)
• global.c (modified) (8 diffs)
• keybinding.c (modified) (3 diffs)
• keymap.c (modified) (1 diff)
• keys.c (modified) (1 diff)
• m4/ax_prog_perl_modules.m4 (added)
• owl.c (modified) (1 diff)
• owl.h (modified) (2 diffs)
• perl/lib/BarnOwl/Style/Default.pm (modified) (2 diffs)
• perlconfig.c (modified) (1 diff)
• perlglue.xs (modified) (13 diffs)
• popexec.c (modified) (3 diffs)
• scripts/add-changelog (modified) (1 diff)
• scripts/do-release (modified) (2 diffs)
• scripts/locker-build (modified) (2 diffs)
• variable.c (modified) (1 diff)
• zephyr.c (modified) (2 diffs)

.gitignore

@@ -15 +15 @@
 autom4te.cache
 barnowl.bin
+zcrypt
 blib
 config.cache

Makefile.am

@@ -5 +5 @@
 
 bin_PROGRAMS = barnowl.bin
+if ENABLE_ZCRYPT
+bin_PROGRAMS += zcrypt
+endif
+
+zcrypt_SOURCES = zcrypt.c filterproc.c
+
 check_PROGRAMS = tester perl_tester
 
 barnowl_bin_SOURCES = $(BASE_SRCS) \
      owl.h owl_perl.h config.h \
-     owl.c \
+     owl.c filterproc.c \
      $(GEN_C) $(GEN_H)
 
@@ -38 +44 @@
      perlconfig.c keys.c functions.c zwrite.c viewwin.c help.c filter.c \
      regex.c history.c view.c dict.c variable.c filterelement.c pair.c \
-     keypress.c keymap.c keybinding.c cmd.c context.c zcrypt.c \
+     keypress.c keymap.c keybinding.c cmd.c context.c \
      aim.c buddy.c buddylist.c style.c errqueue.c \
      zbuddylist.c popexec.c obarray.c select.c wcwidth.c \

barnowl

@@ -13 +13 @@
 
 export BARNOWL_DATA_DIR="$SRCDIR/perl/"
+export BARNOWL_BIN_DIR="$SRCDIR/"
 exec "$EXE" "$@"

commands.c

@@ -2022 +2022 @@
 char *owl_command_zcrypt(int argc, const char *const *argv, const char *buff)
 {
-#ifdef OWL_ENABLE_ZCRYPT
   owl_zwrite z;
 
@@ -2044 +2043 @@
   }
   return(NULL);
-#else
-  owl_function_makemsg("This Owl does not support zcrypt");
-  return NULL;
-#endif
 }
 

configure.ac

@@ -65 +65 @@
 
 AC_CHECK_FUNCS([use_default_colors resizeterm])
-AC_CHECK_FUNCS([des_string_to_key des_key_sched des_ecb_encrypt])
-AC_CHECK_FUNCS([DES_string_to_key DES_ecb_encrypt DES_key_sched])
+AC_CHECK_FUNCS([des_string_to_key DES_string_to_key], [HAVE_DES_STRING_TO_KEY=1])
+AC_CHECK_FUNCS([des_ecb_encrypt DES_ecb_encrypt], [HAVE_DES_ECB_ENCRYPT=1])
+AC_CHECK_FUNCS([des_key_sched DES_key_sched], [HAVE_DES_KEY_SCHED=1])
 
 dnl Checks for header files.
@@ -118 +119 @@
 AC_DEFINE_UNQUOTED([DATADIR],["${prefix}/share/${PACKAGE}"],
                    [Package data directory])
+AC_DEFINE_UNQUOTED([BINDIR],["${prefix}/bin"],
+                   [Binary directory])
 
 dnl Checks for typedefs, structures, and compiler characteristics.
@@ -126 +129 @@
 AX_C_CHECK_FLAG([-Wno-pointer-sign],[],[],
   [LIBFAIM_CFLAGS="$LIBFAIM_CFLAGS -Wno-pointer-sign"])
+
+AM_CONDITIONAL([ENABLE_ZCRYPT], [test "$HAVE_DES_STRING_TO_KEY" && dnl
+                                 test "$HAVE_DES_KEY_SCHED" && dnl
+                                 test "$HAVE_DES_ECB_ENCRYPT"])
 
 AC_SUBST([LIBFAIM_CFLAGS])

functions.c

@@ -12 +12 @@
 #include <signal.h>
 #include "owl.h"
+#include "filterproc.h"
 
 char *owl_function_command(const char *cmdbuff)
@@ -399 +400 @@
   char *cryptmsg;
   owl_message *m;
+  const char *argv[7];
+  char *zcrypt;
+  int rv, status;
 
   /* create the zwrite and send the message */
@@ -408 +412 @@
 
   mymsg=owl_zwrite_get_message(&z);
-#ifdef OWL_ENABLE_ZCRYPT
-  cryptmsg = owl_zcrypt_encrypt(mymsg, owl_zwrite_get_class(&z), owl_zwrite_get_instance(&z));
-  if (!cryptmsg) {
+
+  zcrypt = owl_sprintf("%s/zcrypt", owl_get_bindir());
+  argv[0] = "zcrypt";
+  argv[1] = "-E";
+  argv[2] = "-c"; argv[3] = owl_zwrite_get_class(&z);
+  argv[4] = "-i"; argv[5] = owl_zwrite_get_instance(&z);
+  argv[6] = NULL;
+
+  rv = call_filter(zcrypt, argv, mymsg, &cryptmsg, &status);
+
+  owl_free(zcrypt);
+
+  if (rv || status) {
+    if(cryptmsg) owl_free(cryptmsg);
     owl_function_error("Error in zcrypt, possibly no key found.  Message not sent.");
     owl_function_beep();
@@ -416 +431 @@
     return;
   }
-#else
-  cryptmsg=owl_strdup(mymsg);
-#endif
 
   owl_zwrite_set_message(&z, cryptmsg);

message.c

@@ -10 +10 @@
 #include <time.h>
 #include "owl.h"
+#include "filterproc.h"
 
 static owl_fmtext_cache fmtext_cache[OWL_FMTEXT_CACHE_SIZE];
@@ -838 +839 @@
   owl_free(tmp);
 
-#ifdef OWL_ENABLE_ZCRYPT
   /* if zcrypt is enabled try to decrypt the message */
   if (owl_global_is_zcrypt(&g) && !strcasecmp(n->z_opcode, "crypt")) {
-    char *out = owl_zcrypt_decrypt(owl_message_get_body(m), owl_message_get_class(m), owl_message_get_instance(m));
-    if (out) {
+    const char *argv[] = {
+      "zcrypt",
+      "-D",
+      "-c", owl_message_get_class(m),
+      "-i", owl_message_get_instance(m),
+      NULL
+    };
+    char *out;
+    int rv;
+    int status;
+    char *zcrypt;
+
+    zcrypt = owl_sprintf("%s/zcrypt", owl_get_bindir());
+
+    rv = call_filter(zcrypt, argv, owl_message_get_body(m), &out, &status);
+    owl_free(zcrypt);
+
+    if(!rv && !status) {
+      int len = strlen(out);
+      if(len >= 8 && !strcmp(out + len - 8, "**END**\n")) {
+        out[len - 8] = 0;
+      }
       owl_message_set_body(m, out);
       owl_free(out);
+    } else if(out) {
+      owl_free(out);
     }
   }
-#endif  
 }
 #else

tester.c

@@ -13 +13 @@
 int owl_obarray_regtest(void);
 int owl_editwin_regtest(void);
-#ifdef OWL_ENABLE_ZCRYPT
-int owl_zcrypt_regtest(void);
-#endif
 
 int main(int argc, char **argv, char **env)
@@ -36 +33 @@
   numfailures += owl_obarray_regtest();
   numfailures += owl_editwin_regtest();
-#ifdef OWL_ENABLE_ZCRYPT
-  numfailures += owl_zcrypt_regtest();
-#endif
   if (numfailures) {
       fprintf(stderr, "# *** WARNING: %d failures total\n", numfailures);
@@ -367 +361 @@
   return numfailed;
 }
-
-#ifdef OWL_ENABLE_ZCRYPT
-int owl_zcrypt_regtest(void)
-{
-  int numfailed = 0;
-  char *encrypted, *decrypted;
-
-  printf("# BEGIN testing owl_zcrypt\n");
-
-  encrypted = owl_zcrypt_encrypt_with_key("Hello, world!", "seekritkey");
-  FAIL_UNLESS("zcrypt encrypt", strcmp(encrypted, "TLJMKQSIGKSJRIJRSIIPIJFFULKRJSPK") == 0);
-  decrypted = owl_zcrypt_decrypt_with_key(encrypted, "seekritkey");
-  FAIL_UNLESS("zcrypt decrypt", strcmp(decrypted, "Hello, world!") == 0);
-  owl_free(decrypted);
-  owl_free(encrypted);
-
-  printf("# END testing owl_zcrypt (%d failures)\n", numfailed);
-
-  return numfailed;
-}
-#endif

util.c

@@ -609 +609 @@
 }
 
+const char * owl_get_bindir(void)
+{
+  const char * bindir = getenv("BARNOWL_BIN_DIR");
+  if(bindir != NULL)
+    return bindir;
+  return BINDIR;
+}
+
 /* Strips format characters from a valid utf-8 string. Returns the
    empty string if 'in' does not validate. */

zcrypt.c

@@ -1 @@
-/* This file is stolen and slightly modified code */
-
 /* zcrypt.c -- Read in a data stream from stdin & dump a decrypted/encrypted *
  *   datastream.  Reads the string to make the key from from the first       *
@@ -10 +8 @@
 
 #include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-#include "owl.h"
-
-#ifdef OWL_ENABLE_ZCRYPT
-
-#define BASE_CODE 70
-#define LAST_CODE (BASE_CODE + 15)
-#define OUTPUT_BLOCK_SIZE 16
+
 #include <unistd.h>
 #include <sys/types.h>
+#include <zephyr/zephyr.h>
+#include <glib.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <ctype.h>
 
 #ifdef HAVE_KERBEROS_IV
@@ -30 +24 @@
 #endif
 
-#define MAX_KEY 128
+#include "filterproc.h"
+
+#define MAX_KEY      128
+#define MAX_LINE     128
+#define MAX_RESULT   4096
+
+#ifndef TRUE
+#define TRUE -1
+#endif
+#ifndef FALSE
+#define FALSE 0
+#endif
 
 #define ZWRITE_OPT_NOAUTH     (1<<0)
@@ -48 +53 @@
 
 char *GetZephyrVarKeyFile(const char *whoami, const char *class, const char *instance);
+int ParseCryptSpec(const char *spec, const char **keyfile);
+char *BuildArgString(char **argv, int start, int end);
+char *read_keystring(const char *keyfile);
+
+int do_encrypt(int zephyr, const char *class, const char *instance,
+               ZWRITEOPTIONS *zoptions, const char* keyfile, int cipher);
+int do_encrypt_des(const char *keyfile, const char *in, int len, FILE *out);
+int do_encrypt_aes(const char *keyfile, const char *in, int len, FILE *out);
+
+int do_decrypt(const char *keyfile, int cipher);
+int do_decrypt_aes(const char *keyfile);
+int do_decrypt_des(const char *keyfile);
+
 
 #define M_NONE            0
@@ -56 +74 @@
 #define M_SETKEY          5
 
-static void owl_zcrypt_string_to_schedule(const char *keystring, des_key_schedule *schedule) {
+enum cipher_algo {
+  CIPHER_DES,
+  CIPHER_AES,
+  NCIPHER
+};
+
+typedef struct {
+  int (*encrypt)(const char *keyfile, const char *in, int len, FILE *out);
+  int (*decrypt)(const char *keyfile);
+} cipher_pair;
+
+cipher_pair ciphers[NCIPHER] = {
+  [CIPHER_DES] { do_encrypt_des, do_decrypt_des},
+  [CIPHER_AES] { do_encrypt_aes, do_decrypt_aes},
+};
+
+static void owl_zcrypt_string_to_schedule(char *keystring, des_key_schedule *schedule) {
 #ifdef HAVE_KERBEROS_IV
   des_cblock key;
@@ -67 +101 @@
 }
 
-/* The 'owl_zcrypt_decrypt' function was written by kretch for Owl.
- * Decrypt the message in 'in' on class 'class' and instance
- * 'instance'.  Return must be freed by caller.
- */
-char *owl_zcrypt_decrypt(const char *in, const char *class, const char *instance)
-{
-  char *fname, keystring[MAX_KEY];
-  FILE *fkey;
-  
-  fname=GetZephyrVarKeyFile("zcrypt", class, instance);
-  if (!fname) return NULL;
-  fkey=fopen(fname, "r");
-  owl_free(fname);
-  if (!fkey) return NULL;
-  if (!fgets(keystring, MAX_KEY-1, fkey)) {
-    fclose(fkey);
-    return NULL;
-  }
-  fclose(fkey);
-
-  return owl_zcrypt_decrypt_with_key(in, keystring);
-}
-
-char *owl_zcrypt_decrypt_with_key(const char *in, const char *keystring)
-{
-  const char *inptr, *endptr;
-  char *out;
-  des_key_schedule schedule;
-  unsigned char input[8], output[8];
-  int i, c1, c2;
-
-  /* We read in some number of full 16-byte blocks and write out the
-   * same number of 8-byte blocks, plus a null terminator.
-   */
-  out = owl_malloc((strlen(in) / 16) * 8 + 1);
-
-  strcpy(out, "");
-
-  output[0] = '\0';    /* In case no message at all                 */
-
-  owl_zcrypt_string_to_schedule(keystring, &schedule);
-
-  inptr=in;
-  endptr = in + strlen(in);
-  while (inptr + 16 <= endptr) {
-    for (i=0; i<8; i++) {
-      c1=(inptr[0])-BASE_CODE;
-      c2=(inptr[1])-BASE_CODE;
-      input[i]=c1 * 0x10 + c2;
-      inptr+=2;
-    }
-    des_ecb_encrypt(&input, &output, schedule, FALSE);
-    strncat(out, (const char *)output, 8);
-  }
-
-  return out;
-}
-
-char *owl_zcrypt_encrypt(const char *in, const char *class, const char *instance)
-{
-  char *fname, keystring[MAX_KEY];
-  FILE *fkey;
-
-  fname=GetZephyrVarKeyFile("zcrypt", class, instance);
-  if (!fname) return NULL;
-  fkey=fopen(fname, "r");
-  owl_free(fname);
-  if (!fkey) return NULL;
-  if (!fgets(keystring, MAX_KEY-1, fkey)) {
-    fclose(fkey);
-    return NULL;
-  }
-  fclose(fkey);
-
-  return owl_zcrypt_encrypt_with_key(in, keystring);
-}
-
-char *owl_zcrypt_encrypt_with_key(const char *in, const char *keystring)
-{
-  des_key_schedule schedule;
-  char *out;
-  unsigned char input[8], output[8];
-  int size, length, i;
-  const char *inbuff = NULL, *inptr;
-  int num_blocks=0, last_block_size=0;
-
-  owl_zcrypt_string_to_schedule(keystring, &schedule);
-
-  /* Allocate enough space for the crypted message. For each byte of
-   * the message, the encoded cyphertext will have two bytes. Block
-   * size is 8 bytes of input, or 16 bytes of output, so make sure we
-   * have at least one block worth of space allocated. If the message
-   * is empty, no blocks are sent, but we still allocate one
-   * block. The additional 16 bytes also provide space for the null
-   * terminator, as we will never use all of it for cyphertext.
-   */
-  out = owl_malloc((strlen(in) * 2) + 16);
-
-  inbuff=in;
-  length=strlen(inbuff);
-  num_blocks=(length+7)/8;
-  last_block_size=((length+7)%8)+1;
-
-  strcpy(out, "");
-  
-  inptr=inbuff;
-  while (TRUE) {
-    /* Get 8 bytes from buffer */
-    if (num_blocks > 1) {
-      size = 8;
-      memcpy(input, inptr, size);
-      inptr+=8;
-      num_blocks--;
-    } else if (num_blocks == 1) {
-      size=last_block_size;
-      memcpy(input, inptr, size);
-      num_blocks--;
-    } else {
-      size=0;
-    }
-
-    /* Check for EOF and pad the string to 8 chars, if needed */
-    if (size == 0) break;     /* END OF INPUT: BREAK FROM while LOOP! */
-      
-    if (size<8) memset(input + size, 0, 8 - size);
-
-    /* Encrypt and output the block */
-    des_ecb_encrypt(&input, &output, schedule, TRUE);
-
-    for (i = 0; i < 8; i++) {
-      sprintf(out + strlen(out), "%c", ((output[i] & 0xf0) >> 4) + BASE_CODE);
-      sprintf(out + strlen(out), "%c", (output[i] & 0x0f)        + BASE_CODE);
-    }
-
-    if (size < 8) break;
-  }
-  return out;
-}
-
+int main(int argc, char *argv[])
+{
+  char *cryptspec = NULL;
+  const char *keyfile;
+  int cipher;
+  int error = FALSE;
+  int zephyr = FALSE;
+  char *class = NULL, *instance = NULL;
+  int mode = M_NONE;
+
+  extern int optind, opterr;
+  extern char *optarg;
+  char c;
+
+  int messageflag = FALSE;
+  ZWRITEOPTIONS zoptions;
+  zoptions.flags = 0;
+
+  while ((c = getopt(argc, argv, "ZDERSF:c:i:advqtluons:f:m")) != (char)EOF)
+  {
+    switch(c)
+    {
+      case 'Z':
+        /* Zephyr encrypt */
+        mode = M_ZEPHYR_ENCRYPT;
+        break;
+      case 'D':
+        /* Decrypt */
+        mode = M_DECRYPT;
+        break;
+      case 'E':
+        /* Encrypt */
+        mode = M_ENCRYPT;
+        break;
+      case 'R':
+        /* Randomize the keyfile */
+        mode = M_RANDOMIZE;
+        break;
+      case 'S':
+        /* Set a new key value from stdin */
+        mode = M_SETKEY;
+        break;
+      case 'F':
+        /* Specify the keyfile explicitly */
+        if (cryptspec != NULL) error = TRUE;
+        cryptspec = optarg;
+        break;
+      case 'c':
+        /* Zwrite/zcrypt: class name */
+        if (class != NULL) error = TRUE;
+        class = optarg;
+        break;
+      case 'i':
+        /* Zwrite/zcrypt: instance name */
+        if (instance != NULL) error = TRUE;
+        instance = optarg;
+        break;
+      case 'a':
+        /* Zwrite: authenticate (default) */
+        zoptions.flags &= ~ZWRITE_OPT_NOAUTH;
+        break;
+      case 'd':
+        /* Zwrite: do not authenticate */
+        zoptions.flags |= ZWRITE_OPT_NOAUTH;
+        break;
+      case 'v':
+        /* Zwrite: verbose */
+        zoptions.flags |= ZWRITE_OPT_VERBOSE;
+        break;
+      case 'q':
+        /* Zwrite: quiet */
+        zoptions.flags |= ZWRITE_OPT_QUIET;
+        break;
+      case 't':
+        /* Zwrite: no expand tabs (ignored) */
+        break;
+      case 'l':
+        /* Zwrite: ignore '.' on a line by itself (ignored) */
+        zoptions.flags |= ZCRYPT_OPT_IGNOREDOT;
+        break;
+      case 'u':
+        /* Zwrite: urgent message */
+        instance = "URGENT";
+        break;
+      case 'o':
+        /* Zwrite: ignore zephyr variables zwrite-class, zwrite-inst, */
+        /*         zwrite-opcode */
+        zoptions.flags |= ZWRITE_OPT_IGNOREVARS;
+        break;
+      case 'n':
+        /* Zwrite: prevent PING message (always used) */
+        break;
+      case 's':
+        /* Zwrite: signature */
+        zoptions.flags |= ZWRITE_OPT_SIGNATURE;
+        zoptions.signature = optarg;
+        break;
+      case 'f':
+        /* Zwrite: file system specification (ignored) */
+        break;
+      case 'm':
+        /* Message on rest of line*/
+        messageflag = TRUE;
+        break;
+      case '?':
+        error = TRUE;
+        break;
+    }
+    if (error || messageflag)
+      break;
+  }
+
+  if (class != NULL || instance != NULL)
+    zephyr = TRUE;
+
+  if (messageflag)
+  {
+    zoptions.flags |= ZCRYPT_OPT_MESSAGE;
+    zoptions.message = BuildArgString(argv, optind, argc);
+    if (!zoptions.message)
+    {
+      fprintf(stderr, "Memory allocation error.\n");
+      error = TRUE;
+    }
+  }
+  else if (optind < argc)
+  {
+    error = TRUE;
+  }
+
+  if (mode == M_NONE)
+    mode = (zephyr?M_ZEPHYR_ENCRYPT:M_ENCRYPT);
+
+  if (mode == M_ZEPHYR_ENCRYPT && !zephyr)
+    error = TRUE;
+
+  if (!error && cryptspec == NULL && (class != NULL || instance != NULL)) {
+    cryptspec = GetZephyrVarKeyFile(argv[0], class, instance);
+    if(!cryptspec) {
+      fprintf(stderr, "Unable to find keyfile for ");
+      if(class != NULL) {
+        fprintf(stderr, "-c %s ", class);
+      }
+      if(instance != NULL) {
+        fprintf(stderr, "-i %s ", instance);
+      }
+      fprintf(stderr, "\n");
+      exit(-1);
+    }
+  }
+
+  if (error)
+  {
+    fprintf(stderr, "Usage: %s [-Z|-D|-E|-R|-S] [-F Keyfile] [-c class] [-i instance]\n", argv[0]);
+    fprintf(stderr, "       [-advqtluon] [-s signature] [-f arg] [-m message]\n");
+    fprintf(stderr, "  One or more of class, instance, and keyfile must be specified.\n");
+    exit(1);
+  }
+
+  cipher = ParseCryptSpec(cryptspec, &keyfile);
+  if(cipher < 0) {
+    fprintf(stderr, "Invalid cipher specification: %s\n", cryptspec);
+    exit(1);
+  }
+
+
+  if (mode == M_RANDOMIZE)
+  {
+    /* Choose a new, random key */
+    /*
+      FILE *fkey = fopen(fname, "w");
+      if (!fkey)
+      printf("Could not open key file for writing: %s\n", fname);
+      else
+      {
+      char string[100];
+      fputs(fkey, string);
+      fclose(fkey);
+      }
+    */
+    fprintf(stderr, "Feature not yet implemented.\n");
+  }
+  else if (mode == M_SETKEY)
+  {
+    /* Set a new, user-entered key */
+    char newkey[MAX_KEY];
+    FILE *fkey;
+
+    if (isatty(0))
+    {
+      printf("Enter new key: ");
+      /* Really should read without echo!!! */
+    }
+    if(!fgets(newkey, MAX_KEY - 1, stdin)) {
+      fprintf(stderr, "Error reading key.\n");
+      return 1;
+    }
+
+    fkey = fopen(keyfile, "w");
+    if (!fkey)
+      fprintf(stderr, "Could not open key file for writing: %s\n", keyfile);
+    else
+    {
+      if (fputs(newkey, fkey) != strlen(newkey) || putc('\n', fkey) != '\n')
+      {
+        fprintf(stderr, "Error writing to key file.\n");
+        fclose(fkey);
+        exit(1);
+      }
+      else
+      {
+        fclose(fkey);
+        fprintf(stderr, "Key update complete.\n");
+      }
+    }
+  }
+  else
+  {
+    if (mode == M_ZEPHYR_ENCRYPT || mode == M_ENCRYPT)
+      error = !do_encrypt((mode == M_ZEPHYR_ENCRYPT), class, instance,
+                          &zoptions, keyfile, cipher);
+    else
+      error = !do_decrypt(keyfile, cipher);
+  }
+
+  /* Always print the **END** message if -D is specified. */
+  if (mode == M_DECRYPT)
+    printf("**END**\n");
+
+  return error;
+}
+
+int ParseCryptSpec(const char *spec, const char **keyfile) {
+  int cipher = CIPHER_DES;
+  char *cipher_name = strdup(spec);
+  char *colon = strchr(cipher_name, ':');
+
+  *keyfile = spec;
+
+  if (colon) {
+    char *rest = strchr(spec, ':') + 1;
+    while(isspace(*rest)) rest++;
+
+    *colon-- = '\0';
+    while (colon >= cipher_name && isspace(*colon)) {
+      *colon = '\0';
+    }
+
+    if(strcmp(cipher_name, "AES") == 0) {
+      cipher = CIPHER_AES;
+      *keyfile = rest;
+    } else if(strcmp(cipher_name, "DES") == 0) {
+      cipher = CIPHER_DES;
+      *keyfile = rest;
+    }
+  }
+
+  free(cipher_name);
+
+  return cipher;
+}
+
+/* Build a space-separated string from argv from elements between start  *
+ * and end - 1.  malloc()'s the returned string. */
+char *BuildArgString(char **argv, int start, int end)
+{
+  int len = 1;
+  int i;
+  char *result;
+
+  /* Compute the length of the string.  (Plus 1 or 2) */
+  for (i = start; i < end; i++)
+    len += strlen(argv[i]) + 1;
+
+  /* Allocate memory */
+  result = (char *)malloc(len);
+  if (result)
+  {
+    /* Build the string */
+    char *ptr = result;
+    /* Start with an empty string, in case nothing is copied. */
+    *ptr = '\0';
+    /* Copy the arguments */
+    for (i = start; i < end; i++)
+    {
+      char *temp = argv[i];
+      /* Add a space, if not the first argument */
+      if (i != start)
+        *ptr++ = ' ';
+      /* Copy argv[i], leaving ptr pointing to the '\0' copied from temp */
+      while ((*ptr = *temp++))
+        ptr++;
+    }
+  }
+
+  return result;
+}
 
 #define MAX_BUFF 258
 #define MAX_SEARCH 3
 /* Find the class/instance in the .crypt-table */
-char *GetZephyrVarKeyFile(const char *whoami, const char *class, const char *instance) {
+char *GetZephyrVarKeyFile(const char *whoami, const char *class, const char *instance)
+{
   char *keyfile = NULL;
   char *varname[MAX_SEARCH];
@@ -223 +416 @@
 
   /* Determine names to look for in .crypt-table */
-  if (instance) {
-    varname[numsearch++] = owl_sprintf("crypt-%s-%s:", (class?class:"message"), instance);
-  }
-  if (class) {
-    varname[numsearch++] = owl_sprintf("crypt-%s:", class);
-  }
-  varname[numsearch++] = owl_strdup("crypt-default:");
+  if (instance)
+    varname[numsearch++] = g_strdup_printf("crypt-%s-%s:", (class?class:"message"), instance);
+  if (class)
+    varname[numsearch++] = g_strdup_printf("crypt-%s:", class);
+  varname[numsearch++] = g_strdup("crypt-default:");
 
   /* Setup the result array, and determine string lengths */
-  for (i = 0; i < numsearch; i++) {
+  for (i = 0; i < numsearch; i++)
+  {
     result[i][0] = '\0';
     length[i] = strlen(varname[i]);
@@ -238 +430 @@
 
   /* Open~/.crypt-table */
-  filename = owl_sprintf("%s/.crypt-table", getenv("HOME"));
+  filename = g_strdup_printf("%s/.crypt-table", getenv("HOME"));
   fsearch = fopen(filename, "r");
-  if (fsearch) {
+  if (fsearch)
+  {
     /* Scan file for a match */
-    while (!feof(fsearch)) {
+    while (!feof(fsearch))
+    {
       if (!fgets(buffer, MAX_BUFF - 3, fsearch)) break;
-      for (i = 0; i < numsearch; i++) {
-        if (strncasecmp(varname[i], buffer, length[i]) == 0) {
-          int j;
-          for (j = length[i]; buffer[j] == ' '; j++)
-            ;
-          strcpy(result[i], &buffer[j]);
-          if (*result[i]) {
-            if (result[i][strlen(result[i])-1] == '\n') {
-              result[i][strlen(result[i])-1] = '\0';
-            }
-          }
-        }
-      }
+      for (i = 0; i < numsearch; i++)
+        if (strncasecmp(varname[i], buffer, length[i]) == 0)
+        {
+          int j;
+          for (j = length[i]; buffer[j] == ' '; j++)
+            ;
+          strcpy(result[i], &buffer[j]);
+          if (*result[i])
+            if (result[i][strlen(result[i])-1] == '\n')
+              result[i][strlen(result[i])-1] = '\0';
+        }
     }
 
     /* Pick the "best" match found */
     keyfile = NULL;
-    for (i = 0; i < numsearch; i++) {
-      if (*result[i]) {
-        keyfile = result[i];
-        break;
+    for (i = 0; i < numsearch; i++)
+      if (*result[i])
+      {
+        keyfile = result[i];
+        break;
       }
-    }
-
-    if (keyfile == NULL) {
-      /* printf("Could not find key table entry.\n"); */
+
+    if (keyfile != NULL)
+    {
+      /* Prepare result to be returned */
+      char *temp = keyfile;
+      keyfile = (char *)malloc(strlen(temp) + 1);
+      if (keyfile)
+        strcpy(keyfile, temp);
+      else
+        fprintf(stderr, "Memory allocation error.\n");
+    }
+    fclose(fsearch);
+  }
+  else
+    fprintf(stderr, "Could not open key table file: %s\n", filename);
+
+  for(i = 0; i < MAX_SEARCH; i++) {
+    if(varname[i] != NULL) {
+      g_free(varname[i]);
+    }
+  }
+
+  if(filename != NULL) {
+    g_free(filename);
+  }
+
+  return keyfile;
+}
+
+static pid_t zephyrpipe_pid = 0;
+
+/* Open a pipe to zwrite */
+FILE *GetZephyrPipe(const char *class, const char *instance, const ZWRITEOPTIONS *zoptions)
+{
+  int fildes[2];
+  pid_t pid;
+  FILE *result;
+  const char *argv[20];
+  int argc = 0;
+
+  if (pipe(fildes) < 0)
+    return NULL;
+  pid = fork();
+
+  if (pid < 0)
+  {
+    /* Error: clean up */
+    close(fildes[0]);
+    close(fildes[1]);
+    result = NULL;
+  }
+  else if (pid == 0)
+  {
+    /* Setup child process */
+    argv[argc++] = "zwrite";
+    argv[argc++] = "-n";     /* Always send without ping */
+    if (class)
+    {
+      argv[argc++] = "-c";
+      argv[argc++] = class;
+    }
+    if (instance)
+    {
+      argv[argc++] = "-i";
+      argv[argc++] = instance;
+    }
+    if (zoptions->flags & ZWRITE_OPT_NOAUTH)
+      argv[argc++] = "-d";
+    if (zoptions->flags & ZWRITE_OPT_QUIET)
+      argv[argc++] = "-q";
+    if (zoptions->flags & ZWRITE_OPT_VERBOSE)
+      argv[argc++] = "-v";
+    if (zoptions->flags & ZWRITE_OPT_SIGNATURE)
+    {
+      argv[argc++] = "-s";
+      argv[argc++] = zoptions->signature;
+    }
+    argv[argc++] = "-O";
+    argv[argc++] = "crypt";
+    argv[argc] = NULL;
+    close(fildes[1]);
+    if (fildes[0] != STDIN_FILENO)
+    {
+      if (dup2(fildes[0], STDIN_FILENO) != STDIN_FILENO)
+        exit(0);
+      close(fildes[0]);
+    }
+    close(fildes[0]);
+    execvp(argv[0], (char **)argv);
+    fprintf(stderr, "Exec error: could not run zwrite\n");
+    exit(0);
+  }
+  else
+  {
+    close(fildes[0]);
+    /* Create a FILE * for the zwrite pipe */
+    result = (FILE *)fdopen(fildes[1], "w");
+    zephyrpipe_pid = pid;
+  }
+
+  return result;
+}
+
+/* Close the pipe to zwrite */
+void CloseZephyrPipe(FILE *pipe)
+{
+  fclose(pipe);
+  waitpid(zephyrpipe_pid, NULL, 0);
+  zephyrpipe_pid = 0;
+}
+
+#define BASE_CODE 70
+#define LAST_CODE (BASE_CODE + 15)
+#define OUTPUT_BLOCK_SIZE 16
+
+void block_to_ascii(unsigned char *output, FILE *outfile)
+{
+  int i;
+  for (i = 0; i < 8; i++)
+  {
+    putc(((output[i] & 0xf0) >> 4) + BASE_CODE, outfile);
+    putc( (output[i] & 0x0f)       + BASE_CODE, outfile);
+  }
+}
+
+char *slurp_stdin(int ignoredot, int *length) {
+  char *buf;
+  char *inptr;
+
+  if ((inptr = buf = (char *)malloc(MAX_RESULT)) == NULL)
+  {
+    fprintf(stderr, "Memory allocation error\n");
+    return NULL;
+  }
+  while (inptr - buf < MAX_RESULT - MAX_LINE - 20)
+  {
+    if (fgets(inptr, MAX_LINE, stdin) == NULL)
+      break;
+
+    if (inptr[0])
+    {
+      if (inptr[0] == '.' && inptr[1] == '\n' && !ignoredot)
+      {
+        inptr[0] = '\0';
+        break;
+      }
+      else
+        inptr += strlen(inptr);
+    }
+    else
+      break;
+  }
+  *length = inptr - buf;
+
+  return buf;
+}
+
+char *GetInputBuffer(ZWRITEOPTIONS *zoptions, int *length) {
+  char *buf;
+
+  if (zoptions->flags & ZCRYPT_OPT_MESSAGE)
+  {
+    /* Use the -m message */
+    buf = strdup(zoptions->message);
+    *length = strlen(buf);
+  }
+  else
+  {
+    if (isatty(0)) {
+      /* tty input, so show the "Type your message now..." message */
+      if (zoptions->flags & ZCRYPT_OPT_IGNOREDOT)
+        printf("Type your message now.  End with the end-of-file character.\n");
+      else
+        printf("Type your message now.  End with control-D or a dot on a line by itself.\n");
     } else {
-      /* Prepare result to be returned */
-      keyfile = owl_strdup(keyfile);
-    }
-    
-    fclose(fsearch);
-  } else {
-    /* printf("Could not open key table file: %s\n", filename); */
-  }
-
-  for(i = 0; i < MAX_SEARCH; i++) {
-    owl_free(varname[i]);
-  }
-
-  owl_free(filename);
-
-  return(keyfile);
-}
-
-#endif
+      zoptions->flags |= ZCRYPT_OPT_IGNOREDOT;
+    }
+
+    buf = slurp_stdin(zoptions->flags & ZCRYPT_OPT_IGNOREDOT, length);
+  }
+  return buf;
+}
+
+char *read_keystring(const char *keyfile) {
+  char *keystring;
+  FILE *fkey = fopen(keyfile, "r");
+  if(!fkey) {
+    fprintf(stderr, "Unable to open keyfile %s\n", keyfile);
+    return NULL;
+  }
+  keystring = malloc(MAX_KEY);
+  if(!fgets(keystring, MAX_KEY-1, fkey)) {
+    fprintf(stderr, "Unable to read from keyfile: %s\n", keyfile);
+    free(keystring);
+    keystring = NULL;
+  }
+  fclose(fkey);
+  return keystring;
+}
+
+/* Encrypt stdin, with prompt if isatty, and send to stdout, or to zwrite
+   if zephyr is set. */
+int do_encrypt(int zephyr, const char *class, const char *instance,
+               ZWRITEOPTIONS *zoptions, const char *keyfile, int cipher)
+{
+  FILE *outfile = stdout;
+  char *inbuff = NULL;
+  int buflen;
+  int out = TRUE;
+
+  inbuff = GetInputBuffer(zoptions, &buflen);
+
+  if(!inbuff) {
+    fprintf(stderr, "Error reading zcrypt input!\n");
+    return FALSE;
+  }
+
+  if (zephyr) {
+    outfile = GetZephyrPipe(class, instance, zoptions);
+    if (!outfile)
+    {
+      fprintf(stderr, "Could not run zwrite\n");
+      if (inbuff)
+        free(inbuff);
+      return FALSE;
+    }
+  }
+
+  out = ciphers[cipher].encrypt(keyfile, inbuff, buflen, outfile);
+
+  if (zephyr)
+    CloseZephyrPipe(outfile);
+
+  free(inbuff);
+  return out;
+}
+
+int do_encrypt_des(const char *keyfile, const char *in, int length, FILE *outfile)
+{
+  des_key_schedule schedule;
+  unsigned char input[8], output[8];
+  const char *inptr;
+  int num_blocks, last_block_size;
+  char *keystring;
+  int size;
+
+  keystring = read_keystring(keyfile);
+  if(!keystring) {
+    return FALSE;
+  }
+
+  owl_zcrypt_string_to_schedule(keystring, &schedule);
+  free(keystring);
+
+  inptr = in;
+  num_blocks = (length + 7) / 8;
+  last_block_size = ((length + 7) % 8) + 1;
+
+  /* Encrypt the input (inbuff or stdin) and send it to outfile */
+  while (TRUE)
+  {
+    /* Get 8 bytes from buffer */
+    if (num_blocks > 1)
+    {
+      size = 8;
+      memcpy(input, inptr, size);
+      inptr += 8;
+      num_blocks--;
+    }
+    else if (num_blocks == 1)
+    {
+      size = last_block_size;
+      memcpy(input, inptr, size);
+      num_blocks--;
+    }
+    else
+      size = 0;
+
+    /* Check for EOF and pad the string to 8 chars, if needed */
+    if (size == 0)
+      break;
+    if (size < 8)
+      memset(input + size, 0, 8 - size);
+
+    /* Encrypt and output the block */
+    des_ecb_encrypt(&input, &output, schedule, TRUE);
+    block_to_ascii(output, outfile);
+
+    if (size < 8)
+      break;
+  }
+
+  putc('\n', outfile);
+
+  return TRUE;
+}
+
+int do_encrypt_aes(const char *keyfile, const char *in, int length, FILE *outfile)
+{
+  char *out;
+  int err, status;
+  const char *argv[] = {
+    "gpg",
+    "--symmetric",
+    "--batch",
+    "--quiet",
+    "--no-use-agent",
+    "--armor",
+    "--cipher-algo", "AES",
+    "--passphrase-file", keyfile,
+    NULL
+  };
+  err = call_filter("gpg", argv, in, &out, &status);
+  if(err || status) {
+    if(out) g_free(out);
+    return FALSE;
+  }
+  fwrite(out, strlen(out), 1, outfile);
+  g_free(out);
+  return TRUE;
+}
+
+/* Read a half-byte from stdin, skipping invalid characters.  Returns -1
+   if at EOF or file error */
+int read_ascii_nybble(void)
+{
+  char c;
+
+  while (TRUE)
+  {
+    if (fread(&c, 1, 1, stdin) == 0)
+      return -1;
+    else if (c >= BASE_CODE && c <= LAST_CODE)
+      return c - BASE_CODE;
+  }
+}
+
+/* Read both halves of the byte and return the single byte.  Returns -1
+   if at EOF or file error. */
+int read_ascii_byte(void)
+{
+  int c1, c2;
+  c1 = read_ascii_nybble();
+  if (c1 >= 0)
+  {
+    c2 = read_ascii_nybble();
+    if (c2 >= 0)
+    {
+      return c1 * 0x10 + c2;
+    }
+  }
+  return -1;
+}
+
+/* Read an 8-byte DES block from stdin */
+int read_ascii_block(unsigned char *input)
+{
+  int c;
+
+  int i;
+  for (i = 0; i < 8; i++)
+  {
+    c = read_ascii_byte();
+    if (c < 0)
+      return FALSE;
+
+    input[i] = c;
+  }
+
+  return TRUE;
+}
+
+/* Decrypt stdin */
+int do_decrypt(const char *keyfile, int cipher)
+{
+  return ciphers[cipher].decrypt(keyfile);
+}
+
+int do_decrypt_aes(const char *keyfile) {
+  char *in, *out;
+  int length;
+  const char *argv[] = {
+    "gpg",
+    "--decrypt",
+    "--batch",
+    "--no-use-agent",
+    "--quiet",
+    "--passphrase-file", keyfile,
+    NULL
+  };
+  int err, status;
+
+  in = slurp_stdin(TRUE, &length);
+  if(!in) return FALSE;
+
+  err = call_filter("gpg", argv, in, &out, &status);
+  if(err || status) {
+    if(out) g_free(out);
+    return FALSE;
+  }
+  fwrite(out, strlen(out), 1, stdout);
+  g_free(out);
+
+  return TRUE;
+}
+
+int do_decrypt_des(const char *keyfile) {
+  des_key_schedule schedule;
+  unsigned char input[8], output[8];
+  char *keystring;
+
+  output[0] = '\0';    /* In case no message at all                 */
+
+  keystring = read_keystring(keyfile);
+  if(!keystring) return FALSE;
+
+  owl_zcrypt_string_to_schedule(keystring, &schedule);
+
+  free(keystring);
+
+  while (read_ascii_block(input))
+  {
+    des_ecb_encrypt(&input, &output, schedule, FALSE);
+    printf("%s", output);
+  }
+
+  if (!output[0] || output[strlen((const char*)output) - 1] != '\n')
+      printf("\n");
+  return TRUE;
+}

editwin.c

@@ -35 +35 @@
   oe_excursion *excursions;
 
-  char *command;
   void (*callback)(struct _owl_editwin*);
+  void (*destroy_cbdata)(void *);
   void *cbdata;
 };
@@ -45 +45 @@
 static void oe_restore_excursion(owl_editwin *e, oe_excursion *x);
 static void oe_restore_mark_only(owl_editwin *e, oe_excursion *x);
-static int oe_count_glyphs(const char *s);
 static int oe_char_width(gunichar c, int column);
 static int oe_region_width(owl_editwin *e, int start, int end, int width);
@@ -58 +57 @@
 static int oe_copy_region(owl_editwin *e);
 static char *oe_chunk(owl_editwin *e, int start, int end);
+static void oe_destroy_cbdata(owl_editwin *e);
 
 #define INCR 4096
@@ -63 +63 @@
 #define WHITESPACE " \n\t"
 
-owl_editwin *owl_editwin_allocate(void)
+static owl_editwin *owl_editwin_allocate(void)
 {
   owl_editwin *e;
@@ -75 +75 @@
   owl_free(e->buff);
   owl_free(e->killbuf);
-  owl_free(e->command);
   /* just in case someone forgot to clean up */
   while (e->excursions) {
     oe_release_excursion(e, e->excursions);
   }
+  oe_destroy_cbdata(e);
 
   owl_free(e);
-}
-
-static int oe_count_glyphs(const char *s)
-{
-  int count = 0;
-  const char *p;
-
-  for(p = s; *p != 0; p = g_utf8_find_next_char(p, NULL))
-    if (!g_unichar_ismark(g_utf8_get_char(p)))
-      count++;
-
-  return count;
 }
 
@@ -116 +104 @@
 }
 
-/* initialize the editwin e.
- * 'win' is an already initialzed curses window that will be used by editwin
- */
-void owl_editwin_init(owl_editwin *e, WINDOW *win, int winlines, int wincols, int style, owl_history *hist)
+static void _owl_editwin_init(owl_editwin *e,
+                              WINDOW *win,
+                              int winlines,
+                              int wincols,
+                              int style,
+                              owl_history *hist)
 {
   e->buff=owl_malloc(INCR);
@@ -145 +135 @@
   e->echochar='\0';
 
-  /* We get initialized multiple times, but we need to hold on to
-     the callbacks, so we can't NULL them here. */
-  /*
-    e->command = NULL;
-    e->callback = NULL;
-    e->cbdata = NULL;
-  */
   if (win) werase(win);
+}
+
+owl_editwin *owl_editwin_new(WINDOW *win, int winlines, int wincols, int style, owl_history *hist)
+{
+  owl_editwin *e = owl_editwin_allocate();
+
+  _owl_editwin_init(e, win, winlines, wincols, style, hist);
+  return e;
 }
 
@@ -188 +179 @@
 }
 
-void owl_editwin_set_command(owl_editwin *e, const char *command)
-{
-  if(e->command) owl_free(e->command);
-  e->command = owl_strdup(command);
-}
-
-const char *owl_editwin_get_command(owl_editwin *e)
-{
-  if(e->command) return e->command;
-  return "";
-}
-
 void owl_editwin_set_callback(owl_editwin *e, void (*cb)(owl_editwin*))
 {
@@ -210 +189 @@
 }
 
-void owl_editwin_set_cbdata(owl_editwin *e, void *data)
-{
+static void oe_destroy_cbdata(owl_editwin *e) {
+  if (e->destroy_cbdata)
+    e->destroy_cbdata(e->cbdata);
+  e->cbdata = NULL;
+  e->destroy_cbdata = NULL;
+}
+
+void owl_editwin_set_cbdata(owl_editwin *e, void *data, void (*destroy)(void *))
+{
+  oe_destroy_cbdata(e);
   e->cbdata = data;
+  e->destroy_cbdata = destroy;
 }
 
@@ -259 +247 @@
 }
 
-void owl_editwin_new_style(owl_editwin *e, int newstyle, owl_history *h)
-{
-  e->hist = h;
-
-  if (e->style==newstyle) return;
-
-  if (newstyle==OWL_EDITWIN_STYLE_MULTILINE) {
-    e->style=newstyle;
-  } else if (newstyle==OWL_EDITWIN_STYLE_ONELINE) {
-    e->style=newstyle;
-
-    /* nuke everything after the first line */
-    owl_editwin_move_to_top(e);
-    owl_editwin_move_to_end_of_line(e);
-    owl_editwin_replace(e, oe_count_glyphs(e->buff + e->index),  "");
-  }
-}
-
-/* completly reinitialize the buffer */
-void owl_editwin_fullclear(owl_editwin *e)
-{
-  owl_free(e->buff);
-  owl_editwin_init(e, e->curswin, e->winlines, e->wincols, e->style, e->hist);
-}
-
 /* clear all text except for locktext and put the cursor at the
  * beginning
@@ -302 +265 @@
 
   owl_free(e->buff);
-  owl_editwin_init(e, e->curswin, e->winlines, e->wincols, e->style, e->hist);
+  _owl_editwin_init(e, e->curswin, e->winlines, e->wincols, e->style, e->hist);
 
   if (lock > 0) {

global.c

@@ -45 +45 @@
   g->rightshift=0;
 
-  g->tw = owl_editwin_allocate();
-  owl_editwin_init(g->tw, NULL, owl_global_get_typwin_lines(g), g->cols, OWL_EDITWIN_STYLE_ONELINE, NULL);
+  g->tw = NULL;
 
   owl_keyhandler_init(&g->kh);
@@ -58 +57 @@
   g->curmsg_vert_offset=0;
   g->resizepending=0;
-  g->typwinactive=0;
   g->direction=OWL_DIRECTION_DOWNWARDS;
   g->zaway=0;
@@ -111 +109 @@
   owl_zbuddylist_create(&(g->zbuddies));
 
+  g->zaldlist = NULL;
+  g->pseudologin_notify = 0;
+
   owl_obarray_init(&(g->obarray));
 
@@ -171 +172 @@
   _owl_panel_set_window(&g->typpan, newwin(typwin_lines, cols, g->recwinlines+2, 0));
 
-  owl_editwin_set_curswin(g->tw, owl_global_get_curs_typwin(g), typwin_lines, g->cols);
+  if (g->tw)
+      owl_editwin_set_curswin(g->tw, owl_global_get_curs_typwin(g), typwin_lines, g->cols);
 
   idlok(owl_global_get_curs_typwin(g), FALSE);
@@ -324 +326 @@
 }
 
-/* buffercommand */
-
-void owl_global_set_buffercommand(owl_global *g, const char *command) {
-  owl_editwin_set_command(owl_global_get_typwin(g), command);
-}
-
-const char *owl_global_get_buffercommand(const owl_global *g) {
-  return owl_editwin_get_command(owl_global_get_typwin(g));
-}
-
-void owl_global_set_buffercallback(owl_global *g, void (*cb)(owl_editwin*)) {
-  owl_editwin_set_callback(owl_global_get_typwin(g), cb);
-}
-
-void (*owl_global_get_buffercallback(const owl_global *g))(owl_editwin*) {
-  return owl_editwin_get_callback(owl_global_get_typwin(g));
-}
-
 /* refresh */
 
@@ -381 +365 @@
 /* typwin */
 
-int owl_global_is_typwin_active(const owl_global *g) {
-  if (g->typwinactive==1) return(1);
-  return(0);
-}
-
-void owl_global_set_typwin_active(owl_global *g) {
-  int d = owl_global_get_typewindelta(g);
-  if (d > 0)
+owl_editwin *owl_global_set_typwin_active(owl_global *g, int style, owl_history *hist) {
+  int d;
+  d = owl_global_get_typewindelta(g);
+  if (d > 0 && style == OWL_EDITWIN_STYLE_MULTILINE)
       owl_function_resize_typwin(owl_global_get_typwin_lines(g) + d);
 
-  g->typwinactive=1;
+  g->tw = owl_editwin_new(owl_global_get_curs_typwin(g),
+                          owl_global_get_typwin_lines(g),
+                          g->cols,
+                          style,
+                          hist);
+  return g->tw;
 }
 
 void owl_global_set_typwin_inactive(owl_global *g) {
   int d = owl_global_get_typewindelta(g);
-  if (d > 0)
+  if (d > 0 && owl_editwin_get_style(g->tw) == OWL_EDITWIN_STYLE_MULTILINE)
       owl_function_resize_typwin(owl_global_get_typwin_lines(g) - d);
 
-  g->typwinactive=0;
+  werase(owl_global_get_curs_typwin(g));
+  g->tw = NULL;
 }
 
@@ -531 +517 @@
   owl_mainwin_redisplay(&(g->mw));
   sepbar(NULL);
-  owl_editwin_redisplay(g->tw);
+  if (g->tw)
+      owl_editwin_redisplay(g->tw);
+  else
+    werase(owl_global_get_curs_typwin(g));
+
   owl_function_full_redisplay();
 
@@ -968 +958 @@
 }
 
+GList **owl_global_get_zaldlist(owl_global *g)
+{
+  return &(g->zaldlist);
+}
+
+int owl_global_get_pseudologin_notify(owl_global *g)
+{
+  return g->pseudologin_notify;
+}
+
+void owl_global_set_pseudologin_notify(owl_global *g, int notify)
+{
+  g->pseudologin_notify = notify;
+}
+
 struct termios *owl_global_get_startup_tio(owl_global *g)
 {

keybinding.c

@@ -14 +14 @@
 int owl_keybinding_init(owl_keybinding *kb, const char *keyseq, const char *command, void (*function_fn)(void), const char *desc)
 {
-  char **ktokens;
-  int    nktokens, i;
-  
   owl_function_debugmsg("owl_keybinding_init: creating binding for <%s> with desc: <%s>", keyseq, desc);
   if (command && !function_fn) {
@@ -25 +22 @@
     return(-1);
   }
+
+  if (owl_keybinding_make_keys(kb, keyseq) != 0) {
+    return(-1);
+  }
+
+  if (command) kb->command = owl_strdup(command);
+  kb->function_fn = function_fn;
+  if (desc) kb->desc = owl_strdup(desc);
+  else kb->desc = NULL;
+  return(0);
+}
+
+int owl_keybinding_make_keys(owl_keybinding *kb, const char *keyseq)
+{
+  char **ktokens;
+  int    nktokens, i;
 
   ktokens = atokenize(keyseq, " ", &nktokens);
@@ -42 +55 @@
   }
   kb->len = nktokens;
-
   atokenize_delete(ktokens, nktokens);
-
-  if (command) kb->command = owl_strdup(command);
-  kb->function_fn = function_fn;
-  if (desc) kb->desc = owl_strdup(desc);
-  else kb->desc = NULL;
   return(0);
 }

keymap.c

@@ -51 +51 @@
   }
   return owl_list_append_element(&km->bindings, kb);  
-}
+
+}
+
+/* removes the binding associated with the keymap */
+int owl_keymap_remove_binding(owl_keymap *km, const char *keyseq)
+{
+  owl_keybinding *kb, *curkb;
+  int i;
+
+  if ((kb = owl_malloc(sizeof(owl_keybinding))) == NULL) return(-1);
+  if (0 != owl_keybinding_make_keys(kb, keyseq)) {
+    owl_free(kb);
+    return(-1);
+  }
+
+  for (i = owl_list_get_size(&km->bindings)-1; i >= 0; i--) {
+    curkb = owl_list_get_element(&km->bindings, i);
+    if (owl_keybinding_equal(curkb, kb)) {
+      owl_list_remove_element(&km->bindings, i);
+      owl_keybinding_delete(curkb);
+      return(0);
+    }
+  }
+  return(-2);
+}
+
 
 /* returns a summary line describing this keymap.  the caller must free. */

keys.c

@@ -246 +246 @@
   BIND_CMD("M-n", "smartnarrow",      "narrow to a view based on the current message");
   BIND_CMD("M-N", "smartnarrow -i",   "narrow to a view based on the current message, and consider instance pair");
+  BIND_CMD("M-m", "smartnarrow -r",   "like M-n but with 'narrow-related' temporarily flipped.");
+  BIND_CMD("M-M", "smartnarrow -ri",  "like M-N but with 'narrow-related' temporarily flipped.");
   BIND_CMD("M-p", "view personal", "");
   

owl.c

@@ -629 +629 @@
       /* leave the cursor in the appropriate window */
       if (!owl_popwin_is_active(owl_global_get_popwin(&g))
-          && owl_global_is_typwin_active(&g)) {
+          && owl_global_get_typwin(&g)) {
         owl_function_set_cursor(typwin);
       } else {

owl.h

@@ -559 +559 @@
   int resizepending;
   int recwinlines;
-  int typwinactive;
   char *thishost;
   char *homedir;
@@ -604 +603 @@
   owl_zbuddylist zbuddies;
   owl_timer zephyr_buddycheck_timer;
+  GList *zaldlist;
+  int pseudologin_notify;
   struct termios startup_tio;
   owl_obarray obarray;

perl/lib/BarnOwl/Style/Default.pm

@@ -168 +168 @@
     ? '@color(cyan)' : '';
 
-  my $chars = $oneline ? qr/[[:cntrl:]]/ : qr/[^[:print:]]|[\r\cK\f]/;
+  my $chars = $oneline ? qr/[[:cntrl:]]/ : qr/[^[:print:]\n]|[\r\cK\f]/;
 
   $s =~ s/($chars)/
@@ -179 +179 @@
 
 As above, but always be conservative, and replace with a '?' instead
-of something mmore elaborate.
+of something more elaborate.
 
 =cut

perlconfig.c

@@ -574 +574 @@
   FREETMPS;
   LEAVE;
-
-  SvREFCNT_dec(cb);
-  owl_editwin_set_cbdata(e, NULL);
+}
+
+void owl_perlconfig_dec_refcnt(void *data)
+{
+  SV *v = data;
+  SvREFCNT_dec(v);
 }
 

perlglue.xs

@@ -172 +172 @@
         SV *callback
         PREINIT:
+                owl_editwin *e;
         CODE:
         {
@@ -177 +178 @@
                         croak("Callback must be a subref");
 
-                owl_function_start_question(line);
-
-                owl_editwin_set_cbdata(owl_global_get_typwin(&g), newSVsv(callback));
-                owl_editwin_set_callback(owl_global_get_typwin(&g), owl_perlconfig_edit_callback);
+                e = owl_function_start_question(line);
+
+                owl_editwin_set_cbdata(e,
+                                       newSVsv(callback),
+                                       owl_perlconfig_dec_refcnt);
+                owl_editwin_set_callback(e, owl_perlconfig_edit_callback);
         }
 
@@ -188 +191 @@
         SV *callback
         PREINIT:
+                owl_editwin *e;
         CODE:
         {
@@ -193 +197 @@
                         croak("Callback must be a subref");
 
-                owl_function_start_password(line);
-
-                owl_editwin_set_cbdata(owl_global_get_typwin(&g), newSVsv(callback));
-                owl_editwin_set_callback(owl_global_get_typwin(&g), owl_perlconfig_edit_callback);
+                e = owl_function_start_password(line);
+
+                owl_editwin_set_cbdata(e,
+                                       newSVsv(callback),
+                                       owl_perlconfig_dec_refcnt);
+                owl_editwin_set_callback(e, owl_perlconfig_edit_callback);
         }
 
@@ -208 +214 @@
                         croak("Callback must be a subref");
 
-                owl_function_start_edit_win(line, owl_perlconfig_edit_callback, newSVsv(callback));
+                owl_function_start_edit_win(line,
+                                            owl_perlconfig_edit_callback,
+                                            newSVsv(callback),
+                                            owl_perlconfig_dec_refcnt);
         }
 
@@ -542 +551 @@
         int count;
         const char *string;
-        CODE:
-                RETVAL = owl_editwin_replace(owl_global_get_typwin(&g), count, string);
+        PREINIT:
+                owl_editwin *e;
+        CODE:
+                e = owl_global_get_typwin(&g);
+                if (e) {
+                        RETVAL = owl_editwin_replace(e, count, string);
+                } else {
+                        RETVAL = 0;
+                }
         OUTPUT:
                 RETVAL
@@ -550 +566 @@
 point_move(delta)
         int delta;
-        CODE:
-                RETVAL = owl_editwin_point_move(owl_global_get_typwin(&g), delta);
+        PREINIT:
+                owl_editwin *e;
+        CODE:
+                e = owl_global_get_typwin(&g);
+                if (e) {
+                        RETVAL = owl_editwin_point_move(e, delta);
+                } else {
+                        RETVAL = 0;
+                }
         OUTPUT:
                 RETVAL
@@ -558 +581 @@
 replace_region(string)
         const char *string;
-        CODE:
-                RETVAL = owl_editwin_replace_region(owl_global_get_typwin(&g), string);
+        PREINIT:
+                owl_editwin *e;
+        CODE:
+                e = owl_global_get_typwin(&g);
+                if (e) {
+                        RETVAL = owl_editwin_replace_region(e, string);
+                } else {
+                        RETVAL = 0;
+                }
         OUTPUT:
                 RETVAL
@@ -567 +597 @@
         PREINIT:
                 char *region;
-        CODE:
-                region = owl_editwin_get_region(owl_global_get_typwin(&g));
+                owl_editwin *e;
+        CODE:
+                e = owl_global_get_typwin(&g);
+                if (e) {
+                        region = owl_editwin_get_region(owl_global_get_typwin(&g));
+                } else {
+                        region = NULL;
+                }
                 RETVAL = region;
         OUTPUT:
@@ -581 +617 @@
         PREINIT:
                 int count;
+                owl_editwin *e;
                 owl_editwin_excursion *x;
         CODE:
         {
+                e = owl_global_get_typwin(&g);
+                if(!e)
+                        croak("The edit window is not currently active!");
+
                 x = owl_editwin_begin_excursion(owl_global_get_typwin(&g));
                 PUSHMARK(SP);
@@ -605 +646 @@
 int
 current_column()
-        CODE:
-                RETVAL = owl_editwin_current_column(owl_global_get_typwin(&g));
+        PREINIT:
+                owl_editwin *e;
+        CODE:
+                e = owl_global_get_typwin(&g);
+                if (e) {
+                        RETVAL = owl_editwin_current_column(e);
+                } else {
+                        RETVAL = 0;
+                }
         OUTPUT:
                 RETVAL
@@ -612 +660 @@
 int
 point()
-        CODE:
-                RETVAL = owl_editwin_get_point(owl_global_get_typwin(&g));
+        PREINIT:
+                owl_editwin *e;
+        CODE:
+                e = owl_global_get_typwin(&g);
+                if (e) {
+                        RETVAL = owl_editwin_get_point(e);
+                } else {
+                        RETVAL = 0;
+                }
         OUTPUT:
                 RETVAL
@@ -619 +674 @@
 int
 mark()
-        CODE:
-                RETVAL = owl_editwin_get_mark(owl_global_get_typwin(&g));
-        OUTPUT:
-                RETVAL
+        PREINIT:
+                owl_editwin *e;
+        CODE:
+                e = owl_global_get_typwin(&g);
+                if (e) {
+                        RETVAL = owl_editwin_get_mark(e);
+                } else {
+                        RETVAL = 0;
+                }
+        OUTPUT:
+                RETVAL

popexec.c

@@ -96 +96 @@
   if (!pe->pid && !pe->winactive) {
     owl_select_remove_io_dispatch(d);
+    pe->dispatch = NULL;
     return;
   }
@@ -114 +115 @@
     }
     owl_select_remove_io_dispatch(d);
+    pe->dispatch = NULL;
     return;
   }
@@ -157 +159 @@
 
   pe->winactive = 0;
-  if (pe->dispatch->fd > 0) {
+  if (pe->dispatch) {
     owl_select_remove_io_dispatch(pe->dispatch);
+    pe->dispatch = NULL;
   }
   if (pe->pid) {

scripts/add-changelog

@@ -1 +1 @@
 #!/bin/sh
 version=$1; shift
+
+if [ -z "$version" ] || [ "$#" = 0 ];  then
+    echo "Usage: $0 VERSION REV-LIST-ARGS" > &2
+    exit 1;
+fi
 
 (

scripts/do-release

@@ -4 +4 @@
     echo "$@" >&2
     exit 1
+}
+
+usage() {
+    cat >&2 <<EOF
+Usage: %0 [options]
+Generate a barnowl release tarball.
+
+OPTIONS:
+  -f            Don't require a changelog entry for the new release.
+  --no-tag      Don't create and sign a git tag for the new release
+  --git         Do a beta release for the current git revision.
+EOF
 }
 
@@ -15 +27 @@
         --no-tag) no_tag=1 ;;
         --git) git=1 ;;
+        -h|--help) usage ;;
     esac
 done

scripts/locker-build

@@ -3 +3 @@
 #########################################################
 # Build script to build BarnOwl for the locker.
-
-# Usage: locker-build [-n] [-o OUTPUT-TGZ] SOURCE-TARBALL
-# -n is a dry-run, and drops to a shell in the build directory
-# -o does the install into a temporary directory and tars it into the
-#    specified tarball instead.
-# SOURCE-TARBALL is a source tarball, created by do-release
-
 die() {
     echo "$@" 2>&1;
@@ -22 +15 @@
 
 usage () {
-    echo "Usage: $0 [-n] [-o OUTPUT-TGZ] SOURCE-TARBALL"
+    cat >&2 <<EOF
+Usage: $0 [-n] [-o OUTPUT-TGZ] SOURCE-TARBALL
+ -n is a dry-run, and drops to a shell in the build directory
+ -o does the install into a temporary directory and tars it into the
+    specified tarball instead.
+
+SOURCE-TARBALL is a source tarball, created by do-release.
+EOF
     exit 2;
 }

variable.c

@@ -358 +358 @@
                "normal,top,neartop,center,paged,pagedcenter" ),
 
+  OWLVAR_BOOL( "narrow-related" /* %OwlVarStub:narrow_related */, 1,
+               "Make smartnarrow use broader filters",
+               "Causes smartfiler to narrow to messages \"related\" to \n"
+               "the current message, as well as ones to the same place.\n\n"
+               "for Zephyr, this controls whether to narrow to e.g. class-help or\n"
+               "class-help.d alone, or to related-class-help, which includes\n"
+               "help, unhelp, help.d, etc.\n\nDefault is true (include unclasses, etc.).\n" ),
 
   OWLVAR_BOOL( "_followlast" /* %OwlVarStub */, 0,

zephyr.c

@@ -1299 +1299 @@
 }
 
+#ifdef HAVE_LIBZEPHYR
+void owl_zephyr_process_pseudologin(ZNotice_t *n)
+{
+  owl_message *m;
+  owl_zbuddylist *zbl;
+  GList **zaldlist;
+  GList *zaldptr;
+  ZAsyncLocateData_t *zald = NULL;
+  ZLocations_t location;
+  int numlocs, ret, notify;
+
+  /* Find a ZALD to match this notice. */
+  zaldlist = owl_global_get_zaldlist(&g);
+  zaldptr = g_list_first(*zaldlist);
+  while (zaldptr) {
+    if (ZCompareALDPred(n, zaldptr->data)) {
+      zald = zaldptr->data;
+      *zaldlist = g_list_remove(*zaldlist, zaldptr->data);
+      break;
+    }
+    zaldptr = g_list_next(zaldptr);
+  }
+  if (zald) {
+    /* Deal with notice. */
+    notify = owl_global_get_pseudologin_notify(&g);
+    zbl = owl_global_get_zephyr_buddylist(&g);
+    ret = ZParseLocations(n, zald, &numlocs, NULL);
+    if (ret == ZERR_NONE) {
+      if (numlocs > 0 && !owl_zbuddylist_contains_user(zbl, zald->user)) {
+        if (notify) {
+          numlocs = 1;
+          ret = ZGetLocations(&location, &numlocs);
+          if (ret == ZERR_NONE) {
+            /* Send a PSEUDO LOGIN! */
+            m = owl_malloc(sizeof(owl_message));
+            owl_message_create_pseudo_zlogin(m, 0, zald->user,
+                                             location.host,
+                                             location.time,
+                                             location.tty);
+            owl_global_messagequeue_addmsg(&g, m);
+          }
+          owl_zbuddylist_adduser(zbl, zald->user);
+          owl_function_debugmsg("owl_function_zephyr_buddy_check: login for %s ", zald->user);
+        }
+      } else if (numlocs == 0 && owl_zbuddylist_contains_user(zbl, zald->user)) {
+        /* Send a PSEUDO LOGOUT! */
+        if (notify) {
+          m = owl_malloc(sizeof(owl_message));
+          owl_message_create_pseudo_zlogin(m, 1, zald->user, "", "", "");
+          owl_global_messagequeue_addmsg(&g, m);
+        }
+        owl_zbuddylist_deluser(zbl, zald->user);
+        owl_function_debugmsg("owl_function_zephyr_buddy_check: logout for %s ", zald->user);
+      }
+    }
+    ZFreeALD(zald);
+    owl_free(zald);
+  }
+}
+#else
+void owl_zephyr_process_pseudologin(void *n)
+{
+}
+#endif
+
 /*
  * Process zephyrgrams from libzephyr's queue. To prevent starvation,
@@ -1333 +1398 @@
       }
 
+      /* if it is a LOCATE message, it's for pseudologins. */
+      if (strcmp(notice.z_opcode, LOCATE_LOCATE) == 0) {
+        owl_zephyr_process_pseudologin(&notice);
+        ZFreeNotice(&notice);
+        continue;
+      }
+
       /* create the new message */
       m=owl_malloc(sizeof(owl_message));