Changes in / [8bba1ae:d296c9a]

Files:

• .gitignore (modified) (1 diff)
• Makefile.am (modified) (2 diffs)
• README (modified) (1 diff)
• barnowl (modified) (1 diff)
• cmd.c (modified) (1 diff)
• commands.c (modified) (4 diffs)
• configure.ac (modified) (2 diffs)
• functions.c (modified) (9 diffs)
• global.c (modified) (2 diffs)
• owl.c (modified) (2 diffs)
• owl.h (modified) (2 diffs)
• perl/modules/Jabber/lib/BarnOwl/Message/Jabber.pm (modified) (2 diffs)
• perl/modules/Jabber/lib/BarnOwl/Module/Jabber.pm (modified) (1 diff)
• perl/modules/Twitter/.gitignore (modified) (1 diff)
• perl/modules/Twitter/inc/Module/Install.pm (added)
• perl/modules/Twitter/inc/Module/Install/BarnOwl.pm (added)
• perl/modules/Twitter/inc/Module/Install/Base.pm (added)
• perl/modules/Twitter/inc/Module/Install/Can.pm (added)
• perl/modules/Twitter/inc/Module/Install/Fetch.pm (added)
• perl/modules/Twitter/inc/Module/Install/Makefile.pm (added)
• perl/modules/Twitter/inc/Module/Install/Metadata.pm (added)
• perl/modules/Twitter/inc/Module/Install/Win32.pm (added)
• perl/modules/Twitter/inc/Module/Install/WriteAll.pm (added)
• perl/modules/Twitter/lib/BarnOwl/Message/Twitter.pm (modified) (1 diff)
• perl/modules/Twitter/lib/BarnOwl/Module/Twitter/Handle.pm (modified) (1 diff)
• perl_tester.c (deleted)
• perlconfig.c (modified) (2 diffs)
• runtests.sh (modified) (1 diff)
• t/00-core-tests.t (modified) (1 diff)
• t/mock.pl (modified) (1 diff)
• tester (added)
• tester.c (modified) (3 diffs)
• zcrypt.c (modified) (2 diffs)
• zephyr.c (modified) (2 diffs)
• zwrite.c (modified) (5 diffs)

.gitignore

@@ -35 +35 @@
 pm_to_blib
 stamp-h1
-tester
 varstubs.c

Makefile.am

@@ -12 +12 @@
 zcrypt_SOURCES = zcrypt.c filterproc.c
 
-check_PROGRAMS = tester perl_tester
+check_PROGRAMS = tester.bin
 
 barnowl_bin_SOURCES = $(BASE_SRCS) \
@@ -19 +19 @@
      $(GEN_C) $(GEN_H)
 
+man_MANS = doc/barnowl.1
+doc_DATA = doc/intro.txt doc/advanced.txt
+
 barnowl_bin_LDADD = libfaim/libfaim.a
 
-tester_SOURCES = $(BASE_SRCS) \
+tester_bin_SOURCES = $(BASE_SRCS) \
      owl.h owl_perl.h config.h \
      $(GEN_C) $(GEN_H) \
      tester.c
 
-tester_LDADD = libfaim/libfaim.a
-
-perl_tester_SOURCES = $(BASE_SRCS) \
-     owl.h owl_perl.h config.h \
-     $(GEN_C) $(GEN_H) \
-     perl_tester.c
-
-perl_tester_LDADD = libfaim/libfaim.a
+tester_bin_LDADD = libfaim/libfaim.a
 
 TESTS=runtests.sh

README

@@ -1 +1 @@
 BarnOwl - owl, with more ponies
 
+Source is freely available from http://github.com/barnowl/barnowl/
+
 Based on owl 2.1.11, by James Kretchmar (http://www.ktools.org)
-
-This project is a work in progress.
-We guarantee no stability of form or function.
 
 Notes:

barnowl

@@ -5 +5 @@
 
 SRCDIR=`dirname "${0}"`
-EXE="$SRCDIR/barnowl.bin"
+EXE="$0.bin"
 
 if ! test -x "$EXE"; then

cmd.c

@@ -52 +52 @@
   cmd = owl_malloc(sizeof(owl_cmd));
   owl_cmd_create_alias(cmd, alias_from, alias_to);
+  owl_perlconfig_new_command(cmd->name);
   owl_dict_insert_element(cd, cmd->name, cmd, (void (*)(void *))owl_cmd_delete);
   return(0);

commands.c

@@ -136 +136 @@
               "Send a local message.\n"),
 
-  OWLCMD_ARGS("zcrypt", owl_command_zcrypt, OWL_CTX_INTERACTIVE,
+  OWLCMD_ARGS("zcrypt", owl_command_zwrite, OWL_CTX_INTERACTIVE,
               "send an encrypted zephyr",
               "zcrypt [-n] [-C] [-c class] [-i instance] [-r realm] [-O opcode] [-m <message...>]\n",
@@ -1911 +1911 @@
 char *owl_command_zwrite(int argc, const char *const *argv, const char *buff)
 {
-  owl_zwrite z;
+  owl_zwrite *z;
 
   if (!owl_global_is_havezephyr(&g)) {
@@ -1918 +1918 @@
   }
   /* check for a zwrite -m */
-  owl_zwrite_create_from_line(&z, buff);
-  if (owl_zwrite_is_message_set(&z)) {
-    owl_function_zwrite(buff, NULL);
-    owl_zwrite_cleanup(&z);
-    return (NULL);
-  }
-  owl_zwrite_cleanup(&z);
+  z = owl_zwrite_new(buff);
+  if (!z) {
+    owl_function_error("Error in zwrite arguments");
+    return NULL;
+  }
+
+  if (owl_zwrite_is_message_set(z)) {
+    owl_function_zwrite(z, NULL);
+    owl_zwrite_delete(z);
+    return NULL;
+  }
 
   if (argc < 2) {
+    owl_zwrite_delete(z);
     owl_function_makemsg("Not enough arguments to the zwrite command.");
   } else {
-    owl_function_zwrite_setup(buff);
+    owl_function_zwrite_setup(z);
   }
   return(NULL);
@@ -2016 +2021 @@
 {
   owl_function_loopwrite_setup();
-  return(NULL);
-}
-
-char *owl_command_zcrypt(int argc, const char *const *argv, const char *buff)
-{
-  owl_zwrite z;
-
-  if (!owl_global_is_havezephyr(&g)) {
-    owl_function_makemsg("Zephyr is not available");
-    return(NULL);
-  }
-  /* check for a zcrypt -m */
-  owl_zwrite_create_from_line(&z, buff);
-  if (owl_zwrite_is_message_set(&z)) {
-    owl_function_zcrypt(buff, NULL);
-    owl_zwrite_cleanup(&z);
-    return (NULL);
-  }
-  owl_zwrite_cleanup(&z);
-
-  if (argc < 2) {
-    owl_function_makemsg("Not enough arguments to the zcrypt command.");
-  } else {
-    owl_function_zwrite_setup(buff);
-  }
   return(NULL);
 }

configure.ac

@@ -35 +35 @@
   [with_zephyr=check])
 
+AC_ARG_WITH([krb4],
+  AS_HELP_STRING([--with-krb4],
+                 [Build with kerberos IV]))
+
 AS_IF([test "x$with_zephyr" != xno],
-  [AC_MSG_CHECKING([for Kerberos IV])
-   AS_IF([krb5-config krb4 --libs >/dev/null 2>&1],
-     [AC_MSG_RESULT([yes])
-      AC_DEFINE([HAVE_KERBEROS_IV], [1], [Define if you have kerberos IV])
-      CFLAGS="${CFLAGS} `krb5-config krb4 --cflags`"
-      LIBS="${LIBS} `krb5-config krb4 --libs`"
-     ],
-     [AC_MSG_RESULT([no])
-      PKG_CHECK_MODULES([LIBCRYPTO], [libcrypto])
-      CFLAGS="${CFLAGS} ${LIBCRYPTO_CFLAGS}"
-      LIBS="${LIBS} ${LIBCRYPTO_LIBS}"
-     ])
+  [AS_IF([test "x$with_krb4" != "xno"],
+   [AC_MSG_CHECKING([for Kerberos IV])
+    AS_IF([krb5-config krb4 --libs >/dev/null 2>&1],
+      [AC_MSG_RESULT([yes])
+       AC_DEFINE([HAVE_KERBEROS_IV], [1], [Define if you have kerberos IV])
+       CFLAGS="${CFLAGS} `krb5-config krb4 --cflags`"
+       LIBS="${LIBS} `krb5-config krb4 --libs`"
+      ],
+      [AC_MSG_RESULT([no])
+       AS_IF([test "x$with_krb4" = "xyes"],
+             [AC_MSG_ERROR([Kerberos IV requested but not found])])
+       PKG_CHECK_MODULES([LIBCRYPTO], [libcrypto])
+       CFLAGS="${CFLAGS} ${LIBCRYPTO_CFLAGS}"
+       LIBS="${LIBS} ${LIBCRYPTO_LIBS}"
+     ])])
    AC_CHECK_LIB([zephyr], [ZGetSender],
    [LIBS="$LIBS -lzephyr"
@@ -131 +138 @@
                                  test "$HAVE_DES_ECB_ENCRYPT"])
 
+CFLAGS="$CFLAGS -D_XOPEN_SOURCE"
+
 AC_SUBST([LIBFAIM_CFLAGS])
 

functions.c

@@ -222 +222 @@
  * that.
  */
-owl_message *owl_function_make_outgoing_zephyr(const char *body, const char *zwriteline, const char *zsig)
+owl_message *owl_function_make_outgoing_zephyr(const owl_zwrite *z)
 {
   owl_message *m;
-  owl_zwrite zw;
-
-  owl_zwrite_create_from_line(&zw, zwriteline);
-  owl_zwrite_set_zsig(&zw, zsig);
 
   /* create the message */
   m=owl_malloc(sizeof(owl_message));
-  
-  owl_message_create_from_zwrite(m, &zw, body);
-  owl_zwrite_cleanup(&zw);
+  owl_message_create_from_zwrite(m, z, owl_zwrite_get_message(z));
 
   return(m);
@@ -295 +289 @@
 }
 
-static void owl_function_write_setup(const char *line, const char *noun, void (*callback)(owl_editwin *))
+static void owl_function_write_setup(const char *noun)
 {
 
@@ -306 +300 @@
                          "End with a dot on a line by itself.  ^C will quit.",
                          noun);
-
-  owl_function_start_edit_win(line, callback,
+}
+
+void owl_function_zwrite_setup(owl_zwrite *z)
+{
+  /* send a ping if necessary */
+  if (owl_global_is_txping(&g)) {
+    owl_zwrite_send_ping(z);
+  }
+
+
+  owl_function_write_setup("zephyr");
+  owl_function_start_edit_win(z->zwriteline,
+                              &owl_callback_zwrite,
+                              z, (void(*)(void*))owl_zwrite_delete);
+}
+
+void owl_function_aimwrite_setup(const char *line)
+{
+  owl_function_write_setup("message");
+  owl_function_start_edit_win(line,
+                              &owl_callback_aimwrite,
                               owl_strdup(line),
                               owl_free);
-}
-
-void owl_function_zwrite_setup(const char *line)
-{
-  owl_zwrite z;
-  int ret;
-
-  /* check the arguments */
-  ret=owl_zwrite_create_from_line(&z, line);
-  if (ret) {
-    owl_function_error("Error in zwrite arguments");
-    owl_zwrite_cleanup(&z);
-    return;
-  }
-
-  /* send a ping if necessary */
-  if (owl_global_is_txping(&g)) {
-    owl_zwrite_send_ping(&z);
-  }
-  owl_zwrite_cleanup(&z);
-
-  owl_function_write_setup(line, "zephyr", &owl_callback_zwrite);
-}
-
-void owl_function_aimwrite_setup(const char *line)
-{
-  owl_function_write_setup(line, "message", &owl_callback_aimwrite);
+
 }
 
 void owl_function_loopwrite_setup(void)
 {
-  owl_function_write_setup("loopwrite", "message", owl_callback_loopwrite);
+  owl_function_write_setup("message");
+  owl_function_start_edit_win("loopwrite",
+                              &owl_callback_loopwrite,
+                              "loopwrite", NULL);
 }
 
 void owl_callback_zwrite(owl_editwin *e) {
-  char *command = owl_editwin_get_cbdata(e);
-  owl_function_zwrite(command,
-                      owl_editwin_get_text(e));
+  owl_zwrite *z = owl_editwin_get_cbdata(e);
+  owl_function_zwrite(z, owl_editwin_get_text(e));
 }
 
@@ -353 +342 @@
  * the message is expected to be set from the zwrite line itself
  */
-void owl_function_zwrite(const char *line, const char *msg)
-{
-  owl_zwrite z;
-  const char *mymsg;
+void owl_function_zwrite(owl_zwrite *z, const char *msg)
+{
   owl_message *m;
 
-  if(!strncmp(line, "zcrypt", strlen("zcrypt"))) {
-    owl_function_zcrypt(line, msg);
+  if(strcmp(z->cmd, "zcrypt") == 0) {
+    owl_function_zcrypt(z, msg);
     return;
   }
 
   /* create the zwrite and send the message */
-  owl_zwrite_create_from_line(&z, line);
-  owl_zwrite_populate_zsig(&z);
+  owl_zwrite_populate_zsig(z);
   if (msg) {
-    owl_zwrite_set_message(&z, msg);
-  }
-  owl_zwrite_send_message(&z);
+    owl_zwrite_set_message(z, msg);
+  }
+  owl_zwrite_send_message(z);
   owl_function_makemsg("Waiting for ack...");
 
   /* If it's personal */
-  if (owl_zwrite_is_personal(&z)) {
+  if (owl_zwrite_is_personal(z)) {
     /* create the outgoing message */
-    mymsg=owl_zwrite_get_message(&z);
-    m=owl_function_make_outgoing_zephyr(mymsg, line, owl_zwrite_get_zsig(&z));
+    m=owl_function_make_outgoing_zephyr(z);
 
     if (m) {
@@ -385 +370 @@
     }
   }
-
-  /* free the zwrite */
-  owl_zwrite_cleanup(&z);
 }
 
@@ -393 +375 @@
  * the message is expected to be set from the zwrite line itself
  */
-void owl_function_zcrypt(const char *line, const char *msg)
-{
-  owl_zwrite z;
-  const char *mymsg;
+void owl_function_zcrypt(owl_zwrite *z, const char *msg)
+{
   char *cryptmsg;
   owl_message *m;
@@ -402 +382 @@
   char *zcrypt;
   int rv, status;
+  char *old_msg;
 
   /* create the zwrite and send the message */
-  owl_zwrite_create_from_line(&z, line);
-  owl_zwrite_populate_zsig(&z);
+  owl_zwrite_populate_zsig(z);
   if (msg) {
-    owl_zwrite_set_message(&z, msg);
-  }
-
-  mymsg=owl_zwrite_get_message(&z);
+    owl_zwrite_set_message(z, msg);
+  }
+  old_msg = owl_strdup(owl_zwrite_get_message(z));
 
   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[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);
+  rv = call_filter(zcrypt, argv, owl_zwrite_get_message(z), &cryptmsg, &status);
 
   owl_free(zcrypt);
@@ -425 +404 @@
   if (rv || status) {
     if(cryptmsg) owl_free(cryptmsg);
+    owl_free(old_msg);
     owl_function_error("Error in zcrypt, possibly no key found.  Message not sent.");
     owl_function_beep();
-    owl_zwrite_cleanup(&z);
     return;
   }
 
-  owl_zwrite_set_message(&z, cryptmsg);
-  owl_zwrite_set_opcode(&z, "crypt");
-    
-  owl_zwrite_send_message(&z);
+  owl_zwrite_set_message_raw(z, cryptmsg);
+  owl_zwrite_set_opcode(z, "crypt");
+
+  owl_zwrite_send_message(z);
   owl_function_makemsg("Waiting for ack...");
 
   /* If it's personal */
-  if (owl_zwrite_is_personal(&z)) {
-    /* create the outgoing message */
-    mymsg=owl_zwrite_get_message(&z);
-    m=owl_function_make_outgoing_zephyr(mymsg, line, owl_zwrite_get_zsig(&z));
+  if (owl_zwrite_is_personal(z)) {
+    /* Create the outgoing message. Restore the un-crypted message for display. */
+    owl_zwrite_set_message_raw(z, old_msg);
+    m=owl_function_make_outgoing_zephyr(z);
     if (m) {
       owl_global_messagequeue_addmsg(&g, m);
@@ -451 +430 @@
   /* free the zwrite */
   owl_free(cryptmsg);
-  owl_zwrite_cleanup(&z);
 }
 

global.c

@@ -19 +19 @@
   char hostname[MAXHOSTNAMELEN];
   char *cd;
-
-  g->malloced=0;
-  g->freed=0;
 
   g_type_init();
@@ -955 +952 @@
   g->interrupted = 0;
 }
+
+void owl_global_setup_default_filters(owl_global *g)
+{
+  int i;
+  static const struct {
+    const char *name;
+    const char *desc;
+  } filters[] = {
+    { "personal",
+      "isprivate ^true$ and ( not type ^zephyr$ or ( class ^message  ) )" },
+    { "trash",
+      "class ^mail$ or opcode ^ping$ or type ^admin$ or ( not login ^none$ )" },
+    { "wordwrap", "not ( type ^admin$ or type ^zephyr$ )" },
+    { "ping", "opcode ^ping$" },
+    { "auto", "opcode ^auto$" },
+    { "login", "not login ^none$" },
+    { "reply-lockout", "class ^noc or class ^mail$" },
+    { "out", "direction ^out$" },
+    { "aim", "type ^aim$" },
+    { "zephyr", "type ^zephyr$" },
+    { "none", "false" },
+    { "all", "true" },
+    { NULL, NULL }
+  };
+
+  owl_function_debugmsg("startup: creating default filters");
+
+  for (i = 0; filters[i].name != NULL; i++)
+    owl_global_add_filter(g, owl_filter_new_fromstring(filters[i].name,
+                                                       filters[i].desc));
+}

owl.c

@@ -149 +149 @@
 }
 
-static void owl_setup_default_filters(void)
-{
-  int i;
-  static const struct {
-    const char *name;
-    const char *desc;
-  } filters[] = {
-    { "personal",
-      "isprivate ^true$ and ( not type ^zephyr$ or ( class ^message  ) )" },
-    { "trash",
-      "class ^mail$ or opcode ^ping$ or type ^admin$ or ( not login ^none$ )" },
-    { "wordwrap", "not ( type ^admin$ or type ^zephyr$ )" },
-    { "ping", "opcode ^ping$" },
-    { "auto", "opcode ^auto$" },
-    { "login", "not login ^none$" },
-    { "reply-lockout", "class ^noc or class ^mail$" },
-    { "out", "direction ^out$" },
-    { "aim", "type ^aim$" },
-    { "zephyr", "type ^zephyr$" },
-    { "none", "false" },
-    { "all", "true" },
-    { NULL, NULL }
-  };
-
-  owl_function_debugmsg("startup: creating default filters");
-
-  for (i = 0; filters[i].name != NULL; i++)
-    owl_global_add_filter(&g, owl_filter_new_fromstring(filters[i].name,
-                                                        filters[i].desc));
-}
 
 /*
@@ -544 +514 @@
   owl_global_complete_setup(&g);
 
-  owl_setup_default_filters();
+  owl_global_setup_default_filters(&g);
 
   /* set the current view */

owl.h

@@ -347 +347 @@
 
 typedef struct _owl_zwrite {
+  char *cmd;
   char *zwriteline;
   char *class;
@@ -613 +614 @@
   owl_colorpair_mgr cpmgr;
   pid_t newmsgproc_pid;
-  int malloced, freed;
   owl_regex search_re;
   aim_session_t aimsess;

perl/modules/Jabber/lib/BarnOwl/Message/Jabber.pm

@@ -20 +20 @@
 sub to { shift->{to} };
 sub room { shift->{room} };
+sub nick { shift->{nick} };
 sub subject { shift->{subject} };
 sub status { shift->{status} }
@@ -41 +42 @@
 sub long_sender {
     my $self = shift;
+    if ($self->jtype eq 'groupchat' && $self->nick) {
+        my $from_jid = Net::Jabber::JID->new($self->from);
+        if ($from_jid->GetJID('base') eq $self->room &&
+            $from_jid->GetResource() eq $self->nick) {
+            return $self->nick;
+        }
+    }
     return $self->from;
 }

perl/modules/Jabber/lib/BarnOwl/Module/Jabber.pm

@@ -1241 +1241 @@
             $muc = $connection->FindMUC(jid => $to);
         }
-        $props{from} = $muc->GetFullJID($from) || $nick || $room;
+        $props{from} = $muc->GetFullJID($from) || $props{from};
         $props{sender} = $nick || $room;
         $props{recipient} = $room;

perl/modules/Twitter/.gitignore

@@ -1 +1 @@
 *~
 blib/
-inc/
 META.yml
 Makefile
 Twitter.par
 pm_to_blib
+inc/.author

perl/modules/Twitter/lib/BarnOwl/Message/Twitter.pm

@@ -17 +17 @@
 sub service { return (shift->{"service"} || "http://twitter.com"); }
 sub account { return shift->{"account"}; }
+sub retweeted_by { shift->{retweeted_by}; }
 sub long_sender {
     my $self = shift;
     $self->service =~ m#^\s*(.*?://.*?)/.*$#;
     my $service = $1 || $self->service;
-    return $service . '/' . $self->sender
+    my $long = $service . '/' . $self->sender;
+    if ($self->retweeted_by) {
+        $long = "(retweeted by " . $self->retweeted_by . ") $long";
+    }
+    return $long;
 }
 

perl/modules/Twitter/lib/BarnOwl/Module/Twitter/Handle.pm

@@ -248 +248 @@
                 next;
             }
+            my $orig = $tweet->{retweeted_status};
+            $orig = $tweet unless defined($orig);
+
             my $msg = BarnOwl::Message->new(
                 type      => 'Twitter',
-                sender    => $tweet->{user}{screen_name},
+                sender    => $orig->{user}{screen_name},
                 recipient => $self->{cfg}->{user} || $self->{user},
                 direction => 'in',
-                source    => decode_entities($tweet->{source}),
-                location  => decode_entities($tweet->{user}{location}||""),
-                body      => decode_entities($tweet->{text}),
+                source    => decode_entities($orig->{source}),
+                location  => decode_entities($orig->{user}{location}||""),
+                body      => decode_entities($orig->{text}),
                 status_id => $tweet->{id},
                 service   => $self->{cfg}->{service},
                 account   => $self->{cfg}->{account_nickname},
+                $tweet->{retweeted_status} ? (retweeted_by => $tweet->{user}{screen_name}) : ()
                );
             BarnOwl::queue_message($msg);

perlconfig.c

@@ -12 +12 @@
 /* extern XS(boot_DBI); */
 
-static void owl_perl_xs_init(pTHX)
+void owl_perl_xs_init(pTHX) /* noproto */
 {
   const char *file = __FILE__;
@@ -363 +363 @@
   perl_construct(p);
 
+  PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
+
   owl_global_set_no_have_config(&g);
 

runtests.sh

@@ -1 +1 @@
 #!/bin/sh
-HARNESS_PERL=./perl_tester exec prove t/
+SRCDIR=`dirname "${0}"`
+
+export BARNOWL_DATA_DIR="$SRCDIR/perl/"
+export BARNOWL_BIN_DIR="$SRCDIR/"
+
+HARNESS_PERL=./tester exec prove t/

t/00-core-tests.t

@@ -1 +1 @@
 #!/usr/bin/env perl
 use File::Basename;
-system(dirname($0) . "/../tester");
+system(dirname($0) . "/../tester", "--builtin");

t/mock.pl

@@ -1 @@
-use File::Basename;
-use lib (dirname($0) . '/../perl/lib');
-
 package BarnOwl;
 use strict;
 use warnings;
-use Carp;
 
-sub get_data_dir {"."}
-sub get_config_dir {"."}
-sub create_style {}
-
-sub debug {
+no warnings 'redefine';
+sub debug($) {
     warn "[DEBUG] ", shift, "\n" if $ENV{TEST_VERBOSE};
 }
 
-sub BarnOwl::Internal::new_command {}
-sub BarnOwl::Internal::new_variable_bool {}
-sub BarnOwl::Internal::new_variable_int {}
-sub BarnOwl::Internal::new_variable_string {}
-sub BarnOwl::Editwin::save_excursion(&) {}
-
-use BarnOwl;
-
 1;

tester.c

@@ +1 @@
+#define OWL_PERL
+#define WINDOW FAKE_WINDOW
 #include "owl.h"
+#undef WINDOW
+
 #include <unistd.h>
 #include <stdlib.h>
 
+#undef instr
+#include <curses.h>
+
 owl_global g;
 
 int numtests;
 
+int owl_regtest(void);
 int owl_util_regtest(void);
 int owl_dict_regtest(void);
@@ -14 +22 @@
 int owl_editwin_regtest(void);
 
+extern void owl_perl_xs_init(pTHX);
+
 int main(int argc, char **argv, char **env)
 {
+  FILE *rnull;
+  FILE *wnull;
+  char *perlerr;
+  int status = 0;
+
+  if (argc <= 1) {
+    fprintf(stderr, "Usage: %s --builtin|TEST.t|-le CODE\n", argv[0]);
+    return 1;
+  }
+
   /* initialize a fake ncurses, detached from std{in,out} */
-  FILE *rnull = fopen("/dev/null", "r");
-  FILE *wnull = fopen("/dev/null", "w");
+  wnull = fopen("/dev/null", "w");
+  rnull = fopen("/dev/null", "r");
   newterm("xterm", wnull, rnull);
   /* initialize global structures */
   owl_global_init(&g);
 
+  perlerr = owl_perlconfig_initperl(NULL, &argc, &argv, &env);
+  if (perlerr) {
+    endwin();
+    fprintf(stderr, "Internal perl error: %s\n", perlerr);
+    status = 1;
+    goto out;
+  }
+
+  owl_global_complete_setup(&g);
+  owl_global_setup_default_filters(&g);
+
+  owl_view_create(owl_global_get_current_view(&g), "main",
+                  owl_global_get_filter(&g, "all"),
+                  owl_global_get_style_by_name(&g, "default"));
+
+  owl_function_firstmsg();
+
+  ENTER;
+  SAVETMPS;
+
+  if (strcmp(argv[1], "--builtin") == 0) {
+    status = owl_regtest();
+  } else if (strcmp(argv[1], "-le") == 0 && argc > 2) {
+    /*
+     * 'prove' runs its harness perl with '-le CODE' to get some
+     * information out.
+     */
+    moreswitches("l");
+    eval_pv(argv[2], true);
+  } else {
+    sv_setpv(get_sv("0", false), argv[1]);
+    sv_setpv(get_sv("main::test_prog", TRUE), argv[1]);
+
+    eval_pv("do $main::test_prog; die($@) if($@)", true);
+  }
+
+  status = 0;
+
+  FREETMPS;
+  LEAVE;
+
+ out:
+  perl_destruct(owl_global_get_perlinterp(&g));
+  perl_free(owl_global_get_perlinterp(&g));
+  /* probably not necessary, but tear down the screen */
+  endwin();
+  fclose(rnull);
+  fclose(wnull);
+  return status;
+}
+
+int owl_regtest(void) {
   numtests = 0;
   int numfailures=0;
@@ -38 +110 @@
   }
   printf("1..%d\n", numtests);
-
-  /* probably not necessary, but tear down the screen */
-  endwin();
-  fclose(rnull);
-  fclose(wnull);
 
   return(numfailures);

zcrypt.c

@@ -88 +88 @@
 
 cipher_pair ciphers[NCIPHER] = {
-  [CIPHER_DES] { do_encrypt_des, do_decrypt_des},
-  [CIPHER_AES] { do_encrypt_aes, do_decrypt_aes},
+  [CIPHER_DES] = { do_encrypt_des, do_decrypt_des},
+  [CIPHER_AES] = { do_encrypt_aes, do_decrypt_aes},
 };
 
@@ -113 +113 @@
   int mode = M_NONE;
 
-  extern int optind, opterr;
-  extern char *optarg;
   char c;
 

zephyr.c

@@ -852 +852 @@
   char *tmpbuff, *myuser, *to;
   owl_message *mout;
+  owl_zwrite *z;
   
   /* bail if it doesn't look like a message we should reply to.  Some
@@ -887 +888 @@
   owl_free(to);
 
+  z = owl_zwrite_new(tmpbuff);
+  owl_zwrite_set_message(z, owl_global_get_zaway_msg(&g));
+  owl_zwrite_set_zsig(z, "Automated reply:");
+
   /* display the message as an admin message in the receive window */
-  mout=owl_function_make_outgoing_zephyr(owl_global_get_zaway_msg(&g), tmpbuff, "Automated reply:");
+  mout=owl_function_make_outgoing_zephyr(z);
   owl_global_messagequeue_addmsg(&g, mout);
   owl_free(tmpbuff);
+  owl_zwrite_delete(z);
 #endif
 }

zwrite.c

@@ -5 +5 @@
 #include "owl.h"
 
+owl_zwrite *owl_zwrite_new(const char *line)
+{
+  owl_zwrite *z = owl_malloc(sizeof *z);
+  if (owl_zwrite_create_from_line(z, line) < 0) {
+    owl_zwrite_delete(z);
+    return NULL;
+  }
+  return z;
+}
+
 int owl_zwrite_create_from_line(owl_zwrite *z, const char *line)
 {
@@ -15 +25 @@
   
   /* start with null entries */
+  z->cmd=NULL;
   z->realm=NULL;
   z->class=NULL;
@@ -35 +46 @@
   myargc=argc;
   if (myargc && *(myargv[0])!='-') {
+    z->cmd=owl_strdup(myargv[0]);
     myargc--;
     myargv++;
@@ -187 +199 @@
 }
 
+/* Set the message with no post-processing*/
+void owl_zwrite_set_message_raw(owl_zwrite *z, const char *msg)
+{
+  if (z->message) owl_free(z->message);
+  z->message = owl_validate_utf8(msg);
+}
+
 void owl_zwrite_set_message(owl_zwrite *z, const char *msg)
 {
@@ -350 +369 @@
 }
 
+void owl_zwrite_delete(owl_zwrite *z)
+{
+  owl_zwrite_cleanup(z);
+  owl_free(z);
+}
+
 void owl_zwrite_cleanup(owl_zwrite *z)
 {