Diff [7f86e3dd695e4807d0fdd87af08792a3c204e746:4f6097e57f618562db8d9b2f9bd2c0f3d095e2cc] for / – BarnOwl

.gitignore

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

AUTHORS

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

COPYING

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

ChangeLog

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

Makefile.am

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

README

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

aim.c

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

buddylist.c

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

cmd.c

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

commands.c

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

compat/Makefile.am

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

compat/compat.h

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

configure.ac

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

context.c

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

dict.c

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

doc/barnowl.1

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

editcontext.c

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

editwin.c

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

errqueue.c

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

filter.c

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

filterelement.c

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

filterproc.c

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

filterproc.h

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

fmtext.c

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

functions.c

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

global.c

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

help.c

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

history.c

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

keybinding.c

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

keymap.c

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

keypress.c

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

libfaim/Makefile.am

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

libfaim/aim.h

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

logging.c

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

m4/ax_cflags_warn_all.m4

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

m4/ax_prog_perl_modules.m4

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

m4/pkg.m4

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

mainwin.c

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

message.c

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

messagelist.c

r66a8cd6	r219f52c

Context Navigation

Changes in / [7f86e3d:4f6097e]

Legend: