Changeset 8861654

AUTHORS

r80c0fc7	r9e219d3
32	32	Betsy Riley
33	33	Robert Jacobs
	34	Google Inc.
34	35
35	36	BarnOwl is based on code from Owl, which was originally primarily

Makefile.am

-                      r4fd3c04
+                      r8861654
 CODELIST_SRCS=message.c mainwin.c popwin.c zephyr.c messagelist.c \
      commands.c global.c text.c fmtext.c editwin.c \
      util.c logging.c \
+     util.c logging.c ztext.c \
      perlconfig.c keys.c functions.c zwrite.c viewwin.c help.c filter.c \
      regex.c history.c view.c dict.c variable.c filterelement.c pair.c \
 …
      mainpanel.c msgwin.c sepbar.c editcontext.c signal.c closures.c
 NORMAL_SRCS = filterproc.c filterproc.h window.c window.h windowcb.c
+NORMAL_SRCS = filterproc.c filterproc.h window.c window.h windowcb.c ztext.h
 BASE_SRCS = $(CODELIST_SRCS) $(NORMAL_SRCS)

fmtext.c

-                      rf271129
+                      r4b2eef6
+}
+/* flattens a ztext parse tree into fmtext */
+static void owl_fmtext_append_ztext_tree(owl_fmtext *f, ztext_env *tree, char attr, short fg)
+{
+  char *s;
+  int i;
+  bool handled = false;
+  const struct {
+    const char *tag;
+    enum {SET,  MASK} mode;
+    const char val;
+  } TAGS[] = {
+    {"", MASK, 0},
+    {"@", MASK, 0},
+    {"@bold", MASK, OWL_FMTEXT_ATTR_BOLD},
+    {"@b", MASK, OWL_FMTEXT_ATTR_BOLD},
+    {"@italic", MASK, OWL_FMTEXT_ATTR_UNDERLINE},
+    {"@i", MASK, OWL_FMTEXT_ATTR_UNDERLINE},
+    {"@roman", SET, OWL_FMTEXT_ATTR_NONE},
+    {NULL, 0},
+  };
+  if (tree->closer == '@' && tree->content == NULL) {
+    owl_fmtext_append_attr(f, "@", attr, fg, OWL_COLOR_DEFAULT);
+    return;
+  }
+  for (i = 0; TAGS[i].tag != NULL; i++) {
+    if (!strcasecmp(tree->label, TAGS[i].tag)) {
+      if (TAGS[i].mode == MASK) {
+        attr |= TAGS[i].val;
+      } else if (TAGS[i].mode == SET) {
+        attr = TAGS[i].val;
+      }
+      handled = true;
+      break;
+    }
+  }
+  if (!handled) {
+    /* continue the dubious practice of printing codes we don't understand */
+    s = g_strdup_printf("%s%c", tree->label, tree->opener);
+    owl_fmtext_append_attr(f, s, attr, fg, OWL_COLOR_DEFAULT);
+    g_free(s);
+  }
+  for (ztext_node *p = tree->content; p != NULL; p = p->next) {
+    if (p->type == ZTEXT_NODE_STRING) {
+      owl_fmtext_append_attr(f, p->string, attr, fg, OWL_COLOR_DEFAULT);
+    } else if (p->type == ZTEXT_NODE_ENV) {
+      if (!strcasecmp(p->env->label, "@color")) {
+        s = ztext_strip(p->env);
+        fg = owl_util_string_to_color(s);
+        if (fg == OWL_COLOR_INVALID)
+          fg = OWL_COLOR_DEFAULT;
+        g_free(s);
+      } else {
+        owl_fmtext_append_ztext_tree(f, p->env, attr, fg);
+      }
+    }
+  }
+  if (!handled) {
+    s = g_strdup_printf("%c", tree->closer);
+    owl_fmtext_append_attr(f, s, attr, fg, OWL_COLOR_DEFAULT);
+    g_free(s);
+  }
+}
 /* Append the text 'text' to 'f' and interpret the zephyr style
 …
 void owl_fmtext_append_ztext(owl_fmtext *f, const char *text)
+{
+  int stacksize, curattrs, curcolor;
+  const char *ptr, *txtptr, *tmpptr;
+  char *buff;
+  int attrstack[32], chrstack[32], colorstack[32];
+  curattrs=OWL_FMTEXT_ATTR_NONE;
+  curcolor=OWL_COLOR_DEFAULT;
+  stacksize=0;
+  txtptr=text;
+  while (1) {
+    ptr=strpbrk(txtptr, "@{[<()>]}");
+    if (!ptr) {
+      /* add all the rest of the text and exit */
+      owl_fmtext_append_attr(f, txtptr, curattrs, curcolor, OWL_COLOR_DEFAULT);
+      return;
+    } else if (ptr[0]=='@') {
+      /* add the text up to this point then deal with the stack */
+      buff=g_new(char, ptr-txtptr+20);
+      strncpy(buff, txtptr, ptr-txtptr);
+      buff[ptr-txtptr]='\0';
+      owl_fmtext_append_attr(f, buff, curattrs, curcolor, OWL_COLOR_DEFAULT);
+      g_free(buff);
+      /* update pointer to point at the @ */
+      txtptr=ptr;
+      /* now the stack */
+      /* if we've hit our max stack depth, print the @ and move on */
+      if (stacksize==32) {
+        owl_fmtext_append_attr(f, "@", curattrs, curcolor, OWL_COLOR_DEFAULT);
+        txtptr++;
+        continue;
+      }
+      /* if it's an @@, print an @ and continue */
+      if (txtptr[1]=='@') {
+        owl_fmtext_append_attr(f, "@", curattrs, curcolor, OWL_COLOR_DEFAULT);
+        txtptr+=2;
+        continue;
+      }
+      /* if there's no opener, print the @ and continue */
+      tmpptr=strpbrk(txtptr, "(<[{ ");
+      if (!tmpptr || tmpptr[0]==' ') {
+        owl_fmtext_append_attr(f, "@", curattrs, curcolor, OWL_COLOR_DEFAULT);
+        txtptr++;
+        continue;
+      }
+      /* check what command we've got, push it on the stack, start
+         using it, and continue ... unless it's a color command */
+      buff=g_new(char, tmpptr-ptr+20);
+      strncpy(buff, ptr, tmpptr-ptr);
+      buff[tmpptr-ptr]='\0';
+      if (!strcasecmp(buff, "@bold")) {
+        attrstack[stacksize]=OWL_FMTEXT_ATTR_BOLD;
+        chrstack[stacksize]=tmpptr[0];
+        colorstack[stacksize]=curcolor;
+        stacksize++;
+        curattrs|=OWL_FMTEXT_ATTR_BOLD;
+        txtptr+=6;
+        g_free(buff);
+        continue;
+      } else if (!strcasecmp(buff, "@b")) {
+        attrstack[stacksize]=OWL_FMTEXT_ATTR_BOLD;
+        chrstack[stacksize]=tmpptr[0];
+        colorstack[stacksize]=curcolor;
+        stacksize++;
+        curattrs|=OWL_FMTEXT_ATTR_BOLD;
+        txtptr+=3;
+        g_free(buff);
+        continue;
+      } else if (!strcasecmp(buff, "@i")) {
+        attrstack[stacksize]=OWL_FMTEXT_ATTR_UNDERLINE;
+        chrstack[stacksize]=tmpptr[0];
+        colorstack[stacksize]=curcolor;
+        stacksize++;
+        curattrs|=OWL_FMTEXT_ATTR_UNDERLINE;
+        txtptr+=3;
+        g_free(buff);
+        continue;
+      } else if (!strcasecmp(buff, "@italic")) {
+        attrstack[stacksize]=OWL_FMTEXT_ATTR_UNDERLINE;
+        chrstack[stacksize]=tmpptr[0];
+        colorstack[stacksize]=curcolor;
+        stacksize++;
+        curattrs|=OWL_FMTEXT_ATTR_UNDERLINE;
+        txtptr+=8;
+        g_free(buff);
+        continue;
+      } else if (!strcasecmp(buff, "@")) {
+        attrstack[stacksize]=OWL_FMTEXT_ATTR_NONE;
+        chrstack[stacksize]=tmpptr[0];
+        colorstack[stacksize]=curcolor;
+        stacksize++;
+        txtptr+=2;
+        g_free(buff);
+        continue;
+        /* if it's a color read the color, set the current color and
+           continue */
+      } else if (!strcasecmp(buff, "@color")
+                 && owl_global_is_colorztext(&g)) {
+        g_free(buff);
+        txtptr+=7;
+        tmpptr=strpbrk(txtptr, "@{[<()>]}");
+        if (tmpptr &&
+            ((txtptr[-1]=='(' && tmpptr[0]==')') ||
+             (txtptr[-1]=='<' && tmpptr[0]=='>') ||
+             (txtptr[-1]=='[' && tmpptr[0]==']') ||
+             (txtptr[-1]=='{' && tmpptr[0]=='}'))) {
+          /* grab the color name */
+          buff=g_new(char, tmpptr-txtptr+20);
+          strncpy(buff, txtptr, tmpptr-txtptr);
+          buff[tmpptr-txtptr]='\0';
+          /* set it as the current color */
+          curcolor=owl_util_string_to_color(buff);
+          if (curcolor == OWL_COLOR_INVALID)
+              curcolor = OWL_COLOR_DEFAULT;
+          g_free(buff);
+          txtptr=tmpptr+1;
+          continue;
+        } else {
+        }
+      } else {
+        /* if we didn't understand it, we'll print it.  This is different from zwgc
+         * but zwgc seems to be smarter about some screw cases than I am
+         */
+        g_free(buff);
+        owl_fmtext_append_attr(f, "@", curattrs, curcolor, OWL_COLOR_DEFAULT);
+        txtptr++;
+        continue;
+      }
+    } else if (ptr[0]=='}' || ptr[0]==']' || ptr[0]==')' || ptr[0]=='>') {
+      /* add the text up to this point first */
+      buff=g_new(char, ptr-txtptr+20);
+      strncpy(buff, txtptr, ptr-txtptr);
+      buff[ptr-txtptr]='\0';
+      owl_fmtext_append_attr(f, buff, curattrs, curcolor, OWL_COLOR_DEFAULT);
+      g_free(buff);
+      /* now deal with the closer */
+      txtptr=ptr;
+      /* first, if the stack is empty we must bail (just print and go) */
+      if (stacksize==0) {
+        buff=g_new(char, 5);
+        buff[0]=ptr[0];
+        buff[1]='\0';
+        owl_fmtext_append_attr(f, buff, curattrs, curcolor, OWL_COLOR_DEFAULT);
+        g_free(buff);
+        txtptr++;
+        continue;
+      }
+      /* if the closing char is what's on the stack, turn off the
+         attribue and pop the stack */
+      if ((ptr[0]==')' && chrstack[stacksize-1]=='(') ||
+          (ptr[0]=='>' && chrstack[stacksize-1]=='<') ||
+          (ptr[0]==']' && chrstack[stacksize-1]=='[') ||
+          (ptr[0]=='}' && chrstack[stacksize-1]=='{')) {
+        int i;
+        stacksize--;
+        curattrs=OWL_FMTEXT_ATTR_NONE;
+        curcolor = colorstack[stacksize];
+        for (i=0; i<stacksize; i++) {
+          curattrs|=attrstack[i];
+        }
+        txtptr+=1;
+        continue;
+      } else {
+        /* otherwise print and continue */
+        buff=g_new(char, 5);
+        buff[0]=ptr[0];
+        buff[1]='\0';
+        owl_fmtext_append_attr(f, buff, curattrs, curcolor, OWL_COLOR_DEFAULT);
+        g_free(buff);
+        txtptr++;
+        continue;
+      }
+    } else {
+      /* we've found an unattached opener, print everything and move on */
+      buff=g_new(char, ptr-txtptr+20);
+      strncpy(buff, txtptr, ptr-txtptr+1);
+      buff[ptr-txtptr+1]='\0';
+      owl_fmtext_append_attr(f, buff, curattrs, curcolor, OWL_COLOR_DEFAULT);
+      g_free(buff);
+      txtptr=ptr+1;
+      continue;
+    }
+  }
+}
+  ztext_env *tree = ztext_tree(text);
+  owl_fmtext_append_ztext_tree(f, tree,
+                               OWL_FMTEXT_ATTR_NONE, OWL_COLOR_DEFAULT);
+  ztext_env_free(tree);
+}
 /* requires that the list values are strings or NULL.

owl.h

r4fd3c04	r8861654
62	62
63	63	#include "window.h"
	64	#include "ztext.h"
64	65
65	66	extern const char *version;

perl/lib/BarnOwl.pm

-                      reea7bed4
+                      r8861654
 =head2 ztext_stylestrip STRING
+Strips zephyr formatting from a string and returns the result
+Strips zephyr formatting barnowl understands from a string and returns the result
+=head2 ztext_stylestrip_full STRING
+Strips all the zephyr formatting from a string an returns the reuslt
+=head2 ztext_protect STRING
+Massage zephyr formatting to make it not interfere with more zephyr formatting.
 =head2 zephyr_getsubs

perl/lib/BarnOwl/Style.pm

-                      rfd8dfe7
+                      ra13ad6f
+{
     local $_ = shift;
+    if ( !(/\)/) ) {
+        return '@b(' . $_ . ')';
+    } elsif ( !(/\>/) ) {
+        return '@b<' . $_ . '>';
+    } elsif ( !(/\}/) ) {
+        return '@b{' . $_ . '}';
+    } elsif ( !(/\]/) ) {
+        return '@b[' . $_ . ']';
+    } else {
+        my $txt = "\@b($_";
+        $txt =~ s/\)/\)\@b\[\)\]\@b\(/g;
+        return $txt . ')';
+    }
+    return '@b{' . BarnOwl::ztext_protect($_) . '}'
+}

perlglue.xs

-                      rd2ba33c
+                      r8861654
 const utf8 *
+ztext_protect(ztext)
+        const char *ztext
+        PREINIT:
+                char *rv = NULL;
+        CODE:
+                rv = ztext_protect(ztext);
+                RETVAL = rv;
+        OUTPUT:
+                RETVAL
+        CLEANUP:
+                g_free(rv);
+const utf8 *
+ztext_stylestrip_full(ztext)
+        const char *ztext
+        PREINIT:
+                char *rv = NULL;
+        CODE:
+                ztext_env *tree = ztext_tree(ztext);
+                rv = ztext_strip(tree);
+                ztext_env_free(tree);
+                RETVAL = rv;
+        OUTPUT:
+                RETVAL
+        CLEANUP:
+                g_free(rv);
+const utf8 *
 zephyr_smartstrip_user(in)
         const char *in

tester.c

-                      ra882637
+                      r8861654
 int call_filter_regtest(void);
 int owl_smartstrip_regtest(void);
+int ztext_test(void);
 extern void owl_perl_xs_init(pTHX);
 …
   numfailures += call_filter_regtest();
   numfailures += owl_smartstrip_regtest();
+  numfailures += ztext_test();
   if (numfailures) {
       fprintf(stderr, "# *** WARNING: %d failures total\n", numfailures);
 …
   return numfailed;
+}
+static char *ztext_str(ztext_env *tree)
+{
+    /* Unambiguous representation of the parse tree */
+    char *s, *t, *u;
+    if (tree->opener) {
+        s = g_strdup_printf("{'%s%c'", tree->label, tree->opener);
+    } else {
+        s = g_strdup("{-");
+    }
+    for (ztext_node *p = tree->content; p != NULL; p = p->next) {
+        t = s;
+        if (p->type== ZTEXT_NODE_STRING) {
+            s = g_strdup_printf("%s |%s|", s, p->string);
+        } else if (p->type == ZTEXT_NODE_ENV) {
+            u = ztext_str(p->env);
+            s = g_strconcat(s, " ", u, NULL);
+            g_free(u);
+        }
+        g_free(t);
+    }
+    t = s;
+    if (tree->closer) {
+        s = g_strdup_printf("%s '%c'}", s, tree->closer);
+    } else {
+        s = g_strconcat(s, "}", NULL);
+    }
+    g_free(t);
+    return s;
+}
+char *ztext_ztext(ztext_env *tree)
+{
+    char *s, *t, *u;
+    if (tree->closer == '@' && tree->content == NULL)
+        return g_strdup("@@");
+    if (tree->opener) {
+        s = g_strdup_printf("%s%c", tree->label, tree->opener);
+    } else {
+        s = g_strdup("");
+    }
+    for (ztext_node *p = tree->content; p != NULL; p = p->next) {
+        t = s;
+        if (p->type == ZTEXT_NODE_STRING) {
+            s = g_strconcat(s, p->string, NULL);
+        } else if (p->type == ZTEXT_NODE_ENV) {
+            u = ztext_ztext(p->env);
+            s = g_strconcat(s, u, NULL);
+            g_free(u);
+        }
+        g_free(t);
+    }
+    if (tree->closer) {
+        t = s;
+        s = g_strdup_printf("%s%c", s, tree->closer);
+        g_free(t);
+    }
+    return s;
+}
+int ztext_test(void)
+{
+    int numfailed = 0;
+    char *s;
+    ztext_env *t;
+    char *d;
+#define CHECK_ZTEXT_STR(in, expected)                                         \
+    do {                                                                      \
+      t = ztext_tree(in);                                                     \
+      s = ztext_str(t);                                                       \
+      d = g_strdup_printf("ztext decode \"%s\" expected \"%s\" got \"%s\"",   \
+                          in, expected, s);                                   \
+      FAIL_UNLESS(d, !strcmp(s, expected));                                   \
+      ztext_env_free(t);                                                      \
+      g_free(d);                                                              \
+      g_free(s);                                                              \
+    } while (0)
+    CHECK_ZTEXT_STR("", "{-}");
+    CHECK_ZTEXT_STR("foo", "{- |foo|}");
+    CHECK_ZTEXT_STR("@{foo}", "{- {'@{' |foo| '}'}}");
+    CHECK_ZTEXT_STR("@bar{foo}", "{- {'@bar{' |foo| '}'}}");
+    CHECK_ZTEXT_STR("@bar{foo@bar}", "{- {'@bar{' |foo@bar| '}'}}");
+    CHECK_ZTEXT_STR("@bar{foo@@bar}", "{- {'@bar{' |foo| {'@@' '@'} |bar| '}'}}");
+    CHECK_ZTEXT_STR("@{foo@}bar}baz", "{- {'@{' |foo@| '}'} |bar}baz|}");
+    CHECK_ZTEXT_STR("foo@bar{baz@(bang})}",
+                    "{- |foo| {'@bar{' |baz| {'@(' |bang}| ')'} '}'}}");
+    CHECK_ZTEXT_STR("foo@bar{baz}", "{- |foo| {'@bar{' |baz| '}'}}");
+    CHECK_ZTEXT_STR("@bloop", "{- |@bloop|}");
+    CHECK_ZTEXT_STR("@{)}@{>}", "{- {'@{' |)| '}'} {'@{' |>| '}'}}");
+#define CHECK_ZTEXT_STRIP(in, expected)                                      \
+    do {                                                                     \
+      t = ztext_tree(in);                                                    \
+      s = ztext_strip(t);                                                    \
+      d = g_strdup_printf("ztext strip \"%s\" expected \"%s\" got \"%s\"",   \
+                          in, expected, s);                                  \
+      FAIL_UNLESS(d, !strcmp(s, expected));                                  \
+      ztext_env_free(t);                                                     \
+      g_free(d);                                                             \
+      g_free(s);                                                             \
+    } while (0)
+    CHECK_ZTEXT_STRIP("", "");
+    CHECK_ZTEXT_STRIP("foo", "foo");
+    CHECK_ZTEXT_STRIP("@{foo}", "foo");
+    CHECK_ZTEXT_STRIP("@bar{foo}", "foo");
+    CHECK_ZTEXT_STRIP("@bar{foo@bar}", "foo@bar");
+    CHECK_ZTEXT_STRIP("@bar{foo@@bar}", "foo@bar");
+    CHECK_ZTEXT_STRIP("@{foo@}bar}baz", "foo@bar}baz");
+    CHECK_ZTEXT_STRIP("foo@bar{baz@(bang})}", "foobazbang}");
+    CHECK_ZTEXT_STRIP("foo@bar{baz}", "foobaz");
+    CHECK_ZTEXT_STRIP("@bloop", "@bloop");
+    CHECK_ZTEXT_STRIP("@{)}@{>}", ")>");
+    CHECK_ZTEXT_STRIP("@color(blue)@font(fixed)marzipan", "marzipan");
+#define CHECK_ZTEXT_RT(in)                                                \
+    do {                                                                  \
+      t = ztext_tree(in);                                                 \
+      s = ztext_ztext(t);                                                 \
+      d = g_strdup_printf("ztext round-trip \"%s\" got \"%s\"", in, s);   \
+      FAIL_UNLESS(d, !strcmp(s, in));                                     \
+      ztext_env_free(t);                                                  \
+      g_free(s);                                                          \
+    } while (0)
+    CHECK_ZTEXT_RT("");
+    CHECK_ZTEXT_RT("foo");
+    CHECK_ZTEXT_RT("@{foo}");
+    CHECK_ZTEXT_RT("@bar{foo}");
+    CHECK_ZTEXT_RT("@bar{foo@bar}");
+    CHECK_ZTEXT_RT("@bar{foo@@bar}");
+    CHECK_ZTEXT_RT("@{foo@}bar}baz");
+    CHECK_ZTEXT_RT("foo@bar{baz@(bang})}");
+    CHECK_ZTEXT_RT("foo@bar{baz}");
+    CHECK_ZTEXT_RT("@bloop");
+    CHECK_ZTEXT_RT("@{)}@{>}");
+    /* fuzzzzzz */
+    srand48(getpid() + time(0));
+    char tango[32];
+    const char CHARS[] = "@abc ({<[]>})";
+    for(int i=0; i < 1000; i++) {
+        memset(tango, 0, sizeof(tango));
+        int l = lrand48() % sizeof(tango);
+        for (int j=0; j < l; j++) {
+            tango[j] = CHARS[lrand48() % (sizeof(CHARS) -1)];
+        }
+        CHECK_ZTEXT_RT(tango);
+    }
+#define CHECK_ZTEXT_PROTECT(in, expected)                                     \
+    do {                                                                      \
+      s = ztext_protect(in);                                                  \
+      d = g_strdup_printf("ztext protect \"%s\" expected \"%s\" got \"%s\"",  \
+                          in, expected, s);                                   \
+      FAIL_UNLESS(d, !strcmp(s, expected));                                   \
+      g_free(d);                                                              \
+      g_free(s);                                                              \
+    } while (0)
+    CHECK_ZTEXT_PROTECT("", "");
+    CHECK_ZTEXT_PROTECT("foo", "foo");
+    CHECK_ZTEXT_PROTECT("fo}o", "fo@(})o");
+    CHECK_ZTEXT_PROTECT("@[foo", "@[foo]");
+    CHECK_ZTEXT_PROTECT("})>]", "@(})@<)>@[>]@{]}");
+    return numfailed;
+}

ChangeLog

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

codelist.pl

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

commands.c

-                      r8fcd3e7
+                      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"
 …
           "no argument, it makes search highlighting inactive."),
-  OWLCMD_ARGS("aimlogin", owl_command_aimlogin, OWL_CTX_ANY,
-              "login to an AIM account",
-              "aimlogin <screenname> [<password>]\n",
-              ""),
-  OWLCMD_ARGS("aimlogout", owl_command_aimlogout, OWL_CTX_ANY,
-              "logout from AIM",
-              "aimlogout\n",
-              ""),
   OWLCMD_ARGS("error", owl_command_error, OWL_CTX_ANY,
               "Display an error message",
 …
+    }
+  }
   owl_function_buddylist(0, 1, file);
+  owl_function_buddylist(1, file);
   return(NULL);
+}
-void owl_command_alist(void)
+{
-  owl_function_buddylist(1, 0, NULL);
+}
 void owl_command_blist(void)
+{
   owl_function_buddylist(1, 1, NULL);
+  owl_function_buddylist(1, NULL);
+}
 …
+{
   owl_function_makemsg("BarnOwl version %s", version);
+}
-char *owl_command_aim(int argc, const char *const *argv, const char *buff)
+{
-  if (argc<2) {
-    owl_function_makemsg("not enough arguments to aim command");
-    return(NULL);
+  }
-  if (!strcmp(argv[1], "search")) {
-    if (argc!=3) {
-      owl_function_makemsg("not enough arguments to aim search command");
-      return(NULL);
+    }
-    owl_aim_search(argv[2]);
-  } else {
-    owl_function_makemsg("unknown subcommand '%s' for aim command", argv[1]);
-    return(NULL);
+  }
-  return(NULL);
+}
 …
+  }
+  if (!strcasecmp(argv[1], "aim")) {
+    if (!owl_global_is_aimloggedin(&g)) {
+      owl_function_makemsg("addbuddy: You must be logged into aim to use this command.");
+      return(NULL);
+    }
+    /*
+    owl_function_makemsg("This function is not yet operational.  Stay tuned.");
+    return(NULL);
+    */
+    owl_aim_addbuddy(argv[2]);
+    owl_function_makemsg("%s added as AIM buddy for %s", argv[2], owl_global_get_aim_screenname(&g));
+  } else if (!strcasecmp(argv[1], "zephyr")) {
+  if (!strcasecmp(argv[1], "zephyr")) {
     owl_zephyr_addbuddy(argv[2]);
     owl_function_makemsg("%s added as zephyr buddy", argv[2]);
   } else {
     owl_function_makemsg("addbuddy: currently the only supported protocols are 'zephyr' and 'aim'");
+    owl_function_makemsg("addbuddy: currently the only supported protocol is 'zephyr'");
+  }
 …
+  }
+  if (!strcasecmp(argv[1], "aim")) {
+    if (!owl_global_is_aimloggedin(&g)) {
+      owl_function_makemsg("delbuddy: You must be logged into aim to use this command.");
+      return(NULL);
+    }
+    owl_aim_delbuddy(argv[2]);
+    owl_function_makemsg("%s deleted as AIM buddy for %s", argv[2], owl_global_get_aim_screenname(&g));
+  } else if (!strcasecmp(argv[1], "zephyr")) {
+  if (!strcasecmp(argv[1], "zephyr")) {
     owl_zephyr_delbuddy(argv[2]);
     owl_function_makemsg("%s deleted as zephyr buddy", argv[2]);
   } else {
+    owl_function_makemsg("delbuddy: currently the only supported protocols are 'zephyr' and 'aim'");
+  }
+  return(NULL);
+}
+char *owl_command_join(int argc, const char *const *argv, const char *buff)
+{
+  if (argc!=3 && argc!=4) {
+    owl_function_makemsg("usage: join <protocol> <buddyname> [exchange]");
+    return(NULL);
+  }
+  if (!strcasecmp(argv[1], "aim")) {
+    if (!owl_global_is_aimloggedin(&g)) {
+      owl_function_makemsg("join aim: You must be logged into aim to use this command.");
+      return(NULL);
+    }
+    if (argc==3) {
+      owl_aim_chat_join(argv[2], 4);
+    } else {
+      owl_aim_chat_join(argv[2], atoi(argv[3]));
+    }
+    /* owl_function_makemsg("%s deleted as AIM buddy for %s", argv[2], owl_global_get_aim_screenname(&g)); */
+  } else {
+    owl_function_makemsg("join: currently the only supported protocol is 'aim'");
+  }
+    owl_function_makemsg("delbuddy: currently the only supported protocol is 'zephyr'");
+  }
   return(NULL);
+}
 …
+}
+char *owl_command_flushlogs(int argc, const char *const *argv, const char *buff)
+{
+  bool force = false;
+  bool quiet = false;
+  int i;
+  for (i = 1; i < argc; i++) {
+    if (!strcmp(argv[i], "-f") || !strcmp(argv[i], "--force")) {
+      force = true;
+    } else if (!strcmp(argv[i], "-q") || !strcmp(argv[i], "--quiet")) {
+      quiet = true;
+    } else {
+      owl_function_makemsg("Invalid flag to flush-logs: %s", argv[i]);
+    }
+  }
+  owl_log_flush_logs(force, quiet);
+  return NULL;
+}
 char *owl_command_loadsubs(int argc, const char *const *argv, const char *buff)
+{
 …
-char *owl_command_aaway(int argc, const char *const *argv, const char *buff)
+{
-  if ((argc==1) ||
-      ((argc==2) && !strcmp(argv[1], "on"))) {
-    owl_global_set_aaway_msg(&g, owl_global_get_aaway_msg_default(&g));
-    owl_function_aaway_on();
-    return NULL;
+  }
-  if (argc==2 && !strcmp(argv[1], "off")) {
-    owl_function_aaway_off();
-    return NULL;
+  }
-  if (argc==2 && !strcmp(argv[1], "toggle")) {
-    owl_function_aaway_toggle();
-    return NULL;
+  }
-  buff = skiptokens(buff, 1);
-  owl_global_set_aaway_msg(&g, buff);
-  owl_function_aaway_on();
-  return NULL;
+}
 char *owl_command_away(int argc, const char *const *argv, const char *buff)
+{
 …
       (argc == 2 && !strcmp(argv[1], "on"))) {
     away_off = false;
-    owl_global_set_aaway_msg(&g, owl_global_get_aaway_msg_default(&g));
     owl_global_set_zaway_msg(&g, owl_global_get_zaway_msg_default(&g));
   } else if (argc == 2 && !strcmp(argv[1], "off")) {
 …
   if (away_off) {
-    owl_function_aaway_off();
     owl_function_zaway_off();
     owl_perlconfig_perl_call_norv("BarnOwl::Hooks::_away_off", 0, NULL);
     owl_function_makemsg("Away messages off.");
   } else if (message != NULL) {
-    owl_global_set_aaway_msg(&g, message);
     owl_global_set_zaway_msg(&g, message);
-    owl_function_aaway_on();
     owl_function_zaway_on();
     owl_perlconfig_perl_call_norv("BarnOwl::Hooks::_away_on", 1, &message);
     owl_function_makemsg("Away messages set (%s).", message);
   } else {
-    owl_function_aaway_on();
     owl_function_zaway_on();
     owl_perlconfig_perl_call_norv("BarnOwl::Hooks::_away_on", 0, NULL);
 …
+  }
   return(NULL);
+}
-char *owl_command_aimwrite(int argc, const char *const *argv, const char *buff)
+{
-  char *message = NULL;
-  GString *recip = g_string_new("");
-  const char *const *myargv;
-  int myargc;
-  if (!owl_global_is_aimloggedin(&g)) {
-    owl_function_error("You are not logged in to AIM.");
-    goto err;
+  }
-  /* Skip argv[0]. */
-  myargv = argv+1;
-  myargc = argc-1;
-  while (myargc) {
-    if (!strcmp(myargv[0], "-m")) {
-      if (myargc <= 1) {
-        owl_function_error("No message specified.");
-        goto err;
+      }
-      /* Once we have -m, gobble up everything else on the line */
-      myargv++;
-      myargc--;
-      message = g_strjoinv(" ", (char**)myargv);
-      break;
-    } else {
-      /* squish arguments together to make one screenname w/o spaces for now */
-      g_string_append(recip, myargv[0]);
-      myargv++;
-      myargc--;
+    }
+  }
-  if (recip->str[0] == '\0') {
-    owl_function_error("No recipient specified");
-    goto err;
+  }
-  if (message != NULL)
-    owl_function_aimwrite(recip->str, message, false);
-  else
-    owl_function_aimwrite_setup(recip->str);
- err:
-  g_string_free(recip, true);
-  g_free(message);
-  return NULL;
+}
 …
+}
-char *owl_command_aimlogin(int argc, const char *const *argv, const char *buff)
+{
-  if ((argc<2) || (argc>3)) {
-    owl_function_makemsg("Wrong number of arguments to aimlogin command");
-    return(NULL);
+  }
-  /* if we get two arguments, ask for the password */
-  if (argc==2) {
-    owl_editwin *e = owl_function_start_password("AIM Password: ");
-    owl_editwin_set_cbdata(e, g_strdup(argv[1]), g_free);
-    owl_editwin_set_callback(e, owl_callback_aimlogin);
-    return(NULL);
-  } else {
-    owl_function_aimlogin(argv[1], argv[2]);
+  }
-  /* this is a test */
-  return(NULL);
+}
-char *owl_command_aimlogout(int argc, const char *const *argv, const char *buff)
+{
-  /* clear the buddylist */
-  owl_buddylist_clear(owl_global_get_buddylist(&g));
-  owl_aim_logout();
-  return(NULL);
+}
 CALLER_OWN char *owl_command_getstyle(int argc, const char *const *argv, const char *buff)
+{

configure.ac

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

doc/advanced.txt

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

doc/intro.txt

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

filter.c

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

filterproc.c

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

functions.c

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

global.c

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

help.c

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

keys.c

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

logging.c

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

message.c

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

owl.c

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

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/Complete/Client.pm

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

perl/lib/BarnOwl/Complete/Filter.pm

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

perl/lib/BarnOwl/Message.pm

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

perl/lib/BarnOwl/Message/Loopback.pm

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

perl/lib/BarnOwl/Message/Zephyr.pm

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

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

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

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

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

perl/modules/Makefile.am

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

perlconfig.c

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

scripts/do-release

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

t/completion.t

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

util.c

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

variable.c

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

zcrypt.c

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

zephyr.c

-                      rff58239
+                      ree6b30f
   FILE *file;
   int fopen_errno;
   char *tmp, *start;
+  char *tmp, *start, *saveptr;
   char *buffer = NULL;
   char *subsfile;
 …
     /* add it to the list of subs */
     if ((tmp = strtok(start, ",\n\r")) == NULL)
+    if ((tmp = strtok_r(start, ",\n\r", &saveptr)) == NULL)
       continue;
     subs[count].zsub_class = g_strdup(tmp);
     if ((tmp=strtok(NULL, ",\n\r")) == NULL)
+    if ((tmp = strtok_r(NULL, ",\n\r", &saveptr)) == NULL)
       continue;
     subs[count].zsub_classinst = g_strdup(tmp);
     if ((tmp = strtok(NULL, " \t\n\r")) == NULL)
+    if ((tmp = strtok_r(NULL, " \t\n\r", &saveptr)) == NULL)
       continue;
     subs[count].zsub_recipient = g_strdup(tmp);

zwrite.c

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

Context Navigation

Legend:

Download in other formats: