Diff [416a7e53b80360ba0764edaa41a78445e5a9465c:7aa6811fe738e7a9a69be4363dd7af670acf491c] for / – BarnOwl

.gitignore

-                      r1c22155
+                      r7834bb5
+# Generated by autoreconf
+Makefile.in
+/aclocal.m4
+/autom4te.cache/
+/compile
+/config.h.in
+/config.h.in~
+/configure
+/depcomp
+/install-sh
+/missing
+/test-driver
+# Generated by configure
+Makefile
+.deps/
+/config.cache
+/config.h
+/config.log
+/config.status
+/stamp-h1
+# Generated by make
+*.o
 *.a
+*.o
+*.par
+.deps
+/BUILD_VERSION.mk
+/barnowl
 /bin/
+META.yml
+MYMETA.yml
+Makefile
+Makefile.in
+Makefile.old
+/gmarshal_funcs.c
+/gmarshal_funcs.h
+/owl_prototypes.h
+/owl_prototypes.h.new
+/perlglue.c
+/varstubs.c
+/version.c
+/version.c.new
+/zcrypt
+# Generated by make check
+/runtests.sh.log
+/runtests.sh.trs
+/test-suite.log
+/tester
+# Generated by make tags et al.
+ID
 TAGS
+aclocal.m4
+autom4te.cache
+barnowl
+blib
+config.cache
+config.h
+config.h.in
+config.h.in~
+config.log
+config.status
+configure
+core
+depcomp
+gmarshal_funcs.c
+gmarshal_funcs.h
+inc/
+install-sh
+jabber.log
+missing
+owl_prototypes.h
+owl_prototypes.h.new
+perlglue.c
+pm_to_blib
+runtests.sh.log
+runtests.sh.trs
+stamp-h1
+test-driver
+test-suite.log
+tester
+varstubs.c
+zcrypt
+tags
+/GPATH
+/GRTAGS
+/GSYMS
+/GTAGS
+/cscope.files
+/cscope.in.out
+/cscope.out
+/cscope.po.out

.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

-                      r1b17f50
+                      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
+ * Update and make configurable the Zephyr default format -adehnert@mit.edu
+ * Fix a crash when zcrypt fails -andersk@mit.edu
+ * Fix building with OpenSSL before 0.9.8 -andersk@mit.edu
+ * Make :loadsubs reload instanced personals too -davidben@mit.edu
+ * Make Perl zephyr_zwrite call die() when it fails -jgross@mit.edu
+ * Tell gpg calls from zcrypt to ignore ~/.gnupg -andersk@mit.edu
+ * Replace outgoing zephyr default format with a small URL -geofft@mit.edu
  * Add getnumlines() to perl interface -asedeno@mit.edu
  * Include names of invalid filters on filter errors -adehnert@mit.edu
 …
  * Support --program-{prefix,suffix,transform}. -nelhage
  * Send instanced pings and give useful error messages -adehnert
  * Add <message,*,%me%> to default Barnowl subs. -adehnert
+ * Add <message,*,%me%> to default BarnOwl subs. -adehnert
  * Maintain instance when using shift-R on personals -adehnert
  * Improve handling of outgoing instanced personals -adehnert

Makefile.am

-                      ra223b6b
+                      r4fd3c04
 ACLOCAL_AMFLAGS = -I m4
+GIT_DESCRIPTION := $(if $(wildcard .git),$(shell git describe --match='barnowl-*' HEAD 2>/dev/null))
+GIT_FLAGS := $(if $(GIT_DESCRIPTION),-DGIT_VERSION=$(GIT_DESCRIPTION:barnowl-%=%))
+GIT_DESCRIPTION := $(if $(wildcard $(srcdir)/.git),$(shell cd $(srcdir) && git describe --match='barnowl-*' HEAD 2>/dev/null))
+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
 …
 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)"' \
+           $(GIT_FLAGS)
+           -DBINDIR='"$(bindir)"'
 CODELIST_SRCS=message.c mainwin.c popwin.c zephyr.c messagelist.c \
 …
      regex.c history.c view.c dict.c variable.c filterelement.c pair.c \
      keypress.c keymap.c keybinding.c cmd.c context.c \
      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
 …
 BASE_SRCS = $(CODELIST_SRCS) $(NORMAL_SRCS)
 GEN_C = varstubs.c perlglue.c gmarshal_funcs.c
+GEN_C = varstubs.c perlglue.c gmarshal_funcs.c version.c version.c.new
 GEN_H = owl_prototypes.h owl_prototypes.h.new gmarshal_funcs.h
 BUILT_SOURCES = $(GEN_C) $(GEN_H)
+BUILT_SOURCES = $(GEN_H)
 # Only copy file into place if file.new is different
 %: %.new
+owl_prototypes.h version.c: %: %.new
         @diff -U0 $@ $< || { \
          test -f $@ && echo '$@ changed!'; \
 …
         $(AM_V_GEN)perl $< $(sort $(filter-out $<,$+)) > $@
+version.c.new: Makefile BUILD_VERSION.mk
+        $(AM_V_GEN)echo 'const char *version = "$(VERSION)";' > $@
 gmarshal_funcs.h: marshal_types
         glib-genmarshal --header $< > $@
 …
         $(COMPILE) -Wall -Wextra -pedantic -fsyntax-only $(CHK_SOURCES)
+CLEANFILES = $(BUILT_SOURCES) $(noinst_SCRIPTS) $(check_SCRIPTS)
+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

cmd.c

-                      rf271129
+                      r7dcef03
 void owl_cmddict_add_alias(owl_cmddict *cd, const char *alias_from, const char *alias_to) {
   owl_cmd *cmd;
   cmd = g_new(owl_cmd, 1);
+  cmd = g_slice_new(owl_cmd);
   owl_cmd_create_alias(cmd, alias_from, alias_to);
   owl_perlconfig_new_command(cmd->name);
 …
 int owl_cmddict_add_cmd(owl_cmddict *cd, const owl_cmd * cmd) {
   owl_cmd * newcmd = g_new(owl_cmd, 1);
+  owl_cmd * newcmd = g_slice_new(owl_cmd);
   if(owl_cmd_create_from_template(newcmd, cmd) < 0) {
     g_free(newcmd);
+    g_slice_free(owl_cmd, newcmd);
     return -1;
+  }
 …
+{
   owl_cmd_cleanup(cmd);
   g_free(cmd);
+  g_slice_free(owl_cmd, cmd);
+}

codelist.pl

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

commands.c

-                      ra38becd
+                      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);
+}
 …
 void owl_command_version(void)
+{
+  owl_function_makemsg("BarnOwl version %s", OWL_VERSION_STRING);
+}
+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);
+  owl_function_makemsg("BarnOwl version %s", version);
+}
 …
+  }
+  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

context.c

-                      rf271129
+                      r7dcef03
   if (!(mode & OWL_CTX_MODE_BITS))
     mode |= OWL_CTX_INTERACTIVE;
   c = g_new0(owl_context, 1);
+  c = g_slice_new0(owl_context);
   c->mode = mode;
   c->data = data;
 …
   if (ctx->delete_cb)
     ctx->delete_cb(ctx);
   g_free(ctx);
+  g_slice_free(owl_context, ctx);
+}

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

editwin.c

-                      r8258ea5
+                      r7dcef03
 static CALLER_OWN owl_editwin *owl_editwin_allocate(void)
+{
   owl_editwin *e = g_new0(owl_editwin, 1);
+  owl_editwin *e = g_slice_new0(owl_editwin);
   e->refcount = 1;
   return e;
 …
   oe_destroy_cbdata(e);
   g_free(e);
+  g_slice_free(owl_editwin, e);
+}
 …
 owl_editwin_excursion *owl_editwin_begin_excursion(owl_editwin *e)
+{
   owl_editwin_excursion *x = g_new(owl_editwin_excursion, 1);
+  owl_editwin_excursion *x = g_slice_new(owl_editwin_excursion);
   oe_save_excursion(e, x);
   return x;
 …
+{
   oe_restore_excursion(e, x);
   g_free(x);
+  g_slice_free(owl_editwin_excursion, x);
+}

filter.c

-                      rc068c03
+                      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 = g_new(owl_filter, 1);
+  f = g_slice_new(owl_filter);
   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))) {
 …
   if(!argc) return NULL;
   fe = g_new(owl_filterelement, 1);
+  fe = g_slice_new(owl_filterelement);
   owl_filterelement_create(fe);
 …
 err:
   owl_filterelement_cleanup(fe);
   g_free(fe);
+  g_slice_free(owl_filterelement, fe);
   return NULL;
+}
 …
     op2 = owl_filter_parse_primitive_expression(argc-i-1, argv+i+1, &skip);
     if(!op2) goto err;
     tmp = g_new(owl_filterelement, 1);
+    tmp = g_slice_new(owl_filterelement);
     if(!strcasecmp(argv[i], "and")) {
       owl_filterelement_create_and(tmp, op1, op2);
 …
   if(op1) {
     owl_filterelement_cleanup(op1);
     g_free(op1);
+    g_slice_free(owl_filterelement, op1);
+  }
   return NULL;
 …
   if (f->root) {
     owl_filterelement_cleanup(f->root);
     g_free(f->root);
+    g_slice_free(owl_filterelement, f->root);
+  }
   if (f->name)
     g_free(f->name);
   g_free(f);
+}
+  g_slice_free(owl_filter, f);
+}

filterelement.c

-                      r7756dde
+                      r7dcef03
   if (fe->left) {
     owl_filterelement_cleanup(fe->left);
     g_free(fe->left);
+    g_slice_free(owl_filterelement, fe->left);
+  }
   if (fe->right) {
     owl_filterelement_cleanup(fe->right);
     g_free(fe->right);
+    g_slice_free(owl_filterelement, fe->right);
+  }
   owl_regex_cleanup(&(fe->re));

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

-                      ra38becd
+                      r9e596f5
 void owl_function_show_license(void)
+{
+  const char *text;
+  text=""
+    "BarnOwl version " OWL_VERSION_STRING "\n"
+  char *text = g_strdup_printf(
+    "BarnOwl version %s\n"
     "Copyright (c) 2006-2011 The BarnOwl Developers. All rights reserved.\n"
     "Copyright (c) 2004 James Kretchmar. All rights reserved.\n"
 …
     "WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE\n"
     "OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN\n"
+    "IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n";
+    "IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n",
+    version);
   owl_function_popless_text(text);
+  g_free(text);
+}
 …
     "':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"
+    ;
 …
   owl_message *m;
   m=g_new(owl_message, 1);
+  m=g_slice_new(owl_message);
   owl_message_create_admin(m, header, body);
 …
   if (z->cc && owl_zwrite_is_personal(z)) {
     /* create the message */
     owl_message *m = g_new(owl_message, 1);
+    owl_message *m = g_slice_new(owl_message);
     owl_message_create_from_zwrite(m, z, owl_zwrite_get_message(z), 0);
 …
       /* create the message */
       m = g_new(owl_message, 1);
+      m = g_slice_new(owl_message);
       owl_message_create_from_zwrite(m, z, owl_zwrite_get_message(z), i);
 …
+    }
+  }
+}
-/* 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_new(owl_message, 1);
-  owl_message_create_aim(m,
-                         owl_global_get_aim_screenname(&g),
-                         to,
-                         body,
-                         OWL_MESSAGE_DIRECTION_OUT,
-);
-  return(m);
+}
 …
   /* create the message */
   m=g_new(owl_message, 1);
+  m=g_slice_new(owl_message);
   owl_message_create_loopback(m, body);
   owl_message_set_direction_out(m);
 …
+}
-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)
+{
 …
+}
-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_loopwrite(owl_editwin *e, bool success)
+{
 …
   /* create a message and put it on the message queue.  This simulates
    * an incoming message */
   min=g_new(owl_message, 1);
+  min=g_slice_new(owl_message);
   mout=owl_function_make_outgoing_loopback(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;
-  va_start(ap, fmt);
   if (!owl_global_is_debug_fast(&g))
 …
   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));
   g_free(tmpbuff);
+  va_start(ap, fmt);
   vfprintf(file, fmt, ap);
+  va_end(ap);
   putc('\n', file);
   fflush(file);
-  va_end(ap);
+}
 …
 void owl_function_about(void)
+{
   owl_function_popless_text(
     "This is BarnOwl version " OWL_VERSION_STRING ".\n\n"
+  char *text = g_strdup_printf(
+    "This is BarnOwl version %s.\n\n"
     "BarnOwl is a fork of the Owl zephyr client, written and\n"
     "maintained by Alejandro Sedeno and Nelson Elhage at the\n"
 …
     "This program is free software. You can redistribute it and/or\n"
     "modify under the terms of the Sleepycat License. Use the \n"
+    "':show license' command to display the full license\n"
+  );
+      "':show license' command to display the full license\n",
+      version);
+  owl_function_popless_text(text);
+  g_free(text);
+}
 …
         owl_fmtext_append_normal(&fm, "\n");
         owl_fmtext_appendf_normal(&fm, "  Port      : %i\n", ntohs(n->z_port));
+        owl_fmtext_appendf_normal(&fm, "  Charset   : %s\n", owl_zephyr_get_charsetstr(n));
         owl_fmtext_appendf_normal(&fm, "  Auth      : %s\n", owl_zephyr_get_authstr(n));
 …
   char buff[MAXPATHLEN+1];
   time_t start;
+  struct tm tm;
   int up, days, hours, minutes;
   owl_fmtext fm;
 …
   owl_fmtext_append_normal(&fm, "  Version: ");
   owl_fmtext_append_normal(&fm, OWL_VERSION_STRING);
+  owl_fmtext_append_normal(&fm, version);
   owl_fmtext_append_normal(&fm, "\n");
 …
   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);
 …
   while (zaldptr) {
     ZFreeALD(zaldptr->data);
     g_free(zaldptr->data);
+    g_slice_free(ZAsyncLocateData_t, zaldptr->data);
     zaldptr = g_list_next(zaldptr);
+  }
 …
     for (i = 0; i < anyone->len; i++) {
       user = anyone->pdata[i];
       zald = g_new(ZAsyncLocateData_t, 1);
+      zald = g_slice_new(ZAsyncLocateData_t);
       if (ZRequestLocations(zstr(user), zald, UNACKED, ZAUTH) == ZERR_NONE) {
         *zaldlist = g_list_append(*zaldlist, zald);
       } else {
         g_free(zald);
+        g_slice_free(ZAsyncLocateData_t, zald);
+      }
+    }
 …
+  }
 #endif
+}
-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);
+}

global.c

-                      r120dac7
+                      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));
 …
   e->g->filterlist = g_list_remove(e->g->filterlist, e->f);
   owl_filter_delete(e->f);
   g_free(e);
+  g_slice_free(owl_global_filter_ent, e);
+}
 void owl_global_add_filter(owl_global *g, owl_filter *f) {
   owl_global_filter_ent *e = g_new(owl_global_filter_ent, 1);
+  owl_global_filter_ent *e = g_slice_new(owl_global_filter_ent);
   e->g = g;
   e->f = f;
 …
+}
-/* 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"

keybinding.c

-                      rf271129
+                      r7dcef03
 CALLER_OWN owl_keybinding *owl_keybinding_new(const char *keyseq, const char *command, void (*function_fn)(void), const char *desc)
+{
   owl_keybinding *kb = g_new(owl_keybinding, 1);
+  owl_keybinding *kb = g_slice_new(owl_keybinding);
   owl_function_debugmsg("owl_keybinding_init: creating binding for <%s> with desc: <%s>", keyseq, desc);
   if (command && function_fn) {
     g_free(kb);
+    g_slice_free(owl_keybinding, kb);
     return NULL;
   } else if (command && !function_fn) {
 …
   if (owl_keybinding_make_keys(kb, keyseq) != 0) {
     g_free(kb);
+    g_slice_free(owl_keybinding, kb);
     return NULL;
+  }
 …
   g_free(kb->desc);
   g_free(kb->command);
   g_free(kb);
+  g_slice_free(owl_keybinding, kb);
+}

keymap.c

rf271129	r7dcef03
189	189	{
190	190	owl_keymap *km;
191		km = g_~~new(owl_keymap, 1~~);
	191	km = g_slice_new(owl_keymap);
192	192	owl_keymap_init(km, name, desc, default_fn, prealways_fn, postalways_fn);
193	193	owl_keyhandler_add_keymap(kh, km);

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

-                      r0792d99
+                      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_free(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_new(owl_log_entry,1);
+  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_new(owl_message, 1);
+  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);
+}

mainwin.c

rab88b05	r7dcef03
6	6	CALLER_OWN owl_mainwin owl_mainwin_new(owl_window window)
7	7	{
8		owl_mainwin *mw = g_~~new(owl_mainwin, 1~~);
	8	owl_mainwin *mw = g_slice_new(owl_mainwin);
9	9	mw->curtruncated=0;
10	10	mw->lastdisplayed=-1;

message.c

-                      r2354e9a
+                      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;
 …
   if(pair ==  NULL) {
     pair = g_new(owl_pair, 1);
+    pair = g_slice_new(owl_pair);
     owl_pair_create(pair, attrname, NULL);
     g_ptr_array_add(m->attributes, pair);
 …
 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 */
 …
     p = m->attributes->pdata[i];
     g_free(owl_pair_get_value(p));
     g_free(p);
+    g_slice_free(owl_pair, p);
+  }
 …
+{
   owl_message_cleanup(m);
   g_free(m);
+}
+  g_slice_free(owl_message, m);
+}

messagelist.c

-                      r219f52c
+                      r7dcef03
 CALLER_OWN owl_messagelist *owl_messagelist_new(void)
+{
   owl_messagelist *ml = g_new(owl_messagelist, 1);
+  owl_messagelist *ml = g_slice_new(owl_messagelist);
   ml->list = g_ptr_array_new();
   return ml;
 …
     g_ptr_array_foreach(ml->list, (GFunc)owl_message_delete, NULL);
   g_ptr_array_free(ml->list, true);
   g_free(ml);
+  g_slice_free(owl_messagelist, ml);
+}

owl.c

-                      r120dac7
+                      r4fd3c04
 void usage(FILE *file)
+{
   fprintf(file, "Barnowl version %s\n", OWL_VERSION_STRING);
+  fprintf(file, "BarnOwl version %s\n", version);
   fprintf(file, "Usage: barnowl [-n] [-d] [-D] [-v] [-h] [-c <configfile>] [-s <confdir>] [-t <ttyname>]\n");
   fprintf(file, "  -n,--no-subs        don't load zephyr subscriptions\n");
   fprintf(file, "  -d,--debug          enable debugging\n");
   fprintf(file, "  -v,--version        print the Barnowl version number and exit\n");
+  fprintf(file, "  -v,--version        print the BarnOwl version number and exit\n");
   fprintf(file, "  -h,--help           print this help message\n");
   fprintf(file, "  -s,--config-dir     specify an alternate config dir (default ~/.owl)\n");
 …
       break;
     case 'v':
       printf("This is BarnOwl version %s\n", OWL_VERSION_STRING);
+      printf("This is BarnOwl version %s\n", version);
       exit(0);
     case 'h':
 …
       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_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_function_debugmsg("startup: executing perl startup, if applicable");
 …
   /* welcome message */
   owl_function_debugmsg("startup: creating splash message");
   owl_function_adminmsg("",
+  char *welcome = g_strdup_printf(
     "-----------------------------------------------------------------------\n"
     "Welcome to BarnOwl version " OWL_VERSION_STRING ".\n"
+    "Welcome to BarnOwl version %s.\n"
     "To see a quick introduction, type ':show quickstart'.                  \n"
     "Press 'h' for on-line help.                                            \n"
 …
     "                                                                 OvO   \n"
     "Please report any bugs or suggestions to bug-barnowl@mit.edu    (   )  \n"
+    "-----------------------------------------------------------------m-m---\n"
+  );
+    "-----------------------------------------------------------------m-m---\n",
+    version);
+  owl_function_adminmsg("", welcome);
+  g_free(welcome);
   owl_function_debugmsg("startup: setting context interactive");

owl.h

-                      r120dac7
+                      r4fd3c04
 #include <termios.h>
 #include <unistd.h>
-#include "libfaim/aim.h"
 #include <wchar.h>
 #include <glib.h>
 …
 #include "window.h"
+#ifndef OWL_VERSION_STRING
+#ifdef  GIT_VERSION
+#define stringify(x)       __stringify(x)
+#define __stringify(x)     #x
+#define OWL_VERSION_STRING stringify(GIT_VERSION)
+#else
+#define OWL_VERSION_STRING PACKAGE_VERSION
+#endif
+#endif /* !OWL_VERSION_STRING */
+extern const char *version;
 /* Feature that is being tested to redirect stderr through a pipe.
 …
 #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/lib/BarnOwl/Style/Default.pm

-                      r732d5c0
+                      rebc6f77
     my $self = shift;
     my $m = shift;
+    my $sender = $m->long_sender;
+    $sender =~ s/\n.*$//s;
+    my $sender = $self->humanize($m->long_sender, 1);
     if (BarnOwl::getvar('colorztext') eq 'on') {
       return "  (" . $sender . '@color[default]' . ")";

perl/modules/Facebook/README

-                      rf4037cf
+                      r441fd42
   This token will persist across BarnOwls until you change your
   Facebook password or you revoke permissions for Barnowl at:
+  Facebook password or you revoke permissions for BarnOwl at:
     http://www.facebook.com/settings/?tab=applications&app_id=235537266461636
   (3) Start receiving wall updates in Barnowl!
+  (3) Start receiving wall updates in BarnOwl!
   You can post updates with the ":facebook" command.

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

-                      r4f7b1f4
+                      rd4f33f1
 use AnyEvent::IRC;
+use Encode;
+use File::Spec;
 use Getopt::Long;
-use Encode;
 use Text::Wrap;
 our $VERSION = 0.02;
+our $IRC_SUBS_FILENAME = "ircchannels";
 our $irc;
 …
             summary => 'Connect to an IRC server',
             usage =>
 'irc-connect [-a ALIAS ] [-s] [-p PASSWORD] [-n NICK] SERVER [port]',
+'irc-connect [-a ALIAS] [-s] [-p PASSWORD] [-n NICK] SERVER [port]',
             description => <<END_DESCR
 Connect to an IRC server. Supported options are:
 …
+        {
             summary => 'Join an IRC channel',
+            usage   => 'irc-join [-a ALIAS] #channel [KEY]',
+            description => <<END_DESCR
+Join an IRC channel.
+            usage   => 'irc-join [-a ALIAS] [-t] #channel [KEY]',
+            description => <<END_DESCR
+Join an IRC channel.  If the -t option is present the subscription will only be
+temporary, i.e., it will not be written to the subscription file and will
+therefore not be present the next time BarnOwl is started, and will disappear
+if the connection is lost.
 END_DESCR
+        }
 …
+        {
             summary => 'Leave an IRC channel',
+            usage   => 'irc-part [-a ALIAS] #channel',
+            description => <<END_DESCR
+Part from an IRC channel.
+            usage   => 'irc-part [-a ALIAS] [-t] #channel',
+            description => <<END_DESCR
+Part from an IRC channel.  If the -t option is present the unsubscription will
+only be temporary, i.e., it will not be updated in the subscription file and
+will therefore not be in effect the next time BarnOwl is started, or if the
+connection is lost.
 END_DESCR
+        }
 …
 This can be used to perform some operation not yet supported by
 BarnOwl, or to define new IRC commands.
+END_DESCR
+        }
+    );
+    BarnOwl::new_command(
+        'irc-loadchannels' => \&cmd_loadchannels,
+        {
+            summary => 'Reload persistent channels',
+            usage   => 'irc-loadchannels [-a ALIAS] [<file>]',
+            description => <<END_DESCR
+Load persistent channels from a file.  The file defaults to
+\$HOME/.owl/$IRC_SUBS_FILENAME.  If the ALIAS is present, only channels
+on the given alias are loaded.  The ALIAS is case-sensitive.
+Each line of the file should describe a single channel, in the format
+'\$alias \$channel' (without quotes).
 END_DESCR
+        }
 …
 ######################## Owl command handlers ##################################
 ################################################################################
+sub make_autoconnect_filename {
+    # can't use ||, or else we'll treat '0' as invalid.  We could check for eq "" ...
+    # TODO(jgross): When we move to requiring perl 5.10, combine the
+    # following two lines using //
+    my $filename = shift;
+    $filename = File::Spec->catfile(BarnOwl::get_config_dir(), $IRC_SUBS_FILENAME) unless defined $filename;
+    if (!File::Spec->file_name_is_absolute($filename)) {
+        $filename = File::Spec->catfile($ENV{HOME}, $filename);
+    }
+    return $filename;
+}
+sub _get_autoconnect_lines {
+    my $filename = shift;
+    # TODO(jgross): Write a C-side function to do this, asynchronously;
+    #               AIUI, perl doesn't do asynchronous I/O in any useful way
+    if (open (my $subsfile, "<:encoding(UTF-8)", $filename)) {
+        my @lines = <$subsfile>;
+        close($subsfile);
+        # strip trailing newlines
+        local $/ = "";
+        chomp(@lines);
+        return @lines;
+    }
+    return ();
+}
+sub get_autoconnect_channels {
+    my $filename = make_autoconnect_filename(shift);
+    my %channel_hash = ();
+    # Load the subs from the file
+    my @lines = _get_autoconnect_lines($filename);
+    foreach my $line (@lines) {
+        my @parsed_args = split(' ', $line);
+        if (scalar @parsed_args == 2) {
+            push @{$channel_hash{$parsed_args[0]}}, $parsed_args[1];
+        } else {
+            warn "Trouble parsing irc configuration file '$filename' line '$line'; the format is '\$alias \$channel', with no spaces in either\n";
+        }
+    }
+    return %channel_hash;
+}
+sub add_autoconnect_channel {
+    my $conn = shift;
+    my $channel = shift;
+    my $alias = $conn->alias;
+    my $filename = make_autoconnect_filename(shift);
+    # we already checked for spaces in $channel in cmd_join, but we still need
+    # to check $alias
+    die "Alias name '$alias' contains a space; parsing will fail.  Use the -t flag.\n" unless index($alias, " ") == -1;
+    my $line = "$alias $channel";
+    my @lines = _get_autoconnect_lines($filename);
+    # We don't want to be noisy about duplicated joins.  For example, some
+    # people might have :irc-join in startup files, even though that doesn't
+    # work correctly anymore because connect is asynchronous and so join on
+    # startup races with connect.  Regardless, just fail silently if the line
+    # already exists.
+    return if grep { $_ eq $line } @lines;
+    open (my $subsfile, ">>:encoding(UTF-8)", make_autoconnect_filename($filename))
+        or die "Cannot open $filename for writing: $!\n";
+    local $, = "";
+    local $/ = "";
+    print $subsfile "$line\n";
+    close($subsfile);
+}
+sub remove_autoconnect_channel {
+    my $conn = shift;
+    my $channel = shift;
+    my $alias = $conn->alias;
+    my $filename = make_autoconnect_filename(shift);
+    BarnOwl::Internal::file_deleteline($filename, "$alias $channel", 1);
+}
+sub cmd_loadchannels {
+    my $cmd = shift;
+    my $alias;
+    my $getopt = Getopt::Long::Parser->new;
+    local @ARGV = @_;
+    $getopt->configure(qw(pass_through permute no_getopt_compat prefix_pattern=-|--));
+    $getopt->getoptions("alias=s" => \$alias);
+    my %channel_hash = get_autoconnect_channels(@ARGV);
+    my $aliases = (defined $alias) ? [$alias] : [keys %channel_hash];
+    foreach my $cur_alias (@$aliases) {
+        # get_connection_by_alias might die, and we don't want to
+        eval {
+            my $conn = get_connection_by_alias($cur_alias, 1);
+            my %existing_channels = map { $_ => 1 } @{$conn->autoconnect_channels}, @{$channel_hash{$cur_alias}};
+            $conn->autoconnect_channels([keys %existing_channels]);
+        };
+        foreach my $channel (@{$channel_hash{$cur_alias}}) {
+            if ($cur_alias eq "") {
+                BarnOwl::command("irc-join", "-t", $channel);
+            } else {
+                BarnOwl::command("irc-join", "-t", "-a", $cur_alias, $channel);
+            }
+        }
+    }
+}
 sub cmd_connect {
 …
+    }
+    my %channel_hash = get_autoconnect_channels;
     my $conn = BarnOwl::Module::IRC::Connection->new($alias, $host, $port, {
+        nick      => $nick,
+        user      => $username,
+        real      => $ircname,
+        password  => $password,
+        SSL       => $ssl,
+        timeout   => sub {0}
+        nick                 => $nick,
+        user                 => $username,
+        real                 => $ircname,
+        password             => $password,
+        SSL                  => $ssl,
+        timeout              => sub {0},
+        autoconnect_channels => $channel_hash{$alias}
        });
     $ircnets{$alias} = $conn;
 …
                                "[" . $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};
+    }
 …
 sub cmd_join {
     my $cmd = shift;
+    my $conn = shift;
+    my $chan = shift or die("Usage: $cmd channel\n");
+    $conn->conn->send_msg(join => $chan, @_);
+    my $is_temporary;
+    my $getopt = Getopt::Long::Parser->new;
+    local @ARGV = @_;
+    $getopt->configure(qw(pass_through permute no_getopt_compat prefix_pattern=-|--));
+    $getopt->getoptions("temporary" => \$is_temporary);
+    my $conn = shift @ARGV;
+    my $chan = shift @ARGV or die("Usage: $cmd channel\n");
+    die "Channel name '$chan' contains a space.  As per RFC 2812, IRC channel names may not contain spaces.\n" unless index($chan, " ") == -1;
+    $conn->conn->send_msg(join => $chan, @ARGV);
+    # regardless of whether or not this is temporary, we want to persist it
+    # across reconnects.
+    # check if the channel is already in the list
+    if (!grep { $_ eq $chan } @{$conn->autoconnect_channels}) {
+        push @{$conn->autoconnect_channels}, $chan;
+    }
+    if (!$is_temporary) {
+        # add the line to the subs file
+        add_autoconnect_channel($conn, $chan);
+    }
     return;
+}
 …
 sub cmd_part {
     my $cmd = shift;
+    my $conn = shift;
+    my $chan = shift;
+    my $is_temporary;
+    my $getopt = Getopt::Long::Parser->new;
+    local @ARGV = @_;
+    $getopt->configure(qw(pass_through permute no_getopt_compat prefix_pattern=-|--));
+    $getopt->getoptions("temporary" => \$is_temporary);
+    my $conn = shift @ARGV;
+    my $chan = shift @ARGV or die("Usage: $cmd channel\n");
     $conn->conn->send_msg(part => $chan);
+    # regardless of whether or not this is temporary, we want to persist it
+    # across reconnects
+    my %existing_channels = map { $_ => 1 } @{$conn->autoconnect_channels};
+    delete $existing_channels{$chan};
+    $conn->autoconnect_channels([keys %existing_channels]);
+    if (!$is_temporary) {
+        # remove the line from the subs file
+        remove_autoconnect_channel($conn, $chan);
+    }
     return;
+}
 …
         my $alias;
         my $channel;
+        my $is_temporary;
         my $getopt = Getopt::Long::Parser->new;
         my $m = BarnOwl::getcurmsg();
 …
         local @ARGV = @_;
         $getopt->configure(qw(pass_through permute no_getopt_compat prefix_pattern=-|--));
+        $getopt->getoptions("alias=s" => \$alias);
+        $getopt->getoptions("alias=s" => \$alias,
+                            "temporary" => \$is_temporary);
         if(defined($alias)) {
 …
             die("You must specify an IRC network using -a.\n");
+        }
+        push @ARGV, "-t" if $is_temporary;
         if($flags & CHANNEL_ARG) {
             $sub->($cmd, $conn, $channel, @ARGV);

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

-                      rdace02a
+                      r76e80de
+}
+sub complete_irc_join_part {
+    my $ctx = shift;
+    return complete_flags($ctx,
+        [qw(-t)],
+        {
+            "-a" => \&complete_networks,
+        },
+        \&complete_channels
+       );
+}
 sub complete_irc_channel {
     my $ctx = shift;
 …
 BarnOwl::Completion::register_completer('irc-msg'        => \&complete_irc_dest);
 BarnOwl::Completion::register_completer('irc-mode'       => \&complete_irc_dest);
 BarnOwl::Completion::register_completer('irc-join'       => \&complete_irc_channel);
 BarnOwl::Completion::register_completer('irc-part'       => \&complete_irc_channel);
+BarnOwl::Completion::register_completer('irc-join'       => \&complete_irc_join_part);
+BarnOwl::Completion::register_completer('irc-part'       => \&complete_irc_join_part);
 BarnOwl::Completion::register_completer('irc-names'      => \&complete_irc_channel);
 BarnOwl::Completion::register_completer('irc-whois'      => \&complete_irc_nick);

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

-                      r13ee8f2
+                      r4379288
     my $self = bless({}, $class);
     $self->conn($conn);
+    $self->autoconnect_channels([]);
+    # TODO(jgross): use // when we move to requiring perl 5.10
+    $self->autoconnect_channels(defined $args->{autoconnect_channels} ? $args->{autoconnect_channels} : []);
     $self->alias($alias);
     $self->server($host);
 …
         $self->{reconnect_timer}->stop;
+    }
     $self->{reconnect_timer} =
+    $self->{reconnect_timer} =
         BarnOwl::Timer->new( {
             name  => 'IRC (' . $self->alias . ') reconnect_timer',
 …
+}
+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);
+        }
+        $self->autoconnect_channels([]);
+        rejoin_channels($self, @{$self->autoconnect_channels});
+    }
     $self->conn->enable_ping(60, sub {
 …
     my $backoff = $self->backoff;
-    $self->autoconnect_channels([keys(%{$self->{channel_list}})]);
     $self->conn->connect(@{$self->connect_args});
+}

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/Jabber/lib/BarnOwl/Module/Jabber.pm

r416a7e5	r41064be
1360	1360	{
1361	1361	my @answer = $packet->answer;
1362		return $answer[0]~~{target}, $answer[0]{port}~~;
	1362	return $answer[0]->target, $answer[0]->port if @answer;
1363	1363	}
1364	1364

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)

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

-                      rb8a3e00
+                      r140429f
         my $twitter_args = { username   => $cfg->{user},
                              password   => $cfg->{password},
+                             source     => 'barnowl',
+                             source     => 'barnowl',
+                             ssl        => 1,
+                             legacy_lists_api => 0,
                          };
         if (defined $cfg->{service}) {
 …
 );
+BarnOwl::new_command( 'twitter-favorite' => sub { cmd_twitter_favorite(@_) },
+    {
+    summary     => 'Favorite the current Twitter message',
+    usage       => 'twitter-favorite [ACCOUNT]',
+    description => <<END_DESCRIPTION
+Favorite the current Twitter message using ACCOUNT (defaults to the
+account that received the tweet).
+END_DESCRIPTION
+    }
+);
 BarnOwl::new_command( 'twitter-follow' => sub { cmd_twitter_follow(@_); },
+    {
 …
     $account = $m->account unless defined($account);
     find_account($account)->twitter_retweet($m);
+    return;
+}
+sub cmd_twitter_favorite {
+    my $cmd = shift;
+    my $account = shift;
+    my $m = BarnOwl::getcurmsg();
+    if(!$m || $m->type ne 'Twitter') {
+        die("$cmd must be used with a Twitter message selected.\n");
+    }
+    $account = $m->account unless defined($account);
+    find_account($account)->twitter_favorite($m);
     return;
+}

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

-                      r4ebbfbc
+                      r140429f
         $self->twitter_direct($1, $2);
     } elsif(defined $self->{twitter}) {
-        if(length($msg) > 140) {
-            die("Twitter: Message over 140 characters long.\n");
+        }
         $self->twitter_command('update', {
             status => $msg,
 …
+}
+sub twitter_favorite {
+    my $self = shift;
+    my $msg = shift;
+    if($msg->service ne $self->{cfg}->{service}) {
+        die("Cannot favorite a message from a different service.\n");
+    }
+    $self->twitter_command(create_favorite => $msg->{status_id});
+}
 sub twitter_follow {
     my $self = shift;

perlconfig.c

-                      r96d80e9
+                      r09530e6
   hash = (HV*)SvRV(msg);
   m = g_new(owl_message, 1);
+  m = g_slice_new(owl_message);
   owl_message_init(m);
 …
       g_free(m->timestr);
       m->timestr = g_strdup(val);
+      // FIXME: Daylight saving time will be guessed wrongly one hour per year!
+      tm.tm_isdst = -1;
       strptime(val, "%a %b %d %T %Y", &tm);
       m->time = mktime(&tm);
 …
+  }
   sv_setpv(get_sv("BarnOwl::VERSION", TRUE), OWL_VERSION_STRING);
+  sv_setpv(get_sv("BarnOwl::VERSION", TRUE), version);
   /* Add the system lib path to @INC */

perlglue.xs

-                      r1ced34f
+                      rd2ba33c
      CODE:
+        {
                 s = g_new(owl_style, 1);
+                s = g_slice_new(owl_style);
                 owl_style_create_perl(s, name, newSVsv(object));
                 owl_global_add_style(&g, s);
 …
                 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
 …
 MODULE = BarnOwl                PACKAGE = BarnOwl::Internal
+int
+file_deleteline(filename, line, backup)
+        const char *filename
+        const char *line
+        int backup
+        CODE:
+                RETVAL = owl_util_file_deleteline(filename, line, backup);
+        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);

popexec.c

re146cd7	r7dcef03
23	23	}
24	24
25		pe = g_~~new(owl_popexec, 1~~);
	25	pe = g_slice_new(owl_popexec);
26	26	pe->winactive=0;
27	27	pe->pid=0;
…	…
179	179	if (pe->refcount<=0) {
180	180	owl_function_debugmsg("doing free of %p", pe);
181		g_~~free(~~pe);
	181	g_slice_free(owl_popexec, pe);
182	182	}
183	183	}

popwin.c

-                      r6829afc
+                      r7dcef03
 CALLER_OWN owl_popwin *owl_popwin_new(void)
+{
   owl_popwin *pw = g_new0(owl_popwin, 1);
+  owl_popwin *pw = g_slice_new0(owl_popwin);
   pw->border = owl_window_new(NULL);
 …
   g_object_unref(pw->content);
   g_free(pw);
+  g_slice_free(owl_popwin, pw);
+}

runtests.sh

r5db8835	r7dcef03
1	1	#!/bin/sh
	2	export G_SLICE=debug-blocks
2	3	exec env HARNESS_PERL=./tester prove --failures "${srcdir:=$(dirname "$0")}/t/"

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."

select.c

-                      r84a071f
+                      r7dcef03
   if (t->destroy_cbdata)
     t->destroy_cbdata(t->cbdata);
   g_free(t);
+  g_slice_free(owl_task, t);
+}
 …
+{
   GSource *source = g_idle_source_new();
   owl_task *t = g_new0(owl_task, 1);
+  owl_task *t = g_slice_new0(owl_task);
   t->cb = cb;
   t->cbdata = cbdata;

style.c

r92ffd89	r7dcef03
103	103	{
104	104	owl_style_cleanup(s);
105		g_~~free(~~s);
	105	g_slice_free(owl_style, s);
106	106	}

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

-                      r6a8b519
+                      ra882637
 int owl_history_regtest(void);
 int call_filter_regtest(void);
+int owl_smartstrip_regtest(void);
 extern void owl_perl_xs_init(pTHX);
 …
     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;
 …
   numfailures += owl_history_regtest();
   numfailures += call_filter_regtest();
+  numfailures += owl_smartstrip_regtest();
   if (numfailures) {
       fprintf(stderr, "# *** WARNING: %d failures total\n", numfailures);
 …
   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)));
 …
   return numfailed;
+}
+int owl_smartstrip_regtest(void)
+{
+  int numfailed = 0;
+  printf("# BEGIN testing owl_zephyr_smartstripped_user\n");
+#define CHECK_SMARTSTRIP(in, expected)                  \
+  do {                                                  \
+    char *__value = owl_zephyr_smartstripped_user(in);  \
+    FAIL_UNLESS("owl_zephyr_smartstripped_user " in,    \
+                strcmp((expected), __value) == 0);      \
+    g_free(__value);                                    \
+  } while (0)
+  CHECK_SMARTSTRIP("foo", "foo");
+  CHECK_SMARTSTRIP("foo.bar", "foo");
+  CHECK_SMARTSTRIP("foo/bar", "foo");
+  CHECK_SMARTSTRIP("host/bar", "host/bar");
+  CHECK_SMARTSTRIP("rcmd.bar", "rcmd.bar");
+  CHECK_SMARTSTRIP("daemon/bar", "daemon/bar");
+  CHECK_SMARTSTRIP("daemon.bar", "daemon.bar");
+  CHECK_SMARTSTRIP("foo@ATHENA.MIT.EDU", "foo@ATHENA.MIT.EDU");
+  CHECK_SMARTSTRIP("foo.bar@ATHENA.MIT.EDU", "foo@ATHENA.MIT.EDU");
+  CHECK_SMARTSTRIP("foo/bar@ATHENA.MIT.EDU", "foo@ATHENA.MIT.EDU");
+  CHECK_SMARTSTRIP("host/bar@ATHENA.MIT.EDU", "host/bar@ATHENA.MIT.EDU");
+  CHECK_SMARTSTRIP("rcmd.bar@ATHENA.MIT.EDU", "rcmd.bar@ATHENA.MIT.EDU");
+  CHECK_SMARTSTRIP("daemon/bar@ATHENA.MIT.EDU", "daemon/bar@ATHENA.MIT.EDU");
+  CHECK_SMARTSTRIP("daemon.bar@ATHENA.MIT.EDU", "daemon.bar@ATHENA.MIT.EDU");
+  printf("# END testing owl_zephyr_smartstripped_user\n");
+  return numfailed;
+}

util.c

-                      r7b89e8c
+                      rd2ba33c
   if (fstat(fileno(old), &st) != 0) {
     owl_function_error("Cannot stat %s: %s", filename, strerror(errno));
+    fclose(old);
     return -1;
+  }
 …
   /* resolve symlinks, because link() fails on symlinks, at least on AFS */
   actual_filename = owl_util_recursive_resolve_link(filename);
+  if (actual_filename == NULL)
+  if (actual_filename == NULL) {
+    fclose(old);
     return -1; /* resolving the symlink failed, but we already logged this error */
+  }
   newfile = g_strdup_printf("%s.new", actual_filename);
 …
+}
+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

-                      r9d4dfdc
+                      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)
+{
 …
 static owl_variable *owl_variable_newvar(int type, const char *name, const char *summary, const char *description, const char *validsettings) {
   owl_variable *var = g_new0(owl_variable, 1);
+  owl_variable *var = g_slice_new0(owl_variable);
   var->type = type;
   var->name = g_strdup(name);
 …
   g_closure_unref(v->set_fromstring_fn);
   g_free(v);
+  g_slice_free(owl_variable, v);
+}
 …
 const char *owl_variable_get_validsettings(const owl_variable *v) {
   return v->validsettings;
+}
+bool owl_variable_takes_on_off(const owl_variable *v) {
+  return v->takes_on_off;
+}
 …
 CALLER_OWN char *owl_variable_bool_get_tostring_default(const owl_variable *v, void *dummy)
+{
+  bool val = owl_variable_get_bool(v);
+  if (val == 0) {
+    return g_strdup("off");
+  } else if (val == 1) {
+    return g_strdup("on");
+  } else {
+    return g_strdup("<invalid>");
+  }
+  return g_strdup(owl_variable_get_bool(v) ? "on" : "off");
+}

viewwin.c

-                      r7803326
+                      r7dcef03
 CALLER_OWN owl_viewwin *owl_viewwin_new_text(owl_window *win, const char *text)
+{
   owl_viewwin *v = g_new0(owl_viewwin, 1);
+  owl_viewwin *v = g_slice_new0(owl_viewwin);
   owl_fmtext_init_null(&(v->fmtext));
   if (text) {
 …
+{
   char *text;
   owl_viewwin *v = g_new0(owl_viewwin, 1);
+  owl_viewwin *v = g_slice_new0(owl_viewwin);
   owl_fmtext_copy(&(v->fmtext), fmtext);
 …
   g_object_unref(v->status);
   owl_fmtext_cleanup(&(v->fmtext));
   g_free(v);
+}
+  g_slice_free(owl_viewwin, v);
+}

zcrypt.c

-                      r8f335a8
+                      r9a0d25d
 #include <config.h>
-#ifdef HAVE_KERBEROS_IV
-#include <kerberosIV/des.h>
-#else
 #include <openssl/des.h>
-#endif
 #include "filterproc.h"
+#ifndef OWL_VERSION_STRING
+#ifdef  GIT_VERSION
+#define stringify(x)       __stringify(x)
+#define __stringify(x)     #x
+#define OWL_VERSION_STRING stringify(GIT_VERSION)
+#else
+#define OWL_VERSION_STRING PACKAGE_VERSION
+#endif
+#endif /* !OWL_VERSION_STRING */
+extern const char *version;
 /* Annotate functions in which the caller owns the return value and is
 …
 };
+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);
+}
 …
       case OPT_VERSION:
         /* Version */
         printf("This is zcrypt version %s\n", OWL_VERSION_STRING);
+        printf("This is zcrypt version %s\n", version);
         exit(0);
       case OPT_HELP:
 …
 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

-                      r80d7b44
+                      ree6b30f
     owl_zephyr_loadsubs_helper(subs->subs, subs->nsubs);
     deferred_subs = g_list_delete_link(deferred_subs, deferred_subs);
     g_free(subs);
+    g_slice_free(owl_sub_list, subs);
+  }
 …
   ret_sd = owl_zephyr_loaddefaultsubs();
   /* load Barnowl default subscriptions */
+  /* load BarnOwl default subscriptions */
   ret_bd = owl_zephyr_loadbarnowldefaultsubs();
 …
     g_free(subs);
   } else {
     owl_sub_list *s = g_new(owl_sub_list, 1);
+    owl_sub_list *s = g_slice_new(owl_sub_list);
     s->subs = subs;
     s->nsubs = count;
 …
 #ifdef HAVE_LIBZEPHYR
   FILE *file;
+  char *tmp, *start;
+  int fopen_errno;
+  char *tmp, *start, *saveptr;
   char *buffer = NULL;
   char *subsfile;
 …
   int subSize = 1024;
   int count;
-  struct stat statbuff;
   subsfile = owl_zephyr_dotfile(".zephyr.subs", filename);
+  if (stat(subsfile, &statbuff) != 0) {
+    g_free(subsfile);
+    if (error_on_nofile == 1)
+  count = 0;
+  file = fopen(subsfile, "r");
+  fopen_errno = errno;
+  g_free(subsfile);
+  if (!file) {
+    if (error_on_nofile == 1 || fopen_errno != ENOENT)
       return -1;
     return 0;
+  }
-  ZResetAuthentication();
-  count = 0;
-  file = fopen(subsfile, "r");
-  g_free(subsfile);
-  if (!file)
-    return -1;
   subs = g_new(ZSubscription_t, subSize);
 …
     /* 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);
 …
     g_free(buffer);
+  ZResetAuthentication();
   return owl_zephyr_loadsubs_helper(subs, count);
 #else
 …
+}
 /* Load default Barnowl subscriptions
+/* Load default BarnOwl subscriptions
+ *
  * Returns 0 on success.
 …
 #ifdef HAVE_LIBZEPHYR
   ZSubscription_t *subs;
   int subSize = 10; /* Max Barnowl default subs we allow */
+  int subSize = 10; /* Max BarnOwl default subs we allow */
   int count, ret;
 …
   char *buffer = NULL;
   int count;
-  struct stat statbuff;
   subs = g_new(ZSubscription_t, numSubs);
   subsfile = owl_zephyr_dotfile(".anyone", filename);
-  if (stat(subsfile, &statbuff) == -1) {
-    g_free(subs);
-    g_free(subsfile);
-    return 0;
+  }
-  ZResetAuthentication();
   count = 0;
   file = fopen(subsfile, "r");
 …
     fclose(file);
   } else {
+    g_free(subs);
     return 0;
+  }
   g_free(buffer);
+  ZResetAuthentication();
   return owl_zephyr_loadsubs_helper(subs, count);
 #else
 …
+}
+#ifdef HAVE_LIBZEPHYR
+const char *owl_zephyr_get_charsetstr(const ZNotice_t *n)
+{
+#ifdef ZCHARSET_UTF_8
+  return ZCharsetToString(n->z_charset);
+#else
+  return "";
+#endif
+}
+#else
+const char *owl_zephyr_get_charsetstr(const void *n)
+{
+  return "";
+}
+#endif
 /* return auth string */
 #ifdef HAVE_LIBZEPHYR
 …
 CALLER_OWN char *owl_zephyr_smartstripped_user(const char *in)
+{
+  char *slash, *dot, *realm, *out;
+  out = g_strdup(in);
+  /* bail immeaditly if we don't have to do any work */
+  slash = strchr(out, '/');
+  dot = strchr(out, '.');
+  if (!slash && !dot) {
+    return(out);
+  }
+  if (!strncasecmp(out, OWL_ZEPHYR_NOSTRIP_HOST, strlen(OWL_ZEPHYR_NOSTRIP_HOST)) ||
+      !strncasecmp(out, OWL_ZEPHYR_NOSTRIP_RCMD, strlen(OWL_ZEPHYR_NOSTRIP_RCMD)) ||
+      !strncasecmp(out, OWL_ZEPHYR_NOSTRIP_DAEMON5, strlen(OWL_ZEPHYR_NOSTRIP_DAEMON5)) ||
+      !strncasecmp(out, OWL_ZEPHYR_NOSTRIP_DAEMON4, strlen(OWL_ZEPHYR_NOSTRIP_DAEMON4))) {
+    return(out);
+  }
+  realm = strchr(out, '@');
+  if (!slash && dot && realm && (dot > realm)) {
+    /* There's no '/', and the first '.' is in the realm */
+    return(out);
+  }
+  /* remove the realm from out, but hold on to it */
+  if (realm) realm[0]='\0';
+  /* strip */
+  if (slash) slash[0] = '\0';  /* krb5 style user/instance */
+  else if (dot) dot[0] = '\0'; /* krb4 style user.instance */
+  /* reattach the realm if we had one */
+  if (realm) {
+    strcat(out, "@");
+    strcat(out, realm+1);
+  }
+  return(out);
+  int n = strcspn(in, "./");
+  const char *realm = strchr(in, '@');
+  if (realm == NULL)
+    realm = in + strlen(in);
+  if (in + n >= realm ||
+      g_str_has_prefix(in, OWL_ZEPHYR_NOSTRIP_HOST) ||
+      g_str_has_prefix(in, OWL_ZEPHYR_NOSTRIP_RCMD) ||
+      g_str_has_prefix(in, OWL_ZEPHYR_NOSTRIP_DAEMON5) ||
+      g_str_has_prefix(in, OWL_ZEPHYR_NOSTRIP_DAEMON4))
+    return g_strdup(in);
+  else
+    return g_strdup_printf("%.*s%s", n, in, realm);
+}
 …
           if (ret == ZERR_NONE) {
             /* Send a PSEUDO LOGIN! */
             m = g_new(owl_message, 1);
+            m = g_slice_new(owl_message);
             owl_message_create_pseudo_zlogin(m, 0, zald->user,
                                              location.host,
 …
         /* Send a PSEUDO LOGOUT! */
         if (notify) {
           m = g_new(owl_message, 1);
+          m = g_slice_new(owl_message);
           owl_message_create_pseudo_zlogin(m, 1, zald->user, "", "", "");
           owl_global_messagequeue_addmsg(&g, m);
 …
+    }
     ZFreeALD(zald);
     g_free(zald);
+    g_slice_free(ZAsyncLocateData_t, zald);
+  }
+}
 …
       /* create the new message */
       m=g_new(owl_message, 1);
+      m=g_slice_new(owl_message);
       owl_message_create_from_znotice(m, &notice);

zwrite.c

-                      r919cbf2
+                      r1958790
 CALLER_OWN owl_zwrite *owl_zwrite_new_from_line(const char *line)
+{
   owl_zwrite *z = g_new(owl_zwrite, 1);
+  owl_zwrite *z = g_slice_new(owl_zwrite);
   if (owl_zwrite_create_from_line(z, line) != 0) {
     g_free(z);
+    g_slice_free(owl_zwrite, z);
     return NULL;
+  }
 …
 CALLER_OWN owl_zwrite *owl_zwrite_new(int argc, const char *const *argv)
+{
   owl_zwrite *z = g_new(owl_zwrite, 1);
+  owl_zwrite *z = g_slice_new(owl_zwrite);
   if (owl_zwrite_create(z, argc, argv) != 0) {
     g_free(z);
+    g_slice_free(owl_zwrite, z);
     return NULL;
+  }
 …
   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);
 …
+{
   owl_zwrite_cleanup(z);
   g_free(z);
+  g_slice_free(owl_zwrite, z);
+}

Context Navigation

Changes in / [416a7e5:7aa6811]

Legend:

Download in other formats: