Changeset 2e42098

.gitignore

-                      rf93cc34
+                      r7834bb5
+# Generated by autoreconf
+Makefile.in
+/aclocal.m4
+/autom4te.cache/
+/compile
+/config.h.in
+/config.h.in~
+/configure
+/depcomp
+/install-sh
+/missing
+/test-driver
+# Generated by configure
+Makefile
+.deps/
+/config.cache
+/config.h
+/config.log
+/config.status
+/stamp-h1
+# Generated by make
+*.o
 *.a
+*.o
+*.par
+*~
+.#*
+.*.swp
+.deps
+META.yml
+Makefile
+Makefile.in
+Makefile.old
+/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
 TAGS
+\#*#
+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
+tags
+/GPATH
+/GRTAGS
+/GSYMS
+/GTAGS
+/cscope.files
+/cscope.in.out
+/cscope.out
+/cscope.po.out

AUTHORS

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

COPYING

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

ChangeLog

-                      r65ff3f4
+                      r6f87658
+.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

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

README

-                      rb711711
+                      r1c22155
 following CPAN modules:
+Facebook::Graph
 Net::Jabber
 Net::XMPP
 XML::Stream
 They have been modified slightly for the needs of this project.
+Some have been modified slightly for the needs of this project.
 BarnOwl currently requires the following perl modules off of CPAN:
 …
 AnyEvent
 Class::Accessor
+ExtUtils::Depends
 Glib
+Module::Install
 PAR
 …
 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::SHA1
+Digest::SHA
 The Twitter module requires:

aim.c

-                      rf271129
+                      r7dcef03
+{
   aim_clientready(sess, fr->conn);
   owl_function_debugmsg("conninitdone_admin: initializtion done for admin connection");
+  owl_function_debugmsg("conninitdone_admin: initialization done for admin connection");
   return(1);
+}
 …
   params = va_arg(ap, struct aim_icbmparameters *);
   va_end(ap);
   owl_function_debugmsg("faimtest_icbmparaminfo: ICBM Parameters: maxchannel = %d, default flags = 0x%08x, max msg len = %d, max sender evil = %f, max reciever evil = %f, min msg interval = %u",
+  owl_function_debugmsg("faimtest_icbmparaminfo: ICBM Parameters: maxchannel = %d, default flags = 0x%08x, max msg len = %d, max sender evil = %f, max receiver evil = %f, min msg interval = %u",
                        params->maxchan, params->flags, params->maxmsglen, ((float)params->maxsenderwarn)/10.0, ((float)params->maxrecverwarn)/10.0, params->minmsginterval);
 …
   wrapmsg=owl_text_wordwrap(stripmsg, 70);
   nz_screenname=owl_aim_normalize_screenname(userinfo->sn);
   m=g_new(owl_message, 1);
+  m=g_slice_new(owl_message);
   owl_message_create_aim(m,
                          nz_screenname,

barnowl-wrapper.in

Property mode changed from 100755 to 100644

-                      rf5f6ec0
+                      ra223b6b
 #!/bin/sh
 # This is a wrapper script to point BARNOWL_DATA_DIR at the source dir
 # if we're running from a build tree. barnowl.bin is the actual built
+# if we're running from a build tree. bin/barnowl is the actual built
 # binary.
+SRCDIR=`dirname "${0}"`
+EXE="$0.bin"
+EXE="@abs_builddir@/bin/$(basename "$0")"
 if test ! -x "$EXE"; then
 …
 fi
 BARNOWL_DATA_DIR="$SRCDIR/perl/"
 BARNOWL_BIN_DIR="$SRCDIR/"
+BARNOWL_DATA_DIR="@abs_srcdir@/perl"
+BARNOWL_BIN_DIR="@abs_builddir@"
 export BARNOWL_DATA_DIR
 export BARNOWL_BIN_DIR

buddy.c

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

buddylist.c

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

cmd.c

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

commands.c

-                      rf271129
+                      rca1fb26a
   OWLCMD_ARGS("unbindkey", owl_command_unbindkey, OWL_CTX_ANY,
               "removes a binding in a keymap",
               "bindkey <keymap> <keyseq>",
+              "unbindkey <keymap> <keyseq>",
               "Removes a binding of a key sequence within a keymap.\n"
               "Use 'show keymaps' to see the existing keymaps.\n"
 …
   OWLCMD_ARGS("away", owl_command_away, OWL_CTX_INTERACTIVE,
               "Set, enable or disable both AIM and zephyr away messages",
+              "Set, enable or disable all away messages",
               "away [ on | off | toggle ]\n"
               "away <message>",
               "Turn on or off the AIM and zephyr away message.  If\n"
+              "Turn on or off all away messages.  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] [inital-value]",
+                  "popless:start-search [-r] [initial-value]",
                   "Initializes the command-line to search for initial-value. If\n"
                   "-r is used, the search will be performed backwards.\n\n"
 …
 void owl_command_version(void)
+{
   owl_function_makemsg("BarnOwl version %s", OWL_VERSION_STRING);
+  owl_function_makemsg("BarnOwl version %s", version);
+}
 …
 char *owl_command_away(int argc, const char *const *argv, const char *buff)
+{
+  if ((argc==1) ||
+      ((argc==2) && !strcmp(argv[1], "on"))) {
+  bool away_off;
+  const char *message = NULL;
+  if (argc == 1 ||
+      (argc == 2 && !strcmp(argv[1], "on"))) {
+    away_off = false;
     owl_global_set_aaway_msg(&g, owl_global_get_aaway_msg_default(&g));
     owl_global_set_zaway_msg(&g, owl_global_get_zaway_msg_default(&g));
+  } else if (argc == 2 && !strcmp(argv[1], "off")) {
+    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_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], "off")) {
+    owl_function_aaway_off();
+    owl_function_zaway_off();
+    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 && owl_variable_get_type(v) != OWL_VARIABLE_BOOL) {
+  } else if (requirebool && !v->takes_on_off) {
     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 (owl_variable_get_type(v) != OWL_VARIABLE_BOOL) {
+  } else if (!v->takes_on_off) {
     if (!silent) owl_function_error("Variable '%s' is not a boolean", var);
   } else {
 …
   if (argc < 3) {
     owl_function_makemsg("Usage: bindkey <keymap> <binding>");
+    owl_function_makemsg("Usage: unbindkey <keymap> <binding>");
     return NULL;
+  }
 …
+  }
   /* check for a zwrite -m */
   z = owl_zwrite_new(buff);
+  z = owl_zwrite_new(argc, argv);
   if (!z) {
     owl_function_error("Error in zwrite arguments");
 …
     if (!strcmp(argv[0], "-f")) {
       if (argc<2) {
         owl_function_makemsg("Too few argments to the view command");
+        owl_function_makemsg("Too few arguments to the view command");
         return(NULL);
+      }
 …
     } else if (!strcmp(argv[0], "-s")) {
       if (argc<2) {
         owl_function_makemsg("Too few argments to the view command");
+        owl_function_makemsg("Too few arguments to the view command");
         return(NULL);
+      }
 …
       argv+=2;
     } else {
       owl_function_makemsg("Too few argments to the view command");
+      owl_function_makemsg("Too few arguments to the view command");
       return(NULL);
+    }
 …
     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);
+  owl_editwin_do_callback(e, true);
   owl_editwin_unref(e);
+}

compat/Makefile.am

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

compat/compat.h

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

configure.ac

-                      r883502d
+                      r77dfeb1
 dnl Process this file with autoconf to produce a configure script.
+AC_INIT([BarnOwl],[1.9dev],[bug-barnowl@mit.edu])
+AM_INIT_AUTOMAKE([1.7.0 -Wall -Wno-portability foreign])
+AC_INIT([BarnOwl],[1.10dev],[bug-barnowl@mit.edu])
+AM_INIT_AUTOMAKE([1.7.0 foreign std-options -Wall -Wno-portability])
+AM_MAINTAINER_MODE([enable])
 m4_ifdef([AM_SILENT_RULES],[AM_SILENT_RULES([yes])])
 …
 AC_PROG_CC
 AC_PROG_CC_C99
+AC_PROG_LN_S
+AC_ARG_WITH([zephyr-default-format],
+    [AS_HELP_STRING([--with-zephyr-default-format],
+                    [value for the default format zephyrgram field])],
+    [
+        case $withval in
+            yes) withval='Config error: see http://mit.edu/df';;
+            no) withval='';;
+        esac
+        zephyr_default_format=$withval
+    ],
+    [zephyr_default_format='Config error: see http://mit.edu/df'])
+AC_DEFINE_UNQUOTED(
+    [ZEPHYR_DEFAULT_FORMAT], ["$zephyr_default_format"],
+    [Value for the default format zephyrgram field]
+)
 AC_ARG_WITH([stack-protector],
 …
 AS_IF([test "x$with_zephyr" != xno],
+  [AS_IF([test "x$with_krb4" != "xno"],
+  [have_krb4=no
+   AS_IF([test "x$with_krb4" != "xno"],
    [AC_MSG_CHECKING([for Kerberos IV])
     AS_IF([krb5-config krb4 --libs >/dev/null 2>&1],
       [AC_MSG_RESULT([yes])
+       have_krb4=yes
        AC_DEFINE([HAVE_KERBEROS_IV], [1], [Define if you have kerberos IV])
        AM_CFLAGS="${AM_CFLAGS} `krb5-config krb4 --cflags`"
 …
       [AC_MSG_RESULT([no])
        AS_IF([test "x$with_krb4" = "xyes"],
+             [AC_MSG_ERROR([Kerberos IV requested but not found])])
+       PKG_CHECK_MODULES([LIBCRYPTO], [libcrypto])
+       AM_CFLAGS="${AM_CFLAGS} ${LIBCRYPTO_CFLAGS}"
+       LIBS="${LIBS} ${LIBCRYPTO_LIBS}"
+     ])])
+             [AC_MSG_ERROR([Kerberos IV requested but not found])])])])
+   AS_IF([test "x$have_krb4" != xyes],
+     [PKG_CHECK_MODULES([LIBCRYPTO], [libcrypto],
+        [AM_CFLAGS="${AM_CFLAGS} ${LIBCRYPTO_CFLAGS}"
+         LIBS="${LIBS} ${LIBCRYPTO_LIBS}"
+        ],
+        [PKG_CHECK_MODULES([OPENSSL], [openssl],
+           [AM_CFLAGS="${AM_CFLAGS} ${OPENSSL_CFLAGS}"
+            LIBS="${LIBS} ${OPENSSL_LIBS}"
+           ])])])
    AC_CHECK_LIB([zephyr], [ZGetSender],
    [LIBS="$LIBS -lzephyr"
 …
 dnl Find the location of perl XSUBPP
 AC_MSG_CHECKING(for the perl xsubpp precompiler)
 XSUBPPDIR="`(perl -MExtUtils::MakeMaker -e 'print ExtUtils::MakeMaker->new({NAME => qw(owl)})->tool_xsubpp;') | grep \^XSUBPPDIR | sed -e 's/XSUBPPDIR = //g;'`"
+XSUBPPDIR="`cd "$srcdir" && perl -MExtUtils::MakeMaker -e 'print ExtUtils::MakeMaker->new({NAME => qw(owl)})->tool_xsubpp;' | grep \^XSUBPPDIR | sed -e 's/XSUBPPDIR = //g;'`"
 if test -n "${XSUBPPDIR}"; then
    AC_MSG_RESULT(${XSUBPPDIR})
 …
 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

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

doc/barnowl.1

-                      rbad4496
+                      r8135737
 .TP
 \fB\-c\fP, \fB\-\-config\-file\fP=\fIFILE\fP
+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.
+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.
 .TP

doc/releasing-barnowl.txt

-                      r5f08dbe
+                      rd995ff3
   - [ ] 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

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

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

filterelement.c

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

filterproc.c

-                      rf271129
+                      r7155955
 #include "owl.h"
+#include "filterproc.h"
 #include <sys/wait.h>
+#include <fcntl.h>
+#include <glib.h>
 #include <poll.h>
+#include <string.h>
+#include <unistd.h>
+int send_receive(int rfd, int wfd, const char *out, char **in)
+/* Even in case of error, send_receive is responsible for closing wfd
+ * (to EOF the child) and rfd (for consistency). */
+static int send_receive(int rfd, int wfd, const char *out, char **in)
+{
   GString *str = g_string_new("");
 …
   fds[1].fd = wfd;
   fds[1].events = POLLOUT;
+  if(!out || !*out) {
+    /* Nothing to write. Close our end so the child doesn't hang waiting. */
+    close(wfd); wfd = -1;
+    out = NULL;
+  }
   while(1) {
 …
+      }
       if(!out || !*out || fds[1].revents & (POLLERR | POLLHUP)) {
         close(wfd);
+        close(wfd); wfd = -1;
         out = NULL;
+      }
 …
+  }
+  if (wfd >= 0) close(wfd);
+  close(rfd);
   *in = g_string_free(str, err < 0);
   return err;
+}
 int call_filter(const char *prog, const char *const *argv, const char *in, char **out, int *status)
+int call_filter(const char *const *argv, const char *in, char **out, int *status)
+{
+  int err = 0;
+  pid_t pid;
+  int rfd[2];
+  int wfd[2];
+  int err;
+  GPid child_pid;
+  int child_stdin, child_stdout;
+  if((err = pipe(rfd))) goto out;
+  if((err = pipe(wfd))) goto out_close_rfd;
+  pid = fork();
+  if(pid < 0) {
+    err = pid;
+    goto out_close_all;
+  }
+  if(pid) {
+    /* parent */
+    close(rfd[1]);
+    close(wfd[0]);
+    err = send_receive(rfd[0], wfd[1], in, out);
+    if(err == 0) {
+      waitpid(pid, status, 0);
+    }
+  } else {
+    /* child */
+    close(rfd[0]);
+    close(wfd[1]);
+    dup2(rfd[1], 1);
+    dup2(wfd[0], 0);
+    close(rfd[1]);
+    close(wfd[0]);
+    if(execvp(prog, (char *const *)argv)) {
+      _exit(-1);
+    }
+  if (!g_spawn_async_with_pipes(NULL, (char**)argv, NULL,
+                                G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD,
+                                NULL, NULL,
+                                &child_pid, &child_stdin, &child_stdout, NULL,
+                                NULL)) {
+    *out = NULL;
+    return 1;
+  }
+ out_close_all:
+  close(wfd[0]);
+  close(wfd[1]);
+ out_close_rfd:
+  close(rfd[0]);
+  close(rfd[1]);
+ out:
+  err = send_receive(child_stdout, child_stdin, in, out);
+  if (err == 0) {
+    waitpid(child_pid, status, 0);
+  }
   return err;
+}

filterproc.h

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

functions.c

-                      r0071c88
+                      r7dcef03
 void owl_function_show_license(void)
+{
+  const char *text;
+  text=""
+    "BarnOwl version " OWL_VERSION_STRING "\n"
+  char *text = g_strdup_printf(
+    "BarnOwl version %s\n"
     "Copyright (c) 2006-2011 The BarnOwl Developers. All rights reserved.\n"
     "Copyright (c) 2004 James Kretchmar. All rights reserved.\n"
 …
     "WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE\n"
     "OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN\n"
+    "IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n";
+    "IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n",
+    version);
   owl_function_popless_text(text);
+  g_free(text);
+}
 …
   owl_message *m;
   m=g_new(owl_message, 1);
+  m=g_slice_new(owl_message);
   owl_message_create_admin(m, header, body);
 …
   /* do followlast if necessary */
   if (owl_global_should_followlast(&g)) owl_function_lastmsg_noredisplay();
+  if (owl_global_should_followlast(&g)) owl_function_lastmsg();
   /* redisplay etc. */
 …
 void owl_function_add_outgoing_zephyrs(const owl_zwrite *z)
+{
   if (z->cc || owl_zwrite_get_numrecips(z) == 0) {
+  if (z->cc && owl_zwrite_is_personal(z)) {
     /* create the message */
     owl_message *m = g_new(owl_message, 1);
+    owl_message *m = g_slice_new(owl_message);
     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 */
       owl_message *m = g_new(owl_message, 1);
+      m = g_slice_new(owl_message);
       owl_message_create_from_zwrite(m, z, owl_zwrite_get_message(z), i);
 …
   if (!owl_global_is_aimloggedin(&g)) return(NULL);
   m=g_new(owl_message, 1);
+  m=g_slice_new(owl_message);
   owl_message_create_aim(m,
                          owl_global_get_aim_screenname(&g),
 …
   /* create the message */
   m=g_new(owl_message, 1);
+  m=g_slice_new(owl_message);
   owl_message_create_loopback(m, body);
   owl_message_set_direction_out(m);
 …
+}
 void owl_function_start_edit_win(const char *line, void (*callback)(owl_editwin *), void *data, void (*cleanup)(void *))
+owl_editwin *owl_function_start_edit_win(const char *line)
+{
   owl_editwin *e;
 …
   g_free(s);
-  owl_editwin_set_cbdata(e, data, cleanup);
-  owl_editwin_set_callback(e, callback);
   ctx = owl_editcontext_new(OWL_CTX_EDITMULTI, e, "editmulti",
                             owl_global_deactivate_editcontext, &g);
   owl_global_push_context_obj(&g, ctx);
+  return e;
+}
 …
 void owl_function_zwrite_setup(owl_zwrite *z)
+{
+  owl_editwin *e;
   /* send a ping if necessary */
   if (owl_global_is_txping(&g)) {
 …
   owl_function_write_setup("zephyr");
   owl_function_start_edit_win(z->zwriteline,
                               &owl_callback_zwrite,
                               z, (void(*)(void*))owl_zwrite_delete);
+  e = owl_function_start_edit_win(z->zwriteline);
+  owl_editwin_set_cbdata(e, z, (void (*)(void *))owl_zwrite_delete);
+  owl_editwin_set_callback(e, &owl_callback_zwrite);
+}
 void owl_function_aimwrite_setup(const char *to)
+{
+  owl_editwin *e;
   /* TODO: We probably actually want an owl_aimwrite object like
    * owl_zwrite. */
   char *line = g_strdup_printf("aimwrite %s", to);
   owl_function_write_setup("message");
+  owl_function_start_edit_win(line,
+                              &owl_callback_aimwrite,
+                              g_strdup(to),
+                              g_free);
+  e = owl_function_start_edit_win(line);
+  owl_editwin_set_cbdata(e, g_strdup(to), g_free);
+  owl_editwin_set_callback(e, &owl_callback_aimwrite);
   g_free(line);
+}
 …
 void owl_function_loopwrite_setup(void)
+{
+  owl_editwin *e;
   owl_function_write_setup("message");
+  owl_function_start_edit_win("loopwrite",
+                              &owl_callback_loopwrite,
+                              NULL, NULL);
+}
+void owl_callback_zwrite(owl_editwin *e) {
+  e = owl_function_start_edit_win("loopwrite");
+  owl_editwin_set_callback(e, &owl_callback_loopwrite);
+}
+void owl_callback_zwrite(owl_editwin *e, bool success)
+{
+  if (!success) return;
   owl_zwrite *z = owl_editwin_get_cbdata(e);
   owl_function_zwrite(z, owl_editwin_get_text(e));
 …
   owl_function_makemsg("Waiting for ack...");
+  /* If it's personal */
+  if (owl_zwrite_is_personal(z)) {
+    /* create the outgoing message */
+    owl_function_add_outgoing_zephyrs(z);
+  }
+  /* create the outgoing message */
+  owl_function_add_outgoing_zephyrs(z);
+}
 #else
 …
   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(zcrypt, argv, owl_zwrite_get_message(z), &cryptmsg, &status);
+  rv = call_filter(argv, owl_zwrite_get_message(z), &cryptmsg, &status);
   g_free(zcrypt);
 …
   owl_function_makemsg("Waiting for ack...");
+  /* If it's personal */
+  if (owl_zwrite_is_personal(z)) {
+    /* Create the outgoing message. Restore the un-crypted message for display. */
+    owl_zwrite_set_message_raw(z, old_msg);
+    owl_function_add_outgoing_zephyrs(z);
+  }
+  /* free the zwrite */
+  /* Create the outgoing message. Restore the un-crypted message for display. */
+  owl_zwrite_set_message_raw(z, old_msg);
+  owl_function_add_outgoing_zephyrs(z);
+  /* Clean up. */
   g_free(cryptmsg);
+}
+void owl_callback_aimwrite(owl_editwin *e) {
+  g_free(old_msg);
+}
+void owl_callback_aimwrite(owl_editwin *e, bool success)
+{
+  if (!success) return;
   char *to = owl_editwin_get_cbdata(e);
   owl_function_aimwrite(to, owl_editwin_get_text(e), true);
 …
+}
+void owl_callback_loopwrite(owl_editwin *e) {
+void owl_callback_loopwrite(owl_editwin *e, bool success)
+{
+  if (!success) return;
   owl_function_loopwrite(owl_editwin_get_text(e));
+}
 …
   /* create a message and put it on the message queue.  This simulates
    * an incoming message */
   min=g_new(owl_message, 1);
+  min=g_slice_new(owl_message);
   mout=owl_function_make_outgoing_loopback(msg);
 …
+}
 void owl_function_lastmsg_noredisplay(void)
+void owl_function_lastmsg(void)
+{
   int oldcurmsg, curmsg;
 …
     owl_global_set_curmsg(&g, curmsg+1);
+  }
   /* owl_mainwin_redisplay(owl_global_get_mainwin(&g)); */
+  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
   owl_global_set_direction_downwards(&g);
+}
-void owl_function_lastmsg(void)
+{
-  owl_function_lastmsg_noredisplay();
-  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
+}
 …
 void owl_function_unsuball(void)
+{
   unsuball();
   owl_function_makemsg("Unsubscribed from all messages.");
+  if (unsuball())
+    owl_function_makemsg("Unsubscribed from all messages.");
+}
 …
 void owl_function_loadsubs(const char *file)
+{
+  int ret, ret2;
+  const char *foo;
+  int ret, ret2, ret3;
   char *path;
 …
   /* for backwards compatibility for now */
+  ret2=owl_zephyr_loaddefaultsubs();
+  ret2 = owl_zephyr_loaddefaultsubs();
+  ret3 = owl_zephyr_loadbarnowldefaultsubs();
   if (!owl_context_is_interactive(owl_global_get_context(&g))) return;
+  foo=file?file:"file";
+  if (ret==0 && ret2==0) {
+  if (ret == 0 && ret2 == 0 && ret3 == 0) {
     if (!file) {
       owl_function_makemsg("Subscribed to messages.");
 …
       owl_function_makemsg("Subscribed to messages from %s", file);
+    }
   } else if (ret==-1) {
     owl_function_error("Could not read %s", foo);
   } else {
+  } else if (ret == -1) {
+    owl_function_error("Could not read %s", file ? file : "file");
+  } else if (ret2 == -1) {
     owl_function_error("Error subscribing to messages");
+  } else {
+    owl_function_error("Error subscribing to instanced personals");
+  }
+}
 …
+}
+void owl_callback_aimlogin(owl_editwin *e) {
+void owl_callback_aimlogin(owl_editwin *e, bool success)
+{
+  if (!success) return;
   char *user = owl_editwin_get_cbdata(e);
   owl_function_aimlogin(user,
 …
   /* owl_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)
+{
   owl_function_popless_text(
     "This is BarnOwl version " OWL_VERSION_STRING ".\n\n"
+  char *text = g_strdup_printf(
+    "This is BarnOwl version %s.\n\n"
     "BarnOwl is a fork of the Owl zephyr client, written and\n"
     "maintained by Alejandro Sedeno and Nelson Elhage at the\n"
 …
     "This program is free software. You can redistribute it and/or\n"
     "modify under the terms of the Sleepycat License. Use the \n"
+    "':show license' command to display the full license\n"
+  );
+      "':show license' command to display the full license\n",
+      version);
+  owl_function_popless_text(text);
+  g_free(text);
+}
 …
       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; i < fields; i++) {
+          tmpbuff = owl_zephyr_get_field_as_utf8(n, i + 1);
+        for (i = 0, f = owl_zephyr_first_raw_field(n); f != NULL;
+             i++, f = owl_zephyr_next_raw_field(n, f)) {
+          tmpbuff = owl_zephyr_field_as_utf8(n, f);
           tmpbuff2 = owl_text_indent(tmpbuff, 14, false);
           owl_fmtext_appendf_normal(&fm, "  Field %i   : %s\n", i + 1, tmpbuff2);
 …
   owl_fmtext_append_normal(&fm, "  Version: ");
   owl_fmtext_append_normal(&fm, OWL_VERSION_STRING);
+  owl_fmtext_append_normal(&fm, version);
   owl_fmtext_append_normal(&fm, "\n");
 …
+}
+void owl_callback_command(owl_editwin *e)
+{
+void owl_callback_command(owl_editwin *e, bool success)
+{
+  if (!success) return;
   char *rv;
   const char *line = owl_editwin_get_text(e);
 …
+}
 void owl_function_start_command(const char *line)
+owl_editwin *owl_function_start_command(const char *line)
+{
   owl_editwin *tw;
 …
   owl_global_push_context_obj(&g, ctx);
   owl_editwin_set_callback(tw, owl_callback_command);
+}
+CALLER_OWN owl_editwin *owl_function_start_question(const char *line)
+  return tw;
+}
+owl_editwin *owl_function_start_question(const char *line)
+{
   owl_editwin *tw;
 …
+}
 CALLER_OWN owl_editwin *owl_function_start_password(const char *line)
+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");
+    owl_function_error("Invalid filter: %s", argv[1]);
     return false;
+  }
 …
   while (zaldptr) {
     ZFreeALD(zaldptr->data);
     g_free(zaldptr->data);
+    g_slice_free(ZAsyncLocateData_t, zaldptr->data);
     zaldptr = g_list_next(zaldptr);
+  }
 …
     for (i = 0; i < anyone->len; i++) {
       user = anyone->pdata[i];
       zald = g_new(ZAsyncLocateData_t, 1);
+      zald = g_slice_new(ZAsyncLocateData_t);
       if (ZRequestLocations(zstr(user), zald, UNACKED, ZAUTH) == ZERR_NONE) {
         *zaldlist = g_list_append(*zaldlist, zald);
       } else {
         g_free(zald);
+        g_slice_free(ZAsyncLocateData_t, zald);
+      }
+    }

global.c

-                      r9078f69
+                      r7dcef03
   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);
   owl_messagelist_create(&(g->msglist));
+  g->msglist = owl_messagelist_new();
   _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 */
   owl_mainwin_init(&(g->mw), g->mainpanel.recwin);
+  g->mw = owl_mainwin_new(g->mainpanel.recwin);
   owl_msgwin_init(&(g->msgwin), g->mainpanel.msgwin);
   owl_sepbar_init(g->mainpanel.sepwin);
 …
 /* 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_free(e);
+  g_slice_free(owl_global_filter_ent, e);
+}
 void owl_global_add_filter(owl_global *g, owl_filter *f) {
   owl_global_filter_ent *e = g_new(owl_global_filter_ent, 1);
+  owl_global_filter_ent *e = g_slice_new(owl_global_filter_ent);
   e->g = g;
   e->f = f;
 …
   } 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$" },
+    { "reply-lockout", "class ^mail$ or class ^filsrv$" },
     { "out", "direction ^out$" },
     { "aim", "type ^aim$" },
 …
+}
+static GMutex *owl_global_get_interrupt_lock(owl_global *g)
+{
+#if GLIB_CHECK_VERSION(2, 31, 0)
+  return &g->interrupt_lock;
+#else
+  return g->interrupt_lock;
+#endif
+}
 void owl_global_add_interrupt(owl_global *g) {
   /* TODO: This can almost certainly be done with atomic
    * operations. Whatever. */
   g_mutex_lock(g->interrupt_lock);
+  g_mutex_lock(owl_global_get_interrupt_lock(g));
   g->interrupt_count++;
   g_mutex_unlock(g->interrupt_lock);
+  g_mutex_unlock(owl_global_get_interrupt_lock(g));
+}
 bool owl_global_take_interrupt(owl_global *g) {
   bool ans = false;
   g_mutex_lock(g->interrupt_lock);
+  g_mutex_lock(owl_global_get_interrupt_lock(g));
   if (g->interrupt_count > 0) {
     ans = true;
     g->interrupt_count--;
+  }
   g_mutex_unlock(g->interrupt_lock);
+  g_mutex_unlock(owl_global_get_interrupt_lock(g));
   return ans;
+}

help.c

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

keybinding.c

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

keymap.c

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

libfaim/Makefile.am

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

logging.c

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

-                      r378ede7
+                      re9b4a2c
 #    - $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 10
+#serial 14
 AC_DEFUN([AX_CFLAGS_WARN_ALL],[dnl
 AS_VAR_PUSHDEF([FLAGS],[CFLAGS])dnl
 AS_VAR_PUSHDEF([VAR],[ac_cv_cflags_warn_all])dnl
+AC_DEFUN([AX_FLAGS_WARN_ALL],[dnl
+AS_VAR_PUSHDEF([FLAGS],[_AC_LANG_PREFIX[]FLAGS])dnl
+AS_VAR_PUSHDEF([VAR],[ac_cv_[]_AC_LANG_ABBREV[]flags_warn_all])dnl
 AC_CACHE_CHECK([m4_ifval($1,$1,FLAGS) for maximum warnings],
 VAR,[VAR="no, unknown"
+ AC_LANG_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"
+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"
+ AC_LANG_POP([Fortran])
+FLAGS="$ac_save_[]FLAGS"
 ])
+AS_VAR_POPDEF([FLAGS])dnl
+AC_REQUIRE([AX_APPEND_FLAG])
 case ".$VAR" in
      .ok|.ok,*) m4_ifvaln($3,$3) ;;
+   .|.no|.no,*) m4_ifvaln($4,$4,[m4_ifval($2,[
+        AC_RUN_LOG([: m4_ifval($1,$1,FLAGS)="$m4_ifval($1,$1,FLAGS) $2"])
+                      m4_ifval($1,$1,FLAGS)="$m4_ifval($1,$1,FLAGS) $2"])]) ;;
+   *) m4_ifvaln($3,$3,[
+   if echo " $[]m4_ifval($1,$1,FLAGS) " | grep " $VAR " 2>&1 >/dev/null
+   then AC_RUN_LOG([: m4_ifval($1,$1,FLAGS) does contain $VAR])
+   else AC_RUN_LOG([: m4_ifval($1,$1,FLAGS)="$m4_ifval($1,$1,FLAGS) $VAR"])
+                      m4_ifval($1,$1,FLAGS)="$m4_ifval($1,$1,FLAGS) $VAR"
+   fi ]) ;;
+   .|.no|.no,*) m4_default($4,[m4_ifval($2,[AX_APPEND_FLAG([$2], [$1])])]) ;;
+   *) m4_default($3,[AX_APPEND_FLAG([$VAR], [$1])]) ;;
 esac
 AS_VAR_POPDEF([VAR])dnl
+AS_VAR_POPDEF([FLAGS])dnl
+])
+])dnl AX_FLAGS_WARN_ALL
 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

-                      r650fb2c
+                      r13a39ae8
 fi[]dnl
 ])# PKG_CHECK_MODULES
+# PKG_INSTALLDIR(DIRECTORY)
+# -------------------------
+# Substitutes the variable pkgconfigdir as the location where a module
+# should install pkg-config .pc files. By default the directory is
+# $libdir/pkgconfig, but the default can be changed by passing
+# DIRECTORY. The user can override through the --with-pkgconfigdir
+# parameter.
+AC_DEFUN([PKG_INSTALLDIR],
+[m4_pushdef([pkg_default], [m4_default([$1], ['${libdir}/pkgconfig'])])
+m4_pushdef([pkg_description],
+    [pkg-config installation directory @<:@]pkg_default[@:>@])
+AC_ARG_WITH([pkgconfigdir],
+    [AS_HELP_STRING([--with-pkgconfigdir], pkg_description)],,
+    [with_pkgconfigdir=]pkg_default)
+AC_SUBST([pkgconfigdir], [$with_pkgconfigdir])
+m4_popdef([pkg_default])
+m4_popdef([pkg_description])
+]) dnl PKG_INSTALLDIR
+# PKG_NOARCH_INSTALLDIR(DIRECTORY)
+# -------------------------
+# Substitutes the variable noarch_pkgconfigdir as the location where a
+# module should install arch-independent pkg-config .pc files. By
+# default the directory is $datadir/pkgconfig, but the default can be
+# changed by passing DIRECTORY. The user can override through the
+# --with-noarch-pkgconfigdir parameter.
+AC_DEFUN([PKG_NOARCH_INSTALLDIR],
+[m4_pushdef([pkg_default], [m4_default([$1], ['${datadir}/pkgconfig'])])
+m4_pushdef([pkg_description],
+    [pkg-config arch-independent installation directory @<:@]pkg_default[@:>@])
+AC_ARG_WITH([noarch-pkgconfigdir],
+    [AS_HELP_STRING([--with-noarch-pkgconfigdir], pkg_description)],,
+    [with_noarch_pkgconfigdir=]pkg_default)
+AC_SUBST([noarch_pkgconfigdir], [$with_noarch_pkgconfigdir])
+m4_popdef([pkg_default])
+m4_popdef([pkg_description])
+]) dnl PKG_NOARCH_INSTALLDIR
+# PKG_CHECK_VAR(VARIABLE, MODULE, CONFIG-VARIABLE,
+# [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
+# -------------------------------------------
+# Retrieves the value of the pkg-config variable for the given module.
+AC_DEFUN([PKG_CHECK_VAR],
+[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
+AC_ARG_VAR([$1], [value of $3 for $2, overriding pkg-config])dnl
+_PKG_CONFIG([$1], [variable="][$3]["], [$2])
+AS_VAR_COPY([$1], [pkg_cv_][$1])
+AS_VAR_IF([$1], [""], [$5], [$4])dnl
+])# PKG_CHECK_VAR

mainwin.c

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

-                      r0071c88
+                      r7dcef03
   if(pair ==  NULL) {
     pair = g_new(owl_pair, 1);
+    pair = g_slice_new(owl_pair);
     owl_pair_create(pair, attrname, NULL);
     g_ptr_array_add(m->attributes, pair);
 …
+  /* set the "isprivate" attribute if it's a private zephyr.
+   ``private'' means recipient is non-empty and doesn't start wit
+   `@' */
+  if (*n->z_recipient && *n->z_recipient != '@') {
+  /* set the "isprivate" attribute if it's a private zephyr. */
+  if (owl_zwrite_recip_is_personal(n->z_recipient)) {
     owl_message_set_isprivate(m);
+  }
 …
   if (owl_global_is_zcrypt(&g) && !strcasecmp(n->z_opcode, "crypt")) {
     const char *argv[] = {
       "zcrypt",
+      NULL,
       "-D",
       "-c", owl_message_get_class(m),
 …
       NULL
     };
     char *out;
+    char *out = NULL;
     int rv;
     int status;
 …
     zcrypt = g_build_filename(owl_get_bindir(), "zcrypt", NULL);
+    rv = call_filter(zcrypt, argv, owl_message_get_body(m), &out, &status);
+    argv[0] = zcrypt;
+    rv = call_filter(argv, owl_message_get_body(m), &out, &status);
     g_free(zcrypt);
 …
+      }
       owl_message_set_body(m, out);
+      g_free(out);
+    } else if(out) {
+      g_free(out);
+    }
+    } else {
+      /* Replace the opcode. Otherwise the UI and other bits of code think the
+       * message was encrypted. */
+      owl_message_set_opcode(m, "failed-decrypt");
+    }
+    g_free(out);
+  }
 …
     p = m->attributes->pdata[i];
     g_free(owl_pair_get_value(p));
     g_free(p);
+    g_slice_free(owl_pair, p);
+  }
 …
+{
   owl_message_cleanup(m);
   g_free(m);
+}
+  g_slice_free(owl_message, m);
+}

messagelist.c

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

owl.c

-                      rf271129
+                      r441fd42
 #include <sys/stat.h>
 #include <locale.h>
+#include <unistd.h>
 #if OWL_STDERR_REDIR
 …
 } owl_options;
 void usage(void)
+void usage(FILE *file)
+{
   fprintf(stderr, "Barnowl version %s\n", OWL_VERSION_STRING);
   fprintf(stderr, "Usage: barnowl [-n] [-d] [-D] [-v] [-h] [-c <configfile>] [-s <confdir>] [-t <ttyname>]\n");
   fprintf(stderr, "  -n,--no-subs        don't load zephyr subscriptions\n");
   fprintf(stderr, "  -d,--debug          enable debugging\n");
   fprintf(stderr, "  -v,--version        print the Barnowl version number and exit\n");
   fprintf(stderr, "  -h,--help           print this help message\n");
   fprintf(stderr, "  -c,--config-file    specify an alternate config file\n");
   fprintf(stderr, "  -s,--config-dir     specify an alternate config dir (default ~/.owl)\n");
   fprintf(stderr, "  -t,--tty            set the tty name\n");
+  fprintf(file, "BarnOwl version %s\n", 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");
+}
 …
       break;
     case 'v':
       printf("This is BarnOwl version %s\n", OWL_VERSION_STRING);
+      printf("This is BarnOwl version %s\n", version);
       exit(0);
     case 'h':
+      usage(stdout);
+      exit(0);
     default:
       usage();
+      usage(stderr);
       exit(1);
+    }
 …
     /* follow the last message if we're supposed to */
     if (followlast)
       owl_function_lastmsg_noredisplay();
+      owl_function_lastmsg();
     /* do the newmsgproc thing */
 …
   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\n");
+    owl_function_debugmsg("stderr_replace: pipe FAILED");
     return -1;
+  }
     owl_function_debugmsg("stderr_replace: pipe: %d,%d\n", pipefds[0], pipefds[1]);
   if (-1 == dup2(pipefds[1], 2 /*stderr*/)) {
     owl_function_debugmsg("stderr_replace: dup2 FAILED (%s)\n", strerror(errno));
+    owl_function_debugmsg("stderr_replace: pipe: %d,%d", pipefds[0], pipefds[1]);
+  if (-1 == dup2(pipefds[1], STDERR_FILENO)) {
+    owl_function_debugmsg("stderr_replace: dup2 FAILED (%s)", strerror(errno));
     perror("dup2");
     return -1;
 …
 #if OWL_STDERR_REDIR
   /* Do this only after we've started curses up... */
+  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);
+  if (isatty(STDERR_FILENO)) {
+    owl_function_debugmsg("startup: doing stderr redirection");
+    channel = g_io_channel_unix_new(stderr_replace());
+    g_io_add_watch(channel, G_IO_IN | G_IO_HUP | G_IO_ERR, &stderr_redirect_handler, NULL);
+    g_io_channel_unref(channel);
+  }
 #endif
 …
   /* welcome message */
   owl_function_debugmsg("startup: creating splash message");
   owl_function_adminmsg("",
+  char *welcome = g_strdup_printf(
     "-----------------------------------------------------------------------\n"
     "Welcome to BarnOwl version " OWL_VERSION_STRING ".\n"
+    "Welcome to BarnOwl version %s.\n"
     "To see a quick introduction, type ':show quickstart'.                  \n"
     "Press 'h' for on-line help.                                            \n"
 …
     "                                                                 OvO   \n"
     "Please report any bugs or suggestions to bug-barnowl@mit.edu    (   )  \n"
+    "-----------------------------------------------------------------m-m---\n"
+  );
+    "-----------------------------------------------------------------m-m---\n",
+    version);
+  owl_function_adminmsg("", welcome);
+  g_free(welcome);
+  owl_function_debugmsg("startup: setting context interactive");
+  owl_global_pop_context(&g);
+  owl_global_push_context(&g, OWL_CTX_INTERACTIVE|OWL_CTX_RECV, NULL, "recv", NULL);
   /* 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

-                      rb9517cf
+                      rca1fb26a
 #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 void WINDOW;
 typedef void PANEL;
+typedef struct _owl_fake_WINDOW WINDOW;
+typedef struct _owl_fake_PANEL PANEL;
 /* logout is defined in FreeBSD. */
 #define logout logout_
 …
 #include "XSUB.h"
 #else
 typedef void SV;
 typedef void AV;
 typedef void HV;
+typedef struct _owl_fake_SV SV;
+typedef struct _owl_fake_AV AV;
+typedef struct _owl_fake_HV HV;
 #endif
 #include "window.h"
+#ifndef OWL_VERSION_STRING
+#ifdef  GIT_VERSION
+#define stringify(x)       __stringify(x)
+#define __stringify(x)     #x
+#define OWL_VERSION_STRING stringify(GIT_VERSION)
+#else
+#define OWL_VERSION_STRING PACKAGE_VERSION
+#endif
+#endif /* !OWL_VERSION_STRING */
+extern const char *version;
 /* Feature that is being tested to redirect stderr through a pipe.
 …
   char *name;
   int   type;  /* OWL_VARIABLE_* */
+  void *pval_default;  /* for types other and string */
+  int   ival_default;  /* for types int and bool     */
+  const char *validsettings;    /* documentation of valid settings */
+  char *default_str;            /* the default value as a string */
+  char *validsettings;          /* documentation of valid settings */
   char *summary;                /* summary of usage */
   char *description;            /* detailed description */
+  void *val;                    /* current value */
+  int  (*validate_fn)(const struct _owl_variable *v, const void *newval);
+  bool takes_on_off;            /* allow passing on/off in argument-less set/unset */
+  GClosure *set_fromstring_fn;
+                                /* sets the variable to a value
+                                 * of the appropriate type.
+                                 * unless documented, this
+                                 * should make a copy.
+                                 * returns 0 on success. */
+  GClosure *get_tostring_fn;
+                                /* converts val to a string;
+                                 * caller must free the result */
+  /* These are only valid for OWL_VARIABLE_{INT,BOOL,STRING} */
+  GValue val;                   /* current value, if default get_fn/set_fn */
+  GCallback get_fn;
+                                /* returns a reference to the current value.
+                                 * WARNING:  this approach is hard to make
+                                 * thread-safe... */
+  GCallback validate_fn;
                                 /* returns 1 if newval is valid */
   int  (*set_fn)(struct _owl_variable *v, const void *newval);
+  GCallback set_fn;
                                 /* sets the variable to a value
+                                 * of the appropriate type.
+                                 * unless documented, this
+                                 * should make a copy.
+                                 * returns 0 on success. */
+  int  (*set_fromstring_fn)(struct _owl_variable *v, const char *newval);
+                                /* sets the variable to a value
+                                 * of the appropriate type.
+                                 * unless documented, this
+                                 * should make a copy.
+                                 * returns 0 on success. */
+  const void *(*get_fn)(const struct _owl_variable *v);
+                                /* returns a reference to the current value.
+                                 * WARNING:  this approach is hard to make
+                                 * thread-safe... */
+  CALLER_OWN char *(*get_tostring_fn)(const struct _owl_variable *v, const void *val);
+                                /* converts val to a string;
+                                 * caller must free the result */
+  void (*delete_fn)(struct _owl_variable *v);
+                                /* frees val as needed */
+                                 * of the appropriate type.
+                                 * unless documented, this
+                                 * should make a copy.
+                                 * returns 0 on success. */
 } owl_variable;
 typedef struct _owl_input {
 …
   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

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

perl/Makefile.am

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

perl/lib/BarnOwl.pm

-                      ra130fc5
+                      recd4edf
 use base qw(Exporter);
+our @EXPORT_OK = qw(command getcurmsg getnumcols getidletime
+our @EXPORT_OK = qw(command getcurmsg getnumcols getnumlines getidletime
+                    register_idle_watcher unregister_idle_watcher
                     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.  Returns the queued message.  This
+is useful for, e.g., deleting a message from the message list.
+BarnOwl::Message or a subclass.
 =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
+input.
+=back
+=item callback
+A Perl subroutine that is called when the user closes the edit_win.
+C<CALLBACK> gets called with two parameters: the text the user entered,
+and a C<SUCCESS> boolean parameter which is false if the user canceled
+the edit_win and true otherwise.
+=back
 =head2 start_question PROMPT CALLBACK
-Displays C<PROMPT> on the screen and lets the user enter a line of
-text, and calls C<CALLBACK>, which must be a perl subroutine
-reference, with the text the user entered
 =head2 start_password PROMPT CALLBACK
-Like C<start_question>, but echoes the user's input as C<*>s when they
-input.
 =head2 start_edit_win PROMPT CALLBACK
+Like C<start_question>, but displays C<PROMPT> on a line of its own
+and opens the editwin. If the user cancels the edit win, C<CALLBACK>
+is not invoked.
+Roughly equivalent to C<start_edit> called with the appropriate parameters.
+C<CALLBACK> is only called on success, for compatibility.
+These are deprecated wrappers around L<BarnOwl::start_edit>, and should not
+be uesd in new code.
+=cut
+sub start_edit {
+    my %args = (@_);
+    BarnOwl::Internal::start_edit($args{type}, $args{prompt}, $args{callback});
+}
+sub start_question {
+    my ($prompt, $callback) = @_;
+    BarnOwl::start_edit(type => 'question', prompt => $prompt, callback => sub {
+            my ($text, $success) = @_;
+            $callback->($text) if $success;
+        });
+}
+sub start_password {
+    my ($prompt, $callback) = @_;
+    BarnOwl::start_edit(type => 'password', prompt => $prompt, callback => sub {
+            my ($text, $success) = @_;
+            $callback->($text) if $success;
+        });
+}
+sub start_edit_win {
+    my ($prompt, $callback) = @_;
+    BarnOwl::start_edit(type => 'edit_win', prompt => $prompt, callback => sub {
+            my ($text, $success) = @_;
+            $callback->($text) if $success;
+        });
+}
 =head2 get_data_dir
 …
 Returns the number of colors this BarnOwl is capable of displaying
+=head2 message_matches_filter MESSAGE FILTER_NAME [QUIET = 0]
+Returns 1 if C<FILTER_NAME> is the name of a valid filter, and
+C<MESSAGE> matches that filter.  Returns 0 otherwise.  If
+C<QUIET> is false, this method displays an error message if
+if C<FILTER_NAME> does not name a valid filter.
 =head2 add_dispatch FD CALLBACK
 …
 our @all_commands;
+if(!$configfile && -f $ENV{HOME} . "/.barnowlconf") {
+    $configfile = $ENV{HOME} . "/.barnowlconf";
+}
+$configfile ||= $ENV{HOME}."/.owlconf";
+if(!$configfile) {
+    if (-f get_config_dir() . "/init.pl") {
+        $configfile = get_config_dir() . "/init.pl";
+    } elsif (-f $ENV{HOME} . "/.barnowlconf") {
+        $configfile = $ENV{HOME} . "/.barnowlconf";
+    } else {
+        $configfile = $ENV{HOME}."/.owlconf";
+    }
+}
 # populate global variable space for legacy owlconf files
 …
 =head2 new_variable_string NAME [{ARGS}]
+Add a new owl variable, either an int, a bool, or a string, with the
+=head2 new_variable_enum NAME [{ARGS}]
+Add a new owl variable, either an int, a bool, a string, or an enum with the
 specified name.
+ARGS can optionally contain the following keys:
+For new_variable_enum, ARGS is required to contain a validsettings key pointing
+to an array reference. For all four, it can optionally contain the following
+keys:
 =over 4
 …
 =back
+In addition, new_variable_string optionally accepts a string validsettings
+parameter, in case people want to set it to "<path>".
 =cut
 sub new_variable_int {
+    unshift @_, \&BarnOwl::Internal::new_variable_int, 0;
+    goto \&_new_variable;
+    my ($name, $args) = @_;
+    my $storage = defined($args->{default}) ? $args->{default} : 0;
+    BarnOwl::new_variable_full($name, {
+            %{$args},
+            get_tostring => sub { "$storage" },
+            set_fromstring => sub {
+                die "Expected integer" unless $_[0] =~ /^-?[0-9]+$/;
+                $storage = 0 + $_[0];
+            },
+            validsettings => "<int>",
+            takes_on_off => 0,
+        });
+}
 sub new_variable_bool {
+    unshift @_, \&BarnOwl::Internal::new_variable_bool, 0;
+    goto \&_new_variable;
+    my ($name, $args) = @_;
+    my $storage = defined($args->{default}) ? $args->{default} : 0;
+    BarnOwl::new_variable_full($name, {
+            %{$args},
+            get_tostring => sub { $storage ? "on" : "off" },
+            set_fromstring => sub {
+                die "Valid settings are on/off" unless $_[0] eq "on" || $_[0] eq "off";
+                $storage = $_[0] eq "on";
+            },
+            validsettings => "on,off",
+            takes_on_off => 1,
+        });
+}
 sub new_variable_string {
+    unshift @_, \&BarnOwl::Internal::new_variable_string, "";
+    goto \&_new_variable;
+}
+sub _new_variable {
+    my $func = shift;
+    my $default_default = shift;
+    my ($name, $args) = @_;
+    my $storage = defined($args->{default}) ? $args->{default} : "";
+    BarnOwl::new_variable_full($name, {
+            # Allow people to override this one if they /reaaally/ want to for
+            # some reason. Though we still reserve the right to interpret this
+            # value in interesting ways for tab-completion purposes.
+            validsettings => "<string>",
+            %{$args},
+            get_tostring => sub { $storage },
+            set_fromstring => sub { $storage = $_[0]; },
+            takes_on_off => 0,
+        });
+}
+sub new_variable_enum {
+    my ($name, $args) = @_;
+    # Gather the valid settings.
+    die "validsettings is required" unless defined($args->{validsettings});
+    my %valid;
+    map { $valid{$_} = 1 } @{$args->{validsettings}};
+    my $storage = (defined($args->{default}) ?
+                   $args->{default} :
+                   $args->{validsettings}->[0]);
+    BarnOwl::new_variable_full($name, {
+            %{$args},
+            get_tostring => sub { $storage },
+            set_fromstring => sub {
+                die "Invalid input" unless $valid{$_[0]};
+                $storage = $_[0];
+            },
+            validsettings => join(",", @{$args->{validsettings}})
+        });
+}
+=head2 new_variable_full NAME {ARGS}
+Create a variable, in full generality. The keyword arguments have types below:
+ get_tostring : ()  -> string
+ set_fromstring : string -> int
+ -- optional --
+ summary : string
+ description : string
+ validsettings : string
+ takes_on_off : int
+The get/set functions are required. Note that the caller manages storage for the
+variable. get_tostring/set_fromstring both convert AND store the value.
+set_fromstring dies on failure.
+If the variable takes parameters 'on' and 'off' (i.e. is boolean-looking), set
+takes_on_off to 1. This makes :set VAR and :unset VAR work. set_fromstring will
+be called with those arguments.
+=cut
+sub new_variable_full {
     my $name = shift;
     my $args = shift || {};
     my %args = (
         summary     => "",
+        summary => "",
         description => "",
+        default     => $default_default,
+        takes_on_off => 0,
+        validsettings => "<string>",
         %{$args});
+    $func->($name, $args{default}, $args{summary}, $args{description});
+    die "get_tostring required" unless $args{get_tostring};
+    die "set_fromstring required" unless $args{set_fromstring};
+    # Strip off the bogus dummy argument. Aargh perl-Glib.
+    my $get_tostring_fn = sub { $args{get_tostring}->() };
+    my $set_fromstring_fn = sub {
+      my ($dummy, $val) = @_;
+      # Translate from user-supplied die-on-failure callback to expected
+      # non-zero on error. Less of a nuisance than interacting with ERRSV.
+      eval { $args{set_fromstring}->($val) };
+      # TODO: Consider changing B::I::new_variable to expect string|NULL with
+      # string as the error message. That can then be translated to a GError in
+      # owl_variable_set_fromstring. For now the string is ignored.
+      return ($@ ? -1 : 0);
+    };
+    BarnOwl::Internal::new_variable($name, $args{summary}, $args{description}, $args{validsettings},
+                                    $args{takes_on_off}, $get_tostring_fn, $set_fromstring_fn, undef);
+}
 …
+}
+=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

-                      r58f4fb2
+                      r4626016
 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(startup   => \&complete_startup);
+BarnOwl::Completion::register_completer(unstartup => \&complete_startup);
 BarnOwl::Completion::register_completer(bindkey => \&complete_bindkey);
 BarnOwl::Completion::register_completer(print   => \&complete_print);

perl/lib/BarnOwl/Complete/Zephyr.pm

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

perl/lib/BarnOwl/Hooks.pm

-                      rb8a3e00
+                      r120dac7
 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

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

perl/lib/BarnOwl/Message/Zephyr.pm

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

perl/lib/BarnOwl/ModuleLoader.pm

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

perl/lib/BarnOwl/Style/Default.pm

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

perl/lib/BarnOwl/Zephyr.pm

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

perl/lib/Module/Install/BarnOwl.pm

-                      rb8a3e00
+                      re4b8f93
     my $class = ref $self;
+    my $srcdir = $ENV{BARNOWL_SRCDIR} || '.';
     $self->name("BarnOwl-Module-$name");
+    $self->all_from("lib/BarnOwl/Module/$name.pm");
+    $self->all_from("$srcdir/lib/BarnOwl/Module/$name.pm");
+    $self->makemaker_args(PMLIBDIRS => ["$srcdir/lib"],
+                          PMLIBPARENTDIRS => ["$srcdir/lib"]);
     $self->postamble(<<"END_MAKEFILE");
 # --- $class section:
+BARNOWL_SRCDIR = $srcdir
+export BARNOWL_SRCDIR
 $name.par: pm_to_blib

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

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

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

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

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

-                      rb8a3e00
+                      r41064be
               . "configure [<muc>]\n"
               . "            Configures a MUC.\n"
               . "            Necessary to initalize a new MUC.\n"
+              . "            Necessary to initialize a new MUC.\n"
               . "            At present, only the default configuration is supported.\n"
               . "            The MUC is taken from the current message if not supplied.\n\n"
 …
+    {
         my @answer = $packet->answer;
         return $answer[0]{target}, $answer[0]{port};
+        return $answer[0]->target, $answer[0]->port if @answer;
+    }
 …
+}
+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

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

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

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

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

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

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

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

perl/modules/Makefile.am

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

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

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

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

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

perlconfig.c

-                      rb9517cf
+                      r7dcef03
   const char *type;
   char *ptr, *utype, *blessas;
+  int i, j;
+  const char *f;
+  int i;
   const owl_pair *pair;
   const owl_filter *wrap;
 …
                                       owl_new_sv(owl_message_get_##field(m)), 0)
   if (owl_message_get_notice(m)) {
+  if (owl_message_is_type_zephyr(m) && owl_message_is_direction_in(m)) {
     /* Handle zephyr-specific fields... */
+    AV *av_zfields;
+    av_zfields = newAV();
+    j=owl_zephyr_get_num_fields(owl_message_get_notice(m));
+    for (i=0; i<j; i++) {
+      ptr=owl_zephyr_get_field_as_utf8(owl_message_get_notice(m), i+1);
+      av_push(av_zfields, owl_new_sv(ptr));
+      g_free(ptr);
+    AV *av_zfields = newAV();
+    if (owl_message_get_notice(m)) {
+      for (f = owl_zephyr_first_raw_field(owl_message_get_notice(m)); f != NULL;
+           f = owl_zephyr_next_raw_field(owl_message_get_notice(m), f)) {
+        ptr = owl_zephyr_field_as_utf8(owl_message_get_notice(m), f);
+        av_push(av_zfields, owl_new_sv(ptr));
+        g_free(ptr);
+      }
+      (void)hv_store(h, "auth", strlen("auth"),
+                     owl_new_sv(owl_zephyr_get_authstr(owl_message_get_notice(m))), 0);
+    } else {
+      /* Incoming zephyrs without a ZNotice_t are pseudo-logins. To appease
+       * existing styles, put in bogus 'auth' and 'fields' keys. */
+      (void)hv_store(h, "auth", strlen("auth"), owl_new_sv("NO"), 0);
+    }
     (void)hv_store(h, "fields", strlen("fields"), newRV_noinc((SV*)av_zfields), 0);
-    (void)hv_store(h, "auth", strlen("auth"),
-                   owl_new_sv(owl_zephyr_get_authstr(owl_message_get_notice(m))),0);
+  }
 …
   hash = (HV*)SvRV(msg);
   m = g_new(owl_message, 1);
+  m = g_slice_new(owl_message);
   owl_message_init(m);
 …
 CALLER_OWN char *owl_perlconfig_call_with_message(const char *subname, const owl_message *m)
+{
+  dSP ;
+  int count;
+  SV *msgref, *srv;
+  char *out;
+  ENTER ;
+  SAVETMPS;
+  PUSHMARK(SP) ;
+  SV *msgref, *rv;
+  char *out = NULL;
   msgref = owl_perlconfig_message2hashref(m);
+  XPUSHs(sv_2mortal(msgref));
+  PUTBACK ;
+  count = call_pv(subname, G_SCALAR|G_EVAL);
+  SPAGAIN ;
+  if (SvTRUE(ERRSV)) {
+    owl_function_error("Perl Error: '%s'", SvPV_nolen(ERRSV));
+    /* and clear the error */
+    sv_setsv (ERRSV, &PL_sv_undef);
+  }
+  if (count != 1) {
+    fprintf(stderr, "bad perl!  no biscuit!  returned wrong count!\n");
+    abort();
+  }
+  srv = POPs;
+  if (srv) {
+    out = g_strdup(SvPV_nolen(srv));
+  } else {
+    out = NULL;
+  }
+  PUTBACK ;
+  FREETMPS ;
+  LEAVE ;
+  OWL_PERL_CALL((call_pv(subname, G_SCALAR|G_EVAL))
+                ,
+                XPUSHs(sv_2mortal(msgref));
+                ,
+                "Perl Error: '%s'"
+                ,
+                false
+                ,
+                false
+                ,
+                rv = POPs;
+                if (rv && SvPOK(rv))
+                  out = g_strdup(SvPV_nolen(rv));
+                );
   return out;
+}
 …
 CALLER_OWN char *owl_perlconfig_message_call_method(const owl_message *m, const char *method, int argc, const char **argv)
+{
+  dSP;
+  unsigned int count, i;
+  SV *msgref, *srv;
+  char *out;
+  SV *msgref, *rv;
+  char *out = NULL;
+  int i;
   msgref = owl_perlconfig_message2hashref(m);
+  ENTER;
+  SAVETMPS;
+  PUSHMARK(SP);
+  XPUSHs(sv_2mortal(msgref));
+  for(i=0;i<argc;i++) {
+    XPUSHs(sv_2mortal(owl_new_sv(argv[i])));
+  }
+  PUTBACK;
+  count = call_method(method, G_SCALAR|G_EVAL);
+  SPAGAIN;
+  if(count != 1) {
+    fprintf(stderr, "perl returned wrong count %u\n", count);
+    abort();
+  }
+  if (SvTRUE(ERRSV)) {
+    owl_function_error("Error: '%s'", SvPV_nolen(ERRSV));
+    /* and clear the error */
+    sv_setsv (ERRSV, &PL_sv_undef);
+  }
+  srv = POPs;
+  if (srv) {
+    out = g_strdup(SvPV_nolen(srv));
+  } else {
+    out = NULL;
+  }
+  PUTBACK;
+  FREETMPS;
+  LEAVE;
+  OWL_PERL_CALL(call_method(method, G_SCALAR|G_EVAL)
+                ,
+                XPUSHs(sv_2mortal(msgref));
+                OWL_PERL_PUSH_ARGS(i, argc, argv);
+                ,
+                "Perl Error: '%s'"
+                ,
+                false
+                ,
+                false
+                ,
+                rv = POPs;
+                if (rv && SvPOK(rv))
+                  out = g_strdup(SvPV_nolen(rv));
+                );
   return out;
+}
 …
   char *err;
   const char *args[4] = {"", "-e", "0;", NULL};
+  const char *dlerr;
   AV *inc;
   char *path;
 …
+  }
   sv_setpv(get_sv("BarnOwl::VERSION", TRUE), OWL_VERSION_STRING);
+  sv_setpv(get_sv("BarnOwl::VERSION", TRUE), version);
   /* Add the system lib path to @INC */
 …
   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)
+{
+  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;
+  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
+                ,
+                );
+}
 …
 CALLER_OWN char *owl_perlconfig_perlcmd(const owl_cmd *cmd, int argc, const char *const *argv)
+{
+  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;
+  int i;
+  SV* rv;
+  char *out = NULL;
+  OWL_PERL_CALL(call_sv(cmd->cmd_perl, G_SCALAR|G_EVAL)
+                ,
+                OWL_PERL_PUSH_ARGS(i, argc, argv);
+                ,
+                "Perl Error: '%s'"
+                ,
+                false
+                ,
+                false
+                ,
+                rv = POPs;
+                if (rv && SvPOK(rv))
+                  out = g_strdup(SvPV_nolen(rv));
+                );
+  return out;
+}
 …
+}
 void owl_perlconfig_edit_callback(owl_editwin *e)
+void owl_perlconfig_edit_callback(owl_editwin *e, bool success)
+{
   SV *cb = owl_editwin_get_cbdata(e);
+  SV *text;
+  dSP;
+  if(cb == NULL) {
+  SV *text = owl_new_sv(owl_editwin_get_text(e));
+  if (cb == NULL) {
     owl_function_error("Perl callback is NULL!");
     return;
+  }
+  text = owl_new_sv(owl_editwin_get_text(e));
+  ENTER;
+  SAVETMPS;
+  PUSHMARK(SP);
+  XPUSHs(sv_2mortal(text));
+  PUTBACK;
+  call_sv(cb, G_DISCARD|G_EVAL);
+  if(SvTRUE(ERRSV)) {
+    owl_function_error("%s", SvPV_nolen(ERRSV));
+  }
+  FREETMPS;
+  LEAVE;
+  OWL_PERL_CALL(call_sv(cb, G_DISCARD|G_EVAL)
+                ,
+                XPUSHs(sv_2mortal(text));
+                XPUSHs(sv_2mortal(newSViv(success)));
+                ,
+                "Perl Error: '%s'"
+                ,
+                false
+                ,
+                true
+                ,
+                );
+}

perlglue.xs

-                      rf271129
+                      r7dcef03
         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_new(owl_style, 1);
+                s = g_slice_new(owl_style);
                 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
 …
+           }
+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::Internal
+void
+new_variable(name, summary, description, validsettings, takes_on_off, get_tostring_fn, set_fromstring_fn, data)
+    const char *name
+    const char *summary
+    const char *description
+    const char *validsettings
+    int takes_on_off
+    SV *get_tostring_fn
+    SV *set_fromstring_fn
+    SV *data
+    CODE:
+{
+        /* data is somewhat redundant given we can create closures, but oh
+         * well. Might be convenient sometimes. */
+        if(!SV_IS_CODEREF(get_tostring_fn)) {
+                croak("To-string function must be a coderef!");
+        }
+        if(!SV_IS_CODEREF(set_fromstring_fn)) {
+                croak("From-string function must be a coderef!");
+        }
+        owl_variable_dict_newvar_other(owl_global_get_vardict(&g),
+                                       name, summary, description, validsettings, takes_on_off,
+                                       perl_closure_new(get_tostring_fn, data, false),
+                                       perl_closure_new(set_fromstring_fn, data, false));
+}
+void
+start_edit(edit_type, line, callback)
+        const char *edit_type
+        const char *line
+        SV *callback
+        PREINIT:
+                owl_editwin *e;
+        CODE:
+        {
+                if (!SV_IS_CODEREF(callback))
+                        croak("Callback must be a subref");
+                if (!strcmp(edit_type, "question"))
+                        e = owl_function_start_question(line);
+                else if (!strcmp(edit_type, "password"))
+                        e = owl_function_start_password(line);
+                else if (!strcmp(edit_type, "edit_win"))
+                        e = owl_function_start_edit_win(line);
+                else
+                        croak("edit_type must be one of 'password', 'question', 'edit_win', not '%s'", edit_type);
+                owl_editwin_set_cbdata(e, newSVsv(callback), owl_perlconfig_dec_refcnt);
+                owl_editwin_set_callback(e, owl_perlconfig_edit_callback);
+        }
+int
+zephyr_zwrite(cmd,msg)
+        const char *cmd
+        const char *msg
+        CODE:
+                RETVAL = owl_zwrite_create_and_send_from_line(cmd, msg);
+        OUTPUT:
+                RETVAL
 MODULE = BarnOwl                PACKAGE = BarnOwl::Editwin

popexec.c

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

popwin.c

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

runtests.sh

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

select.c

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

sepbar.c

-                      r6eb3ed9
+                      ra38becd
+  }
   if (owl_global_is_zaway(&g) || owl_global_is_aaway(&g)) {
+  if (owl_function_is_away()) {
     getyx(sepwin, y, x);
     wmove(sepwin, y, x+2);
     wattron(sepwin, A_BOLD);
     wattroff(sepwin, A_REVERSE);
+    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 ");
+    }
+    waddstr(sepwin, " AWAY ");
     wattron(sepwin, A_REVERSE);
     wattroff(sepwin, A_BOLD);

style.c

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

t/00-core-tests.t

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

tester.c

-                      ra74a044
+                      r21dc927
 #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 *s, *path, *home;
+  char *path, *home;
   printf("# BEGIN testing owl_util\n");
 …
+  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);
+  CHECK_STR_AND_FREE("baseclass barnowl",
+                     "barnowl", owl_util_baseclass("barnowl"));
+  CHECK_STR_AND_FREE("baseclass unbarnowl",
+                     "barnowl", owl_util_baseclass("unbarnowl"));
+  CHECK_STR_AND_FREE("baseclass unununbarnowl.d.d",
+                     "barnowl", owl_util_baseclass("unununbarnowl.d.d"));
+  CHECK_STR_AND_FREE("baseclass ununun.d.d",
+                     "", owl_util_baseclass("ununun.d.d"));
+  CHECK_STR_AND_FREE("baseclass d.d.d.d",
+                     "d", owl_util_baseclass("d.d.d.d"));
+  CHECK_STR_AND_FREE("baseclass n.d.d.d",
+                     "n", owl_util_baseclass("n.d.d.d"));
+  CHECK_STR_AND_FREE("baseclass ununun.",
+                     ".", owl_util_baseclass("ununun."));
+  CHECK_STR_AND_FREE("baseclass unununu",
+                     "u", owl_util_baseclass("unununu"));
+  CHECK_STR_AND_FREE("makepath foo/bar",
+                     "foo/bar", owl_util_makepath("foo/bar"));
+  CHECK_STR_AND_FREE("makepath //foo///bar",
+                     "/foo/bar", owl_util_makepath("//foo///bar"));
+  CHECK_STR_AND_FREE("makepath foo/~//bar/",
+                     "foo/~/bar/", owl_util_makepath("foo/~//bar/"));
+  CHECK_STR_AND_FREE("makepath ~thisuserhadreallybetternotexist/foobar/",
+                     "~thisuserhadreallybetternotexist/foobar/",
+                     owl_util_makepath("~thisuserhadreallybetternotexist/foobar/"));
   home = g_strdup(owl_global_get_homedir(&g));
+  s = owl_util_makepath("~");
+  FAIL_UNLESS("makepath ~", !strcmp(home, s));
+  g_free(s);
+  CHECK_STR_AND_FREE("makepath ~",
+                     home, owl_util_makepath("~"));
   path = g_build_filename(home, "foo/bar/baz", NULL);
+  s = owl_util_makepath("~///foo/bar//baz");
+  FAIL_UNLESS("makepath ~///foo/bar//baz", !strcmp(path, s));
+  g_free(s);
+  CHECK_STR_AND_FREE("makepath ~///foo/bar//baz",
+                     path, owl_util_makepath("~///foo/bar//baz"));
   g_free(path);

Context Navigation

Legend: