Changeset 4f6097e

.gitignore

-                      rf93cc34
+                      r1c22155
 *.o
 *.par
-*~
-.#*
-.*.swp
 .deps
+/bin/
 META.yml
+MYMETA.yml
 Makefile
 Makefile.in
 Makefile.old
 TAGS
-\#*#
 aclocal.m4
 autom4te.cache
+barnowl.bin
+tester.bin
+zcrypt
+barnowl
 blib
 config.cache
 config.h
 config.h.in
+config.h.in~
 config.log
 config.status
 …
 core
 depcomp
+gmarshal_funcs.c
+gmarshal_funcs.h
+inc/
 install-sh
 jabber.log
 …
 owl_prototypes.h.new
 perlglue.c
-perlwrap.c
 pm_to_blib
+runtests.sh.log
+runtests.sh.trs
 stamp-h1
+test-driver
+test-suite.log
+tester
 varstubs.c
+zcrypt

AUTHORS

-                      r1d2c4c3
+                      r80c0fc7
 The following people have provided patches or other contributions:
+  Alex Vandiver
+  Kevin Chen
+  Arun Tharuvai
   Sam Hartman
-  Alex Vandiver
-  Geoffrey Thomas
   Derrick Brashear
   David Glasser
+  Eric Price
   Matthew Goldstein
+  Arun Tharuvai
+  Kevin Chen
+  Eric Price
+  Geoffrey Thomas
+  Anders Kaseorg
+  Greg Price
+  Chris Lesniewski-Laas
+  Alex Dehnert
+  Edward Z. Yang
+  Karl Ramm
+  Evan Broder
+  David Benjamin
+  Cathy Zhang
+  Joshua Oreman
+  Leonid Grinberg
+  Kevin Riggle
+  Brian Sniffen
+  William Throwe
+  Jason Gross
+  Adam Glasgall
+  Tim Hill
+  DD Liu
+  Betsy Riley
+  Robert Jacobs
 BarnOwl is based on code from Owl, which was originally primarly
+BarnOwl is based on code from Owl, which was originally primarily
 written by James Kretchmar.  Erik Nygren also made substantial
 contributions and improvemnts to the program.
+contributions and improvements to the program.
 The following people provided patches and other techincal support for
+The following people provided patches and other technical support for
 Owl:
 …
   Mark Eichin
 Mark Eichin is also maintaining the debian package of Owl.
+Mark Eichin is also maintaining the Debian package of Owl.
 The following people helped with beta testing the earliest versions of

COPYING

-                      rb03c714
+                      rccc182c
 That's all there is to it!
+======================================================================
+Files under perl/modules/Facebook/lib/Facebook are copyright (c) 2010 Plain
+Black Corporation.
+This software is copyright (c) 2010 by Plain Black Corporation.
+This is free software; you can redistribute it and/or modify it under
+the same terms as the Perl 5 programming language system itself.
+Terms of the Perl programming language system itself
+a) the GNU General Public License as published by the Free
+   Software Foundation; either version 1, or (at your option) any
+   later version, or
+b) the "Artistic License"
+--- The GNU General Public License, Version 1, February 1989 ---
+This software is Copyright (c) 2010 by Plain Black Corporation.
+This is free software, licensed under:
+  The GNU General Public License, Version 1, February 1989
+                    GNU GENERAL PUBLIC LICENSE
+                     Version 1, February 1989
+ Copyright (C) 1989 Free Software Foundation, Inc.
+Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+                            Preamble
+  The license agreements of most software companies try to keep users
+at the mercy of those companies.  By contrast, our General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  The
+General Public License applies to the Free Software Foundation's
+software and to any other program whose authors commit to using it.
+You can use it for your programs, too.
+  When we speak of free software, we are referring to freedom, not
+price.  Specifically, the General Public License is designed to make
+sure that you have the freedom to give away or sell copies of free
+software, that you receive source code or can get it if you want it,
+that you can change the software or use pieces of it in new free
+programs; and that you know you can do these things.
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+  For example, if you distribute copies of a such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must tell them their rights.
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+  The precise terms and conditions for copying, distribution and
+modification follow.
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+. This License Agreement applies to any program or other work which
+contains a notice placed by the copyright holder saying it may be
+distributed under the terms of this General Public License.  The
+"Program", below, refers to any such program or work, and a "work based
+on the Program" means either the Program or any work containing the
+Program or a portion of it, either verbatim or with modifications.  Each
+licensee is addressed as "you".
+. You may copy and distribute verbatim copies of the Program's source
+code as you receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice and
+disclaimer of warranty; keep intact all the notices that refer to this
+General Public License and to the absence of any warranty; and give any
+other recipients of the Program a copy of this General Public License
+along with the Program.  You may charge a fee for the physical act of
+transferring a copy.
+. You may modify your copy or copies of the Program or any portion of
+it, and copy and distribute such modifications under the terms of Paragraph
+above, provided that you also do the following:
+    a) cause the modified files to carry prominent notices stating that
+    you changed the files and the date of any change; and
+    b) cause the whole of any work that you distribute or publish, that
+    in whole or in part contains the Program or any part thereof, either
+    with or without modifications, to be licensed at no charge to all
+    third parties under the terms of this General Public License (except
+    that you may choose to grant warranty protection to some or all
+    third parties, at your option).
+    c) If the modified program normally reads commands interactively when
+    run, you must cause it, when started running for such interactive use
+    in the simplest and most usual way, to print or display an
+    announcement including an appropriate copyright notice and a notice
+    that there is no warranty (or else, saying that you provide a
+    warranty) and that users may redistribute the program under these
+    conditions, and telling the user how to view a copy of this General
+    Public License.
+    d) You may charge a fee for the physical act of transferring a
+    copy, and you may at your option offer warranty protection in
+    exchange for a fee.
+Mere aggregation of another independent work with the Program (or its
+derivative) on a volume of a storage or distribution medium does not bring
+the other work under the scope of these terms.
+. You may copy and distribute the Program (or a portion or derivative of
+it, under Paragraph 2) in object code or executable form under the terms of
+Paragraphs 1 and 2 above provided that you also do one of the following:
+    a) accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of
+    Paragraphs 1 and 2 above; or,
+    b) accompany it with a written offer, valid for at least three
+    years, to give any third party free (except for a nominal charge
+    for the cost of distribution) a complete machine-readable copy of the
+    corresponding source code, to be distributed under the terms of
+    Paragraphs 1 and 2 above; or,
+    c) accompany it with the information you received as to where the
+    corresponding source code may be obtained.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form alone.)
+Source code for a work means the preferred form of the work for making
+modifications to it.  For an executable file, complete source code means
+all the source code for all modules it contains; but, as a special
+exception, it need not include source code for modules which are standard
+libraries that accompany the operating system on which the executable
+file runs, or for standard header files or definitions files that
+accompany that operating system.
+. You may not copy, modify, sublicense, distribute or transfer the
+Program except as expressly provided under this General Public License.
+Any attempt otherwise to copy, modify, sublicense, distribute or transfer
+the Program is void, and will automatically terminate your rights to use
+the Program under this License.  However, parties who have received
+copies, or rights to use copies, from you under this General Public
+License will not have their licenses terminated so long as such parties
+remain in full compliance.
+. By copying, distributing or modifying the Program (or any work based
+on the Program) you indicate your acceptance of this license to do so,
+and all its terms and conditions.
+. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the original
+licensor to copy, distribute or modify the Program subject to these
+terms and conditions.  You may not impose any further restrictions on the
+recipients' exercise of the rights granted herein.
+. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of the license which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+the license, you may choose any version ever published by the Free Software
+Foundation.
+. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+                            NO WARRANTY
+. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+                     END OF TERMS AND CONDITIONS
+        Appendix: How to Apply These Terms to Your New Programs
+  If you develop a new program, and you want it to be of the greatest
+possible use to humanity, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these
+terms.
+  To do so, attach the following notices to the program.  It is safest to
+attach them to the start of each source file to most effectively convey
+the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) 19yy  <name of author>
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 1, or (at your option)
+    any later version.
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA  02110-1301 USA
+Also add information on how to contact you by electronic and paper mail.
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+    Gnomovision version 69, Copyright (C) 19xx name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+The hypothetical commands `show w' and `show c' should show the
+appropriate parts of the General Public License.  Of course, the
+commands you use may be called something other than `show w' and `show
+c'; they could even be mouse-clicks or menu items--whatever suits your
+program.
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here a sample; alter the names:
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  program `Gnomovision' (a program to direct compilers to make passes
+  at assemblers) written by James Hacker.
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+That's all there is to it!
+--- The Artistic License 1.0 ---
+This software is Copyright (c) 2010 by Plain Black Corporation.
+This is free software, licensed under:
+  The Artistic License 1.0
+The Artistic License
+Preamble
+The intent of this document is to state the conditions under which a Package
+may be copied, such that the Copyright Holder maintains some semblance of
+artistic control over the development of the package, while giving the users of
+the package the right to use and distribute the Package in a more-or-less
+customary fashion, plus the right to make reasonable modifications.
+Definitions:
+  - "Package" refers to the collection of files distributed by the Copyright
+    Holder, and derivatives of that collection of files created through
+    textual modification.
+  - "Standard Version" refers to such a Package if it has not been modified,
+    or has been modified in accordance with the wishes of the Copyright
+    Holder.
+  - "Copyright Holder" is whoever is named in the copyright or copyrights for
+    the package.
+  - "You" is you, if you're thinking about copying or distributing this Package.
+  - "Reasonable copying fee" is whatever you can justify on the basis of media
+    cost, duplication charges, time of people involved, and so on. (You will
+    not be required to justify it to the Copyright Holder, but only to the
+    computing community at large as a market that must bear the fee.)
+  - "Freely Available" means that no fee is charged for the item itself, though
+    there may be fees involved in handling the item. It also means that
+    recipients of the item may redistribute it under the same conditions they
+    received it.
+. You may make and give away verbatim copies of the source form of the
+Standard Version of this Package without restriction, provided that you
+duplicate all of the original copyright notices and associated disclaimers.
+. You may apply bug fixes, portability fixes and other modifications derived
+from the Public Domain or from the Copyright Holder. A Package modified in such
+a way shall still be considered the Standard Version.
+. You may otherwise modify your copy of this Package in any way, provided that
+you insert a prominent notice in each changed file stating how and when you
+changed that file, and provided that you do at least ONE of the following:
+  a) place your modifications in the Public Domain or otherwise make them
+     Freely Available, such as by posting said modifications to Usenet or an
+     equivalent medium, or placing the modifications on a major archive site
+     such as ftp.uu.net, or by allowing the Copyright Holder to include your
+     modifications in the Standard Version of the Package.
+  b) use the modified Package only within your corporation or organization.
+  c) rename any non-standard executables so the names do not conflict with
+     standard executables, which must also be provided, and provide a separate
+     manual page for each non-standard executable that clearly documents how it
+     differs from the Standard Version.
+  d) make other distribution arrangements with the Copyright Holder.
+. You may distribute the programs of this Package in object code or executable
+form, provided that you do at least ONE of the following:
+  a) distribute a Standard Version of the executables and library files,
+     together with instructions (in the manual page or equivalent) on where to
+     get the Standard Version.
+  b) accompany the distribution with the machine-readable source of the Package
+     with your modifications.
+  c) accompany any non-standard executables with their corresponding Standard
+     Version executables, giving the non-standard executables non-standard
+     names, and clearly documenting the differences in manual pages (or
+     equivalent), together with instructions on where to get the Standard
+     Version.
+  d) make other distribution arrangements with the Copyright Holder.
+. You may charge a reasonable copying fee for any distribution of this
+Package.  You may charge any fee you choose for support of this Package. You
+may not charge a fee for this Package itself. However, you may distribute this
+Package in aggregate with other (possibly commercial) programs as part of a
+larger (possibly commercial) software distribution provided that you do not
+advertise this Package as a product of your own.
+. The scripts and library files supplied as input to or produced as output
+from the programs of this Package do not automatically fall under the copyright
+of this Package, but belong to whomever generated them, and may be sold
+commercially, and may be aggregated with this Package.
+. C or perl subroutines supplied by you and linked into this Package shall not
+be considered part of this Package.
+. The name of the Copyright Holder may not be used to endorse or promote
+products derived from this software without specific prior written permission.
+. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+The End

ChangeLog

-                      r2ff0693
+                      r1b17f50
+.9
+ * Add getnumlines() to perl interface -asedeno@mit.edu
+ * Include names of invalid filters on filter errors -adehnert@mit.edu
+ * Don't incorrectly mark decryption failures as decrypted -davidben@mit.edu
+ * Hide the default cursor when possible -davidben@mit.edu
+ * Complete viewperson and vp as viewuser and vu -davidben@mit.edu
+ * Set z_charset = ZCHARSET_UTF_8 -andersk@mit.edu
+ * Allow zsender spoofing on cross-realm classes -andersk@mit.edu
+ * Append the realm to the zsender if missing -andersk@mit.edu
+ * Redisplay on setting colorztext -jgross@mit.edu
+ * Rename default config file to .owl/init.pl -kevinr@free-dissociation.com
+ * Add completion for jabberlogout -adehnert@mit.edu
+ * Switch to interactive context before sourcing the startup file -davidben@mit.edu
+ * Add completion for reload-module -adehnert@mit.edu
+ * editwin callback for canceling the editwin -jgross@mit.edu
+ * Fix dirtying windows inside a redraw handler -davidben@mit.edu
+ * Facebook module -ezyang@mit.edu
+ * Complete unstartup command just like startup command -jgross@mit.edu
+ * Fix the description of disable-ctrl-d -jgross@mit.edu
+ * Use wbkgrndset instead of wbkgdset in _owl_fmtext_wcolor_set -davidben@mit.edu
+ * Show the time zone in :info -jgross@mit.edu
+ * Treat [!.?]" as end of sentence in edit:fill-paragraph -jgross@mit.edu
+ * Correctly display multiline fields in :info -jgross@mit.edu
+.8.1
+ * Only add outgoing messages for personal part of half-personal messages -andersk@mit.edu
+ * Don’t write CC: line on zwrite -C '' -andersk@mit.edu
+ * Don’t send public pings on zwrite '' or zwrite @REALM -andersk@mit.edu
+ * Don’t treat zwrite '' as personal -andersk@mit.edu
+ * Stop pretending to support zwrite * -andersk@mit.edu
+ * Show foreign realms on non-personal zephyrs like Owl did -andersk@mit.edu
+ * Fix memory leak in zcrypt -davidben@mit.edu
+ * Don't attempt to switch filters in :view -d if invalid -davidben@mit.edu
+ * Fixed typo in unbindkey usage error -rileyb@mit.edu
+ * Fix bug generating filter text in 256-color mode -asedeno@mit.edu
+ * Remove ^noc from reply-lockout -geofft@mit.edu
+ * Avoid quadratic loops when receiving zephyrs -andersk@mit.edu
+ * Fix hang on empty zcrypt messages -adehnert@MIT.EDU
+.8
+ * Compute the home directory in zcrypt consistently with BarnOwl -davidben@mit.edu
+ * Make help show the correct keybinding for A -jgross@mit.edu
+ * Add a delete-and-expunge command. -jgross@mit.edu
+ * Fix a bug in the expunge command -jgross@mit.edu
+ * Replace 'Owl' with 'BarnOwl' in user visible places -jgross@mit.edu
+ * Allow zsigs to be '0' -jgross@mit.edu
+ * Reformat the man page to look more like others -davidben@mit.edu
+ * Consistently use BarnOwl or barnowl -davidben@mit.edu
+ * Update autoconf macros -andersk@mit.edu
+ * history: Do not deduplicate a partial entry -andersk@mit.edu
+ * Drop show timers feature -davidben@mit.edu
+ * Add new dependencies, AnyEvent and perl-Glib -davidben@mit.edu
+ * Bump required glib version to 2.16 -davidben@mit.edu
+ * Don't leak timestr when setting time in a perl message -asedeno@mit.edu
+ * Build with -Wwrite-strings -andersk@mit.edu
+ * Build with C99 -davidben@mit.edu
+ * Jabber: Handle nicks with leading dashes (e.g. Facebook XMPP) -ezyang@mit.edu
+ * Move log-writing onto a background thread. -adam@crossproduct.net
+ * Remove the length limit on field values in :info -jgross@mit.edu
+ * Show how far you are in a long message -jgross@mit.edu
+ * stderr_redirect_handler: Handle partial or failed reads -andersk@mit.edu
+ * Inform the user when an unpunt command does nothing -davidben@mit.edu
+ * Replace custom event loop with GLib's GMainLoop -davidben@mit.edu
+ * Encode glib version requirements in pkg-config check -asedeno@mit.edu
+ * Fix color pair usage on ncurses builds without ext-color -davidben@mit.edu
+ * IRC: Fix reconnect behavior. -nelhage@mit.edu
+ * IRC: Make nick-change events LOGIN messages instead of ADMIN. -nelhage@mit.edu
+ * IRC: Port module to AnyEvent::IRC. -asedeno@mit.edu, nelhage@nelhage.com
+ * Ability to set exposure arbitrarily (like "zctl set exposure") -jgross@mit.edu
+ * Kill --remove-debug option -davidben@mit.edu
+ * exec: Fix input redirection of multistatement commands -andersk@mit.edu
+ * Correctly set the realm in outgoing zwrite errors -davidben@mit.edu
+ * Correctly compute the realm for outgoing messages -davidben@mit.edu
+ * In duplicated outgoing zephyrs only reply on the relevant recipient -davidben@mit.edu
+ * Create per-recipient copies of outgoing messages for non-CC'd personals -liudi@mit.edu
+ * Add black to :show colors -andersk@mit.edu
+ * Fix reporting of errors from libzephyr -kcr@1ts.org
+ * Load Encode module for IRC. -timhill@alum.mit.edu
+ * IRC: Sort the output of :irc-names -nelhage@mit.edu
+ * Prepend "UNAUTH: " to displayed sender for unauthenticated zephyrs -adam@crossproduct.net
+ * For ‘punt’ with one argument, quote the filter name -andersk@mit.edu
+ * Fix spurious error running ‘punt’ with no arguments -andersk@mit.edu
+ * Only handle CCs in messages sent directly to you. -davidben@mit.edu
+ * Update copyright notices for 2011 -davidben@mit.edu
+ * If a smartfilter fails to parse, handle the error -davidben@mit.edu
+ * Replace per-editwin killbuf with a global one. -adam@crossproduct.net
+ * Don't use error_message if we are building without Zephyr. -nelhage@mit.edu
+ * Fix replying to outgoing zwrite when -m is passed -davidben@mit.edu
+ * Fix a number of quoting bugs -davidben@mit.edu
+ * Check passwd entries to determine home dir -davidben@mit.edu
+.7.1
+ * Append sender's realm to CC'd unqualified names when replying. -adam@crossproduct.net
+ * Don't reset ncurses colorpairs in the middle of drawing. -davidben@mit.edu
+ * Fix viewuser when an unqualified name is given. -davidben@mit.edu
 .7
+ * Fix quoting bugs in smartfilter, zpunt, and numerous other commands. -davidben@mit.edu
  * Download Twitter consumer keys from barnowl.mit.edu. -nelhage@MIT.EDU
  * Fix unsub when .zephyr.subs is a symlink. -jgross@MIT.EDU

Makefile.am

-                      r3535a6e
+                      ra223b6b
 GIT_FLAGS := $(if $(GIT_DESCRIPTION),-DGIT_VERSION=$(GIT_DESCRIPTION:barnowl-%=%))
 bin_PROGRAMS = barnowl.bin
+bin_PROGRAMS = bin/barnowl
 if ENABLE_ZCRYPT
 bin_PROGRAMS += zcrypt
 …
 zcrypt_SOURCES = zcrypt.c filterproc.c
+check_PROGRAMS = tester.bin
+check_PROGRAMS = bin/tester
+dist_check_DATA = t
+dist_check_SCRIPTS = runtests.sh
+barnowl_bin_SOURCES = $(BASE_SRCS) \
+     owl.h owl_perl.h config.h \
+     owl.c \
+     $(GEN_C) $(GEN_H)
+noinst_SCRIPTS = barnowl
+check_SCRIPTS = tester
+man_MANS = doc/barnowl.1
+doc_DATA = doc/intro.txt doc/advanced.txt
+barnowl tester: %: barnowl-wrapper.in bin/% Makefile
+        sed \
+            -e 's,[@]abs_srcdir[@],$(abs_srcdir),g' \
+            -e 's,[@]abs_builddir[@],$(abs_builddir),g' \
+            $< > $@
+        chmod +x $@
+barnowl_bin_LDADD = compat/libcompat.a libfaim/libfaim.a
+bin_barnowl_SOURCES = $(BASE_SRCS) \
+     owl.h owl_perl.h \
+     owl.c
+nodist_bin_barnowl_SOURCES = $(GEN_C) $(GEN_H)
+tester_bin_SOURCES = $(BASE_SRCS) \
+     owl.h owl_perl.h config.h \
+     $(GEN_C) $(GEN_H) \
+dist_man_MANS = doc/barnowl.1
+dist_doc_DATA = doc/intro.txt doc/advanced.txt
+bin_barnowl_LDADD = compat/libcompat.a libfaim/libfaim.a
+bin_tester_SOURCES = $(BASE_SRCS) \
+     owl.h owl_perl.h \
      tester.c
+nodist_bin_tester_SOURCES = $(GEN_C) $(GEN_H)
 tester_bin_LDADD = compat/libcompat.a libfaim/libfaim.a
+bin_tester_LDADD = compat/libcompat.a libfaim/libfaim.a
 TESTS=runtests.sh
 AM_CPPFLAGS = -I$(top_srcdir)/ \
+AM_CPPFLAGS = \
            -I$(top_srcdir)/libfaim/ \
            -DDATADIR='"$(pkgdatadir)"' \
 …
            $(GIT_FLAGS)
+CODELIST_SRCS=list.c message.c mainwin.c popwin.c zephyr.c messagelist.c \
+     commands.c global.c text.c fmtext.c editwin.c util.c logging.c \
+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 \
      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 \
 …
      aim.c buddy.c buddylist.c style.c errqueue.c \
      zbuddylist.c popexec.c select.c wcwidth.c \
      glib_compat.c mainpanel.c msgwin.c sepbar.c editcontext.c signal.c
+     mainpanel.c msgwin.c sepbar.c editcontext.c signal.c closures.c
 NORMAL_SRCS = filterproc.c window.c windowcb.c
+NORMAL_SRCS = filterproc.c filterproc.h window.c window.h windowcb.c
 BASE_SRCS = $(CODELIST_SRCS) $(NORMAL_SRCS)
 GEN_C = varstubs.c perlglue.c
 GEN_H = owl_prototypes.h
+GEN_C = varstubs.c perlglue.c gmarshal_funcs.c
+GEN_H = owl_prototypes.h owl_prototypes.h.new gmarshal_funcs.h
 BUILT_SOURCES = $(GEN_C) $(GEN_H)
 …
 proto: owl_prototypes.h
 perlglue.c: perlglue.xs $(TYPEMAP)
         $(AM_V_GEN)perl $(XSUBPPDIR)/xsubpp $(XSUBPPFLAGS) -prototypes perlglue.xs > perlglue.c
+perlglue.c: perlglue.xs typemap
+        $(AM_V_GEN)perl $(XSUBPPDIR)/xsubpp $(XSUBPPFLAGS) -prototypes $< > $@
 varstubs.c: stubgen.pl variable.c
 …
         $(AM_V_GEN)perl $< $(sort $(filter-out $<,$+)) > $@
+gmarshal_funcs.h: marshal_types
+        glib-genmarshal --header $< > $@
+gmarshal_funcs.c: marshal_types
+        glib-genmarshal --body $< > $@
 # For emacs flymake-mode
 check-syntax: proto
         $(COMPILE) -Wall -Wextra -pedantic -fsyntax-only $(CHK_SOURCES)
+install-data-local:
+        $(mkinstalldirs) ${DESTDIR}${pkgdatadir}/lib
+        (cd perl/lib && tar -cf - . ) | (cd ${DESTDIR}${pkgdatadir}/lib && tar -xf - )
+do_transform = $(shell echo '$(1)' | sed '$(transform)')
+install-exec-hook:
+        mv -f $(DESTDIR)$(bindir)/$(call do_transform,barnowl.bin) \
+              $(DESTDIR)$(bindir)/$(call do_transform,barnowl)
+CLEANFILES = $(BUILT_SOURCES) $(noinst_SCRIPTS) $(check_SCRIPTS)
+EXTRA_DIST = \
+    autogen.sh \
+    barnowl-wrapper.in \
+    codelist.pl \
+    doc/code.txt \
+    doc/owl-window.txt \
+    doc/releasing-barnowl.txt \
+    examples \
+    marshal_types \
+    perlglue.xs \
+    scripts \
+    stubgen.pl \
+    typemap
 SUBDIRS = compat libfaim perl

README

-                      r13ee8f2
+                      r1c22155
 Notes:
 -----
 This project's perl/lib/ contains the lib directories from the
+This project's perl/modules/ contains the lib directories from the
 following CPAN modules:
+Facebook::Graph
 Net::Jabber
 Net::XMPP
 XML::Stream
 They have been modified slightly for the needs of this project.
+Some have been modified slightly for the needs of this project.
 BarnOwl currently requires the following perl modules off of CPAN:
 AnyEvent
+Class::Accessor
+ExtUtils::Depends
+Glib
+Module::Install
 PAR
-Net::DNS
-Authen::SASL::Perl
-IO::Socket::SSL
-Digest::SHA1
 (Note that these are all available as Debian packages)
 …
 these for you.
+The Facebook module requires:
+Any::Moose
+AnyEvent::HTTP
+DateTime
+DateTime::Format::Strptime
+JSON
+MIME::Base64::URLSafe
+Ouch
+URI
+URI::Encode
 The IRC module requires:
 AnyEvent::IRC
+Class::Accessor
+The Jabber module requires:
+Net::DNS
+Authen::SASL::Perl
+IO::Socket::SSL
+Digest::SHA
+The Twitter module requires:
+HTML::Entities
+Net::Twitter::Lite
 The WordWrap module requires:

aim.c

-                      rdc1edbd
+                      r8258ea5
-#include <stdio.h>
-#include <stdio.h>
-#include <sys/stat.h>
 #include "owl.h"
 …
+}
+void owl_aim_send_nop(owl_timer *t, void *data) {
+    if(owl_global_is_doaimevents(&g)) {
+        aim_session_t *sess = owl_global_get_aimsess(&g);
+        aim_flap_nop(sess, aim_getconn_type(sess, AIM_CONN_TYPE_BOS));
+    }
+gboolean owl_aim_send_nop(gpointer data) {
+  owl_global *g = data;
+  if (owl_global_is_doaimevents(g)) {
+    aim_session_t *sess = owl_global_get_aimsess(g);
+    aim_flap_nop(sess, aim_getconn_type(sess, AIM_CONN_TYPE_BOS));
+  }
+  return TRUE;
+}
 …
   owl_function_debugmsg("owl_aim_login: connecting");
   g.aim_nop_timer = owl_select_add_timer("owl_aim_send_nop", 30, 30, owl_aim_send_nop, NULL, NULL);
+  g.aim_nop_timer = g_timeout_add_seconds(30, owl_aim_send_nop, &g);
   return(0);
+}
+static void owl_aim_unset_ignorelogin(owl_timer *t, void *data)
+{
+    owl_global_unset_ignore_aimlogin(&g);
+static gboolean owl_aim_unset_ignorelogin(void *data)
+{
+  owl_global *g = data;
+  owl_global_unset_ignore_aimlogin(g);
+  return FALSE;  /* only run once. */
+}
 …
   /* start the ingorelogin timer */
   owl_global_set_ignore_aimlogin(&g);
+  owl_select_add_timer("owl_aim_unset_ignorelogin",
+                       owl_global_get_aim_ignorelogin_timer(&g),
+, owl_aim_unset_ignorelogin, NULL, NULL);
+  g_timeout_add_seconds(owl_global_get_aim_ignorelogin_timer(&g),
+                        owl_aim_unset_ignorelogin, &g);
   /* aim_ssi_setpresence(owl_global_get_aimsess(&g), 0x00000400); */
 …
   owl_global_set_aimnologgedin(&g);
   owl_global_set_no_doaimevents(&g);
+  owl_select_remove_timer(g.aim_nop_timer);
+  if (g.aim_nop_timer) {
+    g_source_remove(g.aim_nop_timer);
+    g.aim_nop_timer = 0;
+  }
+}
 …
   owl_global_set_aimnologgedin(&g);
   owl_global_set_no_doaimevents(&g);
+  owl_select_remove_timer(g.aim_nop_timer);
+  if (g.aim_nop_timer) {
+    g_source_remove(g.aim_nop_timer);
+    g.aim_nop_timer = 0;
+  }
+}
 …
 /* caller must free the return */
 char *owl_aim_normalize_screenname(const char *in)
+CALLER_OWN char *owl_aim_normalize_screenname(const char *in)
+{
   char *out;
 …
+{
   aim_clientready(sess, fr->conn);
   owl_function_debugmsg("conninitdone_admin: initializtion done for admin connection");
+  owl_function_debugmsg("conninitdone_admin: initialization done for admin connection");
   return(1);
+}
 …
   params = va_arg(ap, struct aim_icbmparameters *);
   va_end(ap);
   owl_function_debugmsg("faimtest_icbmparaminfo: ICBM Parameters: maxchannel = %d, default flags = 0x%08x, max msg len = %d, max sender evil = %f, max reciever evil = %f, min msg interval = %u",
+  owl_function_debugmsg("faimtest_icbmparaminfo: ICBM Parameters: maxchannel = %d, default flags = 0x%08x, max msg len = %d, max sender evil = %f, max receiver evil = %f, min msg interval = %u",
                        params->maxchan, params->flags, params->maxmsglen, ((float)params->maxsenderwarn)/10.0, ((float)params->maxrecverwarn)/10.0, params->minmsginterval);
 …
   g_free(wrapmsg);
   g_free(nz_screenname);
+  g_free(realmsg);
   return(1);
+  owl_function_debugmsg("faimtest_parse_incoming_im_chan1: icbm: message: %s\n", realmsg);
+  if (args->icbmflags & AIM_IMFLAGS_MULTIPART) {
+    aim_mpmsg_section_t *sec;
+    int z;
+    owl_function_debugmsg("faimtest_parse_incoming_im_chan1: icbm: multipart: this message has %d parts\n", args->mpmsg.numparts);
+    for (sec = args->mpmsg.parts, z = 0; sec; sec = sec->next, z++) {
+      if ((sec->charset == 0x0000) || (sec->charset == 0x0003) || (sec->charset == 0xffff)) {
+        owl_function_debugmsg("faimtest_parse_incoming_im_chan1: icbm: multipart:   part %d: charset 0x%04x, subset 0x%04x, msg = %s\n", z, sec->charset, sec->charsubset, sec->data);
+      } else {
+        owl_function_debugmsg("faimtest_parse_incoming_im_chan1: icbm: multipart:   part %d: charset 0x%04x, subset 0x%04x, binary or UNICODE data\n", z, sec->charset, sec->charsubset);
+      }
+    }
+  }
+  if (args->icbmflags & AIM_IMFLAGS_HASICON) {
+    /* aim_send_im(sess, userinfo->sn, AIM_IMFLAGS_BUDDYREQ, "You have an icon"); */
+    owl_function_debugmsg("faimtest_parse_incoming_im_chan1: icbm: their icon: iconstamp = %ld, iconlen = 0x%08x, iconsum = 0x%04x\n", args->iconstamp, args->iconlen, args->iconsum);
+  }
+  g_free(realmsg);
+  return(1);
+  /* TODO: Multipart? See history from before 1.8 release. */
+}
 …
   const char *address, *SNs;
   int num, i;
   owl_list list;
+  GPtrArray *list;
   va_start(ap, fr);
 …
   va_end(ap);
   owl_list_create(&list);
+  list = g_ptr_array_new();
   owl_function_debugmsg("faimtest_parse_searchreply: E-Mail Search Results for %s: ", address);
   for (i=0; i<num; i++) {
     owl_function_debugmsg("  %s", &SNs[i*(MAXSNLEN+1)]);
     owl_list_append_element(&list, (void *)&SNs[i*(MAXSNLEN+1)]);
+  }
   owl_function_aimsearch_results(address, &list);
   owl_list_cleanup(&list, NULL);
   return(1);
+    g_ptr_array_add(list, (void *)&SNs[i*(MAXSNLEN+1)]);
+  }
+  owl_function_aimsearch_results(address, list);
+  g_ptr_array_free(list, true);
+  return 1;
+}
 …
   GPollFD *fd;
   int i;
   if (len < event_source->fds->len)
+  if (len < event_source->fds->len) {
     owl_function_debugmsg("Truncating AIM PollFDs to %d, was %d", len, event_source->fds->len);
+  for (i = len; i < event_source->fds->len; i++) {
+    fd = event_source->fds->pdata[i];
+    g_source_remove_poll(&event_source->source, fd);
+    g_free(fd);
+  }
+  g_ptr_array_remove_range(event_source->fds, len, event_source->fds->len - len);
+    for (i = len; i < event_source->fds->len; i++) {
+      fd = event_source->fds->pdata[i];
+      g_source_remove_poll(&event_source->source, fd);
+      g_free(fd);
+    }
+    g_ptr_array_remove_range(event_source->fds, len, event_source->fds->len - len);
+  }
+}
 …
       fd = event_source->fds->pdata[i];
       fd->fd = cur->fd;
       fd->events |= G_IO_IN | G_IO_HUP | G_IO_ERR;
+      fd->events = G_IO_IN | G_IO_HUP | G_IO_ERR;
       if (cur->status & AIM_CONN_STATUS_INPROGRESS) {
+        /* Yes, we're checking writable sockets here. Without it, AIM
+           login is really slow. */
+        /* AIM login requires checking writable sockets. See aim_select. */
         fd->events |= G_IO_OUT;
+      }
 …
+{
   owl_aim_event_source *event_source = (owl_aim_event_source*)source;
+  truncate_pollfd_list(event_source, 0);
+  g_ptr_array_free(event_source->fds, TRUE);
+  /* Don't remove the GPollFDs. We are being finalized, so they'll be removed
+   * for us. Moreover, glib will fire asserts if g_source_remove_poll is called
+   * on a source which has been destroyed (which occurs when g_source_remove is
+   * called on it). */
+  owl_ptr_array_free(event_source->fds, g_free);
+}

buddylist.c

r96828e4	r3cdd6d2
3	3	void owl_buddylist_init(owl_buddylist *bl)
4	4	{
5		~~owl_list_create(&(bl->buddies)~~);
	5	bl->buddies = g_ptr_array_new();
6	6	}
7	7
…	…
14	14
15	15	owl_buddy_create(b, OWL_PROTOCOL_AIM, screenname);
16		~~owl_list_append_element(&(bl->buddies)~~, b);
	16	g_ptr_array_add(bl->buddies, b);
17	17	}
18	18
…	…
21	21	int owl_buddylist_remove_aim_buddy(owl_buddylist bl, const char name)
22	22	{
23		int i~~, j~~;
	23	int i;
24	24	owl_buddy *b;
25	25
26		j=owl_list_get_size(&(bl->buddies));
27		for (i=0; i<j; i++) {
28		b=owl_list_get_element(&(bl->buddies), i);
	26	for (i = 0; i < bl->buddies->len; i++) {
	27	b = bl->buddies->pdata[i];
29	28	if (!strcasecmp(name, owl_buddy_get_name(b)) && owl_buddy_is_proto_aim(b)) {
30		owl_list_remove_element(&(bl->buddies), i);
31		owl_buddy_delete(b);
	29	owl_buddy_delete(g_ptr_array_remove_index(bl->buddies, i));
32	30	return(0);
33	31	}
…	…
87	85	int owl_buddylist_get_size(const owl_buddylist *bl)
88	86	{
89		return~~(owl_list_get_size(&(bl->buddies)))~~;
	87	return bl->buddies->len;
90	88	}
91	89
…	…
97	95	if (index>(owl_buddylist_get_size(bl)-1)) return(NULL);
98	96
99		return~~(owl_list_get_element(&(bl->buddies), index))~~;
	97	return bl->buddies->pdata[index];
100	98	}
101	99
…	…
105	103	owl_buddy owl_buddylist_get_aim_buddy(const owl_buddylist bl, const char *name)
106	104	{
107		int i~~, j~~;
	105	int i;
108	106	owl_buddy *b;
109	107
110		j=owl_list_get_size(&(bl->buddies));
111		for (i=0; i<j; i++) {
112		b=owl_list_get_element(&(bl->buddies), i);
	108	for (i = 0; i < bl->buddies->len; i++) {
	109	b = bl->buddies->pdata[i];
113	110	if (!strcasecmp(name, owl_buddy_get_name(b))) return(b);
114	111	}
…	…
131	128	void owl_buddylist_clear(owl_buddylist *bl)
132	129	{
133		~~owl_list_cleanup(&(bl->buddies), (void ()(void ))owl_buddy_delete~~);
134		~~owl_list_create(&(bl->buddies)~~);
	130	g_ptr_array_foreach(bl->buddies, (GFunc)owl_buddy_delete, NULL);
	131	g_ptr_array_set_size(bl->buddies, 0);
135	132	}
136	133
137	134	void owl_buddylist_cleanup(owl_buddylist *bl)
138	135	{
139		owl_~~list_cleanup(&(bl->buddies), (void ()(void )~~)owl_buddy_delete);
	136	owl_ptr_array_free(bl->buddies, (GDestroyNotify)owl_buddy_delete);
140	137	}

cmd.c

-                      r4c7c21f
+                      rf271129
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
 #include "owl.h"
-extern const owl_cmd commands_to_init[];
 /**************************************************************************/
 …
 /**************************************************************************/
+int owl_cmddict_setup(owl_cmddict *cd) {
+void owl_cmddict_setup(owl_cmddict *cd)
+{
   owl_cmddict_init(cd);
+  if (0 != owl_cmddict_add_from_list(cd, commands_to_init)) return(-1);
+  return(0);
+  owl_cmd_add_defaults(cd);
+}
 …
 /* for bulk initialization at startup */
+int owl_cmddict_add_from_list(owl_cmddict *cd, const owl_cmd *cmds) {
+void owl_cmddict_add_from_list(owl_cmddict *cd, const owl_cmd *cmds)
+{
   const owl_cmd *cur;
-  int ret = 0;
   for (cur = cmds; cur->name != NULL; cur++) {
+    ret = owl_cmddict_add_cmd(cd, cur);
+    if (ret < 0) break;
+  }
+  return ret;
+}
+void owl_cmddict_get_names(const owl_cmddict *d, owl_list *l) {
+  owl_dict_get_keys(d, l);
+    owl_cmddict_add_cmd(cd, cur);
+  }
+}
+GPtrArray *owl_cmddict_get_names(const owl_cmddict *d) {
+  return owl_dict_get_keys(d);
+}
 …
 /* creates a new command alias */
 int owl_cmddict_add_alias(owl_cmddict *cd, const char *alias_from, const char *alias_to) {
+void owl_cmddict_add_alias(owl_cmddict *cd, const char *alias_from, const char *alias_to) {
   owl_cmd *cmd;
   cmd = g_new(owl_cmd, 1);
 …
   owl_perlconfig_new_command(cmd->name);
   owl_dict_insert_element(cd, cmd->name, cmd, (void (*)(void *))owl_cmd_delete);
-  return(0);
+}
 …
+}
+char *_owl_cmddict_execute(const owl_cmddict *cd, const owl_context *ctx, const char *const *argv, int argc, const char *buff) {
+/* caller must free the return */
+CALLER_OWN char *_owl_cmddict_execute(const owl_cmddict *cd, const owl_context *ctx, const char *const *argv, int argc, const char *buff)
+{
   char *retval = NULL;
   const owl_cmd *cmd;
 …
+}
+char *owl_cmddict_execute(const owl_cmddict *cd, const owl_context *ctx, const char *cmdbuff) {
+/* caller must free the return */
+CALLER_OWN char *owl_cmddict_execute(const owl_cmddict *cd, const owl_context *ctx, const char *cmdbuff)
+{
   char **argv;
   int argc;
 …
+}
+char *owl_cmddict_execute_argv(const owl_cmddict *cd, const owl_context *ctx, const char *const *argv, int argc) {
+/* caller must free the return */
+CALLER_OWN char *owl_cmddict_execute_argv(const owl_cmddict *cd, const owl_context *ctx, const char *const *argv, int argc)
+{
   char *buff;
   char *retval = NULL;
 …
+}
 int owl_cmd_create_alias(owl_cmd *cmd, const char *name, const char *aliased_to) {
+void owl_cmd_create_alias(owl_cmd *cmd, const char *name, const char *aliased_to) {
   memset(cmd, 0, sizeof(owl_cmd));
   cmd->name = g_strdup(name);
   cmd->cmd_aliased_to = g_strdup(aliased_to);
   cmd->summary = g_strdup_printf("%s%s", OWL_CMD_ALIAS_SUMMARY_PREFIX, aliased_to);
-  return(0);
+}
 …
+}
+char *owl_cmd_execute(const owl_cmd *cmd, const owl_cmddict *cd, const owl_context *ctx, int argc, const char *const *argv, const char *cmdbuff) {
+/* caller must free the result */
+CALLER_OWN char *owl_cmd_execute(const owl_cmd *cmd, const owl_cmddict *cd, const owl_context *ctx, int argc, const char *const *argv, const char *cmdbuff)
+{
   static int alias_recurse_depth = 0;
   int ival=0;
 …
 /* returns a summary line describing this keymap.  the caller must free. */
+char *owl_cmd_describe(const owl_cmd *cmd) {
+CALLER_OWN char *owl_cmd_describe(const owl_cmd *cmd)
+{
   if (!cmd || !cmd->name || !cmd->summary) return NULL;
   return g_strdup_printf("%-25s - %s", cmd->name, cmd->summary);
 …
   if (cmd->usage && *cmd->usage) {
     s = cmd->usage;
     indent = owl_text_indent(s, OWL_TAB);
+    indent = owl_text_indent(s, OWL_TAB, true);
     owl_fmtext_append_bold(fm, "\nSYNOPSIS\n");
     owl_fmtext_append_normal(fm, indent);
 …
   if (cmd->description && *cmd->description) {
     s = cmd->description;
     indent = owl_text_indent(s, OWL_TAB);
+    indent = owl_text_indent(s, OWL_TAB, true);
     owl_fmtext_append_bold(fm, "\nDESCRIPTION\n");
     owl_fmtext_append_normal(fm, indent);

commands.c

-                      r697221f
+                      r3b9ca71
+#include "owl.h"
 #include <getopt.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include "owl.h"
 /* fn is "char *foo(int argc, const char *const *argv, const char *buff)" */
 #define OWLCMD_ARGS(name, fn, ctx, summary, usage, description) \
         { name, summary, usage, description, ctx, \
+        { g_strdup(name), g_strdup(summary), g_strdup(usage), g_strdup(description), ctx, \
           NULL, fn, NULL, NULL, NULL, NULL, NULL, NULL }
 /* fn is "void foo(void)" */
 #define OWLCMD_VOID(name, fn, ctx, summary, usage, description) \
         { name, summary, usage, description, ctx, \
+        { g_strdup(name), g_strdup(summary), g_strdup(usage), g_strdup(description), ctx, \
           NULL, NULL, fn, NULL, NULL, NULL, NULL, NULL }
 /* fn is "void foo(int)" */
 #define OWLCMD_INT(name, fn, ctx, summary, usage, description) \
         { name, summary, usage, description, ctx, \
+        { g_strdup(name), g_strdup(summary), g_strdup(usage), g_strdup(description), ctx, \
           NULL, NULL, NULL, fn, NULL, NULL, NULL, NULL }
 #define OWLCMD_ALIAS(name, actualname) \
         { name, OWL_CMD_ALIAS_SUMMARY_PREFIX actualname, "", "", OWL_CTX_ANY, \
           actualname, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
+        { g_strdup(name), g_strdup(OWL_CMD_ALIAS_SUMMARY_PREFIX actualname), g_strdup(""), g_strdup(""), OWL_CTX_ANY, \
+          g_strdup(actualname), NULL, NULL, NULL, NULL, NULL, NULL, NULL }
 /* fn is "char *foo(void *ctx, int argc, const char *const *argv, const char *buff)" */
 #define OWLCMD_ARGS_CTX(name, fn, ctx, summary, usage, description) \
         { name, summary, usage, description, ctx, \
+        { g_strdup(name), g_strdup(summary), g_strdup(usage), g_strdup(description), ctx, \
           NULL, NULL, NULL, NULL, ((char*(*)(void*,int,const char*const *,const char*))fn), NULL, NULL, NULL }
 /* fn is "void foo(void)" */
 #define OWLCMD_VOID_CTX(name, fn, ctx, summary, usage, description) \
         { name, summary, usage, description, ctx, \
+        { g_strdup(name), g_strdup(summary), g_strdup(usage), g_strdup(description), ctx, \
           NULL, NULL, NULL, NULL, NULL, ((void(*)(void*))(fn)), NULL, NULL }
 /* fn is "void foo(int)" */
 #define OWLCMD_INT_CTX(name, fn, ctx, summary, usage, description) \
         { name, summary, usage, description, ctx, \
+        { g_strdup(name), g_strdup(summary), g_strdup(usage), g_strdup(description), ctx, \
           NULL, NULL, NULL, NULL, NULL, NULL, ((void(*)(void*,int))fn), NULL }
+const owl_cmd commands_to_init[]
+  = {
+void owl_cmd_add_defaults(owl_cmddict *cd)
+{
+  owl_cmd commands_to_init[] = {
   OWLCMD_ARGS("zlog", owl_command_zlog, OWL_CTX_ANY,
               "send a login or logout notification",
 …
               "zlog in will send a login notification, zlog out will send a\n"
               "logout notification.  By default a login notification is sent\n"
               "when owl is started and a logout notification is sent when owl\n"
+              "when BarnOwl is started and a logout notification is sent when owl\n"
               "is exited.  This behavior can be changed with the 'startuplogin'\n"
               "and 'shutdownlogout' variables.  If a tty is specified for zlog in\n"
               "then the owl variable 'tty' will be set to that string, causing\n"
+              "then the BarnOwl variable 'tty' will be set to that string, causing\n"
               "it to be used as the zephyr location tty.\n"),
   OWLCMD_VOID("quit", owl_command_quit, OWL_CTX_ANY,
               "exit owl",
+              "exit BarnOwl",
               "",
               "Exit owl and run any shutdown activities."),
+              "Exit BarnOwl and run any shutdown activities."),
   OWLCMD_ALIAS("exit", "quit"),
   OWLCMD_ALIAS("q",    "quit"),
 …
   OWLCMD_ARGS("unbindkey", owl_command_unbindkey, OWL_CTX_ANY,
               "removes a binding in a keymap",
               "bindkey <keymap> <keyseq>",
+              "unbindkey <keymap> <keyseq>",
               "Removes a binding of a key sequence within a keymap.\n"
               "Use 'show keymaps' to see the existing keymaps.\n"
 …
   OWLCMD_ARGS("startup", owl_command_startup, OWL_CTX_ANY,
               "run a command and set it to be run at every Owl startup",
+              "run a command and set it to be run at every BarnOwl startup",
               "startup <commands> ...",
               "Everything on the command line after the startup command\n"
               "is executed as a normal owl command and is also placed in\n"
               "a file so that the command is executed every time owl\n"
+              "is executed as a normal BarnOwl command and is also placed in\n"
+              "a file so that the command is executed every time BarnOwl\n"
               "is started"),
   OWLCMD_ARGS("unstartup", owl_command_unstartup, OWL_CTX_ANY,
               "remove a command from the list of those to be run at Owl startup",
+              "remove a command from the list of those to be run at BarnOwl startup",
               "unstartup <commands> ...",
               ""),
   OWLCMD_VOID("version", owl_command_version, OWL_CTX_ANY,
               "print the version of the running owl", "", ""),
+              "print the version of the running BarnOwl", "", ""),
   OWLCMD_ARGS("subscribe", owl_command_subscribe, OWL_CTX_ANY,
 …
               "only be temporary, i.e., it will not be written to\n"
               "the subscription file and will therefore not be\n"
               "present the next time owl is started.\n"),
+              "present the next time BarnOwl is started.\n"),
   OWLCMD_ALIAS("sub", "subscribe"),
 …
               "only be temporary, i.e., it will not be updated in\n"
               "the subscription file and will therefore not be\n"
               "in effect the next time owl is started.\n"),
+              "in effect the next time BarnOwl is started.\n"),
   OWLCMD_ALIAS("unsub", "unsubscribe"),
 …
   OWLCMD_ARGS("source", owl_command_source, OWL_CTX_ANY,
               "execute owl commands from a file",
+              "execute BarnOwl commands from a file",
               "source <filename>",
               "Execute the owl commands in <filename>.\n"),
+              "Execute the BarnOwl commands in <filename>.\n"),
   OWLCMD_ARGS("aim", owl_command_aim, OWL_CTX_INTERACTIVE,
 …
   OWLCMD_ARGS("help", owl_command_help, OWL_CTX_INTERACTIVE,
               "display help on using owl",
+              "display help on using BarnOwl",
               "help [command]", ""),
 …
   OWLCMD_VOID("suspend", owl_command_suspend, OWL_CTX_ANY,
               "suspend owl", "", ""),
+              "suspend BarnOwl", "", ""),
   OWLCMD_ARGS("echo", owl_command_echo, OWL_CTX_ANY,
 …
   OWLCMD_VOID("about", owl_command_about, OWL_CTX_INTERACTIVE,
               "print information about owl", "", ""),
+              "print information about BarnOwl", "", ""),
   OWLCMD_VOID("status", owl_command_status, OWL_CTX_ANY,
               "print status information about the running owl", "", ""),
+              "print status information about the running BarnOwl", "", ""),
   OWLCMD_ARGS("zlocate", owl_command_zlocate, OWL_CTX_INTERACTIVE,
 …
               "The other usages listed above are abbreviated forms that simply set\n"
               "the filter of the current view. The -d option allows you to write a\n"
               "filter expression that will be dynamically created by owl and then\n"
+              "filter expression that will be dynamically created by BarnOwl and then\n"
               "applied as the view's filter\n"
               "SEE ALSO: filter, viewclass, viewuser\n"),
 …
               "show subscriptions / show subs\n"
               "show terminal\n"
-              "show timers\n"
               "show variables\n"
               "show variable <variable>\n"
 …
               "for formatting messages.\n\n"
               "Show variables will list the names of all variables.\n\n"
               "Show errors will show a list of errors encountered by Owl.\n\n"
+              "Show errors will show a list of errors encountered by BarnOwl.\n\n"
               "SEE ALSO: filter, view, alias, bindkey, help\n"),
 …
   OWLCMD_ALIAS("del", "delete"),
+  OWLCMD_ARGS("delete-and-expunge", owl_command_delete_and_expunge, OWL_CTX_INTERACTIVE,
+              "delete a message",
+              "delete-and-expunge [-id msgid] [-q | --quiet]",
+              "If no message id is specified the current message is deleted.\n"
+              "Otherwise the message with the given message id is deleted.\n"
+              "If --quiet is specified, then there is no message displayed on\n"
+              "success.\n"),
+  OWLCMD_ALIAS("delx", "delete-and-expunge"),
   OWLCMD_ARGS("undelete", owl_command_undelete, OWL_CTX_INTERACTIVE,
               "unmark a message for deletion",
 …
   OWLCMD_ARGS_CTX("popless:start-search", owl_viewwin_command_start_search, OWL_CTX_POPLESS,
                   "starts a command line to search for particular string",
                   "popless:start-search [-r] [inital-value]",
+                  "popless:start-search [-r] [initial-value]",
                   "Initializes the command-line to search for initial-value. If\n"
                   "-r is used, the search will be performed backwards.\n\n"
 …
   { NULL, NULL, NULL, NULL, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
+};
+  };
+  owl_cmddict_add_from_list(cd, commands_to_init);
+  owl_cmd *cmd;
+  for (cmd = commands_to_init; cmd->name != NULL; cmd++)
+    owl_cmd_cleanup(cmd);
+}
 void owl_command_info(void)
 …
+}
 char *owl_command_smartfilter(int argc, const char *const *argv, const char *buff)
+CALLER_OWN char *owl_command_smartfilter(int argc, const char *const *argv, const char *buff)
+{
   char *filtname = NULL;
 …
+}
 char *owl_command_get_shift(int argc, const char *const *argv, const char *buff)
+CALLER_OWN char *owl_command_get_shift(int argc, const char *const *argv, const char *buff)
+{
   if(argc != 1)
 …
   int  silent=0;
   int requirebool=0;
+  owl_variable *v;
   if (argc == 1) {
 …
     return NULL;
+  }
+  owl_variable_set_fromstring(owl_global_get_vardict(&g), var, val, !silent, requirebool);
+  v = owl_variable_get_var(owl_global_get_vardict(&g), var);
+  if (v == NULL) {
+    if (!silent) owl_function_error("Unknown variable '%s'", var);
+  } else if (requirebool && !v->takes_on_off) {
+    if (!silent) owl_function_error("Variable '%s' is not a boolean", var);
+  } else {
+    owl_variable_set_fromstring(v, val, !silent);
+  }
   return NULL;
+}
 …
 char *owl_command_unset(int argc, const char *const *argv, const char *buff)
+{
+  owl_variable *v;
   const char *var, *val;
   int  silent=0;
 …
     return NULL;
+  }
+  owl_variable_set_fromstring(owl_global_get_vardict(&g), var, val, !silent, 1);
+  v = owl_variable_get_var(owl_global_get_vardict(&g), var);
+  if (v == NULL) {
+    if (!silent) owl_function_error("Unknown variable '%s'", var);
+  } else if (!v->takes_on_off) {
+    if (!silent) owl_function_error("Variable '%s' is not a boolean", var);
+  } else {
+    owl_variable_set_fromstring(v, val, !silent);
+  }
   return NULL;
+}
 …
   const char *var;
   char *value;
+  const owl_variable *v;
   if (argc==1) {
 …
   var=argv[1];
+  value = owl_variable_get_tostring(owl_global_get_vardict(&g), var);
+  if (value) {
+    owl_function_makemsg("%s = '%s'", var, value);
+  v = owl_variable_get_var(owl_global_get_vardict(&g), var);
+  if (v) {
+    value = owl_variable_get_tostring(v);
+    if (value == NULL)
+      owl_function_makemsg("%s = <null>", var);
+    else
+      owl_function_makemsg("%s = '%s'", var, value);
     g_free(value);
   } else {
 …
 char *owl_command_exec(int argc, const char *const *argv, const char *buff)
+CALLER_OWN char *owl_command_exec(int argc, const char *const *argv, const char *buff)
+{
   return owl_function_exec(argc, argv, buff, OWL_OUTPUT_RETURN);
+}
 char *owl_command_pexec(int argc, const char *const *argv, const char *buff)
+CALLER_OWN char *owl_command_pexec(int argc, const char *const *argv, const char *buff)
+{
   return owl_function_exec(argc, argv, buff, OWL_OUTPUT_POPUP);
+}
 char *owl_command_aexec(int argc, const char *const *argv, const char *buff)
+CALLER_OWN char *owl_command_aexec(int argc, const char *const *argv, const char *buff)
+{
   return owl_function_exec(argc, argv, buff, OWL_OUTPUT_ADMINMSG);
+}
 char *owl_command_perl(int argc, const char *const *argv, const char *buff)
+CALLER_OWN char *owl_command_perl(int argc, const char *const *argv, const char *buff)
+{
   return owl_function_perl(argc, argv, buff, OWL_OUTPUT_RETURN);
+}
 char *owl_command_pperl(int argc, const char *const *argv, const char *buff)
+CALLER_OWN char *owl_command_pperl(int argc, const char *const *argv, const char *buff)
+{
   return owl_function_perl(argc, argv, buff, OWL_OUTPUT_POPUP);
+}
 char *owl_command_aperl(int argc, const char *const *argv, const char *buff)
+CALLER_OWN char *owl_command_aperl(int argc, const char *const *argv, const char *buff)
+{
   return owl_function_perl(argc, argv, buff, OWL_OUTPUT_ADMINMSG);
+}
 char *owl_command_multi(int argc, const char *const *argv, const char *buff)
+CALLER_OWN char *owl_command_multi(int argc, const char *const *argv, const char *buff)
+{
   char *lastrv = NULL, *newbuff;
 …
   if (argc < 3) {
     owl_function_makemsg("Usage: bindkey <keymap> <binding>");
+    owl_function_makemsg("Usage: unbindkey <keymap> <binding>");
     return NULL;
+  }
 …
+  }
   /* check for a zwrite -m */
   z = owl_zwrite_new(buff);
+  z = owl_zwrite_new(argc, argv);
   if (!z) {
     owl_function_error("Error in zwrite arguments");
 …
       myargv[i]=argv[i];
+    }
+    owl_function_create_filter(argc, myargv);
+    owl_function_change_currentview_filter("owl-dynamic");
+    if (owl_function_create_filter(argc, myargv)) {
+      owl_function_change_currentview_filter("owl-dynamic");
+    }
     g_free(myargv);
     return NULL;
 …
     if (!strcmp(argv[0], "-f")) {
       if (argc<2) {
         owl_function_makemsg("Too few argments to the view command");
+        owl_function_makemsg("Too few arguments to the view command");
         return(NULL);
+      }
 …
     } else if (!strcmp(argv[0], "-s")) {
       if (argc<2) {
         owl_function_makemsg("Too few argments to the view command");
+        owl_function_makemsg("Too few arguments to the view command");
         return(NULL);
+      }
 …
       argv+=2;
     } else {
       owl_function_makemsg("Too few argments to the view command");
+      owl_function_makemsg("Too few arguments to the view command");
       return(NULL);
+    }
 …
   } else if (!strcmp(argv[1], "styles")) {
     owl_function_show_styles();
-  } else if (!strcmp(argv[1], "timers")) {
-    owl_function_show_timers();
   } else if (!strcmp(argv[1], "subs") || !strcmp(argv[1], "subscriptions")) {
     owl_function_getsubs();
 …
+}
+char *owl_command_delete_and_expunge(int argc, const char *const *argv, const char *buff)
+{
+  bool exclaim_success = true;
+  if (argc > 1 && (!strcmp(argv[1], "-q") || !strcmp(argv[1], "--quiet"))) {
+    exclaim_success = false;
+    argc--;
+    argv++;
+  } else if (!strcmp(argv[argc - 1], "-q") || !strcmp(argv[argc - 1], "--quiet")) {
+    exclaim_success = false;
+    argc--;
+  }
+  if (argc == 1) {
+    owl_function_delete_and_expunge_cur(exclaim_success);
+    return NULL;
+  }
+  if (argc == 3 && (!strcmp(argv[1], "-id") || !strcmp(argv[1], "--id"))) {
+    owl_function_delete_and_expunge_by_id(atoi(argv[2]), exclaim_success);
+    return NULL;
+  }
+  owl_function_makemsg("Unknown arguments to delete-and-expunge command");
+  return NULL;
+}
 char *owl_command_undelete(int argc, const char *const *argv, const char *buff)
+{
 …
 void owl_command_punt_unpunt(int argc, const char *const * argv, const char *buff, int unpunt)
+{
+  owl_list * fl;
+  owl_filter * f;
+  GPtrArray * fl;
   int i;
 …
   } else if(argc == 2) {
     /* Handle :unpunt <number> */
     if(unpunt && (i=atoi(argv[1])) !=0) {
+    if (unpunt && (i = atoi(argv[1])) > 0) {
       i--;      /* Accept 1-based indexing */
+      if(i < owl_list_get_size(fl)) {
+        f = owl_list_get_element(fl, i);
+        owl_list_remove_element(fl, i);
+        owl_filter_delete(f);
+      if (i < fl->len) {
+        owl_filter_delete(g_ptr_array_remove_index(fl, i));
         return;
       } else {
 …
+}
+char *owl_command_getvar(int argc, const char *const *argv, const char *buff)
+{
+CALLER_OWN char *owl_command_getvar(int argc, const char *const *argv, const char *buff)
+{
+  const owl_variable *v;
   if (argc != 2) {
     owl_function_makemsg("Wrong number of arguments for %s", argv[0]);
     return NULL;
+  }
+  return owl_variable_get_tostring(owl_global_get_vardict(&g), argv[1]);
+  v = owl_variable_get_var(owl_global_get_vardict(&g), argv[1]);
+  if (v == NULL) return NULL;
+  return owl_variable_get_tostring(v);
+}
 …
+}
 char *owl_command_getstyle(int argc, const char *const *argv, const char *buff)
+CALLER_OWN char *owl_command_getstyle(int argc, const char *const *argv, const char *buff)
+{
   const char *stylename;
 …
   ptr = skiptokens(buff, 1);
   hist = owl_global_get_cmd_history(&g);
+  owl_history_store(hist, ptr);
+  owl_history_reset(hist);
+  owl_history_store(hist, ptr, false);
   /* owl_function_makemsg("History '%s' stored successfully", ptr+1); */
   return NULL;
+}
 char *owl_command_with_history(int argc, const char *const *argv, const char *buff)
+CALLER_OWN char *owl_command_with_history(int argc, const char *const *argv, const char *buff)
+{
   owl_history *hist;
 …
   hist = owl_global_get_cmd_history(&g);
+  owl_history_store(hist, ptr);
+  owl_history_reset(hist);
+  owl_history_store(hist, ptr, false);
   return owl_function_command(ptr);
+}
 …
   hist = owl_editwin_get_history(e);
+  if (hist) {
+    owl_history_store(hist, owl_editwin_get_text(e));
+    owl_history_reset(hist);
+  }
+  if (hist)
+    owl_history_store(hist, owl_editwin_get_text(e), false);
+  /* Take a reference to the editwin, so that it survives the pop
+   * context. TODO: We should perhaps refcount or otherwise protect
+   * the context so that, even if a command pops a context, the
+   * context itself will last until the command returns. */
+  owl_editwin_ref(e);
   owl_global_pop_context(&g);
+  owl_editwin_do_callback(e, false);
+  owl_editwin_unref(e);
+}
 …
   if (!hist)
     return;
+  if (!owl_history_is_touched(hist)) {
+    owl_history_store(hist, owl_editwin_get_text(e));
+    owl_history_set_partial(hist);
+  }
+  if (!owl_history_is_touched(hist))
+    owl_history_store(hist, owl_editwin_get_text(e), true);
   ptr=owl_history_get_prev(hist);
   if (ptr) {
 …
   owl_history *hist=owl_editwin_get_history(e);
+  if (hist) {
+    owl_history_store(hist, owl_editwin_get_text(e));
+    owl_history_reset(hist);
+  }
+  if (hist)
+    owl_history_store(hist, owl_editwin_get_text(e), false);
   /* Take a reference to the editwin, so that it survives the pop
 …
   owl_global_pop_context(&g);
   owl_editwin_do_callback(e);
+  owl_editwin_do_callback(e, true);
   owl_editwin_unref(e);
+}

compat/Makefile.am

r12a6616	rb80bae0
1	1	noinst_LIBRARIES = libcompat.a
2	2
3		libcompat_a_SOURCES =
	3	libcompat_a_SOURCES = compat.h
4	4	libcompat_a_LIBADD = $(LIBOBJS)

compat/compat.h

r4dde585	r6249a88f
2	2	#define INC_BARNOWL_COMPAT_COMPAT_H
3	3
4		#include ~~"../config.h"~~
	4	#include <config.h>
5	5
6	6	#include <stddef.h>

configure.ac

-                      rf97c1a6
+                      re4b8f93
 dnl Process this file with autoconf to produce a configure script.
+AC_INIT([BarnOwl],[1.8dev],[bug-barnowl@mit.edu])
+AM_INIT_AUTOMAKE([1.7.0 -Wall -Wno-portability foreign])
+AC_INIT([BarnOwl],[1.10dev],[bug-barnowl@mit.edu])
+AM_INIT_AUTOMAKE([1.7.0 foreign std-options -Wall -Wno-portability])
+AM_MAINTAINER_MODE([enable])
 m4_ifdef([AM_SILENT_RULES],[AM_SILENT_RULES([yes])])
 …
 AC_PROG_CC
+AC_PROG_CC_C99
+AC_PROG_LN_S
+AC_ARG_WITH([zephyr-default-format],
+    [AS_HELP_STRING([--with-zephyr-default-format],
+                    [value for the default format zephyrgram field])],
+    [
+        case $withval in
+            yes) withval='Config error: see http://mit.edu/df';;
+            no) withval='';;
+        esac
+        zephyr_default_format=$withval
+    ],
+    [zephyr_default_format='Config error: see http://mit.edu/df'])
+AC_DEFINE_UNQUOTED(
+    [ZEPHYR_DEFAULT_FORMAT], ["$zephyr_default_format"],
+    [Value for the default format zephyrgram field]
+)
 AC_ARG_WITH([stack-protector],
 …
 AS_IF([test "x$with_stack_protector" != xno],
   [AX_C_CHECK_FLAG([-fstack-protector],[],[],
+  [AX_CHECK_COMPILE_FLAG([-fstack-protector],
     [AM_CFLAGS="$AM_CFLAGS -fstack-protector"],
     [if test "x$with_stack_protector" != xcheck; then
 …
 AS_IF([test "x$with_zephyr" != xno],
+  [AS_IF([test "x$with_krb4" != "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`"
 …
       [AC_MSG_RESULT([no])
        AS_IF([test "x$with_krb4" = "xyes"],
+             [AC_MSG_ERROR([Kerberos IV requested but not found])])
+       PKG_CHECK_MODULES([LIBCRYPTO], [libcrypto])
+       AM_CFLAGS="${AM_CFLAGS} ${LIBCRYPTO_CFLAGS}"
+       LIBS="${LIBS} ${LIBCRYPTO_LIBS}"
+     ])])
+             [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}"
+           ])])])
    AC_CHECK_LIB([zephyr], [ZGetSender],
    [LIBS="$LIBS -lzephyr"
 …
 AC_HEADER_STDC
 AC_HEADER_SYS_WAIT
+AC_HEADER_STDBOOL
+AC_CHECK_HEADERS(strings.h sys/ioctl.h sys/filio.h unistd.h)
+AC_CHECK_HEADERS(stdbool.h strings.h sys/ioctl.h sys/filio.h unistd.h)
 dnl Add CFLAGS for embeded perl
 …
 dnl Find the location of perl XSUBPP
 AC_MSG_CHECKING(for the perl xsubpp precompiler)
 XSUBPPDIR="`(perl -MExtUtils::MakeMaker -e 'print ExtUtils::MakeMaker->new({NAME => qw(owl)})->tool_xsubpp;') | grep \^XSUBPPDIR | sed -e 's/XSUBPPDIR = //g;'`"
+XSUBPPDIR="`cd "$srcdir" && perl -MExtUtils::MakeMaker -e 'print ExtUtils::MakeMaker->new({NAME => qw(owl)})->tool_xsubpp;' | grep \^XSUBPPDIR | sed -e 's/XSUBPPDIR = //g;'`"
 if test -n "${XSUBPPDIR}"; then
    AC_MSG_RESULT(${XSUBPPDIR})
 …
 AC_CHECK_LIB([perl], [perl_alloc],, AC_MSG_ERROR([No libperl found]))
+AX_PROG_PERL_MODULES([AnyEvent],,
+                     [AC_MSG_ERROR([cannot find perl module AnyEvent.])])
 AX_PROG_PERL_MODULES([Class::Accessor::Fast],,
                      [AC_MSG_ERROR([cannot find perl module Class::Accessor::Fast.])])
+AX_PROG_PERL_MODULES([ExtUtils::Depends],,
+                     [AC_MSG_ERROR([cannot find perl module ExtUtils::Depends])])
+AX_PROG_PERL_MODULES([Glib],,
+                     [AC_MSG_ERROR([cannot find perl module Glib.])])
+AX_PROG_PERL_MODULES([Module::Install::Base],,
+                     [AC_MSG_ERROR([cannot find perl module Module::Install::Base])])
 AX_PROG_PERL_MODULES([PAR],,
                      [AC_MSG_WARN([PAR.pm not found. Loadable modules will be disabled.])])
 dnl Add CFLAGS and LIBS for glib-2.0
 PKG_CHECK_MODULES(GLIB,[glib-2.0 >= 2.12 gobject-2.0 gthread-2.0])
+PKG_CHECK_MODULES(GLIB,[glib-2.0 >= 2.16 gobject-2.0 gthread-2.0])
 AC_MSG_NOTICE([Adding glib-2.0 CFLAGS ${GLIB_CFLAGS}])
 …
 fi
+dnl Add CFLAGS for glib-perl
+GLIB_PERL_CFLAGS=`perl -MExtUtils::Depends -e 'my $e = ExtUtils::Depends->new("BarnOwl","Glib"); my %h = $e->get_makefile_vars; print $h{"INC"}'`
+AC_MSG_NOTICE([Adding glib-perl CFLAGS ${GLIB_PERL_CFLAGS}])
+AM_CFLAGS="${GLIB_PERL_CFLAGS} ${AM_CFLAGS}"
 dnl Checks for typedefs, structures, and compiler characteristics.
 AX_CFLAGS_WARN_ALL([AM_CFLAGS])
 AX_C_CHECK_FLAG([-Wstrict-prototypes],[],[],[AM_CFLAGS="$AM_CFLAGS -Wstrict-prototypes"])
+AX_APPEND_COMPILE_FLAGS([-Wstrict-prototypes -Wwrite-strings],[AM_CFLAGS])
 dnl Shut gcc up about zero-length format strings; the warning's apparently for
 dnl efficiency reasons, which is bogus for custom functions.
+AX_C_CHECK_FLAG([-Wno-format-zero-length],[],[],[AM_CFLAGS="$AM_CFLAGS -Wno-format-zero-length"])
+m4_foreach([myflag],
+  [[-Wno-pointer-sign],[-Wno-empty-body],[-Wno-unused-value]],
+  [AX_C_CHECK_FLAG([myflag],[],[],[LIBFAIM_CFLAGS="$LIBFAIM_CFLAGS myflag"])])
+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_ECB_ENCRYPT"])
 AM_CFLAGS="$AM_CFLAGS -D_XOPEN_SOURCE=500"
+AM_CFLAGS="$AM_CFLAGS -D_XOPEN_SOURCE=600"
 dnl Define _BSD_SOURCE because zephyr needs caddr_t.
 AM_CFLAGS="$AM_CFLAGS -D_BSD_SOURCE"
 …
 AC_REPLACE_FUNCS([memrchr])
+AC_SUBST([abs_builddir])
+AC_SUBST([abs_srcdir])
 AC_CONFIG_FILES([Makefile compat/Makefile libfaim/Makefile perl/Makefile perl/modules/Makefile])
 AC_OUTPUT

context.c

-                      rd4927a7
+                      rf271129
-#include <string.h>
 #include "owl.h"
 …
 /* TODO: dependency from owl_context -> owl_window is annoying. */
 owl_context *owl_context_new(int mode, void *data, const char *keymap, owl_window *cursor)
+CALLER_OWN owl_context *owl_context_new(int mode, void *data, const char *keymap, owl_window *cursor)
+{
   owl_context *c;

dict.c

-                      r4c7c21f
+                      rf271129
  */
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
 #include "owl.h"
 #define INITSIZE 30
 …
+}
+/* Appends dictionary keys to a list.  Duplicates the keys,
+ * so they will need to be freed by the caller. */
+void owl_dict_get_keys(const owl_dict *d, owl_list *l) {
+/* Returns a GPtrArray of dictionary keys. Duplicates the keys, so
+ * they will need to be freed by the caller with g_free. */
+CALLER_OWN GPtrArray *owl_dict_get_keys(const owl_dict *d) {
+  GPtrArray *keys = g_ptr_array_sized_new(d->size);
   int i;
   for (i=0; i<d->size; i++) {
     owl_list_append_element(l, g_strdup(d->els[i].k));
+  for (i = 0; i < d->size; i++) {
+    g_ptr_array_add(keys, g_strdup(d->els[i].k));
+  }
+  return keys;
+}
 …
 /* Doesn't free the value of the element, but does
  * return it so the caller can free it. */
+void *owl_dict_remove_element(owl_dict *d, const char *k) {
+CALLER_OWN void *owl_dict_remove_element(owl_dict *d, const char *k)
+{
   int i;
   int pos, found;

doc/barnowl.1

-                      rfa1b15b
+                      r8135737
 .TH barnowl 1 "23 Jun 2008"
+.TH BARNOWL 1 "24 Jun 2011"
 .SH NAME
 barnowl \- tty based zephyr client
+BarnOwl \- tty\(hybased zephyr client
 .SH SYNOPSIS
 .B barnowl
+[ \-n
+]
+[ \-d
+]
+[ \-D
+]
+[ \-v
+]
+[ \-h
+]
+[ \-c
+.I configfile
+]
+[ \-t
+.I tty
+]
+[ \-s
+.I configdir
+]
+[\-n]
+[\-d]
+[\-D]
+[\-v]
+[\-h]
+[\-c \fICONFIGFILE\fP]
+[\-t \fITTY\fP]
+[\-s \fICONFIGDIR\fP]
 .br
 .SH DESCRIPTION
 .B BarnOwl
 is a fully integrated tty based instant messaging client.  Currently
 it supports AOL Instant Messenger, MIT Zephyr, and Jabber.  It is
 curses-based, allows for emacs-style editing of outgoing messages and
 uses perl as an extension and configuration language.  BarnOwl will
+is a fully integrated tty\(hybased instant messaging client.  Currently
+it supports AOL Instant Messenger, MIT Zephyr, Jabber, IRC, and Twitter.  It is
+curses\(hybased, allows for emacs\(hystyle editing of outgoing messages, and
+uses Perl as an extension and configuration language.  \fBBarnOwl\fP will
 also run happily without a configuration file.
 Once BarnOwl is started, typing 'h' will display a help screen.
 Typing \':\' enters command mode, allowing the user to type a barnowl
+Once \fBBarnOwl\fP is started, typing \(oqh\(cq will display a help screen.
+Typing \(oq:\(cq enters command mode, allowing the user to type a \fBBarnOwl\fP
 command line.
+.PP
+.SH USE
+The following command line options are avilable when running barnowl:
+.SH OPTIONS
+The following command\-line options are avilable when running \fBBarnOwl\fP:
+.TP
+\fB\-n\fP, \fB\-\-no\-subs\fP
+Do not subscribe to zephyr messages on startup.  By default, \fBBarnOwl\fP
+subscribes to the default subscriptions and to anything found in
+\fI~/.zephyr.subs\fP.  When this option is used, no subscriptions are loaded.
+.B \-n
+.IP
+Do not subscribe to zephyr messages on startup.  By default BarnOwl
+subscribes to the default subscriptions and to anything found in
+~/.zephyr.subs.  When this option is used no subscriptions are loaded.
+.LP
+.TP
+\fB\-c\fP, \fB\-\-config\-file\fP=\fIFILE\fP
+Specify an alternate config file for \fBBarnOwl\fP to use.  The config file is
+an arbitrary Perl script evaluated in the \fImain\fP package, and if it
+overrides the \fIBarnOwl::startup\fP method that is run when \fBBarnOwl\fP
+starts.  (Compare \fI~/.owl/startup\fP, which contains \fBBarnOwl\fP commands
+that are run at startup after the config file is loaded.)
+.B \-c \fIconfigfile\fP
+.IP
+Specifiy an alternate config file for BarnOwl to use.  By default,
+barnowl uses ~/.barnowlconf if it exists, and ~/.owlconf otherwise.
+.LP
+By default, \fBBarnOwl\fP uses the first of \fI~/.owl/init.pl\fP,
+\fI~/.barnowlconf\fP, or \fI~/.owlconf\fP that exists.
+.B \-s \fIconfigdir\fP
+.IP
+Specify an alternate configuration directory. By default, BarnOwl uses
+~/.owl/.
+.LP
+.TP
+\fB\-s\fP, \fB\-\-config\-dir\fP=\fIDIR\fP
+Specify an alternate configuration directory.  By default, \fBBarnOwl\fP uses
+\fI~/.owl/\fP.
+.B \-t \fItty\fP
+.IP
+Specifiy the tty name to use for the zephyr location.
+.LP
+.TP
+\fB\-t\fP, \fB\-\-tty\fP=\fITTY\fP
+Specify the tty name to use for the zephyr location.
+.B \-v
+.IP
+Print the version number of barnowl and exit.
+.LP
+.TP
+\fB\-v\fP, \fB\-\-version\fP
+Print the version number of \fBBarnOwl\fP and exit.
+.B \-d
+.IP
+Enable debugging.  By default debugging information is placed in
+/var/tmp/owldebug.
+.LP
+.TP
+\fB\-d\fP, \fB\-\-debug\fP
+Enable debugging.  By default, debugging information is placed in
+\fI/var/tmp/barnowl\-debug.PID\fP.
+.B \-D
+.IP
+Enable debugging, but first delete any existing debugging file.
+.LP
+.TP
+\fB\-h\fP, \fB\-\-help\fP
+Print command\(hyline option help.
+.B \-h
+.IP
+Print command line option help.
+.LP
+.SH AUTHOR
+.SH AUTHORS
 Written by Nelson Elhage and Alejandro Sedeno at the Massachusetts
 Institute of Technology. Based on Owl by James Kretchmar.
+Institute of Technology.  Based on Owl by James Kretchmar.
 Comments, questions, and bug reports may be mailed to
 \fBbug-barnowl@mit.edu\fP.
+\fBbug\-barnowl@mit.edu\fP.

editcontext.c

r4a41f16	rf271129
1	1	#include "owl.h"
2
3	2	#include <assert.h>
4	3
…	…
8	7	}
9	8
10		owl_context owl_editcontext_new(int mode, owl_editwin e, const char keymap, void (deactivate_cb)(owl_context), void cbdata)
	9	CALLER_OWN owl_context owl_editcontext_new(int mode, owl_editwin e, const char keymap, void (deactivate_cb)(owl_context), void cbdata)
11	10	{
12	11	owl_context *ctx = owl_context_new(mode, owl_editwin_ref(e), keymap,

editwin.c

-                      r3b8a563
+                      r8258ea5
 #include "owl.h"
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <ctype.h>
 #define VALID_EXCURSION (0x9a2b4729)
 …
   oe_excursion *excursions;
   void (*callback)(struct _owl_editwin*);
+  void (*callback)(struct _owl_editwin *e, bool success);
   void (*destroy_cbdata)(void *);
   void *cbdata;
 …
 static const char *oe_copy_buf(owl_editwin *e, const char *buf, int len);
 static int oe_copy_region(owl_editwin *e);
 static char *oe_chunk(owl_editwin *e, int start, int end);
+static CALLER_OWN char *oe_chunk(owl_editwin *e, int start, int end);
 static void oe_destroy_cbdata(owl_editwin *e);
 static void oe_dirty(owl_editwin *e);
 …
 #define WHITESPACE " \n\t"
 static owl_editwin *owl_editwin_allocate(void)
+static CALLER_OWN owl_editwin *owl_editwin_allocate(void)
+{
   owl_editwin *e = g_new0(owl_editwin, 1);
 …
+}
 owl_editwin *owl_editwin_new(owl_window *win, int winlines, int wincols, int style, owl_history *hist)
+CALLER_OWN owl_editwin *owl_editwin_new(owl_window *win, int winlines, int wincols, int style, owl_history *hist)
+{
   owl_editwin *e = owl_editwin_allocate();
 …
+}
 void owl_editwin_set_callback(owl_editwin *e, void (*cb)(owl_editwin*))
+void owl_editwin_set_callback(owl_editwin *e, void (*cb)(owl_editwin *, bool))
+{
   e->callback = cb;
+}
 void (*owl_editwin_get_callback(owl_editwin *e))(owl_editwin*)
+void (*owl_editwin_get_callback(owl_editwin *e))(owl_editwin *, bool)
+{
   return e->callback;
 …
+}
+void owl_editwin_do_callback(owl_editwin *e) {
+  void (*cb)(owl_editwin*);
+  cb=owl_editwin_get_callback(e);
+  if(!cb) {
+void owl_editwin_do_callback(owl_editwin *e, bool success)
+{
+  void (*cb)(owl_editwin *, bool);
+  cb = owl_editwin_get_callback(e);
+  if (!cb) {
     owl_function_error("Internal error: No editwin callback!");
   } else {
+    /* owl_function_error("text: |%s|", owl_editwin_get_text(e)); */
+    cb(e);
+    cb(e, success);
+  }
+}
 …
   if (!g_utf8_validate(s, -1, NULL)) {
     owl_function_debugmsg("owl_editwin_insert_string: received non-utf-8 string.");
+    owl_function_debugmsg("owl_editwin_insert_string: received non-UTF-8 string.");
     return 0;
+  }
 …
+{
   oe_excursion x;
+  gunichar ch;
+  gunichar ch = 0;
+  gunichar last_ch;
   int sentence;
 …
+    }
+    last_ch = ch;
     ch = owl_editwin_get_char_at_point(e);
 …
+    }
+    if(ch == '.' || ch == '!' || ch == '?')
+    if (ch == '.' || ch == '!' || ch == '?' ||
+        (ch == '"' && (last_ch == '.' || last_ch == '!' || last_ch == '?')))
       sentence = 1;
     else
 …
+}
 char *owl_editwin_get_region(owl_editwin *e)
+CALLER_OWN char *owl_editwin_get_region(owl_editwin *e)
+{
   int start, end;
 …
+}
 static char *oe_chunk(owl_editwin *e, int start, int end)
+static CALLER_OWN char *oe_chunk(owl_editwin *e, int start, int end)
+{
   char *p;

errqueue.c

rd4927a7	reb897c6
3	3	void owl_errqueue_init(owl_errqueue *eq)
4	4	{
5		~~owl_list_create(&(eq->errlist)~~);
	5	eq->errlist = g_ptr_array_new();
6	6	}
7	7
8	8	void owl_errqueue_append_err(owl_errqueue eq, const char msg)
9	9	{
10		~~owl_list_append_element(&(eq->errlist)~~, g_strdup(msg));
	10	g_ptr_array_add(eq->errlist, g_strdup(msg));
11	11	}
12	12
…	…
14	14	void owl_errqueue_to_fmtext(const owl_errqueue eq, owl_fmtext fm)
15	15	{
16		int i, j;
17
18		j=owl_list_get_size(&(eq->errlist));
19		for (i=0; i<j; i++) {
20		owl_fmtext_append_normal(fm, owl_list_get_element(&(eq->errlist), i));
	16	int i;
	17	for (i = 0; i < eq->errlist->len; i++) {
	18	owl_fmtext_append_normal(fm, eq->errlist->pdata[i]);
21	19	owl_fmtext_append_normal(fm, "\n");
22	20	}

filter.c

-                      re56303f
+                      rc068c03
-#include <string.h>
 #include "owl.h"
 …
   op1 = owl_filter_parse_primitive_expression(argc-i, argv+i, &skip);
+  if(!op1) goto err;
   i += skip;
-  if(!op1) goto err;
   while(i < argc) {
 …
 char* owl_filter_print(const owl_filter *f)
+CALLER_OWN char *owl_filter_print(const owl_filter *f)
+{
   GString *out = g_string_new("");
 …
+    }
     else {
       g_string_append_printf(out, "%i",f->fgcolor);
+      g_string_append_printf(out, "%i",f->bgcolor);
+    }
     g_string_append(out, " ");

filterelement.c

rd4927a7	r7756dde
104	104	}
105	105
106		/* XXX: Our boolea operators short-circuit here. The original owl did
	106	/* XXX: Our boolean operators short-circuit here. The original owl did
107	107	not. Do we care?
108	108	*/

filterproc.c

-                      re2cc848
+                      r7155955
+#include <signal.h>
+#include "filterproc.h"
+#include <sys/wait.h>
+#include <fcntl.h>
+#include <glib.h>
+#include <poll.h>
+#include <string.h>
 #include <unistd.h>
-#include <sys/select.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <poll.h>
-#include <fcntl.h>
-#include <string.h>
+#include <glib.h>
 int send_receive(int rfd, int wfd, const char *out, char **in)
+/* 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)
+{
   GString *str = g_string_new("");
 …
   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;
+  }
   while(1) {
 …
+      }
       if(!out || !*out || fds[1].revents & (POLLERR | POLLHUP)) {
         close(wfd);
+        close(wfd); wfd = -1;
         out = NULL;
+      }
 …
+  }
+  if (wfd >= 0) close(wfd);
+  close(rfd);
   *in = g_string_free(str, err < 0);
   return err;
+}
 int call_filter(const char *prog, const char *const *argv, const char *in, char **out, int *status)
+int call_filter(const char *const *argv, const char *in, char **out, int *status)
+{
+  int err = 0;
+  pid_t pid;
+  int rfd[2];
+  int wfd[2];
+  int err;
+  GPid child_pid;
+  int child_stdin, child_stdout;
+  if((err = pipe(rfd))) goto out;
+  if((err = pipe(wfd))) goto out_close_rfd;
+  pid = fork();
+  if(pid < 0) {
+    err = pid;
+    goto out_close_all;
+  }
+  if(pid) {
+    /* parent */
+    close(rfd[1]);
+    close(wfd[0]);
+    err = send_receive(rfd[0], wfd[1], in, out);
+    if(err == 0) {
+      waitpid(pid, status, 0);
+    }
+  } else {
+    /* child */
+    close(rfd[0]);
+    close(wfd[1]);
+    dup2(rfd[1], 1);
+    dup2(wfd[0], 0);
+    close(rfd[1]);
+    close(wfd[0]);
+    if(execvp(prog, (char *const *)argv)) {
+      _exit(-1);
+    }
+  if (!g_spawn_async_with_pipes(NULL, (char**)argv, NULL,
+                                G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD,
+                                NULL, NULL,
+                                &child_pid, &child_stdin, &child_stdout, NULL,
+                                NULL)) {
+    *out = NULL;
+    return 1;
+  }
+ out_close_all:
+  close(wfd[0]);
+  close(wfd[1]);
+ out_close_rfd:
+  close(rfd[0]);
+  close(rfd[1]);
+ out:
+  err = send_receive(child_stdout, child_stdin, in, out);
+  if (err == 0) {
+    waitpid(child_pid, status, 0);
+  }
   return err;
+}

filterproc.h

-                      r06adc25
+                      r97cdbaf5
 #define INC_BARNOWL_FILTER_PROC_H
+int call_filter(const char *prog,
+                const char *const *argv,
+int call_filter(const char *const *argv,
                 const char *in,
                 char **out, int *status);

fmtext.c

-                      r7b4f3be
+                      rf271129
 #include "owl.h"
-#include <stdlib.h>
-#include <string.h>
 /* initialize an fmtext with no data */
 …
  * freeing the return
  */
 char *owl_fmtext_print_plain(const owl_fmtext *f)
+CALLER_OWN char *owl_fmtext_print_plain(const owl_fmtext *f)
+{
   return owl_strip_format_chars(f->buff->str);
 …
 static void _owl_fmtext_wcolor_set(WINDOW *w, short pair)
+{
+  cchar_t background;
+  wchar_t blank[2] = { ' ', 0 };
   if (has_colors()) {
+      wcolor_set(w,pair,NULL);
+      wbkgdset(w, COLOR_PAIR(pair));
+      wcolor_set(w, pair, NULL);
+      /* Set the background with wbkgrndset so that we can handle color-pairs
+       * past 256 on ncurses ABI 6 and later. */
+      setcchar(&background, blank, 0, pair, NULL);
+      wbkgrndset(w, &background);
+  }
+}
 …
          * 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++;
 …
  * If format_fn is specified, passes it the list element value
  * and it will return a string which this needs to free. */
 void owl_fmtext_append_list(owl_fmtext *f, const owl_list *l, const char *join_with, char *(format_fn)(const char *))
+{
   int i, size;
+void owl_fmtext_append_list(owl_fmtext *f, const GPtrArray *l, const char *join_with, char *(format_fn)(const char *))
+{
+  int i;
   const char *elem;
   char *text;
+  size = owl_list_get_size(l);
+  for (i=0; i<size; i++) {
+    elem = owl_list_get_element(l,i);
+  for (i = 0; i < l->len; i++) {
+    elem = l->pdata[i];
     if (elem && format_fn) {
       text = format_fn(elem);
 …
       owl_fmtext_append_normal(f, elem);
+    }
     if ((i < size-1) && join_with) {
+    if ((i < l->len - 1) && join_with) {
       owl_fmtext_append_normal(f, join_with);
+    }

functions.c

-                      r259e60a8
+                      r60e8617
+#include "owl.h"
+#include "filterproc.h"
 #include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <signal.h>
-#include <netinet/in.h>
-#include <string.h>
-#include <time.h>
-#include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/wait.h>
+#include <errno.h>
+#include <signal.h>
+#include "owl.h"
+#include "filterproc.h"
+char *owl_function_command(const char *cmdbuff)
+CALLER_OWN char *owl_function_command(const char *cmdbuff)
+{
   owl_function_debugmsg("executing command: %s", cmdbuff);
 …
+}
 char *owl_function_command_argv(const char *const *argv, int argc)
+CALLER_OWN char *owl_function_command_argv(const char *const *argv, int argc)
+{
   return owl_cmddict_execute_argv(owl_global_get_cmddict(&g),
 …
 void owl_function_show_commands(void)
+{
   owl_list l;
+  GPtrArray *l;
   owl_fmtext fm;
 …
   owl_fmtext_append_bold(&fm, "Commands:  ");
   owl_fmtext_append_normal(&fm, "(use 'show command <name>' for details)\n");
+  owl_list_create(&l);
+  owl_cmddict_get_names(owl_global_get_cmddict(&g), &l);
+  owl_fmtext_append_list(&fm, &l, "\n", owl_function_cmd_describe);
+  l = owl_cmddict_get_names(owl_global_get_cmddict(&g));
+  owl_fmtext_append_list(&fm, l, "\n", owl_function_cmd_describe);
   owl_fmtext_append_normal(&fm, "\n");
   owl_function_popless_fmtext(&fm);
   owl_list_cleanup(&l, g_free);
+  owl_ptr_array_free(l, g_free);
   owl_fmtext_cleanup(&fm);
+}
 …
 void owl_function_show_styles(void) {
   owl_list l;
+  GPtrArray *l;
   owl_fmtext fm;
   owl_fmtext_init_null(&fm);
   owl_fmtext_append_bold(&fm, "Styles:\n");
+  owl_list_create(&l);
+  owl_global_get_style_names(&g, &l);
+  owl_fmtext_append_list(&fm, &l, "\n", owl_function_style_describe);
+  l = owl_global_get_style_names(&g);
+  owl_fmtext_append_list(&fm, l, "\n", owl_function_style_describe);
   owl_fmtext_append_normal(&fm, "\n");
   owl_function_popless_fmtext(&fm);
   owl_list_cleanup(&l, g_free);
+  owl_ptr_array_free(l, g_free);
   owl_fmtext_cleanup(&fm);
+}
+static void _owl_function_timer_append_fmtext(gpointer data, gpointer user_data) {
+  owl_fmtext *fm = user_data;
+  owl_timer *timer = data;
+  char *str = g_strdup_printf("- %s: in %d seconds",
+                              timer->name ? timer->name : "(unnamed)",
+                              (int)(timer->time - time(NULL)));
+  owl_fmtext_append_normal(fm, str);
+  g_free(str);
+  if (timer->interval) {
+    str = g_strdup_printf(", repeat every %d seconds", timer->interval);
+    owl_fmtext_append_normal(fm, str);
+    g_free(str);
+  }
+  owl_fmtext_append_normal(fm, "\n");
+}
+void owl_function_show_timers(void) {
+  owl_fmtext fm;
+  GList **timers;
+  owl_fmtext_init_null(&fm);
+  owl_fmtext_append_bold(&fm, "Active timers:\n");
+  timers = owl_global_get_timerlist(&g);
+  g_list_foreach(*timers, _owl_function_timer_append_fmtext, &fm);
+  owl_function_popless_fmtext(&fm);
+  owl_fmtext_cleanup(&fm);
+}
+char *owl_function_style_describe(const char *name) {
+CALLER_OWN char *owl_function_style_describe(const char *name)
+{
   const char *desc;
   char *s;
 …
+}
 char *owl_function_cmd_describe(const char *name)
+CALLER_OWN char *owl_function_cmd_describe(const char *name)
+{
   const owl_cmd *cmd = owl_cmddict_find(owl_global_get_cmddict(&g), name);
 …
   text=""
     "barnowl version " OWL_VERSION_STRING "\n"
+    "BarnOwl version " OWL_VERSION_STRING "\n"
     "Copyright (c) 2006-2011 The BarnOwl Developers. All rights reserved.\n"
     "Copyright (c) 2004 James Kretchmar. All rights reserved.\n"
 …
     "\n"
     "   * Redistributions in any form must be accompanied by information on\n"
     "     how to obtain complete source code for the Owl software and any\n"
     "     accompanying software that uses the Owl software. The source code\n"
+    "     how to obtain complete source code for the BarnOwl software and any\n"
+    "     accompanying software that uses the BarnOwl software. The source code\n"
     "     must either be included in the distribution or be available for no\n"
     "     more than the cost of distribution plus a nominal fee, and must be\n"
 …
   /* do followlast if necessary */
   if (owl_global_should_followlast(&g)) owl_function_lastmsg_noredisplay();
+  if (owl_global_should_followlast(&g)) owl_function_lastmsg();
   /* redisplay etc. */
 …
 void owl_function_add_outgoing_zephyrs(const owl_zwrite *z)
+{
   if (z->cc || owl_zwrite_get_numrecips(z) == 0) {
+  if (z->cc && owl_zwrite_is_personal(z)) {
     /* create the message */
     owl_message *m = g_new(owl_message, 1);
 …
     int i;
     for (i = 0; i < owl_zwrite_get_numrecips(z); i++) {
+      owl_message *m;
+      if (!owl_zwrite_recip_is_personal(owl_zwrite_get_recip_n(z, i)))
+        continue;
       /* create the message */
       owl_message *m = g_new(owl_message, 1);
+      m = g_new(owl_message, 1);
       owl_message_create_from_zwrite(m, z, owl_zwrite_get_message(z), i);
 …
  * owl_global_messagequeue_addmsg() for that.
  */
 owl_message *owl_function_make_outgoing_aim(const char *body, const char *to)
+CALLER_OWN owl_message *owl_function_make_outgoing_aim(const char *body, const char *to)
+{
   owl_message *m;
 …
  * owl_global_messagequeue_addmsg() for that.
  */
 owl_message *owl_function_make_outgoing_loopback(const char *body)
+CALLER_OWN owl_message *owl_function_make_outgoing_loopback(const char *body)
+{
   owl_message *m;
 …
+}
 void owl_function_start_edit_win(const char *line, void (*callback)(owl_editwin *), void *data, void (*cleanup)(void *))
+owl_editwin *owl_function_start_edit_win(const char *line)
+{
   owl_editwin *e;
 …
   g_free(s);
-  owl_editwin_set_cbdata(e, data, cleanup);
-  owl_editwin_set_callback(e, callback);
   ctx = owl_editcontext_new(OWL_CTX_EDITMULTI, e, "editmulti",
                             owl_global_deactivate_editcontext, &g);
   owl_global_push_context_obj(&g, ctx);
+  return e;
+}
 …
 void owl_function_zwrite_setup(owl_zwrite *z)
+{
+  owl_editwin *e;
   /* send a ping if necessary */
   if (owl_global_is_txping(&g)) {
 …
   owl_function_write_setup("zephyr");
   owl_function_start_edit_win(z->zwriteline,
                               &owl_callback_zwrite,
                               z, (void(*)(void*))owl_zwrite_delete);
+  e = owl_function_start_edit_win(z->zwriteline);
+  owl_editwin_set_cbdata(e, z, (void (*)(void *))owl_zwrite_delete);
+  owl_editwin_set_callback(e, &owl_callback_zwrite);
+}
 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");
+  owl_function_start_edit_win(line,
+                              &owl_callback_aimwrite,
+                              g_strdup(to),
+                              g_free);
+  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)
+{
+  owl_editwin *e;
   owl_function_write_setup("message");
+  owl_function_start_edit_win("loopwrite",
+                              &owl_callback_loopwrite,
+                              NULL, NULL);
+}
+void owl_callback_zwrite(owl_editwin *e) {
+  e = owl_function_start_edit_win("loopwrite");
+  owl_editwin_set_callback(e, &owl_callback_loopwrite);
+}
+void owl_callback_zwrite(owl_editwin *e, bool success)
+{
+  if (!success) return;
   owl_zwrite *z = owl_editwin_get_cbdata(e);
   owl_function_zwrite(z, owl_editwin_get_text(e));
 …
   owl_function_makemsg("Waiting for ack...");
+  /* If it's personal */
+  if (owl_zwrite_is_personal(z)) {
+    /* create the outgoing message */
+    owl_function_add_outgoing_zephyrs(z);
+  }
+  /* create the outgoing message */
+  owl_function_add_outgoing_zephyrs(z);
+}
 #else
 …
   old_msg = g_strdup(owl_zwrite_get_message(z));
   zcrypt = g_strdup_printf("%s/zcrypt", owl_get_bindir());
   argv[0] = "zcrypt";
+  zcrypt = g_build_filename(owl_get_bindir(), "zcrypt", NULL);
+  argv[0] = zcrypt;
   argv[1] = "-E";
   argv[2] = "-c"; argv[3] = owl_zwrite_get_class(z);
 …
   argv[6] = NULL;
   rv = call_filter(zcrypt, argv, owl_zwrite_get_message(z), &cryptmsg, &status);
+  rv = call_filter(argv, owl_zwrite_get_message(z), &cryptmsg, &status);
   g_free(zcrypt);
 …
   owl_function_makemsg("Waiting for ack...");
+  /* If it's personal */
+  if (owl_zwrite_is_personal(z)) {
+    /* Create the outgoing message. Restore the un-crypted message for display. */
+    owl_zwrite_set_message_raw(z, old_msg);
+    owl_function_add_outgoing_zephyrs(z);
+  }
+  /* free the zwrite */
+  /* Create the outgoing message. Restore the un-crypted message for display. */
+  owl_zwrite_set_message_raw(z, old_msg);
+  owl_function_add_outgoing_zephyrs(z);
+  /* Clean up. */
   g_free(cryptmsg);
+}
+void owl_callback_aimwrite(owl_editwin *e) {
+  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_callback_loopwrite(owl_editwin *e) {
+void owl_callback_loopwrite(owl_editwin *e, bool success)
+{
+  if (!success) return;
   owl_function_loopwrite(owl_editwin_get_text(e));
+}
 …
+{
   owl_function_prevmsg_full(NULL, 1, 1);
+}
+void owl_function_delete_and_expunge_message(int n)
+{
+  owl_messagelist *ml = owl_global_get_msglist(&g);
+  owl_view *v = owl_global_get_current_view(&g);
+  int lastmsgid = owl_function_get_curmsg_id(v);
+  /* delete and expunge the message */
+  owl_messagelist_delete_and_expunge_element(ml, n);
+  owl_function_redisplay_to_nearest(lastmsgid, v);
+}
+void owl_function_delete_and_expunge_cur(bool exclaim_success)
+{
+  int curmsg;
+  const owl_view *v = owl_global_get_current_view(&g);
+  /* bail if there's no current message */
+  if (owl_view_get_size(v) < 1) {
+    owl_function_error("No current message to delete");
+    return;
+  }
+  /* delete the current message */
+  curmsg = owl_global_get_curmsg(&g);
+  owl_function_delete_and_expunge_message(curmsg);
+  if (exclaim_success)
+    owl_function_makemsg("Message deleted and expunged");
+}
 …
+}
+/* returns the current message id, if it exists.  Otherwise returns
+ * -1 if we are past the end of the message list, and 0 otherwise. */
+int owl_function_get_curmsg_id(const owl_view *v)
+{
+  int curmsg = owl_global_get_curmsg(&g);
+  const owl_message *m = owl_view_get_element(v, curmsg);
+  if (m)
+    return owl_message_get_id(m);
+  if (curmsg > 0) /* past the end of the message list (probably) */
+    return -1;
+  return 0;
+}
+/* redisplays the view to the nearest message to the id given.
+ * if msgid < 0, redisplay to past the end of the message list */
+void owl_function_redisplay_to_nearest(int msgid, owl_view *v)
+{
+  int curmsg;
+  /* update all views (we only have one right now) */
+  owl_view_recalculate(v);
+  /* find where the new position should be */
+  if (msgid < 0) {
+    /* If already at the end, blank the screen and move curmsg
+     * past the end of the messages. */
+    curmsg = owl_view_get_size(v);
+    owl_global_set_topmsg(&g, curmsg);
+    owl_global_set_curmsg(&g, curmsg);
+  } else {
+    curmsg = owl_view_get_nearest_to_msgid(v, msgid);
+    if (curmsg > owl_view_get_size(v) - 1)
+      curmsg = owl_view_get_size(v) - 1;
+    if (curmsg < 0)
+      curmsg = 0;
+    owl_global_set_curmsg(&g, curmsg);
+    owl_function_calculate_topmsg(OWL_DIRECTION_NONE);
+  }
+  /* if there are no messages set the direction to down in case we
+   * delete everything upwards */
+  owl_global_set_direction_downwards(&g);
+  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
+}
 void owl_function_expunge(void)
+{
+  int curmsg;
+  const owl_message *m;
+  owl_messagelist *ml;
+  owl_view *v;
+  int lastmsgid=0;
+  curmsg=owl_global_get_curmsg(&g);
+  v=owl_global_get_current_view(&g);
+  ml=owl_global_get_msglist(&g);
+  m=owl_view_get_element(v, curmsg);
+  if (m) lastmsgid = owl_message_get_id(m);
+  owl_messagelist *ml = owl_global_get_msglist(&g);
+  owl_view *v = owl_global_get_current_view(&g);
+  int lastmsgid = owl_function_get_curmsg_id(v);
   /* expunge the message list */
   owl_messagelist_expunge(ml);
+  /* update all views (we only have one right now) */
+  owl_view_recalculate(v);
+  /* find where the new position should be
+     (as close as possible to where we last where) */
+  curmsg = owl_view_get_nearest_to_msgid(v, lastmsgid);
+  if (curmsg>owl_view_get_size(v)-1) curmsg = owl_view_get_size(v)-1;
+  if (curmsg<0) curmsg = 0;
+  owl_global_set_curmsg(&g, curmsg);
+  owl_function_calculate_topmsg(OWL_DIRECTION_NONE);
+  /* if there are no messages set the direction to down in case we
+     delete everything upwards */
+  owl_global_set_direction_downwards(&g);
+  owl_function_redisplay_to_nearest(lastmsgid, v);
   owl_function_makemsg("Messages expunged");
-  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
+}
 …
+}
 void owl_function_lastmsg_noredisplay(void)
+void owl_function_lastmsg(void)
+{
   int oldcurmsg, curmsg;
 …
     owl_global_set_curmsg(&g, curmsg+1);
+  }
   /* owl_mainwin_redisplay(owl_global_get_mainwin(&g)); */
+  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
   owl_global_set_direction_downwards(&g);
+}
-void owl_function_lastmsg(void)
+{
-  owl_function_lastmsg_noredisplay();
-  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
+}
 …
 void owl_function_unsuball(void)
+{
   unsuball();
   owl_function_makemsg("Unsubscribed from all messages.");
+  if (unsuball())
+    owl_function_makemsg("Unsubscribed from all messages.");
+}
 …
 void owl_function_loadsubs(const char *file)
+{
+  int ret, ret2;
+  const char *foo;
+  int ret, ret2, ret3;
   char *path;
 …
   /* for backwards compatibility for now */
+  ret2=owl_zephyr_loaddefaultsubs();
+  ret2 = owl_zephyr_loaddefaultsubs();
+  ret3 = owl_zephyr_loadbarnowldefaultsubs();
   if (!owl_context_is_interactive(owl_global_get_context(&g))) return;
+  foo=file?file:"file";
+  if (ret==0 && ret2==0) {
+  if (ret == 0 && ret2 == 0 && ret3 == 0) {
     if (!file) {
       owl_function_makemsg("Subscribed to messages.");
 …
       owl_function_makemsg("Subscribed to messages from %s", file);
+    }
   } else if (ret==-1) {
     owl_function_error("Could not read %s", foo);
   } else {
+  } else if (ret == -1) {
+    owl_function_error("Could not read %s", file ? file : "file");
+  } else if (ret2 == -1) {
     owl_function_error("Error subscribing to messages");
+  } else {
+    owl_function_error("Error subscribing to instanced personals");
+  }
+}
 …
+}
+void owl_callback_aimlogin(owl_editwin *e) {
+void owl_callback_aimlogin(owl_editwin *e, bool success)
+{
+  if (!success) return;
   char *user = owl_editwin_get_cbdata(e);
   owl_function_aimlogin(user,
 …
+  }
   owl_function_debugmsg("Quitting Owl");
+  owl_function_debugmsg("Quitting BarnOwl");
   owl_select_quit_loop();
+}
 …
 void G_GNUC_PRINTF(1, 2) owl_function_debugmsg(const char *fmt, ...)
+{
+  char *tmpbuff;
   FILE *file;
   time_t now;
 …
   now = time(NULL);
+  fprintf(file, "[%d -  %.24s - %lds]: ",
+          (int) getpid(), ctime(&now), now - owl_global_get_starttime(&g));
+  tmpbuff = owl_util_format_time(localtime(&now));
+  fprintf(file, "[%d -  %s - %lds]: ",
+          (int) getpid(), tmpbuff, now - owl_global_get_starttime(&g));
+  g_free(tmpbuff);
   vfprintf(file, fmt, ap);
   putc('\n', file);
 …
+}
+static void _dirty_everything(owl_window *w) {
+static void _dirty_everything(gpointer data, gpointer user_data) {
+  owl_window *w = data;
   if (!owl_window_is_realized(w))
     return;
   owl_window_dirty(w);
   owl_window_children_foreach(w, (GFunc)_dirty_everything, NULL);
+  owl_window_children_foreach(w, _dirty_everything, NULL);
+}
 …
+{
   /* Ask every widget to redraw itself. */
   _dirty_everything(owl_window_get_screen());
+  _dirty_everything(owl_window_get_screen(), NULL);
   /* Force ncurses to redisplay everything. */
   clearok(stdscr, TRUE);
 …
+{
   owl_function_popless_text(
     "This is barnowl version " OWL_VERSION_STRING ".\n\n"
     "barnowl is a fork of the Owl zephyr client, written and\n"
+    "This is BarnOwl version " OWL_VERSION_STRING ".\n\n"
+    "BarnOwl is a fork of the Owl zephyr client, written and\n"
     "maintained by Alejandro Sedeno and Nelson Elhage at the\n"
     "Massachusetts Institute of Technology. \n"
 …
     "The name 'owl' was chosen in reference to the owls in the\n"
     "Harry Potter novels, who are tasked with carrying messages\n"
     "between Witches and Wizards. The name 'barnowl' was chosen\n"
+    "between Witches and Wizards. The name 'BarnOwl' was chosen\n"
     "because we feel our owls should live closer to our ponies.\n"
     "\n"
 …
   owl_fmtext fm, attrfm;
   const owl_view *v;
+  char *time;
 #ifdef HAVE_LIBZEPHYR
   const ZNotice_t *n;
 …
+  }
+  owl_fmtext_appendf_normal(&fm, "  Time      : %s\n", owl_message_get_timestr(m));
+  time = owl_message_format_time(m);
+  owl_fmtext_appendf_normal(&fm, "  Time      : %s\n", time);
+  g_free(time);
   if (!owl_message_is_type_admin(m)) {
 …
     owl_fmtext_appendf_normal(&fm, "  Opcode    : %s\n", owl_message_get_opcode(m));
 #ifdef HAVE_LIBZEPHYR
+    if (owl_message_is_direction_in(m)) {
+      char *tmpbuff;
+    n = owl_message_get_notice(m);
+    if (n != NULL) {
+      char *tmpbuff, *tmpbuff2;
       int i, fields;
+      n=owl_message_get_notice(m);
+      const char *f;
       if (!owl_message_is_pseudo(m)) {
 …
         owl_fmtext_appendf_normal(&fm, "  Fields    : %i\n", fields);
+        for (i = 0; i < fields; i++) {
+          tmpbuff = owl_zephyr_get_field_as_utf8(n, i + 1);
+          g_strdelimit(tmpbuff, "\n", '~');
+          g_strdelimit(tmpbuff, "\r", '!');
+          owl_fmtext_appendf_normal(&fm, "  Field %i   : %s\n", i + 1, tmpbuff);
+          g_free(tmpbuff);
+        for (i = 0, f = owl_zephyr_first_raw_field(n); f != NULL;
+             i++, f = owl_zephyr_next_raw_field(n, f)) {
+          tmpbuff = owl_zephyr_field_as_utf8(n, f);
+          tmpbuff2 = owl_text_indent(tmpbuff, 14, false);
+          owl_fmtext_appendf_normal(&fm, "  Field %i   : %s\n", i + 1, tmpbuff2);
+          g_free(tmpbuff2);
+          g_free(tmpbuff);
+        }
+        owl_fmtext_appendf_normal(&fm, "  Default Fm: %s\n", n->z_default_format);
+        tmpbuff = owl_text_indent(n->z_default_format, 14, false);
+        owl_fmtext_appendf_normal(&fm, "  Default Fm: %s\n", tmpbuff);
+        g_free(tmpbuff);
+      }
 …
+  }
   owl_fmtext_append_bold(&fm, "\nOwl Message Attributes:\n");
+  owl_fmtext_append_bold(&fm, "\nBarnOwl Message Attributes:\n");
   owl_message_attributes_tofmtext(m, &attrfm);
   owl_fmtext_append_fmtext(&fm, &attrfm);
 …
 void owl_function_printallvars(void)
+{
+  const owl_variable *v;
   const char *name;
   char *var;
   owl_list varnames;
   int i, numvarnames;
+  GPtrArray *varnames;
+  int i;
   GString *str   = g_string_new("");
   g_string_append_printf(str, "%-20s = %s\n", "VARIABLE", "VALUE");
   g_string_append_printf(str, "%-20s   %s\n",  "--------", "-----");
+  owl_list_create(&varnames);
+  owl_variable_dict_get_names(owl_global_get_vardict(&g), &varnames);
+  numvarnames = owl_list_get_size(&varnames);
+  for (i=0; i<numvarnames; i++) {
+    name = owl_list_get_element(&varnames, i);
+  varnames = owl_variable_dict_get_names(owl_global_get_vardict(&g));
+  for (i = 0; i < varnames->len; i++) {
+    name = varnames->pdata[i];
     if (name && name[0]!='_') {
       g_string_append_printf(str, "\n%-20s = ", name);
+      var = owl_variable_get_tostring(owl_global_get_vardict(&g), name);
+      v = owl_variable_get_var(owl_global_get_vardict(&g), name);
+      var = owl_variable_get_tostring(v);
       if (var) {
+        g_string_append(str, var);
+        g_free(var);
+        g_string_append(str, var);
+        g_free(var);
+      } else {
+        g_string_append(str, "<null>");
+      }
+    }
+  }
   g_string_append(str, "\n");
   owl_list_cleanup(&varnames, g_free);
+  owl_ptr_array_free(varnames, g_free);
   owl_function_popless_text(str->str);
 …
 void owl_function_show_variables(void)
+{
+  owl_list varnames;
+  const owl_variable *v;
+  GPtrArray *varnames;
   owl_fmtext fm;
   int i, numvarnames;
+  int i;
   const char *varname;
 …
   owl_fmtext_append_bold(&fm,
       "Variables: (use 'show variable <name>' for details)\n");
+  owl_list_create(&varnames);
+  owl_variable_dict_get_names(owl_global_get_vardict(&g), &varnames);
+  numvarnames = owl_list_get_size(&varnames);
+  for (i=0; i<numvarnames; i++) {
+    varname = owl_list_get_element(&varnames, i);
+  varnames = owl_variable_dict_get_names(owl_global_get_vardict(&g));
+  for (i = 0; i < varnames->len; i++) {
+    varname = varnames->pdata[i];
     if (varname && varname[0]!='_') {
+      owl_variable_describe(owl_global_get_vardict(&g), varname, &fm);
+    }
+  }
+  owl_list_cleanup(&varnames, g_free);
+      v = owl_variable_get_var(owl_global_get_vardict(&g), varname);
+      owl_variable_describe(v, &fm);
+    }
+  }
+  owl_ptr_array_free(varnames, g_free);
   owl_function_popless_fmtext(&fm);
   owl_fmtext_cleanup(&fm);
 …
 void owl_function_show_variable(const char *name)
+{
+  const owl_variable *v;
   owl_fmtext fm;
   owl_fmtext_init_null(&fm);
+  owl_variable_get_help(owl_global_get_vardict(&g), name, &fm);
+  v = owl_variable_get_var(owl_global_get_vardict(&g), name);
+  if (v)
+    owl_variable_get_help(v, &fm);
+  else
+    owl_fmtext_append_normal(&fm, "No such variable...\n");
   owl_function_popless_fmtext(&fm);
   owl_fmtext_cleanup(&fm);
+}
+void owl_function_delete_and_expunge_by_id(int id, bool exclaim_success)
+{
+  const owl_messagelist *ml = owl_global_get_msglist(&g);
+  int msg = owl_messagelist_get_index_by_id(ml, id);
+  if (msg < 0) {
+    owl_function_error("No message with id %d: unable to delete", id);
+  } else {
+    owl_function_delete_and_expunge_message(msg);
+    if (exclaim_success)
+      owl_function_makemsg("Message deleted and expunged");
+  }
+}
 …
 void owl_function_status(void)
+{
+  char *tmpbuff;
   char buff[MAXPATHLEN+1];
   time_t start;
 …
   owl_fmtext_append_normal(&fm, "\n");
+  owl_fmtext_appendf_normal(&fm, "  Startup Time: %s", ctime(&start));
+  tmpbuff = owl_util_format_time(localtime(&start));
+  owl_fmtext_appendf_normal(&fm, "  Startup Time: %s\n", tmpbuff);
+  g_free(tmpbuff);
   up=owl_global_get_runtime(&g);
 …
     if (enter) {
       owl_history *hist = owl_global_get_cmd_history(&g);
+      owl_history_store(hist, buff);
+      owl_history_reset(hist);
+      owl_history_store(hist, buff, false);
       owl_function_command_norv(buff);
     } else {
 …
+}
+void owl_callback_command(owl_editwin *e)
+{
+void owl_callback_command(owl_editwin *e, bool success)
+{
+  if (!success) return;
   char *rv;
   const char *line = owl_editwin_get_text(e);
 …
+}
 void owl_function_start_command(const char *line)
+owl_editwin *owl_function_start_command(const char *line)
+{
   owl_editwin *tw;
 …
   owl_global_push_context_obj(&g, ctx);
   owl_editwin_set_callback(tw, owl_callback_command);
+  return tw;
+}
 …
+}
 char *owl_function_exec(int argc, const char *const *argv, const char *buff, int type)
+CALLER_OWN char *owl_function_exec(int argc, const char *const *argv, const char *buff, int type)
+{
   /* if type == 1 display in a popup
 …
+}
 char *owl_function_perl(int argc, const char *const *argv, const char *buff, int type)
+CALLER_OWN char *owl_function_perl(int argc, const char *const *argv, const char *buff, int type)
+{
   /* if type == 1 display in a popup
 …
 /* Create a new filter, or replace an existing one
  * with a new definition.
+ * with a new definition. Returns true on success.
  */
 void owl_function_create_filter(int argc, const char *const *argv)
+bool owl_function_create_filter(int argc, const char *const *argv)
+{
   owl_filter *f;
 …
   if (argc < 2) {
     owl_function_error("Wrong number of arguments to filter command");
     return;
+    return false;
+  }
 …
   if (!strcmp(argv[1], "all")) {
     owl_function_error("You may not change the 'all' filter.");
     return;
+    return false;
+  }
 …
     if (!f) {
       owl_function_error("The filter '%s' does not exist.", argv[1]);
       return;
+      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;
+      return false;
+    }
     owl_filter_set_fgcolor(f, owl_util_string_to_color(argv[3]));
     owl_mainwin_redisplay(owl_global_get_mainwin(&g));
     return;
+    return false;
+  }
   if (argc==4 && !strcmp(argv[2], "-b")) {
 …
     if (!f) {
       owl_function_error("The filter '%s' does not exist.", argv[1]);
       return;
+      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;
+      return false;
+    }
     owl_filter_set_bgcolor(f, owl_util_string_to_color(argv[3]));
     owl_mainwin_redisplay(owl_global_get_mainwin(&g));
     return;
+    return true;
+  }
 …
   f = owl_filter_new(argv[1], argc-2, argv+2);
   if (f == NULL) {
     owl_function_error("Invalid filter");
     return;
+    owl_function_error("Invalid filter: %s", argv[1]);
+    return false;
+  }
 …
+  }
   owl_mainwin_redisplay(owl_global_get_mainwin(&g));
+  return true;
+}
 …
  * Returns the name of the negated filter, which the caller must free.
  */
 char *owl_function_create_negative_filter(const char *filtername)
+CALLER_OWN char *owl_function_create_negative_filter(const char *filtername)
+{
   char *newname;
 …
+{
   const owl_filter *f;
   const owl_list *fl;
+  const GPtrArray *fl;
   char *tmp;
   owl_fmtext fm;
   int i, j;
+  int i;
   owl_fmtext_init_null(&fm);
   fl=owl_global_get_puntlist(&g);
-  j=owl_list_get_size(fl);
   owl_fmtext_append_bold(&fm, "Active zpunt filters:\n");
   for (i=0; i<j; i++) {
     f=owl_list_get_element(fl, i);
+  for (i = 0; i < fl->len; i++) {
+    f = fl->pdata[i];
     owl_fmtext_appendf_normal(&fm, "[% 2d] ", i+1);
     tmp = owl_filter_print(f);
 …
  * If 'related' is nonzero, encompass unclasses and .d classes as well.
  */
 char *owl_function_classinstfilt(const char *c, const char *i, int related)
+CALLER_OWN char *owl_function_classinstfilt(const char *c, const char *i, int related)
+{
   owl_filter *f;
 …
  * the filter, which the caller must free.
  */
 char *owl_function_zuserfilt(const char *longuser)
+CALLER_OWN char *owl_function_zuserfilt(const char *longuser)
+{
   owl_filter *f;
 …
  * Returns the name of the filter, which the caller must free.
  */
 char *owl_function_aimuserfilt(const char *user)
+CALLER_OWN char *owl_function_aimuserfilt(const char *user)
+{
   owl_filter *f;
 …
   /* if it already exists then go with it.  This lets users override */
   if (owl_global_get_filter(&g, filtname)) {
     return(g_strdup(filtname));
+    return filtname;
+  }
 …
+}
 char *owl_function_typefilt(const char *type)
+CALLER_OWN char *owl_function_typefilt(const char *type)
+{
   owl_filter *f;
 …
+}
+static char *owl_function_smartfilter_cc(const owl_message *m) {
+static CALLER_OWN char *owl_function_smartfilter_cc(const owl_message *m)
+{
   const char *ccs;
   char *ccs_quoted;
 …
  *    name to the AIM conversation with that user
  */
 char *owl_function_smartfilter(int type, int invert_related)
+CALLER_OWN char *owl_function_smartfilter(int type, int invert_related)
+{
   const owl_view *v;
 …
   owl_function_punt(argv->len, (const char *const*) argv->pdata, direction);
+  g_ptr_array_foreach(argv, (GFunc)g_free, NULL);
+  g_ptr_array_free(argv, true);
+  owl_ptr_array_free(argv, g_free);
+}
 …
+{
   owl_filter *f;
   owl_list *fl;
   int i, j;
+  GPtrArray *fl;
+  int i;
   fl=owl_global_get_puntlist(&g);
 …
   /* Check for an identical filter */
+  j=owl_list_get_size(fl);
+  for (i=0; i<j; i++) {
+    if (owl_filter_equiv(f, owl_list_get_element(fl, i))) {
+  for (i = 0; i < fl->len; i++) {
+    if (owl_filter_equiv(f, fl->pdata[i])) {
       owl_function_debugmsg("found an equivalent punt filter");
       /* if we're punting, then just silently bow out on this duplicate */
 …
       /* if we're unpunting, then remove this filter from the puntlist */
       if (direction==1) {
+        owl_filter_delete(owl_list_get_element(fl, i));
+        owl_list_remove_element(fl, i);
+        owl_filter_delete(g_ptr_array_remove_index(fl, i));
         owl_filter_delete(f);
         return;
 …
     owl_function_debugmsg("punting");
     /* If we're punting, add the filter to the global punt list */
     owl_list_append_element(fl, f);
+    g_ptr_array_add(fl, f);
   } else if (direction == 1) {
     owl_function_makemsg("No matching punt filter");
 …
 void owl_function_show_keymaps(void)
+{
   owl_list l;
+  GPtrArray *l;
   owl_fmtext fm;
   const owl_keymap *km;
   const owl_keyhandler *kh;
   int i, numkm;
+  int i;
   const char *kmname;
 …
   owl_fmtext_append_bold(&fm, "Keymaps:   ");
   owl_fmtext_append_normal(&fm, "(use 'show keymap <name>' for details)\n");
+  owl_list_create(&l);
+  owl_keyhandler_get_keymap_names(kh, &l);
+  owl_fmtext_append_list(&fm, &l, "\n", owl_function_keymap_summary);
+  l = owl_keyhandler_get_keymap_names(kh);
+  owl_fmtext_append_list(&fm, l, "\n", owl_function_keymap_summary);
   owl_fmtext_append_normal(&fm, "\n");
+  numkm = owl_list_get_size(&l);
+  for (i=0; i<numkm; i++) {
+    kmname = owl_list_get_element(&l, i);
+  for (i = 0; i < l->len; i++) {
+    kmname = l->pdata[i];
     km = owl_keyhandler_get_keymap(kh, kmname);
     owl_fmtext_append_bold(&fm, "\n\n----------------------------------------------------------------------------------------------------\n\n");
 …
   owl_function_popless_fmtext(&fm);
   owl_list_cleanup(&l, g_free);
+  owl_ptr_array_free(l, g_free);
   owl_fmtext_cleanup(&fm);
+}
 char *owl_function_keymap_summary(const char *name)
+CALLER_OWN char *owl_function_keymap_summary(const char *name)
+{
   const owl_keymap *km
 …
 /* strips formatting from ztext and returns the unformatted text.
  * caller is responsible for freeing. */
 char *owl_function_ztext_stylestrip(const char *zt)
+CALLER_OWN char *owl_function_ztext_stylestrip(const char *zt)
+{
   owl_fmtext fm;
 …
 #ifdef HAVE_LIBZEPHYR
   int x;
   owl_list anyone;
+  GPtrArray *anyone;
   const char *user;
   char *tmp;
 …
       idle=owl_buddy_get_idle_time(b);
       if (idle!=0) {
         timestr=owl_util_minutes_to_timestr(idle);
+        timestr=owl_util_format_minutes(idle);
       } else {
         timestr=g_strdup("");
 …
     } else {
       owl_fmtext_append_bold(&fm, "Zephyr users logged in:\n");
+      owl_list_create(&anyone);
+      ret=owl_zephyr_get_anyone_list(&anyone, filename);
+      if (ret) {
+      anyone = owl_zephyr_get_anyone_list(filename);
+      if (anyone == NULL) {
         if (errno == ENOENT) {
           owl_fmtext_append_normal(&fm, " You have not added any zephyr buddies.  Use the\n");
 …
+        }
       } else {
+        j=owl_list_get_size(&anyone);
+        for (i=0; i<j; i++) {
+          user=owl_list_get_element(&anyone, i);
+        for (i = 0; i < anyone->len; i++) {
+          user = anyone->pdata[i];
           ret=ZLocateUser(zstr(user), &numlocs, ZAUTH);
 …
+        }
+      }
       owl_list_cleanup(&anyone, g_free);
+      owl_ptr_array_free(anyone, g_free);
+    }
+  }
 …
+    }
     /* if it exited, fork & exec a new one */
+    /* if it exited, spawn a new one */
     if (owl_global_get_newmsgproc_pid(&g)==0) {
-      pid_t i;
       int myargc;
+      i=fork();
+      if (i) {
+        /* parent set the child's pid */
+        owl_global_set_newmsgproc_pid(&g, i);
+        owl_function_debugmsg("I'm the parent and I started a new newmsgproc with pid %i", i);
+      } else {
+        /* child exec's the program */
+        char **parsed;
+        parsed=owl_parseline(owl_global_get_newmsgproc(&g), &myargc);
+        if (myargc < 0) {
+          owl_function_debugmsg("Could not parse newmsgproc '%s': unbalanced quotes?", owl_global_get_newmsgproc(&g));
+        }
+        if (myargc <= 0) {
+          _exit(127);
+        }
+        owl_function_debugmsg("About to exec \"%s\" with %d arguments", parsed[0], myargc);
+        execvp(parsed[0], parsed);
+        /* was there an error exec'ing? */
+        owl_function_debugmsg("Cannot run newmsgproc '%s': cannot exec '%s': %s",
+                              owl_global_get_newmsgproc(&g), parsed[0], strerror(errno));
+        _exit(127);
+      char **argv = owl_parseline(owl_global_get_newmsgproc(&g), &myargc);
+      if (myargc < 0) {
+        owl_function_debugmsg("Could not parse newmsgproc '%s': unbalanced quotes?",
+                              owl_global_get_newmsgproc(&g));
+      } else if (myargc > 0) {
+        /* Spawn the child. */
+        GPid pid;
+        GError *error = NULL;
+        owl_function_debugmsg("About to exec \"%s\" with %d arguments", argv[0], myargc);
+        if (g_spawn_async(NULL, argv, NULL,
+                          G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD,
+                          NULL, NULL, &pid, &error)) {
+          owl_global_set_newmsgproc_pid(&g, pid);
+          owl_function_debugmsg("I'm the parent and I started a new newmsgproc with pid %i", pid);
+        } else {
+          owl_function_debugmsg("Cannot run newmsgproc '%s': %s",
+                                owl_global_get_newmsgproc(&g), error->message);
+          g_error_free(error);
+        }
+      }
+      g_strfreev(argv);
+    }
+  }
 …
   char *buff;
+  now=time(NULL);
+  date=g_strdup(ctime(&now));
+  date[strlen(date)-1]='\0';
+  now = time(NULL);
+  date = owl_util_format_time(localtime(&now));
   buff = g_strdup_printf("%s %s", date, string);
 …
+{
 #ifdef HAVE_LIBZEPHYR
   int i, j;
   owl_list anyone;
+  int i;
+  GPtrArray *anyone;
   GList **zaldlist;
   GList *zaldptr;
 …
   *zaldlist = NULL;
+  owl_list_create(&anyone);
+  owl_zephyr_get_anyone_list(&anyone, NULL);
+  j = owl_list_get_size(&anyone);
+  for (i = 0; i < j; i++) {
+    user = owl_list_get_element(&anyone, i);
+    zald = g_new(ZAsyncLocateData_t, 1);
+    if (ZRequestLocations(zstr(user), zald, UNACKED, ZAUTH) == ZERR_NONE) {
+      *zaldlist = g_list_append(*zaldlist, zald);
+    } else {
+      g_free(zald);
+    }
+  }
+  owl_list_cleanup(&anyone, g_free);
+  anyone = owl_zephyr_get_anyone_list(NULL);
+  if (anyone != NULL) {
+    for (i = 0; i < anyone->len; i++) {
+      user = anyone->pdata[i];
+      zald = g_new(ZAsyncLocateData_t, 1);
+      if (ZRequestLocations(zstr(user), zald, UNACKED, ZAUTH) == ZERR_NONE) {
+        *zaldlist = g_list_append(*zaldlist, zald);
+      } else {
+        g_free(zald);
+      }
+    }
+    owl_ptr_array_free(anyone, g_free);
+  }
 #endif
+}
 void owl_function_aimsearch_results(const char *email, owl_list *namelist)
+void owl_function_aimsearch_results(const char *email, GPtrArray *namelist)
+{
   owl_fmtext fm;
   int i, j;
+  int i;
   owl_fmtext_init_null(&fm);
 …
   owl_fmtext_append_normal(&fm, ":\n");
+  j=owl_list_get_size(namelist);
+  for (i=0; i<j; i++) {
+  for (i = 0; i < namelist->len; i++) {
     owl_fmtext_append_normal(&fm, "  ");
     owl_fmtext_append_normal(&fm, owl_list_get_element(namelist, i));
+    owl_fmtext_append_normal(&fm, namelist->pdata[i]);
     owl_fmtext_append_normal(&fm, "\n");
+  }

global.c

-                      rf97c1a6
+                      r6383920
+#include "owl.h"
 #include <stdio.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <string.h>
-#include <netdb.h>
-#include <termios.h>
 #include <sys/ioctl.h>
-#include <time.h>
-#include "owl.h"
 static void _owl_global_init_windows(owl_global *g);
 …
   const char *homedir;
+#if !GLIB_CHECK_VERSION(2, 35, 0)
   g_type_init();
+#endif
+#if !GLIB_CHECK_VERSION(2, 31, 0)
   g_thread_init(NULL);
+#endif
   owl_select_init();
 …
   owl_dict_create(&(g->filters));
   g->filterlist = NULL;
   owl_list_create(&(g->puntlist));
+  g->puntlist = g_ptr_array_new();
   g->messagequeue = g_queue_new();
   owl_dict_create(&(g->styledict));
 …
   g->resizepending=0;
   g->direction=OWL_DIRECTION_DOWNWARDS;
-  g->zaway=0;
   owl_fmtext_init_colorpair_mgr(&(g->cpmgr));
   g->debug=OWL_DEBUG;
 …
   owl_history_init(&(g->msghist));
   owl_history_init(&(g->cmdhist));
-  owl_history_set_norepeats(&(g->cmdhist));
   g->nextmsgid=0;
 …
   g->confdir = NULL;
   g->startupfile = NULL;
   cd = g_strdup_printf("%s/%s", g->homedir, OWL_CONFIG_DIR);
+  cd = g_build_filename(g->homedir, OWL_CONFIG_DIR, NULL);
   owl_global_set_confdir(g, cd);
   g_free(cd);
   owl_messagelist_create(&(g->msglist));
+  g->msglist = owl_messagelist_new();
   _owl_global_init_windows(g);
 …
   owl_message_init_fmtext_cache();
-  owl_list_create(&(g->io_dispatch_list));
-  g->timerlist = NULL;
   g->kill_buffer = NULL;
   g->interrupt_count = 0;
+#if GLIB_CHECK_VERSION(2, 31, 0)
+  g_mutex_init(&g->interrupt_lock);
+#else
   g->interrupt_lock = g_mutex_new();
+#endif
+}
 …
   /* Create the widgets */
   owl_mainwin_init(&(g->mw), g->mainpanel.recwin);
+  g->mw = owl_mainwin_new(g->mainpanel.recwin);
   owl_msgwin_init(&(g->msgwin), g->mainpanel.msgwin);
   owl_sepbar_init(g->mainpanel.sepwin);
 …
 /* Pops the current context from the context stack and returns it. Caller is
  * responsible for freeing. */
+owl_context *owl_global_pop_context_no_delete(owl_global *g) {
+CALLER_OWN owl_context *owl_global_pop_context_no_delete(owl_global *g)
+{
   owl_context *c;
   if (!g->context_stack)
 …
 /* windows */
+owl_mainwin *owl_global_get_mainwin(owl_global *g) {
+  return(&(g->mw));
+owl_mainwin *owl_global_get_mainwin(owl_global *g)
+{
+  return g->mw;
+}
 …
 owl_messagelist *owl_global_get_msglist(owl_global *g) {
   return(&(g->msglist));
+  return g->msglist;
+}
 …
   g->confdir = g_strdup(cd);
   g_free(g->startupfile);
   g->startupfile = g_strdup_printf("%s/startup", cd);
+  g->startupfile = g_build_filename(cd, "startup", NULL);
+}
 …
 /* puntlist */
 owl_list *owl_global_get_puntlist(owl_global *g) {
   return(&(g->puntlist));
+GPtrArray *owl_global_get_puntlist(owl_global *g) {
+  return g->puntlist;
+}
 int owl_global_message_is_puntable(owl_global *g, const owl_message *m) {
+  const owl_list *pl;
+  int i, j;
+  pl=owl_global_get_puntlist(g);
+  j=owl_list_get_size(pl);
+  for (i=0; i<j; i++) {
+    if (owl_filter_message_match(owl_list_get_element(pl, i), m)) return(1);
+  }
+  return(0);
+  const GPtrArray *pl;
+  int i;
+  pl = owl_global_get_puntlist(g);
+  for (i = 0; i < pl->len; i++) {
+    if (owl_filter_message_match(pl->pdata[i], m)) return 1;
+  }
+  return 0;
+}
 …
  * necessary.
  */
 owl_message *owl_global_messagequeue_popmsg(owl_global *g)
+CALLER_OWN owl_message *owl_global_messagequeue_popmsg(owl_global *g)
+{
   owl_message *out;
 …
+}
+void owl_global_get_style_names(const owl_global *g, owl_list *l) {
+  owl_dict_get_keys(&(g->styledict), l);
+CALLER_OWN GPtrArray *owl_global_get_style_names(const owl_global *g)
+{
+  return owl_dict_get_keys(&g->styledict);
+}
 …
+}
-owl_list *owl_global_get_io_dispatch_list(owl_global *g)
+{
-  return &(g->io_dispatch_list);
+}
-GList **owl_global_get_timerlist(owl_global *g)
+{
-  return &(g->timerlist);
+}
 void owl_global_setup_default_filters(owl_global *g)
+{
 …
   } filters[] = {
     { "personal",
       "isprivate ^true$ and ( not type ^zephyr$ or ( class ^message  ) )" },
+      "isprivate ^true$ and ( not type ^zephyr$ or ( class ^message$ ) )" },
     { "trash",
       "class ^mail$ or opcode ^ping$ or type ^admin$ or ( not login ^none$ )" },
 …
     { "auto", "opcode ^auto$" },
     { "login", "not login ^none$" },
     { "reply-lockout", "class ^noc or class ^mail$" },
+    { "reply-lockout", "class ^mail$ or class ^filsrv$" },
     { "out", "direction ^out$" },
     { "aim", "type ^aim$" },
 …
+}
+static GMutex *owl_global_get_interrupt_lock(owl_global *g)
+{
+#if GLIB_CHECK_VERSION(2, 31, 0)
+  return &g->interrupt_lock;
+#else
+  return g->interrupt_lock;
+#endif
+}
 void owl_global_add_interrupt(owl_global *g) {
   /* TODO: This can almost certainly be done with atomic
    * operations. Whatever. */
   g_mutex_lock(g->interrupt_lock);
+  g_mutex_lock(owl_global_get_interrupt_lock(g));
   g->interrupt_count++;
   g_mutex_unlock(g->interrupt_lock);
+  g_mutex_unlock(owl_global_get_interrupt_lock(g));
+}
 bool owl_global_take_interrupt(owl_global *g) {
   bool ans = false;
   g_mutex_lock(g->interrupt_lock);
+  g_mutex_lock(owl_global_get_interrupt_lock(g));
   if (g->interrupt_count > 0) {
     ans = true;
     g->interrupt_count--;
+  }
   g_mutex_unlock(g->interrupt_lock);
+  g_mutex_unlock(owl_global_get_interrupt_lock(g));
   return ans;
+}

help.c

-                      rf25df21
+                      r8258ea5
 #include "owl.h"
-#include <string.h>
 void owl_help(void)
+{
+  const owl_variable *v;
   owl_fmtext fm;
   const char *varname;
   owl_list varnames;
   int i, numvarnames;
+  GPtrArray *varnames;
+  int i;
   owl_fmtext_init_null(&fm);
 …
      "\n"
      "    l             Print a zephyr/AIM buddy listing\n"
      "    A             Toggle zaway\n"
+     "    A             Toggle away\n"
      "    o             Toggle one-line display mode\n"
      "    w             Open a URL in the current message\n"
      "    C-l           Refresh the screen\n"
      "    C-z           Suspend Owl\n"
+     "    C-z           Suspend BarnOwl\n"
      "    h             Print this help message\n"
      "    : , M-x       Enter command mode\n"
      "\n"
      "    /             Foward search\n"
+     "    /             Forward search\n"
      "    ?             Reverse search\n"
      "\n\n"
 …
   owl_fmtext_append_normal
     (&fm,
      "    quit, exit    Exit owl\n"
+     "    quit, exit    Exit BarnOwl\n"
      "    help          Get help about commands\n"
      "    show          Show information about owl (see detailed help)\n"
+     "    show          Show information about BarnOwl (see detailed help)\n"
      "\n"
      "    zwrite        Send a zephyr\n"
 …
      "    set           Set a variable (see list below)\n"
      "    print         Print a variable's value (variables listed below)\n"
      "    startup       Set a command to be run at every Owl startup\n"
      "    unstartup     Remove a command to be run at every Owl startup\n"
+     "    startup       Set a command to be run at every BarnOwl startup\n"
+     "    unstartup     Remove a command to be run at every BarnOwl startup\n"
      "\n"
      "    getsubs       Print a list of current subscriptions\n"
      "    unsuball      Unsubscribe from all zephyr classes\n"
      "    load-subs     Load zephyr subscriptions from a file\n"
      "    zpunt         Supress messages from a zephyr triplet\n"
+     "    zpunt         Suppress messages from a zephyr triplet\n"
      "    zlog          Send a login or logout notification\n"
      "    zlist         Print a list of zephyr buddies logged in\n"
 …
      "    dump          Dump messagelist as text to a file\n"
      "\n"
      "    about         Print information about owl\n"
      "    status        Print status information about the running owl\n"
      "    version       Print the version number of owl\n"
+     "    about         Print information about BarnOwl\n"
+     "    status        Print status information about the running BarnOwl\n"
+     "    version       Print the version number of BarnOwl\n"
      "\n");
 …
   owl_fmtext_append_bold(&fm,
                          "Variables:\n");
+  owl_list_create(&varnames);
+  owl_variable_dict_get_names(owl_global_get_vardict(&g), &varnames);
+  numvarnames = owl_list_get_size(&varnames);
+  for (i=0; i<numvarnames; i++) {
+    varname = owl_list_get_element(&varnames, i);
+  varnames = owl_variable_dict_get_names(owl_global_get_vardict(&g));
+  for (i = 0; i < varnames->len; i++) {
+    varname = varnames->pdata[i];
     if (varname && varname[0]!='_') {
+      owl_variable_describe(owl_global_get_vardict(&g), varname, &fm);
+      v = owl_variable_get_var(owl_global_get_vardict(&g), varname);
+      owl_variable_describe(v, &fm);
+    }
+  }
   owl_list_cleanup(&varnames, g_free);
+  owl_ptr_array_free(varnames, g_free);
   owl_fmtext_append_normal(&fm, "\n");

history.c

-                      rd4927a7
+                      r25891a8
 void owl_history_init(owl_history *h)
+{
+  owl_list_create(&(h->hist));
+  h->cur=0;                     /* current position in history */
+  h->touched=0;                 /* whether we've gone into history */
+  h->partial=0;                 /* is the 0th element is partially composed? */
+  h->repeats=1;                 /* by default we'll allow repeat entries */
+  g_queue_init(&h->hist);
+  h->cur = h->hist.tail;        /* current position in history */
+  h->partial = false;           /* is the 0th element is partially composed? */
+}
 void owl_history_set_norepeats(owl_history *h)
+void owl_history_cleanup(owl_history *h)
+{
+  h->repeats=0;
+  g_queue_foreach(&h->hist, (GFunc)g_free, NULL);
+  g_queue_clear(&h->hist);
+}
 const char *owl_history_get_prev(owl_history *h)
+{
+  if (!h) return NULL;
+  if (!h) return NULL;
+  h->touched=1;
+  if (h->cur == NULL || g_list_previous(h->cur) == NULL) return NULL;
+  if (owl_list_get_size(&(h->hist))==0) return(NULL);
+  if (h->cur == owl_list_get_size(&(h->hist))-1) {
+    return(NULL);
+  }
+  h->cur++;
+  return(owl_list_get_element(&(h->hist), h->cur));
+  h->cur = g_list_previous(h->cur);
+  return h->cur->data;
+}
 …
+{
   if (!h) return NULL;
-  if (owl_list_get_size(&(h->hist))==0) return(NULL);
-  if (h->cur==0) {
-    return(NULL);
+  }
+  h->cur--;
+  return(owl_list_get_element(&(h->hist), h->cur));
+  if (h->cur == NULL || g_list_next(h->cur) == NULL) return NULL;
+  h->cur = g_list_next(h->cur);
+  return h->cur->data;
+}
 void owl_history_store(owl_history *h, const char *line)
+void owl_history_store(owl_history *h, const char *line, bool partial)
+{
   int size;
+  if (!h) return;
+  if (!h) return;
+  size=owl_list_get_size(&(h->hist));
+  owl_history_reset(h);
+  /* if partial is set, remove the first entry first */
+  if (h->partial) {
+    g_free(owl_list_get_element(&(h->hist), 0));
+    owl_list_remove_element(&(h->hist), 0);
+  }
+  /* if repeats are disallowed, check if the line is the same as the last */
+  if (owl_list_get_size(&(h->hist))>0) {
+    if (!strcmp(line, owl_list_get_element(&(h->hist), 0))) return;
+  }
+  /* check if the line is the same as the last */
+  if (!partial && !g_queue_is_empty(&h->hist) &&
+      strcmp(line, g_queue_peek_tail(&h->hist)) == 0)
+    return;
   /* if we've reached the max history size, pop off the last element */
+  if (size>OWL_HISTORYSIZE) {
+    g_free(owl_list_get_element(&(h->hist), size-1));
+    owl_list_remove_element(&(h->hist), size-1);
+  }
+  if (g_queue_get_length(&h->hist) >= OWL_HISTORYSIZE)
+    g_free(g_queue_pop_head(&h->hist));
   /* add the new line */
+  owl_list_prepend_element(&(h->hist), g_strdup(line));
+}
+void owl_history_set_partial(owl_history *h)
+{
+  if (!h) return;
+  h->partial=1;
+  g_queue_push_tail(&h->hist, g_strdup(line));
+  h->partial = partial;
+  h->cur = h->hist.tail;
+}
 …
+{
   if (!h) return;
+  h->cur=0;
+  h->touched=0;
+  h->partial=0;
+  /* if partial is set, remove the first entry first */
+  if (h->partial) {
+    g_free(g_queue_pop_tail(&h->hist));
+    h->partial = false;
+  }
+  h->cur = h->hist.tail;
+}
 …
+{
   if (!h) return(0);
+  if (h->touched) return(1);
+  return(0);
+  return h->cur != NULL && g_list_next(h->cur) != NULL;
+}

keybinding.c

r3b8a563	rf271129
1		~~#include <ctype.h>~~
2		~~#include <string.h>~~
3	1	#include "owl.h"
4	2
…	…
14	12
15	13	/* sets up a new keybinding for a command */
16		owl_keybinding owl_keybinding_new(const char keyseq, const char command, void (function_fn)(void), const char *desc)
	14	CALLER_OWN owl_keybinding owl_keybinding_new(const char keyseq, const char command, void (function_fn)(void), const char *desc)
17	15	{
18	16	owl_keybinding *kb = g_new(owl_keybinding, 1);
…	…
85	83	}
86	84
87		char owl_keybinding_stack_tostring(int j, int len)
	85	CALLER_OWN char owl_keybinding_stack_tostring(int j, int len)
88	86	{
89	87	GString *string;
…	…
100	98	}
101	99
102		char owl_keybinding_tostring(const owl_keybinding kb)
	100	CALLER_OWN char owl_keybinding_tostring(const owl_keybinding kb)
103	101	{
104	102	return owl_keybinding_stack_tostring(kb->keys, kb->len);

keymap.c

-                      r4c7c21f
+                      rf271129
-#include <string.h>
 #include "owl.h"
 …
   km->name = g_strdup(name);
   km->desc = g_strdup(desc);
   owl_list_create(&km->bindings);
+  km->bindings = g_ptr_array_new();
   km->parent = NULL;
   km->default_fn = default_fn;
 …
   g_free(km->name);
   g_free(km->desc);
   owl_list_cleanup(&km->bindings, (void (*)(void *))owl_keybinding_delete);
+  owl_ptr_array_free(km->bindings, (GDestroyNotify)owl_keybinding_delete);
+}
 …
 int owl_keymap_create_binding(owl_keymap *km, const char *keyseq, const char *command, void (*function_fn)(void), const char *desc)
+{
   owl_keybinding *kb, *curkb;
+  owl_keybinding *kb;
   int i;
 …
    * otherwise just add this one.
    */
+  for (i = owl_list_get_size(&km->bindings)-1; i>=0; i--) {
+    curkb = owl_list_get_element(&km->bindings, i);
+    if (owl_keybinding_equal(curkb, kb)) {
+      owl_list_remove_element(&km->bindings, i);
+      owl_keybinding_delete(curkb);
+    }
+  }
+  return owl_list_append_element(&km->bindings, kb);
+  for (i = km->bindings->len-1; i >= 0; i--) {
+    if (owl_keybinding_equal(km->bindings->pdata[i], kb)) {
+      owl_keybinding_delete(g_ptr_array_remove_index(km->bindings, i));
+    }
+  }
+  g_ptr_array_add(km->bindings, kb);
+  return 0;
+}
 …
 int owl_keymap_remove_binding(owl_keymap *km, const char *keyseq)
+{
   owl_keybinding *kb, *curkb;
+  owl_keybinding *kb;
   int i;
 …
     return -1;
+  for (i = owl_list_get_size(&km->bindings)-1; i >= 0; i--) {
+    curkb = owl_list_get_element(&km->bindings, i);
+    if (owl_keybinding_equal(curkb, kb)) {
+      owl_list_remove_element(&km->bindings, i);
+      owl_keybinding_delete(curkb);
+  for (i = km->bindings->len-1; i >= 0; i--) {
+    if (owl_keybinding_equal(km->bindings->pdata[i], kb)) {
+      owl_keybinding_delete(g_ptr_array_remove_index(km->bindings, i));
       owl_keybinding_delete(kb);
       return(0);
 …
 /* returns a summary line describing this keymap.  the caller must free. */
 char *owl_keymap_summary(const owl_keymap *km)
+CALLER_OWN char *owl_keymap_summary(const owl_keymap *km)
+{
   if (!km || !km->name || !km->desc) return NULL;
 …
 static void _owl_keymap_format_bindings(const owl_keymap *km, owl_fmtext *fm)
+{
   int i, nbindings;
+  int i;
   const owl_keybinding *kb;
+  nbindings = owl_list_get_size(&km->bindings);
+  for (i=0; i<nbindings; i++) {
+  for (i = 0; i < km->bindings->len; i++) {
     char *kbstr;
     const owl_cmd *cmd;
     const char *tmpdesc, *desc = "";
     kb = owl_list_get_element(&km->bindings, i);
+    kb = km->bindings->pdata[i];
     kbstr = owl_keybinding_tostring(kb);
     owl_fmtext_append_normal(fm, OWL_TABSTR);
 …
+}
 void owl_keyhandler_get_keymap_names(const owl_keyhandler *kh, owl_list *l)
+{
   owl_dict_get_keys(&kh->keymaps, l);
+CALLER_OWN GPtrArray *owl_keyhandler_get_keymap_names(const owl_keyhandler *kh)
+{
+  return owl_dict_get_keys(&kh->keymaps);
+}
 …
    * keyhandler and keymap apart.  */
   for (km=kh->active; km; km=km->parent) {
     for (i=owl_list_get_size(&km->bindings)-1; i>=0; i--) {
       kb = owl_list_get_element(&km->bindings, i);
+    for (i = km->bindings->len-1; i >= 0; i--) {
+      kb = km->bindings->pdata[i];
       match = owl_keybinding_match(kb, kh);
       if (match == 1) {         /* subset match */

keypress.c

-                      rd07af84
+                      rf271129
-#include <ctype.h>
-#include <string.h>
 #include "owl.h"
 …
 /* OWL_META is definied in owl.h */
 char *owl_keypress_tostring(int j, int esc)
+CALLER_OWN char *owl_keypress_tostring(int j, int esc)
+{
   GString *kb;

libfaim/Makefile.am

r215c119	rb80bae0
13	13	libfaim_a_CPPFLAGS = -DAIM_BUILDDATE=\"x\" -DAIM_BUILDTIME=\"x\" \
14	14	-I${top_srcdir}/libfaim
	15
	16	EXTRA_DIST = oscar.c

libfaim/aim.h

-                      r63de71c
+                      rfe73d0c
 #include "config.h"
-#ifdef HAVE_STDBOOL_H
 #include <stdbool.h>
-#else
-#ifndef HAVE__BOOL
-#define _Bool signed char
-#endif
-#define bool _Bool
-#define false 0
-#define true 1
-#define __bool_true_false_are_defined 1
-#endif  /* HAVE_STDBOOL_H */
 #include <stdio.h>

logging.c

-                      rcc305b5
+                      r0792d99
 #include "owl.h"
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <sys/param.h>
+#include <stdio.h>
 typedef struct _owl_log_entry { /* noproto */
 …
+}
+char *owl_log_zephyr(const owl_message *m) {
+CALLER_OWN char *owl_log_zephyr(const owl_message *m)
+{
     char *tmp = NULL;
     GString *buffer = NULL;
 …
+}
+char *owl_log_aim(const owl_message *m) {
+CALLER_OWN char *owl_log_aim(const owl_message *m)
+{
     GString *buffer = NULL;
     buffer = g_string_new("");
 …
+}
+char *owl_log_jabber(const owl_message *m) {
+CALLER_OWN char *owl_log_jabber(const owl_message *m)
+{
     GString *buffer = NULL;
     buffer = g_string_new("");
 …
+}
+char *owl_log_generic(const owl_message *m) {
+CALLER_OWN char *owl_log_generic(const owl_message *m)
+{
     GString *buffer;
     buffer = g_string_new("");
 …
     while (cc != NULL) {
       temp = short_zuser(cc->data);
       filename = g_strdup_printf("%s/%s", logpath, temp);
+      filename = g_build_filename(logpath, temp, NULL);
       owl_log_append(m, filename);
 …
+  }
   filename = g_strdup_printf("%s/%s", logpath, to);
+  filename = g_build_filename(logpath, to, NULL);
   owl_log_append(m, filename);
   g_free(to);
   g_free(filename);
   filename = g_strdup_printf("%s/all", logpath);
+  filename = g_build_filename(logpath, "all", NULL);
   owl_log_append(m, filename);
   g_free(logpath);
 …
   /* expand ~ in path names */
   logpath = owl_util_makepath(owl_global_get_logpath(&g));
   filename = g_strdup_printf("%s/%s", logpath, tobuff);
+  filename = g_build_filename(logpath, tobuff, NULL);
   msgbuf = g_string_new("");
   g_string_printf(msgbuf, "ERROR (owl): %s\n%s\n", tobuff, text);
 …
   g_string_free(msgbuf, TRUE);
   filename = g_strdup_printf("%s/all", logpath);
+  filename = g_build_filename(logpath, "all", NULL);
   g_free(logpath);
   msgbuf = g_string_new("");
 …
   if (personal) {
     logpath = owl_util_makepath(owl_global_get_logpath(&g));
     filename = g_strdup_printf("%s/%s", logpath, from);
     allfilename = g_strdup_printf("%s/all", logpath);
+    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_strdup_printf("%s/%s", logpath, from);
+    filename = g_build_filename(logpath, from, NULL);
+  }
 …
       temp = short_zuser(cc->data);
       if (strcasecmp(temp, frombuff) != 0) {
         filename = g_strdup_printf("%s/%s", logpath, temp);
+        filename = g_build_filename(logpath, temp, NULL);
         owl_log_append(m, filename);
         g_free(filename);
 …
 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)
+{
+  log_context = g_main_context_new();
+#if GLIB_CHECK_VERSION(2, 31, 0)
+  logging_thread = g_thread_new("logging",
+                                owl_log_thread_func,
+                                NULL);
+#else
   GError *error = NULL;
   logging_thread = g_thread_create(owl_log_thread_func,
 …
     exit(1);
+  }
+#endif
+}

m4/ax_append_compile_flags.m4

-                      r8073852
+                      re9b4a2c
 # ===========================================================================
 #            http://autoconf-archive.cryp.to/ax_c_check_flag.html
+#  http://www.gnu.org/software/autoconf-archive/ax_append_compile_flags.html
 # ===========================================================================
+#
 # SYNOPSIS
+#
 #   AX_C_CHECK_FLAG(FLAG-TO-CHECK,[PROLOGUE],[BODY],[ACTION-IF-SUCCESS],[ACTION-IF-FAILURE])
+#   AX_APPEND_COMPILE_FLAGS([FLAG1 FLAG2 ...], [FLAGS-VARIABLE], [EXTRA-FLAGS])
+#
 # DESCRIPTION
+#
+#   This macro tests if the C compiler supports the flag FLAG-TO-CHECK. If
+#   successfull execute ACTION-IF-SUCCESS otherwise ACTION-IF-FAILURE.
+#   PROLOGUE and BODY are optional and should be used as in AC_LANG_PROGRAM
+#   macro.
+#   For every FLAG1, FLAG2 it is checked whether the compiler works with the
+#   flag.  If it does, the flag is added FLAGS-VARIABLE
+#
+#   This code is inspired from KDE_CHECK_COMPILER_FLAG macro. Thanks to
+#   Bogdan Drozdowski <bogdandr@op.pl> for testing and bug fixes.
+#   If FLAGS-VARIABLE is not specified, the current language's flags (e.g.
+#   CFLAGS) is used.  During the check the flag is always added to the
+#   current language's flags.
+#
+#   If EXTRA-FLAGS is defined, it is added to the current language's default
+#   flags (e.g. CFLAGS) when the check is done.  The check is thus made with
+#   the flags: "CFLAGS EXTRA-FLAGS FLAG".  This can for example be used to
+#   force the compiler to issue an error when a bad flag is given.
+#
+#   NOTE: This macro depends on the AX_APPEND_FLAG and
+#   AX_CHECK_COMPILE_FLAG. Please keep this macro in sync with
+#   AX_APPEND_LINK_FLAGS.
+#
 # LICENSE
+#
 #   Copyright (c) 2008 Francesco Salvestrini <salvestrini@users.sourceforge.net>
+#   Copyright (c) 2011 Maarten Bosmans <mkbosmans@gmail.com>
+#
 #   This program is free software; you can redistribute it and/or modify it
+#   This program is free software: you can redistribute it and/or modify it
 #   under the terms of the GNU General Public License as published by the
 #   Free Software Foundation; either version 2 of the License, or (at your
+#   Free Software Foundation, either version 3 of the License, or (at your
 #   option) any later version.
+#
 …
 #   exception to the GPL to apply to your modified version as well.
+AC_DEFUN([AX_C_CHECK_FLAG],[
+  AC_PREREQ([2.61])
+  AC_REQUIRE([AC_PROG_CC])
+  AC_REQUIRE([AC_PROG_SED])
+#serial 3
+  flag=`echo "$1" | $SED 'y% .=/+-(){}<>:*,%_______________%'`
+  AC_CACHE_CHECK([whether the C compiler accepts the $1 flag],
+    [ax_cv_c_check_flag_$flag],[
+    AC_LANG_PUSH([C])
+    save_CFLAGS="$CFLAGS"
+    CFLAGS="$CFLAGS $1"
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([$2],[$3])
+    ],[
+      eval "ax_cv_c_check_flag_$flag=yes"
+    ],[
+      eval "ax_cv_c_check_flag_$flag=no"
+    ])
+    CFLAGS="$save_CFLAGS"
+    AC_LANG_POP
+  ])
+  AS_IF([eval "test \"`echo '$ax_cv_c_check_flag_'$flag`\" = yes"],[
+    :
+    $4
+  ],[
+    :
+    $5
+  ])
+])
+AC_DEFUN([AX_APPEND_COMPILE_FLAGS],
+[AC_REQUIRE([AX_CHECK_COMPILE_FLAG])
+AC_REQUIRE([AX_APPEND_FLAG])
+for flag in $1; do
+  AX_CHECK_COMPILE_FLAG([$flag], [AX_APPEND_FLAG([$flag], [$2])], [], [$3])
+done
+])dnl AX_APPEND_COMPILE_FLAGS

m4/ax_cflags_warn_all.m4

-                      r8073852
+                      re9b4a2c
 # ===========================================================================
 #           http://autoconf-archive.cryp.to/ax_cflags_warn_all.html
+#    http://www.gnu.org/software/autoconf-archive/ax_cflags_warn_all.html
 # ===========================================================================
+#
 # SYNOPSIS
+#
+#   AX_CFLAGS_WARN_ALL [(shellvar [,default, [A/NA]])]
+#   AX_CFLAGS_WARN_ALL   [(shellvar [,default, [A/NA]])]
+#   AX_CXXFLAGS_WARN_ALL [(shellvar [,default, [A/NA]])]
+#   AX_FCFLAGS_WARN_ALL  [(shellvar [,default, [A/NA]])]
+#
 # DESCRIPTION
+#
 #   Try to find a compiler option that enables most reasonable warnings.
-#   This macro is directly derived from VL_PROG_CC_WARNINGS which is split
-#   up into two AX_CFLAGS_WARN_ALL and AX_CFLAGS_WARN_ALL_ANSI
+#
 #   For the GNU CC compiler it will be -Wall (and -ansi -pedantic) The
 #   result is added to the shellvar being CFLAGS by default.
+#   For the GNU compiler it will be -Wall (and -ansi -pedantic) The result
+#   is added to the shellvar being CFLAGS, CXXFLAGS, or FCFLAGS by default.
+#
 #   Currently this macro knows about GCC, Solaris C compiler, Digital Unix C
 #   compiler, C for AIX Compiler, HP-UX C compiler, IRIX C compiler, NEC
 #   SX-5 (Super-UX 10) C compiler, and Cray J90 (Unicos 10.0.0.8) C
 #   compiler.
+#   Currently this macro knows about the GCC, Solaris, Digital Unix, AIX,
+#   HP-UX, IRIX, NEC SX-5 (Super-UX 10), Cray J90 (Unicos 10.0.0.8), and
+#   Intel compilers.  For a given compiler, the Fortran flags are much more
+#   experimental than their C equivalents.
+#
 #    - $1 shell-variable-to-add-to : CFLAGS
+#    - $1 shell-variable-to-add-to : CFLAGS, CXXFLAGS, or FCFLAGS
 #    - $2 add-value-if-not-found : nothing
 #    - $3 action-if-found : add value to shellvariable
 #    - $4 action-if-not-found : nothing
+#
+#   NOTE: These macros depend on AX_APPEND_FLAG.
+#
 # LICENSE
+#
 #   Copyright (c) 2008 Guido U. Draheim <guidod@gmx.de>
+#   Copyright (c) 2010 Rhys Ulerich <rhys.ulerich@gmail.com>
+#
 #   This program is free software; you can redistribute it and/or modify it
 #   under the terms of the GNU General Public License as published by the
 #   Free Software Foundation; either version 2 of the License, or (at your
+#   Free Software Foundation; either version 3 of the License, or (at your
 #   option) any later version.
+#
 …
 #   exception to the GPL to apply to your modified version as well.
+AC_DEFUN([AX_CFLAGS_WARN_ALL],[dnl
+AS_VAR_PUSHDEF([FLAGS],[CFLAGS])dnl
+AS_VAR_PUSHDEF([VAR],[ac_cv_cflags_warn_all])dnl
+#serial 14
+AC_DEFUN([AX_FLAGS_WARN_ALL],[dnl
+AS_VAR_PUSHDEF([FLAGS],[_AC_LANG_PREFIX[]FLAGS])dnl
+AS_VAR_PUSHDEF([VAR],[ac_cv_[]_AC_LANG_ABBREV[]flags_warn_all])dnl
 AC_CACHE_CHECK([m4_ifval($1,$1,FLAGS) for maximum warnings],
 VAR,[VAR="no, unknown"
+ AC_LANG_SAVE
+ AC_LANG_C
+ ac_save_[]FLAGS="$[]FLAGS"
+ac_save_[]FLAGS="$[]FLAGS"
 for ac_arg dnl
+in "-pedantic  % -Wall"       dnl   GCC
+in "-warn all  % -warn all"   dnl Intel
+   "-pedantic  % -Wall"       dnl GCC
    "-xstrconst % -v"          dnl Solaris C
    "-std1      % -verbose -w0 -warnprotos" dnl Digital Unix
 …
+   #
 do FLAGS="$ac_save_[]FLAGS "`echo $ac_arg | sed -e 's,%%.*,,' -e 's,%,,'`
    AC_TRY_COMPILE([],[return 0;],
    [VAR=`echo $ac_arg | sed -e 's,.*% *,,'` ; break])
+   AC_COMPILE_IFELSE([AC_LANG_PROGRAM],
+                     [VAR=`echo $ac_arg | sed -e 's,.*% *,,'` ; break])
 done
+ FLAGS="$ac_save_[]FLAGS"
+ AC_LANG_RESTORE
+FLAGS="$ac_save_[]FLAGS"
 ])
+AS_VAR_POPDEF([FLAGS])dnl
+AC_REQUIRE([AX_APPEND_FLAG])
 case ".$VAR" in
      .ok|.ok,*) m4_ifvaln($3,$3) ;;
+   .|.no|.no,*) m4_ifvaln($4,$4,[m4_ifval($2,[
+        AC_RUN_LOG([: m4_ifval($1,$1,FLAGS)="$m4_ifval($1,$1,FLAGS) $2"])
+                      m4_ifval($1,$1,FLAGS)="$m4_ifval($1,$1,FLAGS) $2"])]) ;;
+   *) m4_ifvaln($3,$3,[
+   if echo " $[]m4_ifval($1,$1,FLAGS) " | grep " $VAR " 2>&1 >/dev/null
+   then AC_RUN_LOG([: m4_ifval($1,$1,FLAGS) does contain $VAR])
+   else AC_RUN_LOG([: m4_ifval($1,$1,FLAGS)="$m4_ifval($1,$1,FLAGS) $VAR"])
+                      m4_ifval($1,$1,FLAGS)="$m4_ifval($1,$1,FLAGS) $VAR"
+   fi ]) ;;
+   .|.no|.no,*) m4_default($4,[m4_ifval($2,[AX_APPEND_FLAG([$2], [$1])])]) ;;
+   *) m4_default($3,[AX_APPEND_FLAG([$VAR], [$1])]) ;;
 esac
 AS_VAR_POPDEF([VAR])dnl
+AS_VAR_POPDEF([FLAGS])dnl
+])
+dnl the only difference - the LANG selection... and the default FLAGS
+AC_DEFUN([AX_CXXFLAGS_WARN_ALL],[dnl
+AS_VAR_PUSHDEF([FLAGS],[CXXFLAGS])dnl
+AS_VAR_PUSHDEF([VAR],[ac_cv_cxxflags_warn_all])dnl
+AC_CACHE_CHECK([m4_ifval($1,$1,FLAGS) for maximum warnings],
+VAR,[VAR="no, unknown"
+ AC_LANG_SAVE
+ AC_LANG_CPLUSPLUS
+ ac_save_[]FLAGS="$[]FLAGS"
+for ac_arg dnl
+in "-pedantic  % -Wall"       dnl   GCC
+   "-xstrconst % -v"          dnl Solaris C
+   "-std1      % -verbose -w0 -warnprotos" dnl Digital Unix
+   "-qlanglvl=ansi % -qsrcmsg -qinfo=all:noppt:noppc:noobs:nocnd" dnl AIX
+   "-ansi -ansiE % -fullwarn" dnl IRIX
+   "+ESlit     % +w1"         dnl HP-UX C
+   "-Xc        % -pvctl[,]fullmsg" dnl NEC SX-5 (Super-UX 10)
+   "-h conform % -h msglevel 2" dnl Cray C (Unicos)
+   #
+do FLAGS="$ac_save_[]FLAGS "`echo $ac_arg | sed -e 's,%%.*,,' -e 's,%,,'`
+   AC_TRY_COMPILE([],[return 0;],
+   [VAR=`echo $ac_arg | sed -e 's,.*% *,,'` ; break])
+done
+ FLAGS="$ac_save_[]FLAGS"
+ AC_LANG_RESTORE
+])
+case ".$VAR" in
+     .ok|.ok,*) m4_ifvaln($3,$3) ;;
+   .|.no|.no,*) m4_ifvaln($4,$4,[m4_ifval($2,[
+        AC_RUN_LOG([: m4_ifval($1,$1,FLAGS)="$m4_ifval($1,$1,FLAGS) $2"])
+                      m4_ifval($1,$1,FLAGS)="$m4_ifval($1,$1,FLAGS) $2"])]) ;;
+   *) m4_ifvaln($3,$3,[
+   if echo " $[]m4_ifval($1,$1,FLAGS) " | grep " $VAR " 2>&1 >/dev/null
+   then AC_RUN_LOG([: m4_ifval($1,$1,FLAGS) does contain $VAR])
+   else AC_RUN_LOG([: m4_ifval($1,$1,FLAGS)="$m4_ifval($1,$1,FLAGS) $VAR"])
+                      m4_ifval($1,$1,FLAGS)="$m4_ifval($1,$1,FLAGS) $VAR"
+   fi ]) ;;
+esac
+AS_VAR_POPDEF([VAR])dnl
+AS_VAR_POPDEF([FLAGS])dnl
+])
+])dnl AX_FLAGS_WARN_ALL
 dnl  implementation tactics:
 dnl   the for-argument contains a list of options. The first part of
 …
 dnl   like -Woption or -Xoption as they think of it is a pass-through
 dnl   to later compile stages or something. The "%" is used as a
 dnl   delimimiter. A non-option comment can be given after "%%" marks
+dnl   delimiter. A non-option comment can be given after "%%" marks
 dnl   which will be shown but not added to the respective C/CXXFLAGS.
+AC_DEFUN([AX_CFLAGS_WARN_ALL],[dnl
+AC_LANG_PUSH([C])
+AX_FLAGS_WARN_ALL([$1], [$2], [$3], [$4])
+AC_LANG_POP([C])
+])
+AC_DEFUN([AX_CXXFLAGS_WARN_ALL],[dnl
+AC_LANG_PUSH([C++])
+AX_FLAGS_WARN_ALL([$1], [$2], [$3], [$4])
+AC_LANG_POP([C++])
+])
+AC_DEFUN([AX_FCFLAGS_WARN_ALL],[dnl
+AC_LANG_PUSH([Fortran])
+AX_FLAGS_WARN_ALL([$1], [$2], [$3], [$4])
+AC_LANG_POP([Fortran])
+])

m4/ax_prog_perl_modules.m4

-                      r2d3ed95
+                      r378ede7
 # ===========================================================================
 #      http://www.nongnu.org/autoconf-archive/ax_prog_perl_modules.html
+#   http://www.gnu.org/software/autoconf-archive/ax_prog_perl_modules.html
 # ===========================================================================
+#
 …
 #   warranty.
 #serial 6
+#serial 7
 AU_ALIAS([AC_PROG_PERL_MODULES], [AX_PROG_PERL_MODULES])

m4/pkg.m4

-                      r8073852
+                      r13a39ae8
 # pkg.m4 - Macros to locate and utilise pkg-config.            -*- Autoconf -*-
+# serial 1 (pkg-config-0.24)
+#
 # Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
 …
 AC_DEFUN([PKG_PROG_PKG_CONFIG],
 [m4_pattern_forbid([^_?PKG_[A-Z_]+$])
+m4_pattern_allow([^PKG_CONFIG(_PATH)?$])
+AC_ARG_VAR([PKG_CONFIG], [path to pkg-config utility])dnl
+m4_pattern_allow([^PKG_CONFIG(_(PATH|LIBDIR|SYSROOT_DIR|ALLOW_SYSTEM_(CFLAGS|LIBS)))?$])
+m4_pattern_allow([^PKG_CONFIG_(DISABLE_UNINSTALLED|TOP_BUILD_DIR|DEBUG_SPEW)$])
+AC_ARG_VAR([PKG_CONFIG], [path to pkg-config utility])
+AC_ARG_VAR([PKG_CONFIG_PATH], [directories to add to pkg-config's search path])
+AC_ARG_VAR([PKG_CONFIG_LIBDIR], [path overriding pkg-config's built-in search path])
 if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
         AC_PATH_TOOL([PKG_CONFIG], [pkg-config])
 …
                 PKG_CONFIG=""
         fi
 fi[]dnl
 ])# PKG_PROG_PKG_CONFIG
 …
 # to PKG_CHECK_MODULES(), but does not set variables or print errors.
+#
+#
 # Similar to PKG_CHECK_MODULES, make sure that the first instance of
 # this or PKG_CHECK_MODULES is called, or make sure to call
 # PKG_CHECK_EXISTS manually
+# Please remember that m4 expands AC_REQUIRE([PKG_PROG_PKG_CONFIG])
+# only at the first occurence in configure.ac, so if the first place
+# it's called might be skipped (such as if it is within an "if", you
+# have to call PKG_CHECK_EXISTS manually
 # --------------------------------------------------------------
 AC_DEFUN([PKG_CHECK_EXISTS],
 …
 if test -n "$PKG_CONFIG" && \
     AC_RUN_LOG([$PKG_CONFIG --exists --print-errors "$1"]); then
   m4_ifval([$2], [$2], [:])
+  m4_default([$2], [:])
 m4_ifvaln([$3], [else
   $3])dnl
 fi])
 # _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
 # ---------------------------------------------
 m4_define([_PKG_CONFIG],
+[if test -n "$PKG_CONFIG"; then
+    if test -n "$$1"; then
+        pkg_cv_[]$1="$$1"
+    else
+        PKG_CHECK_EXISTS([$3],
+                         [pkg_cv_[]$1=`$PKG_CONFIG --[]$2 "$3" 2>/dev/null`],
+                         [pkg_failed=yes])
+    fi
+else
+        pkg_failed=untried
+[if test -n "$$1"; then
+    pkg_cv_[]$1="$$1"
+ elif test -n "$PKG_CONFIG"; then
+    PKG_CHECK_EXISTS([$3],
+                     [pkg_cv_[]$1=`$PKG_CONFIG --[]$2 "$3" 2>/dev/null`
+                      test "x$?" != "x0" && pkg_failed=yes ],
+                     [pkg_failed=yes])
+ else
+    pkg_failed=untried
 fi[]dnl
 ])# _PKG_CONFIG
 …
 if test $pkg_failed = yes; then
+        AC_MSG_RESULT([no])
         _PKG_SHORT_ERRORS_SUPPORTED
         if test $_pkg_short_errors_supported = yes; then
                 $1[]_PKG_ERRORS=`$PKG_CONFIG --short-errors --errors-to-stdout --print-errors "$2"`
+                $1[]_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "$2" 2>&1`
         else
                 $1[]_PKG_ERRORS=`$PKG_CONFIG --errors-to-stdout --print-errors "$2"`
+                $1[]_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "$2" 2>&1`
         fi
         # Put the nasty error message in config.log where it belongs
         echo "$$1[]_PKG_ERRORS" >&AS_MESSAGE_LOG_FD
         ifelse([$4], , [AC_MSG_ERROR(dnl
+        m4_default([$4], [AC_MSG_ERROR(
 [Package requirements ($2) were not met:
 …
 installed software in a non-standard prefix.
+_PKG_TEXT
+])],
+                [AC_MSG_RESULT([no])
+                $4])
+_PKG_TEXT])[]dnl
+        ])
 elif test $pkg_failed = untried; then
+        ifelse([$4], , [AC_MSG_FAILURE(dnl
+        AC_MSG_RESULT([no])
+        m4_default([$4], [AC_MSG_FAILURE(
 [The pkg-config script could not be found or is too old.  Make sure it
 is in your PATH or set the PKG_CONFIG environment variable to the full
 …
 _PKG_TEXT
 To get pkg-config, see <http://pkg-config.freedesktop.org/>.])],
                 [$4])
+To get pkg-config, see <http://pkg-config.freedesktop.org/>.])[]dnl
+        ])
 else
         $1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS
         $1[]_LIBS=$pkg_cv_[]$1[]_LIBS
         AC_MSG_RESULT([yes])
         ifelse([$3], , :, [$3])
+        $3
 fi[]dnl
 ])# PKG_CHECK_MODULES
+# PKG_INSTALLDIR(DIRECTORY)
+# -------------------------
+# Substitutes the variable pkgconfigdir as the location where a module
+# should install pkg-config .pc files. By default the directory is
+# $libdir/pkgconfig, but the default can be changed by passing
+# DIRECTORY. The user can override through the --with-pkgconfigdir
+# parameter.
+AC_DEFUN([PKG_INSTALLDIR],
+[m4_pushdef([pkg_default], [m4_default([$1], ['${libdir}/pkgconfig'])])
+m4_pushdef([pkg_description],
+    [pkg-config installation directory @<:@]pkg_default[@:>@])
+AC_ARG_WITH([pkgconfigdir],
+    [AS_HELP_STRING([--with-pkgconfigdir], pkg_description)],,
+    [with_pkgconfigdir=]pkg_default)
+AC_SUBST([pkgconfigdir], [$with_pkgconfigdir])
+m4_popdef([pkg_default])
+m4_popdef([pkg_description])
+]) dnl PKG_INSTALLDIR
+# PKG_NOARCH_INSTALLDIR(DIRECTORY)
+# -------------------------
+# Substitutes the variable noarch_pkgconfigdir as the location where a
+# module should install arch-independent pkg-config .pc files. By
+# default the directory is $datadir/pkgconfig, but the default can be
+# changed by passing DIRECTORY. The user can override through the
+# --with-noarch-pkgconfigdir parameter.
+AC_DEFUN([PKG_NOARCH_INSTALLDIR],
+[m4_pushdef([pkg_default], [m4_default([$1], ['${datadir}/pkgconfig'])])
+m4_pushdef([pkg_description],
+    [pkg-config arch-independent installation directory @<:@]pkg_default[@:>@])
+AC_ARG_WITH([noarch-pkgconfigdir],
+    [AS_HELP_STRING([--with-noarch-pkgconfigdir], pkg_description)],,
+    [with_noarch_pkgconfigdir=]pkg_default)
+AC_SUBST([noarch_pkgconfigdir], [$with_noarch_pkgconfigdir])
+m4_popdef([pkg_default])
+m4_popdef([pkg_description])
+]) dnl PKG_NOARCH_INSTALLDIR
+# PKG_CHECK_VAR(VARIABLE, MODULE, CONFIG-VARIABLE,
+# [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
+# -------------------------------------------
+# Retrieves the value of the pkg-config variable for the given module.
+AC_DEFUN([PKG_CHECK_VAR],
+[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
+AC_ARG_VAR([$1], [value of $3 for $2, overriding pkg-config])dnl
+_PKG_CONFIG([$1], [variable="][$3]["], [$2])
+AS_VAR_COPY([$1], [pkg_cv_][$1])
+AS_VAR_IF([$1], [""], [$5], [$4])dnl
+])# PKG_CHECK_VAR

mainwin.c

-                      r099597c
+                      rab88b05
 static void owl_mainwin_resized(owl_window *w, void *user_data);
 void owl_mainwin_init(owl_mainwin *mw, owl_window *window)
+CALLER_OWN owl_mainwin *owl_mainwin_new(owl_window *window)
+{
+  owl_mainwin *mw = g_new(owl_mainwin, 1);
   mw->curtruncated=0;
   mw->lastdisplayed=-1;
 …
   /* For now, we do not bother with connecting up dependencies; that'll be a
    * future refactor of the mainwin */
+  return mw;
+}

message.c

-                      r259e60a8
+                      r2354e9a
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <sys/socket.h>
-#include <netdb.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <time.h>
 #include "owl.h"
 #include "filterproc.h"
+#include <sys/socket.h>
+#include <arpa/inet.h>
 static owl_fmtext_cache fmtext_cache[OWL_FMTEXT_CACHE_SIZE];
 …
   m->delete=0;
+#ifdef HAVE_LIBZEPHYR
+  m->has_notice = false;
+#endif
   owl_message_set_hostname(m, "");
   owl_list_create(&(m->attributes));
+  m->attributes = g_ptr_array_new();
   /* save the time */
   m->time=time(NULL);
   m->timestr=g_strdup(ctime(&(m->time)));
   m->timestr[strlen(m->timestr)-1]='\0';
+  m->time = time(NULL);
+  m->timestr = g_strdup(ctime(&m->time));
+  m->timestr[strlen(m->timestr)-1] = '\0';
   m->fmtext = NULL;
 …
 void owl_message_set_attribute(owl_message *m, const char *attrname, const char *attrvalue)
+{
   int i, j;
+  int i;
   owl_pair *p = NULL, *pair = NULL;
 …
   /* look for an existing pair with this key, */
+  j=owl_list_get_size(&(m->attributes));
+  for (i=0; i<j; i++) {
+    p=owl_list_get_element(&(m->attributes), i);
+  for (i = 0; i < m->attributes->len; i++) {
+    p = m->attributes->pdata[i];
     if (owl_pair_get_key(p) == attrname) {
       g_free(owl_pair_get_value(p));
 …
     pair = g_new(owl_pair, 1);
     owl_pair_create(pair, attrname, NULL);
     owl_list_append_element(&(m->attributes), pair);
+    g_ptr_array_add(m->attributes, pair);
+  }
   owl_pair_set_value(pair, owl_validate_or_convert(attrvalue));
 …
 const char *owl_message_get_attribute_value(const owl_message *m, const char *attrname)
+{
   int i, j;
+  int i;
   owl_pair *p;
   GQuark quark;
 …
   attrname = g_quark_to_string(quark);
+  j=owl_list_get_size(&(m->attributes));
+  for (i=0; i<j; i++) {
+    p=owl_list_get_element(&(m->attributes), i);
+  for (i = 0; i < m->attributes->len; i++) {
+    p = m->attributes->pdata[i];
     if (owl_pair_get_key(p) == attrname) {
       return(owl_pair_get_value(p));
 …
  */
 void owl_message_attributes_tofmtext(const owl_message *m, owl_fmtext *fm) {
   int i, j;
+  int i;
   owl_pair *p;
   char *buff, *tmpbuff;
 …
   owl_fmtext_init_null(fm);
+  j=owl_list_get_size(&(m->attributes));
+  for (i=0; i<j; i++) {
+    p=owl_list_get_element(&(m->attributes), i);
+    tmpbuff = g_strdup(owl_pair_get_value(p));
+    g_strdelimit(tmpbuff, "\n", '~');
+    g_strdelimit(tmpbuff, "\r", '!');
+    buff = g_strdup_printf("  %-15.15s: %s\n", owl_pair_get_key(p), tmpbuff);
+    g_free(tmpbuff);
+  for (i = 0; i < m->attributes->len; i++) {
+    p = m->attributes->pdata[i];
+    buff = g_strdup(owl_pair_get_value(p));
+    if (buff) {
+      tmpbuff = owl_text_indent(buff, 19, false);
+      g_free(buff);
+      buff = g_strdup_printf("  %-15.15s: %s\n", owl_pair_get_key(p), tmpbuff);
+      g_free(tmpbuff);
+    }
     if(buff == NULL) {
 …
+}
+CALLER_OWN char *owl_message_format_time(const owl_message *m)
+{
+  return owl_util_format_time(localtime(&m->time));
+}
 void owl_message_set_type_admin(owl_message *m)
+{
 …
 const ZNotice_t *owl_message_get_notice(const owl_message *m)
+{
   return(&(m->notice));
+  return m->has_notice ? &m->notice : NULL;
+}
 #else
 …
 /* caller must free return value. */
 char *owl_message_get_cc(const owl_message *m)
+CALLER_OWN char *owl_message_get_cc(const owl_message *m)
+{
   const char *cur;
 …
 /* caller must free return value */
 GList *owl_message_get_cc_without_recipient(const owl_message *m)
+CALLER_OWN GList *owl_message_get_cc_without_recipient(const owl_message *m)
+{
   char *cc, *shortuser, *recip;
 …
   /* first save the full notice */
   m->notice = *n;
+  m->has_notice = true;
   /* a little gross, we'll replace \r's with ' ' for now */
 …
   /* save the time, we need to nuke the string saved by message_init */
   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';
+  m->time = n->z_time.tv_sec;
+  m->timestr = g_strdup(ctime(&m->time));
+  m->timestr[strlen(m->timestr)-1] = '\0';
   /* set other info */
 …
+  /* set the "isprivate" attribute if it's a private zephyr.
+   ``private'' means recipient is non-empty and doesn't start wit
+   `@' */
+  if (*n->z_recipient && *n->z_recipient != '@') {
+  /* set the "isprivate" attribute if it's a private zephyr. */
+  if (owl_zwrite_recip_is_personal(n->z_recipient)) {
     owl_message_set_isprivate(m);
+  }
 …
   if (owl_global_is_zcrypt(&g) && !strcasecmp(n->z_opcode, "crypt")) {
     const char *argv[] = {
       "zcrypt",
+      NULL,
       "-D",
       "-c", owl_message_get_class(m),
 …
       NULL
     };
     char *out;
+    char *out = NULL;
     int rv;
     int status;
     char *zcrypt;
+    zcrypt = g_strdup_printf("%s/zcrypt", owl_get_bindir());
+    rv = call_filter(zcrypt, argv, owl_message_get_body(m), &out, &status);
+    zcrypt = g_build_filename(owl_get_bindir(), "zcrypt", NULL);
+    argv[0] = zcrypt;
+    rv = call_filter(argv, owl_message_get_body(m), &out, &status);
     g_free(zcrypt);
 …
+      }
       owl_message_set_body(m, out);
+      g_free(out);
+    } else if(out) {
+      g_free(out);
+    }
+    } else {
+      /* Replace the opcode. Otherwise the UI and other bits of code think the
+       * message was encrypted. */
+      owl_message_set_opcode(m, "failed-decrypt");
+    }
+    g_free(out);
+  }
 …
 void owl_message_cleanup(owl_message *m)
+{
   int i, j;
+  int i;
   owl_pair *p;
 #ifdef HAVE_LIBZEPHYR
   if (owl_message_is_type_zephyr(m) && owl_message_is_direction_in(m)) {
+  if (m->has_notice) {
     ZFreeNotice(&(m->notice));
+  }
 …
   /* free all the attributes */
+  j=owl_list_get_size(&(m->attributes));
+  for (i=0; i<j; i++) {
+    p=owl_list_get_element(&(m->attributes), i);
+  for (i = 0; i < m->attributes->len; i++) {
+    p = m->attributes->pdata[i];
     g_free(owl_pair_get_value(p));
     g_free(p);
+  }
   owl_list_cleanup(&(m->attributes), NULL);
+  g_ptr_array_free(m->attributes, true);
   owl_message_invalidate_format(m);

messagelist.c

-                      r66a8cd6
+                      r219f52c
 #include "owl.h"
-#include <stdlib.h>
-#include <string.h>
 int owl_messagelist_create(owl_messagelist *ml)
+CALLER_OWN owl_messagelist *owl_messagelist_new(void)
+{
+  owl_list_create(&(ml->list));
+  return(0);
+  owl_messagelist *ml = g_new(owl_messagelist, 1);
+  ml->list = g_ptr_array_new();
+  return ml;
+}
+void owl_messagelist_delete(owl_messagelist *ml, bool free_messages)
+{
+  if (free_messages)
+    g_ptr_array_foreach(ml->list, (GFunc)owl_message_delete, NULL);
+  g_ptr_array_free(ml->list, true);
+  g_free(ml);
+}
 int owl_messagelist_get_size(const owl_messagelist *ml)
+{
   return(owl_list_get_size(&(ml->list)));
+  return ml->list->len;
+}
 void *owl_messagelist_get_element(const owl_messagelist *ml, int n)
+{
+  return(owl_list_get_element(&(ml->list), n));
+  /* we assume things like owl_view_get_element(v, owl_global_get_curmsg(&g))
+   * work even when there are no messages in the message list.  So don't
+   * segfault if someone asks for the zeroth element of an empty list.
+   */
+  if (n >= ml->list->len) return NULL;
+  return ml->list->pdata[n];
+}
 owl_message *owl_messagelist_get_by_id(const owl_messagelist *ml, int target_id)
+int owl_messagelist_get_index_by_id(const owl_messagelist *ml, int target_id)
+{
   /* return the message with id == 'id'.  If it doesn't exist return NULL. */
+  /* return the message index with id == 'id'.  If it doesn't exist return -1. */
   int first, last, mid, msg_id;
   owl_message *m;
   first = 0;
   last = owl_list_get_size(&(ml->list)) - 1;
+  last = ml->list->len - 1;
   while (first <= last) {
     mid = (first + last) / 2;
     m = owl_list_get_element(&(ml->list), mid);
+    m = ml->list->pdata[mid];
     msg_id = owl_message_get_id(m);
     if (msg_id == target_id) {
       return(m);
+      return mid;
     } else if (msg_id < target_id) {
       first = mid + 1;
 …
+    }
+  }
   return(NULL);
+  return -1;
+}
 int owl_messagelist_append_element(owl_messagelist *ml, void *element)
+owl_message *owl_messagelist_get_by_id(const owl_messagelist *ml, int target_id)
+{
+  return(owl_list_append_element(&(ml->list), element));
+  /* return the message with id == 'id'.  If it doesn't exist return NULL. */
+  int n = owl_messagelist_get_index_by_id(ml, target_id);
+  if (n < 0) return NULL;
+  return ml->list->pdata[n];
+}
+void owl_messagelist_append_element(owl_messagelist *ml, void *element)
+{
+  g_ptr_array_add(ml->list, element);
+}
 …
+{
   /* mark a message as deleted */
   owl_message_mark_delete(owl_list_get_element(&(ml->list), n));
+  owl_message_mark_delete(ml->list->pdata[n]);
   return(0);
+}
 …
+{
   /* mark a message as deleted */
   owl_message_unmark_delete(owl_list_get_element(&(ml->list), n));
+  owl_message_unmark_delete(ml->list->pdata[n]);
   return(0);
+}
+void owl_messagelist_delete_and_expunge_element(owl_messagelist *ml, int n)
+{
+  owl_message_delete(g_ptr_array_remove_index(ml->list, n));
+}
 …
+{
   /* expunge deleted messages */
   int i, j;
   owl_list newlist;
+  int i;
+  GPtrArray *newlist;
   owl_message *m;
   owl_list_create(&newlist);
+  newlist = g_ptr_array_new();
   /*create a new list without messages marked as deleted */
+  j=owl_list_get_size(&(ml->list));
+  for (i=0; i<j; i++) {
+    m=owl_list_get_element(&(ml->list), i);
+  for (i = 0; i < ml->list->len; i++) {
+    m = ml->list->pdata[i];
     if (owl_message_is_delete(m)) {
       owl_message_delete(m);
     } else {
       owl_list_append_element(&newlist, m);
+      g_ptr_array_add(newlist, m);
+    }
+  }
   /* free the old list */
   owl_list_cleanup(&(ml->list), NULL);
+  g_ptr_array_free(ml->list, true);
   /* copy the new list to the old list */
 …
 void owl_messagelist_invalidate_formats(const owl_messagelist *ml)
+{
   int i, j;
+  int i;
   owl_message *m;
+  j=owl_list_get_size(&(ml->list));
+  for (i=0; i<j; i++) {
+    m=owl_list_get_element(&(ml->list), i);
+  for (i = 0; i < ml->list->len; i++) {
+    m = ml->list->pdata[i];
     owl_message_invalidate_format(m);
+  }

owl.c

-                      rcc305b5
+                      r499224d
  */
+#include "owl.h"
 #include <stdio.h>
-#include <unistd.h>
 #include <getopt.h>
-#include <stdlib.h>
-#include <string.h>
-#include <signal.h>
-#include <time.h>
-#include <sys/param.h>
-#include <sys/types.h>
-#include <sys/time.h>
-#include <termios.h>
 #include <sys/stat.h>
 #include <locale.h>
+#include "owl.h"
+#include <unistd.h>
 #if OWL_STDERR_REDIR
 …
 } owl_options;
 void usage(void)
+void usage(FILE *file)
+{
   fprintf(stderr, "Barnowl version %s\n", OWL_VERSION_STRING);
   fprintf(stderr, "Usage: barnowl [-n] [-d] [-D] [-v] [-h] [-c <configfile>] [-s <confdir>] [-t <ttyname>]\n");
   fprintf(stderr, "  -n,--no-subs        don't load zephyr subscriptions\n");
   fprintf(stderr, "  -d,--debug          enable debugging\n");
   fprintf(stderr, "  -v,--version        print the Barnowl version number and exit\n");
   fprintf(stderr, "  -h,--help           print this help message\n");
   fprintf(stderr, "  -c,--config-file    specify an alternate config file\n");
   fprintf(stderr, "  -s,--config-dir     specify an alternate config dir (default ~/.owl)\n");
   fprintf(stderr, "  -t,--tty            set the tty name\n");
+  fprintf(file, "Barnowl version %s\n", OWL_VERSION_STRING);
+  fprintf(file, "Usage: barnowl [-n] [-d] [-D] [-v] [-h] [-c <configfile>] [-s <confdir>] [-t <ttyname>]\n");
+  fprintf(file, "  -n,--no-subs        don't load zephyr subscriptions\n");
+  fprintf(file, "  -d,--debug          enable debugging\n");
+  fprintf(file, "  -v,--version        print the Barnowl version number and exit\n");
+  fprintf(file, "  -h,--help           print this help message\n");
+  fprintf(file, "  -s,--config-dir     specify an alternate config dir (default ~/.owl)\n");
+  fprintf(file, "  -c,--config-file    specify an alternate config file (default ~/.owl/init.pl)\n");
+  fprintf(file, "  -t,--tty            set the tty name\n");
+}
 …
       break;
     case 'v':
       printf("This is barnowl version %s\n", OWL_VERSION_STRING);
+      printf("This is BarnOwl version %s\n", OWL_VERSION_STRING);
       exit(0);
     case 'h':
+      usage(stdout);
+      exit(0);
     default:
       usage();
+      usage(stderr);
       exit(1);
+    }
 …
     /* follow the last message if we're supposed to */
     if (followlast)
       owl_function_lastmsg_noredisplay();
+      owl_function_lastmsg();
     /* do the newmsgproc thing */
 …
+}
 void owl_process_input(const owl_io_dispatch *d, void *data)
+gboolean owl_process_input(GIOChannel *source, GIOCondition condition, void *data)
+{
+  owl_global *g = data;
   owl_input j;
   while (1) {
     j.ch = wgetch(g.input_pad);
     if (j.ch == ERR) return;
+    j.ch = wgetch(g->input_pad);
+    if (j.ch == ERR) return TRUE;
     j.uch = '\0';
 …
       for (i = 1; i < bytes; i++) {
         int tmp = wgetch(g.input_pad);
+        int tmp = wgetch(g->input_pad);
         /* If what we got was not a byte, or not a continuation byte */
         if (tmp > 0xff || !(tmp & 0x80 && ~tmp & 0x40)) {
 …
     owl_process_input_char(j);
+  }
+  return TRUE;
+}
 …
+}
 #define CHECK_RESULT(s, syscall) \
+#define OR_DIE(s, syscall)       \
   G_STMT_START {                 \
     if ((syscall) != 0) {        \
+    if ((syscall) == -1) {       \
       perror((s));               \
       exit(1);                   \
 …
   sigset_t sigset;
   int ret, i;
+  const int signals[] = { SIGABRT, SIGBUS, SIGCHLD, SIGFPE, SIGHUP, SIGILL,
+                          SIGINT, SIGQUIT, SIGSEGV, SIGTERM, SIGWINCH };
+  const int reset_signals[] = { SIGABRT, SIGBUS, SIGCHLD, SIGFPE, SIGILL,
+                                SIGQUIT, SIGSEGV, };
+  /* Don't bother resetting watched ones because owl_signal_init will. */
+  const int watch_signals[] = { SIGWINCH, SIGTERM, SIGHUP, SIGINT, };
   /* Sanitize our signals; the mask and dispositions from our parent
    * aren't really useful. Signal list taken from equivalent code in
    * Chromium. */
   CHECK_RESULT("sigemptyset", sigemptyset(&sigset));
+  OR_DIE("sigemptyset", sigemptyset(&sigset));
   if ((ret = pthread_sigmask(SIG_SETMASK, &sigset, NULL)) != 0) {
     errno = ret;
     perror("pthread_sigmask");
+  }
+  for (i = 0; i < G_N_ELEMENTS(signals); i++) {
+    CHECK_RESULT("sigaction", sigaction(signals[i], &sig_default, NULL));
+    exit(1);
+  }
+  for (i = 0; i < G_N_ELEMENTS(reset_signals); i++) {
+    OR_DIE("sigaction", sigaction(reset_signals[i], &sig_default, NULL));
+  }
   /* Turn off SIGPIPE; we check the return value of write. */
   CHECK_RESULT("sigaction", sigaction(SIGPIPE, &sig_ignore, NULL));
+  OR_DIE("sigaction", sigaction(SIGPIPE, &sig_ignore, NULL));
   /* Register some signals with the signal thread. */
+  CHECK_RESULT("sigaddset", sigaddset(&sigset, SIGWINCH));
+  CHECK_RESULT("sigaddset", sigaddset(&sigset, SIGTERM));
+  CHECK_RESULT("sigaddset", sigaddset(&sigset, SIGHUP));
+  CHECK_RESULT("sigaddset", sigaddset(&sigset, SIGINT));
+  owl_signal_init(&sigset, sig_handler, NULL);
+  owl_signal_init(watch_signals, G_N_ELEMENTS(watch_signals),
+                  sig_handler, NULL);
+}
 …
   if (0 != pipe(pipefds)) {
     perror("pipe");
     owl_function_debugmsg("stderr_replace: pipe FAILED\n");
+    owl_function_debugmsg("stderr_replace: pipe FAILED");
     return -1;
+  }
     owl_function_debugmsg("stderr_replace: pipe: %d,%d\n", pipefds[0], pipefds[1]);
   if (-1 == dup2(pipefds[1], 2 /*stderr*/)) {
     owl_function_debugmsg("stderr_replace: dup2 FAILED (%s)\n", strerror(errno));
+    owl_function_debugmsg("stderr_replace: pipe: %d,%d", pipefds[0], pipefds[1]);
+  if (-1 == dup2(pipefds[1], STDERR_FILENO)) {
+    owl_function_debugmsg("stderr_replace: dup2 FAILED (%s)", strerror(errno));
     perror("dup2");
     return -1;
 …
 /* Sends stderr (read from rfd) messages to the error console */
 void stderr_redirect_handler(const owl_io_dispatch *d, void *data)
+gboolean stderr_redirect_handler(GIOChannel *source, GIOCondition condition, void *data)
+{
   int navail, bread;
   char buf[4096];
   int rfd = d->fd;
+  int rfd = g_io_channel_unix_get_fd(source);
   char *err;
+  if (rfd<0) return;
+  /* TODO: Use g_io_channel_read_line? We'd have to be careful about
+   * blocking on the read. */
+  if (rfd<0) return TRUE;
   if (-1 == ioctl(rfd, FIONREAD, &navail)) {
     return;
+    return TRUE;
+  }
   /*owl_function_debugmsg("stderr_redirect: navail = %d\n", navail);*/
   if (navail <= 0) return;
+  if (navail <= 0) return TRUE;
   if (navail > sizeof(buf)-1) {
     navail = sizeof(buf)-1;
 …
   bread = read(rfd, buf, navail);
   if (bread == -1)
     return;
+    return TRUE;
   err = g_strdup_printf("[stderr]\n%.*s", bread, buf);
 …
   owl_function_log_err(err);
   g_free(err);
+  return TRUE;
+}
 …
   owl_options opts;
   GSource *source;
+  if (!GLIB_CHECK_VERSION (2, 12, 0))
+    g_error ("GLib version 2.12.0 or above is needed.");
+  GIOChannel *channel;
   argc_copy = argc;
 …
   /* register STDIN dispatch; throw away return, we won't need it */
+  owl_select_add_io_dispatch(STDIN_FILENO, OWL_IO_READ, &owl_process_input, NULL, NULL);
+  channel = g_io_channel_unix_new(STDIN_FILENO);
+  g_io_add_watch(channel, G_IO_IN | G_IO_HUP | G_IO_ERR, &owl_process_input, &g);
+  g_io_channel_unref(channel);
   owl_zephyr_initialize();
 #if OWL_STDERR_REDIR
   /* Do this only after we've started curses up... */
+  owl_function_debugmsg("startup: doing stderr redirection");
+  owl_select_add_io_dispatch(stderr_replace(), OWL_IO_READ, &stderr_redirect_handler, NULL, NULL);
+  if (isatty(STDERR_FILENO)) {
+    owl_function_debugmsg("startup: doing stderr redirection");
+    channel = g_io_channel_unix_new(stderr_replace());
+    g_io_add_watch(channel, G_IO_IN | G_IO_HUP | G_IO_ERR, &stderr_redirect_handler, NULL);
+    g_io_channel_unref(channel);
+  }
 #endif
 …
   owl_function_adminmsg("",
     "-----------------------------------------------------------------------\n"
     "Welcome to barnowl version " OWL_VERSION_STRING ".\n"
+    "Welcome to BarnOwl version " OWL_VERSION_STRING ".\n"
     "To see a quick introduction, type ':show quickstart'.                  \n"
     "Press 'h' for on-line help.                                            \n"
 …
   );
+  owl_function_debugmsg("startup: setting context interactive");
+  owl_global_pop_context(&g);
+  owl_global_push_context(&g, OWL_CTX_INTERACTIVE|OWL_CTX_RECV, NULL, "recv", NULL);
   /* process the startup file */
   owl_function_debugmsg("startup: processing startup file");
 …
       owl_function_error("No such style: %s", owl_global_get_default_style(&g));
-  owl_function_debugmsg("startup: setting context interactive");
-  owl_global_pop_context(&g);
-  owl_global_push_context(&g, OWL_CTX_INTERACTIVE|OWL_CTX_RECV, NULL, "recv", NULL);
   source = owl_window_redraw_source_new();
   g_source_attach(source, NULL);

owl.h

-                      r33b6431b
+                      r6249a88f
 #define INC_BARNOWL_OWL_H
 #include "config.h"
+#include <config.h>
 #include "compat/compat.h"
-#ifdef HAVE_STDBOOL_H
 #include <stdbool.h>
-#else
-#ifndef HAVE__BOOL
-#define _Bool signed char
-#endif
-#define bool _Bool
-#define false 0
-#define true 1
-#define __bool_true_false_are_defined 1
-#endif  /* HAVE_STDBOOL_H */
 #ifndef OWL_PERL
+#include <curses.h>
+#include <panel.h>
+#define NCURSES_ENABLE_STDBOOL_H 1
+#include <ncursesw/curses.h>
+#include <ncursesw/panel.h>
 #endif
 #include <sys/param.h>
+#include <sys/types.h>
+#include <ctype.h>
+#include <errno.h>
 #include <EXTERN.h>
+#include <fcntl.h>
 #include <netdb.h>
 #include <regex.h>
 #include <time.h>
 #include <signal.h>
+#include <stdlib.h>
+#include <string.h>
 #include <termios.h>
+#include <unistd.h>
 #include "libfaim/aim.h"
 #include <wchar.h>
 #include "glib.h"
+#include <glib.h>
 #ifdef HAVE_LIBZEPHYR
 #include <zephyr/zephyr.h>
 …
 /* Perl and curses don't play nice. */
 #ifdef OWL_PERL
 typedef void WINDOW;
 typedef void PANEL;
+typedef struct _owl_fake_WINDOW WINDOW;
+typedef struct _owl_fake_PANEL PANEL;
 /* logout is defined in FreeBSD. */
 #define logout logout_
 …
 #include "XSUB.h"
 #else
 typedef void SV;
 typedef void AV;
 typedef void HV;
+typedef struct _owl_fake_SV SV;
+typedef struct _owl_fake_AV AV;
+typedef struct _owl_fake_HV HV;
 #endif
 …
 #define OWL_CONFIG_DIR "/.owl"             /* this is relative to the user's home directory */
-#define OWL_STARTUP_FILE "/.owl/startup"   /* this is relative to the user's home directory */
 #define OWL_FMTEXT_ATTR_NONE      0
 …
 #define OWL_MESSAGE_DIRECTION_IN    1
 #define OWL_MESSAGE_DIRECTION_OUT   2
-#define OWL_IO_READ   1
-#define OWL_IO_WRITE  2
-#define OWL_IO_EXCEPT 4
 #define OWL_DIRECTION_NONE      0
 …
 #endif
+/* Annotate functions in which the caller owns the return value and is
+ * responsible for ensuring it is freed. */
+#define CALLER_OWN G_GNUC_WARN_UNUSED_RESULT
 #define OWL_META(key) ((key)|010000)
 /* OWL_CTRL is definied in kepress.c */
-#define LINE 2048
 #ifdef HAVE_LIBZEPHYR
 …
   char *name;
   int   type;  /* OWL_VARIABLE_* */
+  void *pval_default;  /* for types other and string */
+  int   ival_default;  /* for types int and bool     */
+  char *validsettings;          /* documentation of valid settings */
+  char *default_str;            /* the default value as a string */
+  char *validsettings;          /* documentation of valid settings */
   char *summary;                /* summary of usage */
   char *description;            /* detailed description */
+  void *val;                    /* current value */
+  int  (*validate_fn)(const struct _owl_variable *v, const void *newval);
+  bool takes_on_off;            /* allow passing on/off in argument-less set/unset */
+  GClosure *set_fromstring_fn;
+                                /* sets the variable to a value
+                                 * of the appropriate type.
+                                 * unless documented, this
+                                 * should make a copy.
+                                 * returns 0 on success. */
+  GClosure *get_tostring_fn;
+                                /* converts val to a string;
+                                 * caller must free the result */
+  /* These are only valid for OWL_VARIABLE_{INT,BOOL,STRING} */
+  GValue val;                   /* current value, if default get_fn/set_fn */
+  GCallback get_fn;
+                                /* returns a reference to the current value.
+                                 * WARNING:  this approach is hard to make
+                                 * thread-safe... */
+  GCallback validate_fn;
                                 /* returns 1 if newval is valid */
   int  (*set_fn)(struct _owl_variable *v, const void *newval);
+  GCallback set_fn;
                                 /* sets the variable to a value
+                                 * of the appropriate type.
+                                 * unless documented, this
+                                 * should make a copy.
+                                 * returns 0 on success. */
+  int  (*set_fromstring_fn)(struct _owl_variable *v, const char *newval);
+                                /* sets the variable to a value
+                                 * of the appropriate type.
+                                 * unless documented, this
+                                 * should make a copy.
+                                 * returns 0 on success. */
+  const void *(*get_fn)(const struct _owl_variable *v);
+                                /* returns a reference to the current value.
+                                 * WARNING:  this approach is hard to make
+                                 * thread-safe... */
+  char *(*get_tostring_fn)(const struct _owl_variable *v, const void *val);
+                                /* converts val to a string;
+                                 * caller must free the result */
+  void (*delete_fn)(struct _owl_variable *v);
+                                /* frees val as needed */
+                                 * of the appropriate type.
+                                 * unless documented, this
+                                 * should make a copy.
+                                 * returns 0 on success. */
 } owl_variable;
 typedef struct _owl_input {
 …
   GString *buff;
 } owl_fmtext;
-typedef struct _owl_list {
-  int size;
-  int avail;
-  void **list;
-} owl_list;
 typedef struct _owl_dict_el {
 …
   /* These don't take any context */
   char *(*cmd_args_fn)(int argc, const char *const *argv, const char *buff);
+  CALLER_OWN char *(*cmd_args_fn)(int argc, const char *const *argv, const char *buff);
                                 /* takes argv and the full command as buff.
                                  * caller must free return value if !NULL */
 …
   /* The following also take the active context if it's valid */
   char *(*cmd_ctxargs_fn)(void *ctx, int argc, const char *const *argv, const char *buff);
+  CALLER_OWN char *(*cmd_ctxargs_fn)(void *ctx, int argc, const char *const *argv, const char *buff);
                                 /* takes argv and the full command as buff.
                                  * caller must free return value if !NULL */
 …
   char *zsig;
   char *message;
   owl_list recips;
+  GPtrArray *recips;
   int cc;
   int noping;
 …
   int direction;
 #ifdef HAVE_LIBZEPHYR
+  bool has_notice;
   ZNotice_t notice;
 #endif
 …
   int delete;
   const char *hostname;
   owl_list attributes;            /* this is a list of pairs */
+  GPtrArray *attributes;          /* this is a list of pairs */
   char *timestr;
   time_t time;
 …
 typedef struct _owl_messagelist {
   owl_list list;
+  GPtrArray *list;
 } owl_messagelist;
 …
   char *name;
   owl_filter *filter;
   owl_messagelist ml;
+  owl_messagelist *ml;
   const owl_style *style;
   int cachedmsgid;
 …
 typedef struct _owl_history {
+  owl_list hist;
+  int cur;
+  int touched;
+  int partial;
+  int repeats;
+  GQueue hist;
+  GList *cur;
+  bool partial;
 } owl_history;
 …
   char     *name;               /* name of keymap */
   char     *desc;               /* description */
   owl_list  bindings;           /* key bindings */
+  GPtrArray *bindings;          /* key bindings */
   const struct _owl_keymap *parent;     /* parent */
   void (*default_fn)(owl_input j);      /* default action (takes a keypress) */
 …
 typedef struct _owl_buddylist {
   owl_list buddies;
+  GPtrArray *buddies;
 } owl_buddylist;
 typedef struct _owl_zbuddylist {
   owl_list zusers;
+  GPtrArray *zusers;
 } owl_zbuddylist;
-typedef struct _owl_timer {
-  time_t time;
-  int interval;
-  void (*callback)(struct _owl_timer *, void *);
-  void (*destroy)(struct _owl_timer *);
-  void *data;
-  char *name;
-} owl_timer;
 typedef struct _owl_errqueue {
   owl_list errlist;
+  GPtrArray *errlist;
 } owl_errqueue;
 …
 } owl_colorpair_mgr;
-typedef struct _owl_io_dispatch {
-  int fd;                                     /* FD to watch for dispatch. */
-  int mode;
-  bool valid;
-  int needs_gc;
-  void (*callback)(const struct _owl_io_dispatch *, void *); /* C function to dispatch to. */
-  void (*destroy)(const struct _owl_io_dispatch *);  /* Destructor */
-  void *data;
-  GPollFD pollfd;
-} owl_io_dispatch;
 typedef struct _owl_popexec {
   int refcount;
 …
   int winactive;
   pid_t pid;                    /* or 0 if it has terminated */
   const owl_io_dispatch *dispatch;
+  guint io_watch;
 } owl_popexec;
 typedef struct _owl_global {
   owl_mainwin mw;
+  owl_mainwin *mw;
   owl_popwin *pw;
   owl_msgwin msgwin;
 …
   owl_dict filters;
   GList *filterlist;
   owl_list puntlist;
+  GPtrArray *puntlist;
   owl_vardict vars;
   owl_cmddict cmds;
 …
   int curmsg_vert_offset;
   owl_view current_view;
   owl_messagelist msglist;
+  owl_messagelist *msglist;
   WINDOW *input_pad;
   owl_mainpanel mainpanel;
 …
   char *startupfile;
   int direction;
-  int zaway;
-  char *cur_zaway_msg;
   int haveconfig;
   int config_format;
 …
   int pseudologin_notify;
   struct termios startup_tio;
+  owl_list io_dispatch_list;
+  GList *timerlist;
+  owl_timer *aim_nop_timer;
+  guint aim_nop_timer;
   int load_initial_subs;
   FILE *debug_file;
   char *kill_buffer;
   int interrupt_count;
+#if GLIB_CHECK_VERSION(2, 31, 0)
+  GMutex interrupt_lock;
+#else
   GMutex *interrupt_lock;
+#endif
 } owl_global;
 …
 extern owl_global g;
 #include "owl_prototypes.h"
+#include <owl_prototypes.h>
 /* These were missing from the Zephyr includes before Zephyr 3. */
 …
 #endif
+/* We have to dynamically bind these ourselves */
+extern gboolean (*gvalue_from_sv) (GValue * value, SV * sv);
+extern SV * (*sv_from_gvalue) (const GValue * value);
+extern GClosure * (*perl_closure_new) (SV * callback, SV * data, gboolean swap);
 #endif /* INC_BARNOWL_OWL_H */

owl_perl.h

-                      r06adc25
+                      r92ffd89
 #define INC_BARNOWL_OWL_PERL_H
+#define OWL_PERL_VOID_CALL (void)POPs;
+#include <stdio.h>
+/*
+ * This macro defines a convenience wrapper around the boilerplate
+ * of pushing char * arguments on to the stack for perl calling.
+ *
+ * Arguments are
+ * * i     - the counter variable to use, which must be declared prior
+ *           to calling this macro
+ * * argc  - the number of arguments
+ * * argv  - an array of char*s, of length at least argc; the arguments
+ *           to push on to the stack
+ */
+#define OWL_PERL_PUSH_ARGS(i, argc, argv) { \
+  for (i = 0; i < argc; i++) { \
+    XPUSHs(sv_2mortal(owl_new_sv(argv[i]))); \
+  } \
+}
 /*
  * This macro defines a convenience wrapper around the boilerplate of
  * calling a method on a perl object (SV*) from C.
+ * the perlcall methods.
+ *
  * Arguments are
+ * * obj    - the SV* to call the method on
+ * * meth   - a char* method name
+ * * args   - a code block responsible for pushing args (other than the object)
+ * * err    - a string with a %s format specifier to log in case of error
+ * * fatalp - if true, perl errors terminate barnowl
+ * * ret    - a code block executed if the call succeeded
+ * * call       - the line of code to make the perl call
+ * * args       - a code block responsible for pushing args
+ * * err        - a string with a %s format specifier to log in case of error
+ * * fatalp     - if true, perl errors terminate BarnOwl
+ * * discardret - should be true if no return is expected
+ *                (if the call is passed the flag G_DISCARD or G_VOID)
+ * * ret        - a code block executed if the call succeeded
+ *
  * See also: `perldoc perlcall', `perldoc perlapi'
  */
+#define OWL_PERL_CALL_METHOD(obj, meth, args, err, fatalp, ret) { \
+    int count; \
+    dSP; \
+    ENTER; \
+    SAVETMPS; \
+    PUSHMARK(SP); \
+    XPUSHs(obj); \
+    {args} \
+    PUTBACK; \
+    \
+    count = call_method(meth, G_SCALAR|G_EVAL); \
+    \
+    SPAGAIN; \
+    \
+    if(count != 1) { \
+      fprintf(stderr, "perl returned wrong count: %d\n", count); \
+      abort();                                                   \
+#define OWL_PERL_CALL(call, args, err, fatalp, discardret, ret) { \
+  int count; \
+  dSP; \
+  \
+  ENTER; \
+  SAVETMPS; \
+  \
+  PUSHMARK(SP); \
+  {args} \
+  PUTBACK; \
+  \
+  count = call; \
+  \
+  SPAGAIN; \
+  \
+  if (!discardret && count != 1) { \
+    croak("Perl returned wrong count: %d\n", count); \
+  } \
+  \
+  if (SvTRUE(ERRSV)) { \
+    if (fatalp) { \
+      fprintf(stderr, err, SvPV_nolen(ERRSV)); \
+      exit(-1); \
+    } else { \
+      owl_function_error(err, SvPV_nolen(ERRSV)); \
+      if (!discardret) (void)POPs; \
+      sv_setsv(ERRSV, &PL_sv_undef); \
     } \
+    if (SvTRUE(ERRSV)) { \
+      if(fatalp) { \
+        printf(err, SvPV_nolen(ERRSV)); \
+        exit(-1); \
+      } else { \
+        owl_function_error(err, SvPV_nolen(ERRSV)); \
+        (void)POPs; \
+        sv_setsv(ERRSV, &PL_sv_undef); \
+      } \
+    } else { \
+      ret; \
+    } \
+    PUTBACK; \
+    FREETMPS; \
+    LEAVE; \
+  } else if (!discardret) { \
+    ret; \
+  } \
+  PUTBACK; \
+  FREETMPS; \
+  LEAVE; \
+}

perl/Makefile.am

-                      r10557e6
+                      ra870319
 SUBDIRS = modules
+nobase_dist_pkgdata_DATA = \
+        lib/BarnOwl.pm \
+        lib/BarnOwl/Complete/AIM.pm \
+        lib/BarnOwl/Complete/Client.pm \
+        lib/BarnOwl/Complete/Filter.pm \
+        lib/BarnOwl/Complete/Zephyr.pm \
+        lib/BarnOwl/Completion.pm \
+        lib/BarnOwl/Completion/Context.pm \
+        lib/BarnOwl/Completion/Util.pm \
+        lib/BarnOwl/Editwin.pm \
+        lib/BarnOwl/Help.pm \
+        lib/BarnOwl/Hook.pm \
+        lib/BarnOwl/Hooks.pm \
+        lib/BarnOwl/MainLoopCompatHook.pm \
+        lib/BarnOwl/Message.pm \
+        lib/BarnOwl/Message/AIM.pm \
+        lib/BarnOwl/Message/Admin.pm \
+        lib/BarnOwl/Message/Generic.pm \
+        lib/BarnOwl/Message/Loopback.pm \
+        lib/BarnOwl/Message/Zephyr.pm \
+        lib/BarnOwl/ModuleLoader.pm \
+        lib/BarnOwl/Parse.pm \
+        lib/BarnOwl/Style.pm \
+        lib/BarnOwl/Style/Basic.pm \
+        lib/BarnOwl/Style/Default.pm \
+        lib/BarnOwl/Style/Legacy.pm \
+        lib/BarnOwl/Style/OneLine.pm \
+        lib/BarnOwl/Timer.pm \
+        lib/BarnOwl/Zephyr.pm \
+        lib/Module/Install/BarnOwl.pm

perl/lib/BarnOwl.pm

-                      rf2d71cfa
+                      r1ced34f
 use base qw(Exporter);
 our @EXPORT_OK = qw(command getcurmsg getnumcols getidletime
+our @EXPORT_OK = qw(command getcurmsg getnumcols getnumlines getidletime
                     zephyr_getsender zephyr_getrealm zephyr_zwrite
                     zephyr_stylestrip zephyr_smartstrip_user zephyr_getsubs
                     queue_message admin_message
+                    start_edit
                     start_question start_password start_edit_win
                     get_data_dir get_config_dir popless_text popless_ztext
                     error debug
                     create_style getnumcolors wordwrap
+                    message_matches_filter
                     add_dispatch remove_dispatch
                     add_io_dispatch remove_io_dispatch
                     new_command
                     new_variable_int new_variable_bool new_variable_string
+                    new_variable_enum
                     quote redisplay);
 our %EXPORT_TAGS = (all => \@EXPORT_OK);
 …
 use lib(get_data_dir() . "/lib");
 use lib(get_config_dir() . "/lib");
+use Glib;
+use AnyEvent;
 use BarnOwl::Hook;
 …
 use BarnOwl::Completion;
 use BarnOwl::Help;
-use BarnOwl::AnyEvent;
-unshift @AnyEvent::REGISTRY, [BarnOwl => BarnOwl::AnyEvent::];
-require AnyEvent;
 use List::Util qw(max);
 …
 The BarnOwl module contains the core of BarnOwl's perl
 bindings. Source in this module is also run at startup to bootstrap
 barnowl by defining things like the default style.
+BarnOwl by defining things like the default style.
 =for NOTE
 …
 =head2 zephyr_getrealm
 Returns the zephyr realm barnowl is running in
+Returns the zephyr realm BarnOwl is running in
 =head2 zephyr_getsender
 Returns the fully-qualified name of the zephyr sender barnowl is
+Returns the fully-qualified name of the zephyr sender BarnOwl is
 running as, e.g. C<nelhage@ATHENA.MIT.EDU>
 …
 Sends a zephyr programmatically. C<COMMAND> should be a C<zwrite>
 command line, and C<MESSAGE> is the zephyr body to send.
+=cut
+sub zephyr_zwrite {
+    my ($command, $message) = @_;
+    my $ret = BarnOwl::Internal::zephyr_zwrite($command, $message);
+    die "Error sending zephyr" unless $ret == 0;
+}
 =head2 ztext_stylestrip STRING
 …
 Display a BarnOwl B<Admin> message, with the given header and body.
+=head2 start_edit %ARGS
+Displays a prompt on the screen and lets the user enter text,
+and calls a callback when the editwin is closed.
+C<%ARGS> must contain the following keys:
+=over 4
+=item prompt
+The line to display on the screen
+=item type
+One of:
+=over 4
+=item edit_win
+Displays the prompt on a line of its own and opens the edit_win.
+=item question
+Displays prompt on the screen and lets the user enter a line of
+text.
+=item password
+Like question, but echoes the user's input as C<*>s when they
+input.
+=back
+=item callback
+A Perl subroutine that is called when the user closes the edit_win.
+C<CALLBACK> gets called with two parameters: the text the user entered,
+and a C<SUCCESS> boolean parameter which is false if the user canceled
+the edit_win and true otherwise.
+=back
 =head2 start_question PROMPT CALLBACK
-Displays C<PROMPT> on the screen and lets the user enter a line of
-text, and calls C<CALLBACK>, which must be a perl subroutine
-reference, with the text the user entered
 =head2 start_password PROMPT CALLBACK
-Like C<start_question>, but echoes the user's input as C<*>s when they
-input.
 =head2 start_edit_win PROMPT CALLBACK
+Like C<start_question>, but displays C<PROMPT> on a line of its own
+and opens the editwin. If the user cancels the edit win, C<CALLBACK>
+is not invoked.
+Roughly equivalent to C<start_edit> called with the appropriate parameters.
+C<CALLBACK> is only called on success, for compatibility.
+These are deprecated wrappers around L<BarnOwl::start_edit>, and should not
+be uesd in new code.
+=cut
+sub start_edit {
+    my %args = (@_);
+    BarnOwl::Internal::start_edit($args{type}, $args{prompt}, $args{callback});
+}
+sub start_question {
+    my ($prompt, $callback) = @_;
+    BarnOwl::start_edit(type => 'question', prompt => $prompt, callback => sub {
+            my ($text, $success) = @_;
+            $callback->($text) if $success;
+        });
+}
+sub start_password {
+    my ($prompt, $callback) = @_;
+    BarnOwl::start_edit(type => 'password', prompt => $prompt, callback => sub {
+            my ($text, $success) = @_;
+            $callback->($text) if $success;
+        });
+}
+sub start_edit_win {
+    my ($prompt, $callback) = @_;
+    BarnOwl::start_edit(type => 'edit_win', prompt => $prompt, callback => sub {
+            my ($text, $success) = @_;
+            $callback->($text) if $success;
+        });
+}
 =head2 get_data_dir
 …
 Returns the number of colors this BarnOwl is capable of displaying
+=head2 message_matches_filter MESSAGE FILTER_NAME [QUIET = 0]
+Returns 1 if C<FILTER_NAME> is the name of a valid filter, and
+C<MESSAGE> matches that filter.  Returns 0 otherwise.  If
+C<QUIET> is false, this method displays an error message if
+if C<FILTER_NAME> does not name a valid filter.
 =head2 add_dispatch FD CALLBACK
 …
 read from C<FD>.
+C<add_dispatch> has been deprecated in favor of C<add_io_dispatch>,
+and is now a wrapper for it called with C<mode> set to C<'r'>.
+C<add_dispatch> has been deprecated in favor of C<AnyEvent>, and is
+now a wrapper for C<add_io_dispatch> called with C<mode> set to
+C<'r'>.
 =cut
 …
 Remove a file descriptor previously registered via C<add_dispatch>
+C<remove_dispatch> has been deprecated in favor of
+C<remove_io_dispatch>.
+C<remove_dispatch> has been deprecated in favor of C<AnyEvent>.
 =cut
 …
 registered, the old one is removed.
+=cut
+C<add_io_dispatch> has been deprecated in favor of C<AnyEvent>.
+=cut
+our %_io_dispatches;
 sub add_io_dispatch {
 …
     my $modeStr = shift;
     my $cb = shift;
+    my $mode = 0;
+    $mode |= 0x1 if ($modeStr =~ /r/i); # Read
+    $mode |= 0x2 if ($modeStr =~ /w/i); # Write
+    if ($mode) {
+        $mode |= 0x4;                  # Exceptional
+        BarnOwl::Internal::add_io_dispatch($fd, $mode, $cb);
+    my @modes;
+    push @modes, 'r' if $modeStr =~ /r/i; # Read
+    push @modes, 'w' if $modeStr =~ /w/i; # Write
+    if (@modes) {
+        BarnOwl::remove_io_dispatch($fd);
+        for my $mode (@modes) {
+            push @{$_io_dispatches{$fd}}, AnyEvent->io(fh => $fd,
+                                                       poll => $mode,
+                                                       cb => $cb);
+        }
     } else {
         die("Invalid I/O Dispatch mode: $modeStr");
 …
 Remove a file descriptor previously registered via C<add_io_dispatch>
+C<remove_io_dispatch> has been deprecated in favor of C<AnyEvent>.
+=cut
+sub remove_io_dispatch {
+    my $fd = shift;
+    undef $_ foreach @{$_io_dispatches{$fd}};
+    delete $_io_dispatches{$fd};
+}
 =head2 create_style NAME OBJECT
 Creates a new barnowl style with the given NAME defined by the given
+Creates a new BarnOwl style with the given NAME defined by the given
 object. The object must have a C<description> method which returns a
 string description of the style, and a and C<format_message> method
 …
 our @all_commands;
+if(!$configfile && -f $ENV{HOME} . "/.barnowlconf") {
+    $configfile = $ENV{HOME} . "/.barnowlconf";
+}
+$configfile ||= $ENV{HOME}."/.owlconf";
+if(!$configfile) {
+    if (-f get_config_dir() . "/init.pl") {
+        $configfile = get_config_dir() . "/init.pl";
+    } elsif (-f $ENV{HOME} . "/.barnowlconf") {
+        $configfile = $ENV{HOME} . "/.barnowlconf";
+    } else {
+        $configfile = $ENV{HOME}."/.owlconf";
+    }
+}
 # populate global variable space for legacy owlconf files
 …
 =head2 new_variable_string NAME [{ARGS}]
+Add a new owl variable, either an int, a bool, or a string, with the
+=head2 new_variable_enum NAME [{ARGS}]
+Add a new owl variable, either an int, a bool, a string, or an enum with the
 specified name.
+ARGS can optionally contain the following keys:
+For new_variable_enum, ARGS is required to contain a validsettings key pointing
+to an array reference. For all four, it can optionally contain the following
+keys:
 =over 4
 …
 =back
+In addition, new_variable_string optionally accepts a string validsettings
+parameter, in case people want to set it to "<path>".
 =cut
 sub new_variable_int {
+    unshift @_, \&BarnOwl::Internal::new_variable_int, 0;
+    goto \&_new_variable;
+    my ($name, $args) = @_;
+    my $storage = defined($args->{default}) ? $args->{default} : 0;
+    BarnOwl::new_variable_full($name, {
+            %{$args},
+            get_tostring => sub { "$storage" },
+            set_fromstring => sub {
+                die "Expected integer" unless $_[0] =~ /^-?[0-9]+$/;
+                $storage = 0 + $_[0];
+            },
+            validsettings => "<int>",
+            takes_on_off => 0,
+        });
+}
 sub new_variable_bool {
+    unshift @_, \&BarnOwl::Internal::new_variable_bool, 0;
+    goto \&_new_variable;
+    my ($name, $args) = @_;
+    my $storage = defined($args->{default}) ? $args->{default} : 0;
+    BarnOwl::new_variable_full($name, {
+            %{$args},
+            get_tostring => sub { $storage ? "on" : "off" },
+            set_fromstring => sub {
+                die "Valid settings are on/off" unless $_[0] eq "on" || $_[0] eq "off";
+                $storage = $_[0] eq "on";
+            },
+            validsettings => "on,off",
+            takes_on_off => 1,
+        });
+}
 sub new_variable_string {
+    unshift @_, \&BarnOwl::Internal::new_variable_string, "";
+    goto \&_new_variable;
+}
+sub _new_variable {
+    my $func = shift;
+    my $default_default = shift;
+    my ($name, $args) = @_;
+    my $storage = defined($args->{default}) ? $args->{default} : "";
+    BarnOwl::new_variable_full($name, {
+            # Allow people to override this one if they /reaaally/ want to for
+            # some reason. Though we still reserve the right to interpret this
+            # value in interesting ways for tab-completion purposes.
+            validsettings => "<string>",
+            %{$args},
+            get_tostring => sub { $storage },
+            set_fromstring => sub { $storage = $_[0]; },
+            takes_on_off => 0,
+        });
+}
+sub new_variable_enum {
+    my ($name, $args) = @_;
+    # Gather the valid settings.
+    die "validsettings is required" unless defined($args->{validsettings});
+    my %valid;
+    map { $valid{$_} = 1 } @{$args->{validsettings}};
+    my $storage = (defined($args->{default}) ?
+                   $args->{default} :
+                   $args->{validsettings}->[0]);
+    BarnOwl::new_variable_full($name, {
+            %{$args},
+            get_tostring => sub { $storage },
+            set_fromstring => sub {
+                die "Invalid input" unless $valid{$_[0]};
+                $storage = $_[0];
+            },
+            validsettings => join(",", @{$args->{validsettings}})
+        });
+}
+=head2 new_variable_full NAME {ARGS}
+Create a variable, in full generality. The keyword arguments have types below:
+ get_tostring : ()  -> string
+ set_fromstring : string -> int
+ -- optional --
+ summary : string
+ description : string
+ validsettings : string
+ takes_on_off : int
+The get/set functions are required. Note that the caller manages storage for the
+variable. get_tostring/set_fromstring both convert AND store the value.
+set_fromstring dies on failure.
+If the variable takes parameters 'on' and 'off' (i.e. is boolean-looking), set
+takes_on_off to 1. This makes :set VAR and :unset VAR work. set_fromstring will
+be called with those arguments.
+=cut
+sub new_variable_full {
     my $name = shift;
     my $args = shift || {};
     my %args = (
         summary     => "",
+        summary => "",
         description => "",
+        default     => $default_default,
+        takes_on_off => 0,
+        validsettings => "<string>",
         %{$args});
+    $func->($name, $args{default}, $args{summary}, $args{description});
+    die "get_tostring required" unless $args{get_tostring};
+    die "set_fromstring required" unless $args{set_fromstring};
+    # Strip off the bogus dummy argument. Aargh perl-Glib.
+    my $get_tostring_fn = sub { $args{get_tostring}->() };
+    my $set_fromstring_fn = sub {
+      my ($dummy, $val) = @_;
+      # Translate from user-supplied die-on-failure callback to expected
+      # non-zero on error. Less of a nuisance than interacting with ERRSV.
+      eval { $args{set_fromstring}->($val) };
+      # TODO: Consider changing B::I::new_variable to expect string|NULL with
+      # string as the error message. That can then be translated to a GError in
+      # owl_variable_set_fromstring. For now the string is ignored.
+      return ($@ ? -1 : 0);
+    };
+    BarnOwl::Internal::new_variable($name, $args{summary}, $args{description}, $args{validsettings},
+                                    $args{takes_on_off}, $get_tostring_fn, $set_fromstring_fn, undef);
+}
 …
+{
   my $zsig = getvar('zsig');
+  if (!$zsig) {
+      if (my $zsigproc = getvar('zsigproc')) {
+  if (!defined($zsig) || $zsig eq '') {
+      my $zsigproc = getvar('zsigproc');
+      if (defined($zsigproc) && $zsigproc ne '') {
           $zsig = `$zsigproc`;
       } elsif (!defined($zsig = get_zephyr_variable('zwrite-signature'))) {

perl/lib/BarnOwl/Complete/Client.pm

-                      rc6adf17
+                      r4626016
 my %show = (
-    information => undef,
     colors      => undef,
     commands    => undef,
 …
     subs        => undef,
     terminal    => undef,
-    timers      => undef,
     variables   => undef,
     variable    => \&complete_variable,
 …
 BarnOwl::Completion::register_completer(set     => \&complete_set);
 BarnOwl::Completion::register_completer(unset   => \&complete_set);
+BarnOwl::Completion::register_completer(startup => \&complete_startup);
+BarnOwl::Completion::register_completer(startup   => \&complete_startup);
+BarnOwl::Completion::register_completer(unstartup => \&complete_startup);
 BarnOwl::Completion::register_completer(bindkey => \&complete_bindkey);
 BarnOwl::Completion::register_completer(print   => \&complete_print);

perl/lib/BarnOwl/Complete/Zephyr.pm

r3e8625f	re6e7842
64	64	BarnOwl::Completion::register_completer(viewuser => \&complete_viewuser);
65	65	BarnOwl::Completion::register_completer(vu => \&complete_viewuser);
	66	BarnOwl::Completion::register_completer(viewperson => \&complete_viewuser);
	67	BarnOwl::Completion::register_completer(vp => \&complete_viewuser);
66	68
67	69	BarnOwl::Completion::register_completer(unsub => \&complete_unsub);

perl/lib/BarnOwl/Hooks.pm

r3aa0522	rb8a3e00
146	146	}
147	147
148		# These are the internal hooks called by the ~~barno~~wl C code, which
	148	# These are the internal hooks called by the BarnOwl C code, which
149	149	# take care of dispatching to the appropriate perl hooks, and deal
150	150	# with compatibility by calling the old, fixed-name hooks.

perl/lib/BarnOwl/Message.pm

-                      rd1ae4a4
+                      r0adbce1
 sub is_ping     { return 0; }
 sub is_mail     { return 0; }
 sub is_personal { return shift->is_private; }
+sub is_personal { return BarnOwl::message_matches_filter(shift, "personal"); }
 sub class       { return undef; }
 sub instance    { return undef; }
 …
 # (eg, the oneline style)
 sub short_personal_context { return ""; }
+sub delete_and_expunge {
+    my ($m) = @_;
+    &BarnOwl::command("delete-and-expunge --quiet --id " . $m->id);
+}
 sub delete {

perl/lib/BarnOwl/Message/Zephyr.pm

-                      redd0be7
+                      r0adbce1
     my ($m) = @_;
     return undef if (!$m->is_loginout);
+    return undef if (!defined($m->fields));
     return $m->fields->[2];
+}
 …
     my ($m) = @_;
     return undef if (!$m->is_loginout);
+    return undef if (!defined($m->fields));
     return $m->fields->[0];
+}
 …
 sub is_ping     { return (lc(shift->opcode) eq "ping"); }
-sub is_personal {
-    my ($m) = @_;
-    return ((lc($m->class) eq "message")
-            && $m->is_private);
+}
 sub is_mail {
 …
         $class = $self->class;
         $instance = $self->instance;
+        if ($self->recipient eq '*' || $self->recipient eq '') {
+            $to = '';
+        } elsif ($self->recipient =~ /^@/) {
+        if ($self->recipient eq '' || $self->recipient =~ /^@/) {
             $to = $self->recipient;
         } else {

perl/lib/BarnOwl/ModuleLoader.pm

-                      rf544216
+                      rf34728b
+}
+sub complete_module_name {
+    return sort(keys %modules);
+}
 sub register_keybindings {
     BarnOwl::new_command('reload-modules', sub {BarnOwl::ModuleLoader->reload}, {
 …
                            description => q{Reloads a single module located in ~/.owl/modules or the system modules directory}
                           });
+    BarnOwl::Completion::register_completer('reload-module', \&complete_module_name);
+}

perl/lib/BarnOwl/Style/Default.pm

r5738650	r732d5c0
113	113	}
114	114	$header .= '@b{' . maybe($m->pretty_sender) . '}';
	115	if (defined($m->realm) && $m->realm ne BarnOwl::zephyr_getrealm()) {
	116	$header .= ' {' . $self->humanize($m->realm, 1) . '}';
	117	}
115	118	}
116	119

perl/lib/BarnOwl/Timer.pm

-                      rc6adf17
+                      r074bdaa
 package BarnOwl::Timer;
+use AnyEvent;
 sub new {
 …
     my $self = {cb => $cb};
-    my $name = $args->{name};
-    $name = "(unnamed)" unless defined $name;
     bless($self, $class);
+    $self->{timer} = BarnOwl::Internal::add_timer($args->{after} || 0,
+                                                  $args->{interval} || 0,
+                                                  $self,
+                                                  $name);
+    $self->{timer} = AnyEvent->timer(%$args);
     return $self;
+}
 …
 sub stop {
     my $self = shift;
+    if(defined($self->{timer})) {
+        BarnOwl::Internal::remove_timer($self->{timer});
+        undef $self->{timer};
+    }
+    undef $self->{timer};
+}

perl/lib/BarnOwl/Zephyr.pm

rdf569c5	r53151d4
12	12	use BarnOwl::Hook;
13	13
14		my $zephyrStartup = BarnOwl::Hook->new;
	14	our $zephyrStartup = BarnOwl::Hook->new;
15	15
16	16	sub _zephyr_startup {

perl/lib/Module/Install/BarnOwl.pm

-                      r3519d06
+                      re4b8f93
 =head1 DESCRIPTION
 Module::Install::BarnOwl is a M::I module to help building barnowl
+Module::Install::BarnOwl is a M::I module to help building BarnOwl
 modules,
 …
 As well as make rules to generate Jabber.par, and to put some
 additional barnowl-specific information into META.yml
+additional BarnOwl-specific information into META.yml
 =cut
 …
     my $class = ref $self;
+    my $srcdir = $ENV{BARNOWL_SRCDIR} || '.';
     $self->name("BarnOwl-Module-$name");
+    $self->all_from("lib/BarnOwl/Module/$name.pm");
+    $self->all_from("$srcdir/lib/BarnOwl/Module/$name.pm");
+    $self->makemaker_args(PMLIBDIRS => ["$srcdir/lib"],
+                          PMLIBPARENTDIRS => ["$srcdir/lib"]);
     $self->postamble(<<"END_MAKEFILE");
 # --- $class section:
+BARNOWL_SRCDIR = $srcdir
+export BARNOWL_SRCDIR
 $name.par: pm_to_blib

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

-                      r5c6d661
+                      r731e921
 =head1 DESCRIPTION
 This module implements IRC support for barnowl.
+This module implements IRC support for BarnOwl.
 =cut
 …
 use Getopt::Long;
 use Encode;
+use Text::Wrap;
 our $VERSION = 0.02;
 …
         description => 'If set, each (space-separated) message type ' .
         'provided will be hidden and ignored if received.'
+       });
+    BarnOwl::new_variable_int('irc:max-message-length', {
+        default     => 450,
+        summary     => 'Split messages to at most this many characters.' .
+                       "If non-positive, don't split messages",
+        description => 'If set to a positive number, any paragraph in an ' .
+                       'IRC message will be split after this many characters.'
        });
 …
     @msgs = split "\n\n", $fullbody;
     map { tr/\n/ / } @msgs;
+    # split each body at irc:max-message-length characters, if that number
+    # is positive.  Only split at space boundaries.  Start counting a-fresh
+    # at the beginning of each paragraph
+    my $max_len = BarnOwl::getvar('irc:max-message-length');
+    if ($max_len > 0) {
+        local($Text::Wrap::columns) = $max_len;
+        @msgs = split "\n", wrap("", "", join "\n", @msgs);
+    }
     for my $body (@msgs) {
         if ($body =~ /^\/me (.*)/) {
 …
+        }
         if(!$channel &&
+        if(!defined($channel) &&
            ($flags & CHANNEL_ARG) &&
            !($flags & CHANNEL_OPTIONAL)) {

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

-                      rb401ef2
+                      ra27acf7
     my ($recip, $account, $subject) = @_;
     if (defined $recip) {
         my @cmd = ('jwrite', $recip, '-a', $account);
+        my @cmd = ('jwrite', '-a', $account);
         if (defined $subject) {
             push @cmd, '-s', $subject;
+        }
+        push @cmd, '--', $recip;
         return BarnOwl::quote(@cmd);
     } else {

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

-                      rc8d9f84
+                      r8258ea5
 =head1 DESCRIPTION
 This module implements Jabber support for barnowl.
+This module implements Jabber support for BarnOwl.
 =cut
 …
         if($IO::Socket::SSL::VERSION eq "0.97") {
             BarnOwl::error("You are using IO::Socket:SSL 0.97, which \n" .
                            "contains bugs causing it not to work with barnowl's\n" .
+                           "contains bugs causing it not to work with BarnOwl's\n" .
                            "Jabber support. We recommend updating to the latest\n" .
                            "IO::Socket::SSL from CPAN. \n");
 …
               . "configure [<muc>]\n"
               . "            Configures a MUC.\n"
               . "            Necessary to initalize a new MUC.\n"
+              . "            Necessary to initialize a new MUC.\n"
               . "            At present, only the default configuration is supported.\n"
               . "            The MUC is taken from the current message if not supplied.\n\n"
 …
+}
+sub complete_jabberlogout {
+    my $ctx = shift;
+    if($ctx->word == 1) {
+        return ("-A", complete_account() );
+    } else {
+        return ();
+    }
+}
 BarnOwl::Completion::register_completer(jwrite => sub { BarnOwl::Module::Jabber::complete_jwrite(@_) });
+BarnOwl::Completion::register_completer(jabberlogout => sub { BarnOwl::Module::Jabber::complete_jabberlogout(@_) });
 ;

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

-                      r2cca044
+                      rb8a3e00
 =head1 DESCRIPTION
 A class to keep track of all the active connection in the barnowl
 jabber module
+A class to keep track of all the active connection in the BarnOwl
+Jabber module
 =cut

perl/modules/Jabber/lib/Net/Jabber/Component.pm

rc2bed55	ra8c55b5
220	220	$self->{STREAM}->SetCallBacks(node=>undef);
221	221
222		$self->Send("<handshake>".Digest::SHA1::sha1_hex($self->{SESSION}->{id}.$args{secret})."</handshake>");
	222	$self->Send("<handshake>".Digest::SHA::sha1_hex($self->{SESSION}->{id}.$args{secret})."</handshake>");
223	223	my $handshake = $self->Process();
224	224

perl/modules/Jabber/lib/Net/Jabber/Key.pm

-                      rc2bed55
+                      ra8c55b5
     $self->{CACHE} = {};
     if (eval "require Digest::SHA1")
+    if (eval "require Digest::SHA")
+    {
         $self->{DIGEST} = 1;
         Digest::SHA1->import(qw(sha1 sha1_hex sha1_base64));
+        Digest::SHA->import(qw(sha1 sha1_hex sha1_base64));
+    }
     else
+    {
         print "ERROR:  You cannot use Key.pm unless you have Digest::SHA1 installed.\n";
+        print "ERROR:  You cannot use Key.pm unless you have Digest::SHA installed.\n";
         exit(0);
+    }
 …
     my $string = $$.time.rand(1000000);
     $string = Digest::SHA1::sha1_hex($string);
+    $string = Digest::SHA::sha1_hex($string);
     $self->{DEBUG}->Log1("Generate: key($string)");
     return $string;

perl/modules/Jabber/lib/Net/XMPP.pm

rc2bed55	ra8c55b5
213	213	use Time::Local;
214	214	use Carp;
215		use Digest::SHA1;
	215	use Digest::SHA;
216	216	use Authen::SASL;
217	217	use MIME::Base64;

perl/modules/Jabber/lib/Net/XMPP/Protocol.pm

r7f33c18	ra8c55b5
1849	1849	if ($authType eq "zerok")
1850	1850	{
1851		my $hashA = Digest::SHA1::sha1_hex($password);
1852		$args{hash} = Digest::SHA1::sha1_hex($hashA.$token);
	1851	my $hashA = Digest::SHA::sha1_hex($password);
	1852	$args{hash} = Digest::SHA::sha1_hex($hashA.$token);
1853	1853
1854	1854	for (1..$sequence)
1855	1855	{
1856		$args{hash} = Digest::SHA1::sha1_hex($args{hash});
	1856	$args{hash} = Digest::SHA::sha1_hex($args{hash});
1857	1857	}
1858	1858	}
…	…
1868	1868	if ($authType eq "digest")
1869	1869	{
1870		$args{digest} = Digest::SHA1::sha1_hex($self->GetStreamID().$password);
	1870	$args{digest} = Digest::SHA::sha1_hex($self->GetStreamID().$password);
1871	1871	}
1872	1872

perl/modules/Makefile.am

-                      r1fd469d4
+                      re4b8f93
 MODULES = Jabber IRC WordWrap Twitter
+MODULES = Jabber IRC WordWrap Twitter Facebook
+EXTRA_DIST = $(MODULES:=/Makefile.PL) $(MODULES:=/inc) $(MODULES:=/lib)
+EXTRA_DIST = $(MODULES:=/Makefile.PL) $(MODULES:=/lib)
+EXTRA_DIST += \
+    Facebook/README \
+    Twitter/README \
+    Twitter/twitter.example
 all-local: $(MODULES)
 …
         (cd $* && $(MAKE) $*.par)
+BARNOWL_PERL := $(shell which perl) -I$(abs_srcdir)/../lib
 MODULES_MAKEFILE = $(MODULES:=/Makefile)
+$(MODULES_MAKEFILE): %/Makefile: %/Makefile.PL
+        $(AM_V_GEN)(cd $* && perl -I../../lib Makefile.PL)
+$(MODULES_MAKEFILE): %/Makefile: %/Makefile.PL ../lib/Module/Install/BarnOwl.pm
+        $(AM_V_GEN)test -d $* || mkdir $*
+        $(AM_V_at)test $(srcdir) = . || $(LN_S) $(abs_srcdir)/$*/Makefile.PL $*/Makefile.PL
+        $(AM_V_at)(cd $* && BARNOWL_SRCDIR='$(abs_srcdir)/$*' && export BARNOWL_SRCDIR && $(BARNOWL_PERL) Makefile.PL 'PERL=$(BARNOWL_PERL)')
 MODULES_CLEAN = $(MODULES:%=clean_%)
 clean-local: $(MODULES_CLEAN)
 $(MODULES_CLEAN): clean_%:
+        (cd $* && (test ! -f Makefile || $(MAKE) clean))
+        (cd $* && { test ! -f Makefile || $(MAKE) realclean; })
+        rm -f $*/$*.par
+        rm -rf $*/inc
+        test $(srcdir) = . || rm -f $*/Makefile.PL
 MODULES_INSTALL = $(MODULES:%=module_install_%)
 …
         ${INSTALL_DATA} $*/$*.par ${DESTDIR}${pkgdatadir}/modules/$*.par
+uninstall-local:
+        rm -f $(MODULES:%=${DESTDIR}${pkgdatadir}/modules/%.par)
 .PHONY: $(MODULES) $(MODULES_CLEAN) $(MODULES_INSTALL)

perl/modules/Twitter/README

r8c6e2c1	rb8a3e00
118	118	the sender. Has no effect if poll_for_tweets is false.
119	119
120		* oauth_key, oauth_secret (strings, default ~~barno~~wl's consumer credentials)
	120	* oauth_key, oauth_secret (strings, default BarnOwl's consumer credentials)
121	121	These are the OAuth consumer key and secret to use to negotiate an
122	122	OAuth connection to Twitter. These credentials must be enabled for

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

rf6e1262	rb8a3e00
193	193
194	194	sub poll_messages {
195		# If we are reloaded into a ~~barno~~wl with the old
	195	# If we are reloaded into a BarnOwl with the old
196	196	# BarnOwl::Module::Twitter loaded, it still has a main loop hook
197	197	# that will call this function every second. If we just delete it,

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

-                      r7aa1fa5
+                      r4ebbfbc
 use BarnOwl;
 use BarnOwl::Message::Twitter;
 use POSIX qw(asctime);
+use POSIX qw(strftime);
 use LWP::UserAgent;
 …
                        ($self->{cfg}->{account_nickname} ?
                         "[$self->{cfg}->{account_nickname}]" : "") .
                         ": ratelimited until " . asctime(localtime($timeout)));
+                        ": ratelimited until " . strftime('%c', localtime($timeout)));
     } elsif(exists($ratelimit->{error})) {
         $self->sleep(60*20);

perlconfig.c

-                      r3b8a563
+                      r96d80e9
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <errno.h>
 #define OWL_PERL
 #include "owl.h"
+#include <stdio.h>
 extern XS(boot_BarnOwl);
 …
 SV *owl_new_sv(const char * str)
+CALLER_OWN SV *owl_new_sv(const char * str)
+{
   SV *ret = newSVpv(str, 0);
 …
+}
 AV *owl_new_av(const owl_list *l, SV *(*to_sv)(const void *))
+CALLER_OWN AV *owl_new_av(const GPtrArray *l, SV *(*to_sv)(const void *))
+{
   AV *ret;
 …
   ret = newAV();
   for (i = 0; i < owl_list_get_size(l); i++) {
     element = owl_list_get_element(l, i);
+  for (i = 0; i < l->len; i++) {
+    element = l->pdata[i];
     av_push(ret, to_sv(element));
+  }
 …
+}
 HV *owl_new_hv(const owl_dict *d, SV *(*to_sv)(const void *))
+CALLER_OWN HV *owl_new_hv(const owl_dict *d, SV *(*to_sv)(const void *))
+{
   HV *ret;
   owl_list l;
+  GPtrArray *keys;
   const char *key;
   void *element;
 …
   /* TODO: add an iterator-like interface to owl_dict */
+  owl_list_create(&l);
+  owl_dict_get_keys(d, &l);
+  for (i = 0; i < owl_list_get_size(&l); i++) {
+    key = owl_list_get_element(&l, i);
+  keys = owl_dict_get_keys(d);
+  for (i = 0; i < keys->len; i++) {
+    key = keys->pdata[i];
     element = owl_dict_find_element(d, key);
     (void)hv_store(ret, key, strlen(key), to_sv(element), 0);
+  }
   owl_list_cleanup(&l, g_free);
+  owl_ptr_array_free(keys, g_free);
   return ret;
+}
 SV *owl_perlconfig_message2hashref(const owl_message *m)
+CALLER_OWN SV *owl_perlconfig_message2hashref(const owl_message *m)
+{
   HV *h, *stash;
 …
   const char *type;
   char *ptr, *utype, *blessas;
+  int i, j;
+  const char *f;
+  int i;
   const owl_pair *pair;
   const owl_filter *wrap;
 …
                                       owl_new_sv(owl_message_get_##field(m)), 0)
+  if (owl_message_is_type_zephyr(m)
+      && owl_message_is_direction_in(m)) {
+  if (owl_message_is_type_zephyr(m) && owl_message_is_direction_in(m)) {
     /* Handle zephyr-specific fields... */
+    AV *av_zfields;
+    av_zfields = newAV();
+    j=owl_zephyr_get_num_fields(owl_message_get_notice(m));
+    for (i=0; i<j; i++) {
+      ptr=owl_zephyr_get_field_as_utf8(owl_message_get_notice(m), i+1);
+      av_push(av_zfields, owl_new_sv(ptr));
+      g_free(ptr);
+    AV *av_zfields = newAV();
+    if (owl_message_get_notice(m)) {
+      for (f = owl_zephyr_first_raw_field(owl_message_get_notice(m)); f != NULL;
+           f = owl_zephyr_next_raw_field(owl_message_get_notice(m), f)) {
+        ptr = owl_zephyr_field_as_utf8(owl_message_get_notice(m), f);
+        av_push(av_zfields, owl_new_sv(ptr));
+        g_free(ptr);
+      }
+      (void)hv_store(h, "auth", strlen("auth"),
+                     owl_new_sv(owl_zephyr_get_authstr(owl_message_get_notice(m))), 0);
+    } else {
+      /* Incoming zephyrs without a ZNotice_t are pseudo-logins. To appease
+       * existing styles, put in bogus 'auth' and 'fields' keys. */
+      (void)hv_store(h, "auth", strlen("auth"), owl_new_sv("NO"), 0);
+    }
     (void)hv_store(h, "fields", strlen("fields"), newRV_noinc((SV*)av_zfields), 0);
+    (void)hv_store(h, "auth", strlen("auth"),
+                   owl_new_sv(owl_zephyr_get_authstr(owl_message_get_notice(m))),0);
+  }
+  j=owl_list_get_size(&(m->attributes));
+  for(i=0; i<j; i++) {
+    pair=owl_list_get_element(&(m->attributes), i);
+  }
+  for (i = 0; i < m->attributes->len; i++) {
+    pair = m->attributes->pdata[i];
     (void)hv_store(h, owl_pair_get_key(pair), strlen(owl_pair_get_key(pair)),
                    owl_new_sv(owl_pair_get_value(pair)),0);
 …
+}
 SV *owl_perlconfig_curmessage2hashref(void)
+CALLER_OWN SV *owl_perlconfig_curmessage2hashref(void)
+{
   int curmsg;
 …
    message2hashref and hashref2message. Currently we lose
    zephyr-specific properties stored in the ZNotice_t
-   This has been somewhat addressed, but is still not lossless.
  */
 owl_message * owl_perlconfig_hashref2message(SV *msg)
+CALLER_OWN owl_message *owl_perlconfig_hashref2message(SV *msg)
+{
   owl_message * m;
 …
       owl_message_set_zwriteline(m, val);
     } else if (!strcmp(key, "time")) {
+      g_free(m->timestr);
       m->timestr = g_strdup(val);
       strptime(val, "%a %b %d %T %Y", &tm);
 …
       owl_message_set_attribute(m, "adminheader", "");
+  }
-#ifdef HAVE_LIBZEPHYR
-  if (owl_message_is_type_zephyr(m)) {
-    ZNotice_t *n = &(m->notice);
-    n->z_kind = ACKED;
-    n->z_port = 0;
-    n->z_auth = ZAUTH_NO;
-    n->z_checked_auth = 0;
-    n->z_class = zstr(owl_message_get_class(m));
-    n->z_class_inst = zstr(owl_message_get_instance(m));
-    n->z_opcode = zstr(owl_message_get_opcode(m));
-    n->z_sender = zstr(owl_message_get_sender(m));
-    n->z_recipient = zstr(owl_message_get_recipient(m));
-    n->z_default_format = zstr("[zephyr created from perl]");
-    n->z_multinotice = zstr("[zephyr created from perl]");
-    n->z_num_other_fields = 0;
-    n->z_message = g_strdup_printf("%s%c%s", owl_message_get_zsig(m), '\0', owl_message_get_body(m));
-    n->z_message_len = strlen(owl_message_get_zsig(m)) + strlen(owl_message_get_body(m)) + 1;
+  }
-#endif
   return m;
+}
 …
 /* Calls in a scalar context, passing it a hash reference.
    If return value is non-null, caller must free. */
+char *owl_perlconfig_call_with_message(const char *subname, const owl_message *m)
+{
+  dSP ;
+  int count;
+  SV *msgref, *srv;
+  char *out;
+  ENTER ;
+  SAVETMPS;
+  PUSHMARK(SP) ;
+CALLER_OWN char *owl_perlconfig_call_with_message(const char *subname, const owl_message *m)
+{
+  SV *msgref, *rv;
+  char *out = NULL;
   msgref = owl_perlconfig_message2hashref(m);
+  XPUSHs(sv_2mortal(msgref));
+  PUTBACK ;
+  count = call_pv(subname, G_SCALAR|G_EVAL);
+  SPAGAIN ;
+  if (SvTRUE(ERRSV)) {
+    owl_function_error("Perl Error: '%s'", SvPV_nolen(ERRSV));
+    /* and clear the error */
+    sv_setsv (ERRSV, &PL_sv_undef);
+  }
+  if (count != 1) {
+    fprintf(stderr, "bad perl!  no biscuit!  returned wrong count!\n");
+    abort();
+  }
+  srv = POPs;
+  if (srv) {
+    out = g_strdup(SvPV_nolen(srv));
+  } else {
+    out = NULL;
+  }
+  PUTBACK ;
+  FREETMPS ;
+  LEAVE ;
+  OWL_PERL_CALL((call_pv(subname, G_SCALAR|G_EVAL))
+                ,
+                XPUSHs(sv_2mortal(msgref));
+                ,
+                "Perl Error: '%s'"
+                ,
+                false
+                ,
+                false
+                ,
+                rv = POPs;
+                if (rv && SvPOK(rv))
+                  out = g_strdup(SvPV_nolen(rv));
+                );
   return out;
+}
 …
    If the return value is non-null, the caller must free it.
  */
+char * owl_perlconfig_message_call_method(const owl_message *m, const char *method, int argc, const char ** argv)
+{
+  dSP;
+  unsigned int count, i;
+  SV *msgref, *srv;
+  char *out;
+CALLER_OWN char *owl_perlconfig_message_call_method(const owl_message *m, const char *method, int argc, const char **argv)
+{
+  SV *msgref, *rv;
+  char *out = NULL;
+  int i;
   msgref = owl_perlconfig_message2hashref(m);
+  ENTER;
+  SAVETMPS;
+  PUSHMARK(SP);
+  XPUSHs(sv_2mortal(msgref));
+  for(i=0;i<argc;i++) {
+    XPUSHs(sv_2mortal(owl_new_sv(argv[i])));
+  }
+  PUTBACK;
+  count = call_method(method, G_SCALAR|G_EVAL);
+  SPAGAIN;
+  if(count != 1) {
+    fprintf(stderr, "perl returned wrong count %u\n", count);
+    abort();
+  }
+  if (SvTRUE(ERRSV)) {
+    owl_function_error("Error: '%s'", SvPV_nolen(ERRSV));
+    /* and clear the error */
+    sv_setsv (ERRSV, &PL_sv_undef);
+  }
+  srv = POPs;
+  if (srv) {
+    out = g_strdup(SvPV_nolen(srv));
+  } else {
+    out = NULL;
+  }
+  PUTBACK;
+  FREETMPS;
+  LEAVE;
+  OWL_PERL_CALL(call_method(method, G_SCALAR|G_EVAL)
+                ,
+                XPUSHs(sv_2mortal(msgref));
+                OWL_PERL_PUSH_ARGS(i, argc, argv);
+                ,
+                "Perl Error: '%s'"
+                ,
+                false
+                ,
+                false
+                ,
+                rv = POPs;
+                if (rv && SvPOK(rv))
+                  out = g_strdup(SvPV_nolen(rv));
+                );
   return out;
+}
 char *owl_perlconfig_initperl(const char * file, int *Pargc, char ***Pargv, char *** Penv)
+/* caller must free result, if not NULL */
+CALLER_OWN char *owl_perlconfig_initperl(const char *file, int *Pargc, char ***Pargv, char ***Penv)
+{
   int ret;
 …
   char *err;
   const char *args[4] = {"", "-e", "0;", NULL};
+  const char *dlerr;
   AV *inc;
   char *path;
 …
   /* Add the system lib path to @INC */
   inc = get_av("INC", 0);
   path = g_strdup_printf("%s/lib", owl_get_datadir());
+  path = g_build_filename(owl_get_datadir(), "lib", NULL);
   av_unshift(inc, 1);
   av_store(inc, 0, owl_new_sv(path));
   g_free(path);
+  /* Load up perl-Glib. */
+  eval_pv("use Glib;", FALSE);
+  /* Now, before BarnOwl tries to use them, get the relevant function pointers out. */
+  dlerr = owl_closure_init();
+  if (dlerr) {
+    return g_strdup(dlerr);
+  }
+  /* And now it's safe to import BarnOwl. */
   eval_pv("use BarnOwl;", FALSE);
 …
 /* caller is responsible for freeing returned string */
 char *owl_perlconfig_execute(const char *line)
+CALLER_OWN char *owl_perlconfig_execute(const char *line)
+{
   STRLEN len;
 …
 void owl_perlconfig_new_command(const char *name)
+{
+  dSP;
+  ENTER;
+  SAVETMPS;
+  PUSHMARK(SP);
+  XPUSHs(sv_2mortal(owl_new_sv(name)));
+  PUTBACK;
+  call_pv("BarnOwl::Hooks::_new_command", G_SCALAR|G_VOID|G_EVAL);
+  SPAGAIN;
+  if(SvTRUE(ERRSV)) {
+    owl_function_error("%s", SvPV_nolen(ERRSV));
+  }
+  FREETMPS;
+  LEAVE;
+}
+char *owl_perlconfig_perlcmd(const owl_cmd *cmd, int argc, const char *const *argv)
+{
+  int i, count;
+  char * ret = NULL;
+  OWL_PERL_CALL(call_pv("BarnOwl::Hooks::_new_command", G_VOID|G_EVAL);
+                ,
+                XPUSHs(sv_2mortal(owl_new_sv(name)));
+                ,
+                "Perl Error: '%s'"
+                ,
+                false
+                ,
+                true
+                ,
+                );
+}
+CALLER_OWN char *owl_perlconfig_perl_call(const char *method, int argc, const char *const *argv)
+{
   SV *rv;
+  dSP;
+  ENTER;
+  SAVETMPS;
+  PUSHMARK(SP);
+  for(i=0;i<argc;i++) {
+    XPUSHs(sv_2mortal(owl_new_sv(argv[i])));
+  }
+  PUTBACK;
+  count = call_sv(cmd->cmd_perl, G_SCALAR|G_EVAL);
+  SPAGAIN;
+  if(SvTRUE(ERRSV)) {
+    owl_function_error("%s", SvPV_nolen(ERRSV));
+    (void)POPs;
+  } else {
+    if(count != 1)
+      croak("Perl command %s returned more than one value!", cmd->name);
+    rv = POPs;
+    if(SvTRUE(rv)) {
+      ret = g_strdup(SvPV_nolen(rv));
+    }
+  }
+  FREETMPS;
+  LEAVE;
+  char *out = NULL;
+  int i;
+  OWL_PERL_CALL(call_pv(method, G_SCALAR|G_EVAL)
+                ,
+                OWL_PERL_PUSH_ARGS(i, argc, argv);
+                ,
+                "Perl Error: '%s'"
+                ,
+                false
+                ,
+                false
+                ,
+                rv = POPs;
+                if (rv && SvPOK(rv))
+                  out = g_strdup(SvPV_nolen(rv));
+                );
+  return out;
+}
+int owl_perlconfig_perl_call_int(const char *method, int argc, const char *const *argv)
+{
+  SV *rv;
+  int ret = -1;
+  int i;
+  OWL_PERL_CALL(call_pv(method, G_SCALAR|G_EVAL)
+                ,
+                OWL_PERL_PUSH_ARGS(i, argc, argv);
+                ,
+                "Perl Error: '%s'"
+                ,
+                false
+                ,
+                false
+                ,
+                rv = POPs;
+                if (rv && SvIOK(rv))
+                  ret = SvIV(rv);
+                );
   return ret;
+}
+bool owl_perlconfig_perl_call_bool(const char *method, int argc, const char *const *argv)
+{
+  SV *rv;
+  bool ret = false;
+  int i;
+  OWL_PERL_CALL(call_pv(method, G_SCALAR|G_EVAL)
+                ,
+                OWL_PERL_PUSH_ARGS(i, argc, argv);
+                ,
+                "Perl Error: '%s'"
+                ,
+                false
+                ,
+                false
+                ,
+                rv = POPs;
+                if (rv)
+                  ret = SvTRUE(rv);
+                );
+  return ret;
+}
+void owl_perlconfig_perl_call_norv(const char *method, int argc, const char *const *argv)
+{
+  int i;
+  OWL_PERL_CALL(call_pv(method, G_DISCARD|G_EVAL)
+                ,
+                OWL_PERL_PUSH_ARGS(i, argc, argv);
+                ,
+                "Perl Error: '%s'"
+                ,
+                false
+                ,
+                true
+                ,
+                );
+}
+/* caller must free the result */
+CALLER_OWN char *owl_perlconfig_perlcmd(const owl_cmd *cmd, int argc, const char *const *argv)
+{
+  int i;
+  SV* rv;
+  char *out = NULL;
+  OWL_PERL_CALL(call_sv(cmd->cmd_perl, G_SCALAR|G_EVAL)
+                ,
+                OWL_PERL_PUSH_ARGS(i, argc, argv);
+                ,
+                "Perl Error: '%s'"
+                ,
+                false
+                ,
+                false
+                ,
+                rv = POPs;
+                if (rv && SvPOK(rv))
+                  out = g_strdup(SvPV_nolen(rv));
+                );
+  return out;
+}
 void owl_perlconfig_cmd_cleanup(owl_cmd *cmd)
+{
 …
+}
+void owl_perlconfig_io_dispatch_destroy(const owl_io_dispatch *d)
+{
+  SvREFCNT_dec(d->data);
+}
+void owl_perlconfig_edit_callback(owl_editwin *e)
+void owl_perlconfig_edit_callback(owl_editwin *e, bool success)
+{
   SV *cb = owl_editwin_get_cbdata(e);
+  SV *text;
+  dSP;
+  if(cb == NULL) {
+  SV *text = owl_new_sv(owl_editwin_get_text(e));
+  if (cb == NULL) {
     owl_function_error("Perl callback is NULL!");
     return;
+  }
+  text = owl_new_sv(owl_editwin_get_text(e));
+  ENTER;
+  SAVETMPS;
+  PUSHMARK(SP);
+  XPUSHs(sv_2mortal(text));
+  PUTBACK;
+  call_sv(cb, G_DISCARD|G_EVAL);
+  if(SvTRUE(ERRSV)) {
+    owl_function_error("%s", SvPV_nolen(ERRSV));
+  }
+  FREETMPS;
+  LEAVE;
+  OWL_PERL_CALL(call_sv(cb, G_DISCARD|G_EVAL)
+                ,
+                XPUSHs(sv_2mortal(text));
+                XPUSHs(sv_2mortal(newSViv(success)));
+                ,
+                "Perl Error: '%s'"
+                ,
+                false
+                ,
+                true
+                ,
+                );
+}
 …
   SvREFCNT_dec(v);
+}
-void owl_perlconfig_io_dispatch(const owl_io_dispatch *d, void *data)
+{
-  SV *cb = data;
-  dSP;
-  if(cb == NULL) {
-    owl_function_error("Perl callback is NULL!");
-    return;
+  }
-  ENTER;
-  SAVETMPS;
-  PUSHMARK(SP);
-  PUTBACK;
-  call_sv(cb, G_DISCARD|G_EVAL);
-  if(SvTRUE(ERRSV)) {
-    owl_function_error("%s", SvPV_nolen(ERRSV));
+  }
-  FREETMPS;
-  LEAVE;
+}
-void owl_perlconfig_perl_timer(owl_timer *t, void *data)
+{
-  dSP;
-  SV *obj = data;
-  if(!SvROK(obj)) {
-    return;
+  }
-  ENTER;
-  SAVETMPS;
-  PUSHMARK(SP);
-  XPUSHs(obj);
-  PUTBACK;
-  call_method("do_callback", G_DISCARD|G_EVAL);
-  SPAGAIN;
-  if (SvTRUE(ERRSV)) {
-    owl_function_error("Error in callback: '%s'", SvPV_nolen(ERRSV));
-    sv_setsv (ERRSV, &PL_sv_undef);
+  }
-  PUTBACK;
-  FREETMPS;
-  LEAVE;
+}
-void owl_perlconfig_perl_timer_destroy(owl_timer *t)
+{
-  if(SvOK((SV*)t->data)) {
-    SvREFCNT_dec((SV*)t->data);
+  }
+}

perlglue.xs

-                      r3b8a563
+                      r1ced34f
 /* -*- mode: c; indent-tabs-mode: t; c-basic-offset: 8 -*- */
-#ifdef HAVE_LIBZEPHYR
-#include <zephyr/zephyr.h>
-#endif
-#include <EXTERN.h>
 #define OWL_PERL
 #include "owl.h"
 …
         OUTPUT:
                 RETVAL
+int
+getnumlines()
+        CODE:
+                RETVAL = owl_global_get_lines(&g);
+        OUTPUT:
+                RETVAL
 time_t
 getidletime()
 …
         OUTPUT:
                 RETVAL
-void
-zephyr_zwrite(cmd,msg)
-        const char *cmd
-        const char *msg
-        PREINIT:
-                int i;
-        CODE:
-                i = owl_zwrite_create_and_send_from_line(cmd, msg);
 const utf8 *
 …
                 g_free(rv);
+void
+SV *
 queue_message(msg)
         SV *msg
 …
                 owl_global_messagequeue_addmsg(&g, m);
+        }
+                RETVAL = owl_perlconfig_message2hashref(m);
+        }
+        OUTPUT:
+                RETVAL
 void
 …
+        {
                 owl_function_adminmsg(header, body);
+        }
-void
-start_question(line, callback)
-        const char *line
-        SV *callback
-        PREINIT:
-                owl_editwin *e;
-        CODE:
+        {
-                if(!SV_IS_CODEREF(callback))
-                        croak("Callback must be a subref");
-                e = owl_function_start_question(line);
-                owl_editwin_set_cbdata(e,
-                                       newSVsv(callback),
-                                       owl_perlconfig_dec_refcnt);
-                owl_editwin_set_callback(e, owl_perlconfig_edit_callback);
+        }
-void
-start_password(line, callback)
-        const char *line
-        SV *callback
-        PREINIT:
-                owl_editwin *e;
-        CODE:
+        {
-                if(!SV_IS_CODEREF(callback))
-                        croak("Callback must be a subref");
-                e = owl_function_start_password(line);
-                owl_editwin_set_cbdata(e,
-                                       newSVsv(callback),
-                                       owl_perlconfig_dec_refcnt);
-                owl_editwin_set_callback(e, owl_perlconfig_edit_callback);
+        }
-void
-start_edit_win(line, callback)
-        const char *line
-        SV *callback
-        CODE:
+        {
-                if(!SV_IS_CODEREF(callback))
-                        croak("Callback must be a subref");
-                owl_function_start_edit_win(line,
-                                            owl_perlconfig_edit_callback,
-                                            newSVsv(callback),
-                                            owl_perlconfig_dec_refcnt);
+        }
 …
+        }
+bool
+message_matches_filter(message, filter_name, quiet = false)
+        SV *message
+        const char *filter_name
+        bool quiet
+        PREINIT:
+                owl_message *m;
+                const owl_filter *f;
+        CODE:
+        {
+                if (!SvROK(message) || SvTYPE(SvRV(message)) != SVt_PVHV) {
+                        croak("Usage: BarnOwl::message_matches_filter($message, $filter_name[, $quiet])");
+                }
+                m = owl_perlconfig_hashref2message(message);
+                f = owl_global_get_filter(&g, filter_name);
+                if (!f && !quiet) {
+                        owl_function_error("%s filter is not defined", filter_name);
+                }
+                RETVAL = f && owl_filter_message_match(f, m);
+        }
+        OUTPUT:
+                RETVAL
+        CLEANUP:
+                owl_message_delete(m);
 const utf8 *
 wordwrap(in, cols)
 …
                 g_free(rv);
-void
-remove_io_dispatch(fd)
-        int fd
-        CODE:
-        owl_select_remove_perl_io_dispatch(fd);
 AV*
 all_filters()
         PREINIT:
+                owl_list fl;
+        CODE:
+        {
+                owl_list_create(&fl);
+                owl_dict_get_keys(&g.filters, &fl);
+                RETVAL = owl_new_av(&fl, (SV*(*)(const void*))owl_new_sv);
+                GPtrArray *fl;
+        CODE:
+        {
+                fl = owl_dict_get_keys(&g.filters);
+                RETVAL = owl_new_av(fl, (SV*(*)(const void*))owl_new_sv);
                 sv_2mortal((SV*)RETVAL);
                 owl_list_cleanup(&fl, g_free);
+                owl_ptr_array_free(fl, g_free);
+        }
         OUTPUT:
 …
 all_styles()
         PREINIT:
+                owl_list l;
+        CODE:
+        {
+                owl_list_create(&l);
+                owl_global_get_style_names(&g, &l);
+                RETVAL = owl_new_av(&l, (SV*(*)(const void*))owl_new_sv);
+                GPtrArray *l;
+        CODE:
+        {
+                l = owl_global_get_style_names(&g);
+                RETVAL = owl_new_av(l, (SV*(*)(const void*))owl_new_sv);
                 sv_2mortal((SV*)RETVAL);
+        }
 …
                 RETVAL
         CLEANUP:
                 owl_list_cleanup(&l, g_free);
+                owl_ptr_array_free(l, g_free);
 …
 all_variables()
         PREINIT:
+                owl_list l;
+        CODE:
+        {
+                owl_list_create(&l);
+                owl_dict_get_keys(owl_global_get_vardict(&g), &l);
+                RETVAL = owl_new_av(&l, (SV*(*)(const void*))owl_new_sv);
+                GPtrArray *l;
+        CODE:
+        {
+                l = owl_dict_get_keys(owl_global_get_vardict(&g));
+                RETVAL = owl_new_av(l, (SV*(*)(const void*))owl_new_sv);
                 sv_2mortal((SV*)RETVAL);
+        }
 …
                 RETVAL
         CLEANUP:
                 owl_list_cleanup(&l, g_free);
+                owl_ptr_array_free(l, g_free);
 …
 all_keymaps()
         PREINIT:
                 owl_list l;
+                GPtrArray *l;
                 const owl_keyhandler *kh;
         CODE:
+        {
                 kh = owl_global_get_keyhandler(&g);
+                owl_list_create(&l);
+                owl_keyhandler_get_keymap_names(kh, &l);
+                RETVAL = owl_new_av(&l, (SV*(*)(const void*))owl_new_sv);
+                l = owl_keyhandler_get_keymap_names(kh);
+                RETVAL = owl_new_av(l, (SV*(*)(const void*))owl_new_sv);
                 sv_2mortal((SV*)RETVAL);
+        }
 …
                 RETVAL
         CLEANUP:
                 owl_list_cleanup(&l, g_free);
+                owl_ptr_array_free(l, g_free);
 void
 …
+           }
+void
+new_variable_string(name, ival, summ, desc)
+        const char * name
+        const char * ival
+        const char * summ
+        const char * desc
+        CODE:
+        owl_variable_dict_newvar_string(owl_global_get_vardict(&g),
+                                        name,
+                                        summ,
+                                        desc,
+                                        ival);
+void
+new_variable_int(name, ival, summ, desc)
+        const char * name
+        int ival
+        const char * summ
+        const char * desc
+        CODE:
+        owl_variable_dict_newvar_int(owl_global_get_vardict(&g),
+                                     name,
+                                     summ,
+                                     desc,
+                                     ival);
+void
+new_variable_bool(name, ival, summ, desc)
+        const char * name
+        int ival
+        const char * summ
+        const char * desc
+        CODE:
+        owl_variable_dict_newvar_bool(owl_global_get_vardict(&g),
+                                      name,
+                                      summ,
+                                      desc,
+                                      ival);
+void
+add_io_dispatch(fd, mode, cb)
+        int fd
+        int mode
+        SV * cb
+        CODE:
+        owl_select_add_perl_io_dispatch(fd, mode, newSVsv(cb));
+IV
+add_timer(after, interval, cb, name = NULL)
+        int after
+        int interval
+        SV *cb
+        const char *name
+        PREINIT:
+                SV *ref;
+                owl_timer *t;
+        CODE:
+                ref = sv_rvweaken(newSVsv(cb));
+                t = owl_select_add_timer(name,
+                                         after,
+                                         interval,
+                                         owl_perlconfig_perl_timer,
+                                         owl_perlconfig_perl_timer_destroy,
+                                         ref);
+                owl_function_debugmsg("Created timer %s: %p", t->name ? t->name : "(unnamed)", t);
+        RETVAL = (IV)t;
+        OUTPUT:
+                RETVAL
+void
+remove_timer(timer)
+        IV timer
+        PREINIT:
+                owl_timer *t;
+        CODE:
+                t = (owl_timer*)timer;
+                owl_function_debugmsg("Freeing timer %s: %p", t->name ? t->name : "(unnamed)", t);
+                owl_select_remove_timer(t);
+MODULE = BarnOwl                PACKAGE = BarnOwl::Internal
+void
+new_variable(name, summary, description, validsettings, takes_on_off, get_tostring_fn, set_fromstring_fn, data)
+    const char *name
+    const char *summary
+    const char *description
+    const char *validsettings
+    int takes_on_off
+    SV *get_tostring_fn
+    SV *set_fromstring_fn
+    SV *data
+    CODE:
+{
+        /* data is somewhat redundant given we can create closures, but oh
+         * well. Might be convenient sometimes. */
+        if(!SV_IS_CODEREF(get_tostring_fn)) {
+                croak("To-string function must be a coderef!");
+        }
+        if(!SV_IS_CODEREF(set_fromstring_fn)) {
+                croak("From-string function must be a coderef!");
+        }
+        owl_variable_dict_newvar_other(owl_global_get_vardict(&g),
+                                       name, summary, description, validsettings, takes_on_off,
+                                       perl_closure_new(get_tostring_fn, data, false),
+                                       perl_closure_new(set_fromstring_fn, data, false));
+}
+void
+start_edit(edit_type, line, callback)
+        const char *edit_type
+        const char *line
+        SV *callback
+        PREINIT:
+                owl_editwin *e;
+        CODE:
+        {
+                if (!SV_IS_CODEREF(callback))
+                        croak("Callback must be a subref");
+                if (!strcmp(edit_type, "question"))
+                        e = owl_function_start_question(line);
+                else if (!strcmp(edit_type, "password"))
+                        e = owl_function_start_password(line);
+                else if (!strcmp(edit_type, "edit_win"))
+                        e = owl_function_start_edit_win(line);
+                else
+                        croak("edit_type must be one of 'password', 'question', 'edit_win', not '%s'", edit_type);
+                owl_editwin_set_cbdata(e, newSVsv(callback), owl_perlconfig_dec_refcnt);
+                owl_editwin_set_callback(e, owl_perlconfig_edit_callback);
+        }
+int
+zephyr_zwrite(cmd,msg)
+        const char *cmd
+        const char *msg
+        CODE:
+                RETVAL = owl_zwrite_create_and_send_from_line(cmd, msg);
+        OUTPUT:
+                RETVAL
 MODULE = BarnOwl                PACKAGE = BarnOwl::Editwin

popexec.c

-                      r47e0a6a
+                      re146cd7
   int pipefds[2], child_write_fd, parent_read_fd;
   pid_t pid;
+  GIOChannel *channel;
   if (owl_global_get_popwin(&g) || owl_global_get_viewwin(&g)) {
 …
     pe->pid=pid;
     pe->winactive=1;
+    pe->dispatch = owl_select_add_io_dispatch(parent_read_fd, OWL_IO_READ|OWL_IO_EXCEPT, &owl_popexec_inputhandler, &owl_popexec_delete_dispatch, pe);
+    channel = g_io_channel_unix_new(parent_read_fd);
+    g_io_channel_set_close_on_unref(channel, TRUE);
+    pe->io_watch = g_io_add_watch_full(channel, G_PRIORITY_DEFAULT,
+                                       G_IO_IN | G_IO_ERR | G_IO_HUP,
+                                       owl_popexec_inputhandler, pe,
+                                       (GDestroyNotify)owl_popexec_unref);
+    g_io_channel_unref(channel);
     pe->refcount++;
   } else {
 …
+}
 void owl_popexec_inputhandler(const owl_io_dispatch *d, void *data)
+gboolean owl_popexec_inputhandler(GIOChannel *source, GIOCondition condition, void *data)
+{
   owl_popexec *pe = data;
 …
   char *buf;
   int status;
+  int fd = g_io_channel_unix_get_fd(source);
+  if (!pe) return;
+  /* TODO: Reading from GIOChannel may be more convenient. */
+  if (!pe) return FALSE;
   /* If pe->winactive is 0 then the vwin has closed.
 …
   /* the viewwin has closed */
   if (!pe->pid && !pe->winactive) {
+    owl_select_remove_io_dispatch(d);
+    pe->dispatch = NULL;
+    return;
+    pe->io_watch = 0;
+    return FALSE;
+  }
   if (0 != (rv_navail = ioctl(d->fd, FIONREAD, &navail))) {
+  if (0 != (rv_navail = ioctl(fd, FIONREAD, &navail))) {
     owl_function_debugmsg("ioctl error");
+  }
 …
       owl_viewwin_append_text(pe->vwin, "\n");
+    }
+    owl_select_remove_io_dispatch(d);
+    pe->dispatch = NULL;
+    return;
+    pe->io_watch = 0;
+    return FALSE;
+  }
   if (d->fd<0 || !pe->pid || !pe->winactive || rv_navail) {
+  if (fd<0 || !pe->pid || !pe->winactive || rv_navail) {
     owl_function_error("popexec should not have reached this point");
     return;
+    return FALSE;
+  }
   if (navail<=0) return;
+  if (navail<=0) return TRUE;
   if (navail>1024) { navail = 1024; }
   buf = g_new(char, navail+1);
   owl_function_debugmsg("about to read %d", navail);
   bread = read(d->fd, buf, navail);
+  bread = read(fd, buf, navail);
   if (bread<0) {
     perror("read");
 …
+  }
   g_free(buf);
+}
+void owl_popexec_delete_dispatch(const owl_io_dispatch *d)
+{
+  owl_popexec *pe = d->data;
+  close(d->fd);
+  owl_popexec_unref(pe);
+  return TRUE;
+}
 …
   pe->winactive = 0;
   if (pe->dispatch) {
     owl_select_remove_io_dispatch(pe->dispatch);
     pe->dispatch = NULL;
+  if (pe->io_watch) {
+    g_source_remove(pe->io_watch);
+    pe->io_watch = 0;
+  }
   if (pe->pid) {

popwin.c

rddbbcffa	r6829afc
1	1	#include "owl.h"
2	2
3		owl_popwin *owl_popwin_new(void)
	3	CALLER_OWN owl_popwin *owl_popwin_new(void)
4	4	{
5	5	owl_popwin *pw = g_new0(owl_popwin, 1);

regex.c

-                      rd4927a7
+                      rf271129
-#include <string.h>
 #include "owl.h"
 …
+{
   int ret;
+  char buff1[LINE];
+  size_t errbuf_size;
+  char *errbuf;
   const char *ptr;
 …
   ret=regcomp(&(re->re), ptr, REG_EXTENDED|REG_ICASE);
   if (ret) {
+    regerror(ret, NULL, buff1, LINE);
+    owl_function_makemsg("Error in regular expression: %s", buff1);
+    errbuf_size = regerror(ret, NULL, NULL, 0);
+    errbuf = g_new(char, errbuf_size);
+    regerror(ret, NULL, errbuf, errbuf_size);
+    owl_function_error("Error in regular expression: %s", errbuf);
+    g_free(errbuf);
     g_free(re->string);
     re->string=NULL;
 …
+{
   char *quoted;
+  int ret;
   quoted=owl_text_quote(string, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
   owl_regex_create(re, quoted);
+  quoted = owl_text_quote(string, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
+  ret = owl_regex_create(re, quoted);
   g_free(quoted);
   return(0);
+  return ret;
+}

runtests.sh

-                      r5aa33fd
+                      r5db8835
 #!/bin/sh
+SRCDIR=`dirname "${0}"`
+export BARNOWL_DATA_DIR="$SRCDIR/perl/"
+export BARNOWL_BIN_DIR="$SRCDIR/"
+HARNESS_PERL=./tester exec prove t/
+exec env HARNESS_PERL=./tester prove --failures "${srcdir:=$(dirname "$0")}/t/"

scripts/do-release

-                      r74312ad
+                      rb8a3e00
     cat >&2 <<EOF
 Usage: $0 [options]
 Generate a barnowl release tarball.
+Generate a BarnOwl release tarball.
 OPTIONS:
 …
 else
     VERS=$(perl -ne 'print $1 if m{^AC_INIT\(\[[^\]]+\],\s*\[([^\]]+)\]}' configure.ac) \
         || die "Unable to parse barnowl version"
+        || die "Unable to parse BarnOwl version"
 fi
 TAG=barnowl-$VERS

scripts/locker-build

-                      r0fd5bd5
+                      r055e366
     BARNOWL="/afs/sipb.mit.edu/project/barnowl/arch/$ATHENA_SYS"
     export PKG_CONFIG_PATH="$BARNOWL/lib/pkgconfig"
+    eval $("$BARNOWL/bin/barnowl-perl-config")
     SUFFIX=
 …
     esac
     CFLAGS="-I$BARNOWL/include" \
         LDFLAGS="-L$BARNOWL/lib $opt_rpath$BARNOWL/lib" \
+    CPPFLAGS="-I$BARNOWL/include -I/usr/athena/include" \
+        LDFLAGS="-L$BARNOWL/lib -L/usr/athena/lib $opt_rpath$BARNOWL/lib" \
         ./configure --exec-prefix="/mit/barnowl/arch/$ATHENA_SYS" \
         --prefix="/mit/barnowl/builds/barnowl-$VERS" --mandir=/mit/barnowl/man \
 …
     $MAKE -j$CPUS all || die "make failed"
+    $MAKE check || die "Unit tests failed"
     if [ -n "$DRYRUN" ]; then

select.c

-                      r44976fe
+                      r84a071f
 static GMainLoop *loop = NULL;
-static GMainContext *main_context;
-static int dispatch_active = 0;
-static GSource *owl_timer_source;
-static GSource *owl_io_dispatch_source;
-static int _owl_select_timer_cmp(const owl_timer *t1, const owl_timer *t2) {
-  return t1->time - t2->time;
+}
-owl_timer *owl_select_add_timer(const char* name, int after, int interval, void (*cb)(owl_timer *, void *), void (*destroy)(owl_timer*), void *data)
+{
-  owl_timer *t = g_new(owl_timer, 1);
-  GList **timers = owl_global_get_timerlist(&g);
-  t->time = time(NULL) + after;
-  t->interval = interval;
-  t->callback = cb;
-  t->destroy = destroy;
-  t->data = data;
-  t->name = name ? g_strdup(name) : NULL;
-  *timers = g_list_insert_sorted(*timers, t,
-                                 (GCompareFunc)_owl_select_timer_cmp);
-  return t;
+}
-void owl_select_remove_timer(owl_timer *t)
+{
-  GList **timers = owl_global_get_timerlist(&g);
-  if (t && g_list_find(*timers, t)) {
-    *timers = g_list_remove(*timers, t);
-    if(t->destroy) {
-      t->destroy(t);
+    }
-    g_free(t->name);
-    g_free(t);
+  }
+}
-static gboolean owl_timer_prepare(GSource *source, int *timeout) {
-  GList **timers = owl_global_get_timerlist(&g);
-  GTimeVal now;
-  /* TODO: In the far /far/ future, g_source_get_time is what the cool
-   * kids use to get system monotonic time. */
-  g_source_get_current_time(source, &now);
-  /* FIXME: bother with millisecond accuracy now that we can? */
-  if (*timers) {
-    owl_timer *t = (*timers)->data;
-    *timeout = t->time - now.tv_sec;
-    if (*timeout <= 0) {
-      *timeout = 0;
-      return TRUE;
+    }
-    if (*timeout > 60 * 1000)
-      *timeout = 60 * 1000;
-  } else {
-    *timeout = 60 * 1000;
+  }
-  return FALSE;
+}
-static gboolean owl_timer_check(GSource *source) {
-  GList **timers = owl_global_get_timerlist(&g);
-  GTimeVal now;
-  /* TODO: In the far /far/ future, g_source_get_time is what the cool
-   * kids use to get system monotonic time. */
-  g_source_get_current_time(source, &now);
-  /* FIXME: bother with millisecond accuracy now that we can? */
-  if (*timers) {
-    owl_timer *t = (*timers)->data;
-    return t->time >= now.tv_sec;
+  }
-  return FALSE;
+}
-static gboolean owl_timer_dispatch(GSource *source, GSourceFunc callback, gpointer user_data) {
-  GList **timers = owl_global_get_timerlist(&g);
-  GTimeVal now;
-  /* TODO: In the far /far/ future, g_source_get_time is what the cool
-   * kids use to get system monotonic time. */
-  g_source_get_current_time(source, &now);
-  /* FIXME: bother with millisecond accuracy now that we can? */
-  while(*timers) {
-    owl_timer *t = (*timers)->data;
-    int remove = 0;
-    if(t->time > now.tv_sec)
-      break;
-    /* Reschedule if appropriate */
-    if(t->interval > 0) {
-      t->time = now.tv_sec + t->interval;
-      *timers = g_list_remove(*timers, t);
-      *timers = g_list_insert_sorted(*timers, t,
-                                     (GCompareFunc)_owl_select_timer_cmp);
-    } else {
-      remove = 1;
+    }
-    /* Do the callback */
-    t->callback(t, t->data);
-    if(remove) {
-      owl_select_remove_timer(t);
+    }
+  }
-  return TRUE;
+}
-static GSourceFuncs owl_timer_funcs = {
-  owl_timer_prepare,
-  owl_timer_check,
-  owl_timer_dispatch,
-  NULL
-};
-/* Returns the valid owl_io_dispatch for a given file descriptor. */
-static owl_io_dispatch *owl_select_find_valid_io_dispatch_by_fd(const int fd)
+{
-  int i, len;
-  const owl_list *dl;
-  owl_io_dispatch *d;
-  dl = owl_global_get_io_dispatch_list(&g);
-  len = owl_list_get_size(dl);
-  for(i = 0; i < len; i++) {
-    d = owl_list_get_element(dl, i);
-    if (d->fd == fd && d->valid) return d;
+  }
-  return NULL;
+}
-static int owl_select_find_io_dispatch(const owl_io_dispatch *in)
+{
-  int i, len;
-  const owl_list *dl;
-  if (in != NULL) {
-    dl = owl_global_get_io_dispatch_list(&g);
-    len = owl_list_get_size(dl);
-    for(i = 0; i < len; i++) {
-      const owl_io_dispatch *d = owl_list_get_element(dl, i);
-      if (d == in) return i;
+    }
+  }
-  return -1;
+}
-static void owl_select_invalidate_io_dispatch(owl_io_dispatch *d)
+{
-  if (d == NULL || !d->valid)
-    return;
-  d->valid = false;
-  g_source_remove_poll(owl_io_dispatch_source, &d->pollfd);
+}
-void owl_select_remove_io_dispatch(const owl_io_dispatch *in)
+{
-  int elt;
-  if (in != NULL) {
-    elt = owl_select_find_io_dispatch(in);
-    if (elt != -1) {
-      owl_list *dl = owl_global_get_io_dispatch_list(&g);
-      owl_io_dispatch *d = owl_list_get_element(dl, elt);
-      if (dispatch_active)
-        d->needs_gc = 1;
-      else {
-        owl_select_invalidate_io_dispatch(d);
-        owl_list_remove_element(dl, elt);
-        if (d->destroy)
-          d->destroy(d);
-        g_free(d);
+      }
+    }
+  }
+}
-static void owl_select_io_dispatch_gc(void)
+{
-  int i;
-  owl_list *dl;
-  dl = owl_global_get_io_dispatch_list(&g);
-  /*
-   * Count down so we aren't set off by removing items from the list
-   * during the iteration.
-   */
-  for(i = owl_list_get_size(dl) - 1; i >= 0; i--) {
-    owl_io_dispatch *d = owl_list_get_element(dl, i);
-    if(d->needs_gc) {
-      owl_select_remove_io_dispatch(d);
+    }
+  }
+}
-/* Each FD may have at most one valid dispatcher.
- * If a new dispatch is added for an FD, the old one is removed.
- * mode determines what types of events are watched for, and may be any combination of:
- * OWL_IO_READ, OWL_IO_WRITE, OWL_IO_EXCEPT
- */
-const owl_io_dispatch *owl_select_add_io_dispatch(int fd, int mode, void (*cb)(const owl_io_dispatch *, void *), void (*destroy)(const owl_io_dispatch *), void *data)
+{
-  owl_io_dispatch *d = g_new(owl_io_dispatch, 1);
-  owl_list *dl = owl_global_get_io_dispatch_list(&g);
-  owl_io_dispatch *other;
-  d->fd = fd;
-  d->valid = true;
-  d->needs_gc = 0;
-  d->mode = mode;
-  d->callback = cb;
-  d->destroy = destroy;
-  d->data = data;
-  /* TODO: Allow changing fd and mode in the middle? Probably don't care... */
-  d->pollfd.fd = fd;
-  d->pollfd.events = 0;
-  if (d->mode & OWL_IO_READ)
-    d->pollfd.events |= G_IO_IN | G_IO_HUP | G_IO_ERR;
-  if (d->mode & OWL_IO_WRITE)
-    d->pollfd.events |= G_IO_OUT | G_IO_ERR;
-  if (d->mode & OWL_IO_EXCEPT)
-    d->pollfd.events |= G_IO_PRI | G_IO_ERR;
-  g_source_add_poll(owl_io_dispatch_source, &d->pollfd);
-  other = owl_select_find_valid_io_dispatch_by_fd(fd);
-  if (other)
-    owl_select_invalidate_io_dispatch(other);
-  owl_list_append_element(dl, d);
-  return d;
+}
-static gboolean owl_io_dispatch_prepare(GSource *source, int *timeout) {
-  *timeout = -1;
-  return FALSE;
+}
-static gboolean owl_io_dispatch_check(GSource *source) {
-  int i, len;
-  const owl_list *dl;
-  dl = owl_global_get_io_dispatch_list(&g);
-  len = owl_list_get_size(dl);
-  for(i = 0; i < len; i++) {
-    owl_io_dispatch *d = owl_list_get_element(dl, i);
-    if (!d->valid) continue;
-    if (d->pollfd.revents & G_IO_NVAL) {
-      owl_function_debugmsg("Pruning defunct dispatch on fd %d.", d->fd);
-      owl_select_invalidate_io_dispatch(d);
+    }
-    if (d->pollfd.revents & d->pollfd.events)
-      return TRUE;
+  }
-  return FALSE;
+}
-static gboolean owl_io_dispatch_dispatch(GSource *source, GSourceFunc callback, gpointer user_data) {
-  int i, len;
-  const owl_list *dl;
-  dispatch_active = 1;
-  dl = owl_global_get_io_dispatch_list(&g);
-  len = owl_list_get_size(dl);
-  for (i = 0; i < len; i++) {
-    owl_io_dispatch *d = owl_list_get_element(dl, i);
-    if (!d->valid) continue;
-    if ((d->pollfd.revents & d->pollfd.events) && d->callback != NULL) {
-      d->callback(d, d->data);
+    }
+  }
-  dispatch_active = 0;
-  owl_select_io_dispatch_gc();
-  return TRUE;
+}
-static GSourceFuncs owl_io_dispatch_funcs = {
-  owl_io_dispatch_prepare,
-  owl_io_dispatch_check,
-  owl_io_dispatch_dispatch,
-  NULL
-};
-int owl_select_add_perl_io_dispatch(int fd, int mode, SV *cb)
+{
-  const owl_io_dispatch *d = owl_select_find_valid_io_dispatch_by_fd(fd);
-  if (d != NULL && d->callback != owl_perlconfig_io_dispatch) {
-    /* Don't mess with non-perl dispatch functions from here. */
-    return 1;
+  }
-  /* Also remove any invalidated perl dispatch functions that may have
-   * stuck around. */
-  owl_select_remove_perl_io_dispatch(fd);
-  owl_select_add_io_dispatch(fd, mode, owl_perlconfig_io_dispatch, owl_perlconfig_io_dispatch_destroy, cb);
-  return 0;
+}
-static owl_io_dispatch *owl_select_find_perl_io_dispatch(int fd)
+{
-  int i, len;
-  const owl_list *dl;
-  owl_io_dispatch *d;
-  dl = owl_global_get_io_dispatch_list(&g);
-  len = owl_list_get_size(dl);
-  for(i = 0; i < len; i++) {
-    d = owl_list_get_element(dl, i);
-    if (d->fd == fd && d->callback == owl_perlconfig_io_dispatch)
-      return d;
+  }
-  return NULL;
+}
-int owl_select_remove_perl_io_dispatch(int fd)
+{
-  owl_io_dispatch *d = owl_select_find_perl_io_dispatch(fd);
-  if (d != NULL) {
-    /* Only remove perl io dispatchers from here. */
-    owl_select_remove_io_dispatch(d);
-    return 0;
+  }
-  return 1;
+}
 void owl_select_init(void)
+{
-  owl_timer_source = g_source_new(&owl_timer_funcs, sizeof(GSource));
-  g_source_attach(owl_timer_source, NULL);
-  owl_io_dispatch_source = g_source_new(&owl_io_dispatch_funcs, sizeof(GSource));
-  g_source_attach(owl_io_dispatch_source, NULL);
+}
 void owl_select_run_loop(void)
+{
+  main_context = g_main_context_default();
+  loop = g_main_loop_new(main_context, FALSE);
+  loop = g_main_loop_new(NULL, FALSE);
   g_main_loop_run(loop);
+}
 …
   if (loop) {
     g_main_loop_quit(loop);
+    g_main_loop_unref(loop);
     loop = NULL;
+  }

signal.c

-                      r1d21d9f
+                      ra7fac14
 #include <errno.h>
+#include <glib.h>
 #include <pthread.h>
 #include <signal.h>
 …
 static void *signal_thread_func(void *data);
+/* Initializes the signal thread to listen for 'set' on a dedicated
+static void dummy_handler(int signum)
+{
+  /* Do nothing. This should never get called. It'd be nice to report the error
+   * or something, but you can't have nice things in a signal handler. */
+}
+#define OR_DIE(s, syscall)       \
+  G_STMT_START {                 \
+    if ((syscall) == -1) {       \
+      perror((s));               \
+      exit(1);                   \
+    }                            \
+  } G_STMT_END
+/* Initializes the signal thread to listen for 'signals' on a dedicated
  * thread. 'callback' is called *on the signal thread* when a signal
  * is received.
 …
  * This function /must/ be called before any other threads are
  * created. (Otherwise the signals will not get blocked correctly.) */
+void owl_signal_init(const sigset_t *set, void (*callback)(const siginfo_t*, void*), void *data) {
+void owl_signal_init(const int *signals, int num_signals, void (*callback)(const siginfo_t*, void*), void *data) {
+  struct sigaction sig_dummy = { .sa_handler = dummy_handler };
   int ret;
+  int i;
-  signal_set = *set;
   signal_cb = callback;
   signal_cbdata = data;
+  /* Stuff the signals into our sigset_t. Also assign all of them to a dummy
+   * handler. Otherwise, if their default is SIG_IGN, they will get dropped if
+   * delivered while processing. On Solaris, they will not get delivered at
+   * all. */
+  OR_DIE("sigemptyset", sigemptyset(&signal_set));
+  for (i = 0; i < num_signals; i++) {
+    OR_DIE("sigaddset", sigaddset(&signal_set, signals[i]));
+    OR_DIE("sigaction", sigaction(signals[i], &sig_dummy, NULL));
+  }
   /* Block these signals in all threads, so we can get them. */
   if ((ret = pthread_sigmask(SIG_BLOCK, set, NULL)) != 0) {
+  if ((ret = pthread_sigmask(SIG_BLOCK, &signal_set, NULL)) != 0) {
     errno = ret;
     perror("pthread_sigmask");
+    exit(1);
+  }
   /* Spawn a dedicated thread to sigwait. */

stubgen.pl

-                      rfd03b12
+                      rca54fd6
     if ($vartype =~ /^BOOL/) {
         print "void owl_global_set_${altvarname}_on(owl_global *g) {\n";
         print "  owl_variable_set_bool_on(&g->vars, \"$varname\");\n}\n";
+        print "  owl_variable_set_bool_on(owl_variable_get_var(&g->vars, \"$varname\"));\n}\n";
         print "void owl_global_set_${altvarname}_off(owl_global *g) {\n";
         print "  owl_variable_set_bool_off(&g->vars, \"$varname\");\n}\n";
+        print "  owl_variable_set_bool_off(owl_variable_get_var(&g->vars, \"$varname\"));\n}\n";
         print "int owl_global_is_$altvarname(const owl_global *g) {\n";
         print "  return owl_variable_get_bool(&g->vars, \"$varname\");\n}\n";
+        print "  return owl_variable_get_bool(owl_variable_get_var(&g->vars, \"$varname\"));\n}\n";
     } elsif ($vartype =~ /^PATH/ or $vartype =~ /^STRING/) {
         print "void owl_global_set_$altvarname(owl_global *g, const char *text) {\n";
         print "  owl_variable_set_string(&g->vars, \"$varname\", text);\n}\n";
+        print "  owl_variable_set_string(owl_variable_get_var(&g->vars, \"$varname\"), text);\n}\n";
         print "const char *owl_global_get_$altvarname(const owl_global *g) {\n";
         print "  return owl_variable_get_string(&g->vars, \"$varname\");\n}\n";
+        print "  return owl_variable_get_string(owl_variable_get_var(&g->vars, \"$varname\"));\n}\n";
     } elsif ($vartype =~ /^INT/ or $vartype =~ /^ENUM/) {
         print "void owl_global_set_$altvarname(owl_global *g, int n) {\n";
         print "  owl_variable_set_int(&g->vars, \"$varname\", n);\n}\n";
+        print "  owl_variable_set_int(owl_variable_get_var(&g->vars, \"$varname\"), n);\n}\n";
         print "int owl_global_get_$altvarname(const owl_global *g) {\n";
         print "  return owl_variable_get_int(&g->vars, \"$varname\");\n}\n";
+        print "  return owl_variable_get_int(owl_variable_get_var(&g->vars, \"$varname\"));\n}\n";
+    }
+    }

style.c

-                      rd4927a7
+                      r92ffd89
+{
   SV *sv = NULL;
   OWL_PERL_CALL_METHOD(s->perlobj,
                        "description",
                        ;,
                        "Error in style_get_description: %s",
 ,
                        sv = SvREFCNT_inc(POPs);
                        );
   if(sv) {
+  OWL_PERL_CALL(call_method("description", G_SCALAR|G_EVAL),
+                XPUSHs(s->perlobj);,
+                "Error in style_get_description: %s",
+,
+                false,
+                sv = SvREFCNT_inc(POPs);
+                );
+  if (sv) {
     return SvPV_nolen(sv_2mortal(sv));
   } else {
 …
   /* Call the perl object */
+  OWL_PERL_CALL_METHOD(s->perlobj,
+                       "format_message",
+                       XPUSHs(sv_2mortal(owl_perlconfig_message2hashref(m)));,
+                       "Error in format_message: %s",
+,
+                       sv = SvREFCNT_inc(POPs);
+                       );
+  OWL_PERL_CALL(call_method("format_message", G_SCALAR|G_EVAL),
+                XPUSHs(s->perlobj);
+                XPUSHs(sv_2mortal(owl_perlconfig_message2hashref(m)));,
+                "Error in format_message: %s",
+,
+                false,
+                sv = SvREFCNT_inc(POPs);
+                );
   if(sv) {
+  if (sv) {
     body = SvPV_nolen(sv);
   } else {
 …
   /* indent and ensure ends with a newline */
   indent = owl_text_indent(body, OWL_TAB);
+  indent = owl_text_indent(body, OWL_TAB, true);
   curlen = strlen(indent);
+  if (curlen==0 || indent[curlen-1] != '\n') {
+    indent[curlen] = '\n';
+    indent[curlen+1] = '\0';
+  if (curlen == 0 || indent[curlen-1] != '\n') {
+    char *tmp = indent;
+    indent = g_strconcat(tmp, "\n", NULL);
+    g_free(tmp);
+  }

t/00-core-tests.t

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

t/completion.t

-                      r3001c11
+                      re59d775
+}
 mkpath("$tmpdir/.owl/",
        "$tmpdir/.owl/modules/",
        "$tmpdir/Public/",
        "$tmpdir/Private/",
        "$tmpdir/.ours",
        "$tmpdir/www",
      {mode => 0700});
+mkpath(["$tmpdir/.owl/",
+        "$tmpdir/.owl/modules/",
+        "$tmpdir/Public/",
+        "$tmpdir/Private/",
+        "$tmpdir/.ours",
+        "$tmpdir/www"],
+, 0700);
 touch("$tmpdir/.zephyr.subs");
 touch("$tmpdir/wheee");

t/unicode.t

-                      r09ff1eb
+                      rf415f83
 use Encode;
 BEGIN { bootstrap BarnOwl; };
+use Test::More qw(no_plan);
 use Test::More qw(no_plan);
+use BarnOwl;
 my $unicode = "“hello”";

tester.c

-                      r4c7c21f
+                      r6a8b519
 #include "owl.h"
 #undef WINDOW
+#include <unistd.h>
 #include <stdlib.h>
+#include "filterproc.h"
+#include <stdio.h>
 #undef instr
 #include <curses.h>
+#include <ncursesw/curses.h>
 owl_global g;
 …
 int owl_fmtext_regtest(void);
 int owl_smartfilter_regtest(void);
+int owl_history_regtest(void);
+int call_filter_regtest(void);
 extern void owl_perl_xs_init(pTHX);
 …
   char *perlerr;
   int status = 0;
+  SCREEN *screen;
   if (argc <= 1) {
 …
   wnull = fopen("/dev/null", "w");
   rnull = fopen("/dev/null", "r");
   newterm("xterm", wnull, rnull);
+  screen = newterm("xterm", wnull, rnull);
   /* initialize global structures */
   owl_global_init(&g);
 …
   /* probably not necessary, but tear down the screen */
   endwin();
+  delscreen(screen);
   fclose(rnull);
   fclose(wnull);
 …
   numfailures += owl_fmtext_regtest();
   numfailures += owl_smartfilter_regtest();
+  numfailures += owl_history_regtest();
+  numfailures += call_filter_regtest();
   if (numfailures) {
       fprintf(stderr, "# *** WARNING: %d failures total\n", numfailures);
 …
 #define FAIL_UNLESS(desc,pred) do { int __pred = (pred);                \
     numtests++;                                                         \
     printf("%s %s", (__pred)?"ok":(numfailed++,"not ok"), desc);        \
+    printf("%s %d %s", (__pred) ? "ok" : (numfailed++, "not ok"), numtests, desc); \
     if(!(__pred)) printf("\t(%s:%d)", __FILE__, __LINE__); printf("%c", '\n'); } while(0)
 …
+{
   int numfailed=0;
+  char *path, *home;
   printf("# BEGIN testing owl_util\n");
 …
                 "\"");
   GString *g = g_string_new("");
   owl_string_appendf_quoted(g, "%q foo %q%q %s %", "hello", "world is", "can't");
+  GString *quoted = g_string_new("");
+  owl_string_appendf_quoted(quoted, "%q foo %q%q %s %", "hello", "world is", "can't");
   FAIL_UNLESS("owl_string_appendf",
+              !strcmp(g_string_free(g, false),
+                      "hello foo 'world is'\"can't\" %s %"));
+              !strcmp(quoted->str, "hello foo 'world is'\"can't\" %s %"));
+  g_string_free(quoted, true);
+  CHECK_STR_AND_FREE("baseclass barnowl",
+                     "barnowl", owl_util_baseclass("barnowl"));
+  CHECK_STR_AND_FREE("baseclass unbarnowl",
+                     "barnowl", owl_util_baseclass("unbarnowl"));
+  CHECK_STR_AND_FREE("baseclass unununbarnowl.d.d",
+                     "barnowl", owl_util_baseclass("unununbarnowl.d.d"));
+  CHECK_STR_AND_FREE("baseclass ununun.d.d",
+                     "", owl_util_baseclass("ununun.d.d"));
+  CHECK_STR_AND_FREE("baseclass d.d.d.d",
+                     "d", owl_util_baseclass("d.d.d.d"));
+  CHECK_STR_AND_FREE("baseclass n.d.d.d",
+                     "n", owl_util_baseclass("n.d.d.d"));
+  CHECK_STR_AND_FREE("baseclass ununun.",
+                     ".", owl_util_baseclass("ununun."));
+  CHECK_STR_AND_FREE("baseclass unununu",
+                     "u", owl_util_baseclass("unununu"));
+  CHECK_STR_AND_FREE("makepath foo/bar",
+                     "foo/bar", owl_util_makepath("foo/bar"));
+  CHECK_STR_AND_FREE("makepath //foo///bar",
+                     "/foo/bar", owl_util_makepath("//foo///bar"));
+  CHECK_STR_AND_FREE("makepath foo/~//bar/",
+                     "foo/~/bar/", owl_util_makepath("foo/~//bar/"));
+  CHECK_STR_AND_FREE("makepath ~thisuserhadreallybetternotexist/foobar/",
+                     "~thisuserhadreallybetternotexist/foobar/",
+                     owl_util_makepath("~thisuserhadreallybetternotexist/foobar/"));
+  home = g_strdup(owl_global_get_homedir(&g));
+  CHECK_STR_AND_FREE("makepath ~",
+                     home, owl_util_makepath("~"));
+  path = g_build_filename(home, "foo/bar/baz", NULL);
+  CHECK_STR_AND_FREE("makepath ~///foo/bar//baz",
+                     path, owl_util_makepath("~///foo/bar//baz"));
+  g_free(path);
+  g_free(home);
+  home = owl_util_homedir_for_user("root");
+  if (home == NULL) {
+    /* Just make some noise so we notice. */
+    home = g_strdup("<WHAT>");
+    fprintf(stderr, "owl_util_homedir_for_user failed");
+  }
+  CHECK_STR_AND_FREE("makepath ~root",
+                     home, owl_util_makepath("~root"));
+  path = g_build_filename(home, "foo/bar/baz", NULL);
+  CHECK_STR_AND_FREE("makepath ~root///foo/bar//baz",
+                     path, owl_util_makepath("~root///foo/bar//baz"));
+  g_free(path);
+  g_free(home);
   /* if (numfailed) printf("*** WARNING: failures encountered with owl_util\n"); */
 …
 int owl_dict_regtest(void) {
   owl_dict d;
   owl_list l;
+  GPtrArray *l;
   int numfailed=0;
+  char *av="aval", *bv="bval", *cv="cval", *dv="dval";
+  char *av = g_strdup("aval"), *bv = g_strdup("bval"), *cv = g_strdup("cval"),
+    *dv = g_strdup("dval");
   printf("# BEGIN testing owl_dict\n");
 …
   FAIL_UNLESS("get_size", 3==owl_dict_get_size(&d));
+  owl_list_create(&l);
+  owl_dict_get_keys(&d, &l);
+  FAIL_UNLESS("get_keys result size", 3==owl_list_get_size(&l));
+  l = owl_dict_get_keys(&d);
+  FAIL_UNLESS("get_keys result size", 3 == l->len);
   /* these assume the returned keys are sorted */
   FAIL_UNLESS("get_keys result val",0==strcmp("a",owl_list_get_element(&l,0)));
   FAIL_UNLESS("get_keys result val",0==strcmp("b",owl_list_get_element(&l,1)));
   FAIL_UNLESS("get_keys result val",0==strcmp("c",owl_list_get_element(&l,2)));
   owl_list_cleanup(&l, g_free);
+  FAIL_UNLESS("get_keys result val", 0 == strcmp("a", l->pdata[0]));
+  FAIL_UNLESS("get_keys result val", 0 == strcmp("b", l->pdata[1]));
+  FAIL_UNLESS("get_keys result val", 0 == strcmp("c", l->pdata[2]));
+  owl_ptr_array_free(l, g_free);
   owl_dict_cleanup(&d, NULL);
+  g_free(av);
+  g_free(bv);
+  g_free(cv);
+  g_free(dv);
   /*  if (numfailed) printf("*** WARNING: failures encountered with owl_dict\n"); */
 …
 int owl_variable_regtest(void) {
   owl_vardict vd;
+  owl_variable *var;
   int numfailed=0;
   char *value;
-  const void *v;
   printf("# BEGIN testing owl_variable\n");
+  FAIL_UNLESS("setup", 0==owl_variable_dict_setup(&vd));
+  FAIL_UNLESS("get bool", 0==owl_variable_get_bool(&vd,"rxping"));
+  FAIL_UNLESS("get bool (no such)", -1==owl_variable_get_bool(&vd,"mumble"));
+  owl_variable_dict_setup(&vd);
+  FAIL_UNLESS("get bool var", NULL != (var = owl_variable_get_var(&vd, "rxping")));
+  FAIL_UNLESS("get bool", 0 == owl_variable_get_bool(var));
+  FAIL_UNLESS("get bool (no such)", NULL == owl_variable_get_var(&vd, "mumble"));
   FAIL_UNLESS("get bool as string",
               !strcmp((value = owl_variable_get_tostring(&vd,"rxping")), "off"));
+              !strcmp((value = owl_variable_get_tostring(var)), "off"));
   g_free(value);
+  FAIL_UNLESS("set bool 1", 0==owl_variable_set_bool_on(&vd,"rxping"));
+  FAIL_UNLESS("get bool 2", 1==owl_variable_get_bool(&vd,"rxping"));
+  FAIL_UNLESS("set bool 3", 0==owl_variable_set_fromstring(&vd,"rxping","off",0,0));
+  FAIL_UNLESS("get bool 4", 0==owl_variable_get_bool(&vd,"rxping"));
+  FAIL_UNLESS("set bool 5", -1==owl_variable_set_fromstring(&vd,"rxping","xxx",0,0));
+  FAIL_UNLESS("get bool 6", 0==owl_variable_get_bool(&vd,"rxping"));
+  FAIL_UNLESS("get string", 0==strcmp("~/zlog/people", owl_variable_get_string(&vd,"logpath")));
+  FAIL_UNLESS("set string 7", 0==owl_variable_set_string(&vd,"logpath","whee"));
+  FAIL_UNLESS("get string", 0==strcmp("whee", owl_variable_get_string(&vd,"logpath")));
+  FAIL_UNLESS("get int", 8==owl_variable_get_int(&vd,"typewinsize"));
+  FAIL_UNLESS("get int (no such)", -1==owl_variable_get_int(&vd,"mmble"));
+  FAIL_UNLESS("set bool 1", 0 == owl_variable_set_bool_on(var));
+  FAIL_UNLESS("get bool 2", 1 == owl_variable_get_bool(var));
+  FAIL_UNLESS("set bool 3", 0 == owl_variable_set_fromstring(var, "off", 0));
+  FAIL_UNLESS("get bool 4", 0 == owl_variable_get_bool(var));
+  FAIL_UNLESS("set bool 5", -1 == owl_variable_set_fromstring(var, "xxx", 0));
+  FAIL_UNLESS("get bool 6", 0 == owl_variable_get_bool(var));
+  FAIL_UNLESS("get string var", NULL != (var = owl_variable_get_var(&vd, "logpath")));
+  FAIL_UNLESS("get string", 0 == strcmp("~/zlog/people", owl_variable_get_string(var)));
+  FAIL_UNLESS("set string 7", 0 == owl_variable_set_string(var, "whee"));
+  FAIL_UNLESS("get string", !strcmp("whee", owl_variable_get_string(var)));
+  FAIL_UNLESS("get int var", NULL != (var = owl_variable_get_var(&vd, "typewinsize")));
+  FAIL_UNLESS("get int", 8 == owl_variable_get_int(var));
+  FAIL_UNLESS("get int (no such)", NULL == owl_variable_get_var(&vd, "mumble"));
   FAIL_UNLESS("get int as string",
               !strcmp((value = owl_variable_get_tostring(&vd,"typewinsize")), "8"));
+              !strcmp((value = owl_variable_get_tostring(var)), "8"));
   g_free(value);
+  FAIL_UNLESS("set int 1", 0==owl_variable_set_int(&vd,"typewinsize",12));
+  FAIL_UNLESS("get int 2", 12==owl_variable_get_int(&vd,"typewinsize"));
+  FAIL_UNLESS("set int 1b", -1==owl_variable_set_int(&vd,"typewinsize",-3));
+  FAIL_UNLESS("get int 2b", 12==owl_variable_get_int(&vd,"typewinsize"));
+  FAIL_UNLESS("set int 3", 0==owl_variable_set_fromstring(&vd,"typewinsize","9",0,0));
+  FAIL_UNLESS("get int 4", 9==owl_variable_get_int(&vd,"typewinsize"));
+  FAIL_UNLESS("set int 5", -1==owl_variable_set_fromstring(&vd,"typewinsize","xxx",0,0));
+  FAIL_UNLESS("set int 6", -1==owl_variable_set_fromstring(&vd,"typewinsize","",0,0));
+  FAIL_UNLESS("get int 7", 9==owl_variable_get_int(&vd,"typewinsize"));
+  owl_variable_dict_newvar_string(&vd, "stringvar", "", "", "testval");
+  FAIL_UNLESS("get new string var", NULL != (v = owl_variable_get(&vd, "stringvar", OWL_VARIABLE_STRING)));
+  FAIL_UNLESS("get new string val", !strcmp("testval", owl_variable_get_string(&vd, "stringvar")));
+  owl_variable_set_string(&vd, "stringvar", "new val");
+  FAIL_UNLESS("update string val", !strcmp("new val", owl_variable_get_string(&vd, "stringvar")));
+  owl_variable_dict_newvar_int(&vd, "intvar", "", "", 47);
+  FAIL_UNLESS("get new int var", NULL != (v = owl_variable_get(&vd, "intvar", OWL_VARIABLE_INT)));
+  FAIL_UNLESS("get new int val", 47 == owl_variable_get_int(&vd, "intvar"));
+  owl_variable_set_int(&vd, "intvar", 17);
+  FAIL_UNLESS("update bool val", 17 == owl_variable_get_int(&vd, "intvar"));
+  owl_variable_dict_newvar_bool(&vd, "boolvar", "", "", 1);
+  FAIL_UNLESS("get new bool var", NULL != (v = owl_variable_get(&vd, "boolvar", OWL_VARIABLE_BOOL)));
+  FAIL_UNLESS("get new bool val", owl_variable_get_bool(&vd, "boolvar"));
+  owl_variable_set_bool_off(&vd, "boolvar");
+  FAIL_UNLESS("update string val", !owl_variable_get_bool(&vd, "boolvar"));
+  FAIL_UNLESS("set int 1", 0 == owl_variable_set_int(var, 12));
+  FAIL_UNLESS("get int 2", 12 == owl_variable_get_int(var));
+  FAIL_UNLESS("set int 1b", -1 == owl_variable_set_int(var, -3));
+  FAIL_UNLESS("get int 2b", 12 == owl_variable_get_int(var));
+  FAIL_UNLESS("set int 3", 0 == owl_variable_set_fromstring(var, "9", 0));
+  FAIL_UNLESS("get int 4", 9 == owl_variable_get_int(var));
+  FAIL_UNLESS("set int 5", -1 == owl_variable_set_fromstring(var, "xxx", 0));
+  FAIL_UNLESS("set int 6", -1 == owl_variable_set_fromstring(var, "", 0));
+  FAIL_UNLESS("get int 7", 9 == owl_variable_get_int(var));
+  FAIL_UNLESS("get enum var", NULL != (var = owl_variable_get_var(&vd, "scrollmode")));
+  FAIL_UNLESS("get enum", OWL_SCROLLMODE_NORMAL == owl_variable_get_int(var));
+  FAIL_UNLESS("get enum as string",
+              !strcmp((value = owl_variable_get_tostring(var)), "normal"));
+  g_free(value);
+  FAIL_UNLESS("set enum 1", 0 == owl_variable_set_int(var, OWL_SCROLLMODE_TOP));
+  FAIL_UNLESS("get enum 1", OWL_SCROLLMODE_TOP == owl_variable_get_int(var));
+  FAIL_UNLESS("set enum 2a", -1 == owl_variable_set_int(var, -1));
+  FAIL_UNLESS("set enum 2b", -1 == owl_variable_set_int(var, OWL_SCROLLMODE_PAGEDCENTER + 1));
+  FAIL_UNLESS("get enum 2", OWL_SCROLLMODE_TOP == owl_variable_get_int(var));
+  FAIL_UNLESS("set enum 3", 0 == owl_variable_set_fromstring(var, "center", 0));
+  FAIL_UNLESS("get enum 4", OWL_SCROLLMODE_CENTER == owl_variable_get_int(var));
+  FAIL_UNLESS("set enum 5", -1 == owl_variable_set_fromstring(var, "bogus", 0));
+  FAIL_UNLESS("set enum 6", -1 == owl_variable_set_fromstring(var, "", 0));
+  FAIL_UNLESS("get enum 7", OWL_SCROLLMODE_CENTER == owl_variable_get_int(var));
+  owl_variable_dict_newvar_string(&vd, "stringvar", "testval", "", "");
+  FAIL_UNLESS("get new string var", NULL != (var = owl_variable_get_var(&vd, "stringvar")));
+  FAIL_UNLESS("get new string val", !strcmp("testval", owl_variable_get_string(var)));
+  owl_variable_set_string(var, "new val");
+  FAIL_UNLESS("update string val", !strcmp("new val", owl_variable_get_string(var)));
+  owl_variable_dict_newvar_int(&vd, "intvar", 47, "", "");
+  FAIL_UNLESS("get new int var", NULL != (var = owl_variable_get_var(&vd, "intvar")));
+  FAIL_UNLESS("get new int val", 47 == owl_variable_get_int(var));
+  owl_variable_set_int(var, 17);
+  FAIL_UNLESS("update int val", 17 == owl_variable_get_int(var));
+  owl_variable_dict_newvar_bool(&vd, "boolvar", true, "", "");
+  FAIL_UNLESS("get new bool var", NULL != (var = owl_variable_get_var(&vd, "boolvar")));
+  FAIL_UNLESS("get new bool val", owl_variable_get_bool(var));
+  owl_variable_set_bool_off(var);
+  FAIL_UNLESS("update bool val", !owl_variable_get_bool(var));
+  owl_variable_dict_newvar_string(&vd, "nullstringvar", NULL, "", "");
+  FAIL_UNLESS("get new string (NULL) var", NULL != (var = owl_variable_get_var(&vd, "nullstringvar")));
+  FAIL_UNLESS("get string (NULL)", NULL == (value = owl_variable_get_tostring(var)));
+  g_free(value);
+  var = owl_variable_get_var(&vd, "zsigproc");
+  FAIL_UNLESS("get string (NULL) 2", NULL == (value = owl_variable_get_tostring(var)));
+  g_free(value);
+  owl_variable_dict_newvar_enum(&vd, "enumvar", 0, "", "", "a,b,c,d");
+  FAIL_UNLESS("get new enum var", NULL != (var = owl_variable_get_var(&vd, "enumvar")));
+  FAIL_UNLESS("get new enum val", 0 == owl_variable_get_int(var));
+  owl_variable_set_fromstring(var, "c", 0);
+  FAIL_UNLESS("update enum val", 2 == owl_variable_get_int(var));
   owl_variable_dict_cleanup(&vd);
 …
   FAIL_UNLESS("DAG", (f5 = owl_filter_new_fromstring("dag", "filter f1 or filter f1")) != NULL);
   owl_filter_delete(f5);
+  owl_message_cleanup(&m);
   return 0;
 …
   return numfailed;
+}
+int owl_history_regtest(void)
+{
+  int numfailed = 0;
+  int i;
+  owl_history h;
+  printf("# BEGIN testing owl_history\n");
+  owl_history_init(&h);
+  /* Operations on empty history. */
+  FAIL_UNLESS("prev NULL", owl_history_get_prev(&h) == NULL);
+  FAIL_UNLESS("next NULL", owl_history_get_next(&h) == NULL);
+  FAIL_UNLESS("untouched", !owl_history_is_touched(&h));
+  /* Insert a few records. */
+  owl_history_store(&h, "a", false);
+  owl_history_store(&h, "b", false);
+  owl_history_store(&h, "c", false);
+  owl_history_store(&h, "d", true);
+  /* Walk up and down the history a bit. */
+  FAIL_UNLESS("untouched", !owl_history_is_touched(&h));
+  FAIL_UNLESS("prev c", strcmp(owl_history_get_prev(&h), "c") == 0);
+  FAIL_UNLESS("touched", owl_history_is_touched(&h));
+  FAIL_UNLESS("next d", strcmp(owl_history_get_next(&h), "d") == 0);
+  FAIL_UNLESS("untouched", !owl_history_is_touched(&h));
+  FAIL_UNLESS("next NULL", owl_history_get_next(&h) == NULL);
+  FAIL_UNLESS("prev c", strcmp(owl_history_get_prev(&h), "c") == 0);
+  FAIL_UNLESS("prev b", strcmp(owl_history_get_prev(&h), "b") == 0);
+  FAIL_UNLESS("prev a", strcmp(owl_history_get_prev(&h), "a") == 0);
+  FAIL_UNLESS("prev NULL", owl_history_get_prev(&h) == NULL);
+  /* Now insert something. It should reset and blow away 'd'. */
+  owl_history_store(&h, "e", false);
+  FAIL_UNLESS("untouched", !owl_history_is_touched(&h));
+  FAIL_UNLESS("next NULL", owl_history_get_next(&h) == NULL);
+  FAIL_UNLESS("prev c", strcmp(owl_history_get_prev(&h), "c") == 0);
+  FAIL_UNLESS("touched", owl_history_is_touched(&h));
+  FAIL_UNLESS("next e", strcmp(owl_history_get_next(&h), "e") == 0);
+  FAIL_UNLESS("untouched", !owl_history_is_touched(&h));
+  /* Lines get de-duplicated on insert. */
+  owl_history_store(&h, "e", false);
+  owl_history_store(&h, "e", false);
+  owl_history_store(&h, "e", false);
+  FAIL_UNLESS("prev c", strcmp(owl_history_get_prev(&h), "c") == 0);
+  FAIL_UNLESS("next e", strcmp(owl_history_get_next(&h), "e") == 0);
+  /* But a partial is not deduplicated, as it'll go away soon. */
+  owl_history_store(&h, "e", true);
+  FAIL_UNLESS("prev e", strcmp(owl_history_get_prev(&h), "e") == 0);
+  FAIL_UNLESS("prev c", strcmp(owl_history_get_prev(&h), "c") == 0);
+  FAIL_UNLESS("next e", strcmp(owl_history_get_next(&h), "e") == 0);
+  FAIL_UNLESS("next e", strcmp(owl_history_get_next(&h), "e") == 0);
+  /* Reset moves to the front... */
+  owl_history_store(&h, "f", true);
+  FAIL_UNLESS("prev e", strcmp(owl_history_get_prev(&h), "e") == 0);
+  FAIL_UNLESS("prev c", strcmp(owl_history_get_prev(&h), "c") == 0);
+  owl_history_reset(&h);
+  FAIL_UNLESS("untouched", !owl_history_is_touched(&h));
+  /* ...and destroys any pending partial entry... */
+  FAIL_UNLESS("prev c", strcmp(owl_history_get_prev(&h), "c") == 0);
+  FAIL_UNLESS("prev b", strcmp(owl_history_get_prev(&h), "b") == 0);
+  /* ...but not non-partial ones. */
+  owl_history_reset(&h);
+  FAIL_UNLESS("untouched", !owl_history_is_touched(&h));
+  /* Finally, check we are bounded by OWL_HISTORYSIZE. */
+  for (i = 0; i < OWL_HISTORYSIZE; i++) {
+    char *string = g_strdup_printf("mango%d", i);
+    owl_history_store(&h, string, false);
+    g_free(string);
+  }
+  /* The OWL_HISTORYSIZE'th prev gets NULL. */
+  for (i = OWL_HISTORYSIZE - 2; i >= 0; i--) {
+    char *string = g_strdup_printf("mango%d", i);
+    FAIL_UNLESS("prev mango_N", strcmp(owl_history_get_prev(&h), string) == 0);
+    g_free(string);
+  }
+  FAIL_UNLESS("prev NULL", owl_history_get_prev(&h) == NULL);
+  owl_history_cleanup(&h);
+  printf("# END testing owl_history (%d failures)\n", numfailed);
+  return numfailed;
+}
+int call_filter_regtest(void)
+{
+  int numfailed = 0;
+  int ret;
+  char *out = NULL;
+  int status;
+  printf("# BEGIN testing call_filter\n");
+  const char *cat_argv[] = { "cat", NULL };
+  ret = call_filter(cat_argv, "Mangos!", &out, &status);
+  FAIL_UNLESS("call_filter cat", (ret == 0 &&
+                                  status == 0 &&
+                                  strcmp(out, "Mangos!") == 0));
+  g_free(out); out = NULL;
+  ret = call_filter(cat_argv, "", &out, &status);
+  FAIL_UNLESS("call_filter cat", (ret == 0 &&
+                                  status == 0 &&
+                                  strcmp(out, "") == 0));
+  g_free(out); out = NULL;
+  ret = call_filter(cat_argv, NULL, &out, &status);
+  FAIL_UNLESS("call_filter cat", (ret == 0 &&
+                                  status == 0 &&
+                                  strcmp(out, "") == 0));
+  g_free(out); out = NULL;
+  printf("# END testing call_filter (%d failures)\n", numfailed);
+  return numfailed;
+}

text.c

-                      r7865479
+                      rf271129
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <ctype.h>
 #include "owl.h"
 /* Returns a copy of 'in' with each line indented 'n'
  * characters. Result must be freed with g_free. */
 char *owl_text_indent(const char *in, int n)
+CALLER_OWN char *owl_text_indent(const char *in, int n, bool indent_first_line)
+{
   const char *ptr1, *ptr2, *last;
   GString *out = g_string_new("");
   int i;
+  bool indent_this_line = indent_first_line;
   last=in+strlen(in)-1;
   ptr1=in;
   while (ptr1<=last) {
+    for (i=0; i<n; i++) {
+      g_string_append_c(out, ' ');
+    }
+    if (indent_this_line) {
+      for (i = 0; i < n; i++) {
+        g_string_append_c(out, ' ');
+      }
+    }
+    indent_this_line = true;
     ptr2=strchr(ptr1, '\n');
     if (!ptr2) {
 …
 /* caller must free the return */
 char *owl_text_htmlstrip(const char *in)
+CALLER_OWN char *owl_text_htmlstrip(const char *in)
+{
   const char *ptr1, *end, *ptr2, *ptr3;
 …
 /* Caller must free return */
 char *owl_text_expand_tabs(const char *in)
+CALLER_OWN char *owl_text_expand_tabs(const char *in)
+{
   int len = 0;
 …
 /* caller must free the return */
 char *owl_text_wordwrap(const char *in, int col)
+CALLER_OWN char *owl_text_wordwrap(const char *in, int col)
+{
   char *out;
 …
  * Caller must free returned string.
  */
 char *owl_text_substitute(const char *in, const char *from, const char *to)
+CALLER_OWN char *owl_text_substitute(const char *in, const char *from, const char *to)
+{
   char **split = g_strsplit(in, from, 0), *out;
 …
  * On success returns the string, on error returns NULL.
  */
 char *owl_text_quote(const char *in, const char *toquote, const char *quotestr)
+CALLER_OWN char *owl_text_quote(const char *in, const char *toquote, const char *quotestr)
+{
   int i, x, r, place, escape;

util.c

-                      r83a4af3
+                      r7b89e8c
 #include "owl.h"
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <ctype.h>
 #include <pwd.h>
 #include <sys/stat.h>
-#include <sys/types.h>
-#include <assert.h>
 #include <stdarg.h>
-#include <glib.h>
 #include <glib/gstdio.h>
 #include <glib-object.h>
 …
+}
+CALLER_OWN char *owl_util_homedir_for_user(const char *name)
+{
+  int err;
+  struct passwd pw_buf;
+  struct passwd *pw;
+  char *pw_strbuf, *ret;
+  long pw_strbuf_len = sysconf(_SC_GETPW_R_SIZE_MAX);
+  if (pw_strbuf_len < 0) {
+    /* If we really hate ourselves, we can be fancy and loop until we stop
+     * getting ERANGE. For now just pick a random number. */
+    owl_function_error("owl_util_homedir_for_user: Could not get _SC_GETPW_R_SIZE_MAX");
+    pw_strbuf_len = 16384;
+  }
+  pw_strbuf = g_new0(char, pw_strbuf_len);
+  err = getpwnam_r(name, &pw_buf, pw_strbuf, pw_strbuf_len, &pw);
+  if (err) {
+    owl_function_error("getpwuid_r: %s", strerror(err));
+    /* Fall through; pw will be NULL. */
+  }
+  ret = pw ? g_strdup(pw->pw_dir) : NULL;
+  g_free(pw_strbuf);
+  return ret;
+}
 /* Return a "nice" version of the path.  Tilde expansion is done, and
  * duplicate slashes are removed.  Caller must free the return.
  */
 char *owl_util_makepath(const char *in)
+{
   int i, j, x;
   char *out, user[MAXPATHLEN];
   struct passwd *pw;
   out=g_new(char, MAXPATHLEN+1);
   out[0]='\0';
   j=strlen(in);
   x=0;
+  for (i=0; i<j; i++) {
     if (in[i]=='~') {
       if ( (i==(j-1)) ||          /* last character */
+           (in[i+1]=='/') ) {     /* ~/ */
+        /* use my homedir */
+        pw=getpwuid(getuid());
+        if (!pw) {
+          out[x]=in[i];
+        } else {
           out[x]='\0';
           strcat(out, pw->pw_dir);
+          x+=strlen(pw->pw_dir);
+        }
+CALLER_OWN char *owl_util_makepath(const char *in)
+{
+  char *out;
+  int i, j;
+  if (in[0] == '~') {
+    /* Attempt tilde-expansion of the first component. Get the
+       tilde-prefix, which goes up to the next slash. */
+    const char *end = strchr(in + 1, '/');
+    if (end == NULL)
+      end = in + strlen(in);
+    /* Patch together a new path. Replace the ~ and tilde-prefix with
+       the homedir, if available. */
+    if (end == in + 1) {
+      /* My home directory. Use the one in owl_global for consistency with
+       * owl_zephyr_dotfile. */
+      out = g_strconcat(owl_global_get_homedir(&g), end, NULL);
+    } else {
+      /* Someone else's home directory. */
+      char *user = g_strndup(in + 1, end - (in + 1));
+      char *home = owl_util_homedir_for_user(user);
+      if (home) {
+        out = g_strconcat(home, end, NULL);
       } else {
+        /* another user homedir */
+        int a, b;
+        b=0;
+        for (a=i+1; i<j; a++) {
+          if (in[a]==' ' || in[a]=='/') {
+            break;
+          } else {
+            user[b]=in[a];
+            i++;
+            b++;
+          }
+        }
+        user[b]='\0';
+        pw=getpwnam(user);
+        if (!pw) {
+          out[x]=in[i];
+        } else {
+          out[x]='\0';
+          strcat(out, pw->pw_dir);
+          x+=strlen(pw->pw_dir);
+        }
+        out = g_strdup(in);
+      }
+    } else if (in[i]=='/') {
+      /* check for a double / */
+      if (i<(j-1) && (in[i+1]=='/')) {
+        /* do nothing */
+      } else {
+        out[x]=in[i];
+        x++;
+      }
+    } else {
+      out[x]=in[i];
+      x++;
+    }
+  }
+  out[x]='\0';
+  return(out);
+      g_free(home);
+      g_free(user);
+    }
+  } else {
+    out = g_strdup(in);
+  }
+  /* And a quick pass to remove duplicate slashes. */
+  for (i = j = 0; out[i] != '\0'; i++) {
+    if (out[i] != '/' || i == 0 || out[i-1] != '/')
+      out[j++] = out[i];
+  }
+  out[j] = '\0';
+  return out;
+}
+void owl_ptr_array_free(GPtrArray *array, GDestroyNotify element_free_func)
+{
+  /* TODO: when we move to requiring glib 2.22+, use
+   * g_ptr_array_new_with_free_func instead. */
+  if (element_free_func)
+    g_ptr_array_foreach(array, (GFunc)element_free_func, NULL);
+  g_ptr_array_free(array, true);
+}
 …
    to -1, argv will be NULL and the caller does not need to free anything. The
    returned vector is NULL-terminated. */
 char **owl_parseline(const char *line, int *argc)
+CALLER_OWN char **owl_parseline(const char *line, int *argc)
+{
   GPtrArray *argv;
 …
   /* check for unbalanced quotes */
   if (quote!='\0') {
+    /* TODO: when we move to requiring glib 2.22+, use
+     * g_ptr_array_new_with_free_func. */
+    g_ptr_array_foreach(argv, (GFunc)g_free, NULL);
+    g_ptr_array_free(argv, true);
+    owl_ptr_array_free(argv, g_free);
     if (argc) *argc = -1;
     return(NULL);
 …
 /*
  * Appends 'tmpl' to 'buf', replacing any instances of '%q' with arguments from
  * the varargs provided, quoting them to be safe for placing in a barnowl
+ * the varargs provided, quoting them to be safe for placing in a BarnOwl
  * command line.
  */
 …
+}
 char *owl_string_build_quoted(const char *tmpl, ...)
+CALLER_OWN char *owl_string_build_quoted(const char *tmpl, ...)
+{
   GString *buf = g_string_new("");
 …
 /* Returns a quoted version of arg suitable for placing in a
  * command-line. Result should be freed with g_free. */
 char *owl_arg_quote(const char *arg)
+{
   GString *buf = g_string_new("");;
+CALLER_OWN char *owl_arg_quote(const char *arg)
+{
+  GString *buf = g_string_new("");
   owl_string_append_quoted_arg(buf, arg);
   return g_string_free(buf, false);
+}
+/* Returns a quoted version of argv. owl_parseline on the result should give
+ * back the input. */
+CALLER_OWN char *owl_argv_quote(int argc, const char *const *argv)
+{
+  int i;
+  GString *buf = g_string_new("");
+  for (i = 0; i < argc; i++) {
+    if (i > 0)
+      g_string_append_c(buf, ' ');
+    owl_string_append_quoted_arg(buf, argv[i]);
+  }
+  return g_string_free(buf, false);
+}
 /* caller must free the return */
 char *owl_util_minutes_to_timestr(int in)
+CALLER_OWN char *owl_util_format_minutes(int in)
+{
   int days, hours;
 …
+  }
   return(out);
+}
+CALLER_OWN char *owl_util_format_time(const struct tm *time)
+{
+  /* 32 chosen for first attempt because timestr will end up being
+   * something like "Www Mmm dd hh:mm:ss AM yyyy UTC\0" */
+  size_t timestr_size = 16;
+  char *timestr = NULL;
+  do {
+    timestr_size *= 2;
+    timestr = g_renew(char, timestr, timestr_size);
+  } while (strftime(timestr, timestr_size, "%c", time) == 0);
+  return timestr;
+}
 …
 /* Get the default tty name.  Caller must free the return */
 char *owl_util_get_default_tty(void)
+CALLER_OWN char *owl_util_get_default_tty(void)
+{
   const char *tmp;
 …
  * return.
  */
 char *owl_util_stripnewlines(const char *in)
+CALLER_OWN char *owl_util_stripnewlines(const char *in)
+{
 …
  * Error conditions are the same as g_file_read_link.
  */
 gchar *owl_util_recursive_resolve_link(const char *filename)
+CALLER_OWN gchar *owl_util_recursive_resolve_link(const char *filename)
+{
   gchar *last_path = g_strdup(filename);
 …
     if (!g_path_is_absolute(link_path)) {
       char *last_dir = g_path_get_dirname(last_path);
+      char *tmp = g_build_path(G_DIR_SEPARATOR_S,
+                               last_dir,
+                               link_path,
+                               NULL);
+      char *tmp = g_build_filename(last_dir, link_path, NULL);
       g_free(last_dir);
       g_free(link_path);
 …
    The caller is responsible for freeing the allocated string.
 */
 char * owl_util_baseclass(const char * class)
+CALLER_OWN char *owl_util_baseclass(const char *class)
+{
   char *start, *end;
 …
 /* Strips format characters from a valid utf-8 string. Returns the
    empty string if 'in' does not validate. */
 char * owl_strip_format_chars(const char *in)
+   empty string if 'in' does not validate.  Caller must free the return. */
+CALLER_OWN char *owl_strip_format_chars(const char *in)
+{
   char *r;
 …
  * out characters in Unicode Plane 16, as we use that plane internally
  * for formatting.
+ */
+char * owl_validate_or_convert(const char *in)
+ * Caller must free the return.
+ */
+CALLER_OWN char *owl_validate_or_convert(const char *in)
+{
   if (g_utf8_validate(in, -1, NULL)) {
 …
  * Validate 'in' as UTF-8, and either return a copy of it, or an empty
  * string if it is invalid utf-8.
+ */
+char * owl_validate_utf8(const char *in)
+ * Caller must free the return.
+ */
+CALLER_OWN char *owl_validate_utf8(const char *in)
+{
   char *out;
 …
+}
+char *owl_escape_highbit(const char *str)
+/* caller must free the return */
+CALLER_OWN char *owl_escape_highbit(const char *str)
+{
   GString *out = g_string_new("");
 …
 /* Read the rest of the input available in fp into a string. */
 char *owl_slurp(FILE *fp)
+CALLER_OWN char *owl_slurp(FILE *fp)
+{
   char *buf = NULL;

variable.c

-                      r4c7c21f
+                      r9d4dfdc
+#include "owl.h"
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <ctype.h>
+#include "owl.h"
+#define OWLVAR_BOOL(name,default,summary,description) \
+        { name, OWL_VARIABLE_BOOL, NULL, default, "on,off", summary,description, NULL, \
+        NULL, NULL, NULL, NULL, NULL, NULL }
+#define OWLVAR_BOOL_FULL(name,default,summary,description,validate,set,get) \
+        { name, OWL_VARIABLE_BOOL, NULL, default, "on,off", summary,description, NULL, \
+        validate, set, NULL, get, NULL, NULL }
+#define OWLVAR_INT(name,default,summary,description) \
+        { name, OWL_VARIABLE_INT, NULL, default, "<int>", summary,description, NULL, \
+        NULL, NULL, NULL, NULL, NULL, NULL }
+#include "gmarshal_funcs.h"
+/* TODO(davidben): When we can require 2.30 and up, remove this. */
+#ifndef G_VALUE_INIT
+#define G_VALUE_INIT { 0, { { 0 } } }
+#endif
+typedef const char *(*get_string_t)(const owl_variable *);
+typedef int (*get_int_t)(const owl_variable *);
+typedef bool (*get_bool_t)(const owl_variable *);
+typedef int (*set_string_t)(owl_variable *, const char *);
+typedef int (*set_int_t)(owl_variable *, int);
+typedef int (*set_bool_t)(owl_variable *, bool);
+typedef int (*validate_string_t)(const owl_variable *, const char *);
+typedef int (*validate_int_t)(const owl_variable *, int);
+typedef int (*validate_bool_t)(const owl_variable *, bool);
+static void owl_variable_dict_newvar_bool_full(owl_vardict *vd,
+                                               const char *name,
+                                               bool default_val,
+                                               const char *summary,
+                                               const char *description,
+                                               validate_bool_t validate_fn,
+                                               set_bool_t set_fn,
+                                               get_bool_t get_fn);
+static void owl_variable_dict_newvar_string_full(owl_vardict *vd,
+                                                 const char *name,
+                                                 const char *default_val,
+                                                 const char *summary,
+                                                 const char *description,
+                                                 const char *validsettings,
+                                                 validate_string_t validate_fn,
+                                                 set_string_t set_fn,
+                                                 get_string_t get_fn);
+static void owl_variable_dict_newvar_int_full(owl_vardict *vd,
+                                              const char *name,
+                                              int default_val,
+                                              const char *summary,
+                                              const char *description,
+                                              const char *validsettings,
+                                              validate_int_t validate_fn,
+                                              set_int_t set_fn,
+                                              get_int_t get_fn);
+static void owl_variable_dict_newvar_enum_full(owl_vardict *vd,
+                                               const char *name,
+                                               int default_val,
+                                               const char *summary,
+                                               const char *description,
+                                               const char *validsettings,
+                                               validate_int_t validate_fn,
+                                               set_int_t set_fn,
+                                               get_int_t get_fn);
+#define OWLVAR_BOOL(name, default, summary, description) \
+        owl_variable_dict_newvar_bool(vd, name, default, summary, description)
+#define OWLVAR_BOOL_FULL(name, default, summary, description, validate, set, get) \
+        owl_variable_dict_newvar_bool_full(vd, name, default, summary, description, \
+                                           validate, set, get)
+#define OWLVAR_INT(name, default, summary, description) \
+        owl_variable_dict_newvar_int(vd, name, default, summary, description)
 #define OWLVAR_INT_FULL(name,default,summary,description,validset,validate,set,get) \
+        { name, OWL_VARIABLE_INT, NULL, default, validset, summary,description, NULL, \
+        validate, set, NULL, get, NULL, NULL }
+#define OWLVAR_PATH(name,default,summary,description) \
+        { name, OWL_VARIABLE_STRING, default, 0, "<path>", summary,description,  NULL, \
+        NULL, NULL, NULL, NULL, NULL, NULL }
+#define OWLVAR_STRING(name,default,summary,description) \
+        { name, OWL_VARIABLE_STRING, default, 0, "<string>", summary,description, NULL, \
+        NULL, NULL, NULL, NULL, NULL, NULL }
+#define OWLVAR_STRING_FULL(name,default,validset,summary,description,validate,set,get) \
+        { name, OWL_VARIABLE_STRING, default, 0, validset, summary,description, NULL, \
+        validate, set, NULL, get, NULL, NULL }
+        owl_variable_dict_newvar_int_full(vd, name, default, summary, description, \
+                                          validset, validate, set, get)
+#define OWLVAR_PATH(name, default, summary, description) \
+        owl_variable_dict_newvar_path(vd, name, default, summary, description)
+#define OWLVAR_STRING(name, default, summary, description) \
+        owl_variable_dict_newvar_string(vd, name, default, summary, description)
+#define OWLVAR_STRING_FULL(name, default, validset, summary, description, validate, set, get) \
+        owl_variable_dict_newvar_string_full(vd, name, default, summary, description, \
+                                             validset, validate, set, get)
 /* enums are really integers, but where validset is a comma-separated
  * list of strings which can be specified.  The tokens, starting at 0,
  * correspond to the values that may be specified. */
+#define OWLVAR_ENUM(name,default,summary,description,validset) \
+        { name, OWL_VARIABLE_INT, NULL, default, validset, summary,description, NULL, \
+        owl_variable_enum_validate, \
+        NULL, owl_variable_enum_set_fromstring, \
+        NULL, owl_variable_enum_get_tostring, \
+        NULL }
+#define OWLVAR_ENUM(name, default, summary, description, validset) \
+        owl_variable_dict_newvar_enum(vd, name, default, summary, description, validset)
 #define OWLVAR_ENUM_FULL(name,default,summary,description,validset,validate, set, get) \
+        { name, OWL_VARIABLE_INT, NULL, default, validset, summary,description, NULL, \
+        validate, \
+        set, owl_variable_enum_set_fromstring, \
+        get, owl_variable_enum_get_tostring, \
+        NULL }
+static owl_variable variables_to_init[] = {
+        owl_variable_dict_newvar_enum_full(vd, name, default, summary, description, \
+                                           validset, validate, set, get)
+void owl_variable_add_defaults(owl_vardict *vd)
+{
   OWLVAR_STRING( "personalbell" /* %OwlVarStub */, "off",
                  "ring the terminal bell when personal messages are received",
                  "Can be set to 'on', 'off', or the name of a filter which\n"
                  "messages need to match in order to ring the bell"),
+                 "messages need to match in order to ring the bell");
   OWLVAR_BOOL( "bell" /* %OwlVarStub */, 1,
                "enable / disable the terminal bell", "" ),
+               "enable / disable the terminal bell", "" );
   OWLVAR_BOOL_FULL( "debug" /* %OwlVarStub */, OWL_DEBUG,
 …
                     "If set to 'on', debugging messages are logged to the\n"
                     "file specified by the debugfile variable.\n",
                     NULL, owl_variable_debug_set, NULL),
+                    NULL, owl_variable_debug_set, NULL);
   OWLVAR_BOOL( "startuplogin" /* %OwlVarStub */, 1,
                "send a login message when owl starts", "" ),
+               "send a login message when BarnOwl starts", "" );
   OWLVAR_BOOL( "shutdownlogout" /* %OwlVarStub */, 1,
                "send a logout message when owl exits", "" ),
+               "send a logout message when BarnOwl exits", "" );
   OWLVAR_BOOL( "rxping" /* %OwlVarStub */, 0,
                "display received pings", "" ),
+               "display received pings", "" );
   OWLVAR_BOOL( "txping" /* %OwlVarStub */, 1,
                "send pings", "" ),
+               "send pings", "" );
   OWLVAR_BOOL( "sepbar_disable" /* %OwlVarStub */, 0,
                "disable printing information in the separator bar", "" ),
+               "disable printing information in the separator bar", "" );
   OWLVAR_BOOL( "smartstrip" /* %OwlVarStub */, 1,
                "strip kerberos instance for reply", ""),
+               "strip kerberos instance for reply", "");
   OWLVAR_BOOL( "newlinestrip" /* %OwlVarStub */, 1,
                "strip leading and trailing newlines", ""),
+               "strip leading and trailing newlines", "");
   OWLVAR_BOOL( "displayoutgoing" /* %OwlVarStub */, 1,
                "display outgoing messages", "" ),
+               "display outgoing messages", "" );
   OWLVAR_BOOL( "loginsubs" /* %OwlVarStub */, 1,
                "load logins from .anyone on startup", "" ),
+               "load logins from .anyone on startup", "" );
   OWLVAR_BOOL( "logging" /* %OwlVarStub */, 0,
 …
                "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" ),
+               "directory is derived from the sender of the message.\n" );
   OWLVAR_BOOL( "classlogging" /* %OwlVarStub */, 0,
 …
                "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" ),
+               "the name of the class to which the message was sent.\n" );
   OWLVAR_ENUM( "loggingdirection" /* %OwlVarStub */, OWL_LOGGING_DIRECTION_BOTH,
 …
                "is selected both incoming and outgoing messages are\n"
                "logged.",
+               "both,in,out"),
+  OWLVAR_BOOL( "colorztext" /* %OwlVarStub */, 1,
+               "allow @color() in zephyrs to change color",
+               "Note that only messages received after this variable\n"
+               "is set will be affected." ),
+               "both,in,out");
+  OWLVAR_BOOL_FULL( "colorztext" /* %OwlVarStub */, 1,
+                    "allow @color() in zephyrs to change color",
+                    NULL, NULL, owl_variable_colorztext_set, NULL);
   OWLVAR_BOOL( "fancylines" /* %OwlVarStub */, 1,
 …
                "If turned off, dashes, pipes and pluses will be used\n"
                "to draw lines on the screen.  Useful when the terminal\n"
                "is causing problems" ),
+               "is causing problems" );
   OWLVAR_BOOL( "zcrypt" /* %OwlVarStub */, 1,
                "Do automatic zcrypt processing",
                "" ),
+               "" );
   OWLVAR_BOOL_FULL( "pseudologins" /* %OwlVarStub */, 0,
                     "Enable zephyr pseudo logins",
                     "When this is enabled, Owl will periodically check the zephyr\n"
+                    "When this is enabled, BarnOwl will periodically check the zephyr\n"
                     "location of users in your .anyone file.  If a user is present\n"
                     "but sent no login message, or a user is not present that sent no\n"
                     "logout message, a pseudo login or logout message will be created\n",
                     NULL, owl_variable_pseudologins_set, NULL),
+                    NULL, owl_variable_pseudologins_set, NULL);
   OWLVAR_BOOL( "ignorelogins" /* %OwlVarStub */, 0,
                "Enable printing of login notifications",
                "When this is enabled, Owl will print login and logout notifications\n"
                "for AIM, zephyr, or other protocols.  If disabled Owl will not print\n"
                "login or logout notifications.\n"),
+               "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 */, "",
 …
                  "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"),
+                 "all other logging variables are in their default state.\n");
   OWLVAR_BOOL( "loglogins" /* %OwlVarStub */, 0,
                "Enable logging of login notifications",
                "When this is enabled, Owl will login login and logout notifications\n"
                "for AIM, zephyr, or other protocols.  If disabled Owl will not print\n"
                "login or logout notifications.\n"),
+               "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"
+               "login or logout notifications.\n");
   OWLVAR_ENUM_FULL( "disable-ctrl-d" /* %OwlVarStub:lockout_ctrld */, 1,
                     "don't send zephyrs on C-d",
                     "If set to 'off', C-d won't send a zephyr from the edit\n"
                     "window.  If set to 'on', C-d will always send a zephyr\n"
+                    "If set to 'on', C-d won't send a zephyr from the edit\n"
+                    "window.  If set to 'off', C-d will always send a zephyr\n"
                     "being composed in the edit window.  If set to 'middle',\n"
                     "C-d will only ever send a zephyr if the cursor is at\n"
 …
                     "in the editmulti keymap.\n",
                     "off,middle,on",
                     NULL, owl_variable_disable_ctrl_d_set, NULL),
+                    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"),
+               "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"),
+               "Files will be created in the directory for each class.\n");
   OWLVAR_PATH( "debug_file" /* %OwlVarStub */, OWL_DEBUG_FILE,
                "path for logging debug messages when debugging is enabled",
                "This file will be logged to if 'debug' is set to 'on'.\n"
                "BarnOwl will append a dot and the current process's pid to the filename."),
+               "BarnOwl will append a dot and the current process's pid to the filename.");
   OWLVAR_PATH( "zsigproc" /* %OwlVarStub:zsigproc */, NULL,
 …
                "See the documentation for 'zsig' for more information about\n"
                "how the outgoing zsig is chosen."
                ),
+               );
   OWLVAR_PATH( "newmsgproc" /* %OwlVarStub:newmsgproc */, NULL,
                "name of a program to run when new messages are present",
                "The named program will be run when owl receives new\n"
+               "The named program will be run when BarnOwl receives new\n"
                "messages.  It will not be run again until the first\n"
                "instance exits"),
+               "instance exits");
   OWLVAR_STRING( "zsender" /* %OwlVarStub */, "",
 …
          "zephyrs.  If this is unset, it will use your Kerberos\n"
          "principal. Note that customizing the sender name will\n"
          "cause your zephyrs to be sent unauthenticated."),
+         "cause your zephyrs to be sent unauthenticated.");
   OWLVAR_STRING( "zsigfunc" /* %OwlVarStub */, "BarnOwl::default_zephyr_signature()",
 …
                  "explicit zsig.  The default setting implements the policy\n"
                  "described in the documentation for the 'zsig' variable.\n"
                  "See also BarnOwl::random_zephyr_signature().\n"),
+                 "See also BarnOwl::random_zephyr_signature().\n");
   OWLVAR_STRING( "zsig" /* %OwlVarStub */, "",
 …
                  "unset, 'zsigproc' will be run to generate a zsig. If that is\n"
                  "also unset, the 'zwrite-signature' zephyr variable will be\n"
                  "used instead.\n"),
+                 "used instead.\n");
   OWLVAR_STRING( "appendtosepbar" /* %OwlVarStub */, "",
                  "string to append to the end of the sepbar",
                  "The sepbar is the bar separating the top and bottom\n"
                  "of the owl screen.  Any string specified here will\n"
                  "be displayed on the right of the sepbar\n"),
+                 "of the BarnOwl screen.  Any string specified here will\n"
+                 "be displayed on the right of the sepbar\n");
   OWLVAR_BOOL( "zaway" /* %OwlVarStub */, 0,
                "turn zaway on or off", "" ),
+               "turn zaway on or off", "" );
   OWLVAR_STRING( "zaway_msg" /* %OwlVarStub */,
                  OWL_DEFAULT_ZAWAYMSG,
                  "zaway msg for responding to zephyrs when away", "" ),
+                 "zaway msg for responding to zephyrs when away", "" );
   OWLVAR_STRING( "zaway_msg_default" /* %OwlVarStub */,
                  OWL_DEFAULT_ZAWAYMSG,
                  "default zaway message", "" ),
+                 "default zaway message", "" );
   OWLVAR_BOOL_FULL( "aaway" /* %OwlVarStub */, 0,
                     "Set AIM away status",
                     "",
                     NULL, owl_variable_aaway_set, NULL),
+                    NULL, owl_variable_aaway_set, NULL);
   OWLVAR_STRING( "aaway_msg" /* %OwlVarStub */,
                  OWL_DEFAULT_AAWAYMSG,
                  "AIM away msg for responding when away", "" ),
+                 "AIM away msg for responding when away", "" );
   OWLVAR_STRING( "aaway_msg_default" /* %OwlVarStub */,
                  OWL_DEFAULT_AAWAYMSG,
                  "default AIM away message", "" ),
+                 "default AIM away message", "" );
   OWLVAR_STRING( "view_home" /* %OwlVarStub */, "all",
                  "home view to switch to after 'X' and 'V'",
                  "SEE ALSO: view, filter\n" ),
+                 "SEE ALSO: view, filter\n" );
   OWLVAR_STRING( "alert_filter" /* %OwlVarStub */, "none",
                  "filter on which to trigger alert actions",
                  "" ),
+                 "" );
   OWLVAR_STRING( "alert_action" /* %OwlVarStub */, "nop",
                  "owl command to execute for alert actions",
                  "" ),
+                 "BarnOwl command to execute for alert actions",
+                 "" );
   OWLVAR_STRING_FULL( "tty" /* %OwlVarStub */, "", "<string>", "tty name for zephyr location", "",
                       NULL, owl_variable_tty_set, NULL),
+                      NULL, owl_variable_tty_set, NULL);
   OWLVAR_STRING( "default_style" /* %OwlVarStub */, "default",
 …
                  "Styles may be created with the 'style' command.\n"
                  "Some built-in styles include:\n"
                  "   default  - the default owl formatting\n"
+                 "   default  - the default BarnOwl formatting\n"
                  "   oneline  - one line per-message\n"
                  "   perl     - legacy perl interface\n"
                  "\nSEE ALSO: style, show styles, view -s <style>\n"
                  ),
+                 );
 …
                  "This specifies the maximum number of columns for M-q to fill text\n"
                  "to.  If set to 0, M-q will wrap to the width of the window, and\n"
                  "values less than 0 disable M-q entirely.\n"),
+                 "values less than 0 disable M-q entirely.\n");
   OWLVAR_INT(    "edit:maxwrapcols" /* %OwlVarStub:edit_maxwrapcols */, 70,
 …
                  "\n"
                  "As a courtesy to recipients, it is recommended that outgoing\n"
                  "Zephyr messages be no wider than 70 columns.\n"),
+                 "Zephyr messages be no wider than 70 columns.\n");
   OWLVAR_INT( "aim_ignorelogin_timer" /* %OwlVarStub */, 15,
 …
               "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."),
+              "notifications of buddies as soon as you login, set it to 0 instead.");
 …
                    owl_variable_typewinsize_set,
                    NULL /* use default for get */
                    ),
+                   );
   OWLVAR_INT( "typewindelta" /* %OwlVarStub */, 0,
 …
            "typewinsize to 1.\n\n"
            "This works a lot better with a non-default scrollmode;\n"
            "try :set scrollmode pagedcenter.\n"),
+           "try :set scrollmode pagedcenter.\n");
   OWLVAR_ENUM( "scrollmode" /* %OwlVarStub */, OWL_SCROLLMODE_NORMAL,
 …
                "cursor moves between messages being displayed.\n"
                "The following modes are supported:\n\n"
                "   normal      - This is the owl default.  Scrolling happens\n"
+               "   normal      - This is the BarnOwl default.  Scrolling happens\n"
                "                 when it needs to, and an attempt is made to\n"
                "                 keep the current message roughly near\n"
 …
                "                 the screen will be paged up or down and\n"
                "                 the cursor will be near the center.\n",
                "normal,top,neartop,center,paged,pagedcenter" ),
+               "normal,top,neartop,center,paged,pagedcenter" );
   OWLVAR_BOOL( "narrow-related" /* %OwlVarStub:narrow_related */, 1,
                "Make smartnarrow use broader filters",
                "Causes smartfiler to narrow to messages \"related\" to \n"
+               "Causes smartfilter to narrow to messages \"related\" to \n"
                "the current message, as well as ones to the same place.\n\n"
                "for Zephyr, this controls whether to narrow to e.g. class-help or\n"
                "class-help.d alone, or to related-class-help, which includes\n"
                "help, unhelp, help.d, etc.\n\nDefault is true (include unclasses, etc.).\n" ),
+               "help, unhelp, help.d, etc.\n\nDefault is true (include unclasses, etc.).\n" );
   OWLVAR_BOOL( "_followlast" /* %OwlVarStub */, 0,
 …
                "continue to follow the last message if this is set.\n"
                "Note that this is currently risky as you might accidentally\n"
                "delete a message right as it came in.\n" ),
+               "delete a message right as it came in.\n" );
   OWLVAR_STRING_FULL( "default_exposure" /* %OwlVarStub */, "",
 …
                       "~/.zephyr.vars.\n"
                       "See the description of exposure for the values this can be.",
                       NULL, owl_variable_default_exposure_set, owl_variable_default_exposure_get ),
+                      NULL, owl_variable_default_exposure_set, owl_variable_default_exposure_get );
   OWLVAR_STRING_FULL( "exposure" /* %OwlVarStub */, "",
 …
                       "                     personal subscriptions will be entered for the\n"
                       "                     user.\n",
+                      NULL, owl_variable_exposure_set, NULL /* use default for get */ ),
+  /* This MUST be last... */
+  { NULL, 0, NULL, 0, NULL, NULL, NULL, NULL,
+    NULL, NULL, NULL, NULL, NULL, NULL }
+};
+                      NULL, owl_variable_exposure_set, NULL /* use default for get */ );
+}
 /**************************************************************************/
 …
 /* commonly useful */
+int owl_variable_int_validate_gt0(const owl_variable *v, const void *newval)
+{
+  if (newval == NULL) return(0);
+  else if (*(const int*)newval < 1) return(0);
+  else return (1);
+}
+int owl_variable_int_validate_positive(const owl_variable *v, const void *newval)
+{
+  if (newval == NULL) return(0);
+  else if (*(const int*)newval < 0) return(0);
+  else return (1);
+int owl_variable_int_validate_gt0(const owl_variable *v, int newval)
+{
+  return !(newval < 1);
+}
+int owl_variable_int_validate_positive(const owl_variable *v, int newval)
+{
+  return !(newval < 0);
+}
 /* typewinsize */
 int owl_variable_typewinsize_set(owl_variable *v, const void *newval)
+int owl_variable_typewinsize_set(owl_variable *v, int newval)
+{
   int rv;
 …
 /* debug (cache value in g->debug) */
+int owl_variable_debug_set(owl_variable *v, const void *newval)
+{
+  if (newval && (*(const int*)newval == 1 || *(const int*)newval == 0)) {
+    g.debug = *(const int*)newval;
+int owl_variable_debug_set(owl_variable *v, bool newval)
+{
+  g.debug = newval;
+  return owl_variable_bool_set_default(v, newval);
+}
+/* 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);
+}
+/* When 'aaway' is changed, need to notify the AIM server */
+int owl_variable_aaway_set(owl_variable *v, const void *newval)
+{
+int owl_variable_colorztext_set(owl_variable *v, bool newval)
+{
+  int ret = owl_variable_bool_set_default(v, newval);
+  /* flush the format cache so that we see the update, but only if we're done initializing BarnOwl */
+  if (owl_global_get_msglist(&g) != NULL)
+    owl_messagelist_invalidate_formats(owl_global_get_msglist(&g));
+  if (owl_global_get_mainwin(&g) != NULL) {
+    owl_function_calculate_topmsg(OWL_DIRECTION_DOWNWARDS);
+    owl_mainwin_redisplay(owl_global_get_mainwin(&g));
+  }
+  return ret;
+}
+int owl_variable_pseudologins_set(owl_variable *v, bool newval)
+{
+  static guint timer = 0;
   if (newval) {
+    if (*(const int*)newval == 1) {
+      owl_aim_set_awaymsg(owl_global_get_aaway_msg(&g));
+    } else if (*(const int*)newval == 0) {
+      owl_aim_set_awaymsg("");
+    owl_function_zephyr_buddy_check(0);
+    if (timer == 0) {
+      timer = g_timeout_add_seconds(180, owl_zephyr_buddycheck_timer, NULL);
+    }
+  } else {
+    if (timer != 0) {
+      g_source_remove(timer);
+      timer = 0;
+    }
+  }
 …
+}
-int owl_variable_pseudologins_set(owl_variable *v, const void *newval)
+{
-  static owl_timer *timer = NULL;
-  if (newval) {
-    if (*(const int*)newval == 1) {
-      owl_function_zephyr_buddy_check(0);
-      if (timer == NULL) {
-        timer = owl_select_add_timer("owl_zephyr_buddycheck_timer",
-, 180, owl_zephyr_buddycheck_timer, NULL, NULL);
+      }
-    } else {
-      if (timer != NULL) {
-        owl_select_remove_timer(timer);
-        timer = NULL;
+      }
+    }
+  }
-  return owl_variable_bool_set_default(v, newval);
+}
 /* note that changing the value of this will clobber
  * any user setting of this */
 int owl_variable_disable_ctrl_d_set(owl_variable *v, const void *newval)
+{
   if (newval && !owl_context_is_startup(owl_global_get_context(&g))) {
     if (*(const int*)newval == 2) {
+int owl_variable_disable_ctrl_d_set(owl_variable *v, int newval)
+{
+  if (!owl_context_is_startup(owl_global_get_context(&g))) {
+    if (newval == 2) {
       owl_function_command_norv("bindkey editmulti C-d command edit:delete-next-char");
     } else if (*(const int*)newval == 1) {
+    } else if (newval == 1) {
       owl_function_command_norv("bindkey editmulti C-d command edit:done-or-delete");
     } else {
 …
+    }
+  }
   return owl_variable_int_set_default(v, newval);
+}
 int owl_variable_tty_set(owl_variable *v, const void *newval)
+  return owl_variable_int_set_default(v, newval);
+}
+int owl_variable_tty_set(owl_variable *v, const char *newval)
+{
   owl_zephyr_set_locationinfo(g_get_host_name(), newval);
   return(owl_variable_string_set_default(v, newval));
+}
 int owl_variable_default_exposure_set(owl_variable *v, const void *newval)
+  return owl_variable_string_set_default(v, newval);
+}
+int owl_variable_default_exposure_set(owl_variable *v, const char *newval)
+{
   return owl_zephyr_set_default_exposure(newval);
+}
 const void *owl_variable_default_exposure_get(const owl_variable *v)
+const char *owl_variable_default_exposure_get(const owl_variable *v)
+{
   return owl_zephyr_get_default_exposure();
+}
 int owl_variable_exposure_set(owl_variable *v, const void *newval)
+int owl_variable_exposure_set(owl_variable *v, const char *newval)
+{
   int ret = owl_zephyr_set_exposure(newval);
 …
 /**************************************************************************/
+int owl_variable_dict_setup(owl_vardict *vd) {
+  owl_variable *var, *cur;
+void owl_variable_dict_setup(owl_vardict *vd) {
   owl_dict_create(vd);
+  for (var = variables_to_init; var->name != NULL; var++) {
+    cur = g_new(owl_variable, 1);
+    *cur = *var;
+    /* strdup all the strings so we can delete them consistently. */
+    cur->name = g_strdup(var->name);
+    cur->summary = g_strdup(var->summary);
+    cur->description = g_strdup(var->description);
+    switch (cur->type) {
+    case OWL_VARIABLE_OTHER:
+      cur->set_fn(cur, cur->pval_default);
+      break;
+    case OWL_VARIABLE_STRING:
+      if (!cur->validate_fn)
+        cur->validate_fn = owl_variable_string_validate_default;
+      if (!cur->set_fn)
+        cur->set_fn = owl_variable_string_set_default;
+      if (!cur->set_fromstring_fn)
+        cur->set_fromstring_fn = owl_variable_string_set_fromstring_default;
+      if (!cur->get_fn)
+        cur->get_fn = owl_variable_get_default;
+      if (!cur->get_tostring_fn)
+        cur->get_tostring_fn = owl_variable_string_get_tostring_default;
+      if (!cur->delete_fn)
+        cur->delete_fn = owl_variable_delete_default;
+      cur->set_fn(cur, cur->pval_default);
+      break;
+    case OWL_VARIABLE_BOOL:
+      if (!cur->validate_fn)
+        cur->validate_fn = owl_variable_bool_validate_default;
+      if (!cur->set_fn)
+        cur->set_fn = owl_variable_bool_set_default;
+      if (!cur->set_fromstring_fn)
+        cur->set_fromstring_fn = owl_variable_bool_set_fromstring_default;
+      if (!cur->get_fn)
+        cur->get_fn = owl_variable_get_default;
+      if (!cur->get_tostring_fn)
+        cur->get_tostring_fn = owl_variable_bool_get_tostring_default;
+      if (!cur->delete_fn)
+        cur->delete_fn = owl_variable_delete_default;
+      cur->val = g_new(int, 1);
+      cur->set_fn(cur, &cur->ival_default);
+      break;
+    case OWL_VARIABLE_INT:
+      if (!cur->validate_fn)
+        cur->validate_fn = owl_variable_int_validate_default;
+      if (!cur->set_fn)
+        cur->set_fn = owl_variable_int_set_default;
+      if (!cur->set_fromstring_fn)
+        cur->set_fromstring_fn = owl_variable_int_set_fromstring_default;
+      if (!cur->get_fn)
+        cur->get_fn = owl_variable_get_default;
+      if (!cur->get_tostring_fn)
+        cur->get_tostring_fn = owl_variable_int_get_tostring_default;
+      if (!cur->delete_fn)
+        cur->delete_fn = owl_variable_delete_default;
+      cur->val = g_new(int, 1);
+      cur->set_fn(cur, &cur->ival_default);
+      break;
+    default:
+      fprintf(stderr, "owl_variable_setup: invalid variable type\n");
+      return(-2);
+    }
+    owl_dict_insert_element(vd, cur->name, cur, NULL);
+  }
+  return 0;
+  owl_variable_add_defaults(vd);
+}
+CALLER_OWN GClosure *owl_variable_make_closure(owl_variable *v,
+                                               GCallback fn,
+                                               GClosureMarshal marshal) {
+  GClosure *closure = g_cclosure_new_swap(fn, v, NULL);
+  g_closure_set_marshal(closure,marshal);
+  g_closure_ref(closure);
+  g_closure_sink(closure);
+  return closure;
+}
 void owl_variable_dict_add_variable(owl_vardict * vardict,
                                     owl_variable * var) {
+  char *oldvalue = NULL;
+  owl_variable *oldvar = owl_variable_get_var(vardict, var->name);
+  /* Save the old value as a string. */
+  if (oldvar) {
+    oldvalue = owl_variable_get_tostring(oldvar);
+  }
   owl_dict_insert_element(vardict, var->name, var, (void (*)(void *))owl_variable_delete);
+}
+owl_variable * owl_variable_newvar(const char *name, const char *summary, const char * description) {
+  owl_variable * var = g_new0(owl_variable, 1);
+  /* Restore the old value. */
+  if (oldvalue) {
+    owl_variable_set_fromstring(var, oldvalue, 0);
+    g_free(oldvalue);
+  }
+}
+static owl_variable *owl_variable_newvar(int type, const char *name, const char *summary, const char *description, const char *validsettings) {
+  owl_variable *var = g_new0(owl_variable, 1);
+  var->type = type;
   var->name = g_strdup(name);
   var->summary = g_strdup(summary);
   var->description = g_strdup(description);
+  var->validsettings = g_strdup(validsettings);
   return var;
+}
+void owl_variable_update(owl_variable *var, const char *summary, const char *desc) {
+  g_free(var->summary);
+  var->summary = g_strdup(summary);
+  g_free(var->description);
+  var->description = g_strdup(desc);
+}
+void owl_variable_dict_newvar_string(owl_vardict * vd, const char *name, const char *summ, const char * desc, const char * initval) {
+  owl_variable *old = owl_variable_get_var(vd, name, OWL_VARIABLE_STRING);
+  if(old) {
+    owl_variable_update(old, summ, desc);
+    g_free(old->pval_default);
+    old->pval_default = g_strdup(initval);
+  } else {
+    owl_variable * var = owl_variable_newvar(name, summ, desc);
+    var->type = OWL_VARIABLE_STRING;
+    var->pval_default = g_strdup(initval);
+    var->set_fn = owl_variable_string_set_default;
+    var->set_fromstring_fn = owl_variable_string_set_fromstring_default;
+    var->get_fn = owl_variable_get_default;
+    var->get_tostring_fn = owl_variable_string_get_tostring_default;
+    var->delete_fn = owl_variable_delete_default;
+    var->set_fn(var, initval);
+    owl_variable_dict_add_variable(vd, var);
+  }
+}
+void owl_variable_dict_newvar_int(owl_vardict * vd, const char *name, const char *summ, const char * desc, int initval) {
+  owl_variable *old = owl_variable_get_var(vd, name, OWL_VARIABLE_INT);
+  if(old) {
+    owl_variable_update(old, summ, desc);
+    old->ival_default = initval;
+  } else {
+    owl_variable * var = owl_variable_newvar(name, summ, desc);
+    var->type = OWL_VARIABLE_INT;
+    var->ival_default = initval;
+    var->validate_fn = owl_variable_int_validate_default;
+    var->set_fn = owl_variable_int_set_default;
+    var->set_fromstring_fn = owl_variable_int_set_fromstring_default;
+    var->get_fn = owl_variable_get_default;
+    var->get_tostring_fn = owl_variable_int_get_tostring_default;
+    var->delete_fn = owl_variable_delete_default;
+    var->val = g_new(int, 1);
+    var->set_fn(var, &initval);
+    owl_variable_dict_add_variable(vd, var);
+  }
+}
+void owl_variable_dict_newvar_bool(owl_vardict * vd, const char *name, const char *summ, const char * desc, int initval) {
+  owl_variable *old = owl_variable_get_var(vd, name, OWL_VARIABLE_BOOL);
+  if(old) {
+    owl_variable_update(old, summ, desc);
+    old->ival_default = initval;
+  } else {
+    owl_variable * var = owl_variable_newvar(name, summ, desc);
+    var->type = OWL_VARIABLE_BOOL;
+    var->ival_default = initval;
+    var->validate_fn = owl_variable_bool_validate_default;
+    var->set_fn = owl_variable_bool_set_default;
+    var->set_fromstring_fn = owl_variable_bool_set_fromstring_default;
+    var->get_fn = owl_variable_get_default;
+    var->get_tostring_fn = owl_variable_bool_get_tostring_default;
+    var->delete_fn = owl_variable_delete_default;
+    var->val = g_new(int, 1);
+    var->set_fn(var, &initval);
+    owl_variable_dict_add_variable(vd, var);
+  }
+static void owl_variable_dict_newvar_int_full(owl_vardict *vd, const char *name, int default_val, const char *summary, const char *description, const char *validsettings, validate_int_t validate_fn, set_int_t set_fn, get_int_t get_fn)
+{
+  owl_variable *var = owl_variable_newvar(OWL_VARIABLE_INT, name, summary,
+                                          description, validsettings);
+  var->takes_on_off = false;
+  var->get_fn = G_CALLBACK(get_fn ? get_fn : owl_variable_int_get_default);
+  var->set_fn = G_CALLBACK(set_fn ? set_fn : owl_variable_int_set_default);
+  var->validate_fn = G_CALLBACK(validate_fn ? validate_fn : owl_variable_int_validate_default);
+  var->get_tostring_fn = owl_variable_make_closure(
+      var, G_CALLBACK(owl_variable_int_get_tostring_default),
+      g_cclosure_user_marshal_STRING__VOID);
+  var->set_fromstring_fn = owl_variable_make_closure(
+      var, G_CALLBACK(owl_variable_int_set_fromstring_default),
+      g_cclosure_user_marshal_INT__STRING);
+  g_value_init(&var->val, G_TYPE_INT);
+  owl_variable_set_int(var, default_val);
+  var->default_str = owl_variable_get_tostring(var);
+  owl_variable_dict_add_variable(vd, var);
+}
+void owl_variable_dict_newvar_int(owl_vardict *vd, const char *name, int default_val, const char *summary, const char *description) {
+  owl_variable_dict_newvar_int_full(vd, name, default_val, summary, description,
+                                    "<int>", NULL, NULL, NULL);
+}
+static void owl_variable_dict_newvar_bool_full(owl_vardict *vd, const char *name, bool default_val, const char *summary, const char *description, validate_bool_t validate_fn, set_bool_t set_fn, get_bool_t get_fn)
+{
+  owl_variable *var = owl_variable_newvar(OWL_VARIABLE_BOOL, name, summary,
+                                          description, "on,off");
+  var->takes_on_off = true;
+  var->get_fn = G_CALLBACK(get_fn ? get_fn : owl_variable_bool_get_default);
+  var->set_fn = G_CALLBACK(set_fn ? set_fn : owl_variable_bool_set_default);
+  var->validate_fn = G_CALLBACK(validate_fn ? validate_fn : owl_variable_bool_validate_default);
+  var->get_tostring_fn = owl_variable_make_closure(
+      var, G_CALLBACK(owl_variable_bool_get_tostring_default),
+      g_cclosure_user_marshal_STRING__VOID);
+  var->set_fromstring_fn = owl_variable_make_closure(
+      var, G_CALLBACK(owl_variable_bool_set_fromstring_default),
+      g_cclosure_user_marshal_INT__STRING);
+  g_value_init(&var->val, G_TYPE_BOOLEAN);
+  owl_variable_set_bool(var, default_val);
+  var->default_str = owl_variable_get_tostring(var);
+  owl_variable_dict_add_variable(vd, var);
+}
+void owl_variable_dict_newvar_bool(owl_vardict *vd, const char *name, bool default_val, const char *summary, const char *description) {
+  owl_variable_dict_newvar_bool_full(vd, name, default_val, summary, description,
+                                     NULL, NULL, NULL);
+}
+static void owl_variable_dict_newvar_string_full(owl_vardict *vd, const char *name, const char *default_val, const char *summary, const char *description, const char *validsettings, validate_string_t validate_fn, set_string_t set_fn, get_string_t get_fn)
+{
+  owl_variable *var = owl_variable_newvar(OWL_VARIABLE_STRING, name, summary,
+                                          description, validsettings);
+  var->takes_on_off = false;
+  var->get_fn = G_CALLBACK(get_fn ? get_fn : owl_variable_string_get_default);
+  var->set_fn = G_CALLBACK(set_fn ? set_fn : owl_variable_string_set_default);
+  var->validate_fn = G_CALLBACK(validate_fn ? validate_fn : owl_variable_string_validate_default);
+  var->get_tostring_fn = owl_variable_make_closure(
+      var, G_CALLBACK(owl_variable_string_get_tostring_default),
+      g_cclosure_user_marshal_STRING__VOID);
+  var->set_fromstring_fn = owl_variable_make_closure(
+      var, G_CALLBACK(owl_variable_string_set_fromstring_default),
+      g_cclosure_user_marshal_INT__STRING);
+  g_value_init(&var->val, G_TYPE_STRING);
+  owl_variable_set_string(var, default_val);
+  var->default_str = owl_variable_get_tostring(var);
+  owl_variable_dict_add_variable(vd, var);
+}
+void owl_variable_dict_newvar_string(owl_vardict *vd, const char *name, const char *default_val, const char *summary, const char *description) {
+  owl_variable_dict_newvar_string_full(vd, name, default_val, summary, description,
+                                       "<string>", NULL, NULL, NULL);
+}
+void owl_variable_dict_newvar_path(owl_vardict *vd, const char *name, const char *default_val, const char *summary, const char *description) {
+  owl_variable_dict_newvar_string_full(vd, name, default_val, summary, description,
+                                       "<path>", NULL, NULL, NULL);
+}
+static void owl_variable_dict_newvar_enum_full(owl_vardict *vd, const char *name, int default_val, const char *summary, const char *description, const char *validsettings, validate_int_t validate_fn, set_int_t set_fn, get_int_t get_fn)
+{
+  owl_variable *var = owl_variable_newvar(OWL_VARIABLE_INT, name, summary,
+                                          description, validsettings);
+  var->takes_on_off = false;
+  var->get_fn = G_CALLBACK(get_fn ? get_fn : owl_variable_int_get_default);
+  var->set_fn = G_CALLBACK(set_fn ? set_fn : owl_variable_int_set_default);
+  var->validate_fn = G_CALLBACK(validate_fn ? validate_fn : owl_variable_enum_validate);
+  var->get_tostring_fn = owl_variable_make_closure(
+      var, G_CALLBACK(owl_variable_enum_get_tostring),
+      g_cclosure_user_marshal_STRING__VOID);
+  var->set_fromstring_fn = owl_variable_make_closure(
+      var, G_CALLBACK(owl_variable_enum_set_fromstring),
+      g_cclosure_user_marshal_INT__STRING);
+  g_value_init(&var->val, G_TYPE_INT);
+  owl_variable_set_int(var, default_val);
+  var->default_str = owl_variable_get_tostring(var);
+  owl_variable_dict_add_variable(vd, var);
+}
+void owl_variable_dict_newvar_enum(owl_vardict *vd, const char *name, int default_val, const char *summary, const char *description, const char *validset) {
+  owl_variable_dict_newvar_enum_full(vd, name, default_val, summary, description,
+                                     validset, NULL, NULL, NULL);
+}
+void owl_variable_dict_newvar_other(owl_vardict *vd, const char *name, const char *summary, const char *description, const char *validsettings, bool takes_on_off, GClosure *get_tostring_fn, GClosure *set_fromstring_fn)
+{
+  owl_variable *var = owl_variable_newvar(OWL_VARIABLE_OTHER, name, summary,
+                                          description, validsettings);
+  var->takes_on_off = takes_on_off;
+  var->get_tostring_fn = g_closure_ref(get_tostring_fn);
+  g_closure_sink(get_tostring_fn);
+  var->set_fromstring_fn = g_closure_ref(set_fromstring_fn);
+  g_closure_sink(set_fromstring_fn);
+  var->default_str = owl_variable_get_tostring(var);
+  /* Note: this'll overwrite any existing variable of that name, even a C one,
+     but it's consistent with previous behavior and commands. */
+  owl_variable_dict_add_variable(vd, var);
+}
 …
+}
 void owl_variable_dict_get_names(const owl_vardict *d, owl_list *l) {
   owl_dict_get_keys(d, l);
+CALLER_OWN GPtrArray *owl_variable_dict_get_names(const owl_vardict *d) {
+  return owl_dict_get_keys(d);
+}
 void owl_variable_delete(owl_variable *v)
+{
-  if (v->delete_fn) v->delete_fn(v);
   g_free(v->name);
   g_free(v->summary);
   g_free(v->description);
+  g_free(v->default_str);
+  g_free(v->validsettings);
+  if (v->type != OWL_VARIABLE_OTHER)
+    g_value_unset(&(v->val));
+  g_closure_unref(v->get_tostring_fn);
+  g_closure_unref(v->set_fromstring_fn);
   g_free(v);
+}
+const char *owl_variable_get_name(const owl_variable *v)
+{
+  return v->name;
+}
 const char *owl_variable_get_description(const owl_variable *v) {
 …
 const char *owl_variable_get_validsettings(const owl_variable *v) {
+  if (v->validsettings) {
+    return v->validsettings;
+  } else {
+    return "";
+  return v->validsettings;
+}
+int owl_variable_get_type(const owl_variable *v)
+{
+  return v->type;
+}
+/* returns 0 on success, prints a status msg if msg is true */
+int owl_variable_set_fromstring(owl_variable *v, const char *value, int msg) {
+  char *tostring;
+  GValue values[] = {G_VALUE_INIT, G_VALUE_INIT};
+  GValue return_box = G_VALUE_INIT;
+  int set_successfully;
+  g_value_init(&values[0], G_TYPE_POINTER);
+  g_value_set_pointer(&values[0], NULL);
+  g_value_init(&values[1], G_TYPE_STRING);
+  g_value_set_static_string(&values[1], value);
+  g_value_init(&return_box, G_TYPE_INT);
+  g_closure_invoke(v->set_fromstring_fn, &return_box, 2, values, NULL);
+  set_successfully = g_value_get_int(&return_box);
+  if (0 != set_successfully) {
+    if (msg) owl_function_error("Unable to set %s (must be %s)", owl_variable_get_name(v),
+                                owl_variable_get_validsettings(v));
+  } else if (msg) {
+    tostring = owl_variable_get_tostring(v);
+    if (tostring) {
+      owl_function_makemsg("%s = '%s'", owl_variable_get_name(v), tostring);
+    } else {
+      owl_function_makemsg("%s = <null>", owl_variable_get_name(v));
+    }
+    g_free(tostring);
+  }
+}
+/* functions for getting and setting variable values */
+/* returns 0 on success, prints a status msg if msg is true */
+int owl_variable_set_fromstring(owl_vardict *d, const char *name, const char *value, int msg, int requirebool) {
+  owl_variable *v;
+  g_value_unset(&return_box);
+  g_value_unset(&values[1]);
+  g_value_unset(&values[0]);
+  return set_successfully;
+}
+int owl_variable_set_string(owl_variable *v, const char *newval)
+{
+  g_return_val_if_fail(v->type == OWL_VARIABLE_STRING, -1);
+  set_string_t cb = (set_string_t) v->set_fn;
+  return cb(v, newval);
+}
+int owl_variable_set_int(owl_variable *v, int newval)
+{
+  g_return_val_if_fail(v->type == OWL_VARIABLE_INT, -1);
+  set_int_t cb = (set_int_t) v->set_fn;
+  return cb(v, newval);
+}
+int owl_variable_set_bool(owl_variable *v, bool newval) {
+  g_return_val_if_fail(v->type == OWL_VARIABLE_BOOL, -1);
+  set_bool_t cb = (set_bool_t) v->set_fn;
+  return cb(v, newval);
+}
+int owl_variable_set_bool_on(owl_variable *v)
+{
+  if (v->type != OWL_VARIABLE_BOOL) return -1;
+  return owl_variable_set_bool(v, true);
+}
+int owl_variable_set_bool_off(owl_variable *v)
+{
+  if (v->type != OWL_VARIABLE_BOOL) return -1;
+  return owl_variable_set_bool(v, false);
+}
+CALLER_OWN char *owl_variable_get_tostring(const owl_variable *v)
+{
+  GValue instance = G_VALUE_INIT;
+  GValue tostring_box = G_VALUE_INIT;
+  char *ret = NULL;
+  g_value_init(&instance, G_TYPE_POINTER);
+  g_value_set_pointer(&instance, NULL);
+  g_value_init(&tostring_box, G_TYPE_STRING);
+  g_closure_invoke(v->get_tostring_fn, &tostring_box, 1, &instance, NULL);
+  ret = g_value_dup_string(&tostring_box);
+  g_value_unset(&tostring_box);
+  g_value_unset(&instance);
+  return ret;
+}
+const char *owl_variable_get_default_tostring(const owl_variable *v)
+{
+  return v->default_str;
+}
+owl_variable *owl_variable_get_var(const owl_vardict *d, const char *name)
+{
+  return owl_dict_find_element(d, name);
+}
+const char *owl_variable_get_string(const owl_variable *v)
+{
+  g_return_val_if_fail(v->type == OWL_VARIABLE_STRING, NULL);
+  get_string_t cb = (get_string_t) v->get_fn;
+  return cb(v);
+}
+int owl_variable_get_int(const owl_variable *v)
+{
+  g_return_val_if_fail(v->type == OWL_VARIABLE_INT, 0);
+  get_int_t cb = (get_int_t) v->get_fn;
+  return cb(v);
+}
+bool owl_variable_get_bool(const owl_variable *v)
+{
+  g_return_val_if_fail(v->type == OWL_VARIABLE_BOOL, FALSE);
+  get_bool_t cb = (get_bool_t) v->get_fn;
+  return cb(v);
+}
+void owl_variable_describe(const owl_variable *v, owl_fmtext *fm)
+{
+  const char *default_str = owl_variable_get_default_tostring(v);
+  char *default_buf;
+  if (default_str)
+    default_buf = g_strdup_printf("'%s'", default_str);
+  else
+    default_buf = g_strdup("<null>");
+  owl_fmtext_appendf_normal(fm, OWL_TABSTR "%-20s - %s (default: %s)\n",
+                            owl_variable_get_name(v),
+                            owl_variable_get_summary(v), default_buf);
+  g_free(default_buf);
+}
+void owl_variable_get_help(const owl_variable *v, owl_fmtext *fm) {
   char *tostring;
+  if (!name) return(-1);
+  v = owl_dict_find_element(d, name);
+  if (v == NULL) {
+    if (msg) owl_function_error("Unknown variable %s", name);
+    return -1;
+  }
+  if (!v->set_fromstring_fn) {
+    if (msg) owl_function_error("Variable %s is read-only", name);
+    return -1;
+  }
+  if (requirebool && v->type!=OWL_VARIABLE_BOOL) {
+    if (msg) owl_function_error("Variable %s is not a boolean", name);
+    return -1;
+  }
+  if (0 != v->set_fromstring_fn(v, value)) {
+    if (msg) owl_function_error("Unable to set %s (must be %s)", name,
+                                  owl_variable_get_validsettings(v));
+    return -1;
+  }
+  if (msg && v->get_tostring_fn) {
+    tostring = v->get_tostring_fn(v, v->get_fn(v));
+    owl_function_makemsg("%s = '%s'", name, tostring);
+    g_free(tostring);
+  }
+  return 0;
+}
+int owl_variable_set_string(owl_vardict *d, const char *name, const char *newval) {
+  owl_variable *v;
+  if (!name) return(-1);
+  v = owl_dict_find_element(d, name);
+  if (v == NULL || !v->set_fn) return(-1);
+  if (v->type!=OWL_VARIABLE_STRING) return(-1);
+  return v->set_fn(v, newval);
+}
+int owl_variable_set_int(owl_vardict *d, const char *name, int newval) {
+  owl_variable *v;
+  if (!name) return(-1);
+  v = owl_dict_find_element(d, name);
+  if (v == NULL || !v->set_fn) return(-1);
+  if (v->type!=OWL_VARIABLE_INT && v->type!=OWL_VARIABLE_BOOL) return(-1);
+  return v->set_fn(v, &newval);
+}
+int owl_variable_set_bool_on(owl_vardict *d, const char *name) {
+  return owl_variable_set_int(d,name,1);
+}
+int owl_variable_set_bool_off(owl_vardict *d, const char *name) {
+  return owl_variable_set_int(d,name,0);
+}
+char *owl_variable_get_tostring(const owl_vardict *d, const char *name) {
+  owl_variable *v;
+  if (!name) return NULL;
+  v = owl_dict_find_element(d, name);
+  if (v == NULL || !v->get_tostring_fn) return NULL;
+  return v->get_tostring_fn(v, v->get_fn(v));
+}
+char *owl_variable_get_default_tostring(const owl_vardict *d, const char *name) {
+  owl_variable *v;
+  if (!name) return NULL;
+  v = owl_dict_find_element(d, name);
+  if (v == NULL || !v->get_tostring_fn) return NULL;
+  if (v->type == OWL_VARIABLE_INT || v->type == OWL_VARIABLE_BOOL) {
+    return v->get_tostring_fn(v, &(v->ival_default));
+  } else {
+    return v->get_tostring_fn(v, v->pval_default);
+  }
+}
+owl_variable *owl_variable_get_var(const owl_vardict *d, const char *name, int require_type) {
+  owl_variable *v;
+  if (!name) return(NULL);
+  v = owl_dict_find_element(d, name);
+  if (v == NULL || !v->get_fn || v->type != require_type) return(NULL);
+  return v;
+}
+/* returns a reference */
+const void *owl_variable_get(const owl_vardict *d, const char *name, int require_type) {
+  owl_variable *v = owl_variable_get_var(d, name, require_type);
+  if(v == NULL) return NULL;
+  return v->get_fn(v);
+}
+/* returns a reference */
+const char *owl_variable_get_string(const owl_vardict *d, const char *name) {
+  return owl_variable_get(d,name, OWL_VARIABLE_STRING);
+}
+/* returns a reference */
+const void *owl_variable_get_other(const owl_vardict *d, const char *name) {
+  return owl_variable_get(d,name, OWL_VARIABLE_OTHER);
+}
+int owl_variable_get_int(const owl_vardict *d, const char *name) {
+  const int *pi;
+  pi = owl_variable_get(d,name,OWL_VARIABLE_INT);
+  if (!pi) return(-1);
+  return(*pi);
+}
+int owl_variable_get_bool(const owl_vardict *d, const char *name) {
+  const int *pi;
+  pi = owl_variable_get(d,name,OWL_VARIABLE_BOOL);
+  if (!pi) return(-1);
+  return(*pi);
+}
+void owl_variable_describe(const owl_vardict *d, const char *name, owl_fmtext *fm) {
+  char *default_buf;
+  owl_variable *v;
+  if (!name
+      || (v = owl_dict_find_element(d, name)) == NULL
+      || !v->get_fn) {
+    owl_fmtext_appendf_normal(fm, "     No such variable '%s'\n", name);
+    return;
+  }
+  if (v->type == OWL_VARIABLE_INT || v->type == OWL_VARIABLE_BOOL) {
+    default_buf = v->get_tostring_fn(v, &(v->ival_default));
+  } else {
+    default_buf = v->get_tostring_fn(v, v->pval_default);
+  }
+  owl_fmtext_appendf_normal(fm, OWL_TABSTR "%-20s - %s (default: '%s')\n",
+                            v->name,
+                            owl_variable_get_summary(v), default_buf);
+  g_free(default_buf);
+}
+void owl_variable_get_help(const owl_vardict *d, const char *name, owl_fmtext *fm) {
+  char *tostring;
+  owl_variable *v;
+  if (!name
+      || (v = owl_dict_find_element(d, name)) == NULL
+      || !v->get_fn) {
+    owl_fmtext_append_normal(fm, "No such variable...\n");
+    return;
+  }
+  const char *default_str;
   owl_fmtext_append_bold(fm, "OWL VARIABLE\n\n");
   owl_fmtext_append_normal(fm, OWL_TABSTR);
   owl_fmtext_append_normal(fm, name);
+  owl_fmtext_append_normal(fm, owl_variable_get_name(v));
   owl_fmtext_append_normal(fm, " - ");
   owl_fmtext_append_normal(fm, v->summary);
+  owl_fmtext_append_normal(fm, owl_variable_get_summary(v));
   owl_fmtext_append_normal(fm, "\n\n");
   owl_fmtext_append_normal(fm, "Current:        ");
   tostring = owl_variable_get_tostring(d, name);
   owl_fmtext_append_normal(fm, tostring);
+  tostring = owl_variable_get_tostring(v);
+  owl_fmtext_append_normal(fm, (tostring ? tostring : "<null>"));
   g_free(tostring);
   owl_fmtext_append_normal(fm, "\n\n");
+  if (v->type == OWL_VARIABLE_INT || v->type == OWL_VARIABLE_BOOL) {
+    tostring = v->get_tostring_fn(v, &(v->ival_default));
+  } else {
+    tostring = v->get_tostring_fn(v, v->pval_default);
+  }
+  default_str = owl_variable_get_default_tostring(v);
   owl_fmtext_append_normal(fm, "Default:        ");
   owl_fmtext_append_normal(fm, tostring);
+  owl_fmtext_append_normal(fm, (default_str ? default_str : "<null>"));
   owl_fmtext_append_normal(fm, "\n\n");
 …
     owl_fmtext_append_normal(fm, "\n\n");
+  }
-  g_free(tostring);
+}
 …
 /* default common functions */
+const void *owl_variable_get_default(const owl_variable *v) {
+  return v->val;
+}
+void owl_variable_delete_default(owl_variable *v)
+{
+  g_free(v->val);
+const char *owl_variable_string_get_default(const owl_variable *v) {
+  return g_value_get_string(&(v->val));
+}
+int owl_variable_int_get_default(const owl_variable *v) {
+  return g_value_get_int(&(v->val));
+}
+bool owl_variable_bool_get_default(const owl_variable *v) {
+  return g_value_get_boolean(&(v->val));
+}
 /* default functions for booleans */
+int owl_variable_bool_validate_default(const owl_variable *v, const void *newval) {
+  if (newval == NULL) return(0);
+  else if (*(const int*)newval==1 || *(const int*)newval==0) return(1);
+  else return (0);
+}
+int owl_variable_bool_set_default(owl_variable *v, const void *newval) {
+  if (v->validate_fn) {
+    if (!v->validate_fn(v, newval)) return(-1);
+int owl_variable_bool_validate_default(const owl_variable *v, bool newval) {
+  return (newval == 1) || (newval == 0);
+}
+int owl_variable_bool_set_default(owl_variable *v, bool newval) {
+  if (!((validate_bool_t)v->validate_fn)(v, newval))
+    return -1;
+  g_value_set_boolean(&(v->val), newval);
+  return(0);
+}
+int owl_variable_bool_set_fromstring_default(owl_variable *v, const char *newval, void *dummy) {
+  bool i;
+  if (!strcmp(newval, "on")) {
+    i = true;
+  } else if (!strcmp(newval, "off")) {
+    i = false;
+  } else {
+    return(-1);
+  }
+  *(int*)v->val = *(const int*)newval;
+  return(0);
+}
+int owl_variable_bool_set_fromstring_default(owl_variable *v, const char *newval) {
+  int i;
+  if (!strcmp(newval, "on")) i=1;
+  else if (!strcmp(newval, "off")) i=0;
+  else return(-1);
+  return (v->set_fn(v, &i));
+}
+char *owl_variable_bool_get_tostring_default(const owl_variable *v, const void *val) {
+  if (val == NULL) {
+    return g_strdup("<null>");
+  } else if (*(const int*)val == 0) {
+  return owl_variable_set_bool(v, i);
+}
+CALLER_OWN char *owl_variable_bool_get_tostring_default(const owl_variable *v, void *dummy)
+{
+  bool val = owl_variable_get_bool(v);
+  if (val == 0) {
     return g_strdup("off");
   } else if (*(const int*)val == 1) {
+  } else if (val == 1) {
     return g_strdup("on");
   } else {
 …
 /* default functions for integers */
 int owl_variable_int_validate_default(const owl_variable *v, const void *newval) {
+  if (newval == NULL) return(0);
   else return (1);
+}
 int owl_variable_int_set_default(owl_variable *v, const void *newval) {
   if (v->validate_fn) {
     if (!v->validate_fn(v, newval)) return(-1);
+  }
   *(int*)v->val = *(const int*)newval;
+int owl_variable_int_validate_default(const owl_variable *v, int newval)
+{
+  return (1);
+}
+int owl_variable_int_set_default(owl_variable *v, int newval) {
+  if (!((validate_int_t)v->validate_fn)(v, newval))
+    return -1;
+  g_value_set_int(&(v->val), newval);
   return(0);
+}
 int owl_variable_int_set_fromstring_default(owl_variable *v, const char *newval) {
+int owl_variable_int_set_fromstring_default(owl_variable *v, const char *newval, void *dummy) {
   int i;
   char *ep;
   i = strtol(newval, &ep, 10);
   if (*ep || ep==newval) return(-1);
+  return (v->set_fn(v, &i));
+}
+char *owl_variable_int_get_tostring_default(const owl_variable *v, const void *val) {
+  if (val == NULL) {
+    return g_strdup("<null>");
+  } else {
+    return g_strdup_printf("%d", *(const int*)val);
+  }
+  return owl_variable_set_int(v, i);
+}
+CALLER_OWN char *owl_variable_int_get_tostring_default(const owl_variable *v, void *dummy)
+{
+  return g_strdup_printf("%d", owl_variable_get_int(v));
+}
 /* default functions for enums (a variant of integers) */
 int owl_variable_enum_validate(const owl_variable *v, const void *newval) {
+int owl_variable_enum_validate(const owl_variable *v, int newval) {
   char **enums;
   int nenums, val;
-  if (newval == NULL) return(0);
   enums = g_strsplit_set(v->validsettings, ",", 0);
   nenums = g_strv_length(enums);
   g_strfreev(enums);
   val = *(const int*)newval;
+  val = newval;
   if (val < 0 || val >= nenums) {
     return(0);
 …
+}
 int owl_variable_enum_set_fromstring(owl_variable *v, const char *newval) {
+int owl_variable_enum_set_fromstring(owl_variable *v, const char *newval, void *dummy) {
   char **enums;
   int i, val=-1;
 …
   g_strfreev(enums);
   if (val == -1) return(-1);
+  return (v->set_fn(v, &val));
+}
+char *owl_variable_enum_get_tostring(const owl_variable *v, const void *val) {
+  return owl_variable_set_int(v, val);
+}
+CALLER_OWN char *owl_variable_enum_get_tostring(const owl_variable *v, void *dummy)
+{
   char **enums;
   int nenums, i;
   char *tostring;
-  if (val == NULL) {
-    return g_strdup("<null>");
+  }
   enums = g_strsplit_set(v->validsettings, ",", 0);
   nenums = g_strv_length(enums);
   i = *(const int*)val;
+  i = owl_variable_get_int(v);
   if (i<0 || i>=nenums) {
     g_strfreev(enums);
 …
 /* default functions for stringeans */
 int owl_variable_string_validate_default(const struct _owl_variable *v, const void *newval) {
+int owl_variable_string_validate_default(const owl_variable *v, const char *newval) {
   if (newval == NULL) return(0);
   else return (1);
+}
+int owl_variable_string_set_default(owl_variable *v, const void *newval) {
+  if (v->validate_fn) {
+    if (!v->validate_fn(v, newval)) return(-1);
+  }
+  g_free(v->val);
+  v->val = g_strdup(newval);
+int owl_variable_string_set_default(owl_variable *v, const char *newval) {
+  if (!((validate_string_t)v->validate_fn)(v, newval))
+    return -1;
+  g_value_set_string(&(v->val), newval);
   return(0);
+}
+int owl_variable_string_set_fromstring_default(owl_variable *v, const char *newval) {
+  return (v->set_fn(v, newval));
+}
+char *owl_variable_string_get_tostring_default(const owl_variable *v, const void *val) {
+  if (val == NULL) {
+    return g_strdup("<null>");
+  } else {
+    return g_strdup((const char*)val);
+  }
+}
+int owl_variable_string_set_fromstring_default(owl_variable *v, const char *newval, void *dummy)
+{
+  return owl_variable_set_string(v, newval);
+}
+CALLER_OWN char *owl_variable_string_get_tostring_default(const owl_variable *v, void *dummy)
+{
+  return g_strdup(owl_variable_get_string(v));
+}

view.c

r3b8a563	r219f52c
1		~~#include <stdlib.h>~~
2	1	#include "owl.h"
3	2
…	…
7	6	v->filter=f;
8	7	v->style=s;
9		~~owl_messagelist_create(&(v->ml)~~);
	8	v->ml = owl_messagelist_new();
10	9	owl_view_recalculate(v);
11	10	}
…	…
20	19	{
21	20	if (owl_filter_message_match(v->filter, m)) {
22		owl_messagelist_append_element(~~&(v->ml)~~, m);
	21	owl_messagelist_append_element(v->ml, m);
23	22	}
24	23	}
…	…
31	30	int i, j;
32	31	const owl_messagelist *gml;
33		~~owl_messagelist *ml;~~
34	32	owl_message *m;
35	33
36	34	gml=owl_global_get_msglist(&g);
37		~~ml=&(v->ml);~~
38	35
39		/* nuke the old list */
40		owl_~~list_cleanup(&ml->list, NULL~~);
41		~~owl_messagelist_create(&(v->ml)~~);
	36	/* nuke the old list, don't free the messages */
	37	owl_messagelist_delete(v->ml, false);
	38	v->ml = owl_messagelist_new();
42	39
43	40	/* find all the messages we want */
…	…
46	43	m=owl_messagelist_get_element(gml, i);
47	44	if (owl_filter_message_match(v->filter, m)) {
48		owl_messagelist_append_element(ml, m);
	45	owl_messagelist_append_element(v->ml, m);
49	46	}
50	47	}
…	…
73	70	owl_message owl_view_get_element(const owl_view v, int index)
74	71	{
75		return~~(owl_messagelist_get_element(&(v->ml), index)~~);
	72	return owl_messagelist_get_element(v->ml, index);
76	73	}
77	74
78	75	void owl_view_delete_element(owl_view *v, int index)
79	76	{
80		owl_messagelist_delete_element(~~&(v->ml)~~, index);
	77	owl_messagelist_delete_element(v->ml, index);
81	78	}
82	79
83	80	void owl_view_undelete_element(owl_view *v, int index)
84	81	{
85		owl_messagelist_undelete_element(~~&(v->ml)~~, index);
	82	owl_messagelist_undelete_element(v->ml, index);
86	83	}
87	84
88	85	int owl_view_get_size(const owl_view *v)
89	86	{
90		return~~(owl_messagelist_get_size(&(v->ml))~~);
	87	return owl_messagelist_get_size(v->ml);
91	88	}
92	89
…	…
159	156	void owl_view_cleanup(owl_view *v)
160	157	{
161		owl_~~list_cleanup(&v->ml.list, NULL~~);
	158	owl_messagelist_delete(v->ml, false);
162	159	g_free(v->name);
163	160	}

viewwin.c

-                      r4fd211f
+                      r7803326
-#include <string.h>
 #include "owl.h"
 …
  * will be used by the viewwin
  */
 owl_viewwin *owl_viewwin_new_text(owl_window *win, const char *text)
+CALLER_OWN owl_viewwin *owl_viewwin_new_text(owl_window *win, const char *text)
+{
   owl_viewwin *v = g_new0(owl_viewwin, 1);
 …
  * will be used by the viewwin
  */
 owl_viewwin *owl_viewwin_new_fmtext(owl_window *win, const owl_fmtext *fmtext)
+CALLER_OWN owl_viewwin *owl_viewwin_new_fmtext(owl_window *win, const owl_fmtext *fmtext)
+{
   char *text;
 …
 } owl_viewwin_search_data;
+static void owl_viewwin_callback_search(owl_editwin *e)
+{
+static void owl_viewwin_callback_search(owl_editwin *e, bool success)
+{
+  if (!success) return;
   int consider_current = false;
   const char *line = owl_editwin_get_text(e);
 …
+}
 owl_editwin *owl_viewwin_set_typwin_active(owl_viewwin *v, owl_history *hist) {
+CALLER_OWN owl_editwin *owl_viewwin_set_typwin_active(owl_viewwin *v, owl_history *hist) {
   int lines, cols;
   owl_editwin *cmdline;

window.c

-                      rf97c1a6
+                      r3442788
 #include "owl.h"
-#include <assert.h>
 struct _owl_window { /*noproto*/
 …
+}
+static owl_window *_get_cursor(void)
+{
+static owl_window *_get_cursor(bool *is_default)
+{
+  *is_default = false;
   if (cursor_owner && owl_window_is_realized(cursor_owner))
     return cursor_owner;
+  *is_default = true;
   if (default_cursor && owl_window_is_realized(default_cursor))
     return default_cursor;
 …
+}
+static bool _owl_window_is_subtree_dirty(owl_window *w)
+{
+  owl_window *child;
+  if (w->dirty)
+    return true;
+  for (child = w->child;
+       child != NULL;
+       child = child->next) {
+    if (child->dirty_subtree)
+      return true;
+  }
+  return false;
+}
 static void _owl_window_redraw_subtree(owl_window *w)
+{
   FuncOneArg ptr = (FuncOneArg)_owl_window_redraw_subtree;
   if (!w->dirty_subtree)
     return;
   _owl_window_redraw(w);
   owl_window_children_foreach(w, first_arg_only, &ptr);
+  w->dirty_subtree = 0;
+  /* Clear the dirty_subtree bit, unless a child doesn't have it
+   * cleared because we dirtied a window in redraw. Dirtying a
+   * non-descendant window during a redraw handler is
+   * discouraged. Redraw will not break, but it is undefined whether
+   * the dirty is delayed to the next event loop iteration. */
+  if (_owl_window_is_subtree_dirty(w)) {
+    owl_function_debugmsg("subtree still dirty after one iteration!");
+  } else {
+    w->dirty_subtree = 0;
+  }
+}
 …
   owl_window *cursor;
   owl_window *screen = owl_window_get_screen();
+  bool default_cursor;
   if (!screen->dirty_subtree)
 …
   _owl_window_redraw_subtree(screen);
   update_panels();
   cursor = _get_cursor();
+  cursor = _get_cursor(&default_cursor);
   if (cursor && cursor->win) {
+    /* If supported, hide the default cursor. */
+    curs_set(default_cursor ? 0 : 1);
     /* untouch it to avoid drawing; window should be clean now, but we must
      * clean up in case there was junk left over on a subwin (cleaning up after
 …
 };
+GSource *owl_window_redraw_source_new(void) {
+CALLER_OWN GSource *owl_window_redraw_source_new(void)
+{
   GSource *source;
   source = g_source_new(&redraw_funcs, sizeof(GSource));

window.h

-                      r4cc49bc
+                      rfe73d0c
 #include <glib-object.h>
-#ifdef HAVE_STDBOOL_H
 #include <stdbool.h>
-#else
-#ifndef HAVE__BOOL
-#define _Bool signed char
-#endif
-#define bool _Bool
-#define false 0
-#define true 1
-#define __bool_true_false_are_defined 1
-#endif  /* HAVE_STDBOOL_H */
 G_BEGIN_DECLS

zbuddylist.c

-                      rddbbcffa
+                      r7ed9bc6
 void owl_zbuddylist_create(owl_zbuddylist *zb)
+{
   owl_list_create(&(zb->zusers));
+  zb->zusers = g_ptr_array_new();
+}
 int owl_zbuddylist_adduser(owl_zbuddylist *zb, const char *name)
+{
   int i, j;
+  int i;
   char *user;
   user=long_zuser(name);
+  j=owl_list_get_size(&(zb->zusers));
+  for (i=0; i<j; i++) {
+    if (!strcasecmp(user, owl_list_get_element(&(zb->zusers), i))) {
+  for (i = 0; i < zb->zusers->len; i++) {
+    if (!strcasecmp(user, zb->zusers->pdata[i])) {
       g_free(user);
       return(-1);
+    }
+  }
   owl_list_append_element(&(zb->zusers), user);
+  g_ptr_array_add(zb->zusers, user);
   return(0);
+}
 …
 int owl_zbuddylist_deluser(owl_zbuddylist *zb, const char *name)
+{
   int i, j;
   char *user, *ptr;
+  int i;
+  char *user;
   user=long_zuser(name);
+  j=owl_list_get_size(&(zb->zusers));
+  for (i=0; i<j; i++) {
+    ptr=owl_list_get_element(&(zb->zusers), i);
+    if (!strcasecmp(user, ptr)) {
+      owl_list_remove_element(&(zb->zusers), i);
+      g_free(ptr);
+  for (i = 0; i < zb->zusers->len; i++) {
+    if (!strcasecmp(user, zb->zusers->pdata[i])) {
+      g_free(g_ptr_array_remove_index(zb->zusers, i));
       g_free(user);
       return(0);
 …
 int owl_zbuddylist_contains_user(const owl_zbuddylist *zb, const char *name)
+{
   int i, j;
+  int i;
   char *user;
   user=long_zuser(name);
+  j=owl_list_get_size(&(zb->zusers));
+  for (i=0; i<j; i++) {
+    if (!strcasecmp(user, owl_list_get_element(&(zb->zusers), i))) {
+  for (i = 0; i < zb->zusers->len; i++) {
+    if (!strcasecmp(user, zb->zusers->pdata[i])) {
       g_free(user);
       return(1);

zcrypt.c

-                      r7f86e3d
+                      r8f335a8
 #include <sys/wait.h>
 #include <ctype.h>
+#include "config.h"
+#include <limits.h>
+#include <getopt.h>
+#include <config.h>
 #ifdef HAVE_KERBEROS_IV
 …
 #include "filterproc.h"
+#ifndef OWL_VERSION_STRING
+#ifdef  GIT_VERSION
+#define stringify(x)       __stringify(x)
+#define __stringify(x)     #x
+#define OWL_VERSION_STRING stringify(GIT_VERSION)
+#else
+#define OWL_VERSION_STRING PACKAGE_VERSION
+#endif
+#endif /* !OWL_VERSION_STRING */
+/* Annotate functions in which the caller owns the return value and is
+ * responsible for ensuring it is freed. */
+#define CALLER_OWN G_GNUC_WARN_UNUSED_RESULT
 #define MAX_KEY      128
 …
 } ZWRITEOPTIONS;
 char *GetZephyrVarKeyFile(const char *whoami, const char *class, const char *instance);
+CALLER_OWN char *GetZephyrVarKeyFile(const char *whoami, const char *class, const char *instance);
 int ParseCryptSpec(const char *spec, const char **keyfile);
 char *BuildArgString(char **argv, int start, int end);
 char *read_keystring(const char *keyfile);
+CALLER_OWN char *BuildArgString(char **argv, int start, int end);
+CALLER_OWN char *read_keystring(const char *keyfile);
 int do_encrypt(int zephyr, const char *class, const char *instance,
 …
   des_string_to_key(keystring, key);
   des_key_sched(key, *schedule);
+}
+void usage(FILE *file, const char *progname)
+{
+  fprintf(file, "Usage: %s [-Z|-D|-E|-R|-S] [-F Keyfile] [-c class] [-i instance]\n", progname);
+  fprintf(file, "       [-advqtluon] [-s signature] [-f arg] [-m message]\n");
+  fprintf(file, "  One or more of class, instance, and keyfile must be specified.\n");
+}
 …
   int mode = M_NONE;
   char c;
+  int c;
   int messageflag = FALSE;
 …
   zoptions.flags = 0;
+  while ((c = getopt(argc, argv, "ZDERSF:c:i:advqtluons:f:m")) != (char)EOF)
+  enum {
+    OPT_VERSION = CHAR_MAX + 1,
+    OPT_HELP,
+  };
+  static const struct option options[] = {
+    {"version", no_argument, NULL, OPT_VERSION},
+    {"help", no_argument, NULL, OPT_HELP},
+    {NULL, 0, NULL, 0}
+  };
+  while ((c = getopt_long(argc, argv, "ZDERSF:c:i:advqtluons:f:m", options, NULL)) != -1)
+  {
     switch(c)
+    {
+      case OPT_VERSION:
+        /* Version */
+        printf("This is zcrypt version %s\n", OWL_VERSION_STRING);
+        exit(0);
+      case OPT_HELP:
+        /* Help */
+        usage(stdout, argv[0]);
+        exit(0);
       case 'Z':
         /* Zephyr encrypt */
 …
   if (error || !cryptspec)
+  {
+    fprintf(stderr, "Usage: %s [-Z|-D|-E|-R|-S] [-F Keyfile] [-c class] [-i instance]\n", argv[0]);
+    fprintf(stderr, "       [-advqtluon] [-s signature] [-f arg] [-m message]\n");
+    fprintf(stderr, "  One or more of class, instance, and keyfile must be specified.\n");
+    usage(stderr, argv[0]);
     exit(1);
+  }
 …
 /* Build a space-separated string from argv from elements between start  *
  * and end - 1.  malloc()'s the returned string. */
 char *BuildArgString(char **argv, int start, int end)
+CALLER_OWN char *BuildArgString(char **argv, int start, int end)
+{
   int len = 1;
 …
 #define MAX_SEARCH 3
 /* Find the class/instance in the .crypt-table */
 char *GetZephyrVarKeyFile(const char *whoami, const char *class, const char *instance)
+CALLER_OWN char *GetZephyrVarKeyFile(const char *whoami, const char *class, const char *instance)
+{
   char *keyfile = NULL;
 …
   int length[MAX_SEARCH], i;
   char buffer[MAX_BUFF];
+  const char *home;
   char *filename;
   char result[MAX_SEARCH][MAX_BUFF];
 …
   /* Open~/.crypt-table */
+  filename = g_strdup_printf("%s/.crypt-table", getenv("HOME"));
+  home = getenv("HOME");
+  if (home == NULL)
+    home = g_get_home_dir();
+  filename = g_build_filename(home, ".crypt-table", NULL);
   fsearch = fopen(filename, "r");
   if (fsearch)
 …
+}
 char *slurp_stdin(int ignoredot, int *length) {
+CALLER_OWN char *slurp_stdin(int ignoredot, int *length) {
   char *buf;
   char *inptr;
 …
+}
 char *GetInputBuffer(ZWRITEOPTIONS *zoptions, int *length) {
+CALLER_OWN char *GetInputBuffer(ZWRITEOPTIONS *zoptions, int *length) {
   char *buf;
 …
+}
 char *read_keystring(const char *keyfile) {
+CALLER_OWN char *read_keystring(const char *keyfile) {
   char *keystring;
   FILE *fkey = fopen(keyfile, "r");
 …
     "gpg",
     "--symmetric",
+    "--no-options",
+    "--no-default-keyring",
+    "--keyring", "/dev/null",
+    "--secret-keyring", "/dev/null",
     "--batch",
     "--quiet",
 …
     NULL
   };
   err = call_filter("gpg", argv, in, &out, &status);
+  err = call_filter(argv, in, &out, &status);
   if(err || status) {
     g_free(out);
 …
     "gpg",
     "--decrypt",
+    "--no-options",
+    "--no-default-keyring",
+    "--keyring", "/dev/null",
+    "--secret-keyring", "/dev/null",
     "--batch",
     "--no-use-agent",
 …
   if(!in) return FALSE;
+  err = call_filter("gpg", argv, in, &out, &status);
+  err = call_filter(argv, in, &out, &status);
+  free(in);
   if(err || status) {
     g_free(out);

zephyr.c

-                      rb848e30
+                      r80d7b44
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include "owl.h"
+#include <stdio.h>
 #include <sys/stat.h>
-#include <string.h>
-#include "owl.h"
 #ifdef HAVE_LIBZEPHYR
 …
 #define HM_SVC_FALLBACK         htons((unsigned short) 2104)
 static char *owl_zephyr_dotfile(const char *name, const char *input)
+static CALLER_OWN char *owl_zephyr_dotfile(const char *name, const char *input)
+{
   if (input != NULL)
     return g_strdup(input);
   else
     return g_strdup_printf("%s/%s", owl_global_get_homedir(&g), name);
+    return g_build_filename(owl_global_get_homedir(&g), name, NULL);
+}
 …
   struct sockaddr_in sin;
   ZNotice_t req;
+  GIOChannel *channel;
   /*
 …
+  }
+  owl_select_add_io_dispatch(ZGetFD(), OWL_IO_READ|OWL_IO_EXCEPT, &owl_zephyr_finish_initialization, NULL, NULL);
+}
+void owl_zephyr_finish_initialization(const owl_io_dispatch *d, void *data) {
+  channel = g_io_channel_unix_new(ZGetFD());
+  g_io_add_watch(channel, G_IO_IN | G_IO_ERR | G_IO_HUP,
+                 &owl_zephyr_finish_initialization, NULL);
+  g_io_channel_unref(channel);
+}
+gboolean owl_zephyr_finish_initialization(GIOChannel *source, GIOCondition condition, void *data) {
   Code_t code;
   char *perl;
   GSource *event_source;
-  owl_select_remove_io_dispatch(d);
   ZClosePort();
   if ((code = ZInitialize()) != ZERR_NONE) {
     owl_function_error("Initializing Zephyr: %s", error_message(code));
     return;
+    return FALSE;
+  }
   if ((code = ZOpenPort(NULL)) != ZERR_NONE) {
     owl_function_error("Initializing Zephyr: %s", error_message(code));
     return;
+    return FALSE;
+  }
 …
   perl = owl_perlconfig_execute("BarnOwl::Zephyr::_zephyr_startup()");
   g_free(perl);
+  return FALSE;
+}
 …
   struct stat statbuff;
-  subs = g_new(ZSubscription_t, subSize);
   subsfile = owl_zephyr_dotfile(".zephyr.subs", filename);
 …
   if (!file)
     return -1;
+  subs = g_new(ZSubscription_t, subSize);
   while (owl_getline(&buffer, file)) {
     if (buffer[0] == '#' || buffer[0] == '\n')
 …
+}
 void unsuball(void)
+bool unsuball(void)
+{
 #if HAVE_LIBZEPHYR
 …
     owl_function_error("Zephyr: Cancelling subscriptions: %s",
                        error_message(ret));
+#endif
+  return (ret == ZERR_NONE);
+#endif
+  return true;
+}
 …
+}
+/* return a pointer to the data in the Jth field, (NULL terminated by
+ * definition).  Caller must free the return.
+ */
+#ifdef HAVE_LIBZEPHYR
+char *owl_zephyr_get_field(const ZNotice_t *n, int j)
+{
+  int i, count, save;
+  /* If there's no message here, just run along now */
+#ifdef HAVE_LIBZEPHYR
+const char *owl_zephyr_first_raw_field(const ZNotice_t *n)
+{
   if (n->z_message_len == 0)
+    return(g_strdup(""));
+  count=save=0;
+  for (i=0; i<n->z_message_len; i++) {
+    if (n->z_message[i]=='\0') {
+      count++;
+      if (count==j) {
+        /* just found the end of the field we're looking for */
+        return(g_strdup(n->z_message+save));
+      } else {
+        save=i+1;
+      }
+    }
+  }
+  /* catch the last field, which might not be null terminated */
+  if (count==j-1) {
+    return g_strndup(n->z_message + save, n->z_message_len - save);
+  }
+  return(g_strdup(""));
+}
+char *owl_zephyr_get_field_as_utf8(const ZNotice_t *n, int j)
+{
+  int i, count, save;
+  /* If there's no message here, just run along now */
+  if (n->z_message_len == 0)
+    return(g_strdup(""));
+  count=save=0;
+  for (i = 0; i < n->z_message_len; i++) {
+    if (n->z_message[i]=='\0') {
+      count++;
+      if (count == j) {
+        /* just found the end of the field we're looking for */
+        return(owl_validate_or_convert(n->z_message + save));
+      } else {
+        save = i + 1;
+      }
+    }
+  }
+  /* catch the last field, which might not be null terminated */
+  if (count == j - 1) {
+    char *tmp, *out;
+    tmp = g_strndup(n->z_message + save, n->z_message_len - save);
+    out = owl_validate_or_convert(tmp);
+    g_free(tmp);
+    return out;
+  }
+  return(g_strdup(""));
+}
+#else
+char *owl_zephyr_get_field(void *n, int j)
+{
+  return(g_strdup(""));
+}
+char *owl_zephyr_get_field_as_utf8(void *n, int j)
+{
+  return owl_zephyr_get_field(n, j);
+    return NULL;
+  return n->z_message;
+}
+const char *owl_zephyr_next_raw_field(const ZNotice_t *n, const char *f)
+{
+  const char *end = n->z_message + n->z_message_len;
+  f = memchr(f, '\0', end - f);
+  if (f == NULL)
+    return NULL;
+  return f + 1;
+}
+const char *owl_zephyr_get_raw_field(const ZNotice_t *n, int j)
+{
+  int i;
+  const char *f;
+  for (i = 1, f = owl_zephyr_first_raw_field(n); i < j && f != NULL;
+       i++, f = owl_zephyr_next_raw_field(n, f))
+    ;
+  return f;
+}
+CALLER_OWN char *owl_zephyr_field(const ZNotice_t *n, const char *f)
+{
+  if (f == NULL)
+    return g_strdup("");
+  return g_strndup(f, n->z_message + n->z_message_len - f);
+}
+CALLER_OWN char *owl_zephyr_field_as_utf8(const ZNotice_t *n, const char *f)
+{
+  char *tmp = owl_zephyr_field(n, f);
+  char *out = owl_validate_or_convert(tmp);
+  g_free(tmp);
+  return out;
+}
+CALLER_OWN char *owl_zephyr_get_field(const ZNotice_t *n, int j)
+{
+  return owl_zephyr_field(n, owl_zephyr_get_raw_field(n, j));
+}
+CALLER_OWN char *owl_zephyr_get_field_as_utf8(const ZNotice_t *n, int j)
+{
+  return owl_zephyr_field_as_utf8(n, owl_zephyr_get_raw_field(n, j));
+}
+#else
+const char *owl_zephyr_first_raw_field(const void *n)
+{
+  return NULL;
+}
+const char *owl_zephyr_next_raw_field(const void *n, const char *f)
+{
+  return NULL;
+}
+const char *owl_zephyr_get_raw_field(const void *n, int j)
+{
+  return NULL;
+}
+CALLER_OWN char *owl_zephyr_field(const void *n, const char *f)
+{
+  return g_strdup("");
+}
+CALLER_OWN char *owl_zephyr_field_as_utf8(const void *n, const char *f)
+{
+  return g_strdup("");
+}
+CALLER_OWN char *owl_zephyr_get_field(const void *n, int j)
+{
+  return g_strdup("");
+}
+CALLER_OWN char *owl_zephyr_get_field_as_utf8(const void *n, int j)
+{
+  return owl_zephyr_field(n, owl_zephyr_get_raw_field(n, j));
+}
 #endif
 …
 int owl_zephyr_get_num_fields(const ZNotice_t *n)
+{
+  int i, fields;
+  if(n->z_message_len == 0)
+    return 0;
+  fields=1;
+  for (i=0; i<n->z_message_len; i++) {
+    if (n->z_message[i]=='\0') fields++;
+  }
+  return(fields);
+  int i;
+  const char *f;
+  for (i = 0, f = owl_zephyr_first_raw_field(n); f != NULL;
+       i++, f = owl_zephyr_next_raw_field(n, f))
+    ;
+  return i;
+}
 #else
 …
  * caller must free the return
  */
 char *owl_zephyr_get_message(const ZNotice_t *n, const owl_message *m)
+CALLER_OWN char *owl_zephyr_get_message(const ZNotice_t *n, const owl_message *m)
+{
 #define OWL_NFIELDS     5
 …
   Code_t ret;
   ZNotice_t notice;
+  char *zsender = NULL;
   memset(&notice, 0, sizeof(notice));
 …
   notice.z_kind=ACKED;
   notice.z_port=0;
+#ifdef ZCHARSET_UTF_8
+  notice.z_charset = ZCHARSET_UTF_8;
+#endif
   notice.z_class=zstr(class);
   notice.z_class_inst=zstr(instance);
+  notice.z_sender=NULL;
+  if (!strcmp(recipient, "*") || !strcmp(recipient, "@")) {
+  if (!strcmp(recipient, "@")) {
     notice.z_recipient=zstr("");
-    if (*owl_global_get_zsender(&g))
-        notice.z_sender=zstr(owl_global_get_zsender(&g));
   } else {
     notice.z_recipient=zstr(recipient);
+  }
+  notice.z_default_format=zstr("Class $class, Instance $instance:\nTo: @bold($recipient) at $time $date\nFrom: @bold{$1 <$sender>}\n\n$2");
+  if (!owl_zwrite_recip_is_personal(recipient) && *owl_global_get_zsender(&g))
+    notice.z_sender = zsender = long_zuser(owl_global_get_zsender(&g));
+  notice.z_default_format=zstr(ZEPHYR_DEFAULT_FORMAT);
   if (opcode) notice.z_opcode=zstr(opcode);
 …
   /* free then check the return */
   g_free(notice.z_message);
   ZFreeNotice(&notice);
+  g_free(zsender);
   if (ret != ZERR_NONE) {
     owl_function_error("Error sending zephyr: %s", error_message(ret));
 …
   } else if (!strcmp(retnotice->z_message, ZSRVACK_NOTSENT)) {
     if (retnotice->z_recipient == NULL
+        || *retnotice->z_recipient == 0
+        || *retnotice->z_recipient == '@') {
+        || !owl_zwrite_recip_is_personal(retnotice->z_recipient)) {
       char *buff;
       owl_function_error("No one subscribed to class %s", retnotice->z_class);
 …
       zw.opcode = g_strdup(retnotice->z_opcode);
       zw.zsig   = g_strdup("");
       owl_list_create(&(zw.recips));
       owl_list_append_element(&(zw.recips), g_strdup(retnotice->z_recipient));
+      zw.recips = g_ptr_array_new();
+      g_ptr_array_add(zw.recips, g_strdup(retnotice->z_recipient));
       owl_log_outgoing_zephyr_error(&zw, buff);
 …
   g_free(to);
   z = owl_zwrite_new(tmpbuff);
+  z = owl_zwrite_new_from_line(tmpbuff);
   g_free(tmpbuff);
   if (z == NULL) {
 …
 #endif
 char *owl_zephyr_zlocate(const char *user, int auth)
+CALLER_OWN char *owl_zephyr_zlocate(const char *user, int auth)
+{
 #ifdef HAVE_LIBZEPHYR
 …
+  }
+  g_free(subsfile);
   g_free(line);
 #endif
 …
 /* caller must free the return */
 char *owl_zephyr_makesubline(const char *class, const char *inst, const char *recip)
+CALLER_OWN char *owl_zephyr_makesubline(const char *class, const char *inst, const char *recip)
+{
   return g_strdup_printf("%s,%s,%s\n", class, inst, !strcmp(recip, "") ? "*" : recip);
 …
  * free the return.
  */
 char *owl_zephyr_getsubs(void)
+CALLER_OWN char *owl_zephyr_getsubs(void)
+{
 #ifdef HAVE_LIBZEPHYR
 …
     return -1;
   ret = ZSetLocation(zstr(exposure));
+  if (ret != ZERR_NONE) {
+  if (ret != ZERR_NONE
+#ifdef ZCONST
+      /* Before zephyr 3.0, ZSetLocation had a bug where, if you were subscribed
+       * to your own logins, it could wait for the wrong notice and return
+       * ZERR_INTERNAL when found neither SERVACK nor SERVNAK. Suppress it when
+       * building against the old ABI. */
+      && ret != ZERR_INTERNAL
+#endif
+     ) {
     owl_function_error("Unable to set exposure level: %s.", error_message(ret));
     return -1;
 …
  * The caller must free the return
  */
 char *short_zuser(const char *in)
+CALLER_OWN char *short_zuser(const char *in)
+{
   char *ptr = strrchr(in, '@');
 …
  * The caller must free the return.
  */
 char *long_zuser(const char *in)
+CALLER_OWN char *long_zuser(const char *in)
+{
   char *ptr = strrchr(in, '@');
 …
  * caller must free the return.
  */
 char *owl_zephyr_smartstripped_user(const char *in)
+CALLER_OWN char *owl_zephyr_smartstripped_user(const char *in)
+{
   char *slash, *dot, *realm, *out;
 …
+}
+/* read the list of users in 'filename' as a .anyone file, and put the
+ * names of the zephyr users in the list 'in'.  If 'filename' is NULL,
+ * use the default .anyone file in the users home directory.  Returns
+ * -1 on failure, 0 on success.
+/* Read the list of users in 'filename' as a .anyone file, and return as a
+ * GPtrArray of strings.  If 'filename' is NULL, use the default .anyone file
+ * in the users home directory.  Returns NULL on failure.
  */
 int owl_zephyr_get_anyone_list(owl_list *in, const char *filename)
+GPtrArray *owl_zephyr_get_anyone_list(const char *filename)
+{
 #ifdef HAVE_LIBZEPHYR
   char *ourfile, *tmp, *s = NULL;
   FILE *f;
+  GPtrArray *list;
   ourfile = owl_zephyr_dotfile(".anyone", filename);
 …
     owl_function_error("Error opening file %s: %s", ourfile, strerror(errno) ? strerror(errno) : "");
     g_free(ourfile);
     return -1;
+    return NULL;
+  }
   g_free(ourfile);
+  list = g_ptr_array_new();
   while (owl_getline_chomp(&s, f)) {
     /* ignore comments, blank lines etc. */
 …
       tmp[0] = '\0';
     owl_list_append_element(in, long_zuser(s));
+    g_ptr_array_add(list, long_zuser(s));
+  }
   g_free(s);
   fclose(f);
   return 0;
 #else
   return -1;
+  return list;
+#else
+  return NULL;
 #endif
+}
 …
 #endif
 void owl_zephyr_buddycheck_timer(owl_timer *t, void *data)
+gboolean owl_zephyr_buddycheck_timer(void *data)
+{
   if (owl_global_is_pseudologins(&g)) {
 …
     owl_function_debugmsg("Warning: owl_zephyr_buddycheck_timer call pointless; timer should have been disabled");
+  }
+  return TRUE;
+}
 …
   event_source = (owl_zephyr_event_source*) source;
   event_source->poll_fd.fd = fd;
   event_source->poll_fd.events = G_IO_IN | G_IO_HUP | G_IO_PRI | G_IO_ERR;
+  event_source->poll_fd.events = G_IO_IN | G_IO_HUP | G_IO_ERR;
   g_source_add_poll(source, &event_source->poll_fd);

zwrite.c

-                      r3b8a563
+                      r919cbf2
-#include <string.h>
-#include <pwd.h>
-#include <sys/types.h>
-#include <unistd.h>
 #include "owl.h"
 owl_zwrite *owl_zwrite_new(const char *line)
+CALLER_OWN owl_zwrite *owl_zwrite_new_from_line(const char *line)
+{
   owl_zwrite *z = g_new(owl_zwrite, 1);
   if (owl_zwrite_create_from_line(z, line) < 0) {
     owl_zwrite_delete(z);
+  if (owl_zwrite_create_from_line(z, line) != 0) {
+    g_free(z);
     return NULL;
+  }
 …
+}
+int owl_zwrite_create_from_line(owl_zwrite *z, const char *line)
+{
+  int argc, badargs, myargc;
+CALLER_OWN owl_zwrite *owl_zwrite_new(int argc, const char *const *argv)
+{
+  owl_zwrite *z = g_new(owl_zwrite, 1);
+  if (owl_zwrite_create(z, argc, argv) != 0) {
+    g_free(z);
+    return NULL;
+  }
+  return z;
+}
+G_GNUC_WARN_UNUSED_RESULT int owl_zwrite_create_from_line(owl_zwrite *z, const char *line)
+{
+  int argc;
   char **argv;
+  const char *const *myargv;
+  int ret;
+  /* parse the command line for options */
+  argv = owl_parseline(line, &argc);
+  if (argc < 0) {
+    owl_function_error("Unbalanced quotes in zwrite");
+    return -1;
+  }
+  ret = owl_zwrite_create(z, argc, strs(argv));
+  g_strfreev(argv);
+  return ret;
+}
+G_GNUC_WARN_UNUSED_RESULT int owl_zwrite_create(owl_zwrite *z, int argc, const char *const *argv)
+{
+  int badargs = 0;
   char *msg = NULL;
-  badargs=0;
   /* start with null entries */
 …
   z->cc=0;
   z->noping=0;
+  owl_list_create(&(z->recips));
+  z->zwriteline = g_strdup(line);
+  /* parse the command line for options */
+  argv=owl_parseline(line, &argc);
+  myargv=strs(argv);
+  if (argc<0) {
+    owl_function_error("Unbalanced quotes in zwrite");
+    return(-1);
+  }
+  myargc=argc;
+  if (myargc && *(myargv[0])!='-') {
+    z->cmd=g_strdup(myargv[0]);
+    myargc--;
+    myargv++;
+  }
+  while (myargc) {
+    if (!strcmp(myargv[0], "-c")) {
+      if (myargc<2) {
+        badargs=1;
+        break;
+      }
+      z->class=owl_validate_utf8(myargv[1]);
+      myargv+=2;
+      myargc-=2;
+    } else if (!strcmp(myargv[0], "-i")) {
+      if (myargc<2) {
+        badargs=1;
+        break;
+      }
+      z->inst=owl_validate_utf8(myargv[1]);
+      myargv+=2;
+      myargc-=2;
+    } else if (!strcmp(myargv[0], "-r")) {
+      if (myargc<2) {
+        badargs=1;
+        break;
+      }
+      z->realm=owl_validate_utf8(myargv[1]);
+      myargv+=2;
+      myargc-=2;
+    } else if (!strcmp(myargv[0], "-s")) {
+      if (myargc<2) {
+        badargs=1;
+        break;
+      }
+      z->zsig=owl_validate_utf8(myargv[1]);
+      myargv+=2;
+      myargc-=2;
+    } else if (!strcmp(myargv[0], "-O")) {
+      if (myargc<2) {
+        badargs=1;
+        break;
+      }
+      z->opcode=owl_validate_utf8(myargv[1]);
+      myargv+=2;
+      myargc-=2;
+    } else if (!strcmp(myargv[0], "-m")) {
+      if (myargc<2) {
+  z->recips = g_ptr_array_new();
+  z->zwriteline = owl_argv_quote(argc, argv);
+  if (argc && *(argv[0])!='-') {
+    z->cmd=g_strdup(argv[0]);
+    argc--;
+    argv++;
+  }
+  while (argc) {
+    if (!strcmp(argv[0], "-c")) {
+      if (argc<2) {
+        badargs=1;
+        break;
+      }
+      z->class=owl_validate_utf8(argv[1]);
+      argv+=2;
+      argc-=2;
+    } else if (!strcmp(argv[0], "-i")) {
+      if (argc<2) {
+        badargs=1;
+        break;
+      }
+      z->inst=owl_validate_utf8(argv[1]);
+      argv+=2;
+      argc-=2;
+    } else if (!strcmp(argv[0], "-r")) {
+      if (argc<2) {
+        badargs=1;
+        break;
+      }
+      z->realm=owl_validate_utf8(argv[1]);
+      argv+=2;
+      argc-=2;
+    } else if (!strcmp(argv[0], "-s")) {
+      if (argc<2) {
+        badargs=1;
+        break;
+      }
+      z->zsig=owl_validate_utf8(argv[1]);
+      argv+=2;
+      argc-=2;
+    } else if (!strcmp(argv[0], "-O")) {
+      if (argc<2) {
+        badargs=1;
+        break;
+      }
+      z->opcode=owl_validate_utf8(argv[1]);
+      argv+=2;
+      argc-=2;
+    } else if (!strcmp(argv[0], "-m")) {
+      if (argc<2) {
         badargs=1;
         break;
+      }
       /* we must already have users or a class or an instance */
       if (owl_list_get_size(&(z->recips))<1 && (!z->class) && (!z->inst)) {
+      if (z->recips->len < 1 && (!z->class) && (!z->inst)) {
         badargs=1;
         break;
 …
       /* Once we have -m, gobble up everything else on the line */
       myargv++;
       myargc--;
       msg = g_strjoinv(" ", (char**)myargv);
+      argv++;
+      argc--;
+      msg = g_strjoinv(" ", (char**)argv);
       break;
     } else if (!strcmp(myargv[0], "-C")) {
+    } else if (!strcmp(argv[0], "-C")) {
       z->cc=1;
       myargv++;
       myargc--;
     } else if (!strcmp(myargv[0], "-n")) {
+      argv++;
+      argc--;
+    } else if (!strcmp(argv[0], "-n")) {
       z->noping=1;
       myargv++;
       myargc--;
+      argv++;
+      argc--;
     } else {
       /* anything unattached is a recipient */
       owl_list_append_element(&(z->recips), owl_validate_utf8(myargv[0]));
       myargv++;
       myargc--;
+      g_ptr_array_add(z->recips, owl_validate_utf8(argv[0]));
+      argv++;
+      argc--;
+    }
+  }
-  g_strfreev(argv);
   if (badargs) {
+    owl_zwrite_cleanup(z);
     return(-1);
+  }
 …
   if (z->class == NULL &&
       z->inst == NULL &&
       owl_list_get_size(&(z->recips))==0) {
+      z->recips->len == 0) {
     owl_function_error("You must specify a recipient for zwrite");
+    owl_zwrite_cleanup(z);
     return(-1);
+  }
 …
 void owl_zwrite_send_ping(const owl_zwrite *z)
+{
   int i, j;
+  int i;
   char *to;
 …
+  }
+  /* if there are no recipients we won't send a ping, which
+     is what we want */
+  j=owl_list_get_size(&(z->recips));
+  for (i=0; i<j; i++) {
+  for (i = 0; i < z->recips->len; i++) {
     to = owl_zwrite_get_recip_n_with_realm(z, i);
+    send_ping(to, z->class, z->inst);
+    if (owl_zwrite_recip_is_personal(to))
+      send_ping(to, z->class, z->inst);
     g_free(to);
+  }
 …
 void owl_zwrite_set_message(owl_zwrite *z, const char *msg)
+{
   int i, j;
+  int i;
   GString *message;
   char *tmp = NULL, *tmp2;
 …
   g_free(z->message);
+  j=owl_list_get_size(&(z->recips));
+  if (j>0 && z->cc) {
+  if (z->cc && owl_zwrite_is_personal(z)) {
     message = g_string_new("CC: ");
     for (i=0; i<j; i++) {
+    for (i = 0; i < z->recips->len; i++) {
       tmp = owl_zwrite_get_recip_n_with_realm(z, i);
       g_string_append_printf(message, "%s ", tmp);
 …
 int owl_zwrite_send_message(const owl_zwrite *z)
+{
   int i, j, ret = 0;
+  int i, ret = 0;
   char *to = NULL;
   if (z->message==NULL) return(-1);
+  j=owl_list_get_size(&(z->recips));
+  if (j>0) {
+    for (i=0; i<j; i++) {
+  if (z->recips->len > 0) {
+    for (i = 0; i < z->recips->len; i++) {
       to = owl_zwrite_get_recip_n_with_realm(z, i);
       ret = send_zephyr(z->opcode, z->zsig, z->class, z->inst, to, z->message);
 …
   owl_zwrite z;
   int rv;
   rv=owl_zwrite_create_from_line(&z, cmd);
   if (rv) return(rv);
+  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);
 …
 int owl_zwrite_get_numrecips(const owl_zwrite *z)
+{
   return(owl_list_get_size(&(z->recips)));
+  return z->recips->len;
+}
 const char *owl_zwrite_get_recip_n(const owl_zwrite *z, int n)
+{
   return(owl_list_get_element(&(z->recips), n));
+  return z->recips->pdata[n];
+}
 /* Caller must free the result. */
 char *owl_zwrite_get_recip_n_with_realm(const owl_zwrite *z, int n)
+CALLER_OWN char *owl_zwrite_get_recip_n_with_realm(const owl_zwrite *z, int n)
+{
   if (z->realm[0]) {
 …
+}
+int owl_zwrite_is_personal(const owl_zwrite *z)
+bool owl_zwrite_recip_is_personal(const char *recipient)
+{
+  return recipient[0] && recipient[0] != '@';
+}
+bool owl_zwrite_is_personal(const owl_zwrite *z)
+{
   /* return true if at least one of the recipients is personal */
+  int i, j;
+  char *foo;
+  j=owl_list_get_size(&(z->recips));
+  for (i=0; i<j; i++) {
+    foo=owl_list_get_element(&(z->recips), i);
+    if (foo[0]!='@') return(1);
+  }
+  return(0);
+  int i;
+  for (i = 0; i < z->recips->len; i++)
+    if (owl_zwrite_recip_is_personal(z->recips->pdata[i]))
+      return true;
+  return false;
+}
 …
 void owl_zwrite_cleanup(owl_zwrite *z)
+{
   owl_list_cleanup(&(z->recips), &g_free);
+  owl_ptr_array_free(z->recips, g_free);
   g_free(z->cmd);
   g_free(z->zwriteline);
 …
  * If not a CC, only the recip_index'th user will be replied to.
  */
 char *owl_zwrite_get_replyline(const owl_zwrite *z, int recip_index)
+CALLER_OWN char *owl_zwrite_get_replyline(const owl_zwrite *z, int recip_index)
+{
   /* Match ordering in zwrite help. */
 …
+  }
   if (z->cc) {
     for (i = 0; i < owl_list_get_size(&(z->recips)); i++) {
+    for (i = 0; i < z->recips->len; i++) {
       g_string_append_c(buf, ' ');
       owl_string_append_quoted_arg(buf, owl_list_get_element(&(z->recips), i));
+      owl_string_append_quoted_arg(buf, z->recips->pdata[i]);
+    }
   } else if (recip_index < owl_list_get_size(&(z->recips))) {
+  } else if (recip_index < z->recips->len) {
     g_string_append_c(buf, ' ');
     owl_string_append_quoted_arg(buf, owl_list_get_element(&(z->recips), recip_index));
+    owl_string_append_quoted_arg(buf, z->recips->pdata[recip_index]);
+  }

Context Navigation

Legend:

Download in other formats: