Diff [2e420987ebbe33356a4b7c5dfabd60f1f21f2395:0071c88bc882ae44b235200e821626eb6e96230e] for / – BarnOwl

.gitignore

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

AUTHORS

-                      r80c0fc7
+                      r1d2c4c3
 The following people have provided patches or other contributions:
+  Sam Hartman
   Alex Vandiver
+  Kevin Chen
+  Arun Tharuvai
+  Sam Hartman
+  Geoffrey Thomas
   Derrick Brashear
   David Glasser
+  Matthew Goldstein
+  Arun Tharuvai
+  Kevin Chen
   Eric Price
-  Matthew Goldstein
-  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 primarily
+BarnOwl is based on code from Owl, which was originally primarly
 written by James Kretchmar.  Erik Nygren also made substantial
 contributions and improvements to the program.
+contributions and improvemnts to the program.
 The following people provided patches and other technical support for
+The following people provided patches and other techincal 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

-                      rccc182c
+                      rb03c714
 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

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

Makefile.am

-                      rca1fb26a
+                      rc266281
 ACLOCAL_AMFLAGS = -I m4
+GIT_DESCRIPTION := $(if $(wildcard $(srcdir)/.git),$(shell cd $(srcdir) && git describe --match='barnowl-*' HEAD 2>/dev/null))
+VERSION = $(if $(GIT_DESCRIPTION),$(GIT_DESCRIPTION:barnowl-%=%),@VERSION@)
+-include BUILD_VERSION.mk
+GIT_DESCRIPTION := $(if $(wildcard .git),$(shell git describe --match='barnowl-*' HEAD 2>/dev/null))
+GIT_FLAGS := $(if $(GIT_DESCRIPTION),-DGIT_VERSION=$(GIT_DESCRIPTION:barnowl-%=%))
+FORCE:
+BUILD_VERSION.mk: $(if $(filter-out $(BUILD_VERSION),$(VERSION)),FORCE)
+        echo 'BUILD_VERSION = $(VERSION)' > $@
+bin_PROGRAMS = bin/barnowl
+bin_PROGRAMS = barnowl.bin
 if ENABLE_ZCRYPT
 bin_PROGRAMS += zcrypt
 endif
 zcrypt_SOURCES = zcrypt.c filterproc.c version.c
+zcrypt_SOURCES = zcrypt.c filterproc.c
+check_PROGRAMS = bin/tester
+dist_check_DATA = t
+dist_check_SCRIPTS = runtests.sh
+check_PROGRAMS = tester.bin
+noinst_SCRIPTS = barnowl
+check_SCRIPTS = tester
+barnowl_bin_SOURCES = $(BASE_SRCS) \
+     owl.h owl_perl.h config.h \
+     owl.c \
+     $(GEN_C) $(GEN_H)
+barnowl tester: %: barnowl-wrapper.in bin/% Makefile
+        sed \
+            -e 's,[@]abs_srcdir[@],$(abs_srcdir),g' \
+            -e 's,[@]abs_builddir[@],$(abs_builddir),g' \
+            $< > $@
+        chmod +x $@
+man_MANS = doc/barnowl.1
+doc_DATA = doc/intro.txt doc/advanced.txt
+bin_barnowl_SOURCES = $(BASE_SRCS) \
+     owl.h owl_perl.h \
+     owl.c
+nodist_bin_barnowl_SOURCES = $(GEN_C) $(GEN_H)
+barnowl_bin_LDADD = compat/libcompat.a libfaim/libfaim.a
+dist_man_MANS = doc/barnowl.1
+dist_doc_DATA = doc/intro.txt doc/advanced.txt
+tester_bin_SOURCES = $(BASE_SRCS) \
+     owl.h owl_perl.h config.h \
+     $(GEN_C) $(GEN_H) \
+     tester.c
+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)
+bin_tester_LDADD = compat/libcompat.a libfaim/libfaim.a
+tester_bin_LDADD = compat/libcompat.a libfaim/libfaim.a
 TESTS=runtests.sh
 AM_CPPFLAGS = \
+AM_CPPFLAGS = -I$(top_srcdir)/ \
            -I$(top_srcdir)/libfaim/ \
            -DDATADIR='"$(pkgdatadir)"' \
+           -DBINDIR='"$(bindir)"'
+           -DBINDIR='"$(bindir)"' \
+           $(GIT_FLAGS)
 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 \
+     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 \
      mainpanel.c msgwin.c sepbar.c editcontext.c signal.c closures.c
+     mainpanel.c msgwin.c sepbar.c editcontext.c signal.c
 NORMAL_SRCS = filterproc.c filterproc.h window.c window.h windowcb.c
+NORMAL_SRCS = filterproc.c window.c windowcb.c
 BASE_SRCS = $(CODELIST_SRCS) $(NORMAL_SRCS)
 GEN_C = varstubs.c perlglue.c gmarshal_funcs.c version.c version.c.new
 GEN_H = owl_prototypes.h owl_prototypes.h.new gmarshal_funcs.h
+GEN_C = varstubs.c perlglue.c
+GEN_H = owl_prototypes.h
 BUILT_SOURCES = $(GEN_H)
+BUILT_SOURCES = $(GEN_C) $(GEN_H)
 # Only copy file into place if file.new is different
 owl_prototypes.h version.c: %: %.new
+%: %.new
         @diff -U0 $@ $< || { \
          test -f $@ && echo '$@ changed!'; \
 …
 proto: owl_prototypes.h
 perlglue.c: perlglue.xs typemap
         $(AM_V_GEN)perl $(XSUBPPDIR)/xsubpp $(XSUBPPFLAGS) -prototypes $< > $@
+perlglue.c: perlglue.xs $(TYPEMAP)
+        $(AM_V_GEN)perl $(XSUBPPDIR)/xsubpp $(XSUBPPFLAGS) -prototypes perlglue.xs > perlglue.c
 varstubs.c: stubgen.pl variable.c
 …
         $(AM_V_GEN)perl $< $(sort $(filter-out $<,$+)) > $@
-version.c.new: Makefile BUILD_VERSION.mk
-        $(AM_V_GEN)echo 'const char *version = "$(VERSION)";' > $@
-gmarshal_funcs.h: marshal_types
-        glib-genmarshal --header $< > $@
-gmarshal_funcs.c: marshal_types
-        glib-genmarshal --body $< > $@
 # For emacs flymake-mode
 check-syntax: proto
         $(COMPILE) -Wall -Wextra -pedantic -fsyntax-only $(CHK_SOURCES)
+CLEANFILES = $(BUILT_SOURCES) $(GEN_C) $(noinst_SCRIPTS) $(check_SCRIPTS) BUILD_VERSION.mk
+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
+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)
 SUBDIRS = compat libfaim perl

README

-                      r1c22155
+                      rb711711
 following CPAN modules:
-Facebook::Graph
 Net::Jabber
 Net::XMPP
 XML::Stream
 Some have been modified slightly for the needs of this project.
+They 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
 …
 We plan to soon add targets to the Makefile to check for and install
 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:
 …
 Authen::SASL::Perl
 IO::Socket::SSL
 Digest::SHA
+Digest::SHA1
 The Twitter module requires:

aim.c

-                      r7dcef03
+                      rf271129
+{
   aim_clientready(sess, fr->conn);
   owl_function_debugmsg("conninitdone_admin: initialization done for admin connection");
+  owl_function_debugmsg("conninitdone_admin: initializtion 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 receiver 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 reciever evil = %f, min msg interval = %u",
                        params->maxchan, params->flags, params->maxmsglen, ((float)params->maxsenderwarn)/10.0, ((float)params->maxrecverwarn)/10.0, params->minmsginterval);
 …
   wrapmsg=owl_text_wordwrap(stripmsg, 70);
   nz_screenname=owl_aim_normalize_screenname(userinfo->sn);
   m=g_slice_new(owl_message);
+  m=g_new(owl_message, 1);
   owl_message_create_aim(m,
                          nz_screenname,

buddy.c

r7dcef03	rd4927a7
72	72	{
73	73	owl_buddy_cleanup(b);
74		g_~~slice_free(owl_buddy,~~ b);
	74	g_free(b);
75	75	}

buddylist.c

-                      r7dcef03
+                      r3cdd6d2
+{
   owl_buddy *b;
   b=g_slice_new(owl_buddy);
+  b=g_new(owl_buddy, 1);
   owl_buddy_create(b, OWL_PROTOCOL_AIM, screenname);
 …
     /* if not, create the login message */
     m=g_slice_new(owl_message);
+    m=g_new(owl_message, 1);
     owl_message_create_aim(m,
                            screenname,
 …
   if (owl_buddylist_is_aim_buddy_loggedin(bl, screenname)) {
     m=g_slice_new(owl_message);
+    m=g_new(owl_message, 1);
     owl_message_create_aim(m,
                            screenname,

cmd.c

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

commands.c

-                      rca1fb26a
+                      rf271129
   OWLCMD_ARGS("unbindkey", owl_command_unbindkey, OWL_CTX_ANY,
               "removes a binding in a keymap",
               "unbindkey <keymap> <keyseq>",
+              "bindkey <keymap> <keyseq>",
               "Removes a binding of a key sequence within a keymap.\n"
               "Use 'show keymaps' to see the existing keymaps.\n"
 …
   OWLCMD_ARGS("away", owl_command_away, OWL_CTX_INTERACTIVE,
               "Set, enable or disable all away messages",
+              "Set, enable or disable both AIM and zephyr away messages",
               "away [ on | off | toggle ]\n"
               "away <message>",
               "Turn on or off all away messages.  If\n"
+              "Turn on or off the AIM and zephyr away message.  If\n"
               "'message' is specified turn them on with that message,\n"
               "otherwise use the default.\n"
+              "\n"
+              "This command really just runs the 'aaway' and 'zaway'\n"
+              "commands together\n"
               "\n"
               "SEE ALSO: aaway, zaway"),
 …
   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] [initial-value]",
+                  "popless:start-search [-r] [inital-value]",
                   "Initializes the command-line to search for initial-value. If\n"
                   "-r is used, the search will be performed backwards.\n\n"
 …
 void owl_command_version(void)
+{
   owl_function_makemsg("BarnOwl version %s", version);
+  owl_function_makemsg("BarnOwl version %s", OWL_VERSION_STRING);
+}
 …
 char *owl_command_away(int argc, const char *const *argv, const char *buff)
+{
+  bool away_off;
+  const char *message = NULL;
+  if (argc == 1 ||
+      (argc == 2 && !strcmp(argv[1], "on"))) {
+    away_off = false;
+  if ((argc==1) ||
+      ((argc==2) && !strcmp(argv[1], "on"))) {
     owl_global_set_aaway_msg(&g, owl_global_get_aaway_msg_default(&g));
     owl_global_set_zaway_msg(&g, owl_global_get_zaway_msg_default(&g));
+  } else if (argc == 2 && !strcmp(argv[1], "off")) {
+    away_off = true;
+  } else if (argc == 2 && !strcmp(argv[1], "toggle")) {
+    away_off = owl_function_is_away();
+  } else {
+    away_off = false;
+    message = skiptokens(buff, 1);
+  }
+  if (away_off) {
+    owl_function_aaway_on();
+    owl_function_zaway_on();
+    owl_function_makemsg("Away messages set.");
+    return NULL;
+  }
+  if (argc==2 && !strcmp(argv[1], "off")) {
     owl_function_aaway_off();
     owl_function_zaway_off();
+    owl_perlconfig_perl_call_norv("BarnOwl::Hooks::_away_off", 0, NULL);
+    owl_function_makemsg("Away messages off.");
+  } else if (message != NULL) {
+    owl_global_set_aaway_msg(&g, message);
+    owl_global_set_zaway_msg(&g, message);
+    owl_function_aaway_on();
+    owl_function_zaway_on();
+    owl_perlconfig_perl_call_norv("BarnOwl::Hooks::_away_on", 1, &message);
+    owl_function_makemsg("Away messages set (%s).", message);
+  } else {
+    owl_function_aaway_on();
+    owl_function_zaway_on();
+    owl_perlconfig_perl_call_norv("BarnOwl::Hooks::_away_on", 0, NULL);
+    owl_function_makemsg("Away messages set.");
+  }
+    return NULL;
+  }
+  if (argc==2 && !strcmp(argv[1], "toggle")) {
+    /* if either one is on, turn it off, otherwise toggle both (turn
+     *  them both on)
+     */
+    if (!owl_global_is_zaway(&g) && !owl_global_is_aaway(&g)) {
+      owl_function_aaway_toggle();
+      owl_function_zaway_toggle();
+      owl_function_makemsg("Away messages set.");
+    } else {
+      if (owl_global_is_zaway(&g)) owl_function_zaway_toggle();
+      if (owl_global_is_aaway(&g)) owl_function_aaway_toggle();
+      owl_function_makemsg("Away messages off.");
+    }
+    return NULL;
+  }
+  buff = skiptokens(buff, 1);
+  owl_global_set_aaway_msg(&g, buff);
+  owl_global_set_zaway_msg(&g, buff);
+  owl_function_aaway_on();
+  owl_function_zaway_on();
+  owl_function_makemsg("Away messages set.");
   return NULL;
+}
 …
   if (v == NULL) {
     if (!silent) owl_function_error("Unknown variable '%s'", var);
   } else if (requirebool && !v->takes_on_off) {
+  } else if (requirebool && owl_variable_get_type(v) != OWL_VARIABLE_BOOL) {
     if (!silent) owl_function_error("Variable '%s' is not a boolean", var);
   } else {
 …
   if (v == NULL) {
     if (!silent) owl_function_error("Unknown variable '%s'", var);
   } else if (!v->takes_on_off) {
+  } else if (owl_variable_get_type(v) != OWL_VARIABLE_BOOL) {
     if (!silent) owl_function_error("Variable '%s' is not a boolean", var);
   } else {
 …
   if (argc < 3) {
     owl_function_makemsg("Usage: unbindkey <keymap> <binding>");
+    owl_function_makemsg("Usage: bindkey <keymap> <binding>");
     return NULL;
+  }
 …
+  }
   /* check for a zwrite -m */
   z = owl_zwrite_new(argc, argv);
+  z = owl_zwrite_new(buff);
   if (!z) {
     owl_function_error("Error in zwrite arguments");
 …
     if (!strcmp(argv[0], "-f")) {
       if (argc<2) {
         owl_function_makemsg("Too few arguments to the view command");
+        owl_function_makemsg("Too few argments to the view command");
         return(NULL);
+      }
 …
     } else if (!strcmp(argv[0], "-s")) {
       if (argc<2) {
         owl_function_makemsg("Too few arguments to the view command");
+        owl_function_makemsg("Too few argments to the view command");
         return(NULL);
+      }
 …
       argv+=2;
     } else {
       owl_function_makemsg("Too few arguments to the view command");
+      owl_function_makemsg("Too few argments to the view command");
       return(NULL);
+    }
 …
     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);
+}
 …
   owl_global_pop_context(&g);
   owl_editwin_do_callback(e, true);
+  owl_editwin_do_callback(e);
   owl_editwin_unref(e);
+}

compat/Makefile.am

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

compat/compat.h

r6249a88f	r4dde585
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

-                      r77dfeb1
+                      r883502d
 dnl Process this file with autoconf to produce a configure script.
+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])
+AC_INIT([BarnOwl],[1.9dev],[bug-barnowl@mit.edu])
+AM_INIT_AUTOMAKE([1.7.0 -Wall -Wno-portability foreign])
 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_zephyr" != xno],
+  [have_krb4=no
+   AS_IF([test "x$with_krb4" != "xno"],
+  [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])])])])
+   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_MSG_ERROR([Kerberos IV requested but not found])])
+       PKG_CHECK_MODULES([LIBCRYPTO], [libcrypto])
+       AM_CFLAGS="${AM_CFLAGS} ${LIBCRYPTO_CFLAGS}"
+       LIBS="${LIBS} ${LIBCRYPTO_LIBS}"
+     ])])
    AC_CHECK_LIB([zephyr], [ZGetSender],
    [LIBS="$LIBS -lzephyr"
 …
 dnl Find the location of perl XSUBPP
 AC_MSG_CHECKING(for the perl xsubpp precompiler)
 XSUBPPDIR="`cd "$srcdir" && perl -MExtUtils::MakeMaker -e 'print ExtUtils::MakeMaker->new({NAME => qw(owl)})->tool_xsubpp;' | grep \^XSUBPPDIR | sed -e 's/XSUBPPDIR = //g;'`"
+XSUBPPDIR="`(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})
 …
 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.])])
 …
    prefix="${ac_default_prefix}"
 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.
 …
 dnl Define __EXTENSIONS__ for strcasecmp on Solaris.
 AM_CFLAGS="$AM_CFLAGS -D__EXTENSIONS__"
-dnl Define _XOPEN_SOURCE_EXTENDED for some features in ncurses,
-dnl including cchar_t.  This should not be necessary with
-dnl _XOPEN_SOURCE=600, but some versions of ncurses
-dnl apparently still need it.
-AM_CFLAGS="$AM_CFLAGS -D_XOPEN_SOURCE_EXTENDED"
 AC_SUBST([AM_CFLAGS])
 …
 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

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

doc/barnowl.1

-                      r8135737
+                      rbad4496
 .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.)
+By default, \fBBarnOwl\fP uses the first of \fI~/.owl/init.pl\fP,
+\fI~/.barnowlconf\fP, or \fI~/.owlconf\fP that exists.
+Specify an alternate config file for \fBBarnOwl\fP to use.  By default,
+\fBBarnOwl\fP uses \fI~/.barnowlconf\fP if it exists, and \fI~/.owlconf\fP otherwise.
 .TP

doc/releasing-barnowl.txt

-                      rd995ff3
+                      r5f08dbe
   - [ ] Do a locker build (See DOING A LOCKER BUILD)
   - [ ] Update configure.ac on master to bump the version to 1.(N+1)dev
-  - [ ] Add the barnowl-1.(N+1)dev git tag
   - [ ] Push git git:
    - [ ] The RC commit
    - [ ] The configure.ac change on master
    - [ ] A release-1.N branch pointing at the RC commit
-   - [ ] the new git tags
-  - [ ] Update debian/changelog on the launchpad build using `dch -v 1.(N+1)`
-   - [ ] bzr branch lp:~barnowl/barnowl/packaging && cd packaging && dch -v 1.(N+1)
-   - [ ] Add relevant changelog entries such as "New upstream release" or
-         "Placeholder version number for daily builds."; fix your name and email
-         if necessary
-   - [ ] bzr commit && bzr push
   - [ ] Copy tarball into /mit/barnowl/web_scripts/dist
   - [ ] Send mail announcing the RC to barnowl-dev@mit.edu
 …
 * DOING THE ACTUAL RELEASE
   - [ ] Update the changelog and configure.ac for barnowl 1.N
-  - [ ] Copy the changelog changes to the master branch
   - [ ] run ./scripts/do-release
   - [ ] Do the locker build

editwin.c

-                      r7dcef03
+                      rf271129
   oe_excursion *excursions;
   void (*callback)(struct _owl_editwin *e, bool success);
+  void (*callback)(struct _owl_editwin*);
   void (*destroy_cbdata)(void *);
   void *cbdata;
 …
 static CALLER_OWN owl_editwin *owl_editwin_allocate(void)
+{
   owl_editwin *e = g_slice_new0(owl_editwin);
+  owl_editwin *e = g_new0(owl_editwin, 1);
   e->refcount = 1;
   return e;
 …
   oe_destroy_cbdata(e);
   g_slice_free(owl_editwin, e);
+  g_free(e);
+}
 …
+}
 void owl_editwin_set_callback(owl_editwin *e, void (*cb)(owl_editwin *, bool))
+void owl_editwin_set_callback(owl_editwin *e, void (*cb)(owl_editwin*))
+{
   e->callback = cb;
+}
 void (*owl_editwin_get_callback(owl_editwin *e))(owl_editwin *, bool)
+void (*owl_editwin_get_callback(owl_editwin *e))(owl_editwin*)
+{
   return e->callback;
 …
+}
+void owl_editwin_do_callback(owl_editwin *e, bool success)
+{
+  void (*cb)(owl_editwin *, bool);
+  cb = owl_editwin_get_callback(e);
+  if (!cb) {
+void owl_editwin_do_callback(owl_editwin *e) {
+  void (*cb)(owl_editwin*);
+  cb=owl_editwin_get_callback(e);
+  if(!cb) {
     owl_function_error("Internal error: No editwin callback!");
   } else {
+    cb(e, success);
+    /* owl_function_error("text: |%s|", owl_editwin_get_text(e)); */
+    cb(e);
+  }
+}
 …
 owl_editwin_excursion *owl_editwin_begin_excursion(owl_editwin *e)
+{
   owl_editwin_excursion *x = g_slice_new(owl_editwin_excursion);
+  owl_editwin_excursion *x = g_new(owl_editwin_excursion, 1);
   oe_save_excursion(e, x);
   return x;
 …
+{
   oe_restore_excursion(e, x);
   g_slice_free(owl_editwin_excursion, x);
+  g_free(x);
+}
 …
   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;
+  }

filter.c

-                      r7dcef03
+                      rf271129
   owl_filter *f;
   f = g_slice_new(owl_filter);
+  f = g_new(owl_filter, 1);
   f->name=g_strdup(name);
 …
   if(!argc) return NULL;
   fe = g_slice_new(owl_filterelement);
+  fe = g_new(owl_filterelement, 1);
   owl_filterelement_create(fe);
 …
 err:
   owl_filterelement_cleanup(fe);
   g_slice_free(owl_filterelement, fe);
+  g_free(fe);
   return NULL;
+}
 …
   op1 = owl_filter_parse_primitive_expression(argc-i, argv+i, &skip);
+  i += skip;
   if(!op1) goto err;
-  i += skip;
   while(i < argc) {
 …
     op2 = owl_filter_parse_primitive_expression(argc-i-1, argv+i+1, &skip);
     if(!op2) goto err;
     tmp = g_slice_new(owl_filterelement);
+    tmp = g_new(owl_filterelement, 1);
     if(!strcasecmp(argv[i], "and")) {
       owl_filterelement_create_and(tmp, op1, op2);
 …
   if(op1) {
     owl_filterelement_cleanup(op1);
     g_slice_free(owl_filterelement, op1);
+    g_free(op1);
+  }
   return NULL;
 …
+    }
     else {
       g_string_append_printf(out, "%i",f->bgcolor);
+      g_string_append_printf(out, "%i",f->fgcolor);
+    }
     g_string_append(out, " ");
 …
   if (f->root) {
     owl_filterelement_cleanup(f->root);
     g_slice_free(owl_filterelement, f->root);
+    g_free(f->root);
+  }
   if (f->name)
     g_free(f->name);
   g_slice_free(owl_filter, f);
+}
+  g_free(f);
+}

filterelement.c

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

filterproc.c

-                      r7155955
+                      rf271129
 #include "filterproc.h"
+#include "owl.h"
 #include <sys/wait.h>
-#include <fcntl.h>
-#include <glib.h>
 #include <poll.h>
-#include <string.h>
-#include <unistd.h>
+/* Even in case of error, send_receive is responsible for closing wfd
+ * (to EOF the child) and rfd (for consistency). */
+static int send_receive(int rfd, int wfd, const char *out, char **in)
+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); wfd = -1;
+        close(wfd);
         out = NULL;
+      }
 …
+  }
-  if (wfd >= 0) close(wfd);
-  close(rfd);
   *in = g_string_free(str, err < 0);
   return err;
+}
 int call_filter(const char *const *argv, const char *in, char **out, int *status)
+int call_filter(const char *prog, const char *const *argv, const char *in, char **out, int *status)
+{
+  int err;
+  GPid child_pid;
+  int child_stdin, child_stdout;
+  int err = 0;
+  pid_t pid;
+  int rfd[2];
+  int wfd[2];
+  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;
+  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);
+    }
+  }
+  err = send_receive(child_stdout, child_stdin, in, out);
+  if (err == 0) {
+    waitpid(child_pid, status, 0);
+  }
+ out_close_all:
+  close(wfd[0]);
+  close(wfd[1]);
+ out_close_rfd:
+  close(rfd[0]);
+  close(rfd[1]);
+ out:
   return err;
+}

filterproc.h

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

functions.c

-                      r7dcef03
+                      r0071c88
 void owl_function_show_license(void)
+{
+  char *text = g_strdup_printf(
+    "BarnOwl version %s\n"
+  const char *text;
+  text=""
+    "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"
 …
     "WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE\n"
     "OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN\n"
+    "IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n",
+    version);
+    "IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n";
   owl_function_popless_text(text);
-  g_free(text);
+}
 …
   owl_message *m;
   m=g_slice_new(owl_message);
+  m=g_new(owl_message, 1);
   owl_message_create_admin(m, header, body);
 …
   /* do followlast if necessary */
   if (owl_global_should_followlast(&g)) owl_function_lastmsg();
+  if (owl_global_should_followlast(&g)) owl_function_lastmsg_noredisplay();
   /* redisplay etc. */
 …
 void owl_function_add_outgoing_zephyrs(const owl_zwrite *z)
+{
   if (z->cc && owl_zwrite_is_personal(z)) {
+  if (z->cc || owl_zwrite_get_numrecips(z) == 0) {
     /* create the message */
     owl_message *m = g_slice_new(owl_message);
+    owl_message *m = g_new(owl_message, 1);
     owl_message_create_from_zwrite(m, z, owl_zwrite_get_message(z), 0);
 …
     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 */
       m = g_slice_new(owl_message);
+      owl_message *m = g_new(owl_message, 1);
       owl_message_create_from_zwrite(m, z, owl_zwrite_get_message(z), i);
 …
   if (!owl_global_is_aimloggedin(&g)) return(NULL);
   m=g_slice_new(owl_message);
+  m=g_new(owl_message, 1);
   owl_message_create_aim(m,
                          owl_global_get_aim_screenname(&g),
 …
   /* create the message */
   m=g_slice_new(owl_message);
+  m=g_new(owl_message, 1);
   owl_message_create_loopback(m, body);
   owl_message_set_direction_out(m);
 …
+}
 owl_editwin *owl_function_start_edit_win(const char *line)
+void owl_function_start_edit_win(const char *line, void (*callback)(owl_editwin *), void *data, void (*cleanup)(void *))
+{
   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");
   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);
+  owl_function_start_edit_win(z->zwriteline,
+                              &owl_callback_zwrite,
+                              z, (void(*)(void*))owl_zwrite_delete);
+}
 void owl_function_aimwrite_setup(const char *to)
+{
-  owl_editwin *e;
   /* TODO: We probably actually want an owl_aimwrite object like
    * owl_zwrite. */
   char *line = g_strdup_printf("aimwrite %s", to);
   owl_function_write_setup("message");
+  e = owl_function_start_edit_win(line);
+  owl_editwin_set_cbdata(e, g_strdup(to), g_free);
+  owl_editwin_set_callback(e, &owl_callback_aimwrite);
+  owl_function_start_edit_win(line,
+                              &owl_callback_aimwrite,
+                              g_strdup(to),
+                              g_free);
   g_free(line);
+}
 …
 void owl_function_loopwrite_setup(void)
+{
-  owl_editwin *e;
   owl_function_write_setup("message");
+  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_function_start_edit_win("loopwrite",
+                              &owl_callback_loopwrite,
+                              NULL, NULL);
+}
+void owl_callback_zwrite(owl_editwin *e) {
   owl_zwrite *z = owl_editwin_get_cbdata(e);
   owl_function_zwrite(z, owl_editwin_get_text(e));
 …
   owl_function_makemsg("Waiting for ack...");
+  /* create the outgoing message */
+  owl_function_add_outgoing_zephyrs(z);
+  /* If it's personal */
+  if (owl_zwrite_is_personal(z)) {
+    /* create the outgoing message */
+    owl_function_add_outgoing_zephyrs(z);
+  }
+}
 #else
 …
   zcrypt = g_build_filename(owl_get_bindir(), "zcrypt", NULL);
   argv[0] = zcrypt;
+  argv[0] = "zcrypt";
   argv[1] = "-E";
   argv[2] = "-c"; argv[3] = owl_zwrite_get_class(z);
 …
   argv[6] = NULL;
   rv = call_filter(argv, owl_zwrite_get_message(z), &cryptmsg, &status);
+  rv = call_filter(zcrypt, argv, owl_zwrite_get_message(z), &cryptmsg, &status);
   g_free(zcrypt);
 …
   owl_function_makemsg("Waiting for ack...");
+  /* 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. */
+  /* 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 */
   g_free(cryptmsg);
+  g_free(old_msg);
+}
+void owl_callback_aimwrite(owl_editwin *e, bool success)
+{
+  if (!success) return;
+}
+void owl_callback_aimwrite(owl_editwin *e) {
   char *to = owl_editwin_get_cbdata(e);
   owl_function_aimwrite(to, owl_editwin_get_text(e), true);
 …
+}
+void owl_callback_loopwrite(owl_editwin *e, bool success)
+{
+  if (!success) return;
+void owl_callback_loopwrite(owl_editwin *e) {
   owl_function_loopwrite(owl_editwin_get_text(e));
+}
 …
   /* create a message and put it on the message queue.  This simulates
    * an incoming message */
   min=g_slice_new(owl_message);
+  min=g_new(owl_message, 1);
   mout=owl_function_make_outgoing_loopback(msg);
 …
+}
 void owl_function_lastmsg(void)
+void owl_function_lastmsg_noredisplay(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)
+{
   if (unsuball())
     owl_function_makemsg("Unsubscribed from all messages.");
+  unsuball();
+  owl_function_makemsg("Unsubscribed from all messages.");
+}
 …
 void owl_function_loadsubs(const char *file)
+{
+  int ret, ret2, ret3;
+  int ret, ret2;
+  const char *foo;
   char *path;
 …
   /* for backwards compatibility for now */
+  ret2 = owl_zephyr_loaddefaultsubs();
+  ret3 = owl_zephyr_loadbarnowldefaultsubs();
+  ret2=owl_zephyr_loaddefaultsubs();
   if (!owl_context_is_interactive(owl_global_get_context(&g))) return;
+  if (ret == 0 && ret2 == 0 && ret3 == 0) {
+  foo=file?file:"file";
+  if (ret==0 && ret2==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", file ? file : "file");
   } else if (ret2 == -1) {
+  } else if (ret==-1) {
+    owl_function_error("Could not read %s", foo);
+  } else {
     owl_function_error("Error subscribing to messages");
-  } else {
-    owl_function_error("Error subscribing to instanced personals");
+  }
+}
 …
+}
+void owl_callback_aimlogin(owl_editwin *e, bool success)
+{
+  if (!success) return;
+void owl_callback_aimlogin(owl_editwin *e) {
   char *user = owl_editwin_get_cbdata(e);
   owl_function_aimlogin(user,
 …
   /* owl_aim_set_awaymsg(""); */
   owl_function_makemsg("AIM away off");
+}
-bool owl_function_is_away(void)
+{
-  return owl_global_is_zaway(&g) ||
-         owl_global_is_aaway(&g) ||
-         owl_perlconfig_perl_call_bool("BarnOwl::Hooks::_get_is_away", 0, NULL);
+}
 …
 void owl_function_about(void)
+{
   char *text = g_strdup_printf(
     "This is BarnOwl version %s.\n\n"
+  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"
     "maintained by Alejandro Sedeno and Nelson Elhage at the\n"
 …
     "This program is free software. You can redistribute it and/or\n"
     "modify under the terms of the Sleepycat License. Use the \n"
+      "':show license' command to display the full license\n",
+      version);
+  owl_function_popless_text(text);
+  g_free(text);
+    "':show license' command to display the full license\n"
+  );
+}
 …
       char *tmpbuff, *tmpbuff2;
       int i, fields;
-      const char *f;
       if (!owl_message_is_pseudo(m)) {
 …
         owl_fmtext_append_normal(&fm, "\n");
         owl_fmtext_appendf_normal(&fm, "  Port      : %i\n", ntohs(n->z_port));
-        owl_fmtext_appendf_normal(&fm, "  Charset   : %s\n", owl_zephyr_get_charsetstr(n));
         owl_fmtext_appendf_normal(&fm, "  Auth      : %s\n", owl_zephyr_get_authstr(n));
 …
         owl_fmtext_appendf_normal(&fm, "  Fields    : %i\n", fields);
+        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);
+        for (i = 0; i < fields; i++) {
+          tmpbuff = owl_zephyr_get_field_as_utf8(n, i + 1);
           tmpbuff2 = owl_text_indent(tmpbuff, 14, false);
           owl_fmtext_appendf_normal(&fm, "  Field %i   : %s\n", i + 1, tmpbuff2);
 …
   owl_fmtext_append_normal(&fm, "  Version: ");
   owl_fmtext_append_normal(&fm, version);
+  owl_fmtext_append_normal(&fm, OWL_VERSION_STRING);
   owl_fmtext_append_normal(&fm, "\n");
 …
+}
+void owl_callback_command(owl_editwin *e, bool success)
+{
+  if (!success) return;
+void owl_callback_command(owl_editwin *e)
+{
   char *rv;
   const char *line = owl_editwin_get_text(e);
 …
+}
 owl_editwin *owl_function_start_command(const char *line)
+void 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;
+}
+owl_editwin *owl_function_start_question(const char *line)
+}
+CALLER_OWN owl_editwin *owl_function_start_question(const char *line)
+{
   owl_editwin *tw;
 …
+}
 owl_editwin *owl_function_start_password(const char *line)
+CALLER_OWN owl_editwin *owl_function_start_password(const char *line)
+{
   owl_editwin *tw;
 …
   f = owl_filter_new(argv[1], argc-2, argv+2);
   if (f == NULL) {
     owl_function_error("Invalid filter: %s", argv[1]);
+    owl_function_error("Invalid filter");
     return false;
+  }
 …
   while (zaldptr) {
     ZFreeALD(zaldptr->data);
     g_slice_free(ZAsyncLocateData_t, zaldptr->data);
+    g_free(zaldptr->data);
     zaldptr = g_list_next(zaldptr);
+  }
 …
     for (i = 0; i < anyone->len; i++) {
       user = anyone->pdata[i];
       zald = g_slice_new(ZAsyncLocateData_t);
+      zald = g_new(ZAsyncLocateData_t, 1);
       if (ZRequestLocations(zstr(user), zald, UNACKED, ZAUTH) == ZERR_NONE) {
         *zaldlist = g_list_append(*zaldlist, zald);
       } else {
         g_slice_free(ZAsyncLocateData_t, zald);
+        g_free(zald);
+      }
+    }

global.c

-                      r7dcef03
+                      r9078f69
   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();
 …
   g->starttime=time(NULL); /* assumes we call init only a start time */
   g->lastinputtime=g->starttime;
-  g->last_wakeup_time = g->starttime;
   g->newmsgproc_pid=0;
 …
   g_free(cd);
   g->msglist = owl_messagelist_new();
+  owl_messagelist_create(&(g->msglist));
   _owl_global_init_windows(g);
 …
   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 */
   g->mw = owl_mainwin_new(g->mainpanel.recwin);
+  owl_mainwin_init(&(g->mw), g->mainpanel.recwin);
   owl_msgwin_init(&(g->msgwin), g->mainpanel.msgwin);
   owl_sepbar_init(g->mainpanel.sepwin);
 …
 /* 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));
+}
 …
+}
-void owl_global_wakeup(owl_global *g)
+{
-  if (time(NULL) - g->last_wakeup_time >= 1) {
-    g_free(owl_perlconfig_execute("BarnOwl::Hooks::_wakeup()"));
-    g->last_wakeup_time = time(NULL);
+  }
+}
 /* viewwin */
 …
   e->g->filterlist = g_list_remove(e->g->filterlist, e->f);
   owl_filter_delete(e->f);
   g_slice_free(owl_global_filter_ent, e);
+  g_free(e);
+}
 void owl_global_add_filter(owl_global *g, owl_filter *f) {
   owl_global_filter_ent *e = g_slice_new(owl_global_filter_ent);
+  owl_global_filter_ent *e = g_new(owl_global_filter_ent, 1);
   e->g = g;
   e->f = f;
 …
   } 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 ^mail$ or class ^filsrv$" },
+    { "reply-lockout", "class ^mail$" },
     { "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(owl_global_get_interrupt_lock(g));
+  g_mutex_lock(g->interrupt_lock);
   g->interrupt_count++;
   g_mutex_unlock(owl_global_get_interrupt_lock(g));
+  g_mutex_unlock(g->interrupt_lock);
+}
 bool owl_global_take_interrupt(owl_global *g) {
   bool ans = false;
   g_mutex_lock(owl_global_get_interrupt_lock(g));
+  g_mutex_lock(g->interrupt_lock);
   if (g->interrupt_count > 0) {
     ans = true;
     g->interrupt_count--;
+  }
   g_mutex_unlock(owl_global_get_interrupt_lock(g));
+  g_mutex_unlock(g->interrupt_lock);
   return ans;
+}

help.c

-                      r8258ea5
+                      rf271129
      "    : , M-x       Enter command mode\n"
      "\n"
      "    /             Forward search\n"
+     "    /             Foward search\n"
      "    ?             Reverse search\n"
      "\n\n"
 …
      "    unsuball      Unsubscribe from all zephyr classes\n"
      "    load-subs     Load zephyr subscriptions from a file\n"
      "    zpunt         Suppress messages from a zephyr triplet\n"
+     "    zpunt         Supress messages from a zephyr triplet\n"
      "    zlog          Send a login or logout notification\n"
      "    zlist         Print a list of zephyr buddies logged in\n"

keybinding.c

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

keymap.c

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

libfaim/Makefile.am

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

logging.c

-                      r7dcef03
+                      rf271129
     g_free(msg->message);
     g_free(msg->filename);
     g_slice_free(owl_log_entry, msg);
+    g_free(msg);
+  }
+}
 …
+{
   owl_log_entry *log_msg = NULL;
   log_msg = g_slice_new(owl_log_entry);
+  log_msg = g_new(owl_log_entry,1);
   log_msg->message = g_strdup(buffer);
   log_msg->filename = g_strdup(filename);
 …
    * owl_log_shouldlog_message(void)
    */
   m = g_slice_new(owl_message);
+  m = g_new(owl_message, 1);
   /* recip_index = 0 because there can only be one recipient anyway */
   owl_message_create_from_zwrite(m, zw, text, 0);
 …
 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_cflags_warn_all.m4

-                      re9b4a2c
+                      r378ede7
 #    - $3 action-if-found : add value to shellvariable
 #    - $4 action-if-not-found : nothing
+#
-#   NOTE: These macros depend on AX_APPEND_FLAG.
+#
 # LICENSE
 …
 #   exception to the GPL to apply to your modified version as well.
 #serial 14
+#serial 10
 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_DEFUN([AX_CFLAGS_WARN_ALL],[dnl
+AS_VAR_PUSHDEF([FLAGS],[CFLAGS])dnl
+AS_VAR_PUSHDEF([VAR],[ac_cv_cflags_warn_all])dnl
 AC_CACHE_CHECK([m4_ifval($1,$1,FLAGS) for maximum warnings],
 VAR,[VAR="no, unknown"
+ac_save_[]FLAGS="$[]FLAGS"
+ AC_LANG_PUSH([C])
+ 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_COMPILE_IFELSE([AC_LANG_PROGRAM],
+                     [VAR=`echo $ac_arg | sed -e 's,.*% *,,'` ; break])
+done
+ FLAGS="$ac_save_[]FLAGS"
+ AC_LANG_POP([C])
+])
+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 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],[ax_cv_cxxflags_warn_all])dnl
+AC_CACHE_CHECK([m4_ifval($1,$1,FLAGS) for maximum warnings],
+VAR,[VAR="no, unknown"
+ AC_LANG_PUSH([C++])
+ 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_COMPILE_IFELSE([AC_LANG_PROGRAM],
+                     [VAR=`echo $ac_arg | sed -e 's,.*% *,,'` ; break])
+done
+ FLAGS="$ac_save_[]FLAGS"
+ AC_LANG_POP([C++])
+])
+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 the only difference - the LANG selection... and the default FLAGS
+AC_DEFUN([AX_FCFLAGS_WARN_ALL],[dnl
+AS_VAR_PUSHDEF([FLAGS],[FCFLAGS])dnl
+AS_VAR_PUSHDEF([VAR],[ax_cv_fcflags_warn_all])dnl
+AC_CACHE_CHECK([m4_ifval($1,$1,FLAGS) for maximum warnings],
+VAR,[VAR="no, unknown"
+ AC_LANG_PUSH([Fortran])
+ ac_save_[]FLAGS="$[]FLAGS"
 for ac_arg dnl
 in "-warn all  % -warn all"   dnl Intel
 …
                      [VAR=`echo $ac_arg | sed -e 's,.*% *,,'` ; break])
 done
+FLAGS="$ac_save_[]FLAGS"
+ FLAGS="$ac_save_[]FLAGS"
+ AC_LANG_POP([Fortran])
 ])
-AS_VAR_POPDEF([FLAGS])dnl
-AC_REQUIRE([AX_APPEND_FLAG])
 case ".$VAR" in
      .ok|.ok,*) m4_ifvaln($3,$3) ;;
+   .|.no|.no,*) m4_default($4,[m4_ifval($2,[AX_APPEND_FLAG([$2], [$1])])]) ;;
+   *) m4_default($3,[AX_APPEND_FLAG([$VAR], [$1])]) ;;
+   .|.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
+])dnl AX_FLAGS_WARN_ALL
+AS_VAR_POPDEF([FLAGS])dnl
+])
 dnl  implementation tactics:
 dnl   the for-argument contains a list of options. The first part of
 …
 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/pkg.m4

-                      r13a39ae8
+                      r650fb2c
 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

-                      r7dcef03
+                      r099597c
 static void owl_mainwin_resized(owl_window *w, void *user_data);
 CALLER_OWN owl_mainwin *owl_mainwin_new(owl_window *window)
+void owl_mainwin_init(owl_mainwin *mw, owl_window *window)
+{
-  owl_mainwin *mw = g_slice_new(owl_mainwin);
   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

-                      r7dcef03
+                      r0071c88
   if(pair ==  NULL) {
     pair = g_slice_new(owl_pair);
+    pair = g_new(owl_pair, 1);
     owl_pair_create(pair, attrname, NULL);
     g_ptr_array_add(m->attributes, pair);
 …
+  /* set the "isprivate" attribute if it's a private zephyr. */
+  if (owl_zwrite_recip_is_personal(n->z_recipient)) {
+  /* 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 != '@') {
     owl_message_set_isprivate(m);
+  }
 …
   if (owl_global_is_zcrypt(&g) && !strcasecmp(n->z_opcode, "crypt")) {
     const char *argv[] = {
       NULL,
+      "zcrypt",
       "-D",
       "-c", owl_message_get_class(m),
 …
       NULL
     };
     char *out = NULL;
+    char *out;
     int rv;
     int status;
 …
     zcrypt = g_build_filename(owl_get_bindir(), "zcrypt", NULL);
+    argv[0] = zcrypt;
+    rv = call_filter(argv, owl_message_get_body(m), &out, &status);
+    rv = call_filter(zcrypt, argv, owl_message_get_body(m), &out, &status);
     g_free(zcrypt);
 …
+      }
       owl_message_set_body(m, 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);
+      g_free(out);
+    } else if(out) {
+      g_free(out);
+    }
+  }
 …
     p = m->attributes->pdata[i];
     g_free(owl_pair_get_value(p));
     g_slice_free(owl_pair, p);
+    g_free(p);
+  }
 …
+{
   owl_message_cleanup(m);
   g_slice_free(owl_message, m);
+}
+  g_free(m);
+}

messagelist.c

r7dcef03	rf271129
1	1	#include "owl.h"
2	2
3		~~CALLER_OWN owl_messagelist *owl_messagelist_new(void~~)
	3	void owl_messagelist_create(owl_messagelist *ml)
4	4	{
5		~~owl_messagelist *ml = g_slice_new(owl_messagelist);~~
6	5	ml->list = g_ptr_array_new();
7		~~return ml;~~
8	6	}
9	7
10		void owl_messagelist_~~delete~~(owl_messagelist *ml, bool free_messages)
	8	void owl_messagelist_cleanup(owl_messagelist *ml, bool free_messages)
11	9	{
12	10	if (free_messages)
13	11	g_ptr_array_foreach(ml->list, (GFunc)owl_message_delete, NULL);
14	12	g_ptr_array_free(ml->list, true);
15		~~g_slice_free(owl_messagelist, ml);~~
16	13	}
17	14

owl.c

-                      r441fd42
+                      rf271129
 #include <sys/stat.h>
 #include <locale.h>
-#include <unistd.h>
 #if OWL_STDERR_REDIR
 …
 } owl_options;
 void usage(FILE *file)
+void usage(void)
+{
   fprintf(file, "BarnOwl version %s\n", version);
   fprintf(file, "Usage: barnowl [-n] [-d] [-D] [-v] [-h] [-c <configfile>] [-s <confdir>] [-t <ttyname>]\n");
   fprintf(file, "  -n,--no-subs        don't load zephyr subscriptions\n");
   fprintf(file, "  -d,--debug          enable debugging\n");
   fprintf(file, "  -v,--version        print the BarnOwl version number and exit\n");
   fprintf(file, "  -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");
+  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");
+}
 …
       break;
     case 'v':
       printf("This is BarnOwl version %s\n", version);
+      printf("This is BarnOwl version %s\n", OWL_VERSION_STRING);
       exit(0);
     case 'h':
-      usage(stdout);
-      exit(0);
     default:
       usage(stderr);
+      usage();
       exit(1);
+    }
 …
     /* follow the last message if we're supposed to */
     if (followlast)
       owl_function_lastmsg();
+      owl_function_lastmsg_noredisplay();
     /* do the newmsgproc thing */
 …
   owl_global_set_lastinputtime(&g, time(NULL));
-  owl_global_wakeup(&g);
   ret = owl_keyhandler_process(owl_global_get_keyhandler(&g), j);
   if (ret!=0 && ret!=1) {
 …
   if (0 != pipe(pipefds)) {
     perror("pipe");
     owl_function_debugmsg("stderr_replace: pipe FAILED");
+    owl_function_debugmsg("stderr_replace: pipe FAILED\n");
     return -1;
+  }
     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));
+    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));
     perror("dup2");
     return -1;
 …
 #if OWL_STDERR_REDIR
   /* Do this only after we've started curses up... */
+  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);
+  }
+  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
 …
   /* welcome message */
   owl_function_debugmsg("startup: creating splash message");
   char *welcome = g_strdup_printf(
+  owl_function_adminmsg("",
     "-----------------------------------------------------------------------\n"
     "Welcome to BarnOwl version %s.\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"
 …
     "                                                                 OvO   \n"
     "Please report any bugs or suggestions to bug-barnowl@mit.edu    (   )  \n"
+    "-----------------------------------------------------------------m-m---\n",
+    version);
+  owl_function_adminmsg("", welcome);
+  g_free(welcome);
+  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);
+    "-----------------------------------------------------------------m-m---\n"
+  );
   /* process the 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

-                      rca1fb26a
+                      rb9517cf
 #define INC_BARNOWL_OWL_H
 #include <config.h>
+#include "config.h"
 #include "compat/compat.h"
 …
 /* Perl and curses don't play nice. */
 #ifdef OWL_PERL
 typedef struct _owl_fake_WINDOW WINDOW;
 typedef struct _owl_fake_PANEL PANEL;
+typedef void WINDOW;
+typedef void PANEL;
 /* logout is defined in FreeBSD. */
 #define logout logout_
 …
 #include "XSUB.h"
 #else
 typedef struct _owl_fake_SV SV;
 typedef struct _owl_fake_AV AV;
 typedef struct _owl_fake_HV HV;
+typedef void SV;
+typedef void AV;
+typedef void HV;
 #endif
 #include "window.h"
+extern const char *version;
+#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 */
 /* Feature that is being tested to redirect stderr through a pipe.
 …
   char *name;
   int   type;  /* OWL_VARIABLE_* */
+  char *default_str;            /* the default value as a string */
+  char *validsettings;          /* documentation of valid settings */
+  void *pval_default;  /* for types other and string */
+  int   ival_default;  /* for types int and bool     */
+  const char *validsettings;    /* documentation of valid settings */
   char *summary;                /* summary of usage */
   char *description;            /* detailed description */
+  bool takes_on_off;            /* allow passing on/off in argument-less set/unset */
+  GClosure *set_fromstring_fn;
+  void *val;                    /* current value */
+  int  (*validate_fn)(const struct _owl_variable *v, const void *newval);
+                                /* returns 1 if newval is valid */
+  int  (*set_fn)(struct _owl_variable *v, const void *newval);
                                 /* 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;
+                                 * 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... */
+  CALLER_OWN char *(*get_tostring_fn)(const struct _owl_variable *v, const void *val);
                                 /* 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 */
+  GCallback set_fn;
+                                /* sets the variable to a value
+                                 * of the appropriate type.
+                                 * unless documented, this
+                                 * should make a copy.
+                                 * returns 0 on success. */
+                                 * caller must free the result */
+  void (*delete_fn)(struct _owl_variable *v);
+                                /* frees val as needed */
 } owl_variable;
 typedef struct _owl_input {
 …
   char *name;
   owl_filter *filter;
   owl_messagelist *ml;
+  owl_messagelist ml;
   const owl_style *style;
   int cachedmsgid;
 …
 typedef struct _owl_global {
   owl_mainwin *mw;
+  owl_mainwin mw;
   owl_popwin *pw;
   owl_msgwin msgwin;
 …
   int curmsg_vert_offset;
   owl_view current_view;
   owl_messagelist *msglist;
+  owl_messagelist msglist;
   WINDOW *input_pad;
   owl_mainpanel mainpanel;
 …
   time_t starttime;
   time_t lastinputtime;
-  time_t last_wakeup_time;
   char *startupargs;
   int nextmsgid;
 …
   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

-                      r92ffd89
+                      rf271129
 #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]))); \
+  } \
+}
+#define OWL_PERL_VOID_CALL (void)POPs;
 /*
  * This macro defines a convenience wrapper around the boilerplate of
  * the perlcall methods.
+ * calling a method on a perl object (SV*) from C.
+ *
  * Arguments are
+ * * 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
+ * * 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
+ *
  * See also: `perldoc perlcall', `perldoc perlapi'
  */
+#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); \
+#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();                                                   \
+    } \
+    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 { \
+      owl_function_error(err, SvPV_nolen(ERRSV)); \
+      if (!discardret) (void)POPs; \
+      sv_setsv(ERRSV, &PL_sv_undef); \
+      ret; \
     } \
+  } else if (!discardret) { \
+    ret; \
+  } \
+  PUTBACK; \
+  FREETMPS; \
+  LEAVE; \
+    PUTBACK; \
+    FREETMPS; \
+    LEAVE; \
+}

perl/Makefile.am

-                      ra870319
+                      r10557e6
 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

-                      recd4edf
+                      ra130fc5
 use base qw(Exporter);
+our @EXPORT_OK = qw(command getcurmsg getnumcols getnumlines getidletime
+                    register_idle_watcher unregister_idle_watcher
+our @EXPORT_OK = qw(command getcurmsg getnumcols 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 List::Util qw(max);
-use Tie::RefHash;
 =head1 NAME
 …
 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
 …
 Enqueue a message in the BarnOwl message list, logging it and
 processing it appropriately. C<MESSAGE> should be an instance of
+BarnOwl::Message or a subclass.
+BarnOwl::Message or a subclass.  Returns the queued message.  This
+is useful for, e.g., deleting a message from the message list.
 =head2 admin_message HEADER BODY
 …
 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
+=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.
-=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
-=head2 start_password PROMPT CALLBACK
 =head2 start_edit_win PROMPT CALLBACK
+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;
+        });
+}
+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.
 =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
 …
 our @all_commands;
+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";
+    }
+}
+if(!$configfile && -f $ENV{HOME} . "/.barnowlconf") {
+    $configfile = $ENV{HOME} . "/.barnowlconf";
+}
+$configfile ||= $ENV{HOME}."/.owlconf";
 # populate global variable space for legacy owlconf files
 …
 =head2 new_variable_string NAME [{ARGS}]
+=head2 new_variable_enum NAME [{ARGS}]
+Add a new owl variable, either an int, a bool, a string, or an enum with the
+Add a new owl variable, either an int, a bool, or a string, with the
 specified name.
+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:
+ARGS 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 {
+    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,
+        });
+    unshift @_, \&BarnOwl::Internal::new_variable_int, 0;
+    goto \&_new_variable;
+}
 sub new_variable_bool {
+    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,
+        });
+    unshift @_, \&BarnOwl::Internal::new_variable_bool, 0;
+    goto \&_new_variable;
+}
 sub new_variable_string {
+    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 {
+    unshift @_, \&BarnOwl::Internal::new_variable_string, "";
+    goto \&_new_variable;
+}
+sub _new_variable {
+    my $func = shift;
+    my $default_default = shift;
     my $name = shift;
     my $args = shift || {};
     my %args = (
         summary => "",
+        summary     => "",
         description => "",
+        takes_on_off => 0,
+        validsettings => "<string>",
+        default     => $default_default,
         %{$args});
+    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);
+    $func->($name, $args{default}, $args{summary}, $args{description});
+}
 …
+}
-=head3 register_idle_watcher %ARGS
-Call a callback whenever the amount of time the user becomes idle or comes
-back from being idle.
-You must include the following parameters:
-=over 4
-=item name
-The name given to the idle watcher
-=item after
-How long the user must be idle, in seconds, before the callback is called.
-If the value is too small, you may have spurious or inaccurate calls.
-(The current lower limit is about 1 second.)
-=item callback
-The Perl subroutine that gets called when the user has been idle for C<AFTER>
-seconds, or comes back from being idle.  The subroutine is passed one parameter,
-which is true if the user is currently idle, and false otherwise.
-=back
-This method returns a unique identifier which may be passed to
-L<BarnOwl::unregister_idle_watcher>.
-=cut
-=head3 unregister_idle_watcher UNIQUE_ID [...]
-Removed and returns the idle watcher specified by C<UNIQUE_ID>.
-You may specify multiple unique ids.
-=cut
-my %idle_watchers;
-tie %idle_watchers, 'Tie::RefHash';
-$BarnOwl::Hooks::wakeup->add(sub {
-        foreach my $idle_watcher (values %idle_watchers) {
-            _wakeup_idle_watcher($idle_watcher);
+        }
-    });
-sub _wakeup_idle_watcher {
-    my ($idle_watcher, $offset) = @_;
-    $offset = 0 unless defined $offset;
-    # go unidle
-    $idle_watcher->{idle_timer}->stop if $idle_watcher->{idle_timer};
-    undef $idle_watcher->{idle_timer};
-    $idle_watcher->{callback}->(0) if $idle_watcher->{is_idle};
-    $idle_watcher->{is_idle} = 0;
-    # queue going idle
-    $idle_watcher->{idle_timer} = BarnOwl::Timer->new({
-        name  => $idle_watcher->{name},
-        after => $idle_watcher->{after} - $offset,
-        cb    => sub {
-            $idle_watcher->{is_idle} = 1;
-            $idle_watcher->{callback}->(1);
+        }
-    });
+}
-sub register_idle_watcher {
-    my %args = (@_);
-    $idle_watchers{\%args} = \%args;
-    _wakeup_idle_watcher(\%args, BarnOwl::getidletime); # make sure to queue up the idle/unidle events from this idle watcher
-    return \%args;
+}
-sub unregister_idle_watcher {
-    my ($id) = @_;
-    $idle_watchers{$id}->{idle_timer}->stop if $idle_watchers{$id}->{idle_timer};
-    return delete $idle_watchers{$id};
+}
 # Stub for owl::startup / BarnOwl::startup, so it isn't bound to the
 # startup command. This may be redefined in a user's configfile.

perl/lib/BarnOwl/Complete/Client.pm

-                      r4626016
+                      r58f4fb2
 my %show = (
+    information => undef,
     colors      => undef,
     commands    => undef,
 …
 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(unstartup => \&complete_startup);
+BarnOwl::Completion::register_completer(startup => \&complete_startup);
 BarnOwl::Completion::register_completer(bindkey => \&complete_bindkey);
 BarnOwl::Completion::register_completer(print   => \&complete_print);

perl/lib/BarnOwl/Complete/Zephyr.pm

re6e7842	r3e8625f
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);~~
68	66
69	67	BarnOwl::Completion::register_completer(unsub => \&complete_unsub);

perl/lib/BarnOwl/Hooks.pm

-                      r120dac7
+                      rb8a3e00
 Called before BarnOwl shutdown
-=item $wakeup
-Called, at most once per second, on user input
 =item $receiveMessage
 …
 from every function registered with this hook will be appended and
 displayed in a popup window, with zephyr formatting parsed.
-=item $awayOn
-Called, for all protocol handlers, to go away, with the away message,
-if any.
-=item $awayOff
-Called, for all protocol handlers, to come back from away.
-=item $getIsAway
-Called to check away status for all protocol handlers.  Protocol
-handlers should return a true value if any account of the user is away
-for the given protocol, and a false value otherwise.
 =item $getQuickstart
 …
 our @EXPORT_OK = qw($startup $shutdown
-                    $wakeup
                     $receiveMessage $newMessage
                     $mainLoop $getBuddyList
-                    $awayOn $awayOff $getIsAway
                     $getQuickstart);
 …
 our $startup = BarnOwl::Hook->new;
 our $shutdown = BarnOwl::Hook->new;
-our $wakeup = BarnOwl::Hook->new;
 our $receiveMessage = BarnOwl::Hook->new;
 our $newMessage = BarnOwl::Hook->new;
 …
 our $getBuddyList = BarnOwl::Hook->new;
 our $getQuickstart = BarnOwl::Hook->new;
-our $awayOn = BarnOwl::Hook->new;
-our $awayOff = BarnOwl::Hook->new;
-our $getIsAway = BarnOwl::Hook->new;
 # Internal startup/shutdown routines called by the C code
 …
+}
-sub _wakeup {
-    $wakeup->run;
+}
 sub _receive_msg {
     my $m = shift;
 …
 sub _get_quickstart {
     return join("\n", $getQuickstart->run);
+}
-sub _away_on {
-    $awayOn->run(@_);
+}
-sub _away_off {
-    $awayOff->run();
+}
-sub _get_is_away {
-    my @is_away = grep { $_ } $getIsAway->run();
-    return scalar @is_away;
+}

perl/lib/BarnOwl/Message.pm

r0adbce1	ra130fc5
51	51	sub is_ping { return 0; }
52	52	sub is_mail { return 0; }
53		sub is_personal { return ~~BarnOwl::message_matches_filter(shift, "personal")~~; }
	53	sub is_personal { return shift->is_private; }
54	54	sub class { return undef; }
55	55	sub instance { return undef; }

perl/lib/BarnOwl/Message/Zephyr.pm

-                      r0adbce1
+                      redd0be7
     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 =~ /^@/) {
+        if ($self->recipient eq '*' || $self->recipient eq '') {
+            $to = '';
+        } elsif ($self->recipient =~ /^@/) {
             $to = $self->recipient;
         } else {

perl/lib/BarnOwl/ModuleLoader.pm

-                      rf34728b
+                      rf544216
+}
-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

-                      rebc6f77
+                      r5738650
+        }
         $header .= '@b{' . maybe($m->pretty_sender) . '}';
-        if (defined($m->realm) && $m->realm ne BarnOwl::zephyr_getrealm()) {
-            $header .= ' {' . $self->humanize($m->realm, 1) . '}';
+        }
+    }
 …
     my $self = shift;
     my $m = shift;
+    my $sender = $self->humanize($m->long_sender, 1);
+    my $sender = $m->long_sender;
+    $sender =~ s/\n.*$//s;
     if (BarnOwl::getvar('colorztext') eq 'on') {
       return "  (" . $sender . '@color[default]' . ")";

perl/lib/BarnOwl/Zephyr.pm

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

perl/lib/Module/Install/BarnOwl.pm

-                      re4b8f93
+                      rb8a3e00
     my $class = ref $self;
-    my $srcdir = $ENV{BARNOWL_SRCDIR} || '.';
     $self->name("BarnOwl-Module-$name");
+    $self->all_from("$srcdir/lib/BarnOwl/Module/$name.pm");
+    $self->makemaker_args(PMLIBDIRS => ["$srcdir/lib"],
+                          PMLIBPARENTDIRS => ["$srcdir/lib"]);
+    $self->all_from("lib/BarnOwl/Module/$name.pm");
     $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

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

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

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

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

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

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

-                      r41064be
+                      rb8a3e00
               . "configure [<muc>]\n"
               . "            Configures a MUC.\n"
               . "            Necessary to initialize a new MUC.\n"
+              . "            Necessary to initalize 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"
 …
+    {
         my @answer = $packet->answer;
         return $answer[0]->target, $answer[0]->port if @answer;
+        return $answer[0]{target}, $answer[0]{port};
+    }
 …
+}
-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/Net/Jabber/Component.pm

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

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

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

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

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

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

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

perl/modules/Makefile.am

-                      re4b8f93
+                      r1fd469d4
 MODULES = Jabber IRC WordWrap Twitter Facebook
+MODULES = Jabber IRC WordWrap Twitter
+EXTRA_DIST = $(MODULES:=/Makefile.PL) $(MODULES:=/lib)
+EXTRA_DIST += \
+    Facebook/README \
+    Twitter/README \
+    Twitter/twitter.example
+EXTRA_DIST = $(MODULES:=/Makefile.PL) $(MODULES:=/inc) $(MODULES:=/lib)
 all-local: $(MODULES)
 …
         (cd $* && $(MAKE) $*.par)
-BARNOWL_PERL := $(shell which perl) -I$(abs_srcdir)/../lib
 MODULES_MAKEFILE = $(MODULES:=/Makefile)
+$(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_MAKEFILE): %/Makefile: %/Makefile.PL
+        $(AM_V_GEN)(cd $* && perl -I../../lib Makefile.PL)
 MODULES_CLEAN = $(MODULES:%=clean_%)
 clean-local: $(MODULES_CLEAN)
 $(MODULES_CLEAN): clean_%:
+        (cd $* && { test ! -f Makefile || $(MAKE) realclean; })
+        rm -f $*/$*.par
+        rm -rf $*/inc
+        test $(srcdir) = . || rm -f $*/Makefile.PL
+        (cd $* && (test ! -f Makefile || $(MAKE) clean))
 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/lib/BarnOwl/Module/Twitter.pm

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

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

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

perlconfig.c

-                      r7dcef03
+                      rb9517cf
   const char *type;
   char *ptr, *utype, *blessas;
+  const char *f;
+  int i;
+  int i, j;
   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_get_notice(m)) {
     /* Handle zephyr-specific fields... */
+    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);
+    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);
+    }
     (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);
+  }
 …
   hash = (HV*)SvRV(msg);
   m = g_slice_new(owl_message);
+  m = g_new(owl_message, 1);
   owl_message_init(m);
 …
 CALLER_OWN char *owl_perlconfig_call_with_message(const char *subname, const owl_message *m)
+{
+  SV *msgref, *rv;
+  char *out = NULL;
+  dSP ;
+  int count;
+  SV *msgref, *srv;
+  char *out;
+  ENTER ;
+  SAVETMPS;
+  PUSHMARK(SP) ;
   msgref = owl_perlconfig_message2hashref(m);
+  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));
+                );
+  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 ;
   return 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;
+  dSP;
+  unsigned int count, i;
+  SV *msgref, *srv;
+  char *out;
   msgref = owl_perlconfig_message2hashref(m);
+  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));
+                );
+  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;
   return out;
+}
 …
   char *err;
   const char *args[4] = {"", "-e", "0;", NULL};
-  const char *dlerr;
   AV *inc;
   char *path;
 …
+  }
   sv_setpv(get_sv("BarnOwl::VERSION", TRUE), version);
+  sv_setpv(get_sv("BarnOwl::VERSION", TRUE), OWL_VERSION_STRING);
   /* Add the system lib path to @INC */
 …
   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);
 …
 void owl_perlconfig_new_command(const char *name)
+{
+  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;
+  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
+                ,
+                );
+  dSP;
+  ENTER;
+  SAVETMPS;
+  PUSHMARK(SP);
+  XPUSHs(sv_2mortal(owl_new_sv(name)));
+  PUTBACK;
+  call_pv("BarnOwl::Hooks::_new_command", G_VOID|G_EVAL);
+  SPAGAIN;
+  if(SvTRUE(ERRSV)) {
+    owl_function_error("%s", SvPV_nolen(ERRSV));
+  }
+  FREETMPS;
+  LEAVE;
+}
 …
 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;
+  int i, count;
+  char * ret = NULL;
+  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;
+  return ret;
+}
 …
+}
 void owl_perlconfig_edit_callback(owl_editwin *e, bool success)
+void owl_perlconfig_edit_callback(owl_editwin *e)
+{
   SV *cb = owl_editwin_get_cbdata(e);
+  SV *text = owl_new_sv(owl_editwin_get_text(e));
+  if (cb == NULL) {
+  SV *text;
+  dSP;
+  if(cb == NULL) {
     owl_function_error("Perl callback is NULL!");
     return;
+  }
+  OWL_PERL_CALL(call_sv(cb, G_DISCARD|G_EVAL)
+                ,
+                XPUSHs(sv_2mortal(text));
+                XPUSHs(sv_2mortal(newSViv(success)));
+                ,
+                "Perl Error: '%s'"
+                ,
+                false
+                ,
+                true
+                ,
+                );
+  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;
+}

perlglue.xs

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

popexec.c

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

popwin.c

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

runtests.sh

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

select.c

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

sepbar.c

-                      ra38becd
+                      r6eb3ed9
+  }
   if (owl_function_is_away()) {
+  if (owl_global_is_zaway(&g) || owl_global_is_aaway(&g)) {
     getyx(sepwin, y, x);
     wmove(sepwin, y, x+2);
     wattron(sepwin, A_BOLD);
     wattroff(sepwin, A_REVERSE);
+    waddstr(sepwin, " AWAY ");
+    if (owl_global_is_zaway(&g) && owl_global_is_aaway(&g)) {
+      waddstr(sepwin, " AWAY ");
+    } else if (owl_global_is_zaway(&g)) {
+      waddstr(sepwin, " Z-AWAY ");
+    } else if (owl_global_is_aaway(&g)) {
+      waddstr(sepwin, " A-AWAY ");
+    }
     wattron(sepwin, A_REVERSE);
     wattroff(sepwin, A_BOLD);

style.c

-                      r7dcef03
+                      r14be3a5
+{
   SV *sv = NULL;
   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) {
+  OWL_PERL_CALL_METHOD(s->perlobj,
+                       "description",
+                       ;,
+                       "Error in style_get_description: %s",
+,
+                       sv = SvREFCNT_inc(POPs);
+                       );
+  if(sv) {
     return SvPV_nolen(sv_2mortal(sv));
   } else {
 …
   /* Call the perl object */
+  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);
+                );
+  OWL_PERL_CALL_METHOD(s->perlobj,
+                       "format_message",
+                       XPUSHs(sv_2mortal(owl_perlconfig_message2hashref(m)));,
+                       "Error in format_message: %s",
+,
+                       sv = SvREFCNT_inc(POPs);
+                       );
   if (sv) {
+  if(sv) {
     body = SvPV_nolen(sv);
   } else {
 …
+{
   owl_style_cleanup(s);
   g_slice_free(owl_style, s);
+  g_free(s);
+}

t/00-core-tests.t

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

tester.c

-                      r21dc927
+                      ra74a044
 #include "owl.h"
 #undef WINDOW
-#include "filterproc.h"
 #include <stdio.h>
 …
 int owl_smartfilter_regtest(void);
 int owl_history_regtest(void);
-int call_filter_regtest(void);
-int owl_smartstrip_regtest(void);
 extern void owl_perl_xs_init(pTHX);
 …
   numfailures += owl_smartfilter_regtest();
   numfailures += owl_history_regtest();
-  numfailures += call_filter_regtest();
-  numfailures += owl_smartstrip_regtest();
   if (numfailures) {
       fprintf(stderr, "# *** WARNING: %d failures total\n", numfailures);
 …
+{
   int numfailed=0;
   char *path, *home;
+  char *s, *path, *home;
   printf("# BEGIN testing owl_util\n");
 …
+  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/"));
+  s = owl_util_baseclass("barnowl");
+  FAIL_UNLESS("baseclass barnowl", !strcmp("barnowl", s));
+  g_free(s);
+  s = owl_util_baseclass("unbarnowl");
+  FAIL_UNLESS("baseclass unbarnowl", !strcmp("barnowl", s));
+  g_free(s);
+  s = owl_util_baseclass("unununbarnowl.d.d");
+  FAIL_UNLESS("baseclass unununbarnowl.d.d", !strcmp("barnowl", s));
+  g_free(s);
+  s = owl_util_baseclass("ununun.d.d");
+  FAIL_UNLESS("baseclass ununun.d.d", !strcmp("", s));
+  g_free(s);
+  s = owl_util_baseclass("d.d.d.d");
+  FAIL_UNLESS("baseclass d.d.d.d", !strcmp("d", s));
+  g_free(s);
+  s = owl_util_baseclass("n.d.d.d");
+  FAIL_UNLESS("baseclass n.d.d.d", !strcmp("n", s));
+  g_free(s);
+  s = owl_util_baseclass("ununun.");
+  FAIL_UNLESS("baseclass ununun.", !strcmp(".", s));
+  g_free(s);
+  s = owl_util_baseclass("unununu");
+  FAIL_UNLESS("baseclass unununu", !strcmp("u", s));
+  g_free(s);
+  s = owl_util_makepath("foo/bar");
+  FAIL_UNLESS("makepath foo/bar", !strcmp("foo/bar", s));
+  g_free(s);
+  s = owl_util_makepath("//foo///bar");
+  FAIL_UNLESS("makepath //foo///bar", !strcmp("/foo/bar", s));
+  g_free(s);
+  s = owl_util_makepath("foo/~//bar/");
+  FAIL_UNLESS("makepath foo/~//bar/", !strcmp("foo/~/bar/", s));
+  g_free(s);
+  s = owl_util_makepath("~thisuserhadreallybetternotexist/foobar/");
+  FAIL_UNLESS("makepath ~thisuserhadreallybetternotexist/foobar/",
+              !strcmp("~thisuserhadreallybetternotexist/foobar/", s));
+  g_free(s);
   home = g_strdup(owl_global_get_homedir(&g));
+  CHECK_STR_AND_FREE("makepath ~",
+                     home, owl_util_makepath("~"));
+  s = owl_util_makepath("~");
+  FAIL_UNLESS("makepath ~", !strcmp(home, s));
+  g_free(s);
   path = g_build_filename(home, "foo/bar/baz", NULL);
+  CHECK_STR_AND_FREE("makepath ~///foo/bar//baz",
+                     path, owl_util_makepath("~///foo/bar//baz"));
+  s = owl_util_makepath("~///foo/bar//baz");
+  FAIL_UNLESS("makepath ~///foo/bar//baz", !strcmp(path, s));
+  g_free(s);
   g_free(path);
   g_free(home);
 …
+  }
+  CHECK_STR_AND_FREE("makepath ~root",
+                     home, owl_util_makepath("~root"));
+  s = owl_util_makepath("~root");
+  FAIL_UNLESS("makepath ~root", !strcmp(home, s));
+  g_free(s);
   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"));
+  s = owl_util_makepath("~root///foo/bar//baz");
+  FAIL_UNLESS("makepath ~root///foo/bar//baz", !strcmp(path, s));
+  g_free(s);
   g_free(path);
   g_free(home);
 …
   int numfailed=0;
   char *value;
+  const void *v;
   printf("# BEGIN testing owl_variable\n");
   owl_variable_dict_setup(&vd);
+  FAIL_UNLESS("setup", 0==owl_variable_dict_setup(&vd));
   FAIL_UNLESS("get bool var", NULL != (var = owl_variable_get_var(&vd, "rxping")));
 …
   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", "", "");
+  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 var", NULL != (v = owl_variable_get(var)));
   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, "", "");
+  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 var", NULL != (v = owl_variable_get(var)));
   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, "", "");
+  owl_variable_dict_newvar_bool(&vd, "boolvar", "", "", 1);
   FAIL_UNLESS("get new bool var", NULL != (var = owl_variable_get_var(&vd, "boolvar")));
+  FAIL_UNLESS("get new bool var", NULL != (v = owl_variable_get(var)));
   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, "", "");
+  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)));
 …
   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);
 …
   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;
+}
-int owl_smartstrip_regtest(void)
+{
-  int numfailed = 0;
-  printf("# BEGIN testing owl_zephyr_smartstripped_user\n");
-#define CHECK_SMARTSTRIP(in, expected)                  \
-  do {                                                  \
-    char *__value = owl_zephyr_smartstripped_user(in);  \
-    FAIL_UNLESS("owl_zephyr_smartstripped_user " in,    \
-                strcmp((expected), __value) == 0);      \
-    g_free(__value);                                    \
-  } while (0)
-  CHECK_SMARTSTRIP("foo", "foo");
-  CHECK_SMARTSTRIP("foo.bar", "foo");
-  CHECK_SMARTSTRIP("foo/bar", "foo");
-  CHECK_SMARTSTRIP("host/bar", "host/bar");
-  CHECK_SMARTSTRIP("rcmd.bar", "rcmd.bar");
-  CHECK_SMARTSTRIP("daemon/bar", "daemon/bar");
-  CHECK_SMARTSTRIP("daemon.bar", "daemon.bar");
-  CHECK_SMARTSTRIP("foo@ATHENA.MIT.EDU", "foo@ATHENA.MIT.EDU");
-  CHECK_SMARTSTRIP("foo.bar@ATHENA.MIT.EDU", "foo@ATHENA.MIT.EDU");
-  CHECK_SMARTSTRIP("foo/bar@ATHENA.MIT.EDU", "foo@ATHENA.MIT.EDU");
-  CHECK_SMARTSTRIP("host/bar@ATHENA.MIT.EDU", "host/bar@ATHENA.MIT.EDU");
-  CHECK_SMARTSTRIP("rcmd.bar@ATHENA.MIT.EDU", "rcmd.bar@ATHENA.MIT.EDU");
-  CHECK_SMARTSTRIP("daemon/bar@ATHENA.MIT.EDU", "daemon/bar@ATHENA.MIT.EDU");
-  CHECK_SMARTSTRIP("daemon.bar@ATHENA.MIT.EDU", "daemon.bar@ATHENA.MIT.EDU");
-  printf("# END testing owl_zephyr_smartstripped_user\n");
-  return numfailed;
+}

util.c

-                      r7b89e8c
+                      r0071c88
 CALLER_OWN char *owl_arg_quote(const char *arg)
+{
   GString *buf = g_string_new("");
+  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);
+}

variable.c

-                      r7dcef03
+                      rf271129
 #include "owl.h"
 #include <stdio.h>
+#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_BOOL(name,default,summary,description) \
+        { g_strdup(name), OWL_VARIABLE_BOOL, NULL, default, "on,off", g_strdup(summary), g_strdup(description), NULL, \
+        NULL, NULL, NULL, NULL, NULL, NULL }
+#define OWLVAR_BOOL_FULL(name,default,summary,description,validate,set,get) \
+        { g_strdup(name), OWL_VARIABLE_BOOL, NULL, default, "on,off", g_strdup(summary), g_strdup(description), NULL, \
+        validate, set, NULL, get, NULL, NULL }
+#define OWLVAR_INT(name,default,summary,description) \
+        { g_strdup(name), OWL_VARIABLE_INT, NULL, default, "<int>", g_strdup(summary), g_strdup(description), NULL, \
+        NULL, NULL, NULL, NULL, NULL, NULL }
 #define OWLVAR_INT_FULL(name,default,summary,description,validset,validate,set,get) \
+        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)
+        { g_strdup(name), OWL_VARIABLE_INT, NULL, default, validset, g_strdup(summary), g_strdup(description), NULL, \
+        validate, set, NULL, get, NULL, NULL }
+#define OWLVAR_PATH(name,default,summary,description) \
+        { g_strdup(name), OWL_VARIABLE_STRING, g_strdup(default), 0, "<path>", g_strdup(summary), g_strdup(description),  NULL, \
+        NULL, NULL, NULL, NULL, NULL, NULL }
+#define OWLVAR_STRING(name,default,summary,description) \
+        { g_strdup(name), OWL_VARIABLE_STRING, g_strdup(default), 0, "<string>", g_strdup(summary), g_strdup(description), NULL, \
+        NULL, NULL, NULL, NULL, NULL, NULL }
+#define OWLVAR_STRING_FULL(name,default,validset,summary,description,validate,set,get) \
+        { g_strdup(name), OWL_VARIABLE_STRING, g_strdup(default), 0, validset, g_strdup(summary), g_strdup(description), NULL, \
+        validate, set, NULL, get, NULL, NULL }
 /* 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) \
+        owl_variable_dict_newvar_enum(vd, name, default, summary, description, validset)
+#define OWLVAR_ENUM(name,default,summary,description,validset) \
+        { g_strdup(name), OWL_VARIABLE_INT, NULL, default, validset, g_strdup(summary), g_strdup(description), NULL, \
+        owl_variable_enum_validate, \
+        NULL, owl_variable_enum_set_fromstring, \
+        NULL, owl_variable_enum_get_tostring, \
+        NULL }
 #define OWLVAR_ENUM_FULL(name,default,summary,description,validset,validate, set, get) \
+        owl_variable_dict_newvar_enum_full(vd, name, default, summary, description, \
+                                           validset, validate, set, get)
+void owl_variable_add_defaults(owl_vardict *vd)
+{
+        { g_strdup(name), OWL_VARIABLE_INT, NULL, default, validset, g_strdup(summary), g_strdup(description), NULL, \
+        validate, \
+        set, owl_variable_enum_set_fromstring, \
+        get, owl_variable_enum_get_tostring, \
+        NULL }
+int owl_variable_add_defaults(owl_vardict *vd)
+{
+  owl_variable variables_to_init[] = {
   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 BarnOwl starts", "" );
+               "send a login message when BarnOwl starts", "" ),
   OWLVAR_BOOL( "shutdownlogout" /* %OwlVarStub */, 1,
                "send a logout message when BarnOwl 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_FULL( "colorztext" /* %OwlVarStub */, 1,
+                    "allow @color() in zephyrs to change color",
+                    NULL, NULL, owl_variable_colorztext_set, NULL);
+               "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." ),
   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,
 …
                     "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,
 …
                "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");
+               "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,
 …
                "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");
+               "login or logout notifications.\n"),
   OWLVAR_ENUM_FULL( "disable-ctrl-d" /* %OwlVarStub:lockout_ctrld */, 1,
 …
                     "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,
 …
                "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 */, "",
 …
                  "The sepbar is the bar separating the top and bottom\n"
                  "of the BarnOwl screen.  Any string specified here will\n"
                  "be displayed on the right of the sepbar\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",
                  "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",
 …
                  "   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,
 …
                "                 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 smartfilter to narrow to messages \"related\" to \n"
+               "Causes smartfiler 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 */ );
+                      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 }
+  };
+  int ret = owl_variable_dict_add_from_list(vd, variables_to_init);
+  owl_variable *var;
+  for (var = variables_to_init; var->name != NULL; var++)
+    owl_variable_cleanup(var);
+  return ret;
+}
 …
 /* commonly useful */
+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);
+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);
+}
 /* typewinsize */
 int owl_variable_typewinsize_set(owl_variable *v, int newval)
+int owl_variable_typewinsize_set(owl_variable *v, const void *newval)
+{
   int rv;
 …
 /* debug (cache value in g->debug) */
+int owl_variable_debug_set(owl_variable *v, bool newval)
+{
+  g.debug = newval;
+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;
+  }
   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)
+int owl_variable_aaway_set(owl_variable *v, const void *newval)
+{
   if (newval) {
+    owl_aim_set_awaymsg(owl_global_get_aaway_msg(&g));
+  } else {
+    owl_aim_set_awaymsg("");
+    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("");
+    }
+  }
   return owl_variable_bool_set_default(v, 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)
+int owl_variable_pseudologins_set(owl_variable *v, const void *newval)
+{
   static guint timer = 0;
   if (newval) {
+    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;
+    if (*(const int*)newval == 1) {
+      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;
+      }
+    }
+  }
 …
 /* note that changing the value of this will clobber
  * any user setting of this */
 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) {
+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) {
       owl_function_command_norv("bindkey editmulti C-d command edit:delete-next-char");
     } else if (newval == 1) {
+    } else if (*(const int*)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 char *newval)
+  return owl_variable_int_set_default(v, newval);
+}
+int owl_variable_tty_set(owl_variable *v, const void *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 char *newval)
+  return(owl_variable_string_set_default(v, newval));
+}
+int owl_variable_default_exposure_set(owl_variable *v, const void *newval)
+{
   return owl_zephyr_set_default_exposure(newval);
+}
 const char *owl_variable_default_exposure_get(const owl_variable *v)
+const void *owl_variable_default_exposure_get(const owl_variable *v)
+{
   return owl_zephyr_get_default_exposure();
+}
 int owl_variable_exposure_set(owl_variable *v, const char *newval)
+int owl_variable_exposure_set(owl_variable *v, const void *newval)
+{
   int ret = owl_zephyr_set_exposure(newval);
 …
 /**************************************************************************/
 void owl_variable_dict_setup(owl_vardict *vd) {
+int owl_variable_dict_setup(owl_vardict *vd) {
   owl_dict_create(vd);
+  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;
+  return owl_variable_add_defaults(vd);
+}
+int owl_variable_dict_add_from_list(owl_vardict *vd, owl_variable *variables_to_init)
+{
+  owl_variable *var, *cur;
+  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->pval_default = g_strdup(var->pval_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;
+}
 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);
+  /* 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_slice_new0(owl_variable);
+  var->type = type;
+}
+CALLER_OWN owl_variable *owl_variable_newvar(const char *name, const char *summary, const char *description)
+{
+  owl_variable * var = g_new0(owl_variable, 1);
   var->name = g_strdup(name);
   var->summary = g_strdup(summary);
   var->description = g_strdup(description);
-  var->validsettings = g_strdup(validsettings);
   return 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_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);
+  if (old && owl_variable_get_type(old) == OWL_VARIABLE_STRING) {
+    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->validsettings = "<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);
+  if (old && owl_variable_get_type(old) == OWL_VARIABLE_INT) {
+    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->validsettings = "<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);
+  if (old && owl_variable_get_type(old) == OWL_VARIABLE_BOOL) {
+    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->validsettings = "on,off";
+    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);
+  }
+}
 …
+}
+void owl_variable_delete(owl_variable *v)
+{
+void owl_variable_cleanup(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_slice_free(owl_variable, v);
+  if (v->type == OWL_VARIABLE_STRING)
+    g_free(v->pval_default);
+}
+void owl_variable_delete(owl_variable *v)
+{
+  owl_variable_cleanup(v);
+  g_free(v);
+}
 …
   return v->type;
+}
+/* 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_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 (!v->set_fromstring_fn) {
+    if (msg) owl_function_error("Variable %s is read-only", owl_variable_get_name(v));
+    return -1;
+  }
+  if (0 != v->set_fromstring_fn(v, value)) {
     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) {
+    return -1;
+  }
+  if (msg) {
+    tostring = v->get_tostring_fn(v, v->get_fn(v));
+    if (tostring)
       owl_function_makemsg("%s = '%s'", owl_variable_get_name(v), tostring);
     } else {
+    else
       owl_function_makemsg("%s = <null>", owl_variable_get_name(v));
+    }
     g_free(tostring);
+  }
+  g_value_unset(&return_box);
+  g_value_unset(&values[1]);
+  g_value_unset(&values[0]);
+  return set_successfully;
+  }
+  return 0;
+}
 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);
+}
+  if (v->type != OWL_VARIABLE_STRING) return -1;
+  return v->set_fn(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);
+}
+  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_variable *v)
+{
   if (v->type != OWL_VARIABLE_BOOL) return -1;
   return owl_variable_set_bool(v, true);
+  return owl_variable_set_int(v, true);
+}
 …
+{
   if (v->type != OWL_VARIABLE_BOOL) return -1;
   return owl_variable_set_bool(v, false);
+  return owl_variable_set_int(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;
+  return v->get_tostring_fn(v, v->get_fn(v));
+}
+CALLER_OWN char *owl_variable_get_default_tostring(const owl_variable *v)
+{
+  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);
+  }
+}
 …
+}
+/* returns a reference */
+const void *owl_variable_get(const owl_variable *v)
+{
+  return v->get_fn(v);
+}
 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);
+  if (owl_variable_get_type(v) != OWL_VARIABLE_STRING) {
+    owl_function_error("Variable '%s' is not a string.", owl_variable_get_name(v));
+    return NULL;
+  }
+  return owl_variable_get(v);
+}
+/* returns a reference */
+const void *owl_variable_get_other(const owl_variable *v)
+{
+  if (owl_variable_get_type(v) != OWL_VARIABLE_OTHER) {
+    owl_function_error("Variable '%s' is not type other.", owl_variable_get_name(v));
+    return NULL;
+  }
+  return owl_variable_get(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);
+  if (owl_variable_get_type(v) != OWL_VARIABLE_INT) {
+    owl_function_error("Variable '%s' is an int.", owl_variable_get_name(v));
+    return -1;
+  }
+  const int *pi = owl_variable_get(v);
+  if (!pi) return -1;
+  return *pi;
+}
+int owl_variable_get_bool(const owl_variable *v)
+{
+  if (owl_variable_get_type(v) != OWL_VARIABLE_BOOL) {
+    owl_function_error("Variable '%s' is a boolean.", owl_variable_get_name(v));
+    return -1;
+  }
+  const int *pi = owl_variable_get(v);
+  if (!pi) return -1;
+  return *pi;
+}
 void owl_variable_describe(const owl_variable *v, owl_fmtext *fm)
+{
   const char *default_str = owl_variable_get_default_tostring(v);
+  char *tostring = owl_variable_get_default_tostring(v);
   char *default_buf;
   if (default_str)
     default_buf = g_strdup_printf("'%s'", default_str);
+  if (tostring)
+    default_buf = g_strdup_printf("'%s'", tostring);
   else
     default_buf = g_strdup("<null>");
 …
                             owl_variable_get_summary(v), default_buf);
   g_free(default_buf);
+  g_free(tostring);
+}
 void owl_variable_get_help(const owl_variable *v, owl_fmtext *fm) {
   char *tostring;
-  const char *default_str;
   owl_fmtext_append_bold(fm, "OWL VARIABLE\n\n");
 …
   owl_fmtext_append_normal(fm, "\n\n");
+  default_str = owl_variable_get_default_tostring(v);
+  tostring = owl_variable_get_default_tostring(v);
   owl_fmtext_append_normal(fm, "Default:        ");
   owl_fmtext_append_normal(fm, (default_str ? default_str : "<null>"));
+  owl_fmtext_append_normal(fm, (tostring ? tostring : "<null>"));
   owl_fmtext_append_normal(fm, "\n\n");
 …
     owl_fmtext_append_normal(fm, "\n\n");
+  }
+  g_free(tostring);
+}
 …
 /* default common functions */
+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));
+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);
+}
 /* default functions for booleans */
+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);
+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*)v->val = *(const int*)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);
+  }
+  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) {
+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));
+}
+CALLER_OWN char *owl_variable_bool_get_tostring_default(const owl_variable *v, const void *val)
+{
+  if (val == NULL) {
+    return NULL;
+  } else if (*(const int*)val == 0) {
     return g_strdup("off");
   } else if (val == 1) {
+  } else if (*(const int*)val == 1) {
     return g_strdup("on");
   } else {
 …
 /* default functions for integers */
 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);
+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;
   return(0);
+}
 int owl_variable_int_set_fromstring_default(owl_variable *v, const char *newval, void *dummy) {
+int owl_variable_int_set_fromstring_default(owl_variable *v, const char *newval) {
   int i;
   char *ep;
   i = strtol(newval, &ep, 10);
   if (*ep || ep==newval) return(-1);
+  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));
+  return (v->set_fn(v, &i));
+}
+CALLER_OWN char *owl_variable_int_get_tostring_default(const owl_variable *v, const void *val)
+{
+  if (val == NULL) {
+    return NULL;
+  } else {
+    return g_strdup_printf("%d", *(const int*)val);
+  }
+}
 /* default functions for enums (a variant of integers) */
 int owl_variable_enum_validate(const owl_variable *v, int newval) {
+int owl_variable_enum_validate(const owl_variable *v, const void *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 = newval;
+  val = *(const int*)newval;
   if (val < 0 || val >= nenums) {
     return(0);
 …
+}
 int owl_variable_enum_set_fromstring(owl_variable *v, const char *newval, void *dummy) {
+int owl_variable_enum_set_fromstring(owl_variable *v, const char *newval) {
   char **enums;
   int i, val=-1;
 …
   g_strfreev(enums);
   if (val == -1) return(-1);
   return owl_variable_set_int(v, val);
+}
 CALLER_OWN char *owl_variable_enum_get_tostring(const owl_variable *v, void *dummy)
+  return (v->set_fn(v, &val));
+}
+CALLER_OWN char *owl_variable_enum_get_tostring(const owl_variable *v, const void *val)
+{
   char **enums;
 …
   char *tostring;
+  if (val == NULL) {
+    return NULL;
+  }
   enums = g_strsplit_set(v->validsettings, ",", 0);
   nenums = g_strv_length(enums);
   i = owl_variable_get_int(v);
+  i = *(const int*)val;
   if (i<0 || i>=nenums) {
     g_strfreev(enums);
 …
 /* default functions for stringeans */
 int owl_variable_string_validate_default(const owl_variable *v, const char *newval) {
+int owl_variable_string_validate_default(const struct _owl_variable *v, const void *newval) {
   if (newval == NULL) return(0);
   else return (1);
+}
+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);
+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);
   return(0);
+}
+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));
+}
+int owl_variable_string_set_fromstring_default(owl_variable *v, const char *newval) {
+  return (v->set_fn(v, newval));
+}
+CALLER_OWN char *owl_variable_string_get_tostring_default(const owl_variable *v, const void *val)
+{
+  return g_strdup((const char*)val);
+}

view.c

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

viewwin.c

-                      r7dcef03
+                      rf271129
 CALLER_OWN owl_viewwin *owl_viewwin_new_text(owl_window *win, const char *text)
+{
   owl_viewwin *v = g_slice_new0(owl_viewwin);
+  owl_viewwin *v = g_new0(owl_viewwin, 1);
   owl_fmtext_init_null(&(v->fmtext));
   if (text) {
 …
+{
   char *text;
   owl_viewwin *v = g_slice_new0(owl_viewwin);
+  owl_viewwin *v = g_new0(owl_viewwin, 1);
   owl_fmtext_copy(&(v->fmtext), fmtext);
 …
 } owl_viewwin_search_data;
+static void owl_viewwin_callback_search(owl_editwin *e, bool success)
+{
+  if (!success) return;
+static void owl_viewwin_callback_search(owl_editwin *e)
+{
   int consider_current = false;
   const char *line = owl_editwin_get_text(e);
 …
   g_object_unref(v->status);
   owl_fmtext_cleanup(&(v->fmtext));
   g_slice_free(owl_viewwin, v);
+}
+  g_free(v);
+}

window.c

-                      r3442788
+                      rf271129
+}
+static owl_window *_get_cursor(bool *is_default)
+{
+  *is_default = false;
+static owl_window *_get_cursor(void)
+{
   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);
+  /* 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;
+  }
+  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(&default_cursor);
+  cursor = _get_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

zcrypt.c

-                      rca1fb26a
+                      rc6332f5
 #include <sys/wait.h>
 #include <ctype.h>
+#include <limits.h>
+#include <getopt.h>
+#include <config.h>
+#include "config.h"
 #ifdef HAVE_KERBEROS_IV
 …
 #include "filterproc.h"
-extern const char *version;
 /* Annotate functions in which the caller owns the return value and is
 …
+}
-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 main(int argc, char *argv[])
+{
 …
   int mode = M_NONE;
   int c;
+  char c;
   int messageflag = FALSE;
 …
   zoptions.flags = 0;
+  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)
+  while ((c = getopt(argc, argv, "ZDERSF:c:i:advqtluons:f:m")) != (char)EOF)
+  {
     switch(c)
+    {
-      case OPT_VERSION:
-        /* Version */
-        printf("This is zcrypt version %s\n", version);
-        exit(0);
-      case OPT_HELP:
-        /* Help */
-        usage(stdout, argv[0]);
-        exit(0);
       case 'Z':
         /* Zephyr encrypt */
 …
   if (error || !cryptspec)
+  {
+    usage(stderr, argv[0]);
+    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");
     exit(1);
+  }
 …
     "gpg",
     "--symmetric",
-    "--no-options",
-    "--no-default-keyring",
-    "--keyring", "/dev/null",
-    "--secret-keyring", "/dev/null",
     "--batch",
     "--quiet",
 …
     NULL
   };
   err = call_filter(argv, in, &out, &status);
+  err = call_filter("gpg", 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(argv, in, &out, &status);
+  free(in);
+  err = call_filter("gpg", argv, in, &out, &status);
   if(err || status) {
     g_free(out);

zephyr.c

-                      r7dcef03
+                      rf271129
 #define HM_SVC_FALLBACK         htons((unsigned short) 2104)
 static CALLER_OWN char *owl_zephyr_dotfile(const char *name, const char *input)
+static char *owl_zephyr_dotfile(const char *name, const char *input)
+{
   if (input != NULL)
 …
     owl_zephyr_loadsubs_helper(subs->subs, subs->nsubs);
     deferred_subs = g_list_delete_link(deferred_subs, deferred_subs);
     g_slice_free(owl_sub_list, subs);
+    g_free(subs);
+  }
 …
   ret_sd = owl_zephyr_loaddefaultsubs();
   /* load BarnOwl default subscriptions */
+  /* load Barnowl default subscriptions */
   ret_bd = owl_zephyr_loadbarnowldefaultsubs();
 …
     g_free(subs);
   } else {
     owl_sub_list *s = g_slice_new(owl_sub_list);
+    owl_sub_list *s = g_new(owl_sub_list, 1);
     s->subs = subs;
     s->nsubs = count;
 …
   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')
 …
+}
 /* Load default BarnOwl subscriptions
+/* Load default Barnowl subscriptions
+ *
  * Returns 0 on success.
 …
 #ifdef HAVE_LIBZEPHYR
   ZSubscription_t *subs;
   int subSize = 10; /* Max BarnOwl default subs we allow */
+  int subSize = 10; /* Max Barnowl default subs we allow */
   int count, ret;
 …
+}
 bool unsuball(void)
+void unsuball(void)
+{
 #if HAVE_LIBZEPHYR
 …
     owl_function_error("Zephyr: Cancelling subscriptions: %s",
                        error_message(ret));
+  return (ret == ZERR_NONE);
+#endif
+  return true;
+#endif
+}
 …
+}
+#ifdef HAVE_LIBZEPHYR
+const char *owl_zephyr_first_raw_field(const ZNotice_t *n)
+{
+/* return a pointer to the data in the Jth field, (NULL terminated by
+ * definition).  Caller must free the return.
+ */
+#ifdef HAVE_LIBZEPHYR
+CALLER_OWN 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 */
   if (n->z_message_len == 0)
+    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));
+    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(""));
+}
 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));
+  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
+CALLER_OWN char *owl_zephyr_get_field(void *n, int j)
+{
+  return(g_strdup(""));
+}
+CALLER_OWN char *owl_zephyr_get_field_as_utf8(void *n, int j)
+{
+  return owl_zephyr_get_field(n, j);
+}
 #endif
 …
 int owl_zephyr_get_num_fields(const ZNotice_t *n)
+{
+  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;
+  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);
+}
 #else
 …
   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);
+  if (!strcmp(recipient, "@")) {
+  notice.z_sender=NULL;
+  if (!strcmp(recipient, "*") || !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);
+  }
+  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);
+  notice.z_default_format=zstr("Class $class, Instance $instance:\nTo: @bold($recipient) at $time $date\nFrom: @bold{$1 <$sender>}\n\n$2");
   if (opcode) notice.z_opcode=zstr(opcode);
 …
   /* free then check the return */
   g_free(notice.z_message);
   g_free(zsender);
+  ZFreeNotice(&notice);
   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
+        || !owl_zwrite_recip_is_personal(retnotice->z_recipient)) {
+        || *retnotice->z_recipient == 0
+        || *retnotice->z_recipient == '@') {
       char *buff;
       owl_function_error("No one subscribed to class %s", retnotice->z_class);
 …
   g_free(to);
   z = owl_zwrite_new_from_line(tmpbuff);
+  z = owl_zwrite_new(tmpbuff);
   g_free(tmpbuff);
   if (z == NULL) {
 …
+  }
-  g_free(subsfile);
   g_free(line);
 #endif
 …
   g_free(filename);
+}
-#ifdef HAVE_LIBZEPHYR
-const char *owl_zephyr_get_charsetstr(const ZNotice_t *n)
+{
-#ifdef ZCHARSET_UTF_8
-  return ZCharsetToString(n->z_charset);
-#else
-  return "";
-#endif
+}
-#else
-const char *owl_zephyr_get_charsetstr(const void *n)
+{
-  return "";
+}
-#endif
 /* return auth string */
 …
 CALLER_OWN char *owl_zephyr_smartstripped_user(const char *in)
+{
+  int n = strcspn(in, "./");
+  char *realm = strchrnul(in, '@');
+  if (in + n >= realm ||
+      g_str_has_prefix(in, OWL_ZEPHYR_NOSTRIP_HOST) ||
+      g_str_has_prefix(in, OWL_ZEPHYR_NOSTRIP_RCMD) ||
+      g_str_has_prefix(in, OWL_ZEPHYR_NOSTRIP_DAEMON5) ||
+      g_str_has_prefix(in, OWL_ZEPHYR_NOSTRIP_DAEMON4))
+    return g_strdup(in);
+  else
+    return g_strdup_printf("%.*s%s", n, in, realm);
+  char *slash, *dot, *realm, *out;
+  out = g_strdup(in);
+  /* bail immeaditly if we don't have to do any work */
+  slash = strchr(out, '/');
+  dot = strchr(out, '.');
+  if (!slash && !dot) {
+    return(out);
+  }
+  if (!strncasecmp(out, OWL_ZEPHYR_NOSTRIP_HOST, strlen(OWL_ZEPHYR_NOSTRIP_HOST)) ||
+      !strncasecmp(out, OWL_ZEPHYR_NOSTRIP_RCMD, strlen(OWL_ZEPHYR_NOSTRIP_RCMD)) ||
+      !strncasecmp(out, OWL_ZEPHYR_NOSTRIP_DAEMON5, strlen(OWL_ZEPHYR_NOSTRIP_DAEMON5)) ||
+      !strncasecmp(out, OWL_ZEPHYR_NOSTRIP_DAEMON4, strlen(OWL_ZEPHYR_NOSTRIP_DAEMON4))) {
+    return(out);
+  }
+  realm = strchr(out, '@');
+  if (!slash && dot && realm && (dot > realm)) {
+    /* There's no '/', and the first '.' is in the realm */
+    return(out);
+  }
+  /* remove the realm from out, but hold on to it */
+  if (realm) realm[0]='\0';
+  /* strip */
+  if (slash) slash[0] = '\0';  /* krb5 style user/instance */
+  else if (dot) dot[0] = '\0'; /* krb4 style user.instance */
+  /* reattach the realm if we had one */
+  if (realm) {
+    strcat(out, "@");
+    strcat(out, realm+1);
+  }
+  return(out);
+}
 …
           if (ret == ZERR_NONE) {
             /* Send a PSEUDO LOGIN! */
             m = g_slice_new(owl_message);
+            m = g_new(owl_message, 1);
             owl_message_create_pseudo_zlogin(m, 0, zald->user,
                                              location.host,
 …
         /* Send a PSEUDO LOGOUT! */
         if (notify) {
           m = g_slice_new(owl_message);
+          m = g_new(owl_message, 1);
           owl_message_create_pseudo_zlogin(m, 1, zald->user, "", "", "");
           owl_global_messagequeue_addmsg(&g, m);
 …
+    }
     ZFreeALD(zald);
     g_slice_free(ZAsyncLocateData_t, zald);
+    g_free(zald);
+  }
+}
 …
       /* create the new message */
       m=g_slice_new(owl_message);
+      m=g_new(owl_message, 1);
       owl_message_create_from_znotice(m, &notice);

zwrite.c

-                      r7dcef03
+                      rf271129
 #include "owl.h"
 CALLER_OWN owl_zwrite *owl_zwrite_new_from_line(const char *line)
+{
   owl_zwrite *z = g_slice_new(owl_zwrite);
   if (owl_zwrite_create_from_line(z, line) != 0) {
     g_slice_free(owl_zwrite, z);
+CALLER_OWN owl_zwrite *owl_zwrite_new(const char *line)
+{
+  owl_zwrite *z = g_new(owl_zwrite, 1);
+  if (owl_zwrite_create_from_line(z, line) < 0) {
+    owl_zwrite_delete(z);
     return NULL;
+  }
 …
+}
-CALLER_OWN owl_zwrite *owl_zwrite_new(int argc, const char *const *argv)
+{
-  owl_zwrite *z = g_slice_new(owl_zwrite);
-  if (owl_zwrite_create(z, argc, argv) != 0) {
-    g_slice_free(owl_zwrite, z);
-    return NULL;
+  }
-  return z;
+}
 G_GNUC_WARN_UNUSED_RESULT int owl_zwrite_create_from_line(owl_zwrite *z, const char *line)
+{
   int argc;
+  int argc, badargs, myargc;
   char **argv;
+  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;
+  const char *const *myargv;
   char *msg = NULL;
+  badargs=0;
   /* start with null entries */
 …
   z->noping=0;
   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) {
+  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) {
         badargs=1;
         break;
 …
       /* Once we have -m, gobble up everything else on the line */
       argv++;
       argc--;
       msg = g_strjoinv(" ", (char**)argv);
+      myargv++;
+      myargc--;
+      msg = g_strjoinv(" ", (char**)myargv);
       break;
     } else if (!strcmp(argv[0], "-C")) {
+    } else if (!strcmp(myargv[0], "-C")) {
       z->cc=1;
       argv++;
       argc--;
     } else if (!strcmp(argv[0], "-n")) {
+      myargv++;
+      myargc--;
+    } else if (!strcmp(myargv[0], "-n")) {
       z->noping=1;
       argv++;
       argc--;
+      myargv++;
+      myargc--;
     } else {
       /* anything unattached is a recipient */
       g_ptr_array_add(z->recips, owl_validate_utf8(argv[0]));
       argv++;
       argc--;
+      g_ptr_array_add(z->recips, owl_validate_utf8(myargv[0]));
+      myargv++;
+      myargc--;
+    }
+  }
+  g_strfreev(argv);
   if (badargs) {
-    owl_zwrite_cleanup(z);
     return(-1);
+  }
 …
       z->recips->len == 0) {
     owl_function_error("You must specify a recipient for zwrite");
-    owl_zwrite_cleanup(z);
     return(-1);
+  }
 …
+  }
+  /* if there are no recipients we won't send a ping, which
+     is what we want */
   for (i = 0; i < z->recips->len; i++) {
     to = owl_zwrite_get_recip_n_with_realm(z, i);
+    if (owl_zwrite_recip_is_personal(to))
+      send_ping(to, z->class, z->inst);
+    send_ping(to, z->class, z->inst);
     g_free(to);
+  }
 …
   g_free(z->message);
   if (z->cc && owl_zwrite_is_personal(z)) {
+  if (z->recips->len > 0 && z->cc) {
     message = g_string_new("CC: ");
     for (i = 0; i < z->recips->len; i++) {
 …
   owl_zwrite z;
   int rv;
   rv = owl_zwrite_create_from_line(&z, cmd);
   if (rv != 0) return rv;
+  rv=owl_zwrite_create_from_line(&z, cmd);
+  if (rv) return(rv);
   if (!owl_zwrite_is_message_set(&z)) {
     owl_zwrite_set_message(&z, msg);
 …
+}
+bool owl_zwrite_recip_is_personal(const char *recipient)
+{
+  return recipient[0] && recipient[0] != '@';
+}
+bool owl_zwrite_is_personal(const owl_zwrite *z)
+int owl_zwrite_is_personal(const owl_zwrite *z)
+{
   /* return true if at least one of the recipients is personal */
   int i;
+  for (i = 0; i < z->recips->len; i++)
+    if (owl_zwrite_recip_is_personal(z->recips->pdata[i]))
+      return true;
+  return false;
+  char *recip;
+  for (i = 0; i < z->recips->len; i++) {
+    recip = z->recips->pdata[i];
+    if (recip[0] != '@') return 1;
+  }
+  return(0);
+}
 …
+{
   owl_zwrite_cleanup(z);
   g_slice_free(owl_zwrite, z);
+  g_free(z);
+}

Context Navigation

Changes in / [2e42098:0071c88]

Legend:

Download in other formats: