Merge branch 'maint'
authorAndre Noll <maan@systemlinux.org>
Sat, 19 Dec 2009 12:15:39 +0000 (13:15 +0100)
committerAndre Noll <maan@systemlinux.org>
Sat, 19 Dec 2009 12:15:39 +0000 (13:15 +0100)
Conflicts:
osx_write.c

147 files changed:
.gitignore
COPYING.LIB [new file with mode: 0644]
CREDITS
FEATURES
GIT-VERSION-GEN [new file with mode: 0755]
INSTALL
Makefile.in
NEWS
README
README.afs
REQUIREMENTS
aac_afh.c
aacdec_filter.c
acl.c
afh.c
afh.h
afh_common.c
afs.c
afs.cmd
afs.h
aft.c
alsa_write.c
amp_filter.c
attribute.c
audioc.c
audiod.c
audiod.cmd
audiod.h
audiod_command.c
bitstream.c [new file with mode: 0644]
bitstream.h [new file with mode: 0644]
blob.c
chunk_queue.c
client.c
client.h
client_common.c
close_on_fork.c
command.c
command.h [new file with mode: 0644]
command_util.sh
compress_filter.c
configure.ac
convert_0.2-0.3.sh [deleted file]
convert_0.3-0.4.sh [new file with mode: 0755]
crypt.c
crypt.h
daemon.c
daemon.h
dccp_recv.c
dccp_send.c
depend.sh [new file with mode: 0755]
error.h
exec.c
fade.c
fd.c
fd.h
fec.c
fecdec_filter.c
file_write.c
filter.c
filter.h
filter_common.c
fsck.c [deleted file]
gcc-compat.h
ggo/afh.m4
ggo/audiod.m4
ggo/client.m4
ggo/fade.ggo
ggo/grab_client.ggo [deleted file]
ggo/gui.m4
ggo/log_timing.m4 [new file with mode: 0644]
ggo/makefile
ggo/server.m4
grab_client.c
grab_client.h
gui.c
gui_theme.c
http_recv.c
http_send.c
imdct.c [new file with mode: 0644]
imdct.h [new file with mode: 0644]
list.h
mm.c [new file with mode: 0644]
mm.h [new file with mode: 0644]
mood.c
mood.h [new file with mode: 0644]
mp3_afh.c
mp3dec_filter.c
net.c
net.h
ogg_afh.c
oggdec_filter.c
osl.c [deleted file]
osl.h [deleted file]
osl_core.h [deleted file]
oss_write.c
osx_write.c
para.h
pics/paraslash/default.jpg [deleted file]
pics/screenshots/audiod.log [deleted file]
pics/screenshots/gui.png [deleted file]
pics/screenshots/server.log [deleted file]
pics/web/paraslash.ico [deleted file]
pics/web/paraslash.png [deleted file]
playlist.c
prebuffer_filter.c
rbtree.c [deleted file]
rbtree.h [deleted file]
rc4.h
recv.c
recv_common.c
ringbuffer.c
sched.c
score.c
send.h
send_common.c
server.c
server.cmd
server.h
skencil/overview.sk
stat.c
stdin.c
stdout.c
string.c
string.h
udp_recv.c
udp_send.c
user_list.c
user_list.h
versions/paraslash-0.4.0.tar.bz2 [new file with mode: 0644]
versions/paraslash-0.4.0.tar.bz2.asc [new file with mode: 0644]
vss.c
wav_filter.c
web/images/paraslash.ico [new file with mode: 0644]
web/images/paraslash.png [new file with mode: 0644]
web/index.in.html
web/para.css
web/screenshots/audiod.log [new file with mode: 0644]
web/screenshots/gui.png [new file with mode: 0644]
web/screenshots/server.log [new file with mode: 0644]
wma.h [new file with mode: 0644]
wma_afh.c [new file with mode: 0644]
wma_common.c [new file with mode: 0644]
wmadata.h [new file with mode: 0644]
wmadec_filter.c [new file with mode: 0644]
write.c
write_common.c

index 0000ba4..d3a1fc5 100644 (file)
@@ -1,4 +1,4 @@
-*.[oa]
+objects
 foo*
 bar*
 para_*
@@ -30,4 +30,4 @@ web_sync
 confdefs.h
 conftest
 conftest.c
-
+GIT-VERSION-FILE
diff --git a/COPYING.LIB b/COPYING.LIB
new file mode 100644 (file)
index 0000000..cf9b6b9
--- /dev/null
@@ -0,0 +1,510 @@
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations
+below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+^L
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it
+becomes a de-facto standard.  To achieve this, non-free programs must
+be allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+^L
+                  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control
+compilation and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete 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 License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  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.
+\f
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+^L
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+^L
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at least
+    three years, to give the same user the materials specified in
+    Subsection 6a, above, for a charge no more than the cost of
+    performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+^L
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+^L
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply, and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License
+may add an explicit geographical distribution limitation excluding those
+countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser 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 Library
+specifies a version number of this 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 Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+^L
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+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
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "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
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. 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 LIBRARY 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
+LIBRARY (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 LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+^L
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms
+of the ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.
+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 library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or
+your school, if any, to sign a "copyright disclaimer" for the library,
+if necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James
+  Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+
diff --git a/CREDITS b/CREDITS
index e5f12ac..15313f9 100644 (file)
--- a/CREDITS
+++ b/CREDITS
@@ -14,6 +14,8 @@ Karl Bartel <karlb@gmx.net> (SFont)
 
 Gerd Becker <gerd.mac@gmx.net> (MacOs testing)
 
+Fabrice Bellard (FFmpeg)
+
 Lorenzo Bettini <bettini@dsi.unifi.it> (gengetopt)
 
 Ricardo Cerqueira <rmc@rccn.net> (mp3info)
@@ -34,12 +36,16 @@ Robert Leslie (libmad)
 
 Ian McDonald <imcdnzl@gmail.com> (dccp example code)
 
+Loren Merritt (FFmpeg)
+
 Simon Morlat <simon.morlat@linphone.org> (ortp)
 
 Christof Müller (bug reports)
 
 M. Hari Nezumi <magenta@trikuare.cx> (AudioCompress)
 
+Michael Niedermayer <michaelni@gmx.at> (FFmpeg)
+
 Manuel Odendahl <manuel-poc@bl0rg.net> (poc)
 
 Guillaume Outters <guillaume.outters@free.fr> (mosx-mpg123)
index d054dfd..dc7f853 100644 (file)
--- a/FEATURES
+++ b/FEATURES
@@ -5,7 +5,7 @@ Features
 
        * Runs on Linux, Mac OS, FreeBSD, NetBSD, Solaris and probably other
          Unixes
-       * Mp3, ogg vorbis, aac(m4a) support
+       * Mp3, ogg vorbis, aac (m4a) and wma support
        * Local or remote http, dccp, and udp network audio streaming
        * IPv6 support
        * Forward error correction allows receivers to recover from packet losses
diff --git a/GIT-VERSION-GEN b/GIT-VERSION-GEN
new file mode 100755 (executable)
index 0000000..a64d796
--- /dev/null
@@ -0,0 +1,45 @@
+#!/bin/sh
+
+if test $# -ne 1; then
+       echo >&2 "usage: $0 <version file>"
+       exit 1
+fi
+
+GVF="$1"
+DEF_VER="unnamed_version"
+
+LF='
+'
+
+# First see if there is a version file (included in release tarballs),
+# then try git-describe, then default.
+if test -f VERSION
+then
+       VN=$(cat VERSION) || VN="$DEF_VER"
+elif test -d .git -o -f .git &&
+       VN=$(git describe --abbrev=4 HEAD 2>/dev/null) &&
+       case "$VN" in
+       *$LF*) (exit 1) ;;
+       v[0-9]*)
+               git update-index -q --refresh
+               test -z "$(git diff-index --name-only HEAD --)" ||
+               VN="$VN-dirty" ;;
+       esac
+then
+       VN=$(echo "$VN" | sed -e 's/-/./g');
+else
+       VN="$DEF_VER"
+fi
+
+VN=$(expr "$VN" : v*'\(.*\)')
+
+if test -r $GVF
+then
+       VC=$(sed -e 's/^GIT_VERSION = //' <$GVF)
+else
+       VC=unset
+fi
+test "$VN" = "$VC" || {
+       echo >&2 "GIT_VERSION = $VN"
+       echo "GIT_VERSION = $VN" >$GVF
+}
diff --git a/INSTALL b/INSTALL
index 09a2616..aba5c35 100644 (file)
--- a/INSTALL
+++ b/INSTALL
@@ -17,16 +17,17 @@ optional. The configure script will detect what is installed on your
 system and will only try to build those executables that can be built
 with your setup.
 
-Note that no special library (not even the mp3 decoding library libmad)
-is needed for para_server if you only want to stream mp3 files.
-Also, it's fine to use para_server on a box without sound card as
-para_server only sends the audio stream to connected clients.
+Note that no special library (not even the mp3 decoding library
+libmad) is needed for para_server if you only want to stream mp3 or
+wma files. Also, it's fine to use para_server on a box without sound
+card as para_server only sends the audio stream to connected clients.
 
 -------------------------
 Install server and client
 -------------------------
 
-Install the package on all machines, you'd like this software to run on:
+Install the paraslash package on all machines, you'd like this software
+to run on:
 
        (./configure && make) > /dev/null
 
@@ -43,12 +44,14 @@ successfully, execute as root,
        make install
 
 -----------------------------------
-Setup user list and create rsa keys
+Setup user list and create RSA keys
 -----------------------------------
 
-If you already have your rsa keys, skip this step. If you are new
-to paraslash, you have to generate an rsa key pair for each user you
-want to allow to connect. You need at least one user.
+Note that the RSA keys for paraslash 0.3.x will not work for version
+0.4.x as the new version requires stronger (2048 bit) keys. If you
+already have your 2048 bit keys, skip this step. If you are new to
+paraslash, you have to generate a key pair for each user you want to
+allow to connect. You need at least one user.
 
 Let's assume that you'd like to run the server on host server_host
 as user foo, and that you want to connect from client_host as user bar.
@@ -70,7 +73,7 @@ with the commands
 
        key=~/.paraslash/key.$LOGNAME
        mkdir -p ~/.paraslash
-       (umask 077 && openssl genrsa -out $key)
+       (umask 077 && openssl genrsa -out $key 2048)
 
 Next, extract its public part:
 
@@ -121,11 +124,11 @@ Create the database
 
        para_client init
 
-This creates some empty tables under ~/.paraslash/afs_database.
-You normally don't need to look at these tables, but it's good
-to know that you can start from scratch with
+This creates some empty tables under ~/.paraslash/afs_database-0.4.
+You normally don't need to look at these tables, but it's good to
+know that you can start from scratch with
 
-       rm -rf ~/.paraslash/afs_database
+       rm -rf ~/.paraslash/afs_database-0.4
 
 in case something went wrong.
 
@@ -149,7 +152,7 @@ Start streaming manually
 ------------------------
 
        para_client play
-       para_client stat 2
+       para_client -- stat -n=2
 
 This starts streaming and dumps some information about the current
 audio file to stdout.
@@ -165,7 +168,7 @@ Paraslash comes with its own receiving and playing software, which
 will be described next. Try the following on client_host (assuming
 Linux/ALSA and an mp3 stream):
 
-       para_recv -l info -r 'http -i server_host' > file.mp3
+       para_recv -r 'http -i server_host' > file.mp3
        # (interrupt with CTRL+C after a few seconds)
        ls -l file.mp3 # should not be empty
        para_filter -f mp3dec -f wav < file.mp3 > file.wav
index d04d0ea..e4a3dd3 100644 (file)
@@ -8,12 +8,13 @@ MANDIR := @datarootdir@/man/man1
 PACKAGE_VERSION := @PACKAGE_VERSION@
 PACKAGE_STRING := @PACKAGE_STRING@
 install_sh := @install_sh@
+cmdline_dir := @cmdline_dir@
 
 build_date := $(shell date)
 uname_s := $(shell uname -s 2>/dev/null || echo "UNKNOWN_OS")
 uname_rs := $(shell uname -rs)
 cc_version := $(shell $(CC) --version | head -n 1)
-codename := imaginary radiation
+codename := concurrent horizon
 
 DEBUG_CPPFLAGS += -Wno-sign-compare -g -Wunused -Wundef -W
 DEBUG_CPPFLAGS += -Wredundant-decls
@@ -55,138 +56,222 @@ CPPFLAGS += -DMAIN_INPUT_FILE_IS_$(*F)
 CPPFLAGS += @SSL_CPPFLAGS@
 CPPFLAGS += @ncurses_cppflags@
 CPPFLAGS += @arch_cppflags@
+CPPFLAGS += -I/usr/local/include
+CPPFLAGS += -I$(cmdline_dir)
+CPPFLAGS += @osl_cppflags@
+CPPFLAGS += -DGIT_VERSION='"$(GIT_VERSION)"'
 
 BINARIES = para_server para_client para_audioc para_recv \
-       para_filter para_write para_fsck para_afh @extra_binaries@
+       para_filter para_write para_afh @extra_binaries@
 man_binaries := $(BINARIES)
 man_pages := $(patsubst %, man/man1/%.1, $(man_binaries))
 man_pages_in := $(patsubst %, web/%.man.in.html, $(man_binaries))
 
 ggo_dir := ggo
+object_dir := objects
+man_dir := man/man1
 
-m4_ggos := afh audioc audiod client filter fsck gui recv server write
+m4_ggos := afh audioc audiod client filter gui recv server write
 all_ggos := $(m4_ggos) dccp_recv oggdec_filter alsa_write oss_write fade http_recv \
        osx_write udp_recv amp_filter compress_filter file_write \
-       grab_client mp3dec_filter
-ggo_generated := $(addsuffix .cmdline.c, $(all_ggos)) $(addsuffix .cmdline.h, $(all_ggos)) \
-       $(addsuffix .ggo, $(addprefix $(ggo_dir)/,$(m4_ggos)))
+       mp3dec_filter prebuffer_filter
+ggo_generated := $(addsuffix .ggo, $(addprefix $(ggo_dir)/,$(m4_ggos)))
+cmdline_generated := $(addprefix $(cmdline_dir)/,$(addsuffix .cmdline.c, $(all_ggos)) \
+       $(addsuffix .cmdline.h, $(all_ggos)))
 
 autocrap := config.h.in configure
 tarball_pfx := @PACKAGE_TARNAME@-$(PACKAGE_VERSION)
-tarball_delete = web versions pics .changelog_before_cvs .changelog_cvs .gitignore
-tarball_delete := $(patsubst %,$(tarball_pfx)/%,$(tarball_delete))
-tarball_add := $(ggo_generated) $(autocrap)
+tarball_delete := $(addprefix $(tarball_pfx)/,\
+       web versions .changelog_before_cvs .changelog_cvs .gitignore\
+       $(ggo_dir) skencil)
 tarball := @PACKAGE_TARNAME@-$(PACKAGE_VERSION).tar.bz2
 
-.PHONY: clean distclean maintainer-clean install man tarball
+# To put more focus on warnings, be less verbose as default
+# Use 'make V=1' to see the full commands
+ifdef V
+       ifeq ("$(origin V)", "command line")
+               BUILD_VERBOSE = $(V)
+       endif
+endif
+ifndef BUILD_VERBOSE
+       BUILD_VERBOSE = 0
+endif
+ifeq ($(BUILD_VERBOSE),1)
+       Q =
+else
+       Q = @
+endif
+
+.PHONY: all clean distclean maintainer-clean install man tarball\
+       .FORCE-GIT-VERSION-FILE
 all: $(BINARIES) $(man_pages)
 man: $(man_pages)
 tarball: $(tarball)
 
-*.o: para.h config.h gcc-compat.h
+GIT-VERSION-FILE: .FORCE-GIT-VERSION-FILE
+       @./GIT-VERSION-GEN GIT-VERSION-FILE
+-include GIT-VERSION-FILE
+$(BINARIES): GIT-VERSION-FILE
 
-include Makefile.deps
-include $(ggo_dir)/makefile
-
-%_command_list.c %_command_list.h: %.cmd
-       ./command_util.sh c < $< >$@
-       ./command_util.sh h < $< >$(@:%.c=%.h)
+-include $(ggo_dir)/makefile
 
+%_command_list.c: %.cmd
+       @[ -z "$(Q)" ] || echo 'GEN $@'
+       $(Q) ./command_util.sh c < $< >$@
+%_command_list.h: %.cmd
+       @[ -z "$(Q)" ] || echo 'GEN $@'
+       $(Q) ./command_util.sh h < $< >$@
 %_command_list.man: %.cmd
-       ./command_util.sh man < $< > $@
-
-server_command_lists = server_command_list.man afs_command_list.man
-man/man1/para_server.1: para_server $(server_command_lists)
-       mkdir -p man/man1
-       opts="-h --detailed-help -N `for i in $(server_command_lists); do printf "%s\n" "-i $$i"; done`"; \
+       @[ -z "$(Q)" ] || echo 'GEN $@'
+       $(Q) ./command_util.sh man < $< > $@
+
+server_command_lists_ch = server_command_list.c afs_command_list.c \
+       server_command_list.h afs_command_list.h
+server_command_lists_man = server_command_list.man afs_command_list.man
+man/man1/para_server.1: para_server $(server_command_lists_man) | $(man_dir)
+       @[ -z "$(Q)" ] || echo 'HELP2MAN $<'
+       $(Q) opts="-h --detailed-help -N `for i in $(server_command_lists_man); do printf "%s\n" "-i $$i"; done`"; \
        help2man $$opts ./para_server > $@
 
-man/man1/para_audiod.1: para_audiod audiod_command_list.man
-       mkdir -p man/man1
-       help2man -h --detailed-help -N -i audiod_command_list.man ./para_audiod > $@
+man/man1/para_audiod.1: para_audiod audiod_command_list.man | $(man_dir)
+       @[ -z "$(Q)" ] || echo 'HELP2MAN $<'
+       $(Q) help2man -h --detailed-help -N -i audiod_command_list.man ./para_audiod > $@
 
-man/man1/%.1: %
-       mkdir -p man/man1
-       help2man -h --detailed-help -N ./$< > $@
+man/man1/%.1: % | $(man_dir)
+       @[ -z "$(Q)" ] || echo 'HELP2MAN $<'
+       $(Q) help2man -h --detailed-help -N ./$< > $@
 
 man/html/%.html: man/man1/%.1
-       mkdir -p man/html
-       man2html $< > $@
+       @[ -z "$(Q)" ] || echo 'MAN2HTML $<'
+       $(Q) mkdir -p man/html
+       $(Q) man2html $< > $@
 
 web/%.man.in.html: man/man1/%.1
-       man2html $< | sed -e '/^<\/BODY>/,$$d' -e '1,/<\/HEAD><BODY>/d' > $@
-
-
-oggdec_filter.o: oggdec_filter.c
-       $(CC) -c $(CPPFLAGS) $(DEBUG_CPPFLAGS) @oggvorbis_cppflags@ $<
-ogg_afh.o: ogg_afh.c
-       $(CC) -c $(CPPFLAGS) $(DEBUG_CPPFLAGS) @oggvorbis_cppflags@ $<
-
-mp3dec_filter.o: mp3dec_filter.c
-       $(CC) -c $(CPPFLAGS) $(DEBUG_CPPFLAGS) @mad_cppflags@ $<
-
-aacdec_filter.o: aacdec_filter.c
-       $(CC) -c $(CPPFLAGS) $(DEBUG_CPPFLAGS) @faad_cppflags@ $<
-
-aac_common.o: aac_common.c
-       $(CC) -c $(CPPFLAGS) $(DEBUG_CPPFLAGS) @faad_cppflags@ $<
-
-aac_afh.o: aac_afh.c
-       $(CC) -c $(CPPFLAGS) $(DEBUG_CPPFLAGS) @faad_cppflags@ $<
-
-%.cmdline.o: %.cmdline.c
-       $(CC) -c $(CPPFLAGS) $<
+       @[ -z "$(Q)" ] || echo 'MAN2HTML $<'
+       $(Q) mkdir -p man/html
+       $(Q) man2html $< | sed -e '/^<\/BODY>/,$$d' -e '1,/<\/HEAD><BODY>/d' > $@
+
+$(object_dir):
+       mkdir -p $@
+$(man_dir):
+       mkdir -p $@
+
+$(object_dir)/oggdec_filter.o: oggdec_filter.c | $(object_dir)
+       @[ -z "$(Q)" ] || echo 'CC $<'
+       $(Q) $(CC) -c -o $@ $(CPPFLAGS) $(DEBUG_CPPFLAGS) @oggvorbis_cppflags@ $<
+
+$(object_dir)/ogg_afh.o: ogg_afh.c | $(object_dir)
+       @[ -z "$(Q)" ] || echo 'CC $<'
+       $(Q) $(CC) -c -o $@ $(CPPFLAGS) $(DEBUG_CPPFLAGS) @oggvorbis_cppflags@ $<
+
+$(object_dir)/mp3dec_filter.o: mp3dec_filter.c | $(object_dir)
+       @[ -z "$(Q)" ] || echo 'CC $<'
+       $(Q) $(CC) -c -o $@ $(CPPFLAGS) $(DEBUG_CPPFLAGS) @mad_cppflags@ $<
+
+$(object_dir)/aacdec_filter.o: aacdec_filter.c | $(object_dir)
+       @[ -z "$(Q)" ] || echo 'CC $<'
+       $(Q) $(CC) -c -o $@ $(CPPFLAGS) $(DEBUG_CPPFLAGS) @faad_cppflags@ $<
+
+$(object_dir)/aac_common.o: aac_common.c | $(object_dir)
+       @[ -z "$(Q)" ] || echo 'CC $<'
+       $(Q) $(CC) -c -o $@ $(CPPFLAGS) $(DEBUG_CPPFLAGS) @faad_cppflags@ $<
+
+$(object_dir)/aac_afh.o: aac_afh.c | $(object_dir)
+       @[ -z "$(Q)" ] || echo 'CC $<'
+       $(Q) $(CC) -c -o $@ $(CPPFLAGS) $(DEBUG_CPPFLAGS) @faad_cppflags@ $<
+
+$(object_dir)/%.cmdline.o: $(cmdline_dir)/%.cmdline.c $(cmdline_dir)/%.cmdline.h | $(object_dir)
+       @[ -z "$(Q)" ] || echo 'CC $<'
+       $(Q) $(CC) -c $(CPPFLAGS) -o $@ $<
+
+$(object_dir)/%.o: %.c | $(object_dir)
+       @[ -z "$(Q)" ] || echo 'CC $<'
+       $(Q) $(CC) -c -o $@ $(CPPFLAGS) $(DEBUG_CPPFLAGS) $<
+
+$(object_dir)/%.cmdline.d: $(cmdline_dir)/%.cmdline.c | $(object_dir)
+       @[ -z "$(Q)" ] || echo 'DEP $<'
+       $(Q) ./depend.sh $(object_dir) $(cmdline_dir) $(CPPFLAGS) $< > $@
+
+$(object_dir)/%.d: %.c | $(object_dir)
+       @[ -z "$(Q)" ] || echo 'DEP $<'
+       $(Q) ./depend.sh $(object_dir) $(cmdline_dir) $(CPPFLAGS) $< > $@
+
+recv_objs := $(addprefix $(object_dir)/, @recv_objs@)
+filter_objs := $(addprefix $(object_dir)/, @filter_objs@)
+client_objs := $(addprefix $(object_dir)/, @client_objs@)
+gui_objs := $(addprefix $(object_dir)/, @gui_objs@)
+audiod_objs := $(addprefix $(object_dir)/, @audiod_objs@)
+audioc_objs := $(addprefix $(object_dir)/, @audioc_objs@)
+fade_objs := $(addprefix $(object_dir)/, @fade_objs@)
+server_objs := $(addprefix $(object_dir)/, @server_objs@)
+write_objs := $(addprefix $(object_dir)/, @write_objs@)
+afh_objs := $(addprefix $(object_dir)/, @afh_objs@)
+
+all_objs := $(recv_objs) $(filter_objs) $(client_objs) $(gui_objs) \
+       $(audiod_objs) $(audioc_objs) $(fade_objs) $(server_objs) \
+       $(write_objs) $(afh_objs)
+-include $(all_objs:.o=.d)
+
+para_recv: $(recv_objs)
+       @[ -z "$(Q)" ] || echo 'LD $@'
+       $(Q) $(CC) $(LDFLAGS) $(recv_objs) -o $@ @recv_ldflags@
+
+para_filter: $(filter_objs)
+       @[ -z "$(Q)" ] || echo 'LD $@'
+       $(Q) $(CC) $(LDFLAGS) $(filter_objs) -o $@ @filter_ldflags@
+
+para_client: $(client_objs)
+       @[ -z "$(Q)" ] || echo 'LD $@'
+       $(Q) $(CC) $(LDFLAGS) -o $@ $(client_objs) @client_ldflags@
+
+para_gui: $(gui_objs)
+       @[ -z "$(Q)" ] || echo 'LD $@'
+       $(Q) $(CC) $(LDFLAGS) -o $@ $(gui_objs) -lncurses
+
+para_audiod: audiod_command_list.c audiod_command_list.h $(audiod_objs)
+       @[ -z "$(Q)" ] || echo 'LD $@'
+       $(Q) $(CC) $(LDFLAGS) -o $@ $(audiod_objs) @audiod_ldflags@
+
+para_audioc: $(audioc_objs)
+       @[ -z "$(Q)" ] || echo 'LD $@'
+       $(Q) $(CC) $(LDFLAGS) -o $@ $(audioc_objs) @audioc_ldflags@
+
+para_fade: $(fade_objs)
+       @[ -z "$(Q)" ] || echo 'LD $@'
+       $(Q) $(CC) $(LDFLAGS) -o $@ $(fade_objs) @fade_ldflags@
+
+para_server: $(server_command_lists_ch) $(server_objs)
+       @[ -z "$(Q)" ] || echo 'LD $@'
+       $(Q) $(CC) $(LDFLAGS) -o $@ $(server_objs)  @server_ldflags@
+
+para_write: $(write_objs)
+       @[ -z "$(Q)" ] || echo 'LD $@'
+       $(Q) $(CC) $(LDFLAGS) -o $@ $(write_objs) @write_ldflags@
+
+para_afh: $(afh_objs)
+       @[ -z "$(Q)" ] || echo 'LD $@'
+       $(Q) $(CC) $(LDFLAGS) -o $@ $(afh_objs) @afh_ldflags@
 
-%.o: %.c
-       $(CC) -c $(CPPFLAGS) $(DEBUG_CPPFLAGS) $<
-
-para_recv: @recv_objs@
-       $(CC) $(LDFLAGS) @recv_objs@ -o $@ @recv_ldflags@
-
-para_filter: @filter_objs@
-       $(CC) $(LDFLAGS) @filter_objs@ -o $@ @filter_ldflags@
-
-para_client: @client_objs@
-       $(CC) $(LDFLAGS) -o $@ @client_objs@ @client_ldflags@
-
-para_gui: @gui_objs@
-       $(CC) $(LDFLAGS) -o $@ @gui_objs@ -lncurses
-
-para_audiod: @audiod_objs@
-       $(CC) $(LDFLAGS) -o $@ @audiod_objs@ @audiod_ldflags@
-
-para_audioc: @audioc_objs@
-       $(CC) $(LDFLAGS) -o $@ @audioc_objs@ @audioc_ldflags@
-
-para_fade: @fade_objs@
-       $(CC) $(LDFLAGS) -o $@ @fade_objs@ @fade_ldflags@
-
-para_server: @server_objs@
-       $(CC) $(LDFLAGS) -o $@ @server_objs@  @server_ldflags@
-
-para_fsck: @fsck_objs@
-       $(CC) $(LDFLAGS) -o $@ @fsck_objs@ @fsck_ldflags@
-
-para_write: @write_objs@
-       $(CC) $(LDFLAGS) -o $@ @write_objs@ @write_ldflags@
+clean:
+       @[ -z "$(Q)" ] || echo 'CLEAN'
+       $(Q) rm -f $(BINARIES) $(object_dir)/*.o
 
-para_afh: @afh_objs@
-       $(CC) $(LDFLAGS) -o $@ @afh_objs@ @afh_ldflags@
+clean2: clean
+       @[ -z "$(Q)" ] || echo 'CLEAN2'
+       $(Q) rm -rf man $(object_dir)
+       $(Q) rm -f *_command_list.*
 
-clean:
-       rm -f *.o $(BINARIES)
-       rm -rf man
-distclean: clean
-       rm -f Makefile autoscan.log config.status config.log && \
-       rm -rf web/sync/* autom4te.cache aclocal.m4
-       rm -f GPATH GRTAGS GSYMS GTAGS
+distclean: clean2
+       @[ -z "$(Q)" ] || echo 'DISTCLEAN'
+       $(Q) rm -f Makefile autoscan.log config.status config.log
+       $(Q) rm -rf autom4te.cache aclocal.m4
+       $(Q) rm -f GPATH GRTAGS GSYMS GTAGS
 
 maintainer-clean: distclean
        rm -f $(ggo_generated) *.tar.bz2 \
                config.h configure \
                config.h.in skencil/*.pdf skencil/*.ps
-       rm -f *_command_list.* *.man man/man1/*
-       rm -rf web_sync
+       rm -rf web_sync $(cmdline_dir)
 
 install: all man
        mkdir -p $(BINDIR) $(MANDIR)
@@ -194,12 +279,14 @@ install: all man
        $(install_sh) -m 644 $(man_pages) $(MANDIR)
        mkdir -p $(VARDIR) >/dev/null 2>&1 || true # not fatal, so don't complain
 
-@PACKAGE_TARNAME@-$(PACKAGE_VERSION).tar.bz2: $(tarball_add)
+$(tarball): $(cmdline_generated)
        rm -rf $(tarball_pfx).tar.bz2 $(tarball_pfx)
        git archive --format=tar --prefix=$(tarball_pfx)/ HEAD \
                | tar --delete $(tarball_delete) > $(tarball_pfx).tar
-       mkdir $(tarball_pfx)
-       cp -r $(tarball_add) $(tarball_pfx)
+       mkdir -p $(tarball_pfx)/$(cmdline_dir)
+       echo $(GIT_VERSION) > $(tarball_pfx)/VERSION
+       cp -r $(autocrap) $(tarball_pfx)
+       cp -r $(cmdline_generated) $(tarball_pfx)/$(cmdline_dir)
        tar rf $(tarball_pfx).tar $(tarball_pfx)/*
        rm -rf $(tarball_pfx)
        bzip2 -9 $(tarball_pfx).tar
diff --git a/NEWS b/NEWS
index 66ce1f3..4fe1f2b 100644 (file)
--- a/NEWS
+++ b/NEWS
@@ -1,6 +1,18 @@
 NEWS
 ====
 
+--------------------------------------------
+0.4.1 (to be announced) "concurrent horizon"
+--------------------------------------------
+
+Support for another audio format and bug fixes: All fixes that have
+been accumulated in the 0.3.6 release appear in this release as well.
+
+       - wma support.
+       - new afh option: --human to activate human-readable output.
+       - new server/audiod option: --log-timing to print timing information.
+       - build system improvments.
+
 -------------------------------------
 0.3.6 (2009-12-07) "cubic continuity"
 -------------------------------------
@@ -19,6 +31,28 @@ another 0.3.x release. No new features.
        - http/dccp: Do not send the audio file header twice.
        - FEC: Timing improvements.
 
+----------------------------------------------
+0.4.0 (2009-11-10) "simultaneous independence"
+----------------------------------------------
+
+Two significant changes which require the new version number: The
+improved authentication dialog and the fact that the database code
+has been moved to a library, libosl. To use the new version, you have
+to generate new RSA keys, see INSTALL for details. A shell script is
+provided for conversion of the 0.3 database to the new 0.4 format.
+
+       - stronger crypto for client authentication
+       - the database code has been moved to a library
+       - improved status item handling
+       - cleanup of the build system
+       - The "-V" option now also prints the git version
+       - the new parser-friendly listing mode for the ls and stat commands
+       - mandatory rc4 encryption
+       - major audio format handler cleanups
+       - (id3,...) tags are no longer stored as a combined string in the database
+       - new mood methods: artist_matches, title_matches, comment_matches,
+         album_matches, year_maches, year.
+
 --------------------------------------------
 0.3.5 (2009-09-21) "symplectic separability"
 --------------------------------------------
diff --git a/README b/README
index 6cf34f2..883eeee 100644 (file)
--- a/README
+++ b/README
@@ -12,7 +12,7 @@ It contains the following programs:
 para_server
 -----------
 
-para_server streams binary audio data (mp3/oggvorbis/m4a files)
+para_server streams binary audio data (mp3/oggvorbis/m4a/wma files)
 over local and/or remote networks. It listens on a tcp port and
 accepts commands such as play, stop, pause, next from authenticated
 clients. However, there are many more commands.
@@ -56,11 +56,6 @@ Its features include
        * rename detection. If files are moved or renamed, afs will
          recognize them despite of this change.
 
-Despite of all these features, paraslash is lightweight. The
-stripped binary of para_server with all its features compiled in
-mp3/ogg/aac support, http/dccp/udp support) is about 160K on i386
-under Linux. para_audiod (see below) is even smaller.
-
 -----------
 para_client
 -----------
@@ -88,9 +83,10 @@ para_filter
 
 A filter program that converts from stdin and writes to stdout.
 
-para_filter combines several decoders (mp3, oggvorbis, aac) and a
-volume normalizer. New filters can be added easily. It is possible
-to "chain" any number of filters, like UNIX pipes.
+para_filter combines several decoders (mp3, oggvorbis, aac, wma),
+a volume normalizer and a cpuple of other filters. New filters can
+be added easily. It is possible to "chain" any number of filters,
+like UNIX pipes.
 
 para_filter does not depend on other parts of paraslash, so it can
 be used as a stand-alone command line tool for audio decoding and
@@ -107,7 +103,7 @@ the audio file in complete chunks 'just in time'.
 
 This allows third-party streaming software that is unaware of
 the particular audio format to send complete frames in real
-time. Currently, mp3, ogg vorbis and aac are supported.
+time. Currently, mp3, ogg vorbis, aac and wma are supported.
 
 ----------
 para_write
index ca01df6..46e30c4 100644 (file)
@@ -78,10 +78,10 @@ A mood consists of a unique name and its *mood definition*, which is
 a set of *mood lines* containing expressions in terms of attributes
 and other data contained in the database.
 
-A mood defines a subset of audio files called the *admissible audio
-files* for that mood. At any time, at most one mood can be *active*
-which means that para_server is going to select only files from that
-subset of admissible files.
+A mood defines a subset of audio files called the *admissible audio files*
+for that mood. At any time, at most one mood can be *active* which
+means that para_server is going to select only files from that subset
+of admissible files.
 
 So in order to create a mood definition one has to write a set of
 mood lines. Mood lines come in three flavours: Accept lines, deny
@@ -156,20 +156,43 @@ List of mood_methods
 Takes no arguments and matches an audio file if and only if no
 attributes are set.
 
-       played_rarely
-
-Takes no arguments and matches all audio files where the number of
-times this audio file was selected is below the average.
-
-       is_set attribute_name
+       is_set <attribute_name>
 
 Takes the name of an attribute and matches iff that attribute is set.
 
-       path_matches pattern
+       path_matches <pattern>
 
 Takes a filename pattern and matches iff the path of the audio file
 matches the pattern.
 
+       artist_matches <pattern>
+       album_matches <pattern>
+       title_matches <pattern>
+       comment_matches <pattern>
+
+Takes an extended regular expression and matches iff the text of the
+corresponding tag of the audio file matches the pattern. If the tag
+is not set, the empty string is matched against the pattern.
+
+       year ~ <num>
+       bitrate ~ <num>
+       frequency ~ <num>
+       channels ~ <num>
+       num_played ~ <num>
+
+Takes a comparator ~ of the set {<, =, <=, >, >=, !=} and a number
+<num>. Matches an audio file iff the condition <val> ~ <num> is
+satisfied where val is the corresponding value of the audio file
+(value of the year tag, bitrate in kbit/s, frequency in Hz, channel
+count, play count).
+
+The year tag is special as its value is undefined if the audio file
+has no year tag or the content of the year tag is not a number. Such
+audio files never match. Another difference is the special treatment
+if the year tag is a two-digit number. In this case either 1900 or
+2000 are added to the tag value depending on whether the number is
+greater than 2000 plus the current year.
+
 
 ----------
 Mood usage
index c1743fd..1991737 100644 (file)
@@ -3,6 +3,10 @@ Requirements
 
 In any case you need
 
+       - libosl: If you are compiling from git the osl sources should
+         have been cloned automatically. It is also available for
+         download from http://git.tuebingen.mpg.de/osl. Or run the
+         command "git clone git://git.tuebingen.mpg.de/osl"
        - gcc, the gnu compiler collection (shipped with distro): gcc-3.3
          or newer is required.
        - gnu make (shipped with disto, might be called gmake)
index 80b50a4..d12dfa1 100644 (file)
--- a/aac_afh.c
+++ b/aac_afh.c
 
 /** \file aac_afh.c para_server's aac audio format handler */
 
+#include <regex.h>
+
 #include "para.h"
 #include "error.h"
-#include "string.h"
 #include "afh.h"
-#include "afs.h"
-#include "server.h"
+#include "string.h"
 #include "aac.h"
 
 static int aac_find_stsz(unsigned char *buf, size_t buflen, off_t *skip)
@@ -91,11 +91,9 @@ static char *get_tag(unsigned char *p, int size)
        return buf;
 }
 
-static char *read_tags(unsigned char *buf, size_t buflen)
+static void read_tags(unsigned char *buf, size_t buflen, struct afh_info *afhi)
 {
        unsigned char *p = buf;
-       char *title = NULL, *artist = NULL, *album = NULL, *year = NULL,
-               *comment = NULL, *result;
 
        while (p + 32 < buf + buflen) {
                unsigned char *q, type1[5], type2[5];
@@ -114,27 +112,20 @@ static char *read_tags(unsigned char *buf, size_t buflen)
                if (q + size2 > buf + buflen)
                        break;
                if (!atom_cmp(type1, "©ART"))
-                       artist = get_tag(q, size2);
+                       afhi->tags.artist = get_tag(q, size2);
                else if (!atom_cmp(type1, "©alb"))
-                       album = get_tag(q, size2);
+                       afhi->tags.album = get_tag(q, size2);
                else if (!atom_cmp(type1, "©nam"))
-                       title = get_tag(q, size2);
+                       afhi->tags.title = get_tag(q, size2);
                else if (!atom_cmp(type1, "©cmt"))
-                       comment = get_tag(q, size2);
+                       afhi->tags.comment = get_tag(q, size2);
                else if (!atom_cmp(type1, "©day"))
-                       year = get_tag(q, size2);
+                       afhi->tags.year = get_tag(q, size2);
                p += size1;
        }
-       result = make_taginfo(title, artist, album, year, comment);
-       free(title);
-       free(artist);
-       free(album);
-       free(year);
-       free(comment);
-       return result;
 }
 
-static char *read_meta(unsigned char *buf, size_t buflen)
+static void read_meta(unsigned char *buf, size_t buflen, struct afh_info *afhi)
 {
        unsigned char *p = buf;
 
@@ -145,12 +136,12 @@ static char *read_meta(unsigned char *buf, size_t buflen)
                        continue;
                }
                p += 4;
-               return read_tags(p, buflen - (p - buf));
+               return read_tags(p, buflen - (p - buf), afhi);
        }
-       return make_taginfo(NULL, NULL, NULL, NULL, NULL);
 }
 
-static char *aac_get_taginfo(unsigned char *buf, size_t buflen)
+static void aac_get_taginfo(unsigned char *buf, size_t buflen,
+               struct afh_info *afhi)
 {
        int i;
        uint64_t subsize;
@@ -165,10 +156,9 @@ static char *aac_get_taginfo(unsigned char *buf, size_t buflen)
                p = buf + i;
                i += read_atom_header(p, &subsize, type);
                p = buf + i;
-               return read_meta(p, buflen - i);
+               return read_meta(p, buflen - i, afhi);
        }
        PARA_INFO_LOG("no meta data\n");
-       return make_taginfo(NULL, NULL, NULL, NULL, NULL);
 }
 
 static ssize_t aac_compute_chunk_table(struct afh_info *afhi,
@@ -232,12 +222,11 @@ static int aac_get_file_info(char *map, size_t numbytes, __a_unused int fd,
        mp4AudioSpecificConfig mp4ASC;
        NeAACDecHandle handle = NULL;
        unsigned char *umap = (unsigned char *) map;
-       char *taginfo;
 
        ret = aac_find_esds(umap, numbytes, &skip, &decoder_len);
        if (ret < 0)
                goto out;
-       taginfo = aac_get_taginfo(umap, numbytes);
+       aac_get_taginfo(umap, numbytes, afhi);
        handle = aac_open();
        ret = -E_AAC_AFH_INIT;
        if (NeAACDecInit(handle, umap + skip, decoder_len, &rate, &channels))
@@ -268,11 +257,6 @@ static int aac_get_file_info(char *map, size_t numbytes, __a_unused int fd,
        ret = (afhi->chunk_table[afhi->chunks_total] - afhi->chunk_table[0]) * 8; /* bits */
        ret += (channels * afhi->seconds_total * 500); /* avoid rounding error */
        afhi->bitrate = ret / (channels * afhi->seconds_total * 1000);
-       afhi->info_string = make_message("%s:\n%s",
-               status_item_list[SI_AUDIO_FILE_INFO],
-               taginfo);
-       free(taginfo);
-       tv_scale(20, &afhi->chunk_tv, &afhi->eof_tv);
        ret = 1;
 out:
        if (handle)
index 1ceca1f..59c4989 100644 (file)
@@ -10,8 +10,9 @@
 
 /** \file aacdec_filter.c paraslash's aac (m4a) decoder. */
 
-#include "para.h"
+#include <regex.h>
 
+#include "para.h"
 #include "list.h"
 #include "sched.h"
 #include "ggo.h"
diff --git a/acl.c b/acl.c
index ffcd168..087ea0c 100644 (file)
--- a/acl.c
+++ b/acl.c
@@ -6,6 +6,8 @@
 
 /** \file acl.c Access control lists for paraslash senders. */
 
+#include <regex.h>
+
 #include "para.h"
 #include "error.h"
 #include "string.h"
diff --git a/afh.c b/afh.c
index 8e1e6b3..7fc32cd 100644 (file)
--- a/afh.c
+++ b/afh.c
@@ -6,6 +6,7 @@
 
 /** \file afh.c Paraslash's standalone audio format handler tool. */
 
+#include <regex.h>
 #include <dirent.h>
 #include <sys/time.h>
 
@@ -32,18 +33,28 @@ static void print_info(int audio_format_num, struct afh_info *afhi)
                "%s: %dHz\n" /* frequency */
                "%s: %d\n" /* channels */
                "%s: %lu\n" /* seconds total */
-               "%s" /* tag info */
                "%s: %lu: %lu\n" /* chunk time */
-               "%s: %lu\n", /* num chunks */
+               "%s: %lu\n" /* num chunks */
+               "%s: %s\n" /* techinfo */
+               "%s: %s\n" /* artist */
+               "%s: %s\n" /* title */
+               "%s: %s\n" /* year */
+               "%s: %s\n" /* album */
+               "%s: %s\n", /* comment */
                status_item_list[SI_BITRATE], afhi->bitrate,
                status_item_list[SI_FORMAT], audio_format_name(audio_format_num),
                status_item_list[SI_FREQUENCY], afhi->frequency,
                status_item_list[SI_CHANNELS], afhi->channels,
                status_item_list[SI_SECONDS_TOTAL], afhi->seconds_total,
-               afhi->info_string,
                status_item_list[SI_CHUNK_TIME], (long unsigned)afhi->chunk_tv.tv_sec,
                        (long unsigned)afhi->chunk_tv.tv_usec,
-               status_item_list[SI_NUM_CHUNKS], afhi->chunks_total
+               status_item_list[SI_NUM_CHUNKS], afhi->chunks_total,
+               status_item_list[SI_TECHINFO], afhi->techinfo? afhi->techinfo : "",
+               status_item_list[SI_ARTIST], afhi->tags.artist? afhi->tags.artist : "",
+               status_item_list[SI_TITLE], afhi->tags.title? afhi->tags.title : "",
+               status_item_list[SI_YEAR], afhi->tags.year? afhi->tags.year : "",
+               status_item_list[SI_ALBUM], afhi->tags.album? afhi->tags.album : "",
+               status_item_list[SI_COMMENT], afhi->tags.comment? afhi->tags.comment : ""
        );
 }
 
@@ -51,10 +62,25 @@ static void print_chunk_table(struct afh_info *afhi)
 {
        int i;
 
-       printf("chunk_table: ");
-       for (i = 0; i <= afhi->chunks_total; i++)
-               printf("%u ", afhi->chunk_table[i]);
-       printf("\n");
+       if (!conf.human_given) {
+               printf("chunk_table: ");
+               for (i = 0; i <= afhi->chunks_total; i++)
+                       printf("%u ", afhi->chunk_table[i]);
+               printf("\n");
+               return;
+       }
+       for (i = 1; i <= afhi->chunks_total; i++) {
+               struct timeval tv;
+               long unsigned from, to;
+               tv_scale(i - 1, &afhi->chunk_tv, &tv);
+               from = tv2ms(&tv);
+               tv_scale(i, &afhi->chunk_tv, &tv);
+               to = tv2ms(&tv);
+               printf("%d [%lu.%03lu - %lu.%03lu] %u - %u (%u)\n", i,
+                       from / 1000, from % 1000, to / 1000, to % 1000,
+                       afhi->chunk_table[i - 1], afhi->chunk_table[i],
+                       afhi->chunk_table[i] - afhi->chunk_table[i - 1]);
+       }
 }
 
 static int cat_file(void *audio_file_data, struct afh_info *afhi)
@@ -166,10 +192,15 @@ int main(int argc, char **argv)
                        print_info(audio_format_num, &afhi);
                        if (conf.chunk_table_given)
                                print_chunk_table(&afhi);
+                       free(afhi.techinfo);
+                       free(afhi.tags.artist);
+                       free(afhi.tags.title);
+                       free(afhi.tags.year);
+                       free(afhi.tags.album);
+                       free(afhi.tags.comment);
+                       free(afhi.chunk_table);
                        printf("\n");
                }
-               free(afhi.chunk_table);
-               free(afhi.info_string);
                ret2 = para_munmap(audio_file_data, audio_file_size);
                if (ret2 < 0 && ret >= 0)
                        ret = ret2;
diff --git a/afh.h b/afh.h
index 35cc7ef..50c46ee 100644 (file)
--- a/afh.h
+++ b/afh.h
 #define AAC_AUDIO_FORMAT ""
 #endif
 
-#define SUPPORTED_AUDIO_FORMATS "mp3" OV_AUDIO_FORMAT AAC_AUDIO_FORMAT
+#define SUPPORTED_AUDIO_FORMATS "mp3 " OV_AUDIO_FORMAT AAC_AUDIO_FORMAT " wma "
 
 /** \endcond */
 
+/**
+ * The tags used by all audio format handlers.
+ *
+ * Paraslash only uses the more common tags. These are recognized
+ * for all supported audio formats.
+ */
+struct taginfo {
+       /** TPE1 (id3v2) / ARTIST (vorbis) / ©ART (aac) */
+       char *artist;
+       /** TIT2/TITLE/©nam */
+       char *title;
+       /** TDRC/YEAR/©day */
+       char *year;
+       /** TALB/ALBUM/©alb */
+       char *album;
+       /** COMM/COMMENT/©cmt */
+       char *comment;
+};
+
 /** Audio format dependent information. */
 struct afh_info {
        /** The number of chunks this audio file contains. */
        long unsigned chunks_total;
        /** The length of the audio file in seconds. */
        long unsigned seconds_total;
-       /** A string that gets filled in by the audio format handler. */
-       char *info_string;
+       /** Audio handler specific info about the file. */
+       char *techinfo;
+       /** Id3 tags, vorbis comments, aac tags. */
+       struct taginfo tags;
        /**
         * The table that specifies the offset of the individual pieces in
         * the current audio file.
@@ -38,8 +59,6 @@ struct afh_info {
        uint32_t *chunk_table;
        /** Period of time between sending data chunks. */
        struct timeval chunk_tv;
-       /** End of file timeout - Do not load new audio file until this time. */
-       struct timeval eof_tv;
        /**
         * The position of the header within the audio file. Ignored if \a
         * header_len equals zero.
@@ -104,5 +123,3 @@ void afh_get_chunk(long unsigned chunk_num, struct afh_info *afhi,
                void *map, const char **buf, size_t *len);
 uint32_t afh_get_largest_chunk_size(struct afh_info *afhi);
 void afh_get_header(struct afh_info *afhi, void *map, const char **buf, size_t *len);
-char *make_taginfo(char *title, char *artist, char *album, char *year,
-               char *comment);
index 7d4ab08..1005139 100644 (file)
@@ -10,6 +10,7 @@
 #include <sys/time.h> /* gettimeofday */
 #include <sys/types.h>
 #include <dirent.h>
+#include <regex.h>
 
 #include "para.h"
 #include "error.h"
@@ -26,6 +27,7 @@ void mp3_init(struct audio_format_handler *);
        void aac_afh_init(struct audio_format_handler *);
 #endif
 
+void wma_afh_init(struct audio_format_handler *);
 /**
  * The list of supported audio formats.
  *
@@ -55,6 +57,10 @@ static struct audio_format_handler afl[] = {
                .init = aac_afh_init,
 #endif
        },
+       {
+               .name = "wma",
+               .init = wma_afh_init,
+       },
        {
                .name = NULL,
        }
@@ -121,39 +127,6 @@ int guess_audio_format(const char *name)
        return -E_AUDIO_FORMAT;
 }
 
-/**
- * Pretty-print the given meta-info.
- *
- * \param title The title of the audio file.
- * \param artist The artist.
- * \param album The name of the album.
- * \param year Year of release.
- * \param comment Further comments.
- *
- * This function is called by each audio format handler to produce the tag info
- * status items. Usually, the audio format handlers read this info from the
- * audio file (id3 tags, vorbis comments, ...).
- *
- * It is OK to pass \p NULL pointers for any argument in which case a suitable
- * string is inserted which indicates that this information is not available.
- *
- * \return The status item string. It must be freed by the caller.
- */
-char *make_taginfo(char *title, char *artist, char *album, char *year,
-               char *comment)
-{
-       return make_message("%s: %s, by %s\n" /* taginfo1 */
-               "%s: A: %s, Y: %s, C: %s\n", /* taginfo2 */
-               status_item_list[SI_TAGINFO1],
-               (title && *title)? title : "(title tag not set)",
-               (artist && *artist)? artist : "(artist tag not set)",
-               status_item_list[SI_TAGINFO2],
-               (album && *album)?  album : "(album tag not set)",
-               (year && *year)? year : "????",
-               (comment && *comment)? comment : "(comment tag not set)"
-       );
-}
-
 /**
  * Call get_file_info() to obtain an afhi structure.
  *
@@ -180,22 +153,52 @@ int compute_afhi(const char *path, char *data, size_t size, int fd,
 
        afhi->header_offset = 0;
        afhi->header_len = 0;
+       afhi->techinfo = NULL;
+       afhi->tags.artist = NULL;
+       afhi->tags.title = NULL;
+       afhi->tags.year = NULL;
+       afhi->tags.album = NULL;
+       afhi->tags.comment = NULL;
        format = guess_audio_format(path);
 
        if (format >= 0) {
                ret = afl[format].get_file_info(data, size, fd, afhi);
-               if (ret >= 0)
-                       return format;
+               if (ret >= 0) {
+                       ret = format;
+                       goto success;
+               }
        }
        FOR_EACH_AUDIO_FORMAT(i) {
                if (i == format) /* we already tried this one to no avail */
                        continue;
                ret = afl[i].get_file_info(data, size, fd, afhi);
-               if (ret >= 0)
-                       return i;
+               if (ret >= 0) {
+                       ret = i;
+                       goto success;
+               }
                PARA_WARNING_LOG("%s\n", para_strerror(-ret));
        }
        return -E_AUDIO_FORMAT;
+success:
+       if (!afhi->techinfo)
+               afhi->techinfo = para_strdup(NULL);
+       if (!afhi->tags.artist)
+               afhi->tags.artist = para_strdup(NULL);
+       if (!afhi->tags.title)
+               afhi->tags.title = para_strdup(NULL);
+       if (!afhi->tags.year)
+               afhi->tags.year = para_strdup(NULL);
+       if (!afhi->tags.album)
+               afhi->tags.album = para_strdup(NULL);
+       if (!afhi->tags.comment)
+               afhi->tags.comment = para_strdup(NULL);
+       PARA_DEBUG_LOG("techinfo: %s\n", afhi->techinfo);
+       PARA_DEBUG_LOG("artist: %s\n", afhi->tags.artist);
+       PARA_DEBUG_LOG("title: %s\n", afhi->tags.title);
+       PARA_DEBUG_LOG("year: %s\n", afhi->tags.year);
+       PARA_DEBUG_LOG("album: %s\n", afhi->tags.album);
+       PARA_DEBUG_LOG("comment: %s\n", afhi->tags.comment);
+       return ret;
 }
 
 /**
@@ -252,7 +255,7 @@ uint32_t afh_get_largest_chunk_size(struct afh_info *afhi)
  *
  * This function sets \a buf to \p NULL and \a len to zero if \a map or \a
  * afhi is \p NULL, or if the current audio format does not need special
- * header treamtment.
+ * header treatment.
  */
 void afh_get_header(struct afh_info *afhi, void *map, const char **buf, size_t *len)
 {
diff --git a/afs.c b/afs.c
index ccda7cd..1350db3 100644 (file)
--- a/afs.c
+++ b/afs.c
@@ -6,11 +6,16 @@
 
 /** \file afs.c Paraslash's audio file selector. */
 
+#include <regex.h>
 #include <signal.h>
 #include <fnmatch.h>
+#include <openssl/rc4.h>
+#include <osl.h>
+
 #include "server.cmdline.h"
 #include "para.h"
 #include "error.h"
+#include "crypt.h"
 #include "string.h"
 #include "afh.h"
 #include "afs.h"
@@ -24,6 +29,7 @@
 #include "sched.h"
 #include "signal.h"
 #include "fd.h"
+#include "mood.h"
 
 /** The osl tables used by afs. \sa blob.c. */
 enum afs_table_num {
@@ -85,7 +91,6 @@ static struct signal_task signal_task_struct;
 static enum play_mode current_play_mode;
 static char *current_mop; /* mode or playlist specifier. NULL means dummy mooe */
 
-
 /**
  * A random number used to "authenticate" the connection.
  *
@@ -342,7 +347,7 @@ static int action_if_pattern_matches(struct osl_row *row, void *data)
        struct pattern_match_data *pmd = data;
        struct osl_object name_obj;
        const char *p, *name;
-       int ret = osl_get_object(pmd->table, row, pmd->match_col_num, &name_obj);
+       int ret = osl(osl_get_object(pmd->table, row, pmd->match_col_num, &name_obj));
        const char *pattern_txt = (const char *)pmd->patterns.data;
 
        if (ret < 0)
@@ -369,16 +374,15 @@ static int action_if_pattern_matches(struct osl_row *row, void *data)
  *
  * \param pmd Describes what to match and how.
  *
- * \return The return value of the underlying call to osl_rbtree_loop()
- * or osl_rbtree_loop_reverse().
+ * \return Standard.
  */
 int for_each_matching_row(struct pattern_match_data *pmd)
 {
        if (pmd->pm_flags & PM_REVERSE_LOOP)
-               return osl_rbtree_loop_reverse(pmd->table, pmd->loop_col_num, pmd,
-                       action_if_pattern_matches);
-       return osl_rbtree_loop(pmd->table, pmd->loop_col_num, pmd,
-                       action_if_pattern_matches);
+               return osl(osl_rbtree_loop_reverse(pmd->table, pmd->loop_col_num, pmd,
+                       action_if_pattern_matches));
+       return osl(osl_rbtree_loop(pmd->table, pmd->loop_col_num, pmd,
+                       action_if_pattern_matches));
 }
 
 /**
@@ -403,80 +407,6 @@ int string_compare(const struct osl_object *obj1, const struct osl_object *obj2)
        return strncmp(str1, str2, PARA_MIN(obj1->size, obj2->size));
 }
 
-/*
- * write input from fd to dynamically allocated buffer,
- * but maximal max_size byte.
- */
-static int fd2buf(int fd, unsigned max_size, struct osl_object *obj)
-{
-       const size_t chunk_size = 1024;
-       size_t size = 2048, received = 0;
-       int ret;
-       char *buf = para_malloc(size);
-
-       for (;;) {
-               ret = recv_bin_buffer(fd, buf + received, chunk_size);
-               if (ret <= 0)
-                       break;
-               received += ret;
-               if (received + chunk_size >= size) {
-                       size *= 2;
-                       ret = -E_INPUT_TOO_LARGE;
-                       if (size > max_size)
-                               break;
-                       buf = para_realloc(buf, size);
-               }
-       }
-       obj->data = buf;
-       obj->size = received;
-       if (ret < 0)
-               free(buf);
-       return ret;
-}
-
-/**
- * Read data from a file descriptor, and send it to the afs process.
- *
- * \param fd File descriptor to read data from.
- * \param arg_obj Pointer to the arguments to \a f.
- * \param f The callback function.
- * \param max_len Don't read more than that many bytes from stdin.
- * \param result_handler See \ref send_callback_request.
- * \param private_result_data See \ref send_callback_request.
- *
- * This function is used by commands that wish to let para_server store
- * arbitrary data specified by the user (for instance the add_blob family of
- * commands). First, at most \a max_len bytes are read from \a fd, the result
- * is concatenated with the buffer given by \a arg_obj, and the combined buffer
- * is made available to the afs process via the callback method. See \ref
- * send_callback_request for details.
- *
- * \return Negative on errors, the return value of the underlying call to
- * send_callback_request() otherwise.
- */
-int stdin_command(int fd, struct osl_object *arg_obj, callback_function *f,
-               unsigned max_len, callback_result_handler *result_handler,
-               void *private_result_data)
-{
-       struct osl_object query, stdin_obj;
-       int ret;
-
-       ret = send_buffer(fd, AWAITING_DATA_MSG);
-       if (ret < 0)
-               return ret;
-       ret = fd2buf(fd, max_len, &stdin_obj);
-       if (ret < 0)
-               return ret;
-       query.size = arg_obj->size + stdin_obj.size;
-       query.data = para_malloc(query.size);
-       memcpy(query.data, arg_obj->data, arg_obj->size);
-       memcpy((char *)query.data + arg_obj->size, stdin_obj.data, stdin_obj.size);
-       free(stdin_obj.data);
-       ret = send_callback_request(f, &query, result_handler, private_result_data);
-       free(query.data);
-       return ret;
-}
-
 static int pass_afd(int fd, char *buf, size_t size)
 {
        struct msghdr msg = {.msg_iov = NULL};
@@ -652,21 +582,22 @@ out:
  * Result handler for sending data to the para_client process.
  *
  * \param result The data to be sent.
- * \param fd_ptr Pointer to the file descriptor.
+ * \param private Pointer to rc4 context.
  *
- * \return The return value of the underlying call to send_bin_buffer().
+ * \return The return value of the underlying call to rc4_send_bin_buffer().
  *
- * \sa \ref callback_result_handler.
+ * \sa \ref callback_result_handler, \ref rc4_send_bin_buffer().
  */
-int send_result(struct osl_object *result, void *fd_ptr)
+int rc4_send_result(struct osl_object *result, void *private)
 {
-       int fd = *(int *)fd_ptr;
+       struct rc4_context *rc4c = private;
+
        if (!result->size)
                return 1;
-       return send_bin_buffer(fd, result->data, result->size);
+       return rc4_send_bin_buffer(rc4c, result->data, result->size);
 }
 
-int com_select(int fd, int argc, char * const * const argv)
+int com_select(struct rc4_context *rc4c, int argc, char * const * const argv)
 {
        struct osl_object query;
 
@@ -675,7 +606,7 @@ int com_select(int fd, int argc, char * const * const argv)
        query.data = argv[1];
        query.size = strlen(argv[1]) + 1;
        return send_callback_request(com_select_callback, &query,
-               &send_result, &fd);
+               &rc4_send_result, rc4c);
 }
 
 static void init_admissible_files(char *arg)
@@ -730,7 +661,7 @@ static void get_database_dir(void)
                else {
                        char *home = para_homedir();
                        database_dir = make_message(
-                               "%s/.paraslash/afs_database", home);
+                               "%s/.paraslash/afs_database-0.4", home);
                        free(home);
                }
        }
@@ -1096,7 +1027,7 @@ out:
        free(pb.buf);
 }
 
-int com_init(int fd, int argc, char * const * const argv)
+int com_init(struct rc4_context *rc4c, int argc, char * const * const argv)
 {
        int i, j, ret;
        uint32_t table_mask = (1 << (NUM_AFS_TABLES + 1)) - 1;
@@ -1121,9 +1052,10 @@ int com_init(int fd, int argc, char * const * const argv)
                                return -E_BAD_TABLE_NAME;
                }
        }
-       ret = send_callback_request(create_tables_callback, &query, &send_result, &fd);
+       ret = send_callback_request(create_tables_callback, &query,
+               rc4_send_result, rc4c);
        if (ret < 0)
-               return send_va_buffer(fd, "%s\n", para_strerror(-ret));
+               return rc4_send_va_buffer(rc4c, "%s\n", para_strerror(-ret));
        return ret;
 }
 
@@ -1141,7 +1073,7 @@ enum com_check_flags {
        CHECK_PLAYLISTS = 4
 };
 
-int com_check(int fd, int argc, char * const * const argv)
+int com_check(struct rc4_context *rc4c, int argc, char * const * const argv)
 {
        unsigned flags = 0;
        int i, ret;
@@ -1173,17 +1105,20 @@ int com_check(int fd, int argc, char * const * const argv)
        if (!flags)
                flags = ~0U;
        if (flags & CHECK_AFT) {
-               ret = send_callback_request(aft_check_callback, NULL, send_result, &fd);
+               ret = send_callback_request(aft_check_callback, NULL,
+                       rc4_send_result, rc4c);
                if (ret < 0)
                        return ret;
        }
        if (flags & CHECK_PLAYLISTS) {
-               ret = send_callback_request(playlist_check_callback, NULL, send_result, &fd);
+               ret = send_callback_request(playlist_check_callback,
+                       NULL, rc4_send_result, rc4c);
                if (ret < 0)
                        return ret;
        }
        if (flags & CHECK_MOODS) {
-               ret = send_callback_request(mood_check_callback, NULL, send_result, &fd);
+               ret = send_callback_request(mood_check_callback, NULL,
+                       rc4_send_result, rc4c);
                if (ret < 0)
                        return ret;
        }
diff --git a/afs.cmd b/afs.cmd
index 0af4511..f055199 100644 (file)
--- a/afs.cmd
+++ b/afs.cmd
@@ -3,7 +3,8 @@ SF: afs.c aft.c attribute.c
 HC: Prototypes for the commands of the audio file selector.
 CC: Array of commands for the audio file selector.
 AT: server_command
-IN: para error string afh afs server list user_list
+SI: openssl/rc4 osl regex
+IN: para error crypt command string afh afs server list user_list
 SN: list of afs commands
 TM: mood lyr img pl
 ---
@@ -54,6 +55,8 @@ H:            -ll:   long listing mode (equivalent to -l)
 H:
 H:             -lv:   verbose listing mode
 H:
+H:             -lp:   parser-friendly mode
+H:
 H:             -lm:   mbox listing mode
 H:
 H:             -lc:   chunk-table listing mode
@@ -94,7 +97,7 @@ H:            -sa:  sort by audio format.
 ---
 N: lsatt
 P: AFS_READ
-D: List attributes
+D: List attributes.
 U: lsatt [-i] [-l] [-r] [pattern]
 H: Print the list of all defined attributes which match the
 H: given pattern. If no pattern is given, the full list is
@@ -184,7 +187,7 @@ H:  a slash (see fnmatch(3)).
 N: touch
 P: AFS_READ | AFS_WRITE
 D: Manipulate the afs data for all audio files matching a pattern.
-U: touch [-n numplayed] [-l lastplayed] [-y lyrics_id] [-i image_id] [-a amp] [-v] [-p] pattern
+U: touch [-n=numplayed] [-l=lastplayed] [-y=lyrics_id] [-i=image_id] [-a=amp] [-v] [-p] pattern
 H: If no option is given, lastplayed is set to the current time
 H: and numplayed is increased by one. Otherwise, only the given
 H: options are taken into account.
@@ -197,7 +200,7 @@ H:
 H: -l  Set lastplayed time. The last time this audio file was selected.
 H:     Must be given as the number of seconds since the epoch. Example:
 H:
-H:             touch -l $(date +%s) file
+H:             touch -l=$(date +%s) file
 H:
 H:     sets the lastplayed time of 'file' to the current time.
 H:
@@ -257,7 +260,7 @@ H: loads the mood named 'foo'.
 ---
 T: add
 N: add@member@
-O: int com_add@member@(int fd, int argc, char * const * const argv);
+O: int com_add@member@(struct rc4_context *rc4c, int argc, char * const * const argv);
 P: AFS_READ | AFS_WRITE
 D: Read data from stdin and add it as a blob to the @member@ table.
 U: add@member@ @member@_name
@@ -270,7 +273,7 @@ H: given name already exists, its contents are replaced by the new data.
 ---
 T: cat
 N: cat@member@
-O: int com_cat@member@(int fd, int argc, char * const * const argv);
+O: int com_cat@member@(struct rc4_context *rc4c, int argc, char * const * const argv);
 P: AFS_READ
 D: Dump the contents of a blob of type @member@ to stdout.
 U: cat@member@ @member@_name
@@ -280,7 +283,7 @@ H: they were previously added.
 ---
 T: ls
 N: ls@member@
-O: int com_ls@member@(int fd, int argc, char * const * const argv);
+O: int com_ls@member@(struct rc4_context *rc4c, int argc, char * const * const argv);
 P: AFS_READ
 D: List blobs of type @member@ matching a pattern.
 U: ls@member@ [-i] [-l] [-r] [pattern]
@@ -300,7 +303,7 @@ H: -r       Reverse sort order.
 ---
 T: rm
 N: rm@member@
-O: int com_rm@member@(int fd, int argc, char * const * const argv);
+O: int com_rm@member@(struct rc4_context *rc4c, int argc, char * const * const argv);
 P: AFS_READ | AFS_WRITE
 D: Remove blob(s) of type @member@ from the @member@ table.
 U: rm@member@ pattern...
@@ -309,7 +312,7 @@ H: any given pattern.
 ---
 T: mv
 N: mv@member@
-O: int com_mv@member@(int fd, int argc, char * const * const argv);
+O: int com_mv@member@(struct rc4_context *rc4c, int argc, char * const * const argv);
 P: AFS_READ | AFS_WRITE
 D: Rename a blob of type @member@.
 U: mv@member@ old_@member@_name new_@member@_name
diff --git a/afs.h b/afs.h
index bcc3630..aeaf8fb 100644 (file)
--- a/afs.h
+++ b/afs.h
@@ -7,7 +7,6 @@
 /** \file afs.h Exported symbols of the audio file selector. */
 
 #include <regex.h>
-#include "osl.h"
 #include "hash.h"
 
 /** Audio file selector data stored in the audio file table. */
@@ -118,15 +117,8 @@ struct ls_data {
        HASH_TYPE *hash;
 };
 
-void make_empty_status_items(char *buf);
-
-/** At most that many bytes will be passed from afs to para_server. */
-#define VERBOSE_LS_OUTPUT_SIZE 4096
-
 /** Data about the current audio file, passed from afs to server. */
 struct audio_file_data {
-       /** Same info as ls -lv -p current audio_file. */
-       char verbose_ls_output[VERBOSE_LS_OUTPUT_SIZE];
        /** The open file descriptor to the current audio file. */
        int fd;
        /** Vss needs this for streaming. */
@@ -188,7 +180,7 @@ typedef void callback_function(int fd, const struct osl_object *);
  * \sa \ref send_callback_request().
  */
 typedef int callback_result_handler(struct osl_object *result, void *private);
-int send_result(struct osl_object *result, void *fd_ptr);
+int rc4_send_result(struct osl_object *result, void *private);
 int pass_buffer_as_shm(char *buf, size_t size, void *fd_ptr);
 
 __noreturn void afs_init(uint32_t cookie, int socket_fd);
@@ -204,9 +196,6 @@ int send_option_arg_callback_request(struct osl_object *options,
 int send_standard_callback_request(int argc,  char * const * const argv,
                callback_function *f, callback_result_handler *result_handler,
                void *private_result_data);
-int stdin_command(int fd, struct osl_object *arg_obj, callback_function *f,
-               unsigned max_len, callback_result_handler *result_handler,
-               void *private_result_data);
 int string_compare(const struct osl_object *obj1, const struct osl_object *obj2);
 int for_each_matching_row(struct pattern_match_data *pmd);
 
@@ -245,13 +234,6 @@ int get_afsi_object_of_row(const struct osl_row *row, struct osl_object *obj);
 int audio_file_loop(void *private_data, osl_rbtree_loop_func *func);
 void aft_check_callback(int fd, __a_unused const struct osl_object *query);
 
-/* mood */
-int change_current_mood(char *mood_name);
-void close_current_mood(void);
-int reload_current_mood(void);
-void mood_check_callback(int fd, __a_unused const struct osl_object *query);
-
-
 /* playlist */
 int playlist_open(char *name);
 void playlist_close(void);
@@ -289,21 +271,3 @@ enum blob_table_columns {
        /** A blob table has that many columns. */
        NUM_BLOB_COLUMNS
 };
-
-/** Define an osl table description for a blob table. */
-#define DEFINE_BLOB_TABLE_DESC(table_name) \
-       struct osl_table_description table_name ## _table_desc = { \
-               .name = #table_name, \
-               .num_columns = NUM_BLOB_COLUMNS, \
-               .flags = OSL_LARGE_TABLE, \
-               .column_descriptions = blob_cols \
-       };
-
-/** Define a pointer to an osl blob table with a canonical name. */
-#define DEFINE_BLOB_TABLE_PTR(table_name) struct osl_table *table_name ## _table;
-
-/** Define a blob table. */
-#define INIT_BLOB_TABLE(table_name) \
-       DEFINE_BLOB_TABLE_DESC(table_name); \
-       DEFINE_BLOB_TABLE_PTR(table_name);
-
diff --git a/aft.c b/aft.c
index 5fb0480..39e94a9 100644 (file)
--- a/aft.c
+++ b/aft.c
@@ -6,14 +6,18 @@
 
 /** \file aft.c Audio file table functions. */
 
+#include <regex.h>
 #include <dirent.h> /* readdir() */
-#include "para.h"
-#include "error.h"
-#include "string.h"
+#include <openssl/rc4.h>
 #include <sys/mman.h>
 #include <fnmatch.h>
 #include <sys/shm.h>
+#include <osl.h>
 
+#include "para.h"
+#include "error.h"
+#include "crypt.h"
+#include "string.h"
 #include "afh.h"
 #include "afs.h"
 #include "net.h"
@@ -23,6 +27,8 @@
 #include "portable_io.h"
 
 static struct osl_table *audio_file_table;
+static char *status_items;
+static char *parser_friendly_status_items;
 
 /** The different sorting methods of the ls command. */
 enum ls_sorting_method {
@@ -63,7 +69,9 @@ enum ls_listing_mode {
        /** -lm */
        LS_MODE_MBOX,
        /** -lc */
-       LS_MODE_CHUNKS
+       LS_MODE_CHUNKS,
+       /** -lp */
+       LS_MODE_PARSER,
 };
 
 /** The flags accepted by the ls command. */
@@ -220,12 +228,27 @@ enum audio_file_table_columns {
        NUM_AFT_COLUMNS
 };
 
+/**
+ * Compare two osl objects pointing to hash values.
+ *
+ * \param obj1 Pointer to the first hash object.
+ * \param obj2 Pointer to the second hash object.
+ *
+ * \return The values required for an osl compare function.
+ *
+ * \sa osl_compare_func, uint32_compare().
+ */
+static int aft_hash_compare(const struct osl_object *obj1, const struct osl_object *obj2)
+{
+       return hash_compare((HASH_TYPE *)obj1->data, (HASH_TYPE *)obj2->data);
+}
+
 static struct osl_column_description aft_cols[] = {
        [AFTCOL_HASH] = {
                .storage_type = OSL_MAPPED_STORAGE,
                .storage_flags = OSL_RBTREE | OSL_FIXED_SIZE | OSL_UNIQUE,
                .name = "hash",
-               .compare_function = osl_hash_compare,
+               .compare_function = aft_hash_compare,
                .data_size = HASH_SIZE
        },
        [AFTCOL_PATH] = {
@@ -338,23 +361,29 @@ enum afhi_offsets {
        CHUNK_TV_TV_USEC_OFFSET = 36,
        /** Number of channels is stored here. (1 byte) */
        AFHI_CHANNELS_OFFSET = 40,
-       /** EOF timeout in ms. (2 byte) */
-       AFHI_EOF_OFFSET = 41,
        /** The tag info position. */
-       AFHI_INFO_STRING_OFFSET = 43,
+       AFHI_INFO_STRING_OFFSET = 41,
        /** Minimal on-disk size of a valid afhi struct. */
-       MIN_AFHI_SIZE = 44
+       MIN_AFHI_SIZE = 47, /* at least 6 null bytes for techinfo/tags */
 };
 
 static unsigned sizeof_afhi_buf(const struct afh_info *afhi)
 {
        if (!afhi)
                return 0;
-       return strlen(afhi->info_string) + MIN_AFHI_SIZE;
+       return MIN_AFHI_SIZE
+               + strlen(afhi->techinfo)
+               + strlen(afhi->tags.artist)
+               + strlen(afhi->tags.title)
+               + strlen(afhi->tags.year)
+               + strlen(afhi->tags.album)
+               + strlen(afhi->tags.comment);
 }
 
 static void save_afhi(struct afh_info *afhi, char *buf)
 {
+       char *p;
+
        if (!afhi)
                return;
        write_u32(buf + AFHI_SECONDS_TOTAL_OFFSET, afhi->seconds_total);
@@ -368,8 +397,14 @@ static void save_afhi(struct afh_info *afhi, char *buf)
        write_u32(buf + HEADER_OFFSET_OFFSET, afhi->header_offset);
        write_u32(buf + CHUNK_TV_TV_SEC_OFFSET, afhi->chunk_tv.tv_sec);
        write_u32(buf + CHUNK_TV_TV_USEC_OFFSET, afhi->chunk_tv.tv_usec);
-       write_u16(buf + AFHI_EOF_OFFSET, tv2ms(&afhi->eof_tv));
-       strcpy(buf + AFHI_INFO_STRING_OFFSET, afhi->info_string); /* OK */
+       p = buf + AFHI_INFO_STRING_OFFSET;
+       /* The sprintf's below are OK as our caller made sure that buf is large enough */
+       p += sprintf(p, "%s", afhi->techinfo) + 1;
+       p += sprintf(p, "%s", afhi->tags.artist) + 1;
+       p += sprintf(p, "%s", afhi->tags.title) + 1;
+       p += sprintf(p, "%s", afhi->tags.year) + 1;
+       p += sprintf(p, "%s", afhi->tags.album) + 1;
+       sprintf(p, "%s", afhi->tags.comment);
 }
 
 static void load_afhi(const char *buf, struct afh_info *afhi)
@@ -385,8 +420,12 @@ static void load_afhi(const char *buf, struct afh_info *afhi)
        afhi->header_offset = read_u32(buf + HEADER_OFFSET_OFFSET);
        afhi->chunk_tv.tv_sec = read_u32(buf + CHUNK_TV_TV_SEC_OFFSET);
        afhi->chunk_tv.tv_usec = read_u32(buf + CHUNK_TV_TV_USEC_OFFSET);
-       ms2tv(read_u16(buf + AFHI_EOF_OFFSET), &afhi->eof_tv);
-       afhi->info_string = para_strdup(buf + AFHI_INFO_STRING_OFFSET);
+       afhi->techinfo = (char *)buf + AFHI_INFO_STRING_OFFSET;
+       afhi->tags.artist = afhi->techinfo + strlen(afhi->techinfo) + 1;
+       afhi->tags.title = afhi->tags.artist + strlen(afhi->tags.artist) + 1;
+       afhi->tags.year = afhi->tags.title + strlen(afhi->tags.title) + 1;
+       afhi->tags.album = afhi->tags.year + strlen(afhi->tags.year) + 1;
+       afhi->tags.comment = afhi->tags.album + strlen(afhi->tags.album) + 1;
 }
 
 static unsigned sizeof_chunk_table(struct afh_info *afhi)
@@ -419,27 +458,27 @@ static void load_chunk_table(struct afh_info *afhi, char *buf)
  * \param path The full path of the audio file.
  * \param row Result pointer.
  *
- * \return The return value of the underlying call to osl_get_row().
+ * \return Standard.
  */
 int aft_get_row_of_path(const char *path, struct osl_row **row)
 {
        struct osl_object obj = {.data = (char *)path, .size = strlen(path) + 1};
 
-       return osl_get_row(audio_file_table, AFTCOL_PATH, &obj, row);
+       return osl(osl_get_row(audio_file_table, AFTCOL_PATH, &obj, row));
 }
 
 /**
  * Get the row of the audio file table corresponding to the given hash value.
  *
  * \param hash The hash value of the desired audio file.
- * \param row resul pointer.
+ * \param row Result pointer.
  *
- * \return The return value of the underlying call to osl_get_row().
+ * \return Standard.
  */
-int aft_get_row_of_hash(HASH_TYPE *hash, struct osl_row **row)
+static int aft_get_row_of_hash(HASH_TYPE *hash, struct osl_row **row)
 {
        const struct osl_object obj = {.data = hash, .size = HASH_SIZE};
-       return osl_get_row(audio_file_table, AFTCOL_HASH, &obj, row);
+       return osl(osl_get_row(audio_file_table, AFTCOL_HASH, &obj, row));
 }
 
 /**
@@ -448,11 +487,11 @@ int aft_get_row_of_hash(HASH_TYPE *hash, struct osl_row **row)
  * \param row Pointer to a row in the audio file table.
  * \param obj Result pointer.
  *
- * \return The return value of the underlying call to osl_get_object().
+ * \return Standard.
  */
 int get_afsi_object_of_row(const struct osl_row *row, struct osl_object *obj)
 {
-       return osl_get_object(audio_file_table, row, AFTCOL_AFSI, obj);
+       return osl(osl_get_object(audio_file_table, row, AFTCOL_AFSI, obj));
 }
 
 /**
@@ -464,7 +503,7 @@ int get_afsi_object_of_row(const struct osl_row *row, struct osl_object *obj)
  *
  * \return Positive on success, negative on errors.
  */
-int get_afsi_object_of_path(const char *path, struct osl_object *obj)
+static int get_afsi_object_of_path(const char *path, struct osl_object *obj)
 {
        struct osl_row *row;
        int ret = aft_get_row_of_path(path, &row);
@@ -521,8 +560,8 @@ int get_afsi_of_path(const char *path, struct afs_info *afsi)
 int get_audio_file_path_of_row(const struct osl_row *row, char **path)
 {
        struct osl_object path_obj;
-       int ret = osl_get_object(audio_file_table, row, AFTCOL_PATH,
-               &path_obj);
+       int ret = osl(osl_get_object(audio_file_table, row, AFTCOL_PATH,
+               &path_obj));
        if (ret < 0)
                return ret;
        *path = path_obj.data;
@@ -539,9 +578,10 @@ int get_audio_file_path_of_row(const struct osl_row *row, char **path)
  *
  * \sa get_hash_of_row().
  */
-static int get_hash_object_of_aft_row(const struct osl_row *row, struct osl_object *obj)
+static int get_hash_object_of_aft_row(const struct osl_row *row,
+               struct osl_object *obj)
 {
-       return osl_get_object(audio_file_table, row, AFTCOL_HASH, obj);
+       return osl(osl_get_object(audio_file_table, row, AFTCOL_HASH, obj));
 }
 
 /**
@@ -579,8 +619,8 @@ static int get_hash_of_row(const struct osl_row *row, HASH_TYPE **hash)
 int get_afhi_of_row(const struct osl_row *row, struct afh_info *afhi)
 {
        struct osl_object obj;
-       int ret = osl_get_object(audio_file_table, row, AFTCOL_AFHI,
-               &obj);
+       int ret = osl(osl_get_object(audio_file_table, row, AFTCOL_AFHI,
+               &obj));
        if (ret < 0)
                return ret;
        load_afhi(obj.data, afhi);
@@ -691,56 +731,68 @@ static void get_duration_buf(int seconds, char *buf, struct ls_options *opts)
        }
 }
 
-static char *make_attribute_lines(const char *att_bitmap, struct afs_info *afsi)
+
+static int write_attribute_items(struct para_buffer *b,
+               const char *att_bitmap, struct afs_info *afsi)
 {
-       char *att_text, *att_lines;
+       char *att_text;
+       int ret;
 
-       get_attribute_text(&afsi->attributes, " ", &att_text);
-       if (!att_text)
-               return para_strdup(att_bitmap);
-       att_lines = make_message("%s: %s\n%s: %s",
-               status_item_list[SI_ATTRIBUTES_BITMAP], att_bitmap,
-               status_item_list[SI_ATTRIBUTES_TXT], att_text);
+       ret = WRITE_STATUS_ITEM(b, SI_ATTRIBUTES_BITMAP, "%s\n", att_bitmap);
+       if (ret < 0)
+               return ret;
+       ret = get_attribute_text(&afsi->attributes, " ", &att_text);
+       if (ret < 0)
+               return ret;
+       ret = WRITE_STATUS_ITEM(b, SI_ATTRIBUTES_TXT, "%s\n", att_text);
        free(att_text);
-       return att_lines;
+       return ret;
 }
 
-static char *make_lyrics_lines(struct afs_info *afsi)
+static int write_lyrics_items(struct para_buffer *b, struct afs_info *afsi)
 {
        char *lyrics_name;
+       int ret;
 
+       ret = WRITE_STATUS_ITEM(b, SI_LYRICS_ID, "%u\n", afsi->lyrics_id);
+       if (ret < 0)
+               return ret;
        lyr_get_name_by_id(afsi->lyrics_id, &lyrics_name);
-       return make_message("%s: %u\n%s: %s\n",
-               status_item_list[SI_LYRICS_ID], afsi->lyrics_id,
-               status_item_list[SI_LYRICS_NAME], lyrics_name?
-                       lyrics_name : "(none)");
+       return WRITE_STATUS_ITEM(b, SI_LYRICS_NAME, "%s\n", lyrics_name?
+               lyrics_name : "(none)");
 }
 
-static char *make_image_lines(struct afs_info *afsi)
+static int write_image_items(struct para_buffer *b, struct afs_info *afsi)
 {
        char *image_name;
+       int ret;
+
+       ret = WRITE_STATUS_ITEM(b, SI_IMAGE_ID, "%u\n", afsi->image_id);
+       if (ret < 0)
+               return ret;
        img_get_name_by_id(afsi->image_id, &image_name);
-       return make_message("%s: %u\n%s: %s\n",
-               status_item_list[SI_IMAGE_ID], afsi->image_id,
-               status_item_list[SI_IMAGE_NAME], image_name?
-                       image_name : "(none)");
+       return WRITE_STATUS_ITEM(b, SI_IMAGE_NAME, "%s\n", image_name?
+               image_name : "(none)");
 }
 
-static char *make_filename_lines(const char *path, unsigned flags)
+static int write_filename_items(struct para_buffer *b, const char *path,
+               unsigned flags)
 {
-       char *dirname, *ret;
-       const char *basename;
+       char *val;
+       int ret;
 
        if (!(flags & LS_FLAG_FULL_PATH))
-               return make_message("%s: %s\n",
-                       status_item_list[SI_BASENAME], path);
-       basename = para_basename(path),
-       dirname = para_dirname(path);
-       ret = make_message("%s: %s\n%s: %s\n%s: %s\n",
-               status_item_list[SI_PATH], path,
-               status_item_list[SI_DIRECTORY], dirname? dirname : "?",
-               status_item_list[SI_BASENAME], basename? basename : "?");
-       free(dirname);
+               return WRITE_STATUS_ITEM(b, SI_BASENAME, "%s\n", path);
+       ret = WRITE_STATUS_ITEM(b, SI_PATH, "%s\n", path);
+       if (ret < 0)
+               return ret;
+       val = para_basename(path);
+       ret = WRITE_STATUS_ITEM(b, SI_BASENAME, "%s\n", val? val : "");
+       if (ret < 0)
+               return ret;
+       val = para_dirname(path);
+       ret = WRITE_STATUS_ITEM(b, SI_DIRECTORY, "%s\n", val? val : "");
+       free(val);
        return ret;
 }
 
@@ -778,6 +830,14 @@ out:
        return ret;
 }
 
+static int write_score(struct para_buffer *b, struct ls_data *d,
+               struct ls_options *opts)
+{
+       if (!(opts->flags & LS_FLAG_ADMISSIBLE_ONLY)) /* no score*/
+               return 0;
+       return WRITE_STATUS_ITEM(b, SI_SCORE, "%li\n", d->score);
+}
+
 static int print_list_item(struct ls_data *d, struct ls_options *opts,
        struct para_buffer *b, time_t current_time)
 {
@@ -785,13 +845,9 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts,
        char att_buf[65];
        char last_played_time[30];
        char duration_buf[30]; /* nobody has an audio file long enough to overflow this */
-       char score_buf[30] = "";
        struct afs_info *afsi = &d->afsi;
        struct afh_info *afhi = &d->afhi;
-       struct ls_widths *w = &opts->widths;
-       int have_score = opts->flags & LS_FLAG_ADMISSIBLE_ONLY;
        char asc_hash[2 * HASH_SIZE + 1];
-       char *att_lines, *lyrics_lines, *image_lines, *filename_lines;
 
        if (opts->mode == LS_MODE_SHORT) {
                ret = para_printf(b, "%s\n", d->path);
@@ -812,16 +868,15 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts,
                        goto out;
        }
        get_duration_buf(afhi->seconds_total, duration_buf, opts);
-       if (have_score) {
-               if (opts->mode == LS_MODE_LONG)
-                       sprintf(score_buf, "%*li ", w->score_width, d->score);
-               else
-                       sprintf(score_buf, "%li ", d->score);
-       }
-
        if (opts->mode == LS_MODE_LONG) {
+               struct ls_widths *w = &opts->widths;
+               if (opts->flags & LS_FLAG_ADMISSIBLE_ONLY) {
+                       ret = para_printf(b, "%*li ",
+                               opts->widths.score_width, d->score);
+                       if (ret < 0)
+                               goto out;
+               }
                ret = para_printf(b,
-                       "%s"    /* score */
                        "%s "   /* attributes */
                        "%*u "  /* amp */
                        "%*d "  /* image_id  */
@@ -834,7 +889,6 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts,
                        "%*d "  /* num_played */
                        "%s "   /* last_played */
                        "%s\n", /* path */
-                       score_buf,
                        att_buf,
                        w->amp_width, afsi->amp,
                        w->image_id_width, afsi->image_id,
@@ -850,11 +904,6 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts,
                );
                goto out;
        }
-       hash_to_asc(d->hash, asc_hash);
-       att_lines = make_attribute_lines(att_buf, afsi);
-       lyrics_lines = make_lyrics_lines(afsi);
-       image_lines = make_image_lines(afsi);
-       filename_lines = make_filename_lines(d->path, opts->flags);
        if (opts->mode == LS_MODE_MBOX) {
                const char *bn = para_basename(d->path);
                ret = para_printf(b,
@@ -866,47 +915,78 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts,
                if (ret < 0)
                        goto out;
        }
-       ret = para_printf(b,
-               "%s" /* filename stuff */
-               "%s%s%s%s" /* score */
-               "%s\n" /* attributes */
-               "%s: %s\n" /* hash */
-               "%s" /* image id, image name */
-               "%s" /* lyrics */
-               "%s: %dkbit/s\n" /* bitrate */
-               "%s: %s\n" /* format */
-               "%s: %dHz\n" /* frequency */
-               "%s: %d\n" /* channels */
-               "%s: %s\n" /* duration */
-               "%s: %lu\n" /* seconds total */
-               "%s: %s\n" /* last played time */
-               "%s: %d\n" /* num_played */
-               "%s: %u\n" /* ampplification */
-               "%s" /* tag info */
-               "%s: %lu\n" /* chunk time */
-               "%s: %lu\n", /* num chunks */
-               filename_lines,
-               have_score? status_item_list[SI_SCORE] : "",
-                       have_score? ": " : "",
-                       score_buf,
-                       have_score? "\n" : "",
-               att_lines,
-               status_item_list[SI_HASH], asc_hash,
-               image_lines,
-               lyrics_lines,
-               status_item_list[SI_BITRATE], afhi->bitrate,
-               status_item_list[SI_FORMAT], audio_format_name(afsi->audio_format_id),
-               status_item_list[SI_FREQUENCY], afhi->frequency,
-               status_item_list[SI_CHANNELS], afhi->channels,
-               status_item_list[SI_DURATION], duration_buf,
-               status_item_list[SI_SECONDS_TOTAL], afhi->seconds_total,
-               status_item_list[SI_LAST_PLAYED], last_played_time,
-               status_item_list[SI_NUM_PLAYED], afsi->num_played,
-               status_item_list[SI_AMPLIFICATION], afsi->amp,
-               afhi->info_string,
-               status_item_list[SI_CHUNK_TIME], tv2ms(&afhi->chunk_tv),
-               status_item_list[SI_NUM_CHUNKS], afhi->chunks_total
-       );
+       ret = write_filename_items(b, d->path, opts->flags);
+       if (ret < 0)
+               goto out;
+       ret = write_score(b, d, opts);
+       if (ret < 0)
+               goto out;
+       ret = write_attribute_items(b, att_buf, afsi);
+       if (ret < 0)
+               goto out;
+       ret = write_image_items(b, afsi);
+       if (ret < 0)
+               goto out;
+       ret = write_lyrics_items(b, afsi);
+       if (ret < 0)
+               goto out;
+       hash_to_asc(d->hash, asc_hash);
+       ret = WRITE_STATUS_ITEM(b, SI_HASH, "%s\n", asc_hash);
+       if (ret < 0)
+               goto out;
+       ret = WRITE_STATUS_ITEM(b, SI_BITRATE, "%dkbit/s\n", afhi->bitrate);
+       if (ret < 0)
+               goto out;
+       ret = WRITE_STATUS_ITEM(b, SI_FORMAT, "%s\n",
+               audio_format_name(afsi->audio_format_id));
+       if (ret < 0)
+               goto out;
+       ret = WRITE_STATUS_ITEM(b, SI_FREQUENCY, "%dHz\n", afhi->frequency);
+       if (ret < 0)
+               goto out;
+       ret = WRITE_STATUS_ITEM(b, SI_CHANNELS, "%d\n", afhi->channels);
+       if (ret < 0)
+               goto out;
+       ret = WRITE_STATUS_ITEM(b, SI_DURATION, "%s\n", duration_buf);
+       if (ret < 0)
+               goto out;
+       ret = WRITE_STATUS_ITEM(b, SI_SECONDS_TOTAL, "%lu\n",
+               afhi->seconds_total);
+       if (ret < 0)
+               goto out;
+       ret = WRITE_STATUS_ITEM(b, SI_LAST_PLAYED, "%s\n", last_played_time);
+       if (ret < 0)
+               goto out;
+       ret = WRITE_STATUS_ITEM(b, SI_NUM_PLAYED, "%d\n", afsi->num_played);
+       if (ret < 0)
+               goto out;
+       ret = WRITE_STATUS_ITEM(b, SI_AMPLIFICATION, "%u\n", afsi->amp);
+       if (ret < 0)
+               goto out;
+       ret = WRITE_STATUS_ITEM(b, SI_CHUNK_TIME, "%lu\n",
+               tv2ms(&afhi->chunk_tv));
+       if (ret < 0)
+               goto out;
+       ret = WRITE_STATUS_ITEM(b, SI_NUM_CHUNKS, "%lu\n",
+               afhi->chunks_total);
+       if (ret < 0)
+               goto out;
+       ret = WRITE_STATUS_ITEM(b, SI_TECHINFO, "%s\n", afhi->techinfo);
+       if (ret < 0)
+               goto out;
+       ret = WRITE_STATUS_ITEM(b, SI_ARTIST, "%s\n", afhi->tags.artist);
+       if (ret < 0)
+               goto out;
+       ret = WRITE_STATUS_ITEM(b, SI_TITLE, "%s\n", afhi->tags.title);
+       if (ret < 0)
+               goto out;
+       ret = WRITE_STATUS_ITEM(b, SI_YEAR, "%s\n", afhi->tags.year);
+       if (ret < 0)
+               goto out;
+       ret = WRITE_STATUS_ITEM(b, SI_ALBUM, "%s\n", afhi->tags.album);
+       if (ret < 0)
+               goto out;
+       ret = WRITE_STATUS_ITEM(b, SI_COMMENT, "%s\n", afhi->tags.comment);
        if (ret < 0)
                goto out;
        if (opts->mode == LS_MODE_MBOX) {
@@ -918,129 +998,10 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts,
                        osl_close_disk_object(&lyrics_def);
                }
        }
-       free(att_lines);
-       free(lyrics_lines);
-       free(image_lines);
-       free(filename_lines);
 out:
-       free(afhi->info_string);
        return ret;
 }
 
-/**
- * Write a list of audio-file related status items with empty values.
- *
- * \param buf Result pointer.
- *
- * This is used by vss when currently no audio file is open.
- */
-void make_empty_status_items(char *buf)
-{
-       sprintf(buf,
-               "%s: \n" /* path */
-               "%s: \n" /* dirname */
-               "%s: \n" /* basename */
-               "%s: \n" /* score */
-               "%s: \n" /* attributes bitmap */
-               "%s: \n" /* attributes txt */
-               "%s: \n" /* hash */
-               "%s: \n" /* image id */
-               "%s: \n" /* image name */
-               "%s: \n" /* lyrics id */
-               "%s: \n" /* lyrics name */
-               "%s: \n" /* bitrate */
-               "%s: \n" /* format */
-               "%s: \n" /* frequency */
-               "%s: \n" /* channels */
-               "%s: \n" /* duration */
-               "%s: \n" /* seconds total */
-               "%s: \n" /* num played */
-               "%s: \n" /* last played */
-               "%s: \n" /* audio file info */
-               "%s: \n" /* taginfo1 */
-               "%s: \n" /* taginfo2 */
-               "%s: \n" /* amplification */
-               ,
-               status_item_list[SI_PATH],
-               status_item_list[SI_DIRECTORY],
-               status_item_list[SI_BASENAME],
-               status_item_list[SI_SCORE],
-               status_item_list[SI_ATTRIBUTES_BITMAP],
-               status_item_list[SI_ATTRIBUTES_TXT],
-               status_item_list[SI_HASH],
-               status_item_list[SI_IMAGE_ID],
-               status_item_list[SI_IMAGE_NAME],
-               status_item_list[SI_LYRICS_ID],
-               status_item_list[SI_LYRICS_NAME],
-               status_item_list[SI_BITRATE],
-               status_item_list[SI_FORMAT],
-               status_item_list[SI_FREQUENCY],
-               status_item_list[SI_CHANNELS],
-               status_item_list[SI_DURATION],
-               status_item_list[SI_SECONDS_TOTAL],
-               status_item_list[SI_NUM_PLAYED],
-               status_item_list[SI_LAST_PLAYED],
-               status_item_list[SI_AUDIO_FILE_INFO],
-               status_item_list[SI_TAGINFO1],
-               status_item_list[SI_TAGINFO2],
-               status_item_list[SI_AMPLIFICATION]
-       );
-}
-
-static void fixup_taginfo(char *begin, char *end)
-{
-       char *p = begin;
-
-       for (;;) {
-               p = strchr(p, '\n');
-               if (!p)
-                       break;
-               if (p >= end - 1)
-                       break;
-               *p = ' ';
-               p++;
-       }
-}
-
-/* crap, remove this ASAP. */
-static int fixup_info_string(char *info_string)
-{
-       char *t1, *t2, *end;
-
-       if (strncmp(info_string, "audio_file_info:", 16))
-               return -ERRNO_TO_PARA_ERROR(EINVAL);
-       t1 = strstr(info_string, "\ntaginfo1:");
-       if (!t1)
-               return -ERRNO_TO_PARA_ERROR(EINVAL);
-       t2 = strstr(info_string, "\ntaginfo2: ");
-       if (!t2)
-               return -ERRNO_TO_PARA_ERROR(EINVAL);
-
-       end = t2 + strlen(t2);
-       fixup_taginfo(info_string + 16, t1);
-       fixup_taginfo(t1 + 10, t2);
-       fixup_taginfo(t2 + 10, end);
-
-       if (t1 - info_string < 80 && t2 - t1 < 80 && end - t2 < 80)
-               return 0;
-       if (t1 - info_string >= 80) {
-               memmove(info_string + 80, t1, end - t1);
-               t1 = info_string + 80;
-               t2 -= t1 - info_string - 80;
-               end -= t1 - info_string - 80;
-       }
-       if (t2 - t1 >= 80) {
-               memmove(t1 + 80, t2, end - t2);
-               end -= t2 - t1 - 80;
-               t2 = t1 + 80;
-       }
-       if (end - t2 >= 80) {
-               t2[78] = '\n';
-               t2[79] = '\0';
-       }
-       return 1;
-}
-
 static int make_status_items(struct audio_file_data *afd,
                struct afs_info *afsi, char *path, long score,
                HASH_TYPE *hash)
@@ -1056,26 +1017,28 @@ static int make_status_items(struct audio_file_data *afd,
                .flags = LS_FLAG_FULL_PATH | LS_FLAG_ADMISSIBLE_ONLY,
                .mode = LS_MODE_VERBOSE,
        };
-       struct para_buffer pb = {.max_size = VERBOSE_LS_OUTPUT_SIZE - 1};
+       struct para_buffer pb = {.max_size = SHMMAX - 1};
        time_t current_time;
        int ret;
 
-       ret = fixup_info_string(afd->afhi.info_string);
-       if (ret < 0) {
-               PARA_WARNING_LOG("ignoring invalid tag info\n");
-               afd->afhi.info_string[0] = '\0';
-       } else if (ret)
-               PARA_NOTICE_LOG("truncated overlong tag info\n");
        time(&current_time);
-       ret = print_list_item(&d, &opts, &pb, current_time); /* frees info string */
-       afd->afhi.info_string = NULL;
+       ret = print_list_item(&d, &opts, &pb, current_time);
        if (ret < 0)
-               goto out;
-       strncpy(afd->verbose_ls_output, pb.buf, VERBOSE_LS_OUTPUT_SIZE);
-       afd->verbose_ls_output[VERBOSE_LS_OUTPUT_SIZE - 1] = '\0';
-out:
-       free(pb.buf);
-       return ret;
+               return ret;
+       free(status_items);
+       status_items = pb.buf;
+       memset(&pb, 0, sizeof(pb));
+       pb.max_size = SHMMAX - 1;
+       pb.flags = PBF_SIZE_PREFIX;
+       ret = print_list_item(&d, &opts, &pb, current_time);
+       if (ret < 0) {
+               free(status_items);
+               status_items = NULL;
+               return ret;
+       }
+       free(parser_friendly_status_items);
+       parser_friendly_status_items = pb.buf;
+       return 1;
 }
 
 /**
@@ -1147,7 +1110,6 @@ int open_and_update_audio_file(struct osl_row *aft_row, long score,
        ret = save_afd(afd);
 err:
        free(afd->afhi.chunk_table);
-       free(afd->afhi.info_string);
        osl_close_disk_object(&chunk_table_obj);
        return ret;
 }
@@ -1350,7 +1312,6 @@ static int prepare_ls_row(struct osl_row *row, void *ls_opts)
        }
        return 1;
 err:
-       free(d->afhi.info_string);
        return ret;
 }
 
@@ -1359,11 +1320,11 @@ static void com_ls_callback(int fd, const struct osl_object *query)
        struct ls_options *opts = query->data;
        char *p, *pattern_start = (char *)query->data + sizeof(*opts);
        struct para_buffer b = {.max_size = SHMMAX,
+               .flags = (opts->mode == LS_MODE_PARSER)? PBF_SIZE_PREFIX : 0,
                .max_size_handler = pass_buffer_as_shm, .private_data = &fd};
        int i = 0, ret;
        time_t current_time;
 
-
        if (opts->num_patterns) {
                opts->patterns = para_malloc(opts->num_patterns * sizeof(char *));
                for (i = 0, p = pattern_start; i < opts->num_patterns; i++) {
@@ -1375,8 +1336,8 @@ static void com_ls_callback(int fd, const struct osl_object *query)
        if (opts->flags & LS_FLAG_ADMISSIBLE_ONLY)
                ret = admissible_file_loop(opts, prepare_ls_row);
        else
-               ret = osl_rbtree_loop(audio_file_table, AFTCOL_PATH, opts,
-                       prepare_ls_row);
+               ret = osl(osl_rbtree_loop(audio_file_table, AFTCOL_PATH, opts,
+                       prepare_ls_row));
        if (ret < 0)
                goto out;
        if (!opts->num_matching_paths)
@@ -1409,7 +1370,7 @@ out:
 /*
  * TODO: flags -h (sort by hash)
  */
-int com_ls(int fd, int argc, char * const * const argv)
+int com_ls(struct rc4_context *rc4c, int argc, char * const * const argv)
 {
        int i, ret;
        unsigned flags = 0;
@@ -1449,6 +1410,9 @@ int com_ls(int fd, int argc, char * const * const argv)
                        case 'c':
                                mode = LS_MODE_CHUNKS;
                                continue;
+                       case 'p':
+                               mode = LS_MODE_PARSER;
+                               continue;
                        default:
                                return -E_AFT_SYNTAX;
                        }
@@ -1518,7 +1482,7 @@ int com_ls(int fd, int argc, char * const * const argv)
        opts.mode = mode;
        opts.num_patterns = argc - i;
        ret = send_option_arg_callback_request(&query, opts.num_patterns,
-               argv + i, com_ls_callback, send_result, &fd);
+               argv + i, com_ls_callback, rc4_send_result, rc4c);
        return ret;
 }
 
@@ -1528,12 +1492,12 @@ int com_ls(int fd, int argc, char * const * const argv)
  * \param private_data An arbitrary data pointer, passed to \a func.
  * \param func The custom function to be called.
  *
- * \return The return value of the underlying call to osl_rbtree_loop().
+ * \return Standard.
  */
 int audio_file_loop(void *private_data, osl_rbtree_loop_func *func)
 {
-       return osl_rbtree_loop(audio_file_table, AFTCOL_HASH, private_data,
-               func);
+       return osl(osl_rbtree_loop(audio_file_table, AFTCOL_HASH, private_data,
+               func));
 }
 
 static struct osl_row *find_hash_sister(HASH_TYPE *hash)
@@ -1693,7 +1657,7 @@ static void com_add_callback(int fd, const struct osl_object *query)
        PARA_INFO_LOG("request to add %s\n", path);
        hs = find_hash_sister(hash);
        ret = aft_get_row_of_path(path, &pb);
-       if (ret < 0 && ret != -E_RB_KEY_NOT_FOUND)
+       if (ret < 0 && ret != -OSL_ERRNO_TO_PARA_ERROR(E_OSL_RB_KEY_NOT_FOUND))
                goto out;
        if (hs && pb && hs == pb && !(flags & ADD_FLAG_FORCE)) {
                if (flags & ADD_FLAG_VERBOSE)
@@ -1710,23 +1674,23 @@ static void com_add_callback(int fd, const struct osl_object *query)
                                if (ret < 0)
                                        goto out;
                        }
-                       ret = osl_del_row(audio_file_table, pb);
+                       ret = osl(osl_del_row(audio_file_table, pb));
                        if (ret < 0)
                                goto out;
                        pb = NULL;
                }
                /* file rename, update hs' path */
                if (flags & ADD_FLAG_VERBOSE) {
-                       ret = osl_get_object(audio_file_table, hs,
-                               AFTCOL_PATH, &obj);
+                       ret = osl(osl_get_object(audio_file_table, hs,
+                               AFTCOL_PATH, &obj));
                        if (ret < 0)
                                goto out;
                        ret = para_printf(&msg, "renamed from %s\n", (char *)obj.data);
                        if (ret < 0)
                                goto out;
                }
-               ret = osl_update_object(audio_file_table, hs, AFTCOL_PATH,
-                       &objs[AFTCOL_PATH]);
+               ret = osl(osl_update_object(audio_file_table, hs, AFTCOL_PATH,
+                       &objs[AFTCOL_PATH]));
                if (ret < 0)
                        goto out;
                afs_event(AUDIO_FILE_RENAME, &msg, hs);
@@ -1770,12 +1734,12 @@ static void com_add_callback(int fd, const struct osl_object *query)
                        if (ret < 0)
                                goto out;
                }
-               ret = osl_update_object(audio_file_table, row, AFTCOL_AFHI,
-                       &objs[AFTCOL_AFHI]);
+               ret = osl(osl_update_object(audio_file_table, row, AFTCOL_AFHI,
+                       &objs[AFTCOL_AFHI]));
                if (ret < 0)
                        goto out;
-               ret = osl_update_object(audio_file_table, row, AFTCOL_CHUNKS,
-                       &objs[AFTCOL_CHUNKS]);
+               ret = osl(osl_update_object(audio_file_table, row, AFTCOL_CHUNKS,
+                       &objs[AFTCOL_CHUNKS]));
                if (ret < 0)
                        goto out;
                afs_event(AFHI_CHANGE, &msg, row);
@@ -1793,7 +1757,7 @@ static void com_add_callback(int fd, const struct osl_object *query)
        objs[AFTCOL_AFSI].data = &afsi_buf;
        objs[AFTCOL_AFSI].size = AFSI_SIZE;
        save_afsi(&default_afsi, &objs[AFTCOL_AFSI]);
-       ret = osl_add_and_get_row(audio_file_table, objs, &aft_row);
+       ret = osl(osl_add_and_get_row(audio_file_table, objs, &aft_row));
        afs_event(AUDIO_FILE_ADD, &msg, aft_row);
 out:
        if (ret < 0)
@@ -1805,8 +1769,8 @@ out:
 
 /** Used by com_add(). */
 struct private_add_data {
-       /** The socket file descriptor. */
-       int fd;
+       /** The socket file descriptor, including rc4 keys. */
+       struct rc4_context *rc4c;
        /** The given add flags. */
        uint32_t flags;
 };
@@ -1856,12 +1820,13 @@ static int add_one_audio_file(const char *path, void *private_data)
        query.size = strlen(path) + 1;
        ret = send_callback_request(path_brother_callback, &query,
                get_row_pointer_from_result, &pb);
-       if (ret < 0 && ret != -E_RB_KEY_NOT_FOUND)
+       if (ret < 0 && ret != -OSL_ERRNO_TO_PARA_ERROR(E_OSL_RB_KEY_NOT_FOUND))
                goto out_free;
        ret = 1;
        if (pb && (pad->flags & ADD_FLAG_LAZY)) { /* lazy is really cheap */
                if (pad->flags & ADD_FLAG_VERBOSE)
-                       send_ret = send_va_buffer(pad->fd, "lazy-ignore: %s\n", path);
+                       send_ret = rc4_send_va_buffer(pad->rc4c,
+                               "lazy-ignore: %s\n", path);
                goto out_free;
        }
        /* We still want to add this file. Compute its hash. */
@@ -1881,7 +1846,7 @@ static int add_one_audio_file(const char *path, void *private_data)
        ret = 1;
        if (pb && hs && hs == pb && !(pad->flags & ADD_FLAG_FORCE)) {
                if (pad->flags & ADD_FLAG_VERBOSE)
-                       send_ret = send_va_buffer(pad->fd,
+                       send_ret = rc4_send_va_buffer(pad->rc4c,
                                "%s exists, not forcing update\n", path);
                goto out_unmap;
        }
@@ -1899,13 +1864,13 @@ static int add_one_audio_file(const char *path, void *private_data)
        munmap(map.data, map.size);
        close(fd);
        if (pad->flags & ADD_FLAG_VERBOSE) {
-               send_ret = send_va_buffer(pad->fd, "adding %s\n", path);
+               send_ret = rc4_send_va_buffer(pad->rc4c, "adding %s\n", path);
                if (send_ret < 0)
                        goto out_free;
        }
        save_add_callback_buffer(hash, path, afhi_ptr, pad->flags, format_num, &obj);
        /* Ask afs to consider this entry for adding. */
-       ret = send_callback_request(com_add_callback, &obj, send_result, &pad->fd);
+       ret = send_callback_request(com_add_callback, &obj, rc4_send_result, pad->rc4c);
        goto out_free;
 
 out_unmap:
@@ -1913,21 +1878,26 @@ out_unmap:
        munmap(map.data, map.size);
 out_free:
        if (ret < 0 && send_ret >= 0)
-               send_ret = send_va_buffer(pad->fd, "failed to add %s (%s)\n", path,
-                       para_strerror(-ret));
+               send_ret = rc4_send_va_buffer(pad->rc4c,
+                       "failed to add %s (%s)\n", path, para_strerror(-ret));
        free(obj.data);
        if (afhi_ptr) {
                free(afhi_ptr->chunk_table);
-               free(afhi_ptr->info_string);
+               free(afhi_ptr->techinfo);
+               free(afhi_ptr->tags.artist);
+               free(afhi_ptr->tags.title);
+               free(afhi_ptr->tags.year);
+               free(afhi_ptr->tags.album);
+               free(afhi_ptr->tags.comment);
        }
        /* Stop adding files only on send errors. */
        return send_ret;
 }
 
-int com_add(int fd, int argc, char * const * const argv)
+int com_add(struct rc4_context *rc4c, int argc, char * const * const argv)
 {
        int i, ret;
-       struct private_add_data pad = {.fd = fd, .flags = 0};
+       struct private_add_data pad = {.rc4c = rc4c, .flags = 0};
        struct stat statbuf;
 
        for (i = 1; i < argc; i++) {
@@ -1961,7 +1931,7 @@ int com_add(int fd, int argc, char * const * const argv)
                char *path;
                ret = verify_path(argv[i], &path);
                if (ret < 0) {
-                       ret = send_va_buffer(fd, "%s: %s\n", argv[i],
+                       ret = rc4_send_va_buffer(rc4c, "%s: %s\n", argv[i],
                                para_strerror(-ret));
                        if (ret < 0)
                                return ret;
@@ -1969,7 +1939,7 @@ int com_add(int fd, int argc, char * const * const argv)
                }
                ret = stat(path, &statbuf);
                if (ret < 0) {
-                       ret = send_va_buffer(fd, "failed to stat %s (%s)\n", path,
+                       ret = rc4_send_va_buffer(rc4c, "failed to stat %s (%s)\n", path,
                                strerror(errno));
                        free(path);
                        if (ret < 0)
@@ -1982,7 +1952,7 @@ int com_add(int fd, int argc, char * const * const argv)
                else
                        ret = add_one_audio_file(path, &pad);
                if (ret < 0) {
-                       send_va_buffer(fd, "%s: %s\n", path, para_strerror(-ret));
+                       rc4_send_va_buffer(rc4c, "%s: %s\n", path, para_strerror(-ret));
                        free(path);
                        return ret;
                }
@@ -2114,7 +2084,7 @@ static void com_touch_callback(int fd, const struct osl_object *query)
        free(tad.pb.buf);
 }
 
-int com_touch(int fd, int argc, char * const * const argv)
+int com_touch(struct rc4_context *rc4c, int argc, char * const * const argv)
 {
        struct com_touch_options cto = {
                .num_played = -1,
@@ -2135,33 +2105,33 @@ int com_touch(int fd, int argc, char * const * const argv)
                        i++;
                        break;
                }
-               if (!strncmp(arg, "-n", 2)) {
-                       ret = para_atoi32(arg + 2, &cto.num_played);
+               if (!strncmp(arg, "-n=", 3)) {
+                       ret = para_atoi32(arg + 3, &cto.num_played);
                        if (ret < 0)
                                return ret;
                        continue;
                }
-               if (!strncmp(arg, "-l", 2)) {
-                       ret = para_atoi64(arg + 2, &cto.last_played);
+               if (!strncmp(arg, "-l=", 3)) {
+                       ret = para_atoi64(arg + 3, &cto.last_played);
                        if (ret < 0)
                                return ret;
                        continue;
                }
-               if (!strncmp(arg, "-y", 2)) {
-                       ret = para_atoi32(arg + 2, &cto.lyrics_id);
+               if (!strncmp(arg, "-y=", 3)) {
+                       ret = para_atoi32(arg + 3, &cto.lyrics_id);
                        if (ret < 0)
                                return ret;
                        continue;
                }
-               if (!strncmp(arg, "-i", 2)) {
-                       ret = para_atoi32(arg + 2, &cto.image_id);
+               if (!strncmp(arg, "-i=", 3)) {
+                       ret = para_atoi32(arg + 3, &cto.image_id);
                        if (ret < 0)
                                return ret;
                        continue;
                }
-               if (!strncmp(arg, "-a", 2)) {
+               if (!strncmp(arg, "-a=", 3)) {
                        int32_t val;
-                       ret = para_atoi32(arg + 2, &val);
+                       ret = para_atoi32(arg + 3, &val);
                        if (ret < 0)
                                return ret;
                        if (val < 0 || val > 255)
@@ -2182,9 +2152,9 @@ int com_touch(int fd, int argc, char * const * const argv)
        if (i >= argc)
                return -E_AFT_SYNTAX;
        ret = send_option_arg_callback_request(&query, argc - i,
-               argv + i, com_touch_callback, send_result, &fd);
+               argv + i, com_touch_callback, rc4_send_result, rc4c);
        if (ret < 0)
-               send_va_buffer(fd, "%s\n", para_strerror(-ret));
+               rc4_send_va_buffer(rc4c, "%s\n", para_strerror(-ret));
        return ret;
 }
 
@@ -2220,7 +2190,7 @@ static int remove_audio_file(__a_unused struct osl_table *table,
                        return ret;
        }
        afs_event(AUDIO_FILE_REMOVE, &crd->pb, row);
-       ret = osl_del_row(audio_file_table, row);
+       ret = osl(osl_del_row(audio_file_table, row));
        if (ret < 0)
                para_printf(&crd->pb, "%s: %s\n", name, para_strerror(-ret));
        else
@@ -2266,7 +2236,7 @@ static void com_rm_callback(int fd, const struct osl_object *query)
 }
 
 /* TODO options: -r (recursive) */
-int com_rm(int fd, int argc,  char * const * const argv)
+int com_rm(struct rc4_context *rc4c, int argc,  char * const * const argv)
 {
        uint32_t flags = 0;
        struct osl_object query = {.data = &flags, .size = sizeof(flags)};
@@ -2297,9 +2267,9 @@ int com_rm(int fd, int argc,  char * const * const argv)
        if (i >= argc)
                return -E_AFT_SYNTAX;
        ret = send_option_arg_callback_request(&query, argc - i, argv + i,
-               com_rm_callback, send_result, &fd);
+               com_rm_callback, rc4_send_result, rc4c);
        if (ret < 0)
-               send_va_buffer(fd, "%s\n", para_strerror(-ret));
+               rc4_send_va_buffer(rc4c, "%s\n", para_strerror(-ret));
        return ret;
 }
 
@@ -2414,7 +2384,7 @@ out:
        free(cad.pb.buf);
 }
 
-int com_cpsi(int fd, int argc,  char * const * const argv)
+int com_cpsi(struct rc4_context *rc4c, int argc,  char * const * const argv)
 {
        unsigned flags = 0;
        int i, ret;
@@ -2454,17 +2424,36 @@ int com_cpsi(int fd, int argc,  char * const * const argv)
                }
                break;
        }
-       if (i + 1 >= argc) /* need at least souce file and pattern */
+       if (i + 1 >= argc) /* need at least source file and pattern */
                return -E_AFT_SYNTAX;
        if (!(flags & ~CPSI_FLAG_VERBOSE)) /* no copy flags given */
                flags = ~(unsigned)CPSI_FLAG_VERBOSE | flags;
        ret = send_option_arg_callback_request(&options, argc - i, argv + i,
-               com_cpsi_callback, send_result, &fd);
+               com_cpsi_callback, rc4_send_result, rc4c);
        if (ret < 0)
-               send_va_buffer(fd, "%s\n", para_strerror(-ret));
+               rc4_send_va_buffer(rc4c, "%s\n", para_strerror(-ret));
        return ret;
 }
 
+static void afs_stat_callback(int fd, const struct osl_object *query)
+{
+       int *parser_friendly = query->data;
+       char *buf = *parser_friendly?
+               parser_friendly_status_items : status_items;
+
+       if (!buf)
+               return;
+       pass_buffer_as_shm(buf, strlen(buf), &fd);
+}
+
+int send_afs_status(struct rc4_context *rc4c, int parser_friendly)
+{
+       struct osl_object query = {.data = &parser_friendly,
+               .size = sizeof(parser_friendly)};
+
+       return send_callback_request(afs_stat_callback, &query, rc4_send_result, rc4c);
+}
+
 /* TODO: optionally fix problems by removing offending rows */
 static int check_audio_file(struct osl_row *row, void *data)
 {
@@ -2543,6 +2532,10 @@ static void aft_close(void)
 {
        osl_close_table(audio_file_table, OSL_MARK_CLEAN);
        audio_file_table = NULL;
+       free(status_items);
+       status_items = NULL;
+       free(parser_friendly_status_items);
+       parser_friendly_status_items = NULL;
 }
 
 /**
@@ -2559,7 +2552,7 @@ static int aft_open(const char *dir)
        int ret;
 
        audio_file_table_desc.dir = dir;
-       ret = osl_open_table(&audio_file_table_desc, &audio_file_table);
+       ret = osl(osl_open_table(&audio_file_table_desc, &audio_file_table));
        if (ret >= 0) {
                unsigned num;
                osl_get_num_rows(audio_file_table, &num);
@@ -2568,7 +2561,7 @@ static int aft_open(const char *dir)
        }
        PARA_INFO_LOG("failed to open audio file table\n");
        audio_file_table = NULL;
-       if (ret >= 0 || is_errno(-ret, ENOENT))
+       if (ret >= 0 || ret == -OSL_ERRNO_TO_PARA_ERROR(E_OSL_NOENT))
                return 1;
        return ret;
 }
@@ -2576,7 +2569,7 @@ static int aft_open(const char *dir)
 static int aft_create(const char *dir)
 {
        audio_file_table_desc.dir = dir;
-       return osl_create_table(&audio_file_table_desc);
+       return osl(osl_create_table(&audio_file_table_desc));
 }
 
 static int clear_attribute(struct osl_row *row, void *data)
index 53c9738..9d99c8e 100644 (file)
  * based on the vplay program by Michael Beck.
  */
 
+#include <regex.h>
 #include <sys/types.h>
 #include <dirent.h>
 #include <alsa/asoundlib.h>
+#include <sys/time.h>
 
 #include "para.h"
 #include "fd.h"
@@ -180,6 +182,23 @@ static int alsa_write_pre_select(struct sched *s, struct writer_node *wn)
        return 1;
 }
 
+static void xrun(snd_pcm_t *handle)
+{
+       snd_pcm_status_t *status;
+       int ret;
+       struct timeval tv, diff;
+
+       snd_pcm_status_alloca(&status);
+       ret = snd_pcm_status(handle, status);
+       if (ret < 0)
+               return;
+       if (snd_pcm_status_get_state(status) != SND_PCM_STATE_XRUN)
+               return;
+       snd_pcm_status_get_trigger_tstamp(status, &tv);
+       tv_diff(now, &tv, &diff);
+       PARA_WARNING_LOG("underrun: %lums\n", tv2ms(&diff));
+}
+
 static int alsa_write_post_select(__a_unused struct sched *s,
                struct writer_node *wn)
 {
@@ -212,11 +231,12 @@ static int alsa_write_post_select(__a_unused struct sched *s,
                wn->written += ret * pad->bytes_per_frame;
                return 1;
        }
-       PARA_WARNING_LOG("%s\n", snd_strerror(-ret));
        if (ret == -EPIPE) {
+               xrun(pad->handle);
                snd_pcm_prepare(pad->handle);
                return 0;
        }
+       PARA_WARNING_LOG("%s\n", snd_strerror(-ret));
        if (ret == -EAGAIN)
                return 0;
        return -E_ALSA_WRITE;
index a011c41..e180db4 100644 (file)
@@ -6,6 +6,8 @@
 
 /** \file amp_filter.c Paraslash's amplify filter. */
 
+#include <regex.h>
+
 #include "para.h"
 #include "amp_filter.cmdline.h"
 #include "list.h"
@@ -30,19 +32,29 @@ struct private_amp_data {
 
 static ssize_t amp_convert(char *inbuf, size_t inbuf_len, struct filter_node *fn)
 {
-       size_t i, length = PARA_MIN((inbuf_len / 2) * 2,
-               (fn->bufsize - fn->loaded) / 2 * 2);
+       size_t i, length = PARA_MIN((inbuf_len / 2),
+               (fn->bufsize - fn->loaded) / 2);
        struct private_amp_data *pad = fn->private_data;
        int16_t *ip = (int16_t *)inbuf, *op = (int16_t *)(fn->buf + fn->loaded);
+       int factor = 64 + pad->amp;
 
        if (!length)
                return 0;
-       for (i = 0; i < length / 2; i++) {
-               int x = (PARA_ABS(*ip) * (64 + pad->amp)) >> 6;
-               *op++ = *ip++ > 0? PARA_MIN(x, 32767) : PARA_MAX(-x, -32768);
+
+       if (pad->amp == 0) {
+               memcpy(op, ip, length * 2);
+               goto out;
+       }
+       for (i = 0; i < length; i++) {
+               int x = (ip[i] * factor) >> 6;
+
+               op[i] = x;
+               if (op[i] != x)
+                       op[i] = (x >= 32768)? 32767 : -32768;
        }
-       fn->loaded += length;
-       return length;
+out:
+       fn->loaded += length * 2;
+       return length * 2;
 }
 
 static void amp_close(struct filter_node *fn)
@@ -76,11 +88,9 @@ static void amp_open(struct filter_node *fn)
 
        pad->conf = fn->conf;
        fn->private_data = pad;
-       if (!pad->conf->amp_given && stat_item_values[SI_AMPLIFICATION]) {
-               int i = SI_AMPLIFICATION;
-               char *s = stat_item_values[i] + strlen(status_item_list[i]) + 1;
-               sscanf(s, "%u", &pad->amp);
-       } else
+       if (!pad->conf->amp_given && stat_item_values[SI_AMPLIFICATION])
+               sscanf(stat_item_values[SI_AMPLIFICATION], "%u", &pad->amp);
+       else
                pad->amp = pad->conf->amp_arg;
        fn->bufsize = AMP_CHUNK_SIZE;
        fn->buf = para_malloc(fn->bufsize);
index df66c9d..d945898 100644 (file)
@@ -5,8 +5,14 @@
  */
 
 /** \file attribute.c Attribute handling functions. */
+
+#include <regex.h>
+#include <openssl/rc4.h>
+#include <osl.h>
+
 #include "para.h"
 #include "error.h"
+#include "crypt.h"
 #include "string.h"
 #include "afh.h"
 #include "afs.h"
@@ -89,11 +95,11 @@ int get_attribute_bitnum_by_name(const char *att_name, unsigned char *bitnum)
        struct osl_object obj = {.data = (char *)att_name,
                .size = strlen(att_name) + 1};
        struct osl_row *row;
-       int ret = osl_get_row(attribute_table, ATTCOL_NAME, &obj, &row);
+       int ret = osl(osl_get_row(attribute_table, ATTCOL_NAME, &obj, &row));
 
        if (ret < 0)
                return ret;
-       ret = osl_get_object(attribute_table, row, ATTCOL_BITNUM, &obj);
+       ret = osl(osl_get_object(attribute_table, row, ATTCOL_BITNUM, &obj));
        if (ret < 0)
                return ret;
        *bitnum = *(unsigned char *)obj.data;
@@ -131,7 +137,7 @@ static int print_attribute(struct osl_table *table, struct osl_row *row,
 
        if (!(laad->flags & LSATT_FLAG_LONG))
                return para_printf(&laad->pb, "%s\n", name);
-       ret = osl_get_object(table, row, ATTCOL_BITNUM, &bitnum_obj);
+       ret = osl(osl_get_object(table, row, ATTCOL_BITNUM, &bitnum_obj));
        if (ret < 0) {
                para_printf(&laad->pb, "%s: %s\n", name, para_strerror(-ret));
                return ret;
@@ -171,7 +177,7 @@ static void com_lsatt_callback(int fd, const struct osl_object *query)
        free(laad.pb.buf);
 }
 
-int com_lsatt(int fd, int argc, char * const * const argv)
+int com_lsatt(struct rc4_context *rc4c, int argc, char * const * const argv)
 {
        unsigned flags = 0;
        struct osl_object options = {.data = &flags, .size = sizeof(flags)};
@@ -199,12 +205,12 @@ int com_lsatt(int fd, int argc, char * const * const argv)
                }
        }
        ret = send_option_arg_callback_request(&options, argc - i, argv + i,
-               com_lsatt_callback, send_result, &fd);
+               com_lsatt_callback, rc4_send_result, rc4c);
        if (!ret) {
                if (argc > 1)
-                       ret = send_va_buffer(fd, "no matches\n");
+                       ret = rc4_send_va_buffer(rc4c, "no matches\n");
        } else if (ret < 0)
-               send_va_buffer(fd, "%s\n", para_strerror(-ret));
+               rc4_send_va_buffer(rc4c, "%s\n", para_strerror(-ret));
        return ret;
 }
 
@@ -230,11 +236,11 @@ static void com_setatt_callback(__a_unused int fd, const struct osl_object *quer
                p[len - 1] = '\0';
                obj.data = p;
                obj.size = len + 1;
-               ret = osl_get_row(attribute_table, ATTCOL_NAME, &obj, &row);
+               ret = osl(osl_get_row(attribute_table, ATTCOL_NAME, &obj, &row));
                if (ret < 0)
                        goto out;
-               ret = osl_get_object(attribute_table, row, ATTCOL_BITNUM,
-                       &obj);
+               ret = osl(osl_get_object(attribute_table, row, ATTCOL_BITNUM,
+                       &obj));
                if (ret < 0)
                        goto out;
                if (c == '+')
@@ -272,7 +278,7 @@ out:
                PARA_NOTICE_LOG("%s\n", para_strerror(-ret));
 }
 
-int com_setatt(__a_unused int fd, int argc, char * const * const argv)
+int com_setatt(__a_unused struct rc4_context *rc4c, int argc, char * const * const argv)
 {
        if (argc < 3)
                return -E_ATTR_SYNTAX;
@@ -317,15 +323,15 @@ static void com_addatt_callback(int fd, const struct osl_object *query)
                                goto out;
                        continue;
                }
-               if (ret != -E_RB_KEY_NOT_FOUND) /* error */
+               if (ret != -OSL_ERRNO_TO_PARA_ERROR(E_OSL_RB_KEY_NOT_FOUND)) /* error */
                        goto out;
                objs[ATTCOL_BITNUM].size = 1;
                /* find smallest unused attribute */
                for (bitnum = 0; bitnum < 64; bitnum++) {
                        objs[ATTCOL_BITNUM].data = &bitnum;
-                       ret = osl_get_row(attribute_table, ATTCOL_BITNUM,
-                               &objs[ATTCOL_BITNUM], &row);
-                       if (ret == -E_RB_KEY_NOT_FOUND)
+                       ret = osl(osl_get_row(attribute_table, ATTCOL_BITNUM,
+                               &objs[ATTCOL_BITNUM], &row));
+                       if (ret == -OSL_ERRNO_TO_PARA_ERROR(E_OSL_RB_KEY_NOT_FOUND))
                                break; /* this bitnum is unused, use it */
                        if (ret < 0) /* error */
                                goto out;
@@ -337,7 +343,7 @@ static void com_addatt_callback(int fd, const struct osl_object *query)
                }
                objs[ATTCOL_NAME].data = p;
                objs[ATTCOL_NAME].size = len + 1;
-               ret = osl_add_row(attribute_table, objs);
+               ret = osl(osl_add_row(attribute_table, objs));
                if (ret < 0)
                        goto out;
                aed.name = p;
@@ -353,16 +359,16 @@ out:
        free(pb.buf);
 }
 
-int com_addatt(int fd, int argc, char * const * const argv)
+int com_addatt(struct rc4_context *rc4c, int argc, char * const * const argv)
 {
        int ret;
 
        if (argc < 2)
                return -E_ATTR_SYNTAX;
        ret = send_standard_callback_request(argc - 1, argv + 1, com_addatt_callback,
-               send_result, &fd);
+               rc4_send_result, rc4c);
        if (ret < 0)
-               send_va_buffer(fd, "%s\n", para_strerror(-ret));
+               rc4_send_va_buffer(rc4c, "%s\n", para_strerror(-ret));
        return ret;
 }
 
@@ -380,12 +386,12 @@ static void com_mvatt_callback(int fd, const struct osl_object *query)
        };
        int ret;
 
-       ret = osl_get_row(attribute_table, ATTCOL_NAME, &obj, &row);
+       ret = osl(osl_get_row(attribute_table, ATTCOL_NAME, &obj, &row));
        if (ret < 0)
                goto out;
        obj.data = new;
        obj.size = strlen(new) + 1;
-       ret = osl_update_object(attribute_table, row, ATTCOL_NAME, &obj);
+       ret = osl(osl_update_object(attribute_table, row, ATTCOL_NAME, &obj));
 out:
        if (ret < 0)
                para_printf(&pb, "%s\n", para_strerror(-ret));
@@ -396,16 +402,16 @@ out:
        free(pb.buf);
 }
 
-int com_mvatt(int fd, int argc, char * const * const argv)
+int com_mvatt(struct rc4_context *rc4c, int argc, char * const * const argv)
 {
        int ret;
 
        if (argc != 3)
                return -E_ATTR_SYNTAX;
        ret = send_standard_callback_request(argc - 1, argv + 1, com_mvatt_callback,
-               send_result, &fd);
+               rc4_send_result, rc4c);
        if (ret < 0)
-               send_va_buffer(fd, "%s\n", para_strerror(-ret));
+               rc4_send_va_buffer(rc4c, "%s\n", para_strerror(-ret));
        return ret;
 }
 
@@ -429,7 +435,7 @@ static int remove_attribute(struct osl_table *table, struct osl_row *row,
        ret = get_attribute_bitnum_by_name(name, &red.bitnum);
        if (ret < 0)
                return para_printf(&raad->pb, "%s: %s\n", name, para_strerror(-ret));
-       ret = osl_del_row(table, row);
+       ret = osl(osl_del_row(table, row));
        if (ret < 0)
                return para_printf(&raad->pb, "%s: %s\n", name, para_strerror(-ret));
        ret = para_printf(&raad->pb, "removed attribute %s\n", name);
@@ -468,16 +474,16 @@ static void com_rmatt_callback(int fd, const struct osl_object *query)
        free(raad.pb.buf);
 }
 
-int com_rmatt(int fd, int argc, char * const * const argv)
+int com_rmatt(struct rc4_context *rc4c, int argc, char * const * const argv)
 {
        int ret;
 
        if (argc < 2)
                return -E_ATTR_SYNTAX;
        ret = send_standard_callback_request(argc - 1, argv + 1, com_rmatt_callback,
-               send_result, &fd);
+               rc4_send_result, rc4c);
        if (ret < 0)
-               send_va_buffer(fd, "%s\n", para_strerror(-ret));
+               rc4_send_va_buffer(rc4c, "%s\n", para_strerror(-ret));
        return ret;
 }
 
@@ -533,10 +539,10 @@ int get_attribute_text(uint64_t *atts, const char *delim, char **text)
 
                if (!(*atts & (one << i)))
                        continue;
-               ret = osl_get_row(attribute_table, ATTCOL_BITNUM, &obj, &row);
+               ret = osl(osl_get_row(attribute_table, ATTCOL_BITNUM, &obj, &row));
                if (ret < 0)
                        goto err;
-               ret = osl_get_object(attribute_table, row, ATTCOL_NAME, &obj);
+               ret = osl(osl_get_object(attribute_table, row, ATTCOL_NAME, &obj));
                if (ret < 0)
                        goto err;
                if (*text) {
@@ -559,7 +565,7 @@ err:
  *
  * \sa osl_close_table().
  */
-void attribute_close(void)
+static void attribute_close(void)
 {
        osl_close_table(attribute_table, OSL_MARK_CLEAN);
        attribute_table = NULL;
@@ -579,14 +585,14 @@ static int attribute_open(const char *dir)
        int ret;
 
        attribute_table_desc.dir = dir;
-       ret = osl_open_table(&attribute_table_desc, &attribute_table);
+       ret = osl(osl_open_table(&attribute_table_desc, &attribute_table));
        greatest_att_bitnum = -1; /* no atts available */
        if (ret >= 0) {
                find_greatest_att_bitnum();
                return ret;
        }
        attribute_table = NULL;
-       if (ret >= 0 || is_errno(-ret, ENOENT))
+       if (ret >= 0 || ret == -OSL_ERRNO_TO_PARA_ERROR(E_OSL_NOENT))
                return 1;
        return ret;
 }
@@ -594,7 +600,7 @@ static int attribute_open(const char *dir)
 static int attribute_create(const char *dir)
 {
        attribute_table_desc.dir = dir;
-       return osl_create_table(&attribute_table_desc);
+       return osl(osl_create_table(&attribute_table_desc));
 }
 
 /**
index 5c081da..fa1768b 100644 (file)
--- a/audioc.c
+++ b/audioc.c
@@ -6,6 +6,7 @@
 
 /** \file audioc.c the client program used to connect to para_audiod */
 
+#include <regex.h>
 #include <sys/types.h>
 #include <dirent.h>
 
@@ -18,8 +19,8 @@
 
 INIT_AUDIOC_ERRLISTS;
 
-/** the gengetopt structure containing command line args */
-struct audioc_args_info conf;
+/** The gengetopt structure containing command line args. */
+static struct audioc_args_info conf;
 
 static int loglevel;
 INIT_STDERR_LOGGING(loglevel);
index d39f0f5..395a14d 100644 (file)
--- a/audiod.c
+++ b/audiod.c
@@ -5,19 +5,21 @@
  */
 
 /** \file audiod.c the paraslash's audio daemon */
+#include <regex.h>
 #include <sys/types.h>
 #include <dirent.h>
 #include <signal.h>
+#include <openssl/rc4.h>
 
 #include "para.h"
 #include "error.h"
+#include "crypt.h"
 #include "audiod.cmdline.h"
 #include "list.h"
 #include "sched.h"
 #include "ggo.h"
 #include "recv.h"
 #include "filter.h"
-#include "grab_client.cmdline.h"
 #include "grab_client.h"
 #include "client.cmdline.h"
 #include "client.h"
@@ -160,7 +162,7 @@ struct command_task {
  * \return The audio format number on success, -E_UNSUPPORTED_AUDIO_FORMAT if
  * \a name is not a supported audio format.
  */
-int get_audio_format_num(char *name)
+int get_audio_format_num(const char *name)
 {
        int i;
 
@@ -219,8 +221,7 @@ out:
        seconds = PARA_MIN(seconds, length);
        seconds = PARA_MAX(seconds, 0);
        return make_message(
-               "%s: %s%d:%02d [%d:%02d] (%d%%/%d:%02d)\n",
-               status_item_list[SI_PLAY_TIME],
+               "%s%d:%02d [%d:%02d] (%d%%/%d:%02d)",
                s? "" : "~",
                seconds / 60,
                seconds % 60,
@@ -231,7 +232,7 @@ out:
                length % 60
        );
 empty:
-       return make_message("%s:\n", status_item_list[SI_PLAY_TIME]);
+       return para_strdup(NULL);
 }
 
 static int want_colors(void)
@@ -444,7 +445,7 @@ static void open_writers(int slot_num)
                stat_task->server_stream_start : *now;
        s->offset_seconds = stat_task->offset_seconds;
        s->seconds_total = stat_task->length_seconds;
-       activate_inactive_grab_clients(slot_num, s->format, s->fc);
+       activate_inactive_grab_clients(s->format, s->fc);
 }
 
 static int open_receiver(int format)
@@ -578,45 +579,31 @@ out:
        return count;
 }
 
-static int check_stat_line(char *line, __a_unused void *data)
+static int update_item(int itemnum, char *buf)
 {
-       int itemnum;
-       size_t ilen = 0;
        long unsigned sec, usec;
-       char *tmp;
 
-       //PARA_INFO_LOG("line: %s\n", line);
-       if (!line)
-               return 1;
-       itemnum = stat_line_valid(line);
-       if (itemnum < 0) {
-               PARA_WARNING_LOG("invalid status line: %s\n", line);
-               return 1;
-       }
        if (stat_task->clock_diff_count && itemnum != SI_CURRENT_TIME)
                return 1;
-       tmp = make_message("%s\n", line);
-       stat_client_write(tmp, itemnum);
-       free(tmp);
        free(stat_item_values[itemnum]);
-       stat_item_values[itemnum] = para_strdup(line);
-       ilen = strlen(status_item_list[itemnum]);
+       stat_item_values[itemnum] = para_strdup(buf);
+       stat_client_write_item(itemnum);
        switch (itemnum) {
        case SI_STATUS_FLAGS:
                stat_task->vss_status = 0;
-               if (strchr(line, 'N'))
+               if (strchr(buf, 'N'))
                        stat_task->vss_status |= VSS_STATUS_FLAG_NEXT;
-               if (strchr(line, 'P'))
+               if (strchr(buf, 'P'))
                        stat_task->vss_status |= VSS_STATUS_FLAG_PLAYING;
                break;
        case SI_OFFSET:
-               stat_task->offset_seconds = atoi(line + ilen + 1);
+               stat_task->offset_seconds = atoi(buf);
                break;
        case SI_SECONDS_TOTAL:
-               stat_task->length_seconds = atoi(line + ilen + 1);
+               stat_task->length_seconds = atoi(buf);
                break;
        case SI_STREAM_START:
-               if (sscanf(line + ilen + 1, "%lu.%lu", &sec, &usec) == 2) {
+               if (sscanf(buf, "%lu.%lu", &sec, &usec) == 2) {
                        struct timeval a_start, delay;
                        delay.tv_sec = conf.stream_delay_arg / 1000;
                        delay.tv_usec = (conf.stream_delay_arg % 1000) * 1000;
@@ -634,14 +621,14 @@ static int check_stat_line(char *line, __a_unused void *data)
                }
                break;
        case SI_CURRENT_TIME:
-               if (sscanf(line + ilen + 1, "%lu.%lu", &sec, &usec) == 2) {
+               if (sscanf(buf, "%lu.%lu", &sec, &usec) == 2) {
                        struct timeval tv = {sec, usec};
                        compute_time_diff(&tv);
                }
                break;
        case SI_FORMAT:
-               stat_task->current_audio_format_num = get_audio_format_num(
-                       line + ilen + 1);
+               stat_task->current_audio_format_num
+                       = get_audio_format_num(buf);
        }
        return 1;
 }
@@ -915,8 +902,15 @@ static void command_post_select(struct sched *s, struct task *t)
 {
        int ret;
        struct command_task *ct = container_of(t, struct command_task, task);
+       static struct timeval last_status_dump;
+       struct timeval tmp;
+
+       tv_add(&last_status_dump, &(struct timeval){0, 500 * 1000}, &tmp);
+       if (tv_diff(&tmp, now, NULL) < 0) {
+               audiod_status_dump();
+               last_status_dump = *now;
+       }
 
-       audiod_status_dump();
        if (!FD_ISSET(ct->fd, &s->rfds))
                return;
        ret = handle_connect(ct->fd);
@@ -935,17 +929,11 @@ static void init_command_task(struct command_task *ct)
 
 static void close_stat_pipe(void)
 {
-       int i;
-
        if (!stat_task->ct)
                return;
        client_close(stat_task->ct);
        stat_task->ct = NULL;
-       FOR_EACH_STATUS_ITEM(i) {
-               free(stat_item_values[i]);
-               stat_item_values[i] = NULL;
-       }
-       dump_empty_status();
+       clear_and_dump_items();
        stat_task->length_seconds = 0;
        stat_task->offset_seconds = 0;
        stat_task->vss_status = 0;
@@ -1069,7 +1057,7 @@ static void status_pre_select(struct sched *s, struct task *t)
                goto out;
        }
        if (st->ct) {
-               unsigned bytes_left;
+               int ret;
                if (st->ct->task.error < 0) {
                        if (st->ct->task.error != -E_TASK_UNREGISTERED)
                                goto out;
@@ -1078,11 +1066,15 @@ static void status_pre_select(struct sched *s, struct task *t)
                }
                if (st->ct->status != CL_RECEIVING)
                        goto out;
-               bytes_left = for_each_line(st->ct->buf, st->ct->loaded,
-                       &check_stat_line, NULL);
-               if (st->ct->loaded != bytes_left) {
+               ret = for_each_stat_item(st->ct->buf, st->ct->loaded,
+                       update_item);
+               if (ret < 0) {
+                       st->ct->task.error = ret;
+                       goto out;
+               }
+               if (st->ct->loaded != ret) {
                        st->last_status_read = *now;
-                       st->ct->loaded = bytes_left;
+                       st->ct->loaded = ret;
                } else {
                        struct timeval diff;
                        tv_diff(now, &st->last_status_read, &diff);
@@ -1094,25 +1086,23 @@ static void status_pre_select(struct sched *s, struct task *t)
        if (tv_diff(now, &st->restart_barrier, NULL) < 0)
                goto out;
        if (st->clock_diff_count) { /* get status only one time */
-               char *argv[] = {"audiod", "stat", "1", NULL};
-               int argc = 3;
+               char *argv[] = {"audiod", "--", "stat", "-p", "1", NULL};
+               int argc = 5;
                PARA_INFO_LOG("clock diff count: %d\n", st->clock_diff_count);
                st->clock_diff_count--;
                client_open(argc, argv, &st->ct, NULL);
                set_stat_task_restart_barrier(2);
 
        } else {
-               char *argv[] = {"audiod", "stat", NULL};
-               int argc = 2;
+               char *argv[] = {"audiod", "--", "stat", "-p", NULL};
+               int argc = 4;
                client_open(argc, argv, &st->ct, NULL);
                set_stat_task_restart_barrier(5);
        }
        free(stat_item_values[SI_BASENAME]);
-       stat_item_values[SI_BASENAME] = make_message(
-               "%s: no connection to para_server\n",
-               status_item_list[SI_BASENAME]);
-       stat_client_write(stat_item_values[SI_BASENAME],
-               SI_BASENAME);
+       stat_item_values[SI_BASENAME] = para_strdup(
+               "no connection to para_server");
+       stat_client_write_item(SI_BASENAME);
        st->last_status_read = *now;
 out:
        start_stop_decoders(s);
@@ -1213,9 +1203,12 @@ int main(int argc, char *argv[])
        drop_privileges_or_die(conf.user_arg, conf.group_arg);
        parse_config_or_die();
        init_colors_or_die();
+       init_random_seed_or_die();
        daemon_set_flag(DF_LOG_TIME);
        daemon_set_flag(DF_LOG_HOSTNAME);
        daemon_set_flag(DF_LOG_LL);
+       if (conf.log_timing_given)
+               daemon_set_flag(DF_LOG_TIMING);
        if (conf.logfile_given) {
                daemon_set_logfile(conf.logfile_arg);
                daemon_open_log_or_die();
@@ -1244,7 +1237,7 @@ int main(int argc, char *argv[])
        register_task(&cmd_task->task);
        register_task(&stat_task->task);
        s.default_timeout.tv_sec = 0;
-       s.default_timeout.tv_usec = 99 * 1000;
+       s.default_timeout.tv_usec = 999 * 1000;
        ret = schedule(&s);
 
        PARA_EMERG_LOG("%s\n", para_strerror(-ret));
index 5469476..94f3ca0 100644 (file)
@@ -14,11 +14,36 @@ H: on -> standby -> off -> on
 N: grab
 D: grab the audio stream
 L:
-U: -- grab [grab_options]
+U: -- grab -[n=<num>] [-m[{s|p|a}]] [-i] [-o] [-f=<format>]
+H:
 H: grab ('splice') the audio stream at any position in the filter
-H: chain and send that data back to the client. Try
-H:     para_audioc -- grab -h
-H: for the list of available options.
+H: chain and send that data back to the client.
+H:
+H: Options:
+H:
+H: -n  Point of the filter chain to grab. Filters count from zero.
+H:
+H: -m  Change grab mode. Defaults to sloppy grab if not given.
+H:
+H:             -ms: sloppy grab
+H:
+H:             -mp: pedantic grab
+H:
+H:             -ma: aggressive grab
+H:
+H:     The various grab modes only differ in what happens if the
+H:     file descriptor to write the grabbed audio data to is not
+H:     ready for writing (i.e. would block). Sloppy mode ignores
+H:     the write, pedantic mode aborts and aggressive mode tries
+H:     to write anyway.
+H:
+H: -i  Grab the filter input instead of its output.
+H:
+H: -o  One-shot mode: Stop grabbing if audio file changes.
+H:
+H: -f  Only grab streams of this format (mp3, ogg, aac). The default is to
+H:     grab any stream.
+H:
 ---
 N: help
 D: display command list or help for given command
@@ -51,8 +76,9 @@ H: Stop all decoders but leave connection to para_server open.
 ---
 N: stat
 D: print status information
-U: stat [item1 ...]
-H: Dump given status items (all if none given) to stdout.
+U: stat [-p] [item1 ...]
+H: Dump given status items (all if none given) to stdout. If -p is given, use
+H: parser-friendly mode.
 ---
 N: tasks
 D: list current tasks
index 8b416ce..2d8fec1 100644 (file)
--- a/audiod.h
+++ b/audiod.h
@@ -8,7 +8,7 @@
 
 
 int num_filters(int audio_format_num);
-int get_audio_format_num(char *name);
+int get_audio_format_num(const char *name);
 
 /** enum of audio formats supported by para_audiod */
 enum {AUDIOD_AUDIO_FORMATS_ENUM};
@@ -34,12 +34,6 @@ struct audiod_command {
        const char *name;
        /** pointer to the function that handles the command */
        int (*handler)(int, int, char**);
-       /**
-        * if the command prefers to handle the full line (rather than the usual
-        * argv[] array), it stores a pointer to the corresponding line handling
-        * function here. In this case, the above \a handler pointer must be NULL.
-        */
-       int (*line_handler)(int, char*);
        /** one-line description of the command */
        const char *description;
        /** summary of the command line options */
@@ -82,8 +76,10 @@ extern int audiod_status;
 void __noreturn clean_exit(int status, const char *msg);
 int handle_connect(int accept_fd);
 void audiod_status_dump(void);
-void dump_empty_status(void);
 char *get_time_string(int slot_num);
 
+void stat_client_write_item(int item_num);
+void clear_and_dump_items(void);
+
 /** iterate over all slots */
 #define FOR_EACH_SLOT(_slot) for (_slot = 0; _slot < MAX_STREAM_SLOTS; _slot++)
index 4706131..bb91671 100644 (file)
@@ -6,19 +6,17 @@
 
 /** \file audiod_command.c commands for para_audiod */
 
+#include <regex.h>
 #include <sys/types.h>
 #include <dirent.h>
 
 #include "para.h"
 #include "audiod.cmdline.h"
 #include "list.h"
-#include "close_on_fork.h"
 #include "sched.h"
 #include "ggo.h"
 #include "filter.h"
-#include "grab_client.cmdline.h"
 #include "grab_client.h"
-
 #include "error.h"
 #include "audiod.h"
 #include "net.h"
 
 extern char *stat_item_values[NUM_STAT_ITEMS];
 
-
-/** iterate over the array of all audiod commands */
+/** Iterate over the array of all audiod commands. */
 #define FOR_EACH_COMMAND(c) for (c = 0; audiod_cmds[c].name; c++)
 
+/** The maximal number of simultaneous connections. */
+#define MAX_STAT_CLIENTS 50
+
+/** Flags used for the stat command of para_audiod. */
+enum stat_client_flags {
+       /** Enable parser-friendly output. */
+       SCF_PARSER_FRIENDLY = 1,
+};
+
+/**
+ * Describes a status client of para_audiod.
+ *
+ * There's one such structure per audiod client that sent the 'stat' command.
+ *
+ * A status client is identified by its file descriptor.  para_audiod
+ * keeps a list of connected status clients.
+ */
+struct stat_client {
+       /** The stat client's file descriptor. */
+       int fd;
+       /** Bitmask of those status items the client is interested in. */
+       uint64_t item_mask;
+       /** See \ref stat_client flags. s*/
+       unsigned flags;
+       /** Its entry in the list of stat clients. */
+       struct list_head node;
+};
+
+static INITIALIZED_LIST_HEAD(client_list);
+static int num_clients;
+
+/** The list of all status items used by para_{server,audiod,gui}. */
+const char *status_item_list[] = {STATUS_ITEM_ARRAY};
+
+static void dump_stat_client_list(void)
+{
+       struct stat_client *sc;
+
+       list_for_each_entry(sc, &client_list, node)
+               PARA_INFO_LOG("stat client on fd %d\n", sc->fd);
+}
+/**
+ * Add a status client to the list.
+ *
+ * \param fd The file descriptor of the client.
+ * \param mask Bitfield of status items for this client.
+ * \param parser_friendly Enable parser-friendly output mode.
+ *
+ * Only those status items having the bit set in \a mask will be
+ * sent to the client.
+ *
+ * \return Positive value on success, or -E_TOO_MANY_CLIENTS if
+ * the number of connected clients exceeds #MAX_STAT_CLIENTS.
+ */
+static int stat_client_add(int fd, uint64_t mask, int parser_friendly)
+{
+       struct stat_client *new_client;
+
+       if (num_clients >= MAX_STAT_CLIENTS) {
+               PARA_ERROR_LOG("maximal number of stat clients (%d) exceeded\n",
+                       MAX_STAT_CLIENTS);
+               return -E_TOO_MANY_CLIENTS;
+       }
+       PARA_INFO_LOG("adding client on fd %d\n", fd);
+       new_client = para_calloc(sizeof(struct stat_client));
+       new_client->fd = fd;
+       new_client->item_mask = mask;
+       if (parser_friendly)
+               new_client->flags = SCF_PARSER_FRIENDLY;
+       para_list_add(&new_client->node, &client_list);
+       dump_stat_client_list();
+       num_clients++;
+       return 1;
+}
+/**
+ * Write a message to all connected status clients.
+ *
+ * \param item_num The number of the status item of \a msg.
+ *
+ * On write errors, remove the status client from the client list and close its
+ * file descriptor.
+ */
+void stat_client_write_item(int item_num)
+{
+       struct stat_client *sc, *tmp;
+       struct para_buffer pb = {.flags = 0};
+       struct para_buffer pfpb = {.flags = PBF_SIZE_PREFIX};
+       const uint64_t one = 1;
+
+       list_for_each_entry_safe(sc, tmp, &client_list, node) {
+               int fd = sc->fd, ret;
+
+               if (!((one << item_num) & sc->item_mask))
+                       continue;
+               if (write_ok(fd) > 0) {
+                       struct para_buffer *b =
+                               (sc->flags & SCF_PARSER_FRIENDLY)? &pfpb : &pb;
+                       char *msg = stat_item_values[item_num];
+                       if (!b->buf)
+                               WRITE_STATUS_ITEM(b, item_num, "%s\n",
+                                       msg? msg : "");
+                       ret = write(fd, b->buf, b->offset);
+                       if (ret == b->offset)
+                               continue;
+               }
+               /* write error or fd not ready for writing */
+               close(fd);
+               num_clients--;
+               PARA_INFO_LOG("deleting client on fd %d\n", fd);
+               list_del(&sc->node);
+               free(sc);
+               dump_stat_client_list();
+       }
+       free(pb.buf);
+       free(pfpb.buf);
+//     if (num_clients)
+//             PARA_DEBUG_LOG("%d client(s)\n", num_clients);
+}
+
+/**
+ * Check if string is a known status item.
+ *
+ * \param item Buffer containing the text to check.
+ *
+ * \return If \a item is a valid status item, the number of that status item is
+ * returned. Otherwise, this function returns \p -E_UNKNOWN_STAT_ITEM.
+ */
+static int stat_item_valid(const char *item)
+{
+       int i;
+       if (!item || !*item) {
+               PARA_ERROR_LOG("%s\n", "no item");
+               return -E_UNKNOWN_STAT_ITEM;
+       }
+       FOR_EACH_STATUS_ITEM(i)
+               if (!strcmp(status_item_list[i], item))
+                       return i;
+       PARA_ERROR_LOG("invalid stat item: %s\n", item);
+       return -E_UNKNOWN_STAT_ITEM;
+}
+
 static int client_write(int fd, const char *buf)
 {
-       size_t len = strlen(buf);
+       size_t len;
+
+       if (!buf)
+               return 0;
+       len = strlen(buf);
        return write(fd, buf, len) != len? -E_CLIENT_WRITE: 1;
 }
 
@@ -43,7 +185,7 @@ __malloc static char *audiod_status_string(void)
 {
        const char *status = (audiod_status == AUDIOD_ON)?
                "on" : (audiod_status == AUDIOD_OFF)? "off": "sb";
-       return make_message("%s: %s\n", status_item_list[SI_AUDIOD_STATUS], status);
+       return para_strdup(status);
 }
 
 static int get_play_time_slot_num(void)
@@ -72,13 +214,14 @@ __malloc static char *decoder_flags(void)
                char flag = '0';
                if (s->receiver_node)
                        flag += 1;
-               if (s->wng)
+               if (s->fc)
                        flag += 2;
+               if (s->wng)
+                       flag += 4;
                flags[i] = flag;
        }
        flags[MAX_STREAM_SLOTS] = '\0';
-       return make_message("%s: %s\n", status_item_list[SI_DECODER_FLAGS],
-               flags);
+       return para_strdup(flags);
 }
 
 static int dump_commands(int fd)
@@ -168,95 +311,50 @@ int com_kill(int fd, int argc, char **argv)
 
 int com_stat(int fd, int argc, char **argv)
 {
-       int i, ret;
-       char *buf = NULL;
+       int i, ret, parser_friendly = 0;
        uint64_t mask = 0;
        const uint64_t one = 1;
+       struct para_buffer b = {.flags = 0};
 
-       if (argc > 1) {
-               for (i = 1; i < argc; i++) {
-                       ret = stat_item_valid(argv[i]);
-                       if (ret < 0)
-                               return ret;
-                       mask |= (one << ret);
+       for (i = 1; i < argc; i++) {
+               const char *arg = argv[i];
+               if (arg[0] != '-')
+                       break;
+               if (!strcmp(arg, "--")) {
+                       i++;
+                       break;
                }
-       } else
+               if (!strncmp(arg, "-p", 2)) {
+                       parser_friendly = 1;
+                       b.flags = PBF_SIZE_PREFIX;
+                       continue;
+               }
+       }
+       if (i >= argc)
                mask--; /* set all bits */
+       for (; i < argc; i++) {
+               ret = stat_item_valid(argv[i]);
+               if (ret < 0)
+                       return ret;
+               mask |= (one << ret);
+       }
        PARA_INFO_LOG("mask: 0x%llx\n", (long long unsigned)mask);
        FOR_EACH_STATUS_ITEM(i) {
-               char *tmp, *v;
+               char *item = stat_item_values[i];
                if (!((one << i) & mask))
                        continue;
-               v = stat_item_values[i];
-               if (!v)
-                       continue;
-               tmp = make_message("%s%s%s", buf? buf: "", v,
-                       strrchr(v, '\n')? "" : "\n");
-               free(buf);
-               buf = tmp;
+               WRITE_STATUS_ITEM(&b, i, "%s\n", item? item : "");
        }
-       ret = client_write(fd, buf);
-       if (ret > 0)
-               ret = stat_client_add(fd, mask);
-       free(buf);
+       ret = client_write(fd, b.buf);
+       if (ret >= 0)
+               ret = stat_client_add(fd, mask, parser_friendly);
+       free(b.buf);
        return ret;
 }
 
-static struct filter_node *find_filter_node(int slot_num, int format, int filternum)
-{
-       int i;
-
-       FOR_EACH_SLOT(i) {
-               struct slot_info *s = &slot[i];
-               if (s->format < 0 || !s->fc)
-                       continue;
-               if (slot_num >= 0 && slot_num != i)
-                       continue;
-               if (format >= 0 && s->format != format)
-                       continue;
-               if (num_filters(i) <= filternum)
-                       continue;
-               /* success */
-               return  s->fc->filter_nodes + filternum;
-       }
-       return NULL;
-}
-
-int com_grab(int fd, char *cmdline)
+int com_grab(int fd, int argc, char **argv)
 {
-       struct grab_client *gc;
-       struct filter_node *fn;
-       int i, err;
-       char *msg;
-
-       gc = grab_client_new(fd, cmdline, &err);
-       if (!gc)
-               goto err_out;
-       fn = find_filter_node(gc->conf->slot_arg, gc->audio_format_num, gc->conf->filter_num_arg);
-       if (fn)
-               activate_grab_client(gc, fn);
-       return 1;
-err_out:
-       if (err != -E_GC_HELP_GIVEN && err != -E_GC_VERSION_GIVEN)
-               return err;
-       if (err == -E_GC_HELP_GIVEN) {
-               msg = make_message("%s\n\n", grab_client_args_info_usage);
-               for (i = 0; grab_client_args_info_help[i]; i++) {
-                       char *tmp = make_message("%s%s\n", msg,
-                               grab_client_args_info_help[i]);
-                       free(msg);
-                       msg = tmp;
-               }
-       } else
-               msg = make_message("%s %s\n",
-                       GRAB_CLIENT_CMDLINE_PARSER_PACKAGE,
-                       GRAB_CLIENT_CMDLINE_PARSER_VERSION);
-       err = client_write(fd, msg);
-       free(msg);
-       if (err < 0)
-               return err;
-       close(fd);
-       return 1;
+       return grab_client_new(fd, argc, argv);
 }
 
 __noreturn int com_term(int fd, __a_unused int argc, __a_unused char **argv)
@@ -333,7 +431,7 @@ static int check_perms(uid_t uid)
 int handle_connect(int accept_fd)
 {
        int i, argc, ret, clifd = -1;
-       char *cmd = NULL, *p, *buf = para_calloc(MAXLINE), **argv = NULL;
+       char buf[MAXLINE], **argv = NULL;
        struct sockaddr_un unix_addr;
        uid_t uid;
 
@@ -341,7 +439,7 @@ int handle_connect(int accept_fd)
        if (ret < 0)
                goto out;
        clifd = ret;
-       ret = recv_cred_buffer(clifd, buf, MAXLINE - 1);
+       ret = recv_cred_buffer(clifd, buf, sizeof(buf) - 1);
        if (ret < 0)
                goto out;
        uid = ret;
@@ -349,36 +447,20 @@ int handle_connect(int accept_fd)
        ret = check_perms(uid);
        if (ret < 0)
                goto out;
-       cmd = para_strdup(buf);
-       p = strchr(cmd, '\n');
-       if (!p)
-               p = "";
-       else {
-               *p = '\0';
-               p++;
-       }
-       for (i = 0; audiod_cmds[i].name; i++) {
-               int j;
-               if (strcmp(audiod_cmds[i].name, cmd))
+       ret = create_argv(buf, "\n", &argv);
+       if (ret < 0)
+               goto out;
+       argc = ret;
+       //PARA_INFO_LOG("argv[0]: %s, argc = %d\n", argv[0], argc);
+       FOR_EACH_COMMAND(i) {
+               if (strcmp(audiod_cmds[i].name, argv[0]))
                        continue;
-               if (audiod_cmds[i].handler) {
-                       argc = split_args(buf, &argv, "\n");
-                       PARA_INFO_LOG("argv[0]: %s, argc= %d\n", argv[0], argc);
-                       ret = audiod_cmds[i].handler(clifd, argc, argv);
-                       goto out;
-               }
-               for (j = 0; p[j]; j++)
-                       if (p[j] == '\n')
-                               p[j] = ' ';
-               PARA_INFO_LOG("cmd: %s, options: %s\n", cmd, p);
-               ret = audiod_cmds[i].line_handler(clifd, p);
+               ret = audiod_cmds[i].handler(clifd, argc, argv);
                goto out;
        }
        ret = -E_INVALID_AUDIOD_CMD;
 out:
-       free(cmd);
-       free(buf);
-       free(argv);
+       free_argv(argv);
        if (clifd > 0 && ret < 0 && ret != -E_CLIENT_WRITE) {
                char *tmp = make_message("%s\n", para_strerror(-ret));
                client_write(clifd, tmp);
@@ -387,34 +469,32 @@ out:
        }
        return ret;
 }
+
 /**
- * send the current audiod status to all connected stat clients
+ * Send the current audiod status to all connected stat clients.
  */
 void audiod_status_dump(void)
 {
        int slot_num = get_play_time_slot_num();
-       char *old, *new, *tmp;
+       char *old, *new;
 
        old = stat_item_values[SI_PLAY_TIME];
        new = get_time_string(slot_num);
        if (new) {
                if (!old || strcmp(old, new)) {
                        free(old);
-                       stat_client_write(new, SI_PLAY_TIME);
                        stat_item_values[SI_PLAY_TIME] = new;
+                       stat_client_write_item(SI_PLAY_TIME);
                } else
                        free(new);
        }
 
-       tmp = uptime_str();
-       new = make_message("%s: %s\n", status_item_list[SI_AUDIOD_UPTIME],
-               tmp);
-       free(tmp);
+       new = uptime_str();
        old = stat_item_values[SI_AUDIOD_UPTIME];
        if (!old || strcmp(old, new)) {
                free(old);
-               stat_client_write(new, SI_AUDIOD_UPTIME);
                stat_item_values[SI_AUDIOD_UPTIME] = new;
+               stat_client_write_item(SI_AUDIOD_UPTIME);
        } else
                free(new);
 
@@ -422,8 +502,8 @@ void audiod_status_dump(void)
        new = audiod_status_string();
        if (!old || strcmp(old, new)) {
                free(old);
-               stat_client_write(new, SI_AUDIOD_STATUS);
                stat_item_values[SI_AUDIOD_STATUS] = new;
+               stat_client_write_item(SI_AUDIOD_STATUS);
        } else
                free(new);
 
@@ -431,27 +511,25 @@ void audiod_status_dump(void)
        new = decoder_flags();
        if (!old || strcmp(old, new)) {
                free(old);
-               stat_client_write(new, SI_DECODER_FLAGS);
                stat_item_values[SI_DECODER_FLAGS] = new;
+               stat_client_write_item(SI_DECODER_FLAGS);
        } else
                free(new);
 }
 
 /**
- * send empty status list
+ * Flush and send all status items.
  *
  * Send to  each connected client the full status item list
  * with empty values.
  */
-void dump_empty_status(void)
+void clear_and_dump_items(void)
 {
        int i;
 
        FOR_EACH_STATUS_ITEM(i) {
-               char *tmp = make_message("%s:\n", status_item_list[i]);
-               stat_client_write(tmp, i);
-               free(tmp);
                free(stat_item_values[i]);
                stat_item_values[i] = NULL;
+               stat_client_write_item(i);
        }
 }
diff --git a/bitstream.c b/bitstream.c
new file mode 100644 (file)
index 0000000..1139edc
--- /dev/null
@@ -0,0 +1,207 @@
+/*
+ * Common bit I/O utils.
+ *
+ * Extracted 2009 from mplayer 2009-02-10 libavcodec/bitstream.c.
+ *
+ * Copyright (c) 2000, 2001 Fabrice Bellard
+ * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
+ * alternative bitstream reader & writer by Michael Niedermayer <michaelni@gmx.at>
+ *
+ * Licensed under the GNU Lesser General Public License.
+ * For licencing details see COPYING.LIB.
+ */
+
+/**
+ * \file bitstream.c Bitstream API.
+ */
+
+#include <stdlib.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <string.h>
+#include <regex.h>
+
+#include "para.h"
+#include "error.h"
+#include "string.h"
+#include "wma.h"
+#include "bitstream.h"
+
+#define GET_DATA(v, table, i, size) \
+{\
+       const uint8_t *ptr = (const uint8_t *)table + i * size; \
+       switch (size) { \
+       case 1: \
+               v = *(const uint8_t *)ptr; \
+               break; \
+       case 2: \
+               v = *(const uint16_t *)ptr; \
+               break; \
+       default: \
+               v = *(const uint32_t *)ptr; \
+               break; \
+       } \
+}
+
+static void alloc_table(struct vlc *vlc, int size)
+{
+       vlc->table_size += size;
+       if (vlc->table_size > vlc->table_allocated) {
+               vlc->table_allocated += (1 << vlc->bits);
+               vlc->table = para_realloc(vlc->table,
+                       sizeof(VLC_TYPE) * 2 * vlc->table_allocated);
+       }
+}
+
+static int build_table(struct vlc *vlc, int table_nb_bits, int nb_codes,
+               const void *bits, const void *codes, int codes_size,
+               uint32_t code_prefix, int n_prefix)
+{
+       int i, j, k, n, table_size, table_index, nb, n1, idx, code_prefix2,
+               symbol;
+       uint32_t code;
+       VLC_TYPE(*table)[2];
+
+       table_size = 1 << table_nb_bits;
+       table_index = vlc->table_size;
+       alloc_table(vlc, table_size);
+       table = &vlc->table[table_index];
+
+       for (i = 0; i < table_size; i++) {
+               table[i][1] = 0;        //bits
+               table[i][0] = -1;       //codes
+       }
+
+       /* map codes and compute auxillary table sizes */
+       for (i = 0; i < nb_codes; i++) {
+               GET_DATA(n, bits, i, 1);
+               GET_DATA(code, codes, i, codes_size);
+               /* we accept tables with holes */
+               if (n <= 0)
+                       continue;
+               symbol = i;
+               /* if code matches the prefix, it is in the table */
+               n -= n_prefix;
+               code_prefix2 = code >> n;
+               if (n <= 0 || code_prefix2 != code_prefix)
+                       continue;
+               if (n <= table_nb_bits) {
+                       /* no need to add another table */
+                       j = (code << (table_nb_bits - n)) & (table_size - 1);
+                       nb = 1 << (table_nb_bits - n);
+                       for (k = 0; k < nb; k++) {
+                               if (table[j][1] /* bits */ != 0) {
+                                       PARA_EMERG_LOG("incorrect code\n");
+                                       exit(EXIT_FAILURE);
+                               }
+                               table[j][1] = n;        //bits
+                               table[j][0] = symbol;
+                               j++;
+                       }
+               } else {
+                       n -= table_nb_bits;
+                       j = (code >> n) & ((1 << table_nb_bits) - 1);
+                       /* compute table size */
+                       n1 = -table[j][1];      //bits
+                       if (n > n1)
+                               n1 = n;
+                       table[j][1] = -n1;      //bits
+               }
+       }
+
+       /* fill auxillary tables recursively */
+       for (i = 0; i < table_size; i++) {
+               n = table[i][1];        //bits
+               if (n < 0) {
+                       n = -n;
+                       if (n > table_nb_bits) {
+                               n = table_nb_bits;
+                               table[i][1] = -n;       //bits
+                       }
+                       idx = build_table(vlc, n, nb_codes, bits, codes,
+                               codes_size, (code_prefix << table_nb_bits) | i,
+                               n_prefix + table_nb_bits);
+                       /* vlc->table might have changed */
+                       table = &vlc->table[table_index];
+                       table[i][0] = idx;      //code
+               }
+       }
+       return table_index;
+}
+
+/**
+ * Build VLC decoding tables suitable for use with get_vlc().
+ *
+ * \param vlc The structure to be initialized.
+ *
+ * \param nb_bits Set the decoding table size (2^nb_bits) entries. The bigger
+ * it is, the faster is the decoding. But it should not be too big to save
+ * memory and L1 cache. '9' is a good compromise.
+ *
+ * \param nb_codes Number of vlcs codes.
+ *
+ * \param bits Table which gives the size (in bits) of each vlc code.
+ *
+ * \param codes Table which gives the bit pattern of of each vlc code.
+ *
+ * \param codes_size The number of bytes of each entry of the \a codes tables.
+ *
+ * The wrap and size parameters allow to use any memory configuration and
+ * types (byte/word/long) to store the bits and codes tables.
+ */
+void init_vlc(struct vlc *vlc, int nb_bits, int nb_codes, const void *bits,
+               const void *codes, int codes_size)
+{
+       PARA_INFO_LOG("nb_codes: %d\n", nb_codes);
+       vlc->bits = nb_bits;
+       vlc->table = NULL;
+       vlc->table_allocated = 0;
+       vlc->table_size = 0;
+       build_table(vlc, nb_bits, nb_codes, bits, codes, codes_size, 0, 0);
+}
+
+void free_vlc(struct vlc *vlc)
+{
+       freep(&vlc->table);
+}
+
+/**
+ * Parse a vlc code.
+ *
+ * \param gbc The getbit context structure.
+ *
+ * \param table The vlc tables to use.
+ *
+ * \param bits The number of bits which will be read at once, must be
+ * identical to nb_bits in init_vlc().
+ *
+ * \param max_depth The number of times bits bits must be read to completely
+ * read the longest vlc code = (max_vlc_length + bits - 1) / bits.
+ *
+ * \return The vlc code.
+ */
+int get_vlc(struct getbit_context *gbc, VLC_TYPE(*table)[2], int bits,
+               int max_depth)
+{
+       int n, idx, nb_bits, code;
+
+       idx = show_bits(gbc, bits);
+       code = table[idx][0];
+       n = table[idx][1];
+       if (max_depth > 1 && n < 0) {
+               skip_bits(gbc, bits);
+               nb_bits = -n;
+               idx = show_bits(gbc, nb_bits) + code;
+               code = table[idx][0];
+               n = table[idx][1];
+               if (max_depth > 2 && n < 0) {
+                       skip_bits(gbc, nb_bits);
+                       nb_bits = -n;
+                       idx = show_bits(gbc, nb_bits) + code;
+                       code = table[idx][0];
+                       n = table[idx][1];
+               }
+       }
+       skip_bits(gbc, n);
+       return code >= 0? code : -E_VLC;
+}
diff --git a/bitstream.h b/bitstream.h
new file mode 100644 (file)
index 0000000..0999414
--- /dev/null
@@ -0,0 +1,85 @@
+/*
+ * Extracted 2009 from mplayer 2009-02-10 libavcodec/bitstream.h.
+ *
+ * copyright (c) 2004 Michael Niedermayer <michaelni@gmx.at>
+ *
+ * Licensed under the GNU Lesser General Public License.
+ * For licencing details see COPYING.LIB.
+ */
+
+/** \file bitstream.h Bitstream structures and inline functions. */
+
+/** Structure for bistream I/O. */
+struct getbit_context {
+       /* Start of the internal buffer. */
+       const uint8_t *buffer;
+       /* End of the internal buffer. */
+       const uint8_t *buffer_end;
+       /** Bit counter. */
+       int index;
+};
+
+#define VLC_TYPE int16_t
+
+struct vlc {
+       int bits;
+       VLC_TYPE(*table)[2];    ///< code, bits
+       int table_size, table_allocated;
+};
+
+static inline uint32_t show_bits(struct getbit_context *gbc, int num)
+{
+       int idx = gbc->index;
+       const uint8_t *p = gbc->buffer + (idx >> 3);
+       uint32_t x = ((p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]);
+       return (x << (idx & 7)) >> (32 - num);
+}
+
+static inline int get_bits_count(struct getbit_context *gbc)
+{
+       return gbc->index;
+}
+
+static inline void skip_bits(struct getbit_context *gbc, int n)
+{
+       gbc->index += n;
+}
+
+static inline unsigned int get_bits(struct getbit_context *gbc, int n)
+{
+       unsigned int ret = show_bits(gbc, n);
+       skip_bits(gbc, n);
+       return ret;
+}
+
+/* This is rather hot, we can do better than get_bits(gbc, 1). */
+static inline unsigned int get_bit(struct getbit_context *gbc)
+{
+       int idx = gbc->index++;
+       uint8_t tmp = gbc->buffer[idx >> 3], mask = (1 << (7 - (idx & 7)));
+       return !!(tmp & mask);
+}
+
+/**
+ * Initialize a getbit_context structure.
+ *
+ * \param buffer The bitstream buffer. It must be 4 bytes larger then the
+ * actual read bits because the bitstream reader might read 32 bits at once and
+ * could read over the end.
+ *
+ * \param bit_size The size of the buffer in bytes.
+ */
+static inline void init_get_bits(struct getbit_context *gbc,
+               const uint8_t *buffer, int size)
+{
+       gbc->buffer = buffer;
+       gbc->buffer_end = buffer + size;
+       gbc->index = 0;
+}
+
+void init_vlc(struct vlc *vlc, int nb_bits, int nb_codes, const void *bits,
+               const void *codes, int codes_size);
+void free_vlc(struct vlc *vlc);
+int get_vlc(struct getbit_context *gbc, VLC_TYPE(*table)[2], int bits,
+               int max_depth);
+
diff --git a/blob.c b/blob.c
index 5ab5c1c..dfcb64f 100644 (file)
--- a/blob.c
+++ b/blob.c
@@ -6,14 +6,42 @@
 
 /** \file blob.c Macros and functions for blob handling. */
 
+#include <regex.h>
 #include <fnmatch.h>
+#include <openssl/rc4.h>
+#include <osl.h>
+
 #include "para.h"
 #include "error.h"
+#include "crypt.h"
 #include "string.h"
 #include "afh.h"
 #include "afs.h"
 #include "net.h"
 #include "ipc.h"
+#include "portable_io.h"
+
+/**
+ * Compare two osl objects pointing to unsigned integers of 32 bit size.
+ *
+ * \param obj1 Pointer to the first integer.
+ * \param obj2 Pointer to the second integer.
+ *
+ * \return The values required for an osl compare function.
+ *
+ * \sa osl_compare_func, osl_hash_compare().
+ */
+static int uint32_compare(const struct osl_object *obj1, const struct osl_object *obj2)
+{
+       uint32_t d1 = read_u32((const char *)obj1->data);
+       uint32_t d2 = read_u32((const char *)obj2->data);
+
+       if (d1 < d2)
+               return 1;
+       if (d1 > d2)
+               return -1;
+       return 0;
+}
 
 static struct osl_column_description blob_cols[] = {
        [BLOBCOL_ID] = {
@@ -36,6 +64,24 @@ static struct osl_column_description blob_cols[] = {
        }
 };
 
+/** Define an osl table description for a blob table. */
+#define DEFINE_BLOB_TABLE_DESC(table_name) \
+       struct osl_table_description table_name ## _table_desc = { \
+               .name = #table_name, \
+               .num_columns = NUM_BLOB_COLUMNS, \
+               .flags = OSL_LARGE_TABLE, \
+               .column_descriptions = blob_cols \
+       };
+
+/** Define a pointer to an osl blob table with a canonical name. */
+#define DEFINE_BLOB_TABLE_PTR(table_name) struct osl_table *table_name ## _table;
+
+
+/** Define a blob table. */
+#define INIT_BLOB_TABLE(table_name) \
+       DEFINE_BLOB_TABLE_DESC(table_name); \
+       DEFINE_BLOB_TABLE_PTR(table_name);
+
 /** \cond doxygen isn't smart enough to recognize these */
 INIT_BLOB_TABLE(lyrics);
 INIT_BLOB_TABLE(images);
@@ -71,7 +117,7 @@ static int print_blob(struct osl_table *table, struct osl_row *row,
 
        if (!(lbad->flags & BLOB_LS_FLAG_LONG))
                return para_printf(&lbad->pb, "%s\n", name);
-       ret = osl_get_object(table, row, BLOBCOL_ID, &obj);
+       ret = osl(osl_get_object(table, row, BLOBCOL_ID, &obj));
        if (ret < 0) {
                para_printf(&lbad->pb, "%s: %s\n", name, para_strerror(-ret));
                return ret;
@@ -116,7 +162,7 @@ static void com_lsblob_callback(struct osl_table *table,
        free(lbad.pb.buf);
 }
 
-static int com_lsblob(callback_function *f, int fd, int argc, char * const * const argv)
+static int com_lsblob(callback_function *f, struct rc4_context *rc4c, int argc, char * const * const argv)
 {
        uint32_t flags = 0;
        struct osl_object options = {.data = &flags, .size = sizeof(flags)};
@@ -147,7 +193,7 @@ static int com_lsblob(callback_function *f, int fd, int argc, char * const * con
 //     if (argc > i)
 //             return -E_BLOB_SYNTAX;
        return send_option_arg_callback_request(&options, argc - i,
-               argv + i, f, send_result, &fd);
+               argv + i, f, rc4_send_result, rc4c);
 }
 
 static int cat_blob(struct osl_table *table, struct osl_row *row,
@@ -156,12 +202,12 @@ static int cat_blob(struct osl_table *table, struct osl_row *row,
        int ret = 0, ret2;
        struct osl_object obj;
 
-       ret = osl_open_disk_object(table, row, BLOBCOL_DEF, &obj);
+       ret = osl(osl_open_disk_object(table, row, BLOBCOL_DEF, &obj));
        if (ret < 0)
                return ret;
        if (obj.size)
                ret = pass_buffer_as_shm(obj.data, obj.size, data);
-       ret2 = osl_close_disk_object(&obj);
+       ret2 = osl(osl_close_disk_object(&obj));
        return (ret < 0)? ret : ret2;
 }
 
@@ -180,12 +226,13 @@ static void com_catblob_callback(struct osl_table *table, int fd,
        for_each_matching_row(&pmd);
 }
 
-static int com_catblob(callback_function *f, int fd, int argc,
+static int com_catblob(callback_function *f, struct rc4_context *rc4c, int argc,
                char * const * const argv)
 {
        if (argc < 2)
                return -E_BLOB_SYNTAX;
-       return send_standard_callback_request(argc - 1, argv + 1, f, send_result, &fd);
+       return send_standard_callback_request(argc - 1, argv + 1, f,
+               rc4_send_result, rc4c);
 }
 
 /** Used for removing rows from a blob table. */
@@ -200,7 +247,7 @@ static int remove_blob(struct osl_table *table, struct osl_row *row,
                const char *name, void *data)
 {
        struct rmblob_data *rmbd = data;
-       int ret = osl_del_row(table, row);
+       int ret = osl(osl_del_row(table, row));
        if (ret < 0) {
                para_printf(&rmbd->pb, "%s: %s\n", name, para_strerror(-ret));
                return ret;
@@ -248,13 +295,13 @@ out:
        free(rmbd.pb.buf);
 }
 
-static int com_rmblob(callback_function *f, int fd, int argc,
+static int com_rmblob(callback_function *f, struct rc4_context *rc4c, int argc,
                char * const * const argv)
 {
        if (argc < 2)
                return -E_MOOD_SYNTAX;
        return send_option_arg_callback_request(NULL, argc - 1, argv + 1, f,
-               send_result, &fd);
+               rc4_send_result, rc4c);
 }
 
 static void com_addblob_callback(struct osl_table *table, __a_unused int fd,
@@ -267,7 +314,7 @@ static void com_addblob_callback(struct osl_table *table, __a_unused int fd,
        unsigned num_rows;
        int ret;
 
-       ret = osl_get_num_rows(table, &num_rows);
+       ret = osl(osl_get_num_rows(table, &num_rows));
        if (ret < 0)
                goto out;
        if (!num_rows) { /* this is the first entry ever added */
@@ -279,34 +326,34 @@ static void com_addblob_callback(struct osl_table *table, __a_unused int fd,
                objs[BLOBCOL_NAME].size = 1;
                objs[BLOBCOL_DEF].data = "";
                objs[BLOBCOL_DEF].size = 1;
-               ret = osl_add_row(table, objs);
+               ret = osl(osl_add_row(table, objs));
                if (ret < 0)
                        goto out;
        } else {
                /* check if name already exists */
                struct osl_row *row;
                struct osl_object obj = {.data = name, .size = name_len};
-               ret = osl_get_row(table, BLOBCOL_NAME, &obj, &row);
-               if (ret < 0 && ret != -E_RB_KEY_NOT_FOUND)
+               ret = osl(osl_get_row(table, BLOBCOL_NAME, &obj, &row));
+               if (ret < 0 && ret != -OSL_ERRNO_TO_PARA_ERROR(E_OSL_RB_KEY_NOT_FOUND))
                        goto out;
                if (ret >= 0) { /* we already have a blob with this name */
                        obj.data = name + name_len;
                        obj.size = query->size - name_len;
-                       ret = osl_update_object(table, row, BLOBCOL_DEF, &obj);
+                       ret = osl(osl_update_object(table, row, BLOBCOL_DEF, &obj));
                        goto out;
                }
                /* new blob, get id of the dummy row and increment it */
                obj.data = "";
                obj.size = 1;
-               ret = osl_get_row(table, BLOBCOL_NAME, &obj, &row);
+               ret = osl(osl_get_row(table, BLOBCOL_NAME, &obj, &row));
                if (ret < 0)
                        goto out;
-               ret = osl_get_object(table, row, BLOBCOL_ID, &obj);
+               ret = osl(osl_get_object(table, row, BLOBCOL_ID, &obj));
                if (ret < 0)
                        goto out;
                id = *(uint32_t *)obj.data + 1;
                obj.data = &id;
-               ret = osl_update_object(table, row, BLOBCOL_ID, &obj);
+               ret = osl(osl_update_object(table, row, BLOBCOL_ID, &obj));
                if (ret < 0)
                        goto out;
        }
@@ -317,7 +364,7 @@ static void com_addblob_callback(struct osl_table *table, __a_unused int fd,
        objs[BLOBCOL_NAME].size = name_len;
        objs[BLOBCOL_DEF].data = name + name_len;
        objs[BLOBCOL_DEF].size = query->size - name_len;
-       ret = osl_add_row(table, objs);
+       ret = osl(osl_add_row(table, objs));
        if (ret < 0)
                goto out;
        afs_event(BLOB_ADD, NULL, table);
@@ -326,7 +373,82 @@ out:
                PARA_NOTICE_LOG("%s\n", para_strerror(-ret));
 }
 
-static int com_addblob(callback_function *f, int fd, int argc,
+/*
+ * write input from fd to dynamically allocated buffer,
+ * but maximal max_size byte.
+ */
+static int fd2buf(struct rc4_context *rc4c, unsigned max_size, struct osl_object *obj)
+{
+       const size_t chunk_size = 1024;
+       size_t size = 2048, received = 0;
+       int ret;
+       char *buf = para_malloc(size);
+
+       for (;;) {
+               ret = rc4_recv_bin_buffer(rc4c, buf + received, chunk_size);
+               if (ret <= 0)
+                       break;
+               received += ret;
+               if (received + chunk_size >= size) {
+                       size *= 2;
+                       ret = -E_INPUT_TOO_LARGE;
+                       if (size > max_size)
+                               break;
+                       buf = para_realloc(buf, size);
+               }
+       }
+       obj->data = buf;
+       obj->size = received;
+       if (ret < 0)
+               free(buf);
+       return ret;
+}
+
+/*
+ * Read data from a file descriptor, and send it to the afs process.
+ *
+ * \param rc4c crypt context containing the file descriptor to read data from.
+ * \param arg_obj Pointer to the arguments to \a f.
+ * \param f The callback function.
+ * \param max_len Don't read more than that many bytes from stdin.
+ * \param result_handler See \ref send_callback_request.
+ * \param private_result_data See \ref send_callback_request.
+ *
+ * This function is used by commands that wish to let para_server store
+ * arbitrary data specified by the user (for instance the add_blob family of
+ * commands). First, at most \a max_len bytes are read and decrypted from the
+ * file descriptor given by \a rc4c. The result is concatenated with the buffer
+ * given by \a arg_obj, and the combined buffer is made available to the afs
+ * process via the callback method. See \ref send_callback_request for details.
+ *
+ * \return Negative on errors, the return value of the underlying call to
+ * send_callback_request() otherwise.
+ */
+static int stdin_command(struct rc4_context *rc4c, struct osl_object *arg_obj,
+               callback_function *f, unsigned max_len,
+               callback_result_handler *result_handler,
+               void *private_result_data)
+{
+       struct osl_object query, stdin_obj;
+       int ret;
+
+       ret = rc4_send_buffer(rc4c, AWAITING_DATA_MSG);
+       if (ret < 0)
+               return ret;
+       ret = fd2buf(rc4c, max_len, &stdin_obj);
+       if (ret < 0)
+               return ret;
+       query.size = arg_obj->size + stdin_obj.size;
+       query.data = para_malloc(query.size);
+       memcpy(query.data, arg_obj->data, arg_obj->size);
+       memcpy((char *)query.data + arg_obj->size, stdin_obj.data, stdin_obj.size);
+       free(stdin_obj.data);
+       ret = send_callback_request(f, &query, result_handler, private_result_data);
+       free(query.data);
+       return ret;
+}
+
+static int com_addblob(callback_function *f, struct rc4_context *rc4c, int argc,
                char * const * const argv)
 {
        struct osl_object arg_obj;
@@ -337,7 +459,7 @@ static int com_addblob(callback_function *f, int fd, int argc,
                return -E_BLOB_SYNTAX;
        arg_obj.size = strlen(argv[1]) + 1;
        arg_obj.data = (char *)argv[1];
-       return stdin_command(fd, &arg_obj, f, 10 * 1024 * 1024, NULL, NULL);
+       return stdin_command(rc4c, &arg_obj, f, 10 * 1024 * 1024, NULL, NULL);
 }
 
 /* FIXME: Print output to client, not to log file */
@@ -348,13 +470,13 @@ static void com_mvblob_callback(struct osl_table *table, __a_unused int fd,
        struct osl_object obj = {.data = src, .size = strlen(src) + 1};
        char *dest = src + obj.size;
        struct osl_row *row;
-       int ret = osl_get_row(table, BLOBCOL_NAME, &obj, &row);
+       int ret = osl(osl_get_row(table, BLOBCOL_NAME, &obj, &row));
 
        if (ret < 0)
                goto out;
        obj.data = dest;
        obj.size = strlen(dest) + 1;
-       ret = osl_update_object(table, row, BLOBCOL_NAME, &obj);
+       ret = osl(osl_update_object(table, row, BLOBCOL_NAME, &obj));
        if (ret < 0)
                goto out;
        afs_event(BLOB_RENAME, NULL, table);
@@ -363,7 +485,7 @@ out:
                PARA_NOTICE_LOG("%s\n", para_strerror(-ret));
 }
 
-static int com_mvblob(callback_function *f, __a_unused int fd,
+static int com_mvblob(callback_function *f, __a_unused struct rc4_context *rc4c,
                int argc, char * const * const argv)
 {
        if (argc != 3)
@@ -377,9 +499,9 @@ static int com_mvblob(callback_function *f, __a_unused int fd,
        { \
                return com_ ## cmd_name ## blob_callback(table_name ## _table, fd, query); \
        } \
-       int com_ ## cmd_name ## cmd_prefix(int fd, int argc, char * const * const argv) \
+       int com_ ## cmd_name ## cmd_prefix(struct rc4_context *rc4c, int argc, char * const * const argv) \
        { \
-               return com_ ## cmd_name ## blob(com_ ## cmd_name ## cmd_prefix ## _callback, fd, argc, argv); \
+               return com_ ## cmd_name ## blob(com_ ## cmd_name ## cmd_prefix ## _callback, rc4c, argc, argv); \
        }
 
 static int blob_get_name_by_id(struct osl_table *table, uint32_t id,
@@ -392,10 +514,10 @@ static int blob_get_name_by_id(struct osl_table *table, uint32_t id,
        *name = NULL;
        if (!id)
                return 1;
-       ret = osl_get_row(table, BLOBCOL_ID, &obj, &row);
+       ret = osl(osl_get_row(table, BLOBCOL_ID, &obj, &row));
        if (ret < 0)
                return ret;
-       ret = osl_get_object(table, row, BLOBCOL_NAME, &obj);
+       ret = osl(osl_get_object(table, row, BLOBCOL_NAME, &obj));
        if (ret < 0)
                return ret;
        *name = (char *)obj.data;
@@ -420,10 +542,10 @@ static int blob_get_def_by_name(struct osl_table *table, char *name,
        def->data = NULL;
        if (!*name)
                return 1;
-       ret = osl_get_row(table, BLOBCOL_NAME, &obj, &row);
+       ret = osl(osl_get_row(table, BLOBCOL_NAME, &obj, &row));
        if (ret < 0)
                return ret;
-       return osl_open_disk_object(table, row, BLOBCOL_DEF, def);
+       return osl(osl_open_disk_object(table, row, BLOBCOL_DEF, def));
 }
 
 /** Define the \p get_def_by_id function for this blob type. */
@@ -443,10 +565,10 @@ static int blob_get_def_by_id(struct osl_table *table, uint32_t id,
        def->data = NULL;
        if (!id)
                return 1;
-       ret = osl_get_row(table, BLOBCOL_ID, &obj, &row);
+       ret = osl(osl_get_row(table, BLOBCOL_ID, &obj, &row));
        if (ret < 0)
                return ret;
-       return osl_open_disk_object(table, row, BLOBCOL_DEF, def);
+       return osl(osl_open_disk_object(table, row, BLOBCOL_DEF, def));
 }
 
 /** Define the \p get_def_by_id function for this blob type. */
@@ -460,11 +582,11 @@ static int blob_get_name_and_def_by_row(struct osl_table *table,
                const struct osl_row *row, char **name, struct osl_object *def)
 {
        struct osl_object obj;
-       int ret = osl_get_object(table, row, BLOBCOL_NAME, &obj);
+       int ret = osl(osl_get_object(table, row, BLOBCOL_NAME, &obj));
        if (ret < 0)
                return ret;
        *name = obj.data;
-       return osl_open_disk_object(table, row, BLOBCOL_DEF, def);
+       return osl(osl_open_disk_object(table, row, BLOBCOL_DEF, def));
 }
 /** Define the \p get_name_and_def_by_row function for this blob type. */
 #define DEFINE_GET_NAME_AND_DEF_BY_ROW(table_name, cmd_prefix) \
@@ -497,11 +619,11 @@ static int blob_open(struct osl_table **table,
 {
        int ret;
        desc->dir = dir;
-       ret = osl_open_table(desc, table);
+       ret = osl(osl_open_table(desc, table));
        if (ret >= 0)
                return ret;
        *table = NULL;
-       if (ret >= 0 || is_errno(-ret, ENOENT))
+       if (ret >= 0 || ret == -OSL_ERRNO_TO_PARA_ERROR(E_OSL_NOENT))
                return 1;
        return ret;
 }
index fa31718..bb97c69 100644 (file)
@@ -6,6 +6,8 @@
 
 /** \file chunk_queue.c Queuing functions for paraslash senders. */
 
+#include <regex.h>
+
 #include "para.h"
 #include "list.h"
 #include "afh.h"
index 003c1e6..ebe3389 100644 (file)
--- a/client.c
+++ b/client.c
@@ -6,9 +6,13 @@
 
 /** \file client.c the client program used to connect to para_server */
 
+#include <regex.h>
+#include <openssl/rc4.h>
+
 #include "para.h"
 #include "list.h"
 #include "sched.h"
+#include "crypt.h"
 #include "client.cmdline.h"
 #include "string.h"
 #include "stdin.h"
@@ -78,6 +82,7 @@ int main(int argc, char *argv[])
        int ret;
        static struct sched s;
 
+       init_random_seed_or_die();
        s.default_timeout.tv_sec = 1;
        s.default_timeout.tv_usec = 0;
        ret = client_open(argc, argv, &ct, &client_loglevel);
index c6d5c75..5fc3368 100644 (file)
--- a/client.h
+++ b/client.h
@@ -41,8 +41,8 @@ enum {
 struct client_task {
        /** the state of the connection */
        int status;
-       /** the file descriptor */
-       int fd;
+       /** The file descriptor and the rc4 keys. */
+       struct rc4_context rc4c;
        /** the configuration (including the command) */
        struct client_args_info conf;
        /** the config file for client options */
@@ -51,10 +51,6 @@ struct client_task {
        char *key_file;
        /** paraslash user name */
        char *user;
-       /** session key for receiving data */
-       RC4_KEY rc4_recv_key;
-       /** session key for sending data */
-       RC4_KEY rc4_send_key;
        /** the client task structure */
        struct task task;
        /** the buffer used for handshake and receiving */
@@ -65,8 +61,6 @@ struct client_task {
        int check_r;
        /** non-zero if the pre_select hook added \p fd to the write fd set */
        int check_w;
-       /** the decrypted challenge */
-       long unsigned challenge_nr;
        /** pointer to the data to be sent to para_server */
        char *inbuf;
        /** number of bytes loaded in \p inbuf */
index cf77acd..b6bfde9 100644 (file)
@@ -6,8 +6,10 @@
 
 /** \file client_common.c Common functions of para_client and para_audiod. */
 
+#include <regex.h>
 #include <sys/types.h>
 #include <dirent.h>
+#include <openssl/rc4.h>
 
 #include "para.h"
 #include "error.h"
 #include "string.h"
 #include "client.cmdline.h"
 #include "client.h"
-
-/*
- * Rc4-encrypt data before sending.
- *
- * \param len The number of bytes to encrypt.
- * \param indata Pointer to the input data of length \a len to be encrypted.
- * \param outdata Result-pointer that holds the encrypted data.
- * \param private_data Contains the rc4 key.
- */
-static void rc4_send(unsigned long len, const unsigned char *indata,
-               unsigned char *outdata, void *private_data)
-{
-       struct client_task *ct = private_data;
-       RC4(&ct->rc4_send_key, len, indata, outdata);
-}
-
-/*
- * Rc4-decrypt received data.
- *
- * Parameters are identical to those of rc4_send.
- */
-static void rc4_recv(unsigned long len, const unsigned char *indata,
-               unsigned char *outdata, void *private_data)
-{
-       struct client_task *ct = private_data;
-       RC4(&ct->rc4_recv_key, len, indata, outdata);
-}
+#include "hash.h"
 
 /**
  * Close the connection to para_server and free all resources.
@@ -60,10 +36,8 @@ void client_close(struct client_task *ct)
 {
        if (!ct)
                return;
-       if (ct->fd >= 0) {
-               disable_crypt(ct->fd);
-               close(ct->fd);
-       }
+       if (ct->rc4c.fd >= 0)
+               close(ct->rc4c.fd);
        free(ct->buf);
        free(ct->user);
        free(ct->config_file);
@@ -92,27 +66,27 @@ static void client_pre_select(struct sched *s, struct task *t)
 
        ct->check_r = 0;
        ct->check_w = 0;
-       if (ct->fd < 0)
+       if (ct->rc4c.fd < 0)
                return;
        switch (ct->status) {
        case CL_CONNECTED:
        case CL_SENT_AUTH:
        case CL_SENT_CH_RESPONSE:
        case CL_SENT_COMMAND:
-               para_fd_set(ct->fd, &s->rfds, &s->max_fileno);
+               para_fd_set(ct->rc4c.fd, &s->rfds, &s->max_fileno);
                ct->check_r = 1;
                return;
 
        case CL_RECEIVED_WELCOME:
        case CL_RECEIVED_CHALLENGE:
        case CL_RECEIVED_PROCEED:
-               para_fd_set(ct->fd, &s->wfds, &s->max_fileno);
+               para_fd_set(ct->rc4c.fd, &s->wfds, &s->max_fileno);
                ct->check_w = 1;
                return;
 
        case CL_RECEIVING:
                if (ct->loaded < CLIENT_BUFSIZE - 1) {
-                       para_fd_set(ct->fd, &s->rfds, &s->max_fileno);
+                       para_fd_set(ct->rc4c.fd, &s->rfds, &s->max_fileno);
                        ct->check_r = 1;
                }
                return;
@@ -121,7 +95,7 @@ static void client_pre_select(struct sched *s, struct task *t)
                        return;
                if (*ct->in_loaded) {
                        PARA_INFO_LOG("loaded: %zd\n", *ct->in_loaded);
-                       para_fd_set(ct->fd, &s->wfds, &s->max_fileno);
+                       para_fd_set(ct->rc4c.fd, &s->wfds, &s->max_fileno);
                        ct->check_w = 1;
                } else {
                        if (*ct->in_error) {
@@ -136,14 +110,19 @@ static void client_pre_select(struct sched *s, struct task *t)
 
 static ssize_t client_recv_buffer(struct client_task *ct)
 {
-       ssize_t ret = recv_buffer(ct->fd, ct->buf + ct->loaded,
-               CLIENT_BUFSIZE - ct->loaded);
+       ssize_t ret;
+
+       if (ct->status < CL_SENT_CH_RESPONSE)
+               ret = recv_buffer(ct->rc4c.fd, ct->buf + ct->loaded,
+                       CLIENT_BUFSIZE - ct->loaded);
+       else
+               ret = rc4_recv_buffer(&ct->rc4c, ct->buf + ct->loaded,
+                       CLIENT_BUFSIZE - ct->loaded);
        if (!ret)
                return -E_SERVER_EOF;
        if (ret > 0)
                ct->loaded += ret;
        return ret;
-
 }
 
 /**
@@ -164,80 +143,80 @@ static void client_post_select(struct sched *s, struct task *t)
        struct client_task *ct = container_of(t, struct client_task, task);
 
        t->error = 0;
-       if (ct->fd < 0)
+       if (ct->rc4c.fd < 0)
                return;
        if (!ct->check_r && !ct->check_w)
                return;
-       if (ct->check_r && !FD_ISSET(ct->fd, &s->rfds))
+       if (ct->check_r && !FD_ISSET(ct->rc4c.fd, &s->rfds))
                return;
-       if (ct->check_w && !FD_ISSET(ct->fd, &s->wfds))
+       if (ct->check_w && !FD_ISSET(ct->rc4c.fd, &s->wfds))
                return;
        switch (ct->status) {
        case CL_CONNECTED: /* receive welcome message */
                t->error = client_recv_buffer(ct);
-               if (t->error > 0)
-                       ct->status = CL_RECEIVED_WELCOME;
+               if (t->error < 0)
+                       goto err;
+               ct->status = CL_RECEIVED_WELCOME;
                return;
        case CL_RECEIVED_WELCOME: /* send auth command */
-               sprintf(ct->buf, "auth %s%s", ct->conf.plain_given?
-                       "" : "rc4 ", ct->user);
+               sprintf(ct->buf, AUTH_REQUEST_MSG "%s", ct->user);
                PARA_INFO_LOG("--> %s\n", ct->buf);
-               t->error = send_buffer(ct->fd, ct->buf);
-               if (t->error >= 0)
-                       ct->status = CL_SENT_AUTH;
+               t->error = send_buffer(ct->rc4c.fd, ct->buf);
+               if (t->error < 0)
+                       goto err;
+               ct->status = CL_SENT_AUTH;
                return;
-       case CL_SENT_AUTH: /* receive challenge number */
+       case CL_SENT_AUTH: /* receive challenge and rc4 keys */
                ct->loaded = 0;
                t->error = client_recv_buffer(ct);
                if (t->error < 0)
-                       return;
-               if (t->error < 64) {
-                       t->error = -E_INVALID_CHALLENGE;
-                       PARA_ERROR_LOG("received the following: %s\n", ct->buf);
-                       return;
-               }
-               PARA_INFO_LOG("<-- [challenge] (%d bytes)\n", t->error);
-               /* decrypt challenge number */
-               t->error = para_decrypt_challenge(ct->key_file, &ct->challenge_nr,
-                       (unsigned char *) ct->buf, t->error);
-               if (t->error > 0)
-                       ct->status = CL_RECEIVED_CHALLENGE;
+                       goto err;
+               ct->loaded = t->error;
+               PARA_INFO_LOG("<-- [challenge] (%zu bytes)\n", ct->loaded);
+               ct->status = CL_RECEIVED_CHALLENGE;
                return;
-       case CL_RECEIVED_CHALLENGE: /* send decrypted challenge */
-               PARA_INFO_LOG("--> %lu\n", ct->challenge_nr);
-               t->error = send_va_buffer(ct->fd, "%s%lu", CHALLENGE_RESPONSE_MSG,
-                       ct->challenge_nr);
-               if (t->error > 0)
-                       ct->status = CL_SENT_CH_RESPONSE;
+       case CL_RECEIVED_CHALLENGE:
+               {
+               /* decrypted challenge/rc4 buffer */
+               unsigned char crypt_buf[1024];
+               /* the SHA1 of the decrypted challenge */
+               unsigned char challenge_sha1[HASH_SIZE];
+
+               t->error = para_decrypt_buffer(ct->key_file, crypt_buf,
+                       (unsigned char *)ct->buf, ct->loaded);
+               if (t->error < 0)
+                       goto err;
+               sha1_hash((char *)crypt_buf, CHALLENGE_SIZE, challenge_sha1);
+               RC4_set_key(&ct->rc4c.send_key, RC4_KEY_LEN,
+                       crypt_buf + CHALLENGE_SIZE);
+               RC4_set_key(&ct->rc4c.recv_key, RC4_KEY_LEN,
+                       crypt_buf + CHALLENGE_SIZE + RC4_KEY_LEN);
+               hash_to_asc(challenge_sha1, ct->buf);
+               PARA_INFO_LOG("--> %s\n", ct->buf);
+               t->error = send_bin_buffer(ct->rc4c.fd, (char *)challenge_sha1,
+                       HASH_SIZE);
+               if (t->error < 0)
+                       goto err;
+               ct->status = CL_SENT_CH_RESPONSE;
                return;
+               }
        case CL_SENT_CH_RESPONSE: /* read server response */
                {
                size_t bytes_received;
-               unsigned char rc4_buf[2 * RC4_KEY_LEN] = "";
                ct->loaded = 0;
                t->error = client_recv_buffer(ct);
                if (t->error < 0)
-                       return;
+                       goto err;
                bytes_received = t->error;
-               PARA_DEBUG_LOG("++++ server info ++++\n%s\n++++ end of server "
-                       "info ++++\n", ct->buf);
                /* check if server has sent "Proceed" message */
                t->error = -E_CLIENT_AUTH;
+               if (bytes_received < PROCEED_MSG_LEN)
+                       goto err;
                if (!strstr(ct->buf, PROCEED_MSG))
-                       return;
-               t->error = 0;
+                       goto err;
                ct->status = CL_RECEIVED_PROCEED;
-               if (bytes_received < PROCEED_MSG_LEN + 32)
-                       return;
-               PARA_INFO_LOG("decrypting session key\n");
-               t->error = para_decrypt_buffer(ct->key_file, rc4_buf,
-                       (unsigned char *)ct->buf + PROCEED_MSG_LEN + 1,
-                       bytes_received - PROCEED_MSG_LEN - 1);
-               if (t->error < 0)
-                       return;
-               RC4_set_key(&ct->rc4_send_key, RC4_KEY_LEN, rc4_buf);
-               RC4_set_key(&ct->rc4_recv_key, RC4_KEY_LEN, rc4_buf + RC4_KEY_LEN);
-               enable_crypt(ct->fd, rc4_recv, rc4_send, ct);
+               t->error = 0;
+               return;
                }
        case CL_RECEIVED_PROCEED: /* concat args and send command */
                {
@@ -251,33 +230,40 @@ static void client_post_select(struct sched *s, struct task *t)
                }
                command = para_strcat(command, EOC_MSG "\n");
                PARA_DEBUG_LOG("--> %s\n", command);
-               t->error = send_buffer(ct->fd, command);
+               t->error = rc4_send_buffer(&ct->rc4c, command);
                free(command);
-               if (t->error > 0)
-                       ct->status = CL_SENT_COMMAND;
+               if (t->error < 0)
+                       goto err;
+               ct->status = CL_SENT_COMMAND;
                return;
                }
        case CL_SENT_COMMAND:
                ct->loaded = 0;
                t->error = client_recv_buffer(ct);
                if (t->error < 0)
-                       return;
+                       goto err;
                if (strstr(ct->buf, AWAITING_DATA_MSG))
                        ct->status = CL_SENDING;
                else
                        ct->status = CL_RECEIVING;
                return;
-       case CL_SENDING: /* FIXME: might block */
+       case CL_SENDING:
                PARA_INFO_LOG("loaded: %zd\n", *ct->in_loaded);
-               t->error = send_bin_buffer(ct->fd, ct->inbuf, *ct->in_loaded);
+               t->error = rc4_send_bin_buffer(&ct->rc4c, ct->inbuf,
+                       *ct->in_loaded);
                if (t->error < 0)
-                       return;
+                       goto err;
                *ct->in_loaded = 0;
                return;
        case CL_RECEIVING:
                t->error = client_recv_buffer(ct);
+               if (t->error < 0)
+                       goto err;
                return;
        }
+err:
+       if (t->error != -E_SERVER_EOF)
+               PARA_ERROR_LOG("%s\n", para_strerror(-t->error));
 }
 
 /* connect to para_server and register the client task */
@@ -285,14 +271,14 @@ static int client_connect(struct client_task *ct)
 {
        int ret;
 
-       ct->fd = -1;
+       ct->rc4c.fd = -1;
        ret = makesock(AF_UNSPEC, IPPROTO_TCP, 0, ct->conf.hostname_arg,
                ct->conf.server_port_arg);
        if (ret < 0)
                return ret;
-       ct->fd = ret;
+       ct->rc4c.fd = ret;
        ct->status = CL_CONNECTED;
-       ret = mark_fd_nonblocking(ct->fd);
+       ret = mark_fd_nonblocking(ct->rc4c.fd);
        if (ret < 0)
                goto err_out;
        ct->task.pre_select = client_pre_select;
@@ -301,8 +287,8 @@ static int client_connect(struct client_task *ct)
        register_task(&ct->task);
        return 1;
 err_out:
-       close(ct->fd);
-       ct->fd = -1;
+       close(ct->rc4c.fd);
+       ct->rc4c.fd = -1;
        return ret;
 }
 
@@ -330,7 +316,7 @@ int client_open(int argc, char *argv[], struct client_task **ct_ptr,
 
        ct->buf = para_malloc(CLIENT_BUFSIZE);
        *ct_ptr = ct;
-       ct->fd = -1;
+       ct->rc4c.fd = -1;
        ret = -E_CLIENT_SYNTAX;
        if (client_cmdline_parser(argc, argv, &ct->conf))
                goto out;
index 378799c..fb19064 100644 (file)
@@ -5,6 +5,9 @@
  */
 
 /** \file close_on_fork.c Manage a list of fds that should be closed on fork. */
+
+#include <regex.h>
+
 #include "para.h"
 #include "list.h"
 #include "string.h"
index f61ea57..8fdb839 100644 (file)
--- a/command.c
+++ b/command.c
@@ -6,14 +6,18 @@
 
 /** \file command.c Client authentication and server commands. */
 
+#include <regex.h>
 #include <signal.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <dirent.h>
 #include <openssl/rc4.h>
+#include <osl.h>
 
 #include "para.h"
 #include "error.h"
+#include "crypt.h"
+#include "command.h"
 #include "server.cmdline.h"
 #include "string.h"
 #include "afh.h"
 /** Commands including options must be shorter than this. */
 #define MAX_COMMAND_LEN 32768
 
-static RC4_KEY rc4_recv_key;
-static RC4_KEY rc4_send_key;
-static unsigned char rc4_buf[2 * RC4_KEY_LEN];
-
 extern int mmd_mutex;
 extern struct misc_meta_data *mmd;
 extern struct sender senders[];
+int send_afs_status(struct rc4_context *rc4c, int parser_friendly);
+
+const char *status_item_list[] = {STATUS_ITEM_ARRAY};
 
 static void dummy(__a_unused int s)
 {
@@ -102,14 +105,15 @@ static char *vss_get_status_flags(unsigned int flags)
        return msg;
 }
 
-static char *get_status(struct misc_meta_data *nmmd)
+static char *get_status(struct misc_meta_data *nmmd, int parser_friendly)
 {
-       char *ret, mtime[30] = "";
+       char mtime[30] = "";
        char *status, *flags; /* vss status info */
        char *ut = uptime_str();
        long offset = (nmmd->offset + 500) / 1000;
        struct timeval current_time;
        struct tm mtime_tm;
+       struct para_buffer b = {.flags = parser_friendly? PBF_SIZE_PREFIX : 0};
 
        /* report real status */
        status = vss_status_tohuman(nmmd->vss_status_flags);
@@ -119,38 +123,22 @@ static char *get_status(struct misc_meta_data *nmmd)
                strftime(mtime, 29, "%b %d %Y", &mtime_tm);
        }
        gettimeofday(&current_time, NULL);
-       ret = make_message(
-               "%s: %zu\n" /* file size */
-               "%s: %s\n" /* mtime */
-               "%s: %s\n" /* status */
-               "%s: %s\n" /* status flags */
-               "%s: %li\n" /* offset */
-               "%s: %s\n" /* afs mode */
-               "%s: %lu.%lu\n" /* stream start */
-               "%s: %lu.%lu\n" /* current server time */
-               "%s", /* afs status info */
-               status_item_list[SI_FILE_SIZE], nmmd->size / 1024,
-               status_item_list[SI_MTIME], mtime,
-               status_item_list[SI_STATUS], status,
-               status_item_list[SI_STATUS_FLAGS], flags,
-
-               status_item_list[SI_OFFSET], offset,
-               status_item_list[SI_AFS_MODE], mmd->afs_mode_string,
-
-               status_item_list[SI_STREAM_START],
-                       (long unsigned)nmmd->stream_start.tv_sec,
-                       (long unsigned)nmmd->stream_start.tv_usec,
-               status_item_list[SI_CURRENT_TIME],
-                       (long unsigned)current_time.tv_sec,
-                       (long unsigned)current_time.tv_usec,
-
-               nmmd->afd.verbose_ls_output
-
-       );
+       WRITE_STATUS_ITEM(&b, SI_FILE_SIZE, "%zu\n", nmmd->size / 1024);
+       WRITE_STATUS_ITEM(&b, SI_MTIME, "%s\n", mtime);
+       WRITE_STATUS_ITEM(&b, SI_STATUS, "%s\n", status);
+       WRITE_STATUS_ITEM(&b, SI_STATUS_FLAGS, "%s\n", flags);
+       WRITE_STATUS_ITEM(&b, SI_OFFSET, "%li\n", offset);
+       WRITE_STATUS_ITEM(&b, SI_AFS_MODE, "%s\n", mmd->afs_mode_string);
+       WRITE_STATUS_ITEM(&b, SI_STREAM_START, "%lu.%lu\n",
+               (long unsigned)nmmd->stream_start.tv_sec,
+               (long unsigned)nmmd->stream_start.tv_usec);
+       WRITE_STATUS_ITEM(&b, SI_CURRENT_TIME, "%lu.%lu\n",
+               (long unsigned)current_time.tv_sec,
+               (long unsigned)current_time.tv_usec);
        free(flags);
        free(status);
        free(ut);
-       return ret;
+       return b.buf;
 }
 
 static int check_sender_args(int argc, char * const * argv, struct sender_command_data *scd)
@@ -200,7 +188,7 @@ static int check_sender_args(int argc, char * const * argv, struct sender_comman
        return 1;
 }
 
-int com_sender(int fd, int argc, char * const * argv)
+int com_sender(struct rc4_context *rc4c, int argc, char * const * argv)
 {
        int i, ret;
        struct sender_command_data scd;
@@ -213,7 +201,7 @@ int com_sender(int fd, int argc, char * const * argv)
                        free(msg);
                        msg = tmp;
                }
-               ret = send_buffer(fd, msg);
+               ret = rc4_send_buffer(rc4c, msg);
                free(msg);
                return ret;
        }
@@ -223,7 +211,7 @@ int com_sender(int fd, int argc, char * const * argv)
                if (scd.sender_num < 0)
                        return ret;
                msg = senders[scd.sender_num].help();
-               ret = send_buffer(fd, msg);
+               ret = rc4_send_buffer(rc4c, msg);
                free(msg);
                return ret;
        }
@@ -242,7 +230,7 @@ int com_sender(int fd, int argc, char * const * argv)
 }
 
 /* server info */
-int com_si(int fd, int argc, __a_unused char * const * argv)
+int com_si(struct rc4_context *rc4c, int argc, __a_unused char * const * argv)
 {
        int i, ret;
        char *ut;
@@ -259,7 +247,7 @@ int com_si(int fd, int argc, __a_unused char * const * argv)
                sender_list = para_strcat(sender_list, " ");
        }
        ut = uptime_str();
-       ret = send_va_buffer(fd, "up: %s\nplayed: %u\n"
+       ret = rc4_send_va_buffer(rc4c, "up: %s\nplayed: %u\n"
                "server_pid: %d\n"
                "afs_pid: %d\n"
                "connections (active/accepted/total): %u/%u/%u\n"
@@ -286,42 +274,120 @@ int com_si(int fd, int argc, __a_unused char * const * argv)
 }
 
 /* version */
-int com_version(int fd, int argc, __a_unused char * const * argv)
+int com_version(struct rc4_context *rc4c, int argc, __a_unused char * const * argv)
 {
        if (argc != 1)
                return -E_COMMAND_SYNTAX;
-       return send_buffer(fd, VERSION_TEXT("server")
+       return rc4_send_buffer(rc4c, VERSION_TEXT("server")
                "built: " BUILD_DATE "\n"
                UNAME_RS ", " CC_VERSION "\n"
        );
 }
 
+#define EMPTY_STATUS_ITEMS \
+       ITEM(PATH) \
+       ITEM(DIRECTORY) \
+       ITEM(BASENAME) \
+       ITEM(SCORE) \
+       ITEM(ATTRIBUTES_BITMAP) \
+       ITEM(ATTRIBUTES_TXT) \
+       ITEM(HASH) \
+       ITEM(IMAGE_ID) \
+       ITEM(IMAGE_NAME) \
+       ITEM(LYRICS_ID) \
+       ITEM(LYRICS_NAME) \
+       ITEM(BITRATE) \
+       ITEM(FORMAT) \
+       ITEM(FREQUENCY) \
+       ITEM(CHANNELS) \
+       ITEM(DURATION) \
+       ITEM(SECONDS_TOTAL) \
+       ITEM(NUM_PLAYED) \
+       ITEM(LAST_PLAYED) \
+       ITEM(TECHINFO) \
+       ITEM(ARTIST) \
+       ITEM(TITLE) \
+       ITEM(YEAR) \
+       ITEM(ALBUM) \
+       ITEM(COMMENT) \
+       ITEM(AMPLIFICATION)
+
+/**
+ * Write a list of audio-file related status items with empty values.
+ *
+ * This is used by vss when currently no audio file is open.
+ */
+static char *empty_status_items(int parser_friendly)
+{
+       if (parser_friendly)
+               return make_message(
+                       #define ITEM(x) "0004 %02x:\n"
+                       EMPTY_STATUS_ITEMS
+                       #undef ITEM
+                       #define ITEM(x) , SI_ ## x
+                       EMPTY_STATUS_ITEMS
+                       #undef ITEM
+               );
+       return make_message(
+               #define ITEM(x) "%s:\n"
+               EMPTY_STATUS_ITEMS
+               #undef ITEM
+               #define ITEM(x) ,status_item_list[SI_ ## x]
+               EMPTY_STATUS_ITEMS
+               #undef ITEM
+       );
+}
+#undef EMPTY_STATUS_ITEMS
+
 /* stat */
-int com_stat(int fd, int argc, char * const * argv)
+int com_stat(struct rc4_context *rc4c, int argc, char * const * argv)
 {
-       int ret, num = 0;/* status will be printed that many
-                         * times. num <= 0 means: print forever
-                         */
+       int i, ret;
        struct misc_meta_data tmp, *nmmd = &tmp;
        char *s;
+       int32_t num = 0;
+       int parser_friendly = 0;
 
        para_sigaction(SIGUSR1, dummy);
 
-       if (argc > 2)
+       for (i = 1; i < argc; i++) {
+               const char *arg = argv[i];
+               if (arg[0] != '-')
+                       break;
+               if (!strcmp(arg, "--")) {
+                       i++;
+                       break;
+               }
+               if (!strncmp(arg, "-n=", 3)) {
+                       ret = para_atoi32(arg + 3, &num);
+                       if (ret < 0)
+                               return ret;
+                       continue;
+               }
+               if (!strcmp(arg, "-p")) {
+                       parser_friendly = 1;
+                       continue;
+               }
                return -E_COMMAND_SYNTAX;
-       if (argc > 1) {
-               ret = para_atoi32(argv[1], &num);
-               if (ret < 0)
-                       goto out;
        }
+       if (i != argc)
+               return -E_COMMAND_SYNTAX;
        for (;;) {
-
                mmd_dup(nmmd);
-               s = get_status(nmmd);
-               ret = send_buffer(fd, s);
+               s = get_status(nmmd, parser_friendly);
+               ret = rc4_send_buffer(rc4c, s);
                free(s);
                if (ret < 0)
                        goto out;
+               if (nmmd->vss_status_flags & VSS_NEXT) {
+                       static char *esi;
+                       if (!esi)
+                               esi = empty_status_items(parser_friendly);
+                       ret = rc4_send_buffer(rc4c, esi);
+                       if (ret < 0)
+                               goto out;
+               } else
+                       send_afs_status(rc4c, parser_friendly);
                ret = 1;
                if (num > 0 && !--num)
                        goto out;
@@ -333,14 +399,14 @@ out:
        return ret;
 }
 
-static int send_list_of_commands(int fd, struct server_command *cmd,
+static int send_list_of_commands(struct rc4_context *rc4c, struct server_command *cmd,
                const char *handler)
 {
        int ret, i;
 
        for (i = 1; cmd->name; cmd++, i++) {
                char *perms = cmd_perms_itohuman(cmd->perms);
-               ret = send_va_buffer(fd, "%s\t%s\t%s\t%s\n", cmd->name,
+               ret = rc4_send_va_buffer(rc4c, "%s\t%s\t%s\t%s\n", cmd->name,
                        handler,
                        perms,
                        cmd->description);
@@ -373,7 +439,7 @@ static struct server_command *get_cmd_ptr(const char *name, char **handler)
 }
 
 /* help */
-int com_help(int fd, int argc, char * const * argv)
+int com_help(struct rc4_context *rc4c, int argc, char * const * argv)
 {
        struct server_command *cmd;
        char *perms, *handler;
@@ -381,9 +447,9 @@ int com_help(int fd, int argc, char * const * argv)
 
        if (argc < 2) {
                /* no argument given, print list of commands */
-               if ((ret = send_list_of_commands(fd, server_cmds, "server")) < 0)
+               if ((ret = send_list_of_commands(rc4c, server_cmds, "server")) < 0)
                        return ret;
-               return send_list_of_commands(fd, afs_cmds, "afs");
+               return send_list_of_commands(rc4c, afs_cmds, "afs");
        }
        /* argument given for help */
        cmd = get_cmd_ptr(argv[1], &handler);
@@ -392,7 +458,7 @@ int com_help(int fd, int argc, char * const * argv)
                return -E_BAD_CMD;
        }
        perms = cmd_perms_itohuman(cmd->perms);
-       ret = send_va_buffer(fd,
+       ret = rc4_send_va_buffer(rc4c,
                "%s - %s\n\n"
                "handler: %s\n"
                "permissions: %s\n"
@@ -411,7 +477,7 @@ int com_help(int fd, int argc, char * const * argv)
 }
 
 /* hup */
-int com_hup(__a_unused int fd, int argc, __a_unused char * const * argv)
+int com_hup(__a_unused struct rc4_context *rc4c, int argc, __a_unused char * const * argv)
 {
        if (argc != 1)
                return -E_COMMAND_SYNTAX;
@@ -420,7 +486,7 @@ int com_hup(__a_unused int fd, int argc, __a_unused char * const * argv)
 }
 
 /* term */
-int com_term(__a_unused int fd, int argc, __a_unused char * const * argv)
+int com_term(__a_unused struct rc4_context *rc4c, int argc, __a_unused char * const * argv)
 {
        if (argc != 1)
                return -E_COMMAND_SYNTAX;
@@ -428,7 +494,7 @@ int com_term(__a_unused int fd, int argc, __a_unused char * const * argv)
        return 1;
 }
 
-int com_play(__a_unused int fd, int argc, __a_unused char * const * argv)
+int com_play(__a_unused struct rc4_context *rc4c, int argc, __a_unused char * const * argv)
 {
        if (argc != 1)
                return -E_COMMAND_SYNTAX;
@@ -441,7 +507,7 @@ int com_play(__a_unused int fd, int argc, __a_unused char * const * argv)
 }
 
 /* stop */
-int com_stop(__a_unused int fd, int argc, __a_unused char * const * argv)
+int com_stop(__a_unused struct rc4_context *rc4c, int argc, __a_unused char * const * argv)
 {
        if (argc != 1)
                return -E_COMMAND_SYNTAX;
@@ -454,7 +520,7 @@ int com_stop(__a_unused int fd, int argc, __a_unused char * const * argv)
 }
 
 /* pause */
-int com_pause(__a_unused int fd, int argc, __a_unused char * const * argv)
+int com_pause(__a_unused struct rc4_context *rc4c, int argc, __a_unused char * const * argv)
 {
        if (argc != 1)
                return -E_COMMAND_SYNTAX;
@@ -469,7 +535,7 @@ int com_pause(__a_unused int fd, int argc, __a_unused char * const * argv)
 }
 
 /* next */
-int com_next(__a_unused int fd, int argc, __a_unused char * const * argv)
+int com_next(__a_unused struct rc4_context *rc4c, int argc, __a_unused char * const * argv)
 {
        if (argc != 1)
                return -E_COMMAND_SYNTAX;
@@ -481,7 +547,7 @@ int com_next(__a_unused int fd, int argc, __a_unused char * const * argv)
 }
 
 /* nomore */
-int com_nomore(__a_unused int fd, int argc, __a_unused char * const * argv)
+int com_nomore(__a_unused struct rc4_context *rc4c, int argc, __a_unused char * const * argv)
 {
        if (argc != 1)
                return -E_COMMAND_SYNTAX;
@@ -493,7 +559,7 @@ int com_nomore(__a_unused int fd, int argc, __a_unused char * const * argv)
 }
 
 /* ff */
-int com_ff(__a_unused int fd, int argc, char * const * argv)
+int com_ff(__a_unused struct rc4_context *rc4c, int argc, char * const * argv)
 {
        long promille;
        int ret, backwards = 0;
@@ -532,7 +598,7 @@ out:
 }
 
 /* jmp */
-int com_jmp(__a_unused int fd, int argc, char * const * argv)
+int com_jmp(__a_unused struct rc4_context *rc4c, int argc, char * const * argv)
 {
        long unsigned int i;
        int ret;
@@ -586,32 +652,7 @@ static struct server_command *parse_cmd(const char *cmdstr)
        return get_cmd_ptr(buf, NULL);
 }
 
-static void init_rc4_keys(void)
-{
-       int i;
-
-       for (i = 0; i < 2 * RC4_KEY_LEN; i++)
-               rc4_buf[i] = para_random(256);
-       PARA_DEBUG_LOG("rc4 keys initialized (%u:%u)\n",
-               (unsigned char) rc4_buf[0],
-               (unsigned char) rc4_buf[RC4_KEY_LEN]);
-       RC4_set_key(&rc4_recv_key, RC4_KEY_LEN, rc4_buf);
-       RC4_set_key(&rc4_send_key, RC4_KEY_LEN, rc4_buf + RC4_KEY_LEN);
-}
-
-static void rc4_recv(unsigned long len, const unsigned char *indata,
-               unsigned char *outdata, __a_unused void *private_data)
-{
-       RC4(&rc4_recv_key, len, indata, outdata);
-}
-
-static void rc4_send(unsigned long len, const unsigned char *indata,
-               unsigned char *outdata, __a_unused void *private_data)
-{
-       RC4(&rc4_send_key, len, indata, outdata);
-}
-
-static int read_command(int fd, char **result)
+static int read_command(struct rc4_context *rc4c, char **result)
 {
        int ret;
        char buf[4096];
@@ -621,7 +662,7 @@ static int read_command(int fd, char **result)
                size_t numbytes;
                char *p;
 
-               ret = recv_buffer(fd, buf, sizeof(buf));
+               ret = rc4_recv_buffer(rc4c, buf, sizeof(buf));
                if (ret < 0)
                        goto out;
                if (!ret)
@@ -684,22 +725,22 @@ static void reset_signals(void)
  */
 __noreturn void handle_connect(int fd, const char *peername)
 {
-       int ret, argc, use_rc4 = 0;
+       int ret, argc;
        char buf[4096];
-       unsigned char crypt_buf[MAXLINE];
+       unsigned char rand_buf[CHALLENGE_SIZE + 2 * RC4_KEY_LEN];
+       unsigned char challenge_sha1[HASH_SIZE];
        struct user *u;
        struct server_command *cmd = NULL;
-       long unsigned challenge_nr, chall_response;
        char **argv = NULL;
        char *p, *command = NULL;
        size_t numbytes;
+       struct rc4_context rc4c = {.fd = fd};
 
        reset_signals();
        /* we need a blocking fd here as recv() might return EAGAIN otherwise. */
        ret = mark_fd_blocking(fd);
        if (ret < 0)
                goto err_out;
-       challenge_nr = random();
        /* send Welcome message */
        ret = send_va_buffer(fd, "This is para_server, version "
                PACKAGE_VERSION  ".\n" );
@@ -709,65 +750,69 @@ __noreturn void handle_connect(int fd, const char *peername)
        ret = recv_buffer(fd, buf, sizeof(buf));
        if (ret < 0)
                goto err_out;
-       if (ret <= 6) {
-               ret = -E_AUTH;
+       if (ret < 10) {
+               ret = -E_AUTH_REQUEST;
                goto err_out;
        }
        numbytes = ret;
-       ret = -E_AUTH;
-       if (strncmp(buf, "auth ", 5))
+       ret = -E_AUTH_REQUEST;
+       if (strncmp(buf, AUTH_REQUEST_MSG, strlen(AUTH_REQUEST_MSG)))
                goto err_out;
-
-       if (numbytes < 9 || strncmp(buf, "auth rc4 ", 9))
-               p = buf + 5; /* client version < 0.2.6 */
-       else {
-               p = buf + 9; /* client version >= 0.2.6 */
-               use_rc4 = 1;
-       }
-       PARA_DEBUG_LOG("received %s request for user %s\n",
-               use_rc4? "rc4" : "auth", p);
+       p = buf + strlen(AUTH_REQUEST_MSG);
+       PARA_DEBUG_LOG("received auth request for user %s\n", p);
        ret = -E_BAD_USER;
        u = lookup_user(p);
-       if (!u)
-               goto err_out;
-       ret = para_encrypt_challenge(u->rsa, challenge_nr, crypt_buf);
-       if (ret <= 0)
-               goto err_out;
-       numbytes = ret;
-       PARA_DEBUG_LOG("sending %zu byte challenge\n", numbytes);
-       /* We can't use send_buffer here since buf may contain null bytes */
-       ret = send_bin_buffer(fd,(char *) crypt_buf, numbytes);
+       if (u) {
+               get_random_bytes_or_die(rand_buf, sizeof(rand_buf));
+               ret = para_encrypt_buffer(u->rsa, rand_buf, sizeof(rand_buf),
+                       (unsigned char *)buf);
+               if (ret < 0)
+                       goto err_out;
+               numbytes = ret;
+       } else {
+               /*
+                * We don't want to reveal our user names, so we send a
+                * challenge to the client even if the user does not exist, and
+                * fail the authentication later.
+                */
+               numbytes = 256;
+               get_random_bytes_or_die((unsigned char *)buf, numbytes);
+       }
+       PARA_DEBUG_LOG("sending %u byte challenge + rc4 keys (%zu bytes)\n",
+               CHALLENGE_SIZE, numbytes);
+       ret = send_bin_buffer(fd, buf, numbytes);
        if (ret < 0)
                goto net_err;
-       /* recv decrypted number */
-       ret = recv_buffer(fd, buf, sizeof(buf));
+       /* recv challenge response */
+       ret = recv_bin_buffer(fd, buf, HASH_SIZE);
        if (ret < 0)
                goto net_err;
        numbytes = ret;
-       ret = -E_AUTH;
-       if (!numbytes)
+       PARA_DEBUG_LOG("received %d bytes challenge response\n", ret);
+       ret = -E_BAD_USER;
+       if (!u)
                goto net_err;
-       if (sscanf(buf, CHALLENGE_RESPONSE_MSG "%lu", &chall_response) < 1
-                       || chall_response != challenge_nr)
-               goto err_out;
-       /* auth successful, send 'Proceed' message */
-       PARA_INFO_LOG("good auth for %s (%lu)\n", u->name, challenge_nr);
-       sprintf(buf, "%s", PROCEED_MSG);
-       if (use_rc4) {
-               init_rc4_keys();
-               ret = para_encrypt_buffer(u->rsa, rc4_buf, 2 * RC4_KEY_LEN,
-                       (unsigned char *)buf + PROCEED_MSG_LEN + 1);
-               if (ret <= 0)
-                       goto err_out;
-               numbytes = ret + strlen(PROCEED_MSG) + 1;
-       } else
-               numbytes = strlen(buf);
-       ret = send_bin_buffer(fd, buf, numbytes);
+       /*
+        * The correct response is the sha1 of the first CHALLENGE_SIZE bytes
+        * of the random data.
+        */
+       ret = -E_BAD_AUTH;
+       if (numbytes != HASH_SIZE)
+               goto net_err;
+       sha1_hash((char *)rand_buf, CHALLENGE_SIZE, challenge_sha1);
+       if (memcmp(challenge_sha1, buf, HASH_SIZE))
+               goto net_err;
+       /* auth successful */
+       alarm(0);
+       PARA_INFO_LOG("good auth for %s\n", u->name);
+       /* init rc4 keys with the second part of the random buffer */
+       RC4_set_key(&rc4c.recv_key, RC4_KEY_LEN, rand_buf + CHALLENGE_SIZE);
+       RC4_set_key(&rc4c.send_key, RC4_KEY_LEN, rand_buf + CHALLENGE_SIZE
+               + RC4_KEY_LEN);
+       ret = rc4_send_buffer(&rc4c, PROCEED_MSG);
        if (ret < 0)
                goto net_err;
-       if (use_rc4)
-               enable_crypt(fd, rc4_recv, rc4_send, NULL);
-       ret = read_command(fd, &command);
+       ret = read_command(&rc4c, &command);
        if (ret == -E_COMMAND_SYNTAX)
                goto err_out;
        if (ret < 0)
@@ -781,23 +826,25 @@ __noreturn void handle_connect(int fd, const char *peername)
        if (ret < 0)
                goto err_out;
        /* valid command and sufficient perms */
-       alarm(0);
-       argc = split_args(command, &argv, "\n");
+       ret = create_argv(command, "\n", &argv);
+       if (ret < 0)
+               goto err_out;
+       argc = ret;
        PARA_NOTICE_LOG("calling com_%s() for %s@%s\n", cmd->name, u->name,
                        peername);
-       ret = cmd->handler(fd, argc, argv);
+       ret = cmd->handler(&rc4c, argc, argv);
+       free_argv(argv);
        mutex_lock(mmd_mutex);
        mmd->num_commands++;
        mutex_unlock(mmd_mutex);
        if (ret >= 0)
                goto out;
 err_out:
-       send_va_buffer(fd, "%s\n", para_strerror(-ret));
+       rc4_send_va_buffer(&rc4c, "%s\n", para_strerror(-ret));
 net_err:
        PARA_NOTICE_LOG("%s\n", para_strerror(-ret));
 out:
        free(command);
-       free(argv);
        mutex_lock(mmd_mutex);
        if (cmd && (cmd->perms & AFS_WRITE) && ret >= 0)
                mmd->events++;
diff --git a/command.h b/command.h
new file mode 100644 (file)
index 0000000..347dd81
--- /dev/null
+++ b/command.h
@@ -0,0 +1,19 @@
+/** \file command.h The structure of server and afs commands. */
+
+/**
+ * Defines one command of para_server.
+ */
+struct server_command {
+       /** The name of the command. */
+       const char *name;
+       /** Pointer to the function that handles the command. */
+       int (*handler)(struct rc4_context *, int, char * const * const);
+       /** The privileges a user must have to execute this command. */
+       unsigned int perms;
+       /** One-line description of the command. */
+       const char *description;
+       /** Summary of the command line options. */
+       const char *usage;
+       /** The long help text. */
+       const char *help;
+};
index 62ad966..f388b2c 100755 (executable)
@@ -26,6 +26,12 @@ read_header()
                AT:)
                        array_type="$value"
                        ;;
+               SI:)
+                       for i in $value; do
+                               system_includes="$system_includes
+#include <$i.h>"
+                       done
+                       ;;
                IN:)
                        for i in $value; do
                                includes="$includes
@@ -57,7 +63,6 @@ read_one_command()
        usage_txt=""
        help_txt=""
        perms_txt=""
-       line_handler=0
        template=0
        template_name=""
        template_prototype=""
@@ -84,9 +89,6 @@ read_one_command()
                D:)
                        desc_txt="$value"
                        ;;
-               L:)
-                       line_handler=1
-                       ;;
                U:)
                        usage_txt="$value"
                        ;;
@@ -198,13 +200,13 @@ dump_proto()
        echo '/**'
        echo " * $desc_txt"
        echo ' *'
-       echo ' * \param fd The file descriptor to send output to.'
-       if test $line_handler -eq 0; then
-               echo ' * \param argc The number of arguments.'
-               echo ' * \param argv The argument vector.'
+       if [[ "$system_includes" =~ openssl/rc4.h ]]; then
+               echo ' * \param rc4c The rc4 crypt context.'
        else
-               echo ' * \param cmdline The full command line.'
+               echo ' * \param fd The file descriptor to send output to.'
        fi
+       echo ' * \param argc The number of arguments.'
+       echo ' * \param argv The argument vector.'
        echo ' * '
        echo " * Usage: $usage_txt"
        echo ' * '
@@ -229,12 +231,7 @@ dump_array_member()
 {
        echo '{'
        echo ".name = \"$name_txt\","
-       if test $line_handler -eq 0; then
-               echo ".handler = com_$name_txt,"
-       else
-               echo ".handler = NULL,"
-               echo ".line_handler = com_$name_txt,"
-       fi
+       echo ".handler = com_$name_txt,"
        if test -n "$perms_txt"; then
                echo ".perms = $perms_txt,"
        fi
@@ -273,6 +270,7 @@ template_loop()
 com_c_file()
 {
        echo "/** \file $output_file.c $c_file_comment */"
+       echo "$system_includes"
        echo "$includes"
        echo "struct $array_type $array_name[] = {"
        while : ; do
index f853b63..7bad4c2 100644 (file)
@@ -10,6 +10,8 @@
  * Uses ideas of AudioCompress, (C) 2002-2004  M. Hari Nezumi <magenta@trikuare.cx>
  */
 
+#include <regex.h>
+
 #include "para.h"
 #include "compress_filter.cmdline.h"
 #include "list.h"
@@ -22,8 +24,6 @@
 /** The size of the output data buffer. */
 #define COMPRESS_CHUNK_SIZE 40960
 
-extern char *stat_item_values[NUM_STAT_ITEMS];
-
 /** Data specific to the compress filter. */
 struct private_compress_data {
        /** The current multiplier. */
@@ -53,7 +53,7 @@ static ssize_t compress(char *inbuf, size_t inbuf_len, struct filter_node *fn)
                /* be careful in that heat, my dear */
                int sample = *ip++, adjusted_sample = (PARA_ABS(sample) *
                        pcd->current_gain) >> gain_shift;
-               if (unlikely(adjusted_sample > 32767)) { /* clip */
+               if (adjusted_sample > 32767) { /* clip */
                        PARA_NOTICE_LOG("clip: sample: %d, adjusted sample: %d\n",
                                sample, adjusted_sample);
                        adjusted_sample = 32767;
@@ -63,7 +63,7 @@ static ssize_t compress(char *inbuf, size_t inbuf_len, struct filter_node *fn)
                } else
                        pcd->peak = PARA_MAX(pcd->peak, adjusted_sample);
                *op++ = sample >= 0? adjusted_sample : -adjusted_sample;
-               if (likely(++pcd->num_samples & mask))
+               if (++pcd->num_samples & mask)
                        continue;
 //             PARA_DEBUG_LOG("gain: %u, peak: %u\n", pcd->current_gain,
 //                     pcd->peak);
index 74a3c74..da9c5db 100644 (file)
@@ -78,17 +78,26 @@ AC_CHECK_FUNCS([atexit dup2 memchr memmove memset \
        strncasecmp strrchr strspn alarm mkdir rmdir], [],
        [AC_MSG_ERROR([function not found, cannot live without it])])
 
+cmdline_dir="cmdline"
+AC_SUBST(cmdline_dir)
+AC_DEFUN([add_cmdline],[$(for i in $@; do printf "${i}.cmdline "; done)])
+
+
 all_errlist_objs="server mp3_afh afh_common vss command net string signal time
 daemon stat crypt http_send close_on_fork ipc acl afh fade amp_filter
-dccp_send fd user_list chunk_queue afs osl aft mood score attribute blob ringbuffer
-playlist sha1 rbtree sched audiod grab_client filter_common wav_filter compress_filter
+dccp_send fd user_list chunk_queue afs aft mood score attribute blob ringbuffer
+playlist sha1 sched audiod grab_client filter_common wav_filter compress_filter
 http_recv dccp_recv recv_common write_common file_write audiod_command
-client_common recv stdout filter stdin audioc write client fsck exec send_common ggo
-udp_recv udp_send color fec fecdec_filter prebuffer_filter"
+client_common recv stdout filter stdin audioc write client exec send_common ggo
+udp_recv udp_send color fec fecdec_filter prebuffer_filter mm
+server_command_list afs_command_list audiod_command_list bitstream imdct wma_afh
+wma_common wmadec_filter
+"
 
-all_executables="server recv filter audioc write client fsck afh"
+all_executables="server recv filter audioc write client afh"
+
+recv_cmdline_objs="add_cmdline(recv http_recv dccp_recv udp_recv)"
 
-recv_cmdline_objs="recv.cmdline http_recv.cmdline dccp_recv.cmdline udp_recv.cmdline"
 recv_errlist_objs="http_recv recv_common recv time string net dccp_recv
        fd sched stdout ggo udp_recv fec"
 recv_ldflags=""
@@ -96,64 +105,91 @@ recv_ldflags=""
 receivers=" http dccp udp"
 senders=" http dccp udp"
 
-filter_cmdline_objs="filter.cmdline compress_filter.cmdline amp_filter.cmdline
-       prebuffer_filter.cmdline"
+filter_cmdline_objs="add_cmdline(filter compress_filter amp_filter prebuffer_filter)"
 filter_errlist_objs="filter_common wav_filter compress_filter filter string
        stdin stdout sched fd amp_filter ggo fecdec_filter fec
-       prebuffer_filter time"
-filter_ldflags=""
-filters=" compress wav amp fecdec prebuffer"
+       prebuffer_filter time bitstream imdct wma_common wmadec_filter"
+filter_ldflags="-lm"
+filters=" compress wav amp fecdec wmadec prebuffer"
 
-audioc_cmdline_objs="audioc.cmdline"
+audioc_cmdline_objs="add_cmdline(audioc)"
 audioc_errlist_objs="audioc string net fd"
 audioc_ldflags=""
 
-audiod_cmdline_objs="audiod.cmdline grab_client.cmdline compress_filter.cmdline
-       http_recv.cmdline dccp_recv.cmdline file_write.cmdline client.cmdline
-       audiod_command_list amp_filter.cmdline udp_recv.cmdline
-       prebuffer_filter.cmdline"
+audiod_cmdline_objs="add_cmdline(audiod compress_filter http_recv dccp_recv file_write client amp_filter udp_recv prebuffer_filter)"
 audiod_errlist_objs="audiod signal string daemon stat net
        time grab_client filter_common wav_filter compress_filter amp_filter http_recv dccp_recv
        recv_common fd sched write_common file_write audiod_command crypt fecdec_filter
-       client_common ggo udp_recv color fec prebuffer_filter"
+       client_common ggo udp_recv color fec prebuffer_filter sha1 audiod_command_list
+       bitstream imdct wma_common wmadec_filter"
 audiod_ldflags=""
-audiod_audio_formats=""
+audiod_audio_formats="wma"
 
-afh_cmdline_objs="afh.cmdline"
-afh_errlist_objs="afh string fd mp3_afh afh_common time"
+afh_cmdline_objs="add_cmdline(afh)"
+afh_errlist_objs="afh string fd mp3_afh afh_common time wma_afh wma_common"
 afh_ldflags=""
 
-server_cmdline_objs="server.cmdline server_command_list afs_command_list"
+server_cmdline_objs="add_cmdline(server)"
 server_errlist_objs="server afh_common mp3_afh vss command net string signal
-       time daemon stat crypt http_send close_on_fork
-       ipc dccp_send fd user_list chunk_queue afs osl aft mood score attribute
-       blob playlist sha1 rbtree sched acl send_common udp_send color fec"
-server_ldflags=""
+       time daemon crypt http_send close_on_fork mm
+       ipc dccp_send fd user_list chunk_queue afs aft mood score attribute
+       blob playlist sha1 sched acl send_common udp_send color fec
+       server_command_list afs_command_list wma_afh wma_common"
+server_ldflags="-losl"
 server_audio_formats=" mp3"
 
-write_cmdline_objs="write.cmdline file_write.cmdline"
+write_cmdline_objs="add_cmdline(write file_write)"
 write_errlist_objs="write write_common file_write time fd string sched stdin ggo"
 write_ldflags=""
 writers=" file"
 default_writer="FILE_WRITE"
 
-client_cmdline_objs="client.cmdline"
-client_errlist_objs="client net string crypt fd sched stdin stdout client_common"
+client_cmdline_objs="add_cmdline(client)"
+client_errlist_objs="client net string crypt fd sched stdin stdout
+       client_common sha1"
 client_ldflags=""
 
-fsck_cmdline_objs="fsck.cmdline"
-fsck_errlist_objs="osl rbtree fsck string sha1 fd"
-
-gui_cmdline_objs="gui.cmdline"
+gui_cmdline_objs="add_cmdline(gui)"
 gui_errlist_objs="exec signal string stat ringbuffer fd"
 gui_other_objs="gui gui_theme"
 gui_objs="$gui_cmdline_objs $gui_errlist_objs $gui_other_objs"
 
-fade_cmdline_objs="fade.cmdline"
+fade_cmdline_objs="add_cmdline(fade)"
 fade_errlist_objs="fade exec string fd"
 
 
+########################################################################### osl
+have_osl=yes
+OLD_CPPFLAGS="$CPPFLAGS"
+OLD_LD_FLAGS="$LDFLAGS"
+OLD_LIBS="$LIBS"
+AC_ARG_WITH(osl_headers, [AC_HELP_STRING(--with-osl-headers=dir,
+       [look for osl.h also in dir])])
+if test -n "$with_osl_headers"; then
+       osl_cppflags="-I$with_osl_headers"
+       CPPFLAGS="$CPPFLAGS $osl_cppflags"
+fi
+AC_ARG_WITH(osl_libs, [AC_HELP_STRING(--with-osl-libs=dir,
+       [look for libosl also in dir])])
+if test -n "$with_osl_libs"; then
+       osl_libs="-L$with_osl_libs"
+       LDFLAGS="$LDFLAGS $osl_libs"
+fi
 
+AC_CHECK_HEADER(osl.h, [], have_osl=no)
+AC_CHECK_LIB([osl], [osl_open_table], [], have_osl=no)
+if test "$have_osl" = "no"; then
+       AC_MSG_ERROR([libosl not found, download it at
+       http://systemlinux.org/~maan/osl
+or execute
+       git clone git://git.tuebingen.mpg.de/osl
+       ])
+fi
+AC_SUBST(osl_cppflags)
+server_ldflags="$server_ldflags -L$with_osl_libs"
+CPPFLAGS="$OLD_CPPFLAGS"
+LDFLAGS="$OLD_LDFLAGS"
+LIBS="$OLD_LIBS"
 ########################################################################### ssl
 dnl @synopsis CHECK_SSL
 dnl
@@ -193,10 +229,9 @@ AC_ARG_ENABLE(ssldir, [AS_HELP_STRING(--enable-ssldir=path,
        [Search for openssl also in path.])])
 if test "$enable_ssldir" = "yes"; then enable_ssldir=""; fi
 CHECK_SSL($enable_ssldir)
-server_ldflags="$srver_ldflags $SSL_LDFLAGS $SSL_LIBS"
+server_ldflags="$server_ldflags $SSL_LDFLAGS $SSL_LIBS"
 client_ldflags="$client_ldflags $SSL_LDFLAGS $SSL_LIBS"
 audiod_ldflags="$audiod_ldflags $SSL_LDFLAGS $SSL_LIBS"
-fsck_ldflags="$fsck_ldflags $SSL_LDFLAGS $SSL_LIBS"
 
 ########################################################################### libsocket
 AC_CHECK_LIB([c], [socket],
@@ -347,15 +382,15 @@ if test "$have_ogg" = "yes"; then
        audiod_ldflags="$audiod_ldflags $oggvorbis_libs -lvorbis -lvorbisfile"
        afh_ldflags="$afh_ldflags $oggvorbis_libs -logg -lvorbis -lvorbisfile"
 
-       filter_cmdline_objs="$filter_cmdline_objs oggdec_filter.cmdline"
-       audiod_cmdline_objs="$audiod_cmdline_objs oggdec_filter.cmdline"
+       filter_cmdline_objs="$filter_cmdline_objs add_cmdline(oggdec_filter)"
+       audiod_cmdline_objs="$audiod_cmdline_objs add_cmdline(oggdec_filter)"
 
        server_errlist_objs="$server_errlist_objs ogg_afh"
        filter_errlist_objs="$filter_errlist_objs oggdec_filter"
        audiod_errlist_objs="$audiod_errlist_objs oggdec_filter"
        afh_errlist_objs="$afh_errlist_objs ogg_afh"
 
-       audiod_audio_formats="ogg"
+       audiod_audio_formats="$audiod_audio_formats ogg"
        server_audio_formats="$server_audio_formats ogg"
        AC_SUBST(oggvorbis_cppflags)
        AC_SUBST(oggvorbis_libs)
@@ -432,8 +467,8 @@ AC_CHECK_LIB([mad], [mad_stream_init], [], [
 ])
 if test "$have_mad" = "yes"; then
        AC_DEFINE(HAVE_MAD, 1, define to 1 if you want to build the mp3dec filter)
-       filter_cmdline_objs="$filter_cmdline_objs mp3dec_filter.cmdline"
-       audiod_cmdline_objs="$audiod_cmdline_objs mp3dec_filter.cmdline"
+       filter_cmdline_objs="$filter_cmdline_objs add_cmdline(mp3dec_filter)"
+       audiod_cmdline_objs="$audiod_cmdline_objs add_cmdline(mp3dec_filter)"
        all_errlist_objs="$all_errlist_objs mp3dec_filter"
        filter_errlist_objs="$filter_errlist_objs mp3dec_filter"
        audiod_errlist_objs="$audiod_errlist_objs mp3dec_filter"
@@ -483,10 +518,10 @@ AC_CHECK_HEADER(sys/soundcard.h, [
        all_executables="$all_executables fade"
        all_errlist_objs="$all_errlist_objs oss_write"
        audiod_errlist_objs="$audiod_errlist_objs oss_write"
-       audiod_cmdline_objs="$audiod_cmdline_objs oss_write.cmdline"
+       audiod_cmdline_objs="$audiod_cmdline_objs add_cmdline(oss_write)"
 
        write_errlist_objs="$write_errlist_objs oss_write"
-       write_cmdline_objs="$write_cmdline_objs oss_write.cmdline"
+       write_cmdline_objs="$write_cmdline_objs add_cmdline(oss_write)"
        writers="$writers oss"
        default_writer="OSS_WRITE"
        AC_CHECK_LIB(ossaudio, _oss_ioctl, [
@@ -533,11 +568,11 @@ fi
 if test "$have_alsa" = "yes"; then
        all_errlist_objs="$all_errlist_objs alsa_write"
        audiod_errlist_objs="$audiod_errlist_objs alsa_write"
-       audiod_cmdline_objs="$audiod_cmdline_objs alsa_write.cmdline"
+       audiod_cmdline_objs="$audiod_cmdline_objs add_cmdline(alsa_write)"
        audiod_ldflags="$audiod_ldflags -lasound"
 
        write_errlist_objs="$write_errlist_objs alsa_write"
-       write_cmdline_objs="$write_cmdline_objs alsa_write.cmdline"
+       write_cmdline_objs="$write_cmdline_objs add_cmdline(alsa_write)"
        write_ldflags="$write_ldflags -lasound"
        writers="$writers alsa"
        default_writer="ALSA_WRITE"
@@ -613,11 +648,12 @@ AC_DEFINE_UNQUOTED(DEFINE_ERRLIST_OBJECT_ENUM,
 ################################################################## status items
 
 status_items="basename status num_played mtime bitrate frequency file_size
-status_flags format score audio_file_info taginfo1 taginfo2 afs_mode
+status_flags format score techinfo afs_mode
 attributes_txt decoder_flags audiod_status play_time attributes_bitmap
 offset seconds_total stream_start current_time audiod_uptime image_id
 lyrics_id duration directory lyrics_name image_name path hash channels
-last_played num_chunks chunk_time amplification"
+last_played num_chunks chunk_time amplification artist title year album
+comment"
 
 # $1: prefix, $2: items
 AC_DEFUN([make_enum_items], [$(
@@ -649,7 +685,6 @@ audiod_objs="$audiod_cmdline_objs $audiod_errlist_objs"
 server_objs="$server_cmdline_objs $server_errlist_objs"
 write_objs="$write_cmdline_objs $write_errlist_objs"
 client_objs="$client_cmdline_objs $client_errlist_objs"
-fsck_objs="$fsck_cmdline_objs $fsck_errlist_objs"
 audioc_objs="$audioc_cmdline_objs $audioc_errlist_objs"
 afh_objs="$afh_cmdline_objs $afh_errlist_objs"
 fade_objs="$fade_cmdline_objs $fade_errlist_objs"
@@ -689,11 +724,6 @@ AC_SUBST(client_ldflags, $client_ldflags)
 AC_DEFINE_UNQUOTED(INIT_CLIENT_ERRLISTS,
        objlist_to_errlist($client_errlist_objs), errors used by para_client)
 
-AC_SUBST(fsck_objs, add_dot_o($fsck_objs))
-AC_SUBST(fsck_ldflags, $fsck_ldflags)
-AC_DEFINE_UNQUOTED(INIT_FSCK_ERRLISTS,
-       objlist_to_errlist($fsck_errlist_objs), errors used by para_fsck)
-
 AC_SUBST(audioc_objs, add_dot_o($audioc_objs))
 AC_SUBST(audioc_ldflags, $audioc_ldflags)
 AC_DEFINE_UNQUOTED(INIT_AUDIOC_ERRLISTS,
@@ -735,8 +765,6 @@ names="$(for i in $audiod_audio_formats; do printf \"$i\",' ' ; done)"
 AC_DEFINE_UNQUOTED(AUDIOD_AUDIO_FORMAT_ARRAY, $names, array of audio formats supported by audiod)
 
 AC_OUTPUT
-AC_MSG_NOTICE([creating Makefile.deps])
-gcc -MM -MG $faad_cppflags $mad_cppflags $oggvorbis_cppflags *.c > Makefile.deps
 AC_MSG_NOTICE([
 paraslash configuration:
 ~~~~~~~~~~~~~~~~~~~~~~~~
diff --git a/convert_0.2-0.3.sh b/convert_0.2-0.3.sh
deleted file mode 100755 (executable)
index 24c937b..0000000
+++ /dev/null
@@ -1,186 +0,0 @@
-#!/usr/bin/env bash
-
-#-------------------------------------------------------------------------------
-## Script to convert the database of paraslash 0.2.x to version 0.3.x.
-##
-## Assumptions:
-##     - para_server 0.2.x is running and the mysql selector is active
-##     - para_server 0.3.x is running on another port
-##     - The database of paraslash 0.3.x has been initialized (i.e.
-##       para_client init has successfully been executed)
-##     - All audio files in the mysql database of paraslash 0.2.x. have
-##       already been added to the 0.3.x database (execute para_client add
-##       /my/audio/file/dir to do that)
-##
-## The script converts the attribute table, the set attributes for each audio
-## file, the image table and all image ids, and finally the lastplayed and the
-## numplayed data.
-##
-## However, it  does not convert the paraslash stream definitions from 0.2.x to