Changeset c2a8e22

README

r1c22155	rea23e6d
55	55	The Twitter module requires:
56	56
57		HTML::Entities
	57	HTML::Entities (provided by HTML::Parser)
58	58	Net::Twitter::Lite
59	59

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

-                      r8106870
+                      r10e2295
     $self->service =~ m#^\s*(.*?://.*?)/.*$#;
     my $service = $1 || $self->service;
     my $long = $service . '/' . $self->sender;
+    my $long = $service . '/' . $self->sender . '/status/' . $self->{status_id};
     if ($self->retweeted_by) {
         $long = "(retweeted by " . $self->retweeted_by . ") $long";
 …
     if($self->is_private) {
         return $self->replysendercmd;
+    } elsif(exists($self->{status_id})) {
+        return BarnOwl::quote('twitter-atreply', $self->sender, $self->{status_id}, $self->account);
+    }
+    # Roughly, this is how Twitter's @-reply calculation works
+    # (based on a few experiments)
+    #
+    #   1. The person who wrote the tweet you are replying to is added.
+    #      This is the only time when your own name can show up in an
+    #      at-reply string.
+    #   2. Next, Twitter goes through the Tweet front to back, adding
+    #      mentioned usernames that have not already been added to the
+    #      string.
+    #
+    # In degenerate cases, the at-reply string might be longer than
+    # the max Tweet size; Twitter doesn't care.
+    # XXX A horrifying violation of encapsulation
+    # NB: names array includes @-signs.
+    my $account = BarnOwl::Module::Twitter::find_account_default($self->{account});
+    my @inside_names = grep($_ ne ("@" . $account->{cfg}->{user}),
+                            $self->{body} =~ /(?:^|\s)(@\w+)/g );
+    my @dup_names = ( ( "@" . $self->sender ), @inside_names );
+    # XXX Really should use List::MoreUtils qw(uniq).  This code snippet
+    # lifted from `perldoc -q duplicate`.
+    my %seen = ();
+    my @names = grep { ! $seen{ $_ }++ } @dup_names;
+    my $prefill = join(' ', @names) . ' '; # NB need trailing space
+    if(exists($self->{status_id})) {
+        return BarnOwl::quote('twitter-prefill', $prefill, $self->{status_id}, $self->account);
     } else {
+        return BarnOwl::quote('twitter-atreply', $self->sender, $self->account);
+        # Give a dummy status ID
+        return BarnOwl::quote('twitter-prefill', $prefill, '', $self->account);
+    }
+}

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

-                      r140429f
+                      r8de7c84
 BarnOwl::new_command(twitter => \&cmd_twitter, {
     summary     => 'Update Twitter from BarnOwl',
     usage       => 'twitter [ACCOUNT] [MESSAGE]',
+    usage       => 'twitter [ACCOUNT [MESSAGE]]',
     description => 'Update Twitter on ACCOUNT. If MESSAGE is provided, use it as your status.'
     . "\nIf no ACCOUNT is provided, update all services which have publishing enabled."
 …
+    {
     summary     => 'Send a Twitter @ message',
     usage       => 'twitter-atreply USER [ACCOUNT]',
+    usage       => 'twitter-atreply USER [ID [ACCOUNT]]',
     description => 'Send a Twitter @reply Message to USER on ACCOUNT (defaults to default_sender,'
+    . "\nor first service if no default is provided)"
+    }
+);
+BarnOwl::new_command( 'twitter-prefill' => sub { cmd_twitter_prefill(@_); },
+    {
+    summary     => 'Send a Twitter message with prefilled text',
+    usage       => 'twitter-prefill PREFILL [ID [ACCOUNT]]',
+    description => 'Send a Twitter message with initial text PREFILL on ACCOUNT (defaults to default_sender,'
     . "\nor first service if no default is provided)"
+    }
 …
                             sub { $account->twitter_atreply($user, $id, shift) });
     BarnOwl::Editwin::insert_text("\@$user ");
+}
+sub cmd_twitter_prefill {
+    my $cmd  = shift;
+    # prefill is responsible for spacing
+    my $prefill = shift || die("Usage: $cmd PREFILL [In-Reply-To ID]\n");
+    my $id   = shift;
+    my $account = find_account_default(shift);
+    my $msg = "What's happening?";
+    if ($id) {
+        # So, this isn't quite semantically correct, but it's close
+        # enough, and under the planned use-case, it will look identical.
+        $msg = "Reply to " . $prefill;
+    }
+    if ($account->nickname) {
+        # XXX formatting slightly suboptimal on What's happening message;
+        # and the behavior does not match up with 'twitter' anyhoo,
+        # which doesn't dispatch through account_find_default
+        $msg .= " on " . $account->nickname;
+    }
+    BarnOwl::start_edit_win($msg,
+                            sub { $account->twitter_atreply(undef, $id, shift) });
+    BarnOwl::Editwin::insert_text($prefill);
+}

.travis.yml

-                      r48c09d4
+                      rbecd617
 language: perl
+sudo: false
 compiler:
   - clang
 …
   - "5.16"
   - "5.18"
+  - "5.19"
+install:
+  - sudo apt-get update -q
+# we actually want debhelper >= 7, libperl-dev >= 5.10.1-8, libzephyr-dev >= 3.0~beta
+  - sudo apt-get install -q autoconf autotools-dev debhelper dh-autoreconf libglib2.0-dev libkrb5-dev libncurses5-dev libncursesw5-dev libssl-dev libzephyr-dev pkg-config zip
+  - "5.20"
+addons:
+  apt:
+    # we actually want debhelper >= 7, libperl-dev >= 5.10.1-8, libzephyr-dev >= 3.0~beta
+    packages:
+    - autoconf
+    - autotools-dev
+    - debhelper
+    - dh-autoreconf
+    - libglib2.0-dev
+    - libkrb5-dev
+    - libncurses5-dev
+    - libncursesw5-dev
+    - libssl-dev
+    - libzephyr-dev
+    - pkg-config
+    - zip
 # perl things
 # In lp:~barnowl/barnowl/packaging, we use apt-get.  Here, we use cpanm.
 #  - sudo apt-get install libanyevent-perl libclass-accessor-perl libextutils-depends-perl libglib-perl libmodule-install-perl libnet-twitter-lite-perl libpar-perl libperl-dev
+  - cpanm AnyEvent Class::Accessor ExtUtils::Depends Glib Module::Install Net::Twitter::Lite PAR
 script: "./autogen.sh && ./configure && make distcheck"
+# It's taken care of by the default install script
+script: ./autogen.sh && ./configure && make distcheck

ChangeLog

-                      r6f87658
+                      r678a7650
+.10
+ * No changes above what's already in 1.10rc1
+.10rc1
+ * Numerous autotools/build machinery fixes -andersk@mit.edu
+ * Numerous code correctness and simplification/cleanup fixes -andersk@mit.edu
+ * Add and use a cpanfile documenting perl module dependencies -jgross@mit.edu
+ * Add Travis configuration -jgross@mit.edu
+ * Avoid strchrnul -andersk@mit.edu
+ * Numerous IRC fixes -jgross@mit.edu
+ * Improve smartnarrow and smartfilter documentation -jgross@mit.edu
+ * filterproc: Rewrite using GIOChannel -andersk@mit.edu
+ * Implement :twitter-favorite -nelhage@nelhage.com
+ * Kill the client-side tweet length check. -nelhage@nelhage.com
+ * squelch the Twitter legacy_list_api warnings -nelhage@nelhage.com
+ * Use SSL for Twitter by default -adehnert@mit.edu
+ * Humanize zsigs -andersk@mit.edu
+ * Show Zephyr charset in info popup -andersk@mit.edu
+ * Fix Jabber SRV record support (at one point fixed connecting via jabber to google talk or facebook) -james2vegas@aim.com
+ * fix cmd_join in BarnOwl/Module/IRC.pm -james2vegas@aim.com
+ * Add a ~/.owl/ircchannels file, persist channels -jgross@mit.edu
+ * Added hooks for user going idle or active. -jgross@mit.edu
+ * Support channel-or-user IRC commands, and setup irc-msg to use it. -ezyang@mit.edu
+ * Refactor perl calls through a single method -jgross@mit.edu
+ * Really support building Perl modules from a separate builddir -andersk@mit.edu
+ * Get rid of all our embedded copies of Module::Install -andersk@mit.edu
+ * Don't let new_variable_* overriding previously set values -rnjacobs@mit.edu
+ * Messages sent to 'class messages' are not personal -jgross@mit.edu
+ * Expose message_matches_filter to perl -jgross@mit.edu
+ * Fail fast on -c filsrv, which most people won't have permission to send to -rnjacobs@mit.edu
+ * zcrypt: Use getopt_long for argument parsing -andersk@mit.edu
+ * zcrypt: Accept -help and --version -andersk@mit.edu
+ * barnowl --help: Write to stdout and exit successfully -andersk@mit.edu
+ * Don't swallow errors in :unsuball -davidben@mit.edu
+ * Allow testing in a separate build directory -andersk@mit.edu
+ * Add support for arbitrary Perl subs for getters and setters for barnowl variables -glasgall@mit.edu
+ * owl_zephyr_loadsubs: Don’t leak memory on error opening ~/.zephyr.subs -andersk@mit.edu
+ * Make :loadsubs reload instanced personals too -davidben@mit.edu
+ * Fix some undefined behavior in filter.c, caught by clang scan-build -jgross@mit.edu
+ * Die on a failed zephyr_zwrite; don't silently ignore it -jgross@mit.edu
+ * Fix a memory leak in zcrypt.c, caught by clang scan-build -jgross@mit.edu
+ * zcrypt: Make gpg stop messing around in ~/.gnupg -andersk@mit.edu
+ * Fix display of pseudologins -davidben@mit.edu
+ * Unbundle random Facebook module libraries -davidben@mit.edu
+ * Replace deprecated GLib < 2.31.0 APIs -andersk@mit.edu
+ * Abstract g->interrupt_lock -andersk@mit.edu
+ * zephyr: Replace outgoing default format with a small URL -geofft@mit.edu
 .9
  * Update Jabber module for Net::DNS changes -james2vegas@aim.com

Makefile.am

-                      rca1fb26a
+                      r4fd3c04
 GIT_DESCRIPTION := $(if $(wildcard $(srcdir)/.git),$(shell cd $(srcdir) && git describe --match='barnowl-*' HEAD 2>/dev/null))
+VERSION = $(if $(GIT_DESCRIPTION),$(GIT_DESCRIPTION:barnowl-%=%),@VERSION@)
+-include BUILD_VERSION.mk
+VERSION = $(if $(GIT_DESCRIPTION),$(GIT_DESCRIPTION:barnowl-%=%),$(DIST_VERSION))
+DIST_VERSION = @VERSION@
+-include $(srcdir)/DIST_VERSION.mk BUILD_VERSION.mk
 FORCE:
 BUILD_VERSION.mk: $(if $(filter-out $(BUILD_VERSION),$(VERSION)),FORCE)
         echo 'BUILD_VERSION = $(VERSION)' > $@
+dist-hook:: $(if $(filter-out @VERSION@,$(VERSION)),dist-hook-version)
+dist-hook-version:
+        echo 'DIST_VERSION = $(VERSION)' > $(distdir)/DIST_VERSION.mk
 bin_PROGRAMS = bin/barnowl
 …
 endif
+zcrypt_SOURCES = zcrypt.c filterproc.c version.c
+zcrypt_SOURCES = zcrypt.c filterproc.c
+nodist_zcrypt_SOURCES = version.c
 check_PROGRAMS = bin/tester
 …
 dist_doc_DATA = doc/intro.txt doc/advanced.txt
 bin_barnowl_LDADD = compat/libcompat.a libfaim/libfaim.a
+bin_barnowl_LDADD = compat/libcompat.a
 bin_tester_SOURCES = $(BASE_SRCS) \
 …
 nodist_bin_tester_SOURCES = $(GEN_C) $(GEN_H)
 bin_tester_LDADD = compat/libcompat.a libfaim/libfaim.a
+bin_tester_LDADD = compat/libcompat.a
 TESTS=runtests.sh
 AM_CPPFLAGS = \
-           -I$(top_srcdir)/libfaim/ \
            -DDATADIR='"$(pkgdatadir)"' \
            -DBINDIR='"$(bindir)"'
 …
      regex.c history.c view.c dict.c variable.c filterelement.c pair.c \
      keypress.c keymap.c keybinding.c cmd.c context.c \
      aim.c buddy.c buddylist.c style.c errqueue.c \
+     style.c errqueue.c \
      zbuddylist.c popexec.c select.c wcwidth.c \
      mainpanel.c msgwin.c sepbar.c editcontext.c signal.c closures.c
 …
 CLEANFILES = $(BUILT_SOURCES) $(GEN_C) $(noinst_SCRIPTS) $(check_SCRIPTS) BUILD_VERSION.mk
+MAINTAINERCLEANFILES = DIST_VERSION.mk
 EXTRA_DIST = \
     autogen.sh \
 …
     scripts \
     stubgen.pl \
+    typemap
+    typemap \
+    cpanfile
 SUBDIRS = compat libfaim perl
+SUBDIRS = compat perl

codelist.pl

-                      r06adc25
+                      r4fd3c04
             && !/^XS/
             && !/\/\*/
+            && !/ZWRITEOPTIONS/
+            && !/owlfaim_priv/)
+            && !/ZWRITEOPTIONS/)
+        {

commands.c

-                      rca1fb26a
+                      r4fd3c04
               "      Send to the specified opcode\n"),
-  OWLCMD_ARGS("aimwrite", owl_command_aimwrite, OWL_CTX_INTERACTIVE,
-              "send an AIM message",
-              "aimwrite <user> [-m <message...>]",
-              "Send an aim message to a user.\n\n"
-              "The following options are available:\n\n"
-              "-m    Specifies a message to send without prompting.\n"),
   OWLCMD_ARGS("loopwrite", owl_command_loopwrite, OWL_CTX_INTERACTIVE,
               "send a loopback message",
 …
   OWLCMD_ARGS("set", owl_command_set, OWL_CTX_ANY,
               "set a variable value",
               "set [-q] [<variable>] [<value>]\n"
+              "set [-q] <variable> [<value>]\n"
               "set",
               "Set the named variable to the specified value.  If no\n"
 …
               "Execute the BarnOwl commands in <filename>.\n"),
-  OWLCMD_ARGS("aim", owl_command_aim, OWL_CTX_INTERACTIVE,
-              "AIM specific commands",
-              "aim search <email>",
-              ""),
   OWLCMD_ARGS("addbuddy", owl_command_addbuddy, OWL_CTX_INTERACTIVE,
               "add a buddy to a buddylist",
               "addbuddy <protocol> <screenname>",
               "Add the named buddy to your buddylist.  <protocol> can be aim or zephyr\n"),
+              "Add the named buddy to your buddylist.  <protocol> must be zephyr\n"),
   OWLCMD_ARGS("delbuddy", owl_command_delbuddy, OWL_CTX_INTERACTIVE,
               "delete a buddy from a buddylist",
               "delbuddy <protocol> <screenname>",
+              "Delete the named buddy from your buddylist.  <protocol> can be aim or zephyr\n"),
+  OWLCMD_ARGS("join", owl_command_join, OWL_CTX_INTERACTIVE,
+              "join a chat group",
+              "join aim <groupname> [exchange]",
+              "Join the AIM chatroom with 'groupname'.\n"),
+              "Delete the named buddy from your buddylist.  <protocol> must be zephyr\n"),
   OWLCMD_ARGS("smartzpunt", owl_command_smartzpunt, OWL_CTX_INTERACTIVE,
 …
               "znol [-f file]",
               "Print a znol-style listing of users logged in"),
-  OWLCMD_VOID("alist", owl_command_alist, OWL_CTX_INTERACTIVE,
-              "List AIM users logged in",
-              "alist",
-              "Print a listing of AIM users logged in"),
   OWLCMD_VOID("blist", owl_command_blist, OWL_CTX_INTERACTIVE,
 …
               "use the default.\n"),
-  OWLCMD_ARGS("aaway", owl_command_aaway, OWL_CTX_INTERACTIVE,
-              "Set, enable or disable AIM away message",
-              "aaway [ on | off | toggle ]\n"
-              "aaway <message>",
-              "Turn on or off the AIM away message.  If 'message' is\n"
-              "specified turn on aaway with that message, otherwise\n"
-              "use the default.\n"),
   OWLCMD_ARGS("away", owl_command_away, OWL_CTX_INTERACTIVE,
               "Set, enable or disable all away messages",
 …
               "otherwise use the default.\n"
               "\n"
+              "SEE ALSO: aaway, zaway"),
+              "SEE ALSO: zaway"),
+  OWLCMD_ARGS("flush-logs", owl_command_flushlogs, OWL_CTX_ANY,
+              "flush the queue of messages waiting to be logged",
+              "flush-logs [-f | --force] [-q | --quiet]",
+              "If BarnOwl failed to log a file, this command tells\n"
+              "BarnOwl to try logging the messages that have since\n"
+              "come in, and to resume logging normally.\n"
+              "\n"
+              "Normally, if logging any of these messages fails,\n"
+              "that message is added to the queue of messages waiting\n"
+              "to be logged, and any new messages are deferred until\n"
+              "the next :flush-logs.  If the --force flag is passed,\n"
+              "any messages on the queue which cannot successfully be\n"
+              "logged are dropped, and BarnOwl will resume logging\n"
+              "normally.\n"
+              "\n"
+              "Unless --quiet is passed, a message is printed about\n"
+              "how many logs there are to flush."),
   OWLCMD_ARGS("load-subs", owl_command_loadsubs, OWL_CTX_ANY,
 …
               "    body       -  message body\n"
               "    hostname   -  hostname of sending host\n"
               "    type       -  message type (zephyr, aim, admin)\n"
+              "    type       -  message type (zephyr, admin)\n"
               "    direction  -  either 'in' 'out' or 'none'\n"
               "    login      -  either 'login' 'logout' or 'none'\n"
 …
               "optional color arguments are used they specifies the colors that\n"
               "messages matching this filter should be displayed in.\n\n"
               "SEE ALSO: view, viewclass, viewuser\n"),
+              "SEE ALSO: smartfilter, smartnarrow, view, viewclass, viewuser\n"),
   OWLCMD_ARGS("colorview", owl_command_colorview, OWL_CTX_INTERACTIVE,
 …
               "filter expression that will be dynamically created by BarnOwl and then\n"
               "applied as the view's filter\n"
               "SEE ALSO: filter, viewclass, viewuser\n"),
+              "SEE ALSO: filter, smartfilter, smartnarrow, viewclass, viewuser\n"),
   OWLCMD_ARGS("smartnarrow", owl_command_smartnarrow, OWL_CTX_INTERACTIVE,
 …
               "    then narrow to the class and instance.\n"
               "If '-r' or '--related' is specified, behave as though the\n"
+              "    'narrow-related' variable was inverted."),
+              "    'narrow-related' variable was inverted.\n\n"
+              "SEE ALSO: filter, smartfilter, view, viewclass, viewuser\n"),
   OWLCMD_ARGS("smartfilter", owl_command_smartfilter, OWL_CTX_INTERACTIVE,
 …
               "If the curmsg is a class message, the filter is that class.\n"
               "If the curmsg is a class message and '-i' is specified\n"
+              "    the filter is to that class and instance.\n"),
+              "    the filter is to that class and instance.\n\n"
+              "SEE ALSO: filter, smartnarrow, view, viewclass, viewuser\n"),
   OWLCMD_ARGS("viewclass", owl_command_viewclass, OWL_CTX_INTERACTIVE,
 …
               "matching the specified class and switch the current view\n"
               "to it.\n\n"
               "SEE ALSO: filter, view, viewuser\n"),
+              "SEE ALSO: filter, smartfilter, smartnarrow, view, viewuser\n"),
   OWLCMD_ALIAS("vc", "viewclass"),
 …
               "matching the specified user and switch the current\n"
               "view to it.\n\n"
               "SEE ALSO: filter, view, viewclass\n"),
+              "SEE ALSO: filter, smartfilter, smartnarrow, view, viewclass\n"),
   OWLCMD_ALIAS("vu", "viewuser"),
   OWLCMD_ALIAS("viewperson", "viewuser"),
 …
           "no argument, it makes search highlighting inactive."),
-  OWLCMD_ARGS("aimlogin", owl_command_aimlogin, OWL_CTX_ANY,
-              "login to an AIM account",
-              "aimlogin <screenname> [<password>]\n",
-              ""),
-  OWLCMD_ARGS("aimlogout", owl_command_aimlogout, OWL_CTX_ANY,
-              "logout from AIM",
-              "aimlogout\n",
-              ""),
   OWLCMD_ARGS("error", owl_command_error, OWL_CTX_ANY,
               "Display an error message",
 …
+    }
+  }
   owl_function_buddylist(0, 1, file);
+  owl_function_buddylist(1, file);
   return(NULL);
+}
-void owl_command_alist(void)
+{
-  owl_function_buddylist(1, 0, NULL);
+}
 void owl_command_blist(void)
+{
   owl_function_buddylist(1, 1, NULL);
+  owl_function_buddylist(1, NULL);
+}
 …
+{
   owl_function_makemsg("BarnOwl version %s", version);
+}
-char *owl_command_aim(int argc, const char *const *argv, const char *buff)
+{
-  if (argc<2) {
-    owl_function_makemsg("not enough arguments to aim command");
-    return(NULL);
+  }
-  if (!strcmp(argv[1], "search")) {
-    if (argc!=3) {
-      owl_function_makemsg("not enough arguments to aim search command");
-      return(NULL);
+    }
-    owl_aim_search(argv[2]);
-  } else {
-    owl_function_makemsg("unknown subcommand '%s' for aim command", argv[1]);
-    return(NULL);
+  }
-  return(NULL);
+}
 …
+  }
+  if (!strcasecmp(argv[1], "aim")) {
+    if (!owl_global_is_aimloggedin(&g)) {
+      owl_function_makemsg("addbuddy: You must be logged into aim to use this command.");
+      return(NULL);
+    }
+    /*
+    owl_function_makemsg("This function is not yet operational.  Stay tuned.");
+    return(NULL);
+    */
+    owl_aim_addbuddy(argv[2]);
+    owl_function_makemsg("%s added as AIM buddy for %s", argv[2], owl_global_get_aim_screenname(&g));
+  } else if (!strcasecmp(argv[1], "zephyr")) {
+  if (!strcasecmp(argv[1], "zephyr")) {
     owl_zephyr_addbuddy(argv[2]);
     owl_function_makemsg("%s added as zephyr buddy", argv[2]);
   } else {
     owl_function_makemsg("addbuddy: currently the only supported protocols are 'zephyr' and 'aim'");
+    owl_function_makemsg("addbuddy: currently the only supported protocol is 'zephyr'");
+  }
 …
+  }
+  if (!strcasecmp(argv[1], "aim")) {
+    if (!owl_global_is_aimloggedin(&g)) {
+      owl_function_makemsg("delbuddy: You must be logged into aim to use this command.");
+      return(NULL);
+    }
+    owl_aim_delbuddy(argv[2]);
+    owl_function_makemsg("%s deleted as AIM buddy for %s", argv[2], owl_global_get_aim_screenname(&g));
+  } else if (!strcasecmp(argv[1], "zephyr")) {
+  if (!strcasecmp(argv[1], "zephyr")) {
     owl_zephyr_delbuddy(argv[2]);
     owl_function_makemsg("%s deleted as zephyr buddy", argv[2]);
   } else {
+    owl_function_makemsg("delbuddy: currently the only supported protocols are 'zephyr' and 'aim'");
+  }
+  return(NULL);
+}
+char *owl_command_join(int argc, const char *const *argv, const char *buff)
+{
+  if (argc!=3 && argc!=4) {
+    owl_function_makemsg("usage: join <protocol> <buddyname> [exchange]");
+    return(NULL);
+  }
+  if (!strcasecmp(argv[1], "aim")) {
+    if (!owl_global_is_aimloggedin(&g)) {
+      owl_function_makemsg("join aim: You must be logged into aim to use this command.");
+      return(NULL);
+    }
+    if (argc==3) {
+      owl_aim_chat_join(argv[2], 4);
+    } else {
+      owl_aim_chat_join(argv[2], atoi(argv[3]));
+    }
+    /* owl_function_makemsg("%s deleted as AIM buddy for %s", argv[2], owl_global_get_aim_screenname(&g)); */
+  } else {
+    owl_function_makemsg("join: currently the only supported protocol is 'aim'");
+  }
+    owl_function_makemsg("delbuddy: currently the only supported protocol is 'zephyr'");
+  }
   return(NULL);
+}
 …
+}
+char *owl_command_flushlogs(int argc, const char *const *argv, const char *buff)
+{
+  bool force = false;
+  bool quiet = false;
+  int i;
+  for (i = 1; i < argc; i++) {
+    if (!strcmp(argv[i], "-f") || !strcmp(argv[i], "--force")) {
+      force = true;
+    } else if (!strcmp(argv[i], "-q") || !strcmp(argv[i], "--quiet")) {
+      quiet = true;
+    } else {
+      owl_function_makemsg("Invalid flag to flush-logs: %s", argv[i]);
+    }
+  }
+  owl_log_flush_logs(force, quiet);
+  return NULL;
+}
 char *owl_command_loadsubs(int argc, const char *const *argv, const char *buff)
+{
 …
-char *owl_command_aaway(int argc, const char *const *argv, const char *buff)
+{
-  if ((argc==1) ||
-      ((argc==2) && !strcmp(argv[1], "on"))) {
-    owl_global_set_aaway_msg(&g, owl_global_get_aaway_msg_default(&g));
-    owl_function_aaway_on();
-    return NULL;
+  }
-  if (argc==2 && !strcmp(argv[1], "off")) {
-    owl_function_aaway_off();
-    return NULL;
+  }
-  if (argc==2 && !strcmp(argv[1], "toggle")) {
-    owl_function_aaway_toggle();
-    return NULL;
+  }
-  buff = skiptokens(buff, 1);
-  owl_global_set_aaway_msg(&g, buff);
-  owl_function_aaway_on();
-  return NULL;
+}
 char *owl_command_away(int argc, const char *const *argv, const char *buff)
+{
 …
       (argc == 2 && !strcmp(argv[1], "on"))) {
     away_off = false;
-    owl_global_set_aaway_msg(&g, owl_global_get_aaway_msg_default(&g));
     owl_global_set_zaway_msg(&g, owl_global_get_zaway_msg_default(&g));
   } else if (argc == 2 && !strcmp(argv[1], "off")) {
 …
   if (away_off) {
-    owl_function_aaway_off();
     owl_function_zaway_off();
     owl_perlconfig_perl_call_norv("BarnOwl::Hooks::_away_off", 0, NULL);
     owl_function_makemsg("Away messages off.");
   } else if (message != NULL) {
-    owl_global_set_aaway_msg(&g, message);
     owl_global_set_zaway_msg(&g, message);
-    owl_function_aaway_on();
     owl_function_zaway_on();
     owl_perlconfig_perl_call_norv("BarnOwl::Hooks::_away_on", 1, &message);
     owl_function_makemsg("Away messages set (%s).", message);
   } else {
-    owl_function_aaway_on();
     owl_function_zaway_on();
     owl_perlconfig_perl_call_norv("BarnOwl::Hooks::_away_on", 0, NULL);
 …
+  }
   return(NULL);
+}
-char *owl_command_aimwrite(int argc, const char *const *argv, const char *buff)
+{
-  char *message = NULL;
-  GString *recip = g_string_new("");
-  const char *const *myargv;
-  int myargc;
-  if (!owl_global_is_aimloggedin(&g)) {
-    owl_function_error("You are not logged in to AIM.");
-    goto err;
+  }
-  /* Skip argv[0]. */
-  myargv = argv+1;
-  myargc = argc-1;
-  while (myargc) {
-    if (!strcmp(myargv[0], "-m")) {
-      if (myargc <= 1) {
-        owl_function_error("No message specified.");
-        goto err;
+      }
-      /* Once we have -m, gobble up everything else on the line */
-      myargv++;
-      myargc--;
-      message = g_strjoinv(" ", (char**)myargv);
-      break;
-    } else {
-      /* squish arguments together to make one screenname w/o spaces for now */
-      g_string_append(recip, myargv[0]);
-      myargv++;
-      myargc--;
+    }
+  }
-  if (recip->str[0] == '\0') {
-    owl_function_error("No recipient specified");
-    goto err;
+  }
-  if (message != NULL)
-    owl_function_aimwrite(recip->str, message, false);
-  else
-    owl_function_aimwrite_setup(recip->str);
- err:
-  g_string_free(recip, true);
-  g_free(message);
-  return NULL;
+}
 …
+}
-char *owl_command_aimlogin(int argc, const char *const *argv, const char *buff)
+{
-  if ((argc<2) || (argc>3)) {
-    owl_function_makemsg("Wrong number of arguments to aimlogin command");
-    return(NULL);
+  }
-  /* if we get two arguments, ask for the password */
-  if (argc==2) {
-    owl_editwin *e = owl_function_start_password("AIM Password: ");
-    owl_editwin_set_cbdata(e, g_strdup(argv[1]), g_free);
-    owl_editwin_set_callback(e, owl_callback_aimlogin);
-    return(NULL);
-  } else {
-    owl_function_aimlogin(argv[1], argv[2]);
+  }
-  /* this is a test */
-  return(NULL);
+}
-char *owl_command_aimlogout(int argc, const char *const *argv, const char *buff)
+{
-  /* clear the buddylist */
-  owl_buddylist_clear(owl_global_get_buddylist(&g));
-  owl_aim_logout();
-  return(NULL);
+}
 CALLER_OWN char *owl_command_getstyle(int argc, const char *const *argv, const char *buff)
+{

configure.ac

-                      r77dfeb1
+                      r9a0d25d
 dnl Process this file with autoconf to produce a configure script.
 AC_INIT([BarnOwl],[1.10dev],[bug-barnowl@mit.edu])
+AC_INIT([BarnOwl],[1.11dev],[bug-barnowl@mit.edu])
 AM_INIT_AUTOMAKE([1.7.0 foreign std-options -Wall -Wno-portability])
 AM_MAINTAINER_MODE([enable])
 …
   [with_zephyr=check])
-AC_ARG_WITH([krb4],
-  AS_HELP_STRING([--with-krb4],
-                 [Build with kerberos IV]))
 AS_IF([test "x$with_zephyr" != xno],
+  [have_krb4=no
+   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])
+       have_krb4=yes
+       AC_DEFINE([HAVE_KERBEROS_IV], [1], [Define if you have kerberos IV])
+       AM_CFLAGS="${AM_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])])])])
+   AS_IF([test "x$have_krb4" != xyes],
+     [PKG_CHECK_MODULES([LIBCRYPTO], [libcrypto],
+        [AM_CFLAGS="${AM_CFLAGS} ${LIBCRYPTO_CFLAGS}"
+         LIBS="${LIBS} ${LIBCRYPTO_LIBS}"
+        ],
+        [PKG_CHECK_MODULES([OPENSSL], [openssl],
+           [AM_CFLAGS="${AM_CFLAGS} ${OPENSSL_CFLAGS}"
+            LIBS="${LIBS} ${OPENSSL_LIBS}"
+           ])])])
+  [PKG_CHECK_MODULES([LIBCRYPTO], [libcrypto],
+     [AM_CFLAGS="${AM_CFLAGS} ${LIBCRYPTO_CFLAGS}"
+      LIBS="${LIBS} ${LIBCRYPTO_LIBS}"
+     ],
+     [PKG_CHECK_MODULES([OPENSSL], [openssl],
+        [AM_CFLAGS="${AM_CFLAGS} ${OPENSSL_CFLAGS}"
+         LIBS="${LIBS} ${OPENSSL_LIBS}"
+        ])])
    AC_CHECK_LIB([zephyr], [ZGetSender],
 …
 AC_CHECK_FUNCS([use_default_colors])
 AC_CHECK_FUNCS([resizeterm], [], [AC_MSG_ERROR([No resizeterm found])])
 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])
+AC_CHECK_FUNCS([DES_string_to_key], [HAVE_DES_STRING_TO_KEY=1])
+AC_CHECK_FUNCS([DES_ecb_encrypt], [HAVE_DES_ECB_ENCRYPT=1])
+AC_CHECK_FUNCS([DES_key_sched], [HAVE_DES_KEY_SCHED=1])
 dnl Checks for header files.
 …
 AX_APPEND_COMPILE_FLAGS([-Wno-format-zero-length],[AM_CFLAGS])
-AX_APPEND_COMPILE_FLAGS([-Wno-pointer-sign -Wno-empty-body -Wno-unused-value],[LIBFAIM_CFLAGS])
 AM_CONDITIONAL([ENABLE_ZCRYPT], [test "$HAVE_DES_STRING_TO_KEY" && dnl
                                  test "$HAVE_DES_KEY_SCHED" && dnl
 …
 AM_CFLAGS="$AM_CFLAGS -D_XOPEN_SOURCE=600"
 dnl Define _BSD_SOURCE because zephyr needs caddr_t.
 AM_CFLAGS="$AM_CFLAGS -D_BSD_SOURCE"
+dnl Define _BSD_SOURCE/_DEFAULT_SOURCE because zephyr needs caddr_t.
+AM_CFLAGS="$AM_CFLAGS -D_BSD_SOURCE -D_DEFAULT_SOURCE"
 dnl Define __EXTENSIONS__ for strcasecmp on Solaris.
 AM_CFLAGS="$AM_CFLAGS -D__EXTENSIONS__"
 …
 AC_SUBST([AM_CFLAGS])
-AC_SUBST([LIBFAIM_CFLAGS])
 AC_SUBST(XSUBPPDIR)
 …
 AC_SUBST([abs_srcdir])
 AC_CONFIG_FILES([Makefile compat/Makefile libfaim/Makefile perl/Makefile perl/modules/Makefile])
+AC_CONFIG_FILES([Makefile compat/Makefile perl/Makefile perl/modules/Makefile])
 AC_OUTPUT

doc/advanced.txt

-                      rc82b055
+                      r4fd3c04
      realm         zephyr realm
      body          message body
      type          message type ('zephyr', 'aim', 'admin')
+     type          message type ('zephyr', 'admin')
      direction     either 'in' 'out' or 'none'\n"
      login         either 'login' 'logout' or 'none'\n"
 …
 All owl::Message objects contain the following methods:
     type      - returns the type of the message ("zephyr", "aim", "admin")
+    type      - returns the type of the message ("zephyr", "admin")
     direction - returns "in" or "out" for incoming or outgoing messages
     time      - returns a string of the time when the message showed up
 …
     header      - returns the admin message header line  (admin)
     is_personal - returns true if this is a personal message (aim,zephyr)
+    is_personal - returns true if this is a personal message (zephyr)
     is_private  - returns true if this was a private message (zephyr)
     login_tty   - returns the login tty for login messages (zephyr)

doc/intro.txt

-                      rd7cc50b
+                      r4fd3c04
 Owl is a tty, curses-based instant messaging client.  This is a quick
 guide to learning how to use it.  Currently Owl supports AIM & zephyr,
+guide to learning how to use it.  Currently Owl supports zephyr,
 but other messaging protocols, including Jabber, are on the way.  Some
 major features of owl include:
 …
 If you wish to send to a class/instance pair simply supply -c and -i
 arguments to the zwrite command as you normally would.
-Sending an AIM message
-----------------------
-Before sending an AIM message you must login to AOL Instant Messenger.
-Use the 'aimlogin' command, with your screenname as an argument:
-     aimlogin <screenname>
-You will be prompted for your password, which you must enter.  Once
-you are successfully logged in you can send an AIM message by pressing
-the 'a' key, which will bring up an 'aimwrite' command:
-     aimwrite <screenname>
-Supply the screen name you wish to write to as an argument and then
-send the message just as you would send a zephyr, as described above.
 Manipulating Messages
 …
      auto             Messages generated by automated programs
      out              Messages sent from you to another user
-     aim              AIM messages
      zephyr           Zephyr messages
      trash            "Trash" messages

filter.c

-                      r7dcef03
+                      r9e596f5
 owl_filter *owl_filter_new(const char *name, int argc, const char *const *argv)
+{
+  return owl_filter_new_colored(name, argc, argv, OWL_COLOR_DEFAULT, OWL_COLOR_DEFAULT);
+}
+owl_filter *owl_filter_new_colored(const char *name, int argc, const char *const *argv, int fgcolor, int bgcolor)
+{
   owl_filter *f;
 …
   f->name=g_strdup(name);
+  f->fgcolor=OWL_COLOR_DEFAULT;
+  f->bgcolor=OWL_COLOR_DEFAULT;
+  /* first take arguments that have to come first */
+  /* set the color */
+  while ( argc>=2 && ( !strcmp(argv[0], "-c") ||
+                       !strcmp(argv[0], "-b") ) ) {
+    if (owl_util_string_to_color(argv[1])==OWL_COLOR_INVALID) {
+      owl_function_error("The color '%s' is not available, using default.", argv[1]);
+    } else {
+      switch (argv[0][1]) {
+      case 'c':
+        f->fgcolor=owl_util_string_to_color(argv[1]);
+        break;
+      case 'b':
+        f->bgcolor=owl_util_string_to_color(argv[1]);
+        break;
+      }
+    }
+    argc-=2;
+    argv+=2;
+  }
+  f->fgcolor = fgcolor;
+  f->bgcolor = bgcolor;
   if (!(f->root = owl_filter_parse_expression(argc, argv, NULL))) {

filterproc.c

-                      r7155955
+                      re8db357
 #include "filterproc.h"
 #include <sys/wait.h>
 #include <fcntl.h>
+#include <string.h>
 #include <glib.h>
-#include <poll.h>
-#include <string.h>
-#include <unistd.h>
+/* Even in case of error, send_receive is responsible for closing wfd
+ * (to EOF the child) and rfd (for consistency). */
+static int send_receive(int rfd, int wfd, const char *out, char **in)
+struct filter_data {
+  const char **in;
+  const char *in_end;
+  GString *out_str;
+  GMainLoop *loop;
+  int err;
+};
+static gboolean filter_stdin(GIOChannel *channel, GIOCondition condition, gpointer data_)
+{
+  GString *str = g_string_new("");
+  char buf[1024];
+  nfds_t nfds;
+  int err = 0;
+  struct pollfd fds[2];
+  struct filter_data *data = data_;
+  gboolean done = condition & (G_IO_ERR | G_IO_HUP);
+  fcntl(rfd, F_SETFL, O_NONBLOCK | fcntl(rfd, F_GETFL));
+  fcntl(wfd, F_SETFL, O_NONBLOCK | fcntl(wfd, F_GETFL));
+  fds[0].fd = rfd;
+  fds[0].events = POLLIN;
+  fds[1].fd = wfd;
+  fds[1].events = POLLOUT;
+  if(!out || !*out) {
+    /* Nothing to write. Close our end so the child doesn't hang waiting. */
+    close(wfd); wfd = -1;
+    out = NULL;
+  if (condition & G_IO_OUT) {
+    gsize n;
+    GIOStatus ret = g_io_channel_write_chars(channel, *data->in, data->in_end - *data->in, &n, NULL);
+    *data->in += n;
+    if (ret == G_IO_STATUS_ERROR)
+      data->err = 1;
+    if (ret == G_IO_STATUS_ERROR || *data->in == data->in_end)
+      done = TRUE;
+  }
+  while(1) {
+    if(out && *out) {
+      nfds = 2;
+    } else {
+      nfds = 1;
+    }
+    err = poll(fds, nfds, -1);
+    if(err < 0) {
+      break;
+    }
+    if(out && *out) {
+      if(fds[1].revents & POLLOUT) {
+        err = write(wfd, out, strlen(out));
+        if(err > 0) {
+          out += err;
+        }
+        if(err < 0) {
+          out = NULL;
+        }
+      }
+      if(!out || !*out || fds[1].revents & (POLLERR | POLLHUP)) {
+        close(wfd); wfd = -1;
+        out = NULL;
+      }
+    }
+    if(fds[0].revents & POLLIN) {
+      err = read(rfd, buf, sizeof(buf));
+      if(err <= 0) {
+        break;
+      }
+      g_string_append_len(str, buf, err);
+    } else if(fds[0].revents & (POLLHUP | POLLERR)) {
+      err = 0;
+      break;
+  if (condition & G_IO_ERR)
+    data->err = 1;
+  if (done)
+    g_io_channel_shutdown(channel, TRUE, NULL);
+  return !done;
+}
+static gboolean filter_stdout(GIOChannel *channel, GIOCondition condition, gpointer data_)
+{
+  struct filter_data *data = data_;
+  gboolean done = condition & (G_IO_ERR | G_IO_HUP);
+  if (condition & (G_IO_IN | G_IO_HUP)) {
+    gchar *buf;
+    gsize n;
+    GIOStatus ret = g_io_channel_read_to_end(channel, &buf, &n, NULL);
+    g_string_append_len(data->out_str, buf, n);
+    g_free(buf);
+    if (ret == G_IO_STATUS_ERROR) {
+      data->err = 1;
+      done = TRUE;
+    }
+  }
+  if (wfd >= 0) close(wfd);
+  close(rfd);
+  *in = g_string_free(str, err < 0);
+  return err;
+  if (condition & G_IO_ERR)
+    data->err = 1;
+  if (done) {
+    g_io_channel_shutdown(channel, TRUE, NULL);
+    g_main_loop_quit(data->loop);
+  }
+  return !done;
+}
 int call_filter(const char *const *argv, const char *in, char **out, int *status)
+{
-  int err;
   GPid child_pid;
   int child_stdin, child_stdout;
 …
+  }
+  err = send_receive(child_stdout, child_stdin, in, out);
+  if (err == 0) {
+    waitpid(child_pid, status, 0);
+  }
+  return err;
+  if (in == NULL) in = "";
+  GMainContext *context = g_main_context_new();
+  struct filter_data data = {&in, in + strlen(in), g_string_new(""), g_main_loop_new(context, FALSE), 0};
+  GIOChannel *channel = g_io_channel_unix_new(child_stdin);
+  g_io_channel_set_encoding(channel, NULL, NULL);
+  g_io_channel_set_flags(channel, g_io_channel_get_flags(channel) | G_IO_FLAG_NONBLOCK, NULL);
+  GSource *source = g_io_create_watch(channel, G_IO_OUT | G_IO_ERR | G_IO_HUP);
+  g_io_channel_unref(channel);
+  g_source_set_callback(source, (GSourceFunc)filter_stdin, &data, NULL);
+  g_source_attach(source, context);
+  g_source_unref(source);
+  channel = g_io_channel_unix_new(child_stdout);
+  g_io_channel_set_encoding(channel, NULL, NULL);
+  g_io_channel_set_flags(channel, g_io_channel_get_flags(channel) | G_IO_FLAG_NONBLOCK, NULL);
+  source = g_io_create_watch(channel, G_IO_IN | G_IO_ERR | G_IO_HUP);
+  g_io_channel_unref(channel);
+  g_source_set_callback(source, (GSourceFunc)filter_stdout, &data, NULL);
+  g_source_attach(source, context);
+  g_source_unref(source);
+  g_main_loop_run(data.loop);
+  g_main_loop_unref(data.loop);
+  g_main_context_unref(context);
+  waitpid(child_pid, status, 0);
+  g_spawn_close_pid(child_pid);
+  *out = g_string_free(data.out_str, data.err);
+  return data.err;
+}

functions.c

-                      rb61ad80
+                      r9e596f5
     "':sub @b(class)', and then type ':zwrite -c @b(class)' to send.\n\n"
 #endif
-    "@b(AIM:)\n"
-    "Log in to AIM with ':aimlogin @b(screenname)'. Use ':aimwrite @b(screenname)',\n"
-    "or 'a' and then the screen name, to send someone a message.\n\n"
+    ;
 …
+}
-/* Create an outgoing AIM message, returns a pointer to the created
- * message or NULL if we're not logged into AIM (and thus unable to
- * create the message).  Does not put it on the global queue.  Use
- * owl_global_messagequeue_addmsg() for that.
- */
-CALLER_OWN owl_message *owl_function_make_outgoing_aim(const char *body, const char *to)
+{
-  owl_message *m;
-  /* error if we're not logged into aim */
-  if (!owl_global_is_aimloggedin(&g)) return(NULL);
-  m=g_slice_new(owl_message);
-  owl_message_create_aim(m,
-                         owl_global_get_aim_screenname(&g),
-                         to,
-                         body,
-                         OWL_MESSAGE_DIRECTION_OUT,
-);
-  return(m);
+}
 /* Create an outgoing loopback message and return a pointer to it.
  * Does not append it to the global queue, use
 …
+}
-void owl_function_aimwrite_setup(const char *to)
+{
-  owl_editwin *e;
-  /* TODO: We probably actually want an owl_aimwrite object like
-   * owl_zwrite. */
-  char *line = g_strdup_printf("aimwrite %s", to);
-  owl_function_write_setup("message");
-  e = owl_function_start_edit_win(line);
-  owl_editwin_set_cbdata(e, g_strdup(to), g_free);
-  owl_editwin_set_callback(e, &owl_callback_aimwrite);
-  g_free(line);
+}
 void owl_function_loopwrite_setup(void)
+{
 …
   g_free(cryptmsg);
   g_free(old_msg);
+}
-void owl_callback_aimwrite(owl_editwin *e, bool success)
+{
-  if (!success) return;
-  char *to = owl_editwin_get_cbdata(e);
-  owl_function_aimwrite(to, owl_editwin_get_text(e), true);
+}
-void owl_function_aimwrite(const char *to, const char *msg, bool unwrap)
+{
-  int ret;
-  char *format_msg;
-  owl_message *m;
-  /* make a formatted copy of the message */
-  format_msg = g_strdup(msg);
-  if (unwrap)
-    owl_text_wordunwrap(format_msg);
-  /* send the message */
-  ret=owl_aim_send_im(to, format_msg);
-  if (!ret) {
-    owl_function_makemsg("AIM message sent.");
-  } else {
-    owl_function_error("Could not send AIM message.");
+  }
-  /* create the outgoing message */
-  m=owl_function_make_outgoing_aim(msg, to);
-  if (m) {
-    owl_global_messagequeue_addmsg(&g, m);
-  } else {
-    owl_function_error("Could not create outgoing AIM message");
+  }
-  g_free(format_msg);
+}
-void owl_function_send_aimawymsg(const char *to, const char *msg)
+{
-  int ret;
-  char *format_msg;
-  owl_message *m;
-  /* make a formatted copy of the message */
-  format_msg=g_strdup(msg);
-  owl_text_wordunwrap(format_msg);
-  /* send the message */
-  ret=owl_aim_send_awaymsg(to, format_msg);
-  if (!ret) {
-    /* owl_function_makemsg("AIM message sent."); */
-  } else {
-    owl_function_error("Could not send AIM message.");
+  }
-  /* create the message */
-  m=owl_function_make_outgoing_aim(msg, to);
-  if (m) {
-    owl_global_messagequeue_addmsg(&g, m);
-  } else {
-    owl_function_error("Could not create AIM message");
+  }
-  g_free(format_msg);
+}
 …
+}
-void owl_callback_aimlogin(owl_editwin *e, bool success)
+{
-  if (!success) return;
-  char *user = owl_editwin_get_cbdata(e);
-  owl_function_aimlogin(user,
-                        owl_editwin_get_text(e));
+}
-void owl_function_aimlogin(const char *user, const char *passwd) {
-  int ret;
-  /* clear the buddylist */
-  owl_buddylist_clear(owl_global_get_buddylist(&g));
-  /* try to login */
-  ret=owl_aim_login(user, passwd);
-  if (ret) owl_function_makemsg("Warning: login for %s failed.\n", user);
+}
 void owl_function_suspend(void)
+{
 …
+}
-void owl_function_aaway_toggle(void)
+{
-  if (!owl_global_is_aaway(&g)) {
-    owl_global_set_aaway_msg(&g, owl_global_get_aaway_msg_default(&g));
-    owl_function_aaway_on();
-  } else {
-    owl_function_aaway_off();
+  }
+}
-void owl_function_aaway_on(void)
+{
-  owl_global_set_aaway_on(&g);
-  /* owl_aim_set_awaymsg(owl_global_get_zaway_msg(&g)); */
-  owl_function_makemsg("AIM away set (%s)", owl_global_get_aaway_msg(&g));
+}
-void owl_function_aaway_off(void)
+{
-  owl_global_set_aaway_off(&g);
-  /* owl_aim_set_awaymsg(""); */
-  owl_function_makemsg("AIM away off");
+}
 bool owl_function_is_away(void)
+{
   return owl_global_is_zaway(&g) ||
-         owl_global_is_aaway(&g) ||
          owl_perlconfig_perl_call_bool("BarnOwl::Hooks::_get_is_away", 0, NULL);
+}
 …
   if (owl_global_get_newmsgproc_pid(&g)) {
     kill(owl_global_get_newmsgproc_pid(&g), SIGHUP);
+  }
-  /* Quit AIM */
-  if (owl_global_is_aimloggedin(&g)) {
-    owl_aim_logout();
+  }
 …
   FILE *file;
   time_t now;
+  struct tm tm;
   va_list ap;
 …
   now = time(NULL);
   tmpbuff = owl_util_format_time(localtime(&now));
+  tmpbuff = owl_util_format_time(localtime_r(&now, &tm));
   fprintf(file, "[%d -  %s - %lds]: ",
           (int) getpid(), tmpbuff, now - owl_global_get_starttime(&g));
 …
   char buff[MAXPATHLEN+1];
   time_t start;
+  struct tm tm;
   int up, days, hours, minutes;
   owl_fmtext fm;
 …
   owl_fmtext_append_normal(&fm, "\n");
   tmpbuff = owl_util_format_time(localtime(&start));
+  tmpbuff = owl_util_format_time(localtime_r(&start, &tm));
   owl_fmtext_appendf_normal(&fm, "  Startup Time: %s\n", tmpbuff);
   g_free(tmpbuff);
 …
     owl_fmtext_append_normal(&fm, "no\n");
+  }
-  owl_fmtext_append_normal(&fm, "  AIM included       : yes\n");
   owl_fmtext_append_normal(&fm, "  Loopback included  : yes\n");
 …
   owl_fmtext_append_normal(&fm, "no\n");
 #endif
-  owl_fmtext_append_normal(&fm, "\nAIM Status:\n");
-  owl_fmtext_append_normal(&fm, "  Logged in: ");
-  if (owl_global_is_aimloggedin(&g)) {
-    owl_fmtext_append_normal(&fm, owl_global_get_aim_screenname(&g));
-    owl_fmtext_append_normal(&fm, "\n");
-  } else {
-    owl_fmtext_append_normal(&fm, "(not logged in)\n");
+  }
-  owl_fmtext_append_normal(&fm, "  Processing events: ");
-  if (owl_global_is_doaimevents(&g)) {
-    owl_fmtext_append_normal(&fm, "yes\n");
-  } else {
-    owl_fmtext_append_normal(&fm, "no\n");
+  }
   owl_function_popless_fmtext(&fm);
 …
   const owl_view *v;
   int inuse = 0;
+  int i = 2;
+  int fgcolor = OWL_COLOR_DEFAULT;
+  bool set_fgcolor = false;
+  int bgcolor = OWL_COLOR_DEFAULT;
+  bool set_bgcolor = false;
   if (argc < 2) {
 …
+  }
+  /* deal with the case of trying change the filter color */
+  if (argc==4 && !strcmp(argv[2], "-c")) {
+  /* set the color */
+  while (i + 2 <= argc && (!strcmp(argv[i], "-c") ||
+                           !strcmp(argv[i], "-b"))) {
+    int color = owl_util_string_to_color(argv[i + 1]);
+    if (color == OWL_COLOR_INVALID) {
+      owl_function_error("The color '%s' is not available.", argv[i + 1]);
+    } else if (argv[i][1] == 'c') {
+      fgcolor = color;
+      set_fgcolor = true;
+    } else {
+      bgcolor = color;
+      set_bgcolor = true;
+    }
+    i += 2;
+  }
+  if (i > 2 && i == argc) {
     f=owl_global_get_filter(&g, argv[1]);
     if (!f) {
 …
       return false;
+    }
+    if (owl_util_string_to_color(argv[3])==OWL_COLOR_INVALID) {
+      owl_function_error("The color '%s' is not available.", argv[3]);
+    if (!set_fgcolor && !set_bgcolor)
       return false;
+    }
+    owl_filter_set_fgcolor(f, owl_util_string_to_color(argv[3]));
+    owl_mainwin_redisplay(owl_global_get_mainwin(&g));
+    return false;
+  }
+  if (argc==4 && !strcmp(argv[2], "-b")) {
+    f=owl_global_get_filter(&g, argv[1]);
+    if (!f) {
+      owl_function_error("The filter '%s' does not exist.", argv[1]);
+      return false;
+    }
+    if (owl_util_string_to_color(argv[3])==OWL_COLOR_INVALID) {
+      owl_function_error("The color '%s' is not available.", argv[3]);
+      return false;
+    }
+    owl_filter_set_bgcolor(f, owl_util_string_to_color(argv[3]));
+    if (set_fgcolor)
+      owl_filter_set_fgcolor(f, fgcolor);
+    if (set_bgcolor)
+      owl_filter_set_bgcolor(f, bgcolor);
     owl_mainwin_redisplay(owl_global_get_mainwin(&g));
     return true;
 …
   /* create the filter and check for errors */
   f = owl_filter_new(argv[1], argc-2, argv+2);
+  f = owl_filter_new_colored(argv[1], argc - i, argv + i, fgcolor, bgcolor);
   if (f == NULL) {
     owl_function_error("Invalid filter: %s", argv[1]);
 …
   if (f == NULL) {
     /* Couldn't make a filter for some reason. Return NULL. */
-    owl_function_error("Error creating filter '%s'", filtname);
-    g_free(filtname);
-    return NULL;
+  }
-  /* add it to the global list */
-  owl_global_add_filter(&g, f);
-  return(filtname);
+}
-/* Create a filter for AIM IM messages to or from the specified
- * screenname.  The name of the filter will be 'aimuser-<user>'.  If a
- * filter already exists with this name, no new filter will be
- * created.  This allows the configuration to override this function.
- * Returns the name of the filter, which the caller must free.
- */
-CALLER_OWN char *owl_function_aimuserfilt(const char *user)
+{
-  owl_filter *f;
-  char *argbuff, *filtname;
-  char *escuser;
-  /* name for the filter */
-  filtname=g_strdup_printf("aimuser-%s", user);
-  /* if it already exists then go with it.  This lets users override */
-  if (owl_global_get_filter(&g, filtname)) {
-    return filtname;
+  }
-  /* create the new-internal filter */
-  escuser = owl_text_quote(user, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
-  argbuff = g_strdup_printf(
-      "( type ^aim$ and ( ( sender ^%1$s$ and recipient ^%2$s$ ) or "
-      "( sender ^%2$s$ and recipient ^%1$s$ ) ) )",
-      escuser, owl_global_get_aim_screenname_for_filters(&g));
-  g_free(escuser);
-  f = owl_filter_new_fromstring(filtname, argbuff);
-  g_free(argbuff);
-  if (f == NULL) {
     owl_function_error("Error creating filter '%s'", filtname);
     g_free(filtname);
 …
  * If the curmsg is a zephyr class message and type==1 then
  *    return a filter name for the class and instance.
- * If the curmsg is a personal AIM message returna  filter
- *    name to the AIM conversation with that user
  */
 CALLER_OWN char *owl_function_smartfilter(int type, int invert_related)
 …
   if (owl_message_is_type_loopback(m)) {
     return(owl_function_typefilt("loopback"));
+  }
-  /* aim messages */
-  if (owl_message_is_type_aim(m)) {
-    if (owl_message_is_direction_in(m)) {
-      filtname=owl_function_aimuserfilt(owl_message_get_sender(m));
-    } else if (owl_message_is_direction_out(m)) {
-      filtname=owl_function_aimuserfilt(owl_message_get_recipient(m));
+    }
-    return(filtname);
+  }
 …
 /* Popup a buddylisting.  If filename is NULL use the default .anyone */
 void owl_function_buddylist(int aim, int zephyr, const char *filename)
+{
   int i, j, idle;
+void owl_function_buddylist(int zephyr, const char *filename)
+{
+  int i;
   int interrupted = 0;
   owl_fmtext fm;
-  const owl_buddylist *bl;
-  const owl_buddy *b;
-  char *timestr;
 #ifdef HAVE_LIBZEPHYR
   int x;
 …
   owl_fmtext_init_null(&fm);
-  /* AIM first */
-  if (aim && owl_global_is_aimloggedin(&g)) {
-    bl=owl_global_get_buddylist(&g);
-    owl_fmtext_append_bold(&fm, "AIM users logged in:\n");
-    /* we're assuming AIM for now */
-    j=owl_buddylist_get_size(bl);
-    for (i=0; i<j; i++) {
-      b=owl_buddylist_get_buddy_n(bl, i);
-      idle=owl_buddy_get_idle_time(b);
-      if (idle!=0) {
-        timestr=owl_util_format_minutes(idle);
-      } else {
-        timestr=g_strdup("");
+      }
-      owl_fmtext_appendf_normal(&fm, "  %-20.20s %-12.12s\n", owl_buddy_get_name(b), timestr);
-      g_free(timestr);
+    }
+  }
 #ifdef HAVE_LIBZEPHYR
 …
 #endif
   if (aim && zephyr) {
+  if (zephyr) {
     if (owl_perlconfig_is_function("BarnOwl::Hooks::_get_blist")) {
       char * perlblist = owl_perlconfig_execute("BarnOwl::Hooks::_get_blist()");
 …
   char *date;
   time_t now;
+  struct tm tm;
   char *buff;
   now = time(NULL);
   date = owl_util_format_time(localtime(&now));
+  date = owl_util_format_time(localtime_r(&now, &tm));
   buff = g_strdup_printf("%s %s", date, string);
 …
+}
-void owl_function_aimsearch_results(const char *email, GPtrArray *namelist)
+{
-  owl_fmtext fm;
-  int i;
-  owl_fmtext_init_null(&fm);
-  owl_fmtext_append_normal(&fm, "AIM screennames associated with ");
-  owl_fmtext_append_normal(&fm, email);
-  owl_fmtext_append_normal(&fm, ":\n");
-  for (i = 0; i < namelist->len; i++) {
-    owl_fmtext_append_normal(&fm, "  ");
-    owl_fmtext_append_normal(&fm, namelist->pdata[i]);
-    owl_fmtext_append_normal(&fm, "\n");
+  }
-  owl_function_popless_fmtext(&fm);
-  owl_fmtext_cleanup(&fm);
+}
 int owl_function_get_color_count(void)
+{

global.c

-                      r7dcef03
+                      r4fd3c04
   _owl_global_init_windows(g);
-  g->aim_screenname=NULL;
-  g->aim_screenname_for_filters=NULL;
-  g->aim_loggedin=0;
-  owl_buddylist_init(&(g->buddylist));
   g->havezephyr=0;
-  g->haveaim=0;
-  g->ignoreaimlogin=0;
-  owl_global_set_no_doaimevents(g);
   owl_errqueue_init(&(g->errqueue));
 …
+}
-/* AIM stuff */
-int owl_global_is_aimloggedin(const owl_global *g)
+{
-  if (g->aim_loggedin) return(1);
-  return(0);
+}
-const char *owl_global_get_aim_screenname(const owl_global *g)
+{
-  if (owl_global_is_aimloggedin(g)) {
-    return (g->aim_screenname);
+  }
-  return("");
+}
-const char *owl_global_get_aim_screenname_for_filters(const owl_global *g)
+{
-  if (owl_global_is_aimloggedin(g)) {
-    return (g->aim_screenname_for_filters);
+  }
-  return("");
+}
-void owl_global_set_aimloggedin(owl_global *g, const char *screenname)
+{
-  char *sn_escaped;
-  g->aim_loggedin=1;
-  if (g->aim_screenname) g_free(g->aim_screenname);
-  if (g->aim_screenname_for_filters) g_free(g->aim_screenname_for_filters);
-  g->aim_screenname=g_strdup(screenname);
-  sn_escaped = owl_text_quote(screenname, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
-  g->aim_screenname_for_filters = owl_arg_quote(sn_escaped);
-  g_free(sn_escaped);
+}
-void owl_global_set_aimnologgedin(owl_global *g)
+{
-  g->aim_loggedin=0;
+}
-bool owl_global_is_doaimevents(const owl_global *g)
+{
-  return g->aim_event_source != NULL;
+}
-void owl_global_set_doaimevents(owl_global *g)
+{
-  if (g->aim_event_source)
-    return;
-  g->aim_event_source = owl_aim_event_source_new(owl_global_get_aimsess(g));
-  g_source_attach(g->aim_event_source, NULL);
+}
-void owl_global_set_no_doaimevents(owl_global *g)
+{
-  if (!g->aim_event_source)
-    return;
-  g_source_destroy(g->aim_event_source);
-  g_source_unref(g->aim_event_source);
-  g->aim_event_source = NULL;
+}
-aim_session_t *owl_global_get_aimsess(owl_global *g)
+{
-  return(&(g->aimsess));
+}
-aim_conn_t *owl_global_get_bosconn(owl_global *g)
+{
-  return(&(g->bosconn));
+}
-void owl_global_set_bossconn(owl_global *g, aim_conn_t *conn)
+{
-  g->bosconn=*conn;
+}
 /* message queue */
 …
+}
-owl_buddylist *owl_global_get_buddylist(owl_global *g)
+{
-  return(&(g->buddylist));
+}
 /* style */
 …
   owl_dict_insert_element(&(g->styledict), owl_style_get_name(s),
                           s, (void (*)(void *))owl_style_delete);
+}
-void owl_global_set_haveaim(owl_global *g)
+{
-  g->haveaim=1;
+}
-int owl_global_is_haveaim(const owl_global *g)
+{
-  if (g->haveaim) return(1);
-  return(0);
+}
-void owl_global_set_ignore_aimlogin(owl_global *g)
+{
-    g->ignoreaimlogin = 1;
+}
-void owl_global_unset_ignore_aimlogin(owl_global *g)
+{
-    g->ignoreaimlogin = 0;
+}
-int owl_global_is_ignore_aimlogin(const owl_global *g)
+{
-    return g->ignoreaimlogin;
+}
 …
     { "reply-lockout", "class ^mail$ or class ^filsrv$" },
     { "out", "direction ^out$" },
-    { "aim", "type ^aim$" },
     { "zephyr", "type ^zephyr$" },
     { "none", "false" },

help.c

-                      r8258ea5
+                      r4fd3c04
      "\n"
      "    z             Start a zwrite command\n"
-     "    a             Start an aimwrite command\n"
      "    r             Reply to the current message\n"
      "    R             Reply to sender\n"
 …
      "    !             Invert the current view\n"
      "\n"
      "    l             Print a zephyr/AIM buddy listing\n"
+     "    l             Print a zephyr buddy listing\n"
      "    A             Toggle away\n"
      "    o             Toggle one-line display mode\n"
 …
      "\n"
      "    zwrite        Send a zephyr\n"
-     "    aimlogin      Login to AIM\n"
-     "    aimwrite      Send an AIM message\n"
      "\n"
      "    addbuddy      Add a zephyr or AIM buddy\n"
+     "    addbuddy      Add a zephyr buddy\n"
      "    zaway         Turn zaway on or off, or set the message\n"
      "    zlocate       Locate a user\n"
      "    subscribe     Subscribe to a zephyr class or instance\n"
      "    unsubscribe   Unsubscribe to a zephyr class or instance\n"
      "    blist         Print a list of zephyr and AIM buddies logged in\n"
+     "    blist         Print a list of zephyr buddies logged in\n"
      "    search        Search for a text string\n"
      "\n"
 …
      "    zlog          Send a login or logout notification\n"
      "    zlist         Print a list of zephyr buddies logged in\n"
-     "    alist         Print a list of AIM buddies logged in\n"
      "    info          Print detailed information about the current message\n"
      "    filter        Create a message filter\n"

keys.c

-                      rdcd48ad
+                      r4fd3c04
   BIND_CMD("M-RIGHT",     "edit:move-next-word", "");
   BIND_CMD("M-[ 1 ; 3 D", "edit:move-next-word", "");
+  BIND_CMD("M-[ 1 ; 5 D", "edit:move-next-word", "");
   BIND_CMD("M-b",         "edit:move-prev-word", "");
   BIND_CMD("M-O 3 D",     "edit:move-prev-word", "");
   BIND_CMD("M-LEFT",      "edit:move-prev-word", "");
+  BIND_CMD("M-[ 1 ; 3 C", "edit:move-next-word", "");
+  BIND_CMD("M-[ 1 ; 3 C", "edit:move-prev-word", "");
+  BIND_CMD("M-[ 1 ; 5 C", "edit:move-prev-word", "");
   BIND_CMD("LEFT",        "edit:move-left", "");
 …
   BIND_CMD("z",   "start-command zwrite ", "start a zwrite command");
-  BIND_CMD("a",   "start-command aimwrite ", "start an aimwrite command");
   BIND_CMD("r",   "reply",            "reply to the current message");
   BIND_CMD("R",   "reply sender",     "reply to sender of the current message");

logging.c

-                      r7dcef03
+                      r0c059f0
 } owl_log_entry;
+typedef struct _owl_log_options { /* noproto */
+  bool drop_failed_logs;
+  bool display_initial_log_count;
+} owl_log_options;
 static GMainContext *log_context;
 static GMainLoop *log_loop;
 static GThread *logging_thread;
+/* This is now the one function that should be called to log a
+ * message.  It will do all the work necessary by calling the other
+ * functions in this file as necessary.
+static bool defer_logs; /* to be accessed only on the disk-writing thread */
+static GQueue *deferred_entry_queue;
+static void owl_log_error_main_thread(gpointer data)
+{
+  owl_function_error("%s", (const char*)data);
+}
+static void owl_log_adminmsg_main_thread(gpointer data)
+{
+  owl_function_adminmsg("Logging", (const char*)data);
+}
+static void owl_log_makemsg_main_thread(gpointer data)
+{
+  owl_function_makemsg("%s", (const char*)data);
+}
+static void G_GNUC_PRINTF(1, 2) owl_log_error(const char *fmt, ...)
+{
+  va_list ap;
+  char *data;
+  va_start(ap, fmt);
+  data = g_strdup_vprintf(fmt, ap);
+  va_end(ap);
+  owl_select_post_task(owl_log_error_main_thread,
+                       data, g_free, g_main_context_default());
+}
+static void G_GNUC_PRINTF(1, 2) owl_log_adminmsg(const char *fmt, ...)
+{
+  va_list ap;
+  char *data;
+  va_start(ap, fmt);
+  data = g_strdup_vprintf(fmt, ap);
+  va_end(ap);
+  owl_select_post_task(owl_log_adminmsg_main_thread,
+                       data, g_free, g_main_context_default());
+}
+static void G_GNUC_PRINTF(1, 2) owl_log_makemsg(const char *fmt, ...)
+{
+  va_list ap;
+  char *data;
+  va_start(ap, fmt);
+  data = g_strdup_vprintf(fmt, ap);
+  va_end(ap);
+  owl_select_post_task(owl_log_makemsg_main_thread,
+                       data, g_free, g_main_context_default());
+}
+static CALLER_OWN owl_log_entry *owl_log_new_entry(const char *buffer, const char *filename)
+{
+  owl_log_entry *log_msg = g_slice_new(owl_log_entry);
+  log_msg->message = g_strdup(buffer);
+  log_msg->filename = g_strdup(filename);
+  return log_msg;
+}
+static void owl_log_deferred_enqueue_message(const char *buffer, const char *filename)
+{
+  g_queue_push_tail(deferred_entry_queue, owl_log_new_entry(buffer, filename));
+}
+static void owl_log_deferred_enqueue_first_message(const char *buffer, const char *filename)
+{
+  g_queue_push_head(deferred_entry_queue, owl_log_new_entry(buffer, filename));
+}
+/* write out the entry if possible
+ * return 0 on success, errno on failure to open
  */
+void owl_log_message(const owl_message *m) {
+  owl_function_debugmsg("owl_log_message: entering");
+  if (m == NULL) {
+    owl_function_debugmsg("owl_log_message: passed null message");
+    return;
+  }
+  /* should we be logging this message? */
+  if (!owl_log_shouldlog_message(m)) {
+    owl_function_debugmsg("owl_log_message: not logging message");
+    return;
+  }
+  /* handle incmoing messages */
+  if (owl_message_is_direction_in(m)) {
+    owl_log_incoming(m);
+    owl_function_debugmsg("owl_log_message: leaving");
+    return;
+  }
+  /* handle outgoing messages */
+  owl_log_outgoing(m);
+  owl_function_debugmsg("owl_log_message: leaving");
+}
+/* Return 1 if we should log the given message, otherwise return 0 */
+int owl_log_shouldlog_message(const owl_message *m) {
+  const owl_filter *f;
+  /* If there's a logfilter and this message matches it, log */
+  f=owl_global_get_filter(&g, owl_global_get_logfilter(&g));
+  if (f && owl_filter_message_match(f, m)) return(1);
+  /* otherwise we do things based on the logging variables */
+  /* skip login/logout messages if appropriate */
+  if (!owl_global_is_loglogins(&g) && owl_message_is_loginout(m)) return(0);
+  /* check direction */
+  if ((owl_global_get_loggingdirection(&g)==OWL_LOGGING_DIRECTION_IN) && owl_message_is_direction_out(m)) {
+    return(0);
+  }
+  if ((owl_global_get_loggingdirection(&g)==OWL_LOGGING_DIRECTION_OUT) && owl_message_is_direction_in(m)) {
+    return(0);
+  }
+  if (owl_message_is_type_zephyr(m)) {
+    if (owl_message_is_personal(m) && !owl_global_is_logging(&g)) return(0);
+    if (!owl_message_is_personal(m) && !owl_global_is_classlogging(&g)) return(0);
+  } else {
+    if (owl_message_is_private(m) || owl_message_is_loginout(m)) {
+      if (!owl_global_is_logging(&g)) return(0);
+    } else {
+      if (!owl_global_is_classlogging(&g)) return(0);
+    }
+  }
+  return(1);
+}
+CALLER_OWN char *owl_log_zephyr(const owl_message *m)
+{
+    char *tmp = NULL;
+    GString *buffer = NULL;
+    buffer = g_string_new("");
+    tmp = short_zuser(owl_message_get_sender(m));
+    g_string_append_printf(buffer, "Class: %s Instance: %s",
+                           owl_message_get_class(m),
+                           owl_message_get_instance(m));
+    if (strcmp(owl_message_get_opcode(m), "")) {
+      g_string_append_printf(buffer, " Opcode: %s",
+                             owl_message_get_opcode(m));
+    }
+    g_string_append_printf(buffer, "\n");
+    g_string_append_printf(buffer, "Time: %s Host: %s\n",
+                           owl_message_get_timestr(m),
+                           owl_message_get_hostname(m));
+    g_string_append_printf(buffer, "From: %s <%s>\n\n",
+                           owl_message_get_zsig(m), tmp);
+    g_string_append_printf(buffer, "%s\n\n", owl_message_get_body(m));
+    g_free(tmp);
+    return g_string_free(buffer, FALSE);
+}
+CALLER_OWN char *owl_log_aim(const owl_message *m)
+{
+    GString *buffer = NULL;
+    buffer = g_string_new("");
+    g_string_append_printf(buffer, "From: <%s> To: <%s>\n",
+                           owl_message_get_sender(m), owl_message_get_recipient(m));
+    g_string_append_printf(buffer, "Time: %s\n\n",
+                           owl_message_get_timestr(m));
+    if (owl_message_is_login(m)) {
+        g_string_append_printf(buffer, "LOGIN\n\n");
+    } else if (owl_message_is_logout(m)) {
+        g_string_append_printf(buffer, "LOGOUT\n\n");
+    } else {
+        g_string_append_printf(buffer, "%s\n\n", owl_message_get_body(m));
+    }
+    return g_string_free(buffer, FALSE);
+}
+CALLER_OWN char *owl_log_jabber(const owl_message *m)
+{
+    GString *buffer = NULL;
+    buffer = g_string_new("");
+    g_string_append_printf(buffer, "From: <%s> To: <%s>\n",
+                           owl_message_get_sender(m),
+                           owl_message_get_recipient(m));
+    g_string_append_printf(buffer, "Time: %s\n\n",
+                           owl_message_get_timestr(m));
+    g_string_append_printf(buffer, "%s\n\n", owl_message_get_body(m));
+    return g_string_free(buffer, FALSE);
+}
+CALLER_OWN char *owl_log_generic(const owl_message *m)
+{
+    GString *buffer;
+    buffer = g_string_new("");
+    g_string_append_printf(buffer, "From: <%s> To: <%s>\n",
+                           owl_message_get_sender(m),
+                           owl_message_get_recipient(m));
+    g_string_append_printf(buffer, "Time: %s\n\n",
+                           owl_message_get_timestr(m));
+    g_string_append_printf(buffer, "%s\n\n",
+                           owl_message_get_body(m));
+    return g_string_free(buffer, FALSE);
+}
+static void owl_log_error_main_thread(gpointer data)
+{
+  owl_function_error("%s", (const char*)data);
+}
+static void owl_log_error(const char *message)
+{
+  char *data = g_strdup(message);
+  owl_select_post_task(owl_log_error_main_thread,
+                       data, g_free, g_main_context_default());
+}
+static void owl_log_write_entry(gpointer data)
+{
+  owl_log_entry *msg = (owl_log_entry*)data;
+static int owl_log_try_write_entry(owl_log_entry *msg)
+{
   FILE *file = NULL;
   file = fopen(msg->filename, "a");
   if (!file) {
+    owl_log_error("Unable to open file for logging");
+    return;
+    return errno;
+  }
   fprintf(file, "%s", msg->message);
   fclose(file);
+}
+static void owl_log_entry_free(void *data)
+  return 0;
+}
+static void owl_log_entry_delete(void *data)
+{
   owl_log_entry *msg = (owl_log_entry*)data;
+  if (msg) {
+    g_free(msg->message);
+    g_free(msg->filename);
+    g_slice_free(owl_log_entry, msg);
+  }
+  g_free(msg->message);
+  g_free(msg->filename);
+  g_slice_free(owl_log_entry, msg);
+}
+#if GLIB_CHECK_VERSION(2, 32, 0)
+#else
+static void owl_log_entry_delete_gfunc(gpointer data, gpointer user_data)
+{
+  owl_log_entry_delete(data);
+}
+#endif
+static void owl_log_file_error(owl_log_entry *msg, int errnum)
+{
+  owl_log_error("Unable to open file for logging: %s (file %s)",
+                g_strerror(errnum),
+                msg->filename);
+}
+/* If we are deferring log messages, enqueue this entry for writing.
+ * Otherwise, try to write this log message, and, if it fails with
+ * EPERM, EACCES, or ETIMEDOUT, go into deferred logging mode and
+ * queue an admin message.  If it fails with anything else, display an
+ * error message, drop the log message, and do not go into deferred
+ * logging mode.
+ *
+ * N.B. This function is called only on the disk-writing thread. */
+static void owl_log_eventually_write_entry(gpointer data)
+{
+  int ret;
+  owl_log_entry *msg = (owl_log_entry*)data;
+  if (defer_logs) {
+    owl_log_deferred_enqueue_message(msg->message, msg->filename);
+  } else {
+    ret = owl_log_try_write_entry(msg);
+    if (ret == EPERM || ret == EACCES || ret == ETIMEDOUT) {
+      defer_logs = true;
+      owl_log_error("Unable to open file for logging (%s): \n"
+                    "%s.  \n"
+                    "Consider renewing your tickets.  Logging has been \n"
+                    "suspended, and your messages will be saved.  To \n"
+                    "resume logging, use the command :flush-logs.\n\n",
+                    msg->filename,
+                    g_strerror(ret));
+      /* If we were not in deferred logging mode, either the queue should be
+       * empty, or we are attempting to log a message that we just popped off
+       * the head of the queue.  Either way, we should enqueue this message as
+       * the first message in the queue, rather than the last, so that we
+       * preserve message ordering. */
+      owl_log_deferred_enqueue_first_message(msg->message, msg->filename);
+    } else if (ret != 0) {
+      owl_log_file_error(msg, ret);
+    }
+  }
+}
+/* tries to write the deferred log entries
+ *
+ * N.B. This function is called only on the disk-writing thread. */
+static void owl_log_write_deferred_entries(gpointer data)
+{
+  owl_log_entry *entry;
+  owl_log_options *opts = (owl_log_options *)data;
+  int ret;
+  int logged_message_count = 0;
+  bool all_succeeded = true;
+  if (opts->display_initial_log_count) {
+    if (g_queue_is_empty(deferred_entry_queue)) {
+      owl_log_makemsg("There are no logs to flush.");
+    } else {
+      owl_log_makemsg("Attempting to flush %u logs...",
+                      g_queue_get_length(deferred_entry_queue));
+    }
+  }
+  defer_logs = false;
+  while (!g_queue_is_empty(deferred_entry_queue) && !defer_logs) {
+    logged_message_count++;
+    entry = (owl_log_entry*)g_queue_pop_head(deferred_entry_queue);
+    if (!opts->drop_failed_logs) {
+      /* Attempt to write the log entry.  If it fails, re-queue the entry at
+       * the head of the queue. */
+      owl_log_eventually_write_entry(entry);
+    } else {
+      /* Attempt to write the log entry. If it fails, print an error message,
+       * drop the log, and keep going through the queue. */
+      ret = owl_log_try_write_entry(entry);
+      if (ret != 0) {
+        all_succeeded = false;
+        owl_log_file_error(entry, ret);
+      }
+    }
+    owl_log_entry_delete(entry);
+  }
+  if (logged_message_count > 0) {
+    if (opts->display_initial_log_count) {
+      /* first clear the "attempting to flush" message from the status bar */
+      owl_log_makemsg("");
+    }
+    if (!defer_logs) {
+      if (all_succeeded) {
+        owl_log_adminmsg("Flushed %d logs and resumed logging.",
+                         logged_message_count);
+      } else {
+        owl_log_adminmsg("Flushed or dropped %d logs and resumed logging.",
+                         logged_message_count);
+      }
+    } else {
+      owl_log_error("Attempted to flush %d logs; %u deferred logs remain.",
+                    logged_message_count, g_queue_get_length(deferred_entry_queue));
+    }
+  }
+}
+void owl_log_flush_logs(bool drop_failed_logs, bool quiet)
+{
+  owl_log_options *data = g_new(owl_log_options, 1);
+  data->drop_failed_logs = drop_failed_logs;
+  data->display_initial_log_count = !quiet;
+  owl_select_post_task(owl_log_write_deferred_entries,
+                       data,
+                       g_free,
+                       log_context);
+}
 void owl_log_enqueue_message(const char *buffer, const char *filename)
+{
+  owl_log_entry *log_msg = NULL;
+  log_msg = g_slice_new(owl_log_entry);
+  log_msg->message = g_strdup(buffer);
+  log_msg->filename = g_strdup(filename);
+  owl_select_post_task(owl_log_write_entry, log_msg,
+                       owl_log_entry_free, log_context);
+}
+void owl_log_append(const owl_message *m, const char *filename) {
+  char *buffer = NULL;
+  if (owl_message_is_type_zephyr(m)) {
+    buffer = owl_log_zephyr(m);
+  } else if (owl_message_is_type_jabber(m)) {
+    buffer = owl_log_jabber(m);
+  } else if (owl_message_is_type_aim(m)) {
+    buffer = owl_log_aim(m);
+  } else {
+    buffer = owl_log_generic(m);
+  }
+  owl_log_enqueue_message(buffer, filename);
+  g_free(buffer);
+}
+void owl_log_outgoing(const owl_message *m)
+{
+  char *filename, *logpath;
+  char *to, *temp;
+  GList *cc;
+  /* expand ~ in path names */
+  logpath = owl_util_makepath(owl_global_get_logpath(&g));
+  /* Figure out what path to log to */
+  if (owl_message_is_type_zephyr(m)) {
+    /* If this has CC's, do all but the "recipient" which we'll do below */
+    cc = owl_message_get_cc_without_recipient(m);
+    while (cc != NULL) {
+      temp = short_zuser(cc->data);
+      filename = g_build_filename(logpath, temp, NULL);
+      owl_log_append(m, filename);
+      g_free(filename);
+      g_free(temp);
+      g_free(cc->data);
+      cc = g_list_delete_link(cc, cc);
+    }
+    to = short_zuser(owl_message_get_recipient(m));
+  } else if (owl_message_is_type_jabber(m)) {
+    to = g_strdup_printf("jabber:%s", owl_message_get_recipient(m));
+    g_strdelimit(to, "/", '_');
+  } else if (owl_message_is_type_aim(m)) {
+    char *temp2;
+    temp = owl_aim_normalize_screenname(owl_message_get_recipient(m));
+    temp2 = g_utf8_strdown(temp,-1);
+    to = g_strdup_printf("aim:%s", temp2);
+    g_free(temp2);
+    g_free(temp);
+  } else {
+    to = g_strdup("loopback");
+  }
+  filename = g_build_filename(logpath, to, NULL);
+  owl_log_append(m, filename);
+  g_free(to);
+  g_free(filename);
+  filename = g_build_filename(logpath, "all", NULL);
+  owl_log_append(m, filename);
+  g_free(logpath);
+  g_free(filename);
+}
+  owl_log_entry *log_msg = owl_log_new_entry(buffer, filename);
+  owl_select_post_task(owl_log_eventually_write_entry, log_msg,
+                       owl_log_entry_delete, log_context);
+}
 void owl_log_outgoing_zephyr_error(const owl_zwrite *zw, const char *text)
+{
+  char *filename, *logpath;
+  char *tobuff, *recip;
+  owl_message *m;
+  GString *msgbuf;
+  /* create a present message so we can pass it to
+   * owl_log_shouldlog_message(void)
+   */
+  m = g_slice_new(owl_message);
+  owl_message *m = g_slice_new(owl_message);
   /* recip_index = 0 because there can only be one recipient anyway */
   owl_message_create_from_zwrite(m, zw, text, 0);
+  if (!owl_log_shouldlog_message(m)) {
+    owl_message_delete(m);
+    return;
+  }
+  g_free(owl_perlconfig_call_with_message("BarnOwl::Logging::log_outgoing_error", m));
   owl_message_delete(m);
-  /* chop off a local realm */
-  recip = owl_zwrite_get_recip_n_with_realm(zw, 0);
-  tobuff = short_zuser(recip);
-  g_free(recip);
-  /* expand ~ in path names */
-  logpath = owl_util_makepath(owl_global_get_logpath(&g));
-  filename = g_build_filename(logpath, tobuff, NULL);
-  msgbuf = g_string_new("");
-  g_string_printf(msgbuf, "ERROR (owl): %s\n%s\n", tobuff, text);
-  if (text[strlen(text)-1] != '\n') {
-    g_string_append_printf(msgbuf, "\n");
+  }
-  owl_log_enqueue_message(msgbuf->str, filename);
-  g_string_free(msgbuf, TRUE);
-  filename = g_build_filename(logpath, "all", NULL);
-  g_free(logpath);
-  msgbuf = g_string_new("");
-  g_string_printf(msgbuf, "ERROR (owl): %s\n%s\n", tobuff, text);
-  if (text[strlen(text)-1] != '\n') {
-    g_string_append_printf(msgbuf, "\n");
+  }
-  owl_log_enqueue_message(msgbuf->str, filename);
-  g_string_free(msgbuf, TRUE);
-  g_free(tobuff);
+}
-void owl_log_incoming(const owl_message *m)
+{
-  char *filename, *allfilename, *logpath;
-  const char *from=NULL;
-  char *frombuff=NULL;
-  int len, ch, i, personal;
-  /* figure out if it's a "personal" message or not */
-  if (owl_message_is_type_zephyr(m)) {
-    if (owl_message_is_personal(m)) {
-      personal = 1;
-    } else {
-      personal = 0;
+    }
-  } else if (owl_message_is_type_jabber(m)) {
-    /* This needs to be fixed to handle groupchat */
-    const char* msgtype = owl_message_get_attribute_value(m,"jtype");
-    if (msgtype && !strcmp(msgtype,"groupchat")) {
-      personal = 0;
-    } else {
-      personal = 1;
+    }
-  } else {
-    if (owl_message_is_private(m) || owl_message_is_loginout(m)) {
-      personal = 1;
-    } else {
-      personal = 0;
+    }
+  }
-  if (owl_message_is_type_zephyr(m)) {
-    if (personal) {
-      from=frombuff=short_zuser(owl_message_get_sender(m));
-    } else {
-      from=frombuff=g_strdup(owl_message_get_class(m));
+    }
-  } else if (owl_message_is_type_aim(m)) {
-    /* we do not yet handle chat rooms */
-    char *normalto, *temp;
-    temp = owl_aim_normalize_screenname(owl_message_get_sender(m));
-    normalto = g_utf8_strdown(temp, -1);
-    from=frombuff=g_strdup_printf("aim:%s", normalto);
-    g_free(normalto);
-    g_free(temp);
-  } else if (owl_message_is_type_loopback(m)) {
-    from=frombuff=g_strdup("loopback");
-  } else if (owl_message_is_type_jabber(m)) {
-    if (personal) {
-      from=frombuff=g_strdup_printf("jabber:%s",
-                                    owl_message_get_sender(m));
-    } else {
-      from=frombuff=g_strdup_printf("jabber:%s",
-                                    owl_message_get_recipient(m));
+    }
-  } else {
-    from=frombuff=g_strdup("unknown");
+  }
-  /* check for malicious sender formats */
-  len=strlen(frombuff);
-  if (len<1 || len>35) from="weird";
-  if (strchr(frombuff, '/')) from="weird";
-  ch=frombuff[0];
-  if (!g_ascii_isalnum(ch)) from="weird";
-  for (i=0; i<len; i++) {
-    if (frombuff[i]<'!' || frombuff[i]>='~') from="weird";
+  }
-  if (!strcmp(frombuff, ".") || !strcasecmp(frombuff, "..")) from="weird";
-  if (!personal) {
-    if (strcmp(from, "weird")) {
-      char* temp = g_utf8_strdown(frombuff, -1);
-      if (temp) {
-        g_free(frombuff);
-        from = frombuff = temp;
+      }
+    }
+  }
-  /* create the filename (expanding ~ in path names) */
-  if (personal) {
-    logpath = owl_util_makepath(owl_global_get_logpath(&g));
-    filename = g_build_filename(logpath, from, NULL);
-    allfilename = g_build_filename(logpath, "all", NULL);
-    owl_log_append(m, allfilename);
-    g_free(allfilename);
-  } else {
-    logpath = owl_util_makepath(owl_global_get_classlogpath(&g));
-    filename = g_build_filename(logpath, from, NULL);
+  }
-  owl_log_append(m, filename);
-  g_free(filename);
-  if (personal && owl_message_is_type_zephyr(m)) {
-    /* We want to log to all of the CC'd people who were not us, or
-     * the sender, as well.
-     */
-    char *temp;
-    GList *cc;
-    cc = owl_message_get_cc_without_recipient(m);
-    while (cc != NULL) {
-      temp = short_zuser(cc->data);
-      if (strcasecmp(temp, frombuff) != 0) {
-        filename = g_build_filename(logpath, temp, NULL);
-        owl_log_append(m, filename);
-        g_free(filename);
+      }
-      g_free(temp);
-      g_free(cc->data);
-      cc = g_list_delete_link(cc, cc);
+    }
+  }
-  g_free(frombuff);
-  g_free(logpath);
+}
 static gpointer owl_log_thread_func(gpointer data)
+{
+  log_context = g_main_context_new();
   log_loop = g_main_loop_new(log_context, FALSE);
   g_main_loop_run(log_loop);
 …
+}
 void owl_log_init(void)
+void owl_log_init(void)
+{
   log_context = g_main_context_new();
 …
+  }
 #endif
+  deferred_entry_queue = g_queue_new();
+}
 static void owl_log_quit_func(gpointer data)
+{
+  /* flush the deferred logs queue, trying to write the
+   * entries to the disk one last time.  Drop any failed
+   * entries, and be quiet about it. */
+  owl_log_options opts;
+  opts.drop_failed_logs = true;
+  opts.display_initial_log_count = false;
+  owl_log_write_deferred_entries(&opts);
+#if GLIB_CHECK_VERSION(2, 32, 0)
+  g_queue_free_full(deferred_entry_queue, owl_log_entry_delete);
+#else
+  g_queue_foreach(deferred_entry_queue, owl_log_entry_delete_gfunc, NULL);
+  g_queue_free(deferred_entry_queue);
+#endif
   g_main_loop_quit(log_loop);
+}

message.c

-                      r7dcef03
+                      r4fd3c04
 void owl_message_init(owl_message *m)
+{
+  /* ctime_r requires a 26-byte buffer */
+  char timestr[26];
   m->id=owl_global_get_nextmsgid(&g);
   owl_message_set_direction_none(m);
 …
   /* save the time */
   m->time = time(NULL);
   m->timestr = g_strdup(ctime(&m->time));
   m->timestr[strlen(m->timestr)-1] = '\0';
+  ctime_r(&m->time, timestr);
+  m->timestr = g_strndup(timestr, strlen(timestr) - 1);
   m->fmtext = NULL;
 …
 CALLER_OWN char *owl_message_format_time(const owl_message *m)
+{
+  return owl_util_format_time(localtime(&m->time));
+  struct tm tm;
+  return owl_util_format_time(localtime_r(&m->time, &tm));
+}
 …
+{
   owl_message_set_attribute(m, "type", "zephyr");
+}
-void owl_message_set_type_aim(owl_message *m)
+{
-  owl_message_set_attribute(m, "type", "AIM");
+}
 …
+{
   return owl_message_is_type(m, "zephyr");
+}
-int owl_message_is_type_aim(const owl_message *m)
+{
-  return owl_message_is_type(m, "aim");
+}
-/* XXX TODO: deprecate this */
-int owl_message_is_type_jabber(const owl_message *m)
+{
-  return owl_message_is_type(m, "jabber");
+}
 …
 CALLER_OWN GList *owl_message_get_cc_without_recipient(const owl_message *m)
+{
   char *cc, *shortuser, *recip;
+  char *cc, *shortuser, *recip, *saveptr;
   const char *user;
   GList *out = NULL;
 …
   recip = short_zuser(owl_message_get_recipient(m));
   user = strtok(cc, " ");
+  user = strtok_r(cc, " ", &saveptr);
   while (user != NULL) {
     shortuser = short_zuser(user);
 …
+    }
     g_free(shortuser);
     user = strtok(NULL, " ");
+    user = strtok_r(NULL, " ", &saveptr);
+  }
 …
-/* if loginout == -1 it's a logout message
- *                 0 it's not a login/logout message
- *                 1 it's a login message
- */
-void owl_message_create_aim(owl_message *m, const char *sender, const char *recipient, const char *text, int direction, int loginout)
+{
-  owl_message_init(m);
-  owl_message_set_body(m, text);
-  owl_message_set_sender(m, sender);
-  owl_message_set_recipient(m, recipient);
-  owl_message_set_type_aim(m);
-  if (direction==OWL_MESSAGE_DIRECTION_IN) {
-    owl_message_set_direction_in(m);
-  } else if (direction==OWL_MESSAGE_DIRECTION_OUT) {
-    owl_message_set_direction_out(m);
+  }
-  /* for now all messages that aren't loginout are private */
-  if (!loginout) {
-    owl_message_set_isprivate(m);
+  }
-  if (loginout==-1) {
-    owl_message_set_islogout(m);
-  } else if (loginout==1) {
-    owl_message_set_islogin(m);
+  }
+}
 void owl_message_create_admin(owl_message *m, const char *header, const char *text)
+{
 …
   struct hostent *hent;
 #endif /* ZNOTICE_SOCKADDR */
+  char *tmp, *tmp2;
+  /* ctime_r requires a 26-byte buffer */
+  char timestr[26], *tmp, *tmp2;
   int len;
 …
   if (m->timestr) g_free(m->timestr);
   m->time = n->z_time.tv_sec;
   m->timestr = g_strdup(ctime(&m->time));
   m->timestr[strlen(m->timestr)-1] = '\0';
+  ctime_r(&m->time, timestr);
+  m->timestr = g_strndup(timestr, strlen(timestr) - 1);
   /* set other info */

owl.c

-                      r441fd42
+                      r4fd3c04
       if (owl_message_is_type_zephyr(m)) {
         owl_zephyr_zaway(m);
-      } else if (owl_message_is_type_aim(m)) {
-        if (owl_message_is_private(m)) {
-          owl_function_send_aimawymsg(owl_message_get_sender(m), owl_global_get_zaway_msg(&g));
+        }
+      }
+    }
 …
   /* let perl know about it */
   owl_perlconfig_newmsg(m, NULL);
-  /* log the message if we need to */
-  owl_log_message(m);
   /* redraw the sepbar; TODO: don't violate layering */
   owl_global_sepbar_dirty(&g);
 …
   owl_global_set_startupargs(&g, argc_copy, argv_copy);
   g_strfreev(argv_copy);
-  owl_global_set_haveaim(&g);
   owl_register_signal_handlers();
 …
                   owl_global_get_filter(&g, "all"),
                   owl_global_get_style_by_name(&g, "default"));
-  /* AIM init */
-  owl_function_debugmsg("startup: doing AIM initialization");
-  owl_aim_init();
   /* execute the startup function in the configfile */

owl.h

-                      rca1fb26a
+                      r4fd3c04
 #include <termios.h>
 #include <unistd.h>
-#include "libfaim/aim.h"
 #include <wchar.h>
 #include <glib.h>
 …
 #define OWL_EDITWIN_STYLE_MULTILINE 0
 #define OWL_EDITWIN_STYLE_ONELINE   1
-#define OWL_PROTOCOL_ZEPHYR         0
-#define OWL_PROTOCOL_AIM            1
-#define OWL_PROTOCOL_JABBER         2
-#define OWL_PROTOCOL_ICQ            3
-#define OWL_PROTOCOL_YAHOO          4
-#define OWL_PROTOCOL_MSN            5
 #define OWL_MESSAGE_DIRECTION_NONE  0
 …
 #define OWL_DEFAULT_ZAWAYMSG    "I'm sorry, but I am currently away from the terminal and am\nnot able to receive your message.\n"
-#define OWL_DEFAULT_AAWAYMSG    "I'm sorry, but I am currently away from the terminal and am\nnot able to receive your message.\n"
 #define OWL_CMD_ALIAS_SUMMARY_PREFIX "command alias to: "
 …
   int       kpstackpos;         /* location in stack (-1 = none) */
 } owl_keyhandler;
-typedef struct _owl_buddy {
-  int proto;
-  char *name;
-  int isidle;
-  int idlesince;
-} owl_buddy;
-typedef struct _owl_buddylist {
-  GPtrArray *buddies;
-} owl_buddylist;
 typedef struct _owl_zbuddylist {
 …
   pid_t newmsgproc_pid;
   owl_regex search_re;
+  aim_session_t aimsess;
+  aim_conn_t bosconn;
+  int aim_loggedin;         /* true if currently logged into AIM */
+  GSource *aim_event_source; /* where we get our AIM events from */
+  char *aim_screenname;     /* currently logged in AIM screen name */
+  char *aim_screenname_for_filters;     /* currently logged in AIM screen name */
+  owl_buddylist buddylist;  /* list of logged in AIM buddies */
+  GQueue *messagequeue;     /* for queueing up aim and other messages */
+  GQueue *messagequeue;     /* for queueing up messages */
   owl_dict styledict;       /* global dictionary of available styles */
   char *response;           /* response to the last question asked */
   int havezephyr;
-  int haveaim;
-  int ignoreaimlogin;
   owl_zbuddylist zbuddies;
   GList *zaldlist;
   int pseudologin_notify;
   struct termios startup_tio;
-  guint aim_nop_timer;
   int load_initial_subs;
   FILE *debug_file;

perl/Makefile.am

-                      ra870319
+                      r4fd3c04
 nobase_dist_pkgdata_DATA = \
         lib/BarnOwl.pm \
-        lib/BarnOwl/Complete/AIM.pm \
         lib/BarnOwl/Complete/Client.pm \
         lib/BarnOwl/Complete/Filter.pm \
 …
         lib/BarnOwl/Completion/Context.pm \
         lib/BarnOwl/Completion/Util.pm \
+        lib/BarnOwl/DeferredLogging.pm \
         lib/BarnOwl/Editwin.pm \
         lib/BarnOwl/Help.pm \
         lib/BarnOwl/Hook.pm \
         lib/BarnOwl/Hooks.pm \
+        lib/BarnOwl/Logging.pm \
         lib/BarnOwl/MainLoopCompatHook.pm \
         lib/BarnOwl/Message.pm \
-        lib/BarnOwl/Message/AIM.pm \
         lib/BarnOwl/Message/Admin.pm \
         lib/BarnOwl/Message/Generic.pm \

perl/lib/BarnOwl.pm

-                      recd4edf
+                      reea7bed4
                     create_style getnumcolors wordwrap
                     message_matches_filter
+                    get_variable_info
                     add_dispatch remove_dispatch
                     add_io_dispatch remove_io_dispatch
 …
 use BarnOwl::Hook;
 use BarnOwl::Hooks;
+use BarnOwl::Logging;
 use BarnOwl::Message;
 use BarnOwl::Style;
 …
 use BarnOwl::Completion;
 use BarnOwl::Help;
+use BarnOwl::DeferredLogging;
 use List::Util qw(max);
 …
 C<QUIET> is false, this method displays an error message if
 if C<FILTER_NAME> does not name a valid filter.
+=head2 get_variable_info VARIABLE_NAME
+Returns a hash with the following keys, describing the variable named:
+=over
+=item name
+=item description
+=item summary
+=item validsettings
+=item takes_on_off
+=back
+Fails if C<VARIABLE_NAME> does not name a valid variable.
 =head2 add_dispatch FD CALLBACK

perl/lib/BarnOwl/Complete/Client.pm

-                      r4626016
+                      r1f92f39
 sub complete_set {
     my $ctx = shift;
+    return complete_flags($ctx,
+        [qw(-q)],
+        {
+        },
+         \&complete_set_args
+        );
+}
+sub complete_set_args {
+    my $ctx = shift;
+    my $arg = shift;
+    return if $arg;
+    return complete_variable();
+    my $is_unset = ($ctx->words->[0] eq "unset");
+    # Shift away the -q if seen.
+    my $seen_q = 0;
+    if ($ctx->word > 1 && $ctx->words->[1] eq "-q") {
+        $seen_q = 1;
+        $ctx = $ctx->shift_words(1);
+    }
+    # First argument is the variable.
+    if ($ctx->word == 1) {
+        my @vars = complete_variable();
+        if ($is_unset) {
+            # Only complete the variables which are unsettable.
+            @vars = grep { BarnOwl::get_variable_info($_)->{takes_on_off} } @vars;
+        }
+        unshift(@vars, "-q") unless $seen_q;
+        return @vars;
+    }
+    # For set, second argument is the value.
+    if (!$is_unset && $ctx->word == 2) {
+        # Parse what we can out of validsettings.
+        my $info;
+        eval { $info = BarnOwl::get_variable_info($ctx->words->[1]) };
+        return if $@;
+        if ($info->{validsettings} eq "<path>") {
+            return complete_file($ctx->words->[2]);
+        } elsif ($info->{validsettings} !~ /^<.*>$/) {
+            # Assume it's a comma-separated list of values;
+            return split(",", $info->{validsettings});
+        }
+    }
+    return;
+}

perl/lib/BarnOwl/Complete/Filter.pm

r6dba228	r4fd3c04
36	36	body => undef,
37	37	hostname => undef,
38		type => sub { qw(zephyr a~~im a~~dmin); },
	38	type => sub { qw(zephyr admin); },
39	39	direction => sub { qw(in out none); },
40	40	login => sub { qw(login logout none); },

perl/lib/BarnOwl/Message.pm

-                      r0adbce1
+                      r4fd3c04
 package BarnOwl::Message;
+use File::Spec;
 use BarnOwl::Message::Admin;
-use BarnOwl::Message::AIM;
 use BarnOwl::Message::Generic;
 use BarnOwl::Message::Loopback;
 …
 sub is_generic  { return (shift->{"type"} eq "generic"); }
 sub is_zephyr   { return (shift->{"type"} eq "zephyr"); }
 sub is_aim      { return (shift->{"type"} eq "AIM"); }
+sub is_aim      { return ''; }
 sub is_jabber   { return (shift->{"type"} eq "jabber"); }
 sub is_icq      { return (shift->{"type"} eq "icq"); }
 …
+    }
     return $s;
+}
+=head2 log MESSAGE
+Returns the text that should be written to a file to log C<MESSAGE>.
+=cut
+sub log {
+    my ($m) = @_;
+    return $m->log_header . "\n\n" . $m->log_body . "\n\n";
+}
+=head2 log_header MESSAGE
+Returns the header of the message, for logging purposes.
+If you override L<BarnOwl::Message::log>, this method is not called.
+=cut
+sub log_header {
+    my ($m) = @_;
+    my $sender = $m->sender;
+    my $recipient = $m->recipient;
+    my $timestr = $m->time;
+    return "From: <$sender> To: <$recipient>\n"
+         . "Time: $timestr";
+}
+=head2 log_body MESSAGE
+Returns the body of the message, for logging purposes.
+If you override L<BarnOwl::Message::log>, this method is not called.
+=cut
+sub log_body {
+    my ($m) = @_;
+    if ($m->is_loginout) {
+        return uc($m->login)
+            . $m->login_type
+            . ($m->login_extra ? ' at ' . $m->login_extra : '');
+    } else {
+        return $m->body;
+    }
+}
+=head2 log_filenames MESSAGE
+Returns a list of filenames to which this message should be logged.
+The filenames should be relative to the path returned by C<log_path>.
+See L<BarnOwl::Logging::get_filenames> for the specification of valid
+filenames, and for what happens if this method returns an invalid
+filename.
+=cut
+sub log_filenames {
+    my ($m) = @_;
+    my $filename;
+    if ($m->is_incoming) {
+        $filename = $m->pretty_sender;
+    } elsif ($m->is_outgoing) {
+        $filename = $m->pretty_recipient;
+    }
+    $filename = "unknown" if !defined($filename) || $filename eq '';
+    if (BarnOwl::getvar('log-to-subdirectories') eq 'on') {
+        return ($filename);
+    } else {
+        return ($m->log_subfolder . ':' . $filename);
+    }
+}
+=head2 log_to_all_file MESSAGE
+There is an C<all> file.  This method determines if C<MESSAGE>
+should get logged to it, in addition to any files returned by
+C<log_filenames>.
+It defaults to returning true if and only if C<MESSAGE> is outgoing.
+=cut
+sub log_to_all_file {
+    my ($m) = @_;
+    return $m->is_outgoing;
+}
+=head2 log_path MESSAGE
+Returns the folder in which all messages of this class get logged.
+Defaults to C<log_base_path/log_subfolder> if C<log-to-subdirectories>
+is enabled, or to the C<logpath> BarnOwl variable if it is not.
+Most protocols should override C<log_subfolder> rather than
+C<log_path>, in order to properly take into account the value of
+C<log-to-subdirectories>.
+=cut
+sub log_path {
+    my ($m) = @_;
+    if (BarnOwl::getvar('log-to-subdirectories') eq 'on') {
+        return File::Spec->catfile($m->log_base_path, $m->log_subfolder);
+    } else {
+        return BarnOwl::getvar('logpath');
+    }
+}
+=head2 log_base_path MESSAGE
+Returns the base path for logging.  See C<log_path> for more information.
+Defaults to the BarnOwl variable C<logbasepath>.
+=cut
+sub log_base_path {
+    return BarnOwl::getvar('logbasepath');
+}
+=head2 log_subfolder MESSAGE
+Returns the subfolder of C<log_base_path> to log messages in.
+Defaults to C<lc($m->type)>.
+=cut
+sub log_subfolder {
+    return lc(shift->type);
+}
+=head2 log_outgoing_error MESSAGE
+Returns the string that should be logged if there is an error sending
+an outgoing message.
+=cut
+sub log_outgoing_error {
+    my ($m) = @_;
+    my $recipient = $m->pretty_recipient;
+    my $body = $m->body;
+    chomp $body;
+    return "ERROR (BarnOwl): $recipient\n$body\n\n";
+}
+=head2 should_log MESSAGE
+Returns true if we should log C<MESSAGE>.  This does not override
+user settings; if the BarnOwl variable C<loggingdirection> is in,
+and C<MESSAGE> is outgoing and does not match the C<logfilter>, it
+will not get logged regardless of what this method returns.
+Note that this method I<does> override the BarnOwl C<logging>
+variable; if a derived class overrides this method and does not
+provide an alternative BarnOwl variable (such as C<classlogging>),
+the overriding method should check the BarnOwl C<logging> variable.
+Defaults to returning the value of the BarnOwl variable C<logging>.
+=cut
+sub should_log {
+    return BarnOwl::getvar('logging') eq 'on';
+}

perl/lib/BarnOwl/Message/Loopback.pm

ree183be	r8cec8f7
14	14	sub replysendercmd {return 'loopwrite';}
15	15
	16	sub log_subfolder { return ''; }
	17	sub log_filenames { return ('loopback'); }
16	18
17	19	1;

perl/lib/BarnOwl/Message/Zephyr.pm

-                      r0adbce1
+                      r8f91a70
     my ($user, $realm) = split(/@/,$principal);
     return $realm;
+}
+sub casefold_principal {
+    my $principal = shift;
+    # split the principal right after the final @, without eating any
+    # characters; this way, we always get at least '@' in $user
+    my ($user, $realm) = split(/(?<=@)(?=[^@]+$)/, $principal);
+    $user = '' if !defined $user;
+    $user = lc($user);
+    $user = $user . uc($realm) if defined $realm;
+    return $user;
+}
 …
     return $1 if $self->body =~ /^\s*cc:\s+([^\n]+)/i;
     return undef;
+}
+# Note: This is the cc-line without the recipient; it does not include
+# the sender.
+sub zephyr_cc_without_recipient {
+    my $self = shift;
+    my $recipient = lc(strip_realm($self->recipient));
+    my $cc = $self->zephyr_cc;
+    return grep { lc(strip_realm($_)) ne $recipient } split(/\s+/, $cc) if defined $cc;
+    return ();
+}
 …
+}
+# Logging
+sub log_header {
+    my ($m) = @_;
+    my $class = $m->class;
+    my $instance = $m->instance;
+    my $opcode = $m->opcode;
+    my $timestr = $m->time;
+    my $host = $m->host;
+    my $sender = $m->pretty_sender;
+    my $zsig = $m->zsig;
+    my $rtn = "Class: $class Instance: $instance";
+    $rtn .= " Opcode: $opcode" unless !defined $opcode || $opcode eq '';
+    $rtn .= "\nTime: $timestr Host: $host"
+          . "\nFrom: $zsig <$sender>";
+    return $rtn;
+}
+sub log_filenames {
+    my ($m) = @_;
+    my @filenames = ();
+    if ($m->is_personal) {
+        # If this has CC's, add all but the "recipient" which we'll add below
+        @filenames = $m->zephyr_cc_without_recipient;
+    }
+    if ($m->is_incoming) {
+        if ($m->is_personal) {
+            push @filenames, $m->sender;
+        } else {
+            my $realm = '';
+            $realm .= '@' . $m->realm if $m->realm ne BarnOwl::zephyr_getrealm();
+            return (BarnOwl::compat_casefold($m->class) . uc($realm));
+        }
+    } else {
+        push @filenames, $m->recipient;
+    }
+    return map { casefold_principal(BarnOwl::zephyr_smartstrip_user(strip_realm($_))) } @filenames;
+}
+sub log_to_class_file {
+    my ($m) = @_;
+    return !$m->is_personal;
+}
+sub log_path {
+    my ($m) = @_;
+    if ($m->log_to_class_file) {
+        return BarnOwl::getvar('classlogpath');
+    } else {
+        return BarnOwl::getvar('logpath');
+    }
+}
+sub should_log {
+    my ($m) = @_;
+    if ($m->log_to_class_file) {
+        return BarnOwl::getvar('classlogging') eq 'on';
+    } else {
+        return BarnOwl::getvar('logging') eq 'on';
+    }
+}
 ;

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

-                      r60b49a7
+                      r3f0c209
+}
+# logging
+sub log_filenames {
+    my ($m) = @_;
+    die "IRC should not be handling non-IRC messages" if lc($m->type) ne "irc";
+    BarnOwl::error("IRC message without a network") if !defined($m->network) || $m->network eq '';
+    my $filename = lc($m->network);
+    # Note: Channel names generally start with '#', which
+    # disambiguates channels from individuals; for example, personals
+    # will look like, e.g., "~/zlog/irc/freenode:john-doe", whereas
+    # channels will look like, e.g., "~/zlog/irc/freenode:#barnowl"
+    if ($m->is_personal) {
+        if ($m->is_incoming) {
+            $filename .= ":" . $m->sender;
+        } elsif ($m->is_outgoing) {
+            $filename .= ":" . $m->recipient;
+        }
+    } else {
+        $filename .= ":" . $m->channel;
+    }
+    return ($filename);
+}
+sub log {
+    my ($m) = @_;
+    my $sender = $m->sender;
+    my $timestr = $m->time;
+    my $body = $m->body;
+    if ($m->is_loginout) {
+        return BarnOwl::Message::log($m);
+    } else {
+        return "[$timestr] <$sender> $body\n";
+    }
+}
 ;

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

-                      r926c721
+                      rd4f33f1
                                "[" . $conn->alias . "] Reconnect cancelled");
         $conn->cancel_reconnect;
+        delete $ircnets{$conn->alias};
+    } elsif (exists $ircnets{$conn->alias}) { # inconsistent state; no socket, but not yet deleted
+        BarnOwl::admin_message('IRC',
+                               "[" . $conn->alias . "] Attempt to disconnect from a socketless connection; deleting it");
         delete $ircnets{$conn->alias};
+    }

perl/modules/IRC/lib/BarnOwl/Module/IRC/Connection.pm

-                      rbe43554
+                      r4379288
+}
+sub rejoin_channels {
+    my $self = shift;
+    my @channels = @_;
+    # As reported in https://barnowl.mit.edu/ticket/274, if we reconnect to
+    # too many at once, the server rejects us.  Empirically, this is about
+    # 20-26, so we set the cap at 15, then delay further joins for 5 seconds.
+    my $MAX_RECONNECT_CHANNELS = 15;
+    my $DELAY = 5;
+    foreach my $c (@channels[ 0 .. $MAX_RECONNECT_CHANNELS ]) {
+        $self->conn->send_msg(join => $c);
+    }
+    if ($MAX_RECONNECT_CHANNELS < $#channels) {
+        my $remaining = $#channels - $MAX_RECONNECT_CHANNELS;
+        my $cur_alias = $self->alias;
+        BarnOwl::admin_message('IRC', "[$cur_alias] Delaying $remaining autorejoins for $DELAY seconds");
+        # if we don't assign the timer to anything, then it gets garbage
+        # collected, and never runs
+        $self->{autoconnect_channels_delay_timer} = BarnOwl::Timer->new({
+            name  => "IRC rejoin overflow timer ($remaining remaining)",
+            after => $DELAY,
+            cb    => sub {
+                rejoin_channels($self, @channels[ $MAX_RECONNECT_CHANNELS .. $#channels ]);
+            }
+        });
+    }
+}
 sub connected {
     my $self = shift;
 …
     $self->cancel_reconnect;
     if ($self->autoconnect_channels) {
+        for my $c (@{$self->autoconnect_channels}) {
+            $self->conn->send_msg(join => $c);
+        }
+        rejoin_channels($self, @{$self->autoconnect_channels});
+    }
     $self->conn->enable_ping(60, sub {

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

-                      ra27acf7
+                      rd2ba33c
+}
+sub log_filenames {
+    return map { BarnOwl::compat_casefold($_) } BarnOwl::Message::log_filenames(@_);
+}
 =head1 SEE ALSO

perl/modules/Makefile.am

re4b8f93	r268c7e8
1		MODULES = Jabber IRC WordWrap Twitter Facebook
	1	MODULES = Jabber IRC WordWrap Twitter Facebook Kerberos
2	2
3	3	EXTRA_DIST = $(MODULES:=/Makefile.PL) $(MODULES:=/lib)

perlconfig.c

r7dcef03	r09530e6
211	211	g_free(m->timestr);
212	212	m->timestr = g_strdup(val);
	213	// FIXME: Daylight saving time will be guessed wrongly one hour per year!
	214	tm.tm_isdst = -1;
213	215	strptime(val, "%a %b %d %T %Y", &tm);
214	216	m->time = mktime(&tm);

perlglue.xs

-                      r7dcef03
+                      rd2ba33c
                 RETVAL
+SV *
+get_variable_info(name)
+        const char *name;
+        PREINIT:
+                owl_variable *var;
+                HV *h;
+        CODE:
+                var = owl_variable_get_var(owl_global_get_vardict(&g), name);
+                if (var == NULL) {
+                        croak("No such variable");
+                }
+                h = newHV();
+                (void)hv_store(h, "name", strlen("name"),
+                               owl_new_sv(owl_variable_get_name(var)), 0);
+                (void)hv_store(h, "description", strlen("description"),
+                               owl_new_sv(owl_variable_get_description(var)),
+);
+                (void)hv_store(h, "summary", strlen("summary"),
+                               owl_new_sv(owl_variable_get_summary(var)), 0);
+                (void)hv_store(h, "validsettings", strlen("validsettings"),
+                               owl_new_sv(owl_variable_get_validsettings(var)),
+);
+                (void)hv_store(h, "takes_on_off", strlen("takes_on_off"),
+                               newSViv(owl_variable_takes_on_off(var)), 0);
+                RETVAL = newRV_noinc((SV*)h);
+        OUTPUT:
+                RETVAL
+const utf8 *
+compat_casefold(in)
+        const char * in
+        PREINIT:
+                char *rv;
+        CODE:
+                rv = owl_util_compat_casefold(in);
+                RETVAL = rv;
+        OUTPUT:
+                RETVAL
+        CLEANUP:
+                g_free(rv);
 MODULE = BarnOwl                PACKAGE = BarnOwl::Zephyr
 …
         OUTPUT:
                 RETVAL
+const utf8 *
+makepath(in)
+        const char * in
+        PREINIT:
+                char *rv;
+        CODE:
+                rv = owl_util_makepath(in);
+                RETVAL = rv;
+        OUTPUT:
+                RETVAL
+        CLEANUP:
+                g_free(rv);
 void
 …
         OUTPUT:
                 RETVAL
+MODULE = BarnOwl                PACKAGE = BarnOwl::Logging
+void
+enqueue_text(log_text, filename)
+        const char * log_text
+        const char * filename
+        CODE:
+                owl_log_enqueue_message(log_text, filename);

scripts/do-release

-                      rb8a3e00
+                      rbc308eb
+#!/bin/sh -e
+#!/bin/bash
+set -eu
 die() {
 …
 fi
+[ -e Makefile.in ] || autoreconf -fvi
+[ -e config.status ] || ./configure
+make -j4 distcheck VERSION="$VERS"
+echo 'Checking distributed files against Git:'
+if comm -3 <(tar -tzf "$TAG.tar.gz" | grep -v '/$' | sed "s%^$TAG/%%" | sort) \
+    <(git ls-files | sort) | grep -vxf scripts/dist-ignore; then
+    echo
+    echo 'Error: Please fix Makefile.am and/or scripts/dist-ignore.'
+    exit 1
+fi
+echo 'ok'
+mv "$TAG.tar.gz" "$TGZ.tgz"
 if ! [ "$no_tag" ]; then
     if git cat-file -t "$TAG" > /dev/null 2>&1; then
 …
 fi
+exittrap() { :; }
+for sig in 1 2 13 15; do trap "exit $(($sig + 128))" $sig; done
+trap 'exittrap' EXIT
+TMPDIR=$(mktemp -d /tmp/barnowl.XXXXXX)
+exittrap() { rm -rf "$TMPDIR"; }
+git archive --format=tar --prefix="$TGZ/" "$TAG" | tar -x -C "$TMPDIR"
+CODIR=$(pwd)
+cd "$TMPDIR/$TGZ"
+[ "$git" ] && perl -i -pe 's{^(AC_INIT\(\[[^\]]+\],\s*)\[([^\]]+)\]}{${1}['$VERS']}' configure.ac
+autoreconf -fvi
+rm -r autom4te.cache/
+cd "$TMPDIR"
+tar czvf "$TGZ.tgz" "$TGZ"
+cd "$CODIR"
+mv "$TMPDIR/$TGZ.tgz" .
+rm -rf "$TMPDIR"
+exittrap() { :; }
+echo "Created release tarball for BarnOwl $VERS in $(pwd)"
+echo "Created release tarball for BarnOwl $VERS at $(pwd)/$TGZ.tgz"
 echo "Remember to bump OWL_VERSION_STRING for future development."

t/completion.t

-                      re59d775
+                      r4fd3c04
 use File::Basename;
+BEGIN {require (dirname($0) . "/mock.pl");};
+use File::Spec;
+BEGIN {require File::Spec->rel2abs("mock.pl", dirname($0));};
 use BarnOwl::Complete::Filter qw(complete_filter_expr);
 …
 test_complete('type ', '',
               [qw[admin aim zephyr]],
+              [qw[admin zephyr]],
               \&complete_filter_expr);

tester.c

-                      r21dc927
+                      ra882637
     sv_setpv(get_sv("main::test_prog", TRUE), argv[1]);
+    eval_pv("do $main::test_prog; die($@) if($@)", true);
+  }
+  status = 0;
+    eval_pv("use File::Spec; do File::Spec->rel2abs($main::test_prog); die($@) if($@)", true);
+  }
   FREETMPS;
 …
   FAIL_UNLESS("get string var", NULL != (var = owl_variable_get_var(&vd, "logpath")));
   FAIL_UNLESS("get string", 0 == strcmp("~/zlog/people", owl_variable_get_string(var)));
+  FAIL_UNLESS("get string var", NULL != (var = owl_variable_get_var(&vd, "personalbell")));
+  FAIL_UNLESS("get string", 0 == strcmp("off", owl_variable_get_string(var)));
   FAIL_UNLESS("set string 7", 0 == owl_variable_set_string(var, "whee"));
   FAIL_UNLESS("get string", !strcmp("whee", owl_variable_get_string(var)));

util.c

-                      rcba6b9c
+                      rd2ba33c
+}
+CALLER_OWN char *owl_util_compat_casefold(const char *str)
+{
+  /*
+   * Quoting Anders Kaseorg at https://github.com/barnowl/barnowl/pull/54#issuecomment-31452543:
+   *
+   * The Unicode specification calls this compatibility caseless matching, and
+   * the correct transformation actually has five calls:
+   * NFKC(toCasefold(NFKD(toCasefold(NFD(string))))) Zephyr’s current
+   * implementation incorrectly omits the innermost NFD, but that difference
+   * only matters for characters including U+0345 ◌ͅ COMBINING GREEK
+   * YPOGEGRAMMENI. I think we should just write the correct version and get
+   * Zephyr fixed.
+   *
+   * Neither of these operations should be called toNFKC_Casefold, because that
+   * has slightly different behavior regarding Default_Ignorable_Code_Point. I
+   * propose compat_casefold. And I guess if Jabber wants it too, we should
+   * move it to util.c.
+   */
+  char *tmp0 = g_utf8_normalize(str, -1, G_NORMALIZE_NFD);
+  char *tmp1 = g_utf8_casefold(tmp0, -1);
+  char *tmp2 = g_utf8_normalize(tmp1, -1, G_NORMALIZE_NFKD);
+  char *tmp3 = g_utf8_casefold(tmp2, -1);
+  char *out = g_utf8_normalize(tmp3, -1, G_NORMALIZE_NFKC);
+  g_free(tmp0);
+  g_free(tmp1);
+  g_free(tmp2);
+  g_free(tmp3);
+  return out;
+}
 /* This is based on _extract() and _isCJ() from perl's Text::WrapI18N */
 int owl_util_can_break_after(gunichar c)

variable.c

-                      r94b9ee0
+                      r4fd3c04
                "load logins from .anyone on startup", "" );
-  OWLVAR_BOOL( "logging" /* %OwlVarStub */, 0,
-               "turn personal logging on or off",
-               "If this is set to on, personal messages are\n"
-               "logged in the directory specified\n"
-               "by the 'logpath' variable.  The filename in that\n"
-               "directory is derived from the sender of the message.\n" );
-  OWLVAR_BOOL( "classlogging" /* %OwlVarStub */, 0,
-               "turn class logging on or off",
-               "If this is set to on, class messages are\n"
-               "logged in the directory specified\n"
-               "by the 'classlogpath' variable.\n"
-               "The filename in that directory is derived from\n"
-               "the name of the class to which the message was sent.\n" );
-  OWLVAR_ENUM( "loggingdirection" /* %OwlVarStub */, OWL_LOGGING_DIRECTION_BOTH,
-               "specifies which kind of messages should be logged",
-               "Can be one of 'both', 'in', or 'out'.  If 'in' is\n"
-               "selected, only incoming messages are logged, if 'out'\n"
-               "is selected only outgoing messages are logged.  If 'both'\n"
-               "is selected both incoming and outgoing messages are\n"
-               "logged.",
-               "both,in,out");
   OWLVAR_BOOL_FULL( "colorztext" /* %OwlVarStub */, 1,
                     "allow @color() in zephyrs to change color",
                     NULL, NULL, owl_variable_colorztext_set, NULL);
+                    "", NULL, owl_variable_colorztext_set, NULL);
   OWLVAR_BOOL( "fancylines" /* %OwlVarStub */, 1,
 …
                "Enable printing of login notifications",
                "When this is enabled, BarnOwl will print login and logout notifications\n"
+               "for AIM, zephyr, or other protocols.  If disabled BarnOwl will not print\n"
+               "login or logout notifications.\n");
+  OWLVAR_STRING( "logfilter" /* %OwlVarStub */, "",
+                 "name of a filter controlling which messages to log",
+                 "If non empty, any messages matching the given filter will be logged.\n"
+                 "This is a completely separate mechanism from the other logging\n"
+                 "variables like logging, classlogging, loglogins, loggingdirection,\n"
+                 "etc.  If you want this variable to control all logging, make sure\n"
+                 "all other logging variables are in their default state.\n");
+  OWLVAR_BOOL( "loglogins" /* %OwlVarStub */, 0,
+               "Enable logging of login notifications",
+               "When this is enabled, BarnOwl will log login and logout notifications\n"
+               "for AIM, zephyr, or other protocols.  If disabled BarnOwl will not print\n"
+               "for zephyr or other protocols.  If disabled BarnOwl will not print\n"
                "login or logout notifications.\n");
 …
                     "off,middle,on",
                     NULL, owl_variable_disable_ctrl_d_set, NULL);
-  OWLVAR_PATH( "logpath" /* %OwlVarStub */, "~/zlog/people",
-               "path for logging personal zephyrs",
-               "Specifies a directory which must exist.\n"
-               "Files will be created in the directory for each sender.\n");
-  OWLVAR_PATH( "classlogpath" /* %OwlVarStub:classlogpath */, "~/zlog/class",
-               "path for logging class zephyrs",
-               "Specifies a directory which must exist.\n"
-               "Files will be created in the directory for each class.\n");
   OWLVAR_PATH( "debug_file" /* %OwlVarStub */, OWL_DEBUG_FILE,
 …
                  "default zaway message", "" );
-  OWLVAR_BOOL_FULL( "aaway" /* %OwlVarStub */, 0,
-                    "Set AIM away status",
-                    "",
-                    NULL, owl_variable_aaway_set, NULL);
-  OWLVAR_STRING( "aaway_msg" /* %OwlVarStub */,
-                 OWL_DEFAULT_AAWAYMSG,
-                 "AIM away msg for responding when away", "" );
-  OWLVAR_STRING( "aaway_msg_default" /* %OwlVarStub */,
-                 OWL_DEFAULT_AAWAYMSG,
-                 "default AIM away message", "" );
   OWLVAR_STRING( "view_home" /* %OwlVarStub */, "all",
                  "home view to switch to after 'X' and 'V'",
 …
                  "Zephyr messages be no wider than 70 columns.\n");
-  OWLVAR_INT( "aim_ignorelogin_timer" /* %OwlVarStub */, 15,
-              "number of seconds after AIM login to ignore login messages",
-              "This specifies the number of seconds to wait after an\n"
-              "AIM login before allowing the receipt of AIM login notifications.\n"
-              "By default this is set to 15.  If you would like to view login\n"
-              "notifications of buddies as soon as you login, set it to 0 instead.");
   OWLVAR_INT_FULL( "typewinsize" /* %OwlVarStub:typwin_lines */,
                    OWL_TYPWIN_SIZE,
 …
+}
-/* When 'aaway' is changed, need to notify the AIM server */
-int owl_variable_aaway_set(owl_variable *v, bool newval)
+{
-  if (newval) {
-    owl_aim_set_awaymsg(owl_global_get_aaway_msg(&g));
-  } else {
-    owl_aim_set_awaymsg("");
+  }
-  return owl_variable_bool_set_default(v, newval);
+}
 int owl_variable_colorztext_set(owl_variable *v, bool newval)
+{
 …
+}
+bool owl_variable_takes_on_off(const owl_variable *v) {
+  return v->takes_on_off;
+}
 int owl_variable_get_type(const owl_variable *v)
+{

zcrypt.c

-                      rca1fb26a
+                      r9a0d25d
 #include <config.h>
-#ifdef HAVE_KERBEROS_IV
-#include <kerberosIV/des.h>
-#else
 #include <openssl/des.h>
-#endif
 #include "filterproc.h"
 …
 };
+static void owl_zcrypt_string_to_schedule(char *keystring, des_key_schedule *schedule) {
+#ifdef HAVE_KERBEROS_IV
+  des_cblock key;
+#else
+  des_cblock _key, *key = &_key;
+#endif
+  des_string_to_key(keystring, key);
+  des_key_sched(key, *schedule);
+static void owl_zcrypt_string_to_schedule(char *keystring, DES_key_schedule *schedule) {
+  DES_cblock key;
+  DES_string_to_key(keystring, &key);
+  DES_key_sched(&key, schedule);
+}
 …
 int do_encrypt_des(const char *keyfile, const char *in, int length, FILE *outfile)
+{
   des_key_schedule schedule;
+  DES_key_schedule schedule;
   unsigned char input[8], output[8];
   const char *inptr;
 …
     /* Encrypt and output the block */
     des_ecb_encrypt(&input, &output, schedule, TRUE);
+    DES_ecb_encrypt(&input, &output, &schedule, TRUE);
     block_to_ascii(output, outfile);
 …
   char *out;
   int err, status;
+  int tried_gpg1 = FALSE;
   const char *argv[] = {
     "gpg",
+    "gpg1",
     "--symmetric",
     "--no-options",
 …
     NULL
   };
+  err = call_filter(argv, in, &out, &status);
+  while ((err = call_filter(argv, in, &out, &status)) && !out && !tried_gpg1) {
+    tried_gpg1 = TRUE;
+    argv[0] = "gpg";
+  }
   if(err || status) {
     g_free(out);
 …
   char *in, *out;
   int length;
+  int tried_gpg1 = FALSE;
   const char *argv[] = {
     "gpg",
+    "gpg1",
     "--decrypt",
     "--no-options",
 …
   if(!in) return FALSE;
+  err = call_filter(argv, in, &out, &status);
+  while ((err = call_filter(argv, in, &out, &status)) && !out && !tried_gpg1) {
+    tried_gpg1 = TRUE;
+    argv[0] = "gpg";
+  }
   free(in);
   if(err || status) {
 …
 int do_decrypt_des(const char *keyfile) {
   des_key_schedule schedule;
+  DES_key_schedule schedule;
   unsigned char input[8], output[8];
   char tmp[9];
 …
     have a NULL-terminated string we can call printf/strlen on.
     We don't pass 'tmp' to des_ecb_encrypt directly, because it's
+    We don't pass 'tmp' to DES_ecb_encrypt directly, because it's
     prototyped as taking 'unsigned char[8]', and this avoids a stupid
     cast.
 …
   while (read_ascii_block(input))
+  {
     des_ecb_encrypt(&input, &output, schedule, FALSE);
+    DES_ecb_encrypt(&input, &output, &schedule, FALSE);
     memcpy(tmp, output, 8);
     printf("%s", tmp);

zephyr.c

-                      r18380fd
+                      ree6b30f
   FILE *file;
   int fopen_errno;
   char *tmp, *start;
+  char *tmp, *start, *saveptr;
   char *buffer = NULL;
   char *subsfile;
 …
     /* add it to the list of subs */
     if ((tmp = strtok(start, ",\n\r")) == NULL)
+    if ((tmp = strtok_r(start, ",\n\r", &saveptr)) == NULL)
       continue;
     subs[count].zsub_class = g_strdup(tmp);
     if ((tmp=strtok(NULL, ",\n\r")) == NULL)
+    if ((tmp = strtok_r(NULL, ",\n\r", &saveptr)) == NULL)
       continue;
     subs[count].zsub_classinst = g_strdup(tmp);
     if ((tmp = strtok(NULL, " \t\n\r")) == NULL)
+    if ((tmp = strtok_r(NULL, " \t\n\r", &saveptr)) == NULL)
       continue;
     subs[count].zsub_recipient = g_strdup(tmp);
 …
+{
   int n = strcspn(in, "./");
+  char *realm = strchrnul(in, '@');
+  const char *realm = strchr(in, '@');
+  if (realm == NULL)
+    realm = in + strlen(in);
   if (in + n >= realm ||

zwrite.c

-                      r7dcef03
+                      r1958790
   rv = owl_zwrite_create_from_line(&z, cmd);
   if (rv != 0) return rv;
+  if (!owl_zwrite_is_message_set(&z)) {
+    owl_zwrite_set_message(&z, msg);
+  }
+  owl_zwrite_populate_zsig(&z);
+  owl_zwrite_send_message(&z);
+  owl_function_zwrite(&z, msg);
   owl_zwrite_cleanup(&z);
   return(0);

Context Navigation

Legend:

Download in other formats: