Upload 181 files

AUTHORS

@@ -0,0 +1,21 @@
+Bastien Nocera
+Bryan Forbes
+Christophe Fergeau
+Geoff Paul
+Ingmar Vanhassel
+John Maguire
+Jonathan Beck
+Joshua Hill
+Julien Lavergne
+Martin Aumueller
+Martin Szulecki
+Marty Rosenberg
+Matt Colyer
+Nikias Bassen
+Patrick Walton
+Paul Sladen
+Peter Hoepfner
+Petr Uzel
+Todd Zullinger
+Zach C
+Zoltan Balaton

COPYING

@@ -0,0 +1,340 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, 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 or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+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.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, 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) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+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 Program, 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 Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, 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 executable.  However, as a
+special exception, the source code 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.
+
+If distribution of executable or 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 counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program 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.
+
+  5. 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 Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. 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 Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program 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 Program.
+
+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.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program 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.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of 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 Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
+

COPYING.LESSER

@@ -0,0 +1,502 @@
+		  GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[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.
+
+  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.
+
+		  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.
+
+  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.
+
+  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.
+
+  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.
+
+  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.
+
+  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.
+
+  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
+
+           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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  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!

Makefile.am

@@ -0,0 +1,21 @@
+AUTOMAKE_OPTIONS = foreign
+ACLOCAL_AMFLAGS = -I m4
+SUBDIRS = 3rd_party common src include $(CYTHON_SUB) tools docs
+
+EXTRA_DIST = \
+	README.md \
+	git-version-gen
+
+dist-hook:
+	@if ! git diff --quiet; then echo "Uncommitted changes present; not releasing"; exit 1; fi
+	echo $(VERSION) > $(distdir)/.tarball-version
+
+docs/html: $(top_builddir)/doxygen.cfg $(top_srcdir)/src/*.c $(top_srcdir)/src/*.h $(top_srcdir)/include/libimobiledevice/*.h
+	rm -rf docs/html
+	doxygen doxygen.cfg
+
+docs: doxygen.cfg docs/html
+
+indent:
+	indent -kr -ut -ts4 -l120 src/*.c src/*.h
+

NEWS

@@ -0,0 +1,602 @@
+Version 1.4.0
+~~~~~~~~~~~~~
+
+* Development release
+  - From now on, releases will be made more frequently
+* Changes:
+  - Add support for MbedTLS
+  - Add Reverse Proxy implementation
+  - Add support for wireless pairing (AppleTV)
+  - Embed 3rd party libraries for ed25519 and SRP6a
+  - Fixes in idevicedebug
+  - idevicecrashreport: Allow filtering crash reports by filename
+  - Add idevicedevmodectl tool
+  - Fixes for idevicebackup2
+  - Add property_list_client_get_service_client() and service_get_connection() functions
+  - Add idevicebtlogger
+  - Add new idevice_events_subscribe/unsubscribe API
+  - Move LIBIMOBILEDEVICE_API to public headers
+  - Add afc_strerror function
+  - Add libimobiledevice_version() function
+  - Use libimobiledevice-glue's SHA1 implementation
+  - Add support for iOS 17+ Personalized Developer Disk image mounting
+  - Fix compilation on MSVC
+  - Add idevice_strerror() to interface
+  - Add new idevice_get_device_version() to interface
+  - Add os_trace_relay service implementation
+  - Fixes for idevicesyslog
+  - afc: Add afc_get_file_info_plist and afc_get_device_info_plist functions
+  ... and several other internal changes
+
+
+Version 1.3.0
+~~~~~~~~~~~~~
+
+* Development release "Let's get the party started."
+* Changes:
+  - Fix Python 3 support
+  - Add more lockdown error codes
+  - Add new lockdownd_pair_with_options() function
+  - Fix GnuTLS support with iOS 10
+  - Make sure sockets only listen locally due to security reasons
+  - Plug various memory leaks
+  - Fix SSL version negotiation for newer versions of OpenSSL
+  - Optimize lockdown pair record handling
+  - Return proper error code when a lockdown pair record is missing
+  - Fix building with MingGW
+  - Store application information in Info.plist using idevicebackup2
+  - Fix application backup handling to allow the device to restore applications
+    that were installed using idevicebackup2
+  - Make idevicebackup2 reboot after restore the default to allow the device to
+    migrate data correctly and thus improve the restored device data state
+  - Improve console frontend information output in idevicebackup2
+  - Extend ideviceprovision tool to allow retrieving and removing all
+    provisioning profiles
+  - Fix parsing large provisioning profile using ideviceprovision
+  - Fix receiving large property lists in property list service
+  - Propagate lower level errors to callers instead of returning
+    IDEVICE_E_UNKNOWN_ERROR
+  - API: Add IDEVICE_DEVICE_PAIRED event type
+  - Detect screenshot format to support png, tiff and dat formats using
+    idevicescreenshot tool
+  - API: Add mobileactivation service implementation
+  - Wait for passcode entry if required using idevicesyslog
+  - Add HDMI option to diagnostics command for idevicediagnostics
+  - Fix IORegistry command for iOS 11+ devices in idevicediagnostics
+  - Remove 40-digit character limit for UDID in tools to support newer devices
+  - Fix broken validate command in idevicepair with iOS 11+
+  - Fix OpenSSL version checks for configure target when using LibreSSL
+  - Migrate latest improved common code from libusbmuxd
+  - Convert README file to markdown format
+  - Fix idevicecrashreport tool to work with iOS 13+
+  - Fix various errors in SSL communication logic
+  - API: Add preboard service implementation
+  - Output hint to user to enter passcode when changing password using
+    idevicebackup2
+  - Cython: Fix and improve debugserver and diagnostics service bindings
+  - API: Add WiFi device support via new idevice_new_with_options() function
+  - API: Add idevice_get_device_list_extended() to also list network devices
+  - API: Add lockdown_strerror() helper to get error representation as string
+  - Add network device support to idevicesyslog and ideviceinfo tools
+  - Make debug output consistently output to stderr
+  - Add new idevicesetlocation tool (requires mounted developer image)
+  - Add option to exit if device disconnects in idevicesyslog
+  - API: Add syslog_relay_start_capture_raw() for raw syslog capture
+  - Add color output and process filter support to idevicesyslog
+  - API: Add companion_proxy service implementation
+  - Bump dependency to libusbmuxd 2.0.2
+  - Bump dependency to libplist 2.2.0
+  - Improve error handling and reporting in library and tools
+  - Fix various memory leaks in library and tools
+  - Add "--network" and "--version" options to all tools
+  - Fix socket_connect_addr() not connecting to network devices using IPv6
+    in some cases.
+  - Improve IPv6 "scope id" detection to fix connecting to network devices with
+    link-local adresses.
+  - Update man pages
+  - Fix various inconsistent declarations in public headers
+  - Allow OpenSSL >= 1.1.0 to use older/disallowed TLS versions fixing issues
+    where pairing records were getting removed repeatingly
+  - Fixed memory leaks
+  - Cython: Rewrite version detection logic in configure.ac
+  - Rename "--enable-debug-code" configure option to "--enable-debug"
+  - Improve README.md with project description, installation, contributing and
+    usage sections
+  - Rename library and all related files by adding an API version resulting
+    in "libimobiledevice-1.0"
+  - Bump soname version
+* API is UNSTABLE
+
+Version 1.2.0
+~~~~~~~~~~~~~
+
+* Stable release "It took you so long baby!"
+* Changes:
+  - Require autoconf 2.64 or later
+  - Remove dev tools, will return either as proper tools or website examples
+  - Refactor installation proxy service implementation and normalize code
+  - API: Added instproxy_lookup() to efficiently lookup app information
+  - API: Added instproxy_check_capabilities_match() to check device capabilities
+  - API: Added various instproxy command and status plist getters
+  - API: Make debugserver_client_set_ack_mode() public
+  - Fix handling of clients reconnecting in idevicedebugserverproxy which
+    previously didn't work properly
+  - Flush stdout for every line in idevicesyslog
+  - Fix shutdown of idevicedebugserverproxy tool which could hang
+  - Notify user when erroneously using idevicebackup with iOS 4 or later
+  - Enable build of idevicecrashreport on WIN32
+  - Fix thread handle leaks on WIN32 adding thread_new and thread_free
+  - cython: Add receive/receive_timeout methods for iDeviceConnection to
+    receive raw data from a connection
+  - cython: Add new FILE_RELAY_E_PERMISSION_DENIED(-6) error
+  - API: Refactor lockdown service internal error checking and add a bunch of
+    new native errors
+  - Convert int16_t macro error types into enum within common module, too
+  - Add new "idevicenotificationproxy" tool to post or observe notifications
+  - Fix overlong blocking in np_client_free()
+  - Improve maintainability and Requires of pkg-config file
+  - API: Add new LOCKDOWN_E_SERVICE_LIMIT error to detect service limit states
+  - API: Remove const argv requirement for debugserver_command_new
+  - cython: Add get_path_for_bundle_identifier() method to
+    InstallationProxyClient
+  - cython: Add DebugServerClient class to communicate with debugserver
+  - Comply to strict function prototypes by using (void) instead of just ()
+  - Fix notification proxy shutdown process which was incorrectly implemented
+  - Fix linking problems on OS X
+  - Fix missing debug output which broke with the last release
+  - Unify and improve various debug messages
+  - Fix re-pairing if pairing with existing pair record failed initially
+  - Skip printing long plist (16kb+) files to prevent excessive debug output
+  - Move a few common helpers from backup tools to common utility helper code
+  - Remove incorrect flags from afc_file_open() documentation
+  - Fix various memory leaks
+
+Version 1.1.7
+~~~~~~~~~~~~~
+
+* Development release "Cleaning up the yard."
+* Changes:
+  - Fix broken app args, environment handling and memory leaks in idevicedebug
+  - Make all tools print an error if lockdown connection fails
+  - Convert int16_t macro error types into enum for better type-checking and
+    for various debugging benefits
+  - Avoid exporting non-public symbols for better ABI stability
+  - Fix failing backup process for devices having a passcode set and entering
+    lock state during the process in idevicebackup2
+  - API: Added lockdownd_start_service_with_escrow_bag()
+  - API: Added afc_remove_path_and_contents() for recursive deletion
+  - Fix last memory leak with OpenSSL through proper library deinitialization
+  - Add new idevicedebug tool to interact with debugserver on a device
+  - API: Add debugserver service implementation
+  - Handle new PermissionDenied error of file_relay due new security in iOS 8+
+  - Fix retry loop problem when device requests 0 files in idevicebackup2
+  - Add trust dialog related error codes to Cython bindings
+  - Fix various memory leaks in AFC implementation
+  - Fix disk image upload with latest iOS 8 in ideviceimagemounter
+  - Add new "dump" command to print information about a provisioning profile in
+    ideviceprovision
+  - Refactor plist print helper code and move it into common module for better
+    reuse accross the tools
+  - Do not crash if retrieving the system buid fails
+  - API: Make generic "propery_list_service_client" public
+  - Moved doc comments from private to public headers
+  - Fix possible segfault when using lockdownd_get_value() due to always
+    returning success
+  - Do not read files entirely into memory during restore in idevicebackup
+  - Plug a few memory leaks and fix invalid password check in idevicebackup2
+  - Add support for file sizes > 4GB on Win32 in idevicebackup2
+  - Fix declaration for DllMain on Win32
+  - Silence various compiler warnings
+  - Fix assert within pairing logic
+* API is UNSTABLE
+
+Version 1.1.6
+~~~~~~~~~~~~~
+
+* Development release "Way too overdue."
+* Changes:
+  - Remove segmentation code from afc_file_read() to provide raw interface and
+    more control to API consumer I/O logic
+  - Implement global thread safe library initialization, especially to control
+    SSL backend lifecycle
+  - Major refactoring of pair record code and logic to use new usbmuxd pair
+    record management interface
+  - Replace user level with system wide pair record file handling
+  - Bump dependency to libplist 1.11 and remove use of "plist_dict_insert_item"
+  - Bump dependency to libusbmuxd 1.0.9
+  - Finish pair record and trust dialog handling for iOS 7+
+  - Improve AFC write performance and memory usage
+  - Add support for custom output filename to idevicescreenshot
+  - Fix detection and compilation for Python 3.x
+  - API: Added file_relay_request_sources_timeout()
+  - Fix broken HouseArrestClient class in cython bindings
+  - Add new idevicecrashreport tool to retrieve crash reports and logs from a
+    device
+  - Prevent "Failed to restart/shutdown device" messages in idevicediagnostics
+  - Link against ws2_32.dll on Win32
+  - Add support for iOS 7+ disk image mounting to ideviceimagemounter
+  - Add new idevicename tool to get or set the device name
+  - Allow unbacking of encrypted backups with a given password to idevicebackup2
+  - Remove sending "Goodbye" request on lockdown
+  - Add support for newer PLIST_REAL based time type to idevicedate
+  - Add note about setting time not working on iOS 6+ to idevicedate
+  - Handle partial SSL reads correctly now to prevent random crashes
+  - Fix duplicated output in ideviceinfo output
+  - Remove a bunch of dead code
+  - Fix deprecated OpenSSL "RSA_generate_key" with "RSA_generate_key_ex" which
+    is available since OpenSSL 0.9.8 (July 2005)
+  - Improve debug messages
+  - Enforce "-fsigned-char" to fix issues on embedded platforms
+  - Fix compilation with Clang/LLVM
+  - Avoid versioning for shared library on Win32
+  - Add experimental support for controlling cloud backup mode to idevicebackup2
+  - Save EscrowBag when starting service for automatic unlocking in pair record
+  - Remove pairing logic which is obsoleted by usbmuxd's preflight handler
+  - Fix shutdown of SSL connection to be correct and no longer generate errors
+    on device
+  - Add support for GnuTLS 3.x and fix broken GnuTLS backend
+  - Add extensions to generated certificates to match native ones
+  - Add "systembuid" command to idevicepair
+  - Allow starting service without the need for a running SSL session
+  - Refactor more code into common module
+  - Add option to filerelaytest to specify a source to request
+  - Fix support for partial messages in webinspector implementation
+  - Implement support for encrypted backups in idevicebackup2
+  - API: Export SSL control functions for idevice_connection_t
+  - API: Make generic service client public to allow external service
+    implementations
+  - Implement *_start_service() helper for easier creation of service clients
+  - Add public *_SERVICE_NAME defines for each service
+  - Fix a great bunch of memory leaks after intensive valgrind session
+  - Security: Fix insecure use of the /tmp directory (CVE-2013-2142)
+  - A bunch of memory leak fixes
+  - Python: Various fixes and support for "with" statement for AfcFile class
+  - Python: Add Afc2Client class to allow jailbroken filesystem access
+  - Fix linking issue with newer libtool as reported for Ubuntu
+  - Fix stuck thread in idevicesyslog which broke quit from within the tool
+  - Add syslog_relay service implementation and use it in idevicesyslog
+  - API: Add instproxy_client_get_path_for_bundle_identifier() helper
+  - API: Add afc_dictionary_free() helper
+  - Move thread, socket, debug and userpref code to "common" source directory
+    in order to improve code reuse
+  - Fix broken byte order detection in configure.ac which could lead to broken
+    AFC protocol communication on platforms without endian.h (Raspberry PI)
+* API is UNSTABLE
+
+Version 1.1.5
+~~~~~~~~~~~~~
+
+* Development release
+* Changes:
+  - Implement automatic reconnecting in idevicesyslog
+  - Refactor all services to use new base service
+  - Add new generic service_client_factory_start_service() helper
+  - Implement a base service that all services inherit from
+  - API: Refactor use of "port numbers" into a "service descriptor" which is
+    a needed change as all services must now transparently support SSL.
+    Fortunately, only minor changes are needed to migrate your code properly.
+  - Add experimental ideviceheartbeat to allow service checkin over the network
+  - Add heartbeat service implementation to keep alive network connections
+  - Add webinspector service implementation for WebKit remote debugging
+  - Fix idevicebackup2 failing due to integer overflow in free disk space 
+    calculation on 32 bit architectures and large disk capacities
+  - Add support for encrypted and password protected backups to idevicebackup2
+  - Fix major "too long filename received" bug in idevicebackup2
+  - Various fixes for proper and tested WIN32 support including MinGW building
+  - Fix various crashers and improve quality of idevicebackup2 tool
+  - Add endianness helpers for systems lacking support
+  - Fix idevicedate to work on iOS 6+
+  - Add idevicediagnostics tool
+  - Add diagnostics_relay service implementation
+  - Add idevicedebugserverproxy tool for remote lldb debugging
+  - Add ideviceprovision tool
+  - Add misagent service implementation to manage provisioning profiles
+  - Fix crash if $HOME is empty or not defined
+  - Fix non-ASCII characters being stripped when using plist communication
+  - Improve compile support for cython and check it at configure time
+  - Bump cython requirement to 0.17.0+
+  - Fix compilation of cython bindings
+  - Python bindings now cover all C APIs
+  - Fix iOS 6 compatibility for mobilesync, mobilebackup, mobilebackup2 and
+    screenshotr by bumping device link protocol version number
+  - Do not strip non_ASCII characters from XML plists
+  - Fix possible crash when using OpenSSL
+* API is UNSTABLE
+
+Version 1.1.4
+~~~~~~~~~~~~~
+
+* Development release
+* Changes:
+  - Fix a bug in idevicesyslog causing the connection to close after timeout
+  - Bump soname revision
+* API is UNSTABLE
+
+Version 1.1.3
+~~~~~~~~~~~~~
+
+* Development release
+* Changes:
+  - Bump libusbmuxd dependency to 1.0.8
+  - Fix reading from syslog_relay and remove null characters
+  - Relicense ideviceimagemounter and idevicescreenshot to LGPL
+  - Fix a crash when using restored_client_free()
+  - API: Add sbservices_get_interface_orientation()
+  - Update man pages and code comments for documentation
+  - Minor cleanup
+* API is UNSTABLE
+
+Version 1.1.2
+~~~~~~~~~~~~~
+
+* Development release
+* Changes:
+  - Add Python bindings generated by Cython
+  - Bump libplist requirement to latest 1.8
+  - Add support for OpenSSL with fallback to GNUTLS
+  - Improvements and various fixes for Win32 and OS X build
+  - Remove glib dependency
+  - Improve restored implementation
+  - Fix various memory leaks
+  - Fix support for iOS 5 and later
+* SWIG Python Bindings are removed
+* API is UNSTABLE
+
+Version 1.1.1
+~~~~~~~~~~~~~
+
+* Development release
+* Changes:
+  - Add new idevicebackup2 tool for full backup and restore support on iOS 4+
+  - Add a workaround for a bug in iOS 4.3 affecting lockdown_get_value() which
+    most prominently affected libgpod, gvfs, ideviceinfo and some other tools
+  - Read ProxyDeath message to preventing obsolete messages in device syslog
+  - Rework SWIG detection and includes
+  - Add new idevicedate tool to get or set the clock on iDevices
+  - API: Add mobilesync_clear_all_records_on_device()
+  - API: Change device_link_service_disconnect() to accept a message
+  - Add manpages for ideviceenterrecovery, idevicepair, idevicebackup2 and
+    idevicedate
+  - Add missing libgen.h include to silence compiler warnings
+  - Fix a segfault that might occour if locally stored certs could not be read
+  - Fix various memory leaks
+  - Update documentation
+* Python Bindings will get refactored completely
+* API is UNSTABLE
+
+Version 1.1.0
+~~~~~~~~~~~~~
+
+* Development release
+* Changes:
+  - Implement restoring backups using idevicebackup
+  - Allow connecting without pairing using "ideviceinfo -s"
+  - Add ideviceenterrecovery tool
+  - Add mobilesync service implementation
+  - Add restored service implementation for restore mode
+  - Add home_arrest service implementation for document sharing
+  - Add API afc_client_new_from_connection()
+  - Support to fetch wallpaper in sbservices
+  - Support for formatVersion 2 of iOS 4+ in sbservices
+  - Add new lockdownd domains to ideviceinfo
+  - Give the device time to prepare backup data to prevent abort
+  - Improve idevicebackup output
+  - notification_proxy fixes and new notification type
+  - Silence some 64bit compiler warnings
+  - Fix various memory leaks
+  - Update documentation
+* Python Bindings will get refactored completely
+* API is UNSTABLE
+
+Version 1.0.7
+~~~~~~~~~~~~~
+
+* Maintenance release of stable series
+* Changes:
+  - Fix SWIG 2.x detection
+  - Fix support for iOS 5 and later
+  - Flush output of idevicesyslog immediately
+  - Replace deprecated GNUTLS functions properly
+  - Fix segfaults in library and some tools
+  - Fix memory leaks
+  - Build fixes
+
+Version 1.0.6
+~~~~~~~~~~~~~
+
+* Quick follow up release
+* Changes:
+  - Add ideviceenterrecovery which was missing in last release by accident
+
+Version 1.0.5
+~~~~~~~~~~~~~
+
+* Maintenance release of stable series
+* Changes:
+  - Add a workaround for a bug in iOS 4.3 affecting lockdown_get_value() which
+    most prominently affected libgpod, gvfs, ideviceinfo and some other tools
+  - Read ProxyDeath message to preventing obsolete messages in device syslog
+  - Rework SWIG detection and includes
+  - Add manpages for ideviceenterrecovery and idevicepair
+  - Add missing libgen.h include to silence compiler warnings
+
+Version 1.0.4
+~~~~~~~~~~~~~
+
+* Maintenance release of stable series
+* Changes:
+  - Fix a possible crash in lockdownd_client_new_with_handshake()
+  - Do not not check for Swig/Python if --without-swig is set
+  - Fail with an error message if libgcrypt is not found
+  - Pass host certificate with GNUTLS correctly
+  - Fix connecting to iOS 4.2.1+ devices
+
+Version 1.0.3
+~~~~~~~~~~~~~
+
+* Maintenance release of stable series
+* Changes:
+  - Terminate idevicesyslog on receive errors (like device unplug)
+  - Bugfixes for idevicebackup tool
+  - Hopefully the last fixes for big endian machines
+  - Build fixes for FreeBSD Python support
+  - Fix build on Mac OS X
+
+Version 1.0.2
+~~~~~~~~~~~~~
+
+* Maintenance release of stable series
+* Changes:
+  - Backport new idevicepair tool to manage pairings
+  - Fix a bug causing bad backup data
+  - Silence 64bit compiler warnings
+  - Plug some memory leaks
+
+Version 1.0.1
+~~~~~~~~~~~~~
+
+* Maintenance release of stable series
+* Changes:
+  - Cleanup includes of files
+  - Use glib instead of netinet for endianess
+  - Fix installation_proxy not adding client options correctly
+  - idevicebackup: better handle broken or missing plist files
+  - Fix some memory leaks in pairing/handshake process
+  - Fix label not being used in lockdownd_client_new()
+  - Update AUTHORS, README and installation instructions
+
+Version 1.0.0
+~~~~~~~~~~~~~
+
+* Changes:
+  - Update and fix documentation for full coverage
+  - Add man pages for tools
+  - Extend mobilebackup interface
+  - Add user data argument to notification callback function
+  - Fix broken Python bindings
+  - Add Python bindings for notification proxy interface
+  - Add screenshotr interface and tool
+  - Add mobile_image_mounter interface and tool
+  - Remove HAL fdi rules
+
+Version 0.9.7 (RC1)
+~~~~~~~~~~~~~~~~~~~
+
+* Project is now called libimobiledevice due to legal reasons
+* Changes:
+  - Project renamed to libimobiledevice
+  - Add soname versioning for future releases
+  - Fix regression causing never paired devices to not work by adding
+    auto-pairing for devices in lockdownd_client_new_with_handshake
+  - Add file_relay service implementation and dev test tool
+  - Minor device link service fixes 
+  - New idevicebackup tool with support for full and incremental backups
+  - Add mobilebackup service implementation
+
+Version 0.9.6
+~~~~~~~~~~~~~
+
+* Changes:
+  - Minor public API changes to prepare for 1.0 release:
+    * lockdownd_client_new -> lockdownd_client_new_with_handshake
+    * fooservice_recv -> fooservice_receive
+    * iphone_device_send/_recv -> iphone_connection_send/_receive
+  - Rename some code for consistency
+  - Refactor pairing to allow custom pair records
+  - Move SSL handling out of lockdownd code
+  - Refactor lockdown session handling code
+  - Remove debug mask support
+  - No longer do a full lockdown handshake on client_new
+  - Refactor debug code to be consistent and easier to use
+  - Run validate_pair by default during lockdown handshake
+  - Allow retrieving the type for lockdown query_type request
+  - Add new property_list_service and device_link_service abstractions
+  - Detect pairing failure due to having a password set on the device
+  - Implement lockdown phone activation and deactivation
+  - Fix iphoneinfo not printing values in key/value mode
+  - Implement lockdownd_unpair() request
+  - Add more notification ids and lockdown domains
+  - Implement label support for lockdown requests
+  - Add new installation_proxy interface
+  - Add new sbservices interface
+  - Implement lockdownd_validate_pair() request
+  - Add endian safety to AFC
+  - Make lockdown sessions without SSL work
+  - Fix linking on Mandriva Linux
+  - Minor bugfixes and documentation updates
+
+Version 0.9.5
+~~~~~~~~~~~~~
+
+* Changes:
+  - Updated to the latest libplist 0.16 API
+  - Fixed various minor leaks and issues
+  - Updated Python bindings and module name
+
+Version 0.9.4
+~~~~~~~~~~~~~
+
+* Changes:
+  - Update to libplist 0.15 API rework
+  - Update Python bindings
+  - Bufixes around usbmuxd daemon usage
+  - Use automake 1.11 silent rules if available
+  - Various bugfixes
+
+Version 0.9.3
+~~~~~~~~~~~~~
+
+* Changes:
+  - Bump libplist requirement to 0.13 and remove deprecated code
+
+Version 0.9.2
+~~~~~~~~~~~~~
+
+* Changes:
+  - Migrate to use the new usbmuxd daemon
+  - Refactor whole API
+  - Add iPhone 3GS support
+  - Add hard/symlink support for AFC
+  - New iphone_id tool to list connected devices and get the device
+    name
+  - iphoneinfo now allows plist/xml output and queries by
+    domain/key
+  - Fix a lot of bugs/crashes, compiler warnings and comments
+
+Version 0.9.1
+~~~~~~~~~~~~~
+
+* Changes:
+  - Fix make distcheck
+  - Bump libplist requirement to 0.12 and remove deprecated code
+  - A bunch of autotools fixes
+
+Version 0.9.0
+~~~~~~~~~~~~~
+
+* Changes:
+  - Fix pkg-config dependancies
+  - Fix Python binding generation
+  - AFC cleanup and improved error handling
+  - Add support for the notification proxy service
+  - Add tools to show device information and relay syslog
+  - More robust pairing implementation
+  - Remove libiphone-initconf, SSL implementation handles it at
+    runtime now
+  - Fix receive of plists larger than a packet
+  - Return an error if failed to start a service on the device
+  - Fix usb enumeration
+  - Fix udev rule to catch usb hubs, too
+  - Add large file support
+  - Move out plist handling into libplist and depend on it
+  - Add Python bindings
+  - Lots of bugfixes
+
+Version 0.1.0
+~~~~~~~~~~~~~
+
+* Changes:
+  - Use udev to set usb configuration; iphone kmod is obsolete now
+  - Remove HAL mounting
+  - Bugfixes
+

README.md

@@ -1,10 +1,201 @@
----
-title: Restore
-emoji: 🦀
-colorFrom: green
-colorTo: green
-sdk: static
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# libimobiledevice
+
+*A library to communicate with services on iOS devices using native protocols.*
+
+![](https://github.com/libimobiledevice/libimobiledevice/actions/workflows/build.yml/badge.svg)
+
+## Features
+
+libimobiledevice is a cross-platform software library that talks the protocols
+to interact with iOS devices.
+
+Unlike other projects, it does not depend on using any existing proprietary
+libraries and does not require jailbreaking.
+
+Some key features are:
+
+- **Interface**: Implements many high-level interfaces for device services
+- **Implementation**: Object oriented architecture and service abstraction layer
+- **Cross-Platform:** Tested on Linux, macOS, Windows and Android platforms
+- **Utilities**: Provides various command-line utilities for device services
+- **SSL**: Allows choosing between OpenSSL, GnuTLS, or MbedTLS to handle SSL communication
+- **Network**: Supports network connections with "WiFi sync" enabled devices
+- **Python:** Provides Cython based bindings for Python
+
+The implemented interfaces of many device service protocols allow applications
+to:
+
+* Access filesystem of a device
+* Access documents of file sharing apps
+* Retrieve information about a device and modify various settings
+* Backup and restore the device in a native way compatible with iTunes
+* Manage app icons arrangement on the device
+* Install, remove, list and basically manage apps
+* Activate a device using official servers
+* Manage contacts, calendars, notes and bookmarks
+* Retrieve and remove crashreports
+* Retrieve various diagnostics information
+* Establish a debug connection for app debugging
+* Mount filesystem images
+* Forward device notifications
+* Manage device provisioning
+* Take screenshots from the device screen (requires mounted developer image)
+* Simulate changed geolocation of the device (requires mounted developer image)
+* Relay the syslog of the device
+* Expose a connection for WebKit remote debugging
+
+... and much more.
+
+The library is in development since August 2007 with the goal to bring support
+for these devices to the Linux Desktop.
+
+## Installation / Getting started
+
+### Debian / Ubuntu Linux
+
+First install all required dependencies and build tools:
+```shell
+sudo apt-get install \
+	build-essential \
+	pkg-config \
+	checkinstall \
+	git \
+	autoconf \
+	automake \
+	libtool-bin \
+	libplist-dev \
+	libusbmuxd-dev \
+	libimobiledevice-glue-dev \
+	libtatsu-dev \
+	libssl-dev \
+	usbmuxd
+```
+NOTE: [libtatsu](https://github.com/libimobiledevice/libtatsu) (and thus `libtatsu-dev`)
+is a new library that was just published recently, you have to
+[build it from source](https://github.com/libimobiledevice/libtatsu?tab=readme-ov-file#building).
+
+If you want to optionally build the documentation or Python bindings use:
+```shell
+sudo apt-get install \
+	doxygen \
+	cython
+```
+
+Then clone the actual project repository:
+```shell
+git clone https://github.com/libimobiledevice/libimobiledevice.git
+cd libimobiledevice
+```
+
+Now you can build and install it:
+```shell
+./autogen.sh
+make
+sudo make install
+```
+
+If you require a custom prefix or other option being passed to `./configure`
+you can pass them directly to `./autogen.sh` like this:
+```bash
+./autogen.sh --prefix=/opt/local --enable-debug
+make
+sudo make install
+```
+
+By default, OpenSSL will be used as TLS/SSL library. If you prefer GnuTLS,
+configure with `--with-gnutls` like this:
+```bash
+./autogen.sh --with-gnutls
+```
+
+MbedTLS is also supported and can be enabled by passing `--with-mbedtls` to
+configure. If mbedTLS is not installed in a default location, you need to set
+the environment variables `mbedtls_INCLUDES` to the path that contains the
+MbedTLS headers and `mbedtls_LIBDIR` to set the library path. Optionally,
+`mbedtls_LIBS` can be used to set the library names directly. Example:
+```bash
+./autogen.sh --with-mbedtls mbedtls_INCLUDES=/opt/local/include mbedtls_LIBDIR=/opt/local/lib
+```
+
+## Usage
+
+Documentation about using the library in your application is not available yet.
+The "hacker way" for now is to look at the implementation of the included
+utilities.
+
+### Utilities
+
+The library bundles the following command-line utilities in the tools directory:
+
+| Utility                    | Description                                                        |
+| -------------------------- | ------------------------------------------------------------------ |
+| `idevice_id`               | List attached devices or print device name of given device         |
+| `idevicebackup`            | Create or restore backup for devices (legacy)                      |
+| `idevicebackup2`           | Create or restore backups for devices running iOS 4 or later       |
+| `idevicebtlogger`          | Capture Bluetooth HCI traffic from a device (requires log profile) |
+| `idevicecrashreport`       | Retrieve crash reports from a device                               |
+| `idevicedate`              | Display the current date or set it on a device                     |
+| `idevicedebug`             | Interact with the debugserver service of a device                  |
+| `idevicedebugserverproxy`  | Proxy a debugserver connection from a device for remote debugging  |
+| `idevicediagnostics`       | Interact with the diagnostics interface of a device                |
+| `ideviceenterrecovery`     | Make a device enter recovery mode                                  |
+| `ideviceimagemounter`      | Mount disk images on the device                                    |
+| `ideviceinfo`              | Show information about a connected device                          |
+| `idevicename`              | Display or set the device name                                     |
+| `idevicenotificationproxy` | Post or observe notifications on a device                          |
+| `idevicepair`              | Manage host pairings with devices and usbmuxd                      |
+| `ideviceprovision`         | Manage provisioning profiles on a device                           |
+| `idevicescreenshot`        | Gets a screenshot from the connected device                        |
+| `idevicesetlocation`       | Simulate location on device                                        |
+| `idevicesyslog`            | Relay syslog of a connected device                                 |
+| `afcclient`                | Interact with device filesystem via AFC/HouseArrest                |
+
+Please consult the usage information or manual pages of each utility for a
+documentation of available command line options and usage examples like this:
+```shell
+ideviceinfo --help
+man ideviceinfo
+```
+
+## Contributing
+
+We welcome contributions from anyone and are grateful for every pull request!
+
+If you'd like to contribute, please fork the `master` branch, change, commit and
+send a pull request for review. Once approved it can be merged into the main
+code base.
+
+If you plan to contribute larger changes or a major refactoring, please create a
+ticket first to discuss the idea upfront to ensure less effort for everyone.
+
+Please make sure your contribution adheres to:
+* Try to follow the code style of the project
+* Commit messages should describe the change well without being too short
+* Try to split larger changes into individual commits of a common domain
+* Use your real name and a valid email address for your commits
+
+We are still working on the guidelines so bear with us!
+
+## Links
+
+* Homepage: https://libimobiledevice.org/
+* Repository: https://github.com/libimobiledevice/libimobiledevice.git
+* Repository (Mirror): https://git.libimobiledevice.org/libimobiledevice.git
+* Issue Tracker: https://github.com/libimobiledevice/libimobiledevice/issues
+* Mailing List: https://lists.libimobiledevice.org/mailman/listinfo/libimobiledevice-devel
+* Twitter: https://twitter.com/libimobiledev
+
+## License
+
+This library and utilities are licensed under the [GNU Lesser General Public License v2.1](https://www.gnu.org/licenses/lgpl-2.1.en.html),
+also included in the repository in the `COPYING` file.
+
+## Credits
+
+Apple, iPhone, iPad, iPod, iPod Touch, Apple TV, Apple Watch, Mac, iOS,
+iPadOS, tvOS, watchOS, and macOS are trademarks of Apple Inc.
+
+This project is an independent software and has not been authorized, sponsored,
+or otherwise approved by Apple Inc.
+
+README Updated on: 2024-10-22

ac_pkg_cython.m4

@@ -0,0 +1,67 @@
+
+AC_DEFUN([AC_PROG_CYTHON],[
+        AC_PATH_PROGS([CYTHON],[cython cython3])
+        if test -z "$CYTHON" ; then
+                AC_MSG_WARN([Unable to find 'cython' or 'cython3' program. You should look at https://cython.org or install your distribution specific cython package.])
+                CYTHON=false
+        elif test -n "$1" ; then
+                AC_MSG_CHECKING([for Cython version])
+                [cython_version=`$CYTHON --version 2>&1 | sed 's/Cython version \(.*\)$/\1/g'`]
+                AC_MSG_RESULT([$cython_version])
+
+                # Setup extra version string for parsing
+                [cython_version_stripped=`echo $cython_version | sed 's/\([0-9]\+\)\.\([0-9]\+\)[^\.]*\(\.\([0-9]\+\)\)\?.*/0\1.0\2.0\4/g'`]
+                if test -n "$cython_version" ; then
+                        # Calculate the required version number components
+                        [required=$1]
+                        [required_major=`echo $required | sed 's/[^0-9].*//'`]
+                        if test -z "$required_major" ; then
+                                [required_major=0]
+                        fi
+                        [required=`echo $required | sed 's/[0-9]*[^0-9]//'`]
+                        [required_minor=`echo $required | sed 's/[^0-9].*//'`]
+                        if test -z "$required_minor" ; then
+                                [required_minor=0]
+                        fi
+                        [required=`echo $required | sed 's/[0-9]*[^0-9]//'`]
+                        [required_patch=`echo $required | sed 's/[^0-9].*//'`]
+                        if test -z "$required_patch" ; then
+                                [required_patch=0]
+                        fi
+
+                        # Calculate the available version number components
+                        [available=$cython_version_stripped]
+                        [available_major=`echo $available | sed 's/[^0-9].*//'`]
+                        if test -z "$available_major" ; then
+                                [available_major=0]
+                        fi
+                        [available=`echo $available | sed 's/[0-9]*[^0-9]//'`]
+                        [available_minor=`echo $available | sed 's/[^0-9].*//'`]
+                        if test -z "$available_minor" ; then
+                                [available_minor=0]
+                        fi
+                        [available=`echo $available | sed 's/[0-9]*[^0-9]//'`]
+                        [available_patch=`echo $available | sed 's/[^0-9].*//'`]
+                        if test -z "$available_patch" ; then
+                                [available_patch=0]
+                        fi
+
+                        if test $available_major -gt $required_major || \
+                                ( test $available_major -eq $required_major && \
+                                      test $available_minor -gt $required_minor ) || \
+                                ( test $available_major -eq $required_major && \
+                                        test $available_minor -eq $required_minor && \
+                                        test $available_patch -ge $required_patch ) ; then
+
+                                AC_MSG_NOTICE([Cython executable is '$CYTHON'])
+                        else
+                                AC_MSG_WARN([Cython version >= $1 is required.  You have $cython_version.  You should look at http://www.cython.org])
+                                CYTHON='echo "Error: Cython version >= $1 is required.  You have '"$cython_version"'.  You should look at http://www.cython.org" ; false'
+                        fi
+                else
+                        AC_MSG_WARN([Unable to determine Cython version])
+                        CYTHON=false
+                fi
+        fi
+        AC_SUBST([CYTHON_LIB])
+])

afc.c

@@ -0,0 +1,1314 @@
+/*
+ * afc.c
+ * Contains functions for the built-in AFC client.
+ *
+ * Copyright (c) 2014 Martin Szulecki All Rights Reserved.
+ * Copyright (c) 2009-2014 Nikias Bassen. All Rights Reserved.
+ * Copyright (c) 2008 Zach C. All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef _MSC_VER
+#include <unistd.h>
+#endif
+
+#include "idevice.h"
+#include "afc.h"
+#include "common/debug.h"
+#include "endianness.h"
+
+/**
+ * Locks an AFC client, done for thread safety stuff
+ *
+ * @param client The AFC client connection to lock
+ */
+static void afc_lock(afc_client_t client)
+{
+	debug_info("Locked");
+	mutex_lock(&client->mutex);
+}
+
+/**
+ * Unlocks an AFC client, done for thread safety stuff.
+ *
+ * @param client The AFC
+ */
+static void afc_unlock(afc_client_t client)
+{
+	debug_info("Unlocked");
+	mutex_unlock(&client->mutex);
+}
+
+/**
+ * Makes a connection to the AFC service on the device using the given
+ * connection.
+ *
+ * @param service_client A connected service client
+ * @param client Pointer that will be set to a newly allocated afc_client_t
+ *     upon successful return.
+ *
+ * @return AFC_E_SUCCESS on success, AFC_E_INVALID_ARG if connection is
+ *  invalid, or AFC_E_NO_MEM if there is a memory allocation problem.
+ */
+
+afc_error_t afc_client_new_with_service_client(service_client_t service_client, afc_client_t *client)
+{
+	if (!service_client)
+		return AFC_E_INVALID_ARG;
+
+	afc_client_t client_loc = (afc_client_t) malloc(sizeof(struct afc_client_private));
+	client_loc->parent = service_client;
+	client_loc->free_parent = 0;
+
+	/* allocate a packet */
+	client_loc->packet_extra = 1024;
+	client_loc->afc_packet = (AFCPacket *) malloc(sizeof(AFCPacket) + client_loc->packet_extra);
+	if (!client_loc->afc_packet) {
+		free(client_loc);
+		return AFC_E_NO_MEM;
+	}
+	client_loc->afc_packet->packet_num = 0;
+	client_loc->afc_packet->entire_length = 0;
+	client_loc->afc_packet->this_length = 0;
+	memcpy(client_loc->afc_packet->magic, AFC_MAGIC, AFC_MAGIC_LEN);
+	mutex_init(&client_loc->mutex);
+
+	*client = client_loc;
+	return AFC_E_SUCCESS;
+}
+
+afc_error_t afc_client_new(idevice_t device, lockdownd_service_descriptor_t service, afc_client_t * client)
+{
+	if (!device || !service || service->port == 0)
+		return AFC_E_INVALID_ARG;
+
+	service_client_t parent = NULL;
+	if (service_client_new(device, service, &parent) != SERVICE_E_SUCCESS) {
+		return AFC_E_MUX_ERROR;
+	}
+
+	afc_error_t err = afc_client_new_with_service_client(parent, client);
+	if (err != AFC_E_SUCCESS) {
+		service_client_free(parent);
+	} else {
+		(*client)->free_parent = 1;
+	}
+	return err;
+}
+
+afc_error_t afc_client_start_service(idevice_t device, afc_client_t * client, const char* label)
+{
+	int32_t err = AFC_E_UNKNOWN_ERROR;
+	service_client_factory_start_service(device, AFC_SERVICE_NAME, (void**)client, label, SERVICE_CONSTRUCTOR(afc_client_new), &err);
+	return err;
+}
+
+afc_error_t afc_client_free(afc_client_t client)
+{
+	if (!client || !client->afc_packet)
+		return AFC_E_INVALID_ARG;
+
+	if (client->free_parent && client->parent) {
+		service_client_free(client->parent);
+		client->parent = NULL;
+	}
+	free(client->afc_packet);
+	mutex_destroy(&client->mutex);
+	free(client);
+	return AFC_E_SUCCESS;
+}
+
+/**
+ * Dispatches an AFC packet over a client.
+ *
+ * @param client The client to send data through.
+ * @param operation The operation to perform.
+ * @param data The data to send together with the header.
+ * @param data_length The length of the data to send with the header.
+ * @param payload The data to send after the header has been sent.
+ * @param payload_length The length of data to send after the header.
+ * @param bytes_sent The total number of bytes actually sent.
+ *
+ * @return AFC_E_SUCCESS on success or an AFC_E_* error value.
+ */
+static afc_error_t afc_dispatch_packet(afc_client_t client, uint64_t operation, uint32_t data_length, const char* payload, uint32_t payload_length, uint32_t *bytes_sent)
+{
+	uint32_t sent = 0;
+
+	if (!client || !client->parent || !client->afc_packet)
+		return AFC_E_INVALID_ARG;
+
+	*bytes_sent = 0;
+
+	if (!payload || !payload_length)
+		payload_length = 0;
+
+	client->afc_packet->packet_num++;
+	client->afc_packet->operation = operation;
+	client->afc_packet->entire_length = sizeof(AFCPacket) + data_length + payload_length;
+	client->afc_packet->this_length = sizeof(AFCPacket) + data_length;
+
+	debug_info("packet length = %i", client->afc_packet->this_length);
+
+	/* send AFC packet header and data */
+	AFCPacket_to_LE(client->afc_packet);
+	debug_buffer((char*)client->afc_packet, sizeof(AFCPacket) + data_length);
+	sent = 0;
+	service_send(client->parent, (void*)client->afc_packet, sizeof(AFCPacket) + data_length, &sent);
+	AFCPacket_from_LE(client->afc_packet);
+	*bytes_sent += sent;
+	if (sent < sizeof(AFCPacket) + data_length) {
+		return AFC_E_SUCCESS;
+	}
+
+	sent = 0;
+	if (payload_length > 0) {
+		if (payload_length > 256) {
+			debug_info("packet payload follows (256/%u)", payload_length);
+			debug_buffer(payload, 256);
+		} else {
+			debug_info("packet payload follows");
+			debug_buffer(payload, payload_length);
+		}
+		service_send(client->parent, payload, payload_length, &sent);
+	}
+	*bytes_sent += sent;
+	if (sent < payload_length) {
+		return AFC_E_SUCCESS;
+	}
+
+	return AFC_E_SUCCESS;
+}
+
+/**
+ * Receives data through an AFC client and sets a variable to the received data.
+ *
+ * @param client The client to receive data on.
+ * @param bytes The char* to point to the newly-received data.
+ * @param bytes_recv How much data was received.
+ *
+ * @return AFC_E_SUCCESS on success or an AFC_E_* error value.
+ */
+static afc_error_t afc_receive_data(afc_client_t client, char **bytes, uint32_t *bytes_recv)
+{
+	AFCPacket header;
+	uint32_t entire_len = 0;
+	uint32_t this_len = 0;
+	uint32_t current_count = 0;
+	uint64_t param1 = -1;
+	char *buf = NULL;
+	uint32_t recv_len = 0;
+
+	if (bytes_recv) {
+		*bytes_recv = 0;
+	}
+	if (bytes) {
+		*bytes = NULL;
+	}
+
+	/* first, read the AFC header */
+	service_receive(client->parent, (char*)&header, sizeof(AFCPacket), &recv_len);
+	AFCPacket_from_LE(&header);
+	if (recv_len == 0) {
+		debug_info("Just didn't get enough.");
+		return AFC_E_MUX_ERROR;
+	}
+
+	if (recv_len < sizeof(AFCPacket)) {
+		debug_info("Did not even get the AFCPacket header");
+		return AFC_E_MUX_ERROR;
+	}
+
+	/* check if it's a valid AFC header */
+	if (strncmp(header.magic, AFC_MAGIC, AFC_MAGIC_LEN) != 0) {
+		debug_info("Invalid AFC packet received (magic != " AFC_MAGIC ")!");
+	}
+
+	/* check if it has the correct packet number */
+	if (header.packet_num != client->afc_packet->packet_num) {
+		/* otherwise print a warning but do not abort */
+		debug_info("ERROR: Unexpected packet number (%lld != %lld) aborting.", header.packet_num, client->afc_packet->packet_num);
+		return AFC_E_OP_HEADER_INVALID;
+	}
+
+	/* then, read the attached packet */
+	if (header.this_length < sizeof(AFCPacket)) {
+		debug_info("Invalid AFCPacket header received!");
+		return AFC_E_OP_HEADER_INVALID;
+	}
+	if ((header.this_length == header.entire_length)
+		&& header.entire_length == sizeof(AFCPacket)) {
+		debug_info("Empty AFCPacket received!");
+		if (header.operation == AFC_OP_DATA) {
+			return AFC_E_SUCCESS;
+		}
+		return AFC_E_IO_ERROR;
+	}
+
+	debug_info("received AFC packet, full len=%lld, this len=%lld, operation=0x%llx", header.entire_length, header.this_length, header.operation);
+
+	entire_len = (uint32_t)header.entire_length - sizeof(AFCPacket);
+	this_len = (uint32_t)header.this_length - sizeof(AFCPacket);
+
+	buf = (char*)malloc(entire_len);
+	if (this_len > 0) {
+		recv_len = 0;
+		service_receive(client->parent, buf, this_len, &recv_len);
+		if (recv_len <= 0) {
+			free(buf);
+			debug_info("Did not get packet contents!");
+			return AFC_E_NOT_ENOUGH_DATA;
+		}
+		if (recv_len < this_len) {
+			free(buf);
+			debug_info("Could not receive this_len=%d bytes", this_len);
+			return AFC_E_NOT_ENOUGH_DATA;
+		}
+	}
+
+	current_count = this_len;
+
+	if (entire_len > this_len) {
+		while (current_count < entire_len) {
+			recv_len = 0;
+			service_receive(client->parent, buf+current_count, entire_len - current_count, &recv_len);
+			if (recv_len <= 0) {
+				debug_info("Error receiving data (recv returned %d)", recv_len);
+				break;
+			}
+			current_count += recv_len;
+		}
+		if (current_count < entire_len) {
+			debug_info("WARNING: could not receive full packet (read %s, size %d)", current_count, entire_len);
+		}
+	}
+
+	if (current_count >= sizeof(uint64_t)) {
+		param1 = le64toh(*(uint64_t*)(buf));
+	}
+
+	debug_info("packet data size = %i", current_count);
+	if (current_count > 256) {
+		debug_info("packet data follows (256/%u)", current_count);
+		debug_buffer(buf, 256);
+	} else {
+		debug_info("packet data follows");
+		debug_buffer(buf, current_count);
+	}
+
+	/* check operation types */
+	if (header.operation == AFC_OP_STATUS) {
+		/* status response */
+		debug_info("got a status response, code=%lld", param1);
+
+		if (param1 != AFC_E_SUCCESS) {
+			/* error status */
+			/* free buffer */
+			free(buf);
+			return (afc_error_t)param1;
+		}
+	} else if (header.operation == AFC_OP_DATA) {
+		/* data response */
+		debug_info("got a data response");
+	} else if (header.operation == AFC_OP_FILE_OPEN_RES) {
+		/* file handle response */
+		debug_info("got a file handle response, handle=%lld", param1);
+	} else if (header.operation == AFC_OP_FILE_TELL_RES) {
+		/* tell response */
+		debug_info("got a tell response, position=%lld", param1);
+	} else {
+		/* unknown operation code received */
+		free(buf);
+
+		debug_info("WARNING: Unknown operation code received 0x%llx param1=%lld", header.operation, param1);
+#ifndef _WIN32
+		fprintf(stderr, "%s: WARNING: Unknown operation code received 0x%llx param1=%lld", __func__, (long long)header.operation, (long long)param1);
+#endif
+
+		return AFC_E_OP_NOT_SUPPORTED;
+	}
+
+	if (bytes) {
+		*bytes = buf;
+	} else {
+		free(buf);
+	}
+
+	*bytes_recv = current_count;
+	return AFC_E_SUCCESS;
+}
+
+/**
+ * Returns counts of null characters within a string.
+ */
+static uint32_t count_nullspaces(const char *string, uint32_t number)
+{
+	uint32_t i = 0, nulls = 0;
+
+	for (i = 0; i < number; i++) {
+		if (string[i] == '\0')
+			nulls++;
+	}
+
+	return nulls;
+}
+
+/**
+ * Splits a string of tokens by null characters and returns each token in a
+ * char array/list.
+ *
+ * @param tokens The characters to split into a list.
+ * @param length The length of the tokens string.
+ *
+ * @return A char ** list with each token found in the string. The caller is
+ *  responsible for freeing the memory.
+ */
+static char **make_strings_list(char *tokens, uint32_t length)
+{
+	uint32_t nulls = 0, i = 0, j = 0;
+	char **list = NULL;
+
+	if (!tokens || !length)
+		return NULL;
+
+	nulls = count_nullspaces(tokens, length);
+	list = (char **) malloc(sizeof(char *) * (nulls + 1));
+	for (i = 0; i < nulls; i++) {
+		list[i] = strdup(tokens + j);
+		j += strlen(list[i]) + 1;
+	}
+	list[i] = NULL;
+
+	return list;
+}
+
+static plist_t *make_dictionary(char *tokens, size_t length)
+{
+	size_t j = 0;
+	plist_t dict = NULL;
+
+	if (!tokens || !length)
+		return NULL;
+
+	dict = plist_new_dict();
+
+	while (j < length) {
+		size_t key_len = strnlen(tokens + j, length - j);
+		if (j + key_len >= length) {
+			plist_free(dict);
+			return NULL;
+		}
+		char* key = tokens + j;
+		j += key_len + 1;
+
+		if (j >= length) {
+			plist_free(dict);
+			return NULL;
+		}
+
+		size_t val_len = strnlen(tokens + j, length - j);
+		if (j + val_len >= length) {
+			plist_free(dict);
+			return NULL;
+		}
+		char* val = tokens + j;
+		j += val_len + 1;
+
+		char* endp = NULL;
+		unsigned long long u64val = strtoull(val, &endp, 10);
+		if (endp && *endp == '\0') {
+			plist_dict_set_item(dict, key, plist_new_uint(u64val));
+		} else {
+			plist_dict_set_item(dict, key, plist_new_string(val));
+		}
+	}
+
+	return dict;
+}
+
+static int _afc_check_packet_buffer(afc_client_t client, uint32_t data_len)
+{
+	if (data_len > client->packet_extra) {
+		client->packet_extra = (data_len & ~8) + 8;
+		AFCPacket* newpkt = (AFCPacket*)realloc(client->afc_packet, sizeof(AFCPacket) + client->packet_extra);
+		if (!newpkt) {
+			return -1;
+		}
+		client->afc_packet = newpkt;
+	}
+	return 0;
+}
+
+#define AFC_PACKET_DATA_PTR ((char*)client->afc_packet + sizeof(AFCPacket))
+
+afc_error_t afc_read_directory(afc_client_t client, const char *path, char ***directory_information)
+{
+	uint32_t bytes = 0;
+	char *data = NULL, **list_loc = NULL;
+	afc_error_t ret = AFC_E_UNKNOWN_ERROR;
+
+	if (!client || !path || !directory_information || (directory_information && *directory_information))
+		return AFC_E_INVALID_ARG;
+
+	afc_lock(client);
+
+	uint32_t data_len = (uint32_t)strlen(path)+1;
+	if (_afc_check_packet_buffer(client, data_len) < 0) {
+		afc_unlock(client);
+		debug_info("Failed to realloc packet buffer");
+		return AFC_E_NO_MEM;
+	}
+
+	/* Send the command */
+	memcpy(AFC_PACKET_DATA_PTR, path, data_len);
+	ret = afc_dispatch_packet(client, AFC_OP_READ_DIR, data_len, NULL, 0, &bytes);
+	if (ret != AFC_E_SUCCESS) {
+		afc_unlock(client);
+		return AFC_E_NOT_ENOUGH_DATA;
+	}
+	/* Receive the data */
+	ret = afc_receive_data(client, &data, &bytes);
+	if (ret != AFC_E_SUCCESS) {
+		if (data)
+			free(data);
+		afc_unlock(client);
+		return ret;
+	}
+	/* Parse the data */
+	list_loc = make_strings_list(data, bytes);
+	if (data)
+		free(data);
+
+	afc_unlock(client);
+	*directory_information = list_loc;
+
+	return ret;
+}
+
+afc_error_t afc_get_device_info(afc_client_t client, char ***device_information)
+{
+	uint32_t bytes = 0;
+	char *data = NULL, **list = NULL;
+	afc_error_t ret = AFC_E_UNKNOWN_ERROR;
+
+	if (!client || !device_information)
+		return AFC_E_INVALID_ARG;
+
+	afc_lock(client);
+
+	/* Send the command */
+	ret = afc_dispatch_packet(client, AFC_OP_GET_DEVINFO, 0, NULL, 0, &bytes);
+	if (ret != AFC_E_SUCCESS) {
+		afc_unlock(client);
+		return AFC_E_NOT_ENOUGH_DATA;
+	}
+	/* Receive the data */
+	ret = afc_receive_data(client, &data, &bytes);
+	if (ret != AFC_E_SUCCESS) {
+		if (data)
+			free(data);
+		afc_unlock(client);
+		return ret;
+	}
+	/* Parse the data */
+	list = make_strings_list(data, bytes);
+	if (data)
+		free(data);
+
+	afc_unlock(client);
+
+	*device_information = list;
+
+	return ret;
+}
+
+afc_error_t afc_get_device_info_plist(afc_client_t client, plist_t *device_information)
+{
+	uint32_t bytes = 0;
+	char *data = NULL;
+	afc_error_t ret = AFC_E_UNKNOWN_ERROR;
+
+	if (!client || !device_information)
+		return AFC_E_INVALID_ARG;
+
+	afc_lock(client);
+
+	/* Send the command */
+	ret = afc_dispatch_packet(client, AFC_OP_GET_DEVINFO, 0, NULL, 0, &bytes);
+	if (ret != AFC_E_SUCCESS) {
+		afc_unlock(client);
+		return AFC_E_NOT_ENOUGH_DATA;
+	}
+	/* Receive the data */
+	ret = afc_receive_data(client, &data, &bytes);
+	if (ret != AFC_E_SUCCESS) {
+		if (data)
+			free(data);
+		afc_unlock(client);
+		return ret;
+	}
+	/* Parse the data */
+	*device_information = make_dictionary(data, bytes);
+	free(data);
+
+	afc_unlock(client);
+
+	return ret;
+}
+
+afc_error_t afc_get_device_info_key(afc_client_t client, const char *key, char **value)
+{
+	afc_error_t ret = AFC_E_INTERNAL_ERROR;
+	char **kvps, **ptr;
+
+	*value = NULL;
+	if (key == NULL)
+		return AFC_E_INVALID_ARG;
+
+	ret = afc_get_device_info(client, &kvps);
+	if (ret != AFC_E_SUCCESS)
+		return ret;
+
+	for (ptr = kvps; *ptr; ptr++) {
+		if (!strcmp(*ptr, key)) {
+			*value = strdup(*(ptr+1));
+			break;
+		}
+	}
+	for (ptr = kvps; *ptr; ptr++) {
+		free(*ptr);
+	}
+	free(kvps);
+
+	return ret;
+}
+
+afc_error_t afc_remove_path(afc_client_t client, const char *path)
+{
+	uint32_t bytes = 0;
+	afc_error_t ret = AFC_E_UNKNOWN_ERROR;
+
+	if (!client || !path || !client->afc_packet || !client->parent)
+		return AFC_E_INVALID_ARG;
+
+	afc_lock(client);
+
+	uint32_t data_len = (uint32_t)strlen(path)+1;
+	if (_afc_check_packet_buffer(client, data_len) < 0) {
+		afc_unlock(client);
+		debug_info("Failed to realloc packet buffer");
+		return AFC_E_NO_MEM;
+	}
+
+	/* Send command */
+	memcpy(AFC_PACKET_DATA_PTR, path, data_len);
+	ret = afc_dispatch_packet(client, AFC_OP_REMOVE_PATH, data_len, NULL, 0, &bytes);
+	if (ret != AFC_E_SUCCESS) {
+		afc_unlock(client);
+		return AFC_E_NOT_ENOUGH_DATA;
+	}
+	/* Receive response */
+	ret = afc_receive_data(client, NULL, &bytes);
+
+	/* special case; unknown error actually means directory not empty */
+	if (ret == AFC_E_UNKNOWN_ERROR)
+		ret = AFC_E_DIR_NOT_EMPTY;
+
+	afc_unlock(client);
+
+	return ret;
+}
+
+afc_error_t afc_rename_path(afc_client_t client, const char *from, const char *to)
+{
+	if (!client || !from || !to || !client->afc_packet || !client->parent)
+		return AFC_E_INVALID_ARG;
+
+	uint32_t bytes = 0;
+	afc_error_t ret = AFC_E_UNKNOWN_ERROR;
+
+	size_t from_len = strlen(from);
+	size_t to_len = strlen(to);
+
+	afc_lock(client);
+
+	uint32_t data_len = (uint32_t)(from_len+1 + to_len+1);
+	if (_afc_check_packet_buffer(client, data_len) < 0) {
+		afc_unlock(client);
+		debug_info("Failed to realloc packet buffer");
+		return AFC_E_NO_MEM;
+	}
+
+	/* Send command */
+	memcpy(AFC_PACKET_DATA_PTR, from, from_len+1);
+	memcpy(AFC_PACKET_DATA_PTR + from_len+1, to, to_len+1);
+	ret = afc_dispatch_packet(client, AFC_OP_RENAME_PATH, data_len, NULL, 0, &bytes);
+	if (ret != AFC_E_SUCCESS) {
+		afc_unlock(client);
+		return AFC_E_NOT_ENOUGH_DATA;
+	}
+	/* Receive response */
+	ret = afc_receive_data(client, NULL, &bytes);
+
+	afc_unlock(client);
+
+	return ret;
+}
+
+afc_error_t afc_make_directory(afc_client_t client, const char *path)
+{
+	uint32_t bytes = 0;
+	afc_error_t ret = AFC_E_UNKNOWN_ERROR;
+
+	if (!client)
+		return AFC_E_INVALID_ARG;
+
+	afc_lock(client);
+
+	uint32_t data_len = (uint32_t)strlen(path)+1;
+	if (_afc_check_packet_buffer(client, data_len) < 0) {
+		afc_unlock(client);
+		debug_info("Failed to realloc packet buffer");
+		return AFC_E_NO_MEM;
+	}
+
+	/* Send command */
+	memcpy(AFC_PACKET_DATA_PTR, path, data_len);
+	ret = afc_dispatch_packet(client, AFC_OP_MAKE_DIR, data_len, NULL, 0, &bytes);
+	if (ret != AFC_E_SUCCESS) {
+		afc_unlock(client);
+		return AFC_E_NOT_ENOUGH_DATA;
+	}
+	/* Receive response */
+	ret = afc_receive_data(client, NULL, &bytes);
+
+	afc_unlock(client);
+
+	return ret;
+}
+
+afc_error_t afc_get_file_info(afc_client_t client, const char *path, char ***file_information)
+{
+	char *received = NULL;
+	uint32_t bytes = 0;
+	afc_error_t ret = AFC_E_UNKNOWN_ERROR;
+
+	if (!client || !path || !file_information)
+		return AFC_E_INVALID_ARG;
+
+	afc_lock(client);
+
+	uint32_t data_len = (uint32_t)strlen(path)+1;
+	if (_afc_check_packet_buffer(client, data_len) < 0) {
+		afc_unlock(client);
+		debug_info("Failed to realloc packet buffer");
+		return AFC_E_NO_MEM;
+	}
+
+	/* Send command */
+	memcpy(AFC_PACKET_DATA_PTR, path, data_len);
+	ret = afc_dispatch_packet(client, AFC_OP_GET_FILE_INFO, data_len, NULL, 0, &bytes);
+	if (ret != AFC_E_SUCCESS) {
+		afc_unlock(client);
+		return AFC_E_NOT_ENOUGH_DATA;
+	}
+
+	/* Receive data */
+	ret = afc_receive_data(client, &received, &bytes);
+	if (received) {
+		*file_information = make_strings_list(received, bytes);
+		free(received);
+	}
+
+	afc_unlock(client);
+
+	return ret;
+}
+
+afc_error_t afc_get_file_info_plist(afc_client_t client, const char *path, plist_t *file_information)
+{
+	char *received = NULL;
+	uint32_t bytes = 0;
+	afc_error_t ret = AFC_E_UNKNOWN_ERROR;
+
+	if (!client || !path || !file_information)
+		return AFC_E_INVALID_ARG;
+
+	afc_lock(client);
+
+	uint32_t data_len = (uint32_t)strlen(path)+1;
+	if (_afc_check_packet_buffer(client, data_len) < 0) {
+		afc_unlock(client);
+		debug_info("Failed to realloc packet buffer");
+		return AFC_E_NO_MEM;
+	}
+
+	/* Send command */
+	memcpy(AFC_PACKET_DATA_PTR, path, data_len);
+	ret = afc_dispatch_packet(client, AFC_OP_GET_FILE_INFO, data_len, NULL, 0, &bytes);
+	if (ret != AFC_E_SUCCESS) {
+		afc_unlock(client);
+		return AFC_E_NOT_ENOUGH_DATA;
+	}
+
+	/* Receive data */
+	ret = afc_receive_data(client, &received, &bytes);
+	if (received) {
+		*file_information = make_dictionary(received, bytes);
+		free(received);
+	}
+
+	afc_unlock(client);
+
+	return ret;
+}
+
+afc_error_t afc_file_open(afc_client_t client, const char *filename, afc_file_mode_t file_mode, uint64_t *handle)
+{
+	if (!client || !client->parent || !client->afc_packet)
+		return AFC_E_INVALID_ARG;
+
+	//uint64_t file_mode_loc = htole64(file_mode);
+	uint32_t bytes = 0;
+	afc_error_t ret = AFC_E_UNKNOWN_ERROR;
+
+	/* set handle to 0 so in case an error occurs, the handle is invalid */
+	*handle = 0;
+
+	afc_lock(client);
+
+	uint32_t data_len = (uint32_t)(strlen(filename)+1 + 8);
+	if (_afc_check_packet_buffer(client, data_len) < 0) {
+		afc_unlock(client);
+		debug_info("Failed to realloc packet buffer");
+		return AFC_E_NO_MEM;
+	}
+
+	/* Send command */
+	//memcpy(AFC_PACKET_DATA_PTR, &file_mode_loc, 8);
+	*(uint64_t*)(AFC_PACKET_DATA_PTR) = htole64(file_mode);
+	memcpy(AFC_PACKET_DATA_PTR + 8, filename, data_len-8);
+	ret = afc_dispatch_packet(client, AFC_OP_FILE_OPEN, data_len, NULL, 0, &bytes);
+	if (ret != AFC_E_SUCCESS) {
+		debug_info("Didn't receive a response to the command");
+		afc_unlock(client);
+		return AFC_E_NOT_ENOUGH_DATA;
+	}
+	/* Receive the data */
+	char* data = NULL;
+	ret = afc_receive_data(client, &data, &bytes);
+	if ((ret == AFC_E_SUCCESS) && (bytes > 0) && data) {
+		afc_unlock(client);
+
+		/* Get the file handle */
+		memcpy(handle, data, sizeof(uint64_t));
+		free(data);
+		return ret;
+	}
+	/* in case memory was allocated but no data received or an error occurred */
+	free(data);
+
+	debug_info("Didn't get any further data");
+
+	afc_unlock(client);
+
+	return ret;
+}
+
+afc_error_t afc_file_read(afc_client_t client, uint64_t handle, char *data, uint32_t length, uint32_t *bytes_read)
+{
+	char *input = NULL;
+	uint32_t current_count = 0, bytes_loc = 0;
+	struct readinfo {
+		uint64_t handle;
+		uint64_t size;
+	};
+	afc_error_t ret = AFC_E_SUCCESS;
+
+	if (!client || !client->afc_packet || !client->parent || handle == 0)
+		return AFC_E_INVALID_ARG;
+	debug_info("called for length %i", length);
+
+	//uint32_t data_len = 8 + 8;
+
+	afc_lock(client);
+
+	/* Send the read command */
+	struct readinfo* readinfo = (struct readinfo*)(AFC_PACKET_DATA_PTR);
+	readinfo->handle = handle;
+	readinfo->size = htole64(length);
+	ret = afc_dispatch_packet(client, AFC_OP_FILE_READ, sizeof(struct readinfo), NULL, 0, &bytes_loc);
+	if (ret != AFC_E_SUCCESS) {
+		afc_unlock(client);
+		return AFC_E_NOT_ENOUGH_DATA;
+	}
+	/* Receive the data */
+	ret = afc_receive_data(client, &input, &bytes_loc);
+	debug_info("afc_receive_data returned error: %d", ret);
+	debug_info("bytes returned: %i", bytes_loc);
+	if (ret != AFC_E_SUCCESS) {
+		afc_unlock(client);
+		return ret;
+	}
+	if (bytes_loc == 0) {
+		if (input)
+			free(input);
+		afc_unlock(client);
+		*bytes_read = current_count;
+		/* FIXME: check that's actually a success */
+		return ret;
+	}
+	if (input) {
+		debug_info("%d", bytes_loc);
+		memcpy(data + current_count, input, (bytes_loc > length) ? length : bytes_loc);
+		free(input);
+		input = NULL;
+		current_count += (bytes_loc > length) ? length : bytes_loc;
+	}
+
+	afc_unlock(client);
+	*bytes_read = current_count;
+	return ret;
+}
+
+afc_error_t afc_file_write(afc_client_t client, uint64_t handle, const char *data, uint32_t length, uint32_t *bytes_written)
+{
+	uint32_t current_count = 0;
+	uint32_t bytes_loc = 0;
+	afc_error_t ret = AFC_E_SUCCESS;
+
+	if (!client || !client->afc_packet || !client->parent || !bytes_written || (handle == 0))
+		return AFC_E_INVALID_ARG;
+
+	uint32_t data_len = 8;
+
+	afc_lock(client);
+
+	debug_info("Write length: %i", length);
+
+	*(uint64_t*)(AFC_PACKET_DATA_PTR) = handle;
+	ret = afc_dispatch_packet(client, AFC_OP_FILE_WRITE, data_len, data, length, &bytes_loc);
+
+	current_count += bytes_loc - (sizeof(AFCPacket) + 8);
+
+	if (ret != AFC_E_SUCCESS) {
+		afc_unlock(client);
+		*bytes_written = current_count;
+		return AFC_E_SUCCESS;
+	}
+
+	ret = afc_receive_data(client, NULL, &bytes_loc);
+	afc_unlock(client);
+	if (ret != AFC_E_SUCCESS) {
+		debug_info("Failed to receive reply (%d)", ret);
+	}
+	*bytes_written = current_count;
+	return ret;
+}
+
+afc_error_t afc_file_close(afc_client_t client, uint64_t handle)
+{
+	uint32_t bytes = 0;
+	afc_error_t ret = AFC_E_UNKNOWN_ERROR;
+
+	if (!client || (handle == 0))
+		return AFC_E_INVALID_ARG;
+
+	uint32_t data_len = 8;
+
+	afc_lock(client);
+
+	debug_info("File handle %i", handle);
+
+	/* Send command */
+	*(uint64_t*)(AFC_PACKET_DATA_PTR) = handle;
+	ret = afc_dispatch_packet(client, AFC_OP_FILE_CLOSE, data_len, NULL, 0, &bytes);
+
+	if (ret != AFC_E_SUCCESS) {
+		afc_unlock(client);
+		return AFC_E_UNKNOWN_ERROR;
+	}
+
+	/* Receive the response */
+	ret = afc_receive_data(client, NULL, &bytes);
+
+	afc_unlock(client);
+
+	return ret;
+}
+
+afc_error_t afc_file_lock(afc_client_t client, uint64_t handle, afc_lock_op_t operation)
+{
+	uint32_t bytes = 0;
+	struct lockinfo {
+		uint64_t handle;
+		uint64_t op;
+	};
+	afc_error_t ret = AFC_E_UNKNOWN_ERROR;
+
+	if (!client || (handle == 0))
+		return AFC_E_INVALID_ARG;
+
+	afc_lock(client);
+
+	debug_info("file handle %i", handle);
+
+	/* Send command */
+	struct lockinfo* lockinfo = (struct lockinfo*)(AFC_PACKET_DATA_PTR);
+	lockinfo->handle = handle;
+	lockinfo->op = htole64(operation);
+	ret = afc_dispatch_packet(client, AFC_OP_FILE_LOCK, sizeof(struct lockinfo), NULL, 0, &bytes);
+	if (ret != AFC_E_SUCCESS) {
+		afc_unlock(client);
+		debug_info("could not send lock command");
+		return AFC_E_UNKNOWN_ERROR;
+	}
+	/* Receive the response */
+	ret = afc_receive_data(client, NULL, &bytes);
+
+	afc_unlock(client);
+
+	return ret;
+}
+
+afc_error_t afc_file_seek(afc_client_t client, uint64_t handle, int64_t offset, int whence)
+{
+	uint32_t bytes = 0;
+	struct seekinfo {
+		uint64_t handle;
+		uint64_t whence;
+		int64_t offset;
+	};
+	afc_error_t ret = AFC_E_UNKNOWN_ERROR;
+
+	if (!client || (handle == 0))
+		return AFC_E_INVALID_ARG;
+
+	afc_lock(client);
+
+	/* Send the command */
+	struct seekinfo* seekinfo = (struct seekinfo*)(AFC_PACKET_DATA_PTR);
+	seekinfo->handle = handle;
+	seekinfo->whence = htole64(whence);
+	seekinfo->offset = (int64_t)htole64(offset);
+	ret = afc_dispatch_packet(client, AFC_OP_FILE_SEEK, sizeof(struct seekinfo), NULL, 0, &bytes);
+
+	if (ret != AFC_E_SUCCESS) {
+		afc_unlock(client);
+		return AFC_E_NOT_ENOUGH_DATA;
+	}
+	/* Receive response */
+	ret = afc_receive_data(client, NULL, &bytes);
+
+	afc_unlock(client);
+
+	return ret;
+}
+
+afc_error_t afc_file_tell(afc_client_t client, uint64_t handle, uint64_t *position)
+{
+	char *buffer = NULL;
+	uint32_t bytes = 0;
+	afc_error_t ret = AFC_E_UNKNOWN_ERROR;
+
+	if (!client || (handle == 0))
+		return AFC_E_INVALID_ARG;
+
+	uint32_t data_len = 8;
+
+	afc_lock(client);
+
+	/* Send the command */
+	*(uint64_t*)(AFC_PACKET_DATA_PTR) = handle;
+	ret = afc_dispatch_packet(client, AFC_OP_FILE_TELL, data_len, NULL, 0, &bytes);
+	if (ret != AFC_E_SUCCESS) {
+		afc_unlock(client);
+		return AFC_E_NOT_ENOUGH_DATA;
+	}
+
+	/* Receive the data */
+	ret = afc_receive_data(client, &buffer, &bytes);
+	if (bytes > 0 && buffer) {
+		/* Get the position */
+		memcpy(position, buffer, sizeof(uint64_t));
+		*position = le64toh(*position);
+	}
+	free(buffer);
+
+	afc_unlock(client);
+
+	return ret;
+}
+
+afc_error_t afc_file_truncate(afc_client_t client, uint64_t handle, uint64_t newsize)
+{
+	uint32_t bytes = 0;
+	struct truncinfo {
+		uint64_t handle;
+		uint64_t newsize;
+	};
+	afc_error_t ret = AFC_E_UNKNOWN_ERROR;
+
+	if (!client || (handle == 0))
+		return AFC_E_INVALID_ARG;
+
+	afc_lock(client);
+
+	/* Send command */
+	struct truncinfo* truncinfo = (struct truncinfo*)(AFC_PACKET_DATA_PTR);
+	truncinfo->handle = handle;
+	truncinfo->newsize = htole64(newsize);
+	ret = afc_dispatch_packet(client, AFC_OP_FILE_SET_SIZE, sizeof(struct truncinfo), NULL, 0, &bytes);
+
+	if (ret != AFC_E_SUCCESS) {
+		afc_unlock(client);
+		return AFC_E_NOT_ENOUGH_DATA;
+	}
+	/* Receive response */
+	ret = afc_receive_data(client, NULL, &bytes);
+
+	afc_unlock(client);
+
+	return ret;
+}
+
+afc_error_t afc_truncate(afc_client_t client, const char *path, uint64_t newsize)
+{
+	if (!client || !path || !client->afc_packet || !client->parent)
+		return AFC_E_INVALID_ARG;
+
+	uint32_t bytes = 0;
+	afc_error_t ret = AFC_E_UNKNOWN_ERROR;
+
+	afc_lock(client);
+
+	uint32_t data_len = 8 + (uint32_t)(strlen(path)+1);
+	if (_afc_check_packet_buffer(client, data_len) < 0) {
+		afc_unlock(client);
+		debug_info("Failed to realloc packet buffer");
+		return AFC_E_NO_MEM;
+	}
+
+	/* Send command */
+	*(uint64_t*)(AFC_PACKET_DATA_PTR) = htole64(newsize);
+	memcpy(AFC_PACKET_DATA_PTR + 8, path, data_len-8);
+	ret = afc_dispatch_packet(client, AFC_OP_TRUNCATE, data_len, NULL, 0, &bytes);
+	if (ret != AFC_E_SUCCESS) {
+		afc_unlock(client);
+		return AFC_E_NOT_ENOUGH_DATA;
+	}
+	/* Receive response */
+	ret = afc_receive_data(client, NULL, &bytes);
+
+	afc_unlock(client);
+
+	return ret;
+}
+
+afc_error_t afc_make_link(afc_client_t client, afc_link_type_t linktype, const char *target, const char *linkname)
+{
+	if (!client || !target || !linkname || !client->afc_packet || !client->parent)
+		return AFC_E_INVALID_ARG;
+
+	uint32_t bytes = 0;
+	afc_error_t ret = AFC_E_UNKNOWN_ERROR;
+
+	size_t target_len = strlen(target);
+	size_t link_len = strlen(linkname);
+
+	afc_lock(client);
+
+	uint32_t data_len = 8 + target_len + 1 + link_len + 1;
+	if (_afc_check_packet_buffer(client, data_len) < 0) {
+		afc_unlock(client);
+		debug_info("Failed to realloc packet buffer");
+		return AFC_E_NO_MEM;
+	}
+
+	debug_info("link type: %lld", htole64(linktype));
+	debug_info("target: %s, length:%d", target, target_len);
+	debug_info("linkname: %s, length:%d", linkname, link_len);
+
+	/* Send command */
+	*(uint64_t*)(AFC_PACKET_DATA_PTR) = htole64(linktype);
+	memcpy(AFC_PACKET_DATA_PTR + 8, target, target_len + 1);
+	memcpy(AFC_PACKET_DATA_PTR + 8 + target_len + 1, linkname, link_len + 1);
+	ret = afc_dispatch_packet(client, AFC_OP_MAKE_LINK, data_len, NULL, 0, &bytes);
+	if (ret != AFC_E_SUCCESS) {
+		afc_unlock(client);
+		return AFC_E_NOT_ENOUGH_DATA;
+	}
+	/* Receive response */
+	ret = afc_receive_data(client, NULL, &bytes);
+
+	afc_unlock(client);
+
+	return ret;
+}
+
+afc_error_t afc_set_file_time(afc_client_t client, const char *path, uint64_t mtime)
+{
+	if (!client || !path || !client->afc_packet || !client->parent)
+		return AFC_E_INVALID_ARG;
+
+	uint32_t bytes = 0;
+	afc_error_t ret = AFC_E_UNKNOWN_ERROR;
+
+	afc_lock(client);
+
+	uint32_t data_len = 8 + strlen(path) + 1;
+	if (_afc_check_packet_buffer(client, data_len) < 0) {
+		afc_unlock(client);
+		debug_info("Failed to realloc packet buffer");
+		return AFC_E_NO_MEM;
+	}
+
+	/* Send command */
+	*(uint64_t*)(AFC_PACKET_DATA_PTR) = htole64(mtime);
+	memcpy(AFC_PACKET_DATA_PTR + 8, path, data_len-8);
+	ret = afc_dispatch_packet(client, AFC_OP_SET_FILE_MOD_TIME, data_len, NULL, 0, &bytes);
+	if (ret != AFC_E_SUCCESS) {
+		afc_unlock(client);
+		return AFC_E_NOT_ENOUGH_DATA;
+	}
+	/* Receive response */
+	ret = afc_receive_data(client, NULL, &bytes);
+
+	afc_unlock(client);
+
+	return ret;
+}
+
+afc_error_t afc_remove_path_and_contents(afc_client_t client, const char *path)
+{
+	uint32_t bytes = 0;
+	afc_error_t ret = AFC_E_UNKNOWN_ERROR;
+
+	if (!client || !path || !client->afc_packet || !client->parent)
+		return AFC_E_INVALID_ARG;
+
+	afc_lock(client);
+
+	uint32_t data_len = strlen(path) + 1;
+	if (_afc_check_packet_buffer(client, data_len) < 0) {
+		afc_unlock(client);
+		debug_info("Failed to realloc packet buffer");
+		return AFC_E_NO_MEM;
+	}
+
+	/* Send command */
+	memcpy(AFC_PACKET_DATA_PTR, path, data_len);
+	ret = afc_dispatch_packet(client, AFC_OP_REMOVE_PATH_AND_CONTENTS, data_len, NULL, 0, &bytes);
+	if (ret != AFC_E_SUCCESS) {
+		afc_unlock(client);
+		return AFC_E_NOT_ENOUGH_DATA;
+	}
+	/* Receive response */
+	ret = afc_receive_data(client, NULL, &bytes);
+
+	afc_unlock(client);
+
+	return ret;
+}
+
+afc_error_t afc_dictionary_free(char **dictionary)
+{
+	int i = 0;
+
+	if (!dictionary)
+		return AFC_E_INVALID_ARG;
+
+	for (i = 0; dictionary[i]; i++) {
+		free(dictionary[i]);
+	}
+	free(dictionary);
+
+	return AFC_E_SUCCESS;
+}
+
+const char* afc_strerror(afc_error_t err)
+{
+	switch (err) {
+		case AFC_E_SUCCESS:
+			return "Success";
+		case AFC_E_UNKNOWN_ERROR:
+			return "Unknown Error";
+		case AFC_E_OP_HEADER_INVALID:
+			return "Operation header invalid";
+		case AFC_E_NO_RESOURCES:
+			return "No resources";
+		case AFC_E_READ_ERROR:
+			return "Read error";
+		case AFC_E_WRITE_ERROR:
+			return "Write error";
+		case AFC_E_UNKNOWN_PACKET_TYPE:
+			return "Unknown packet type";
+		case AFC_E_INVALID_ARG:
+			return "Invalid argument";
+		case AFC_E_OBJECT_NOT_FOUND:
+			return "Not found";
+		case AFC_E_OBJECT_IS_DIR:
+			return "Object is a directory";
+		case AFC_E_PERM_DENIED:
+			return "Permission denied";
+		case AFC_E_SERVICE_NOT_CONNECTED:
+			return "Service not connected";
+		case AFC_E_OP_TIMEOUT:
+			return "Timeout";
+		case AFC_E_TOO_MUCH_DATA:
+			return "Too much data";
+		case AFC_E_END_OF_DATA:
+			return "End of data";
+		case AFC_E_OP_NOT_SUPPORTED:
+			return "Operation not supported";
+		case AFC_E_OBJECT_EXISTS:
+			return "Object exists";
+		case AFC_E_OBJECT_BUSY:
+			return "Object busy";
+		case AFC_E_NO_SPACE_LEFT:
+			return "No space left on device";
+		case AFC_E_OP_WOULD_BLOCK:
+			return "Operation would block";
+		case AFC_E_IO_ERROR:
+			return "I/O error";
+		case AFC_E_OP_INTERRUPTED:
+			return "Operation interrupted";
+		case AFC_E_OP_IN_PROGRESS:
+			return "Operation on progress";
+		case AFC_E_INTERNAL_ERROR:
+			return "Internal error";
+		case AFC_E_MUX_ERROR:
+			return "MUX error";
+		case AFC_E_NO_MEM:
+			return "Out of memory";
+		case AFC_E_NOT_ENOUGH_DATA:
+			return "Not enough data";
+		case AFC_E_DIR_NOT_EMPTY:
+			return "Directory not empty";
+		case AFC_E_FORCE_SIGNED_TYPE:
+			return "Force signed type";
+		default:
+			break;
+	}
+	return "Unknown Error";
+}

afc.h

@@ -0,0 +1,110 @@
+/*
+ * afc.h
+ * Defines and structs and the like for the built-in AFC client
+ *
+ * Copyright (c) 2014 Martin Szulecki All Rights Reserved.
+ * Copyright (c) 2008 Zach C. All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef __AFC_H
+#define __AFC_H
+
+#include <stdint.h>
+
+#include "libimobiledevice/afc.h"
+#include "service.h"
+#include "endianness.h"
+#include <libimobiledevice-glue/thread.h>
+
+#define AFC_MAGIC "CFA6LPAA"
+#define AFC_MAGIC_LEN (8)
+
+typedef struct {
+	char magic[AFC_MAGIC_LEN];
+	uint64_t entire_length, this_length, packet_num, operation;
+} AFCPacket;
+
+#define AFCPacket_to_LE(x) \
+ 	(x)->entire_length = htole64((x)->entire_length); \
+	(x)->this_length   = htole64((x)->this_length); \
+	(x)->packet_num    = htole64((x)->packet_num); \
+	(x)->operation     = htole64((x)->operation);
+
+#define AFCPacket_from_LE(x) \
+	(x)->entire_length = le64toh((x)->entire_length); \
+	(x)->this_length   = le64toh((x)->this_length); \
+	(x)->packet_num    = le64toh((x)->packet_num); \
+	(x)->operation     = le64toh((x)->operation);
+
+struct afc_client_private {
+	service_client_t parent;
+	AFCPacket *afc_packet;
+	uint32_t packet_extra;
+	mutex_t mutex;
+	int free_parent;
+};
+
+/* AFC Operations */
+enum {
+	AFC_OP_INVALID                   = 0x00000000,	/* Invalid */
+	AFC_OP_STATUS                    = 0x00000001,	/* Status */
+	AFC_OP_DATA                      = 0x00000002,	/* Data */
+	AFC_OP_READ_DIR                  = 0x00000003,	/* ReadDir */
+	AFC_OP_READ_FILE                 = 0x00000004,	/* ReadFile */
+	AFC_OP_WRITE_FILE                = 0x00000005,	/* WriteFile */
+	AFC_OP_WRITE_PART                = 0x00000006,	/* WritePart */
+	AFC_OP_TRUNCATE                  = 0x00000007,	/* TruncateFile */
+	AFC_OP_REMOVE_PATH               = 0x00000008,	/* RemovePath */
+	AFC_OP_MAKE_DIR                  = 0x00000009,	/* MakeDir */
+	AFC_OP_GET_FILE_INFO             = 0x0000000A,	/* GetFileInfo */
+	AFC_OP_GET_DEVINFO               = 0x0000000B,	/* GetDeviceInfo */
+	AFC_OP_WRITE_FILE_ATOM           = 0x0000000C,	/* WriteFileAtomic (tmp file+rename) */
+	AFC_OP_FILE_OPEN                 = 0x0000000D,	/* FileRefOpen */
+	AFC_OP_FILE_OPEN_RES             = 0x0000000E,	/* FileRefOpenResult */
+	AFC_OP_FILE_READ                 = 0x0000000F,	/* FileRefRead */
+	AFC_OP_FILE_WRITE                = 0x00000010,	/* FileRefWrite */
+	AFC_OP_FILE_SEEK                 = 0x00000011,	/* FileRefSeek */
+	AFC_OP_FILE_TELL                 = 0x00000012,	/* FileRefTell */
+	AFC_OP_FILE_TELL_RES             = 0x00000013,	/* FileRefTellResult */
+	AFC_OP_FILE_CLOSE                = 0x00000014,	/* FileRefClose */
+	AFC_OP_FILE_SET_SIZE             = 0x00000015,	/* FileRefSetFileSize (ftruncate) */
+	AFC_OP_GET_CON_INFO              = 0x00000016,	/* GetConnectionInfo */
+	AFC_OP_SET_CON_OPTIONS           = 0x00000017,	/* SetConnectionOptions */
+	AFC_OP_RENAME_PATH               = 0x00000018,	/* RenamePath */
+	AFC_OP_SET_FS_BS                 = 0x00000019,	/* SetFSBlockSize (0x800000) */
+	AFC_OP_SET_SOCKET_BS             = 0x0000001A,	/* SetSocketBlockSize (0x800000) */
+	AFC_OP_FILE_LOCK                 = 0x0000001B,	/* FileRefLock */
+	AFC_OP_MAKE_LINK                 = 0x0000001C,	/* MakeLink */
+	AFC_OP_GET_FILE_HASH             = 0x0000001D,	/* GetFileHash */
+	AFC_OP_SET_FILE_MOD_TIME         = 0x0000001E,	/* SetModTime */
+	AFC_OP_GET_FILE_HASH_RANGE       = 0x0000001F,	/* GetFileHashWithRange */
+	/* iOS 6+ */
+	AFC_OP_FILE_SET_IMMUTABLE_HINT   = 0x00000020,	/* FileRefSetImmutableHint */
+	AFC_OP_GET_SIZE_OF_PATH_CONTENTS = 0x00000021,	/* GetSizeOfPathContents */
+	AFC_OP_REMOVE_PATH_AND_CONTENTS  = 0x00000022,	/* RemovePathAndContents */
+	AFC_OP_DIR_OPEN                  = 0x00000023,	/* DirectoryEnumeratorRefOpen */
+	AFC_OP_DIR_OPEN_RESULT           = 0x00000024,	/* DirectoryEnumeratorRefOpenResult */
+	AFC_OP_DIR_READ                  = 0x00000025,	/* DirectoryEnumeratorRefRead */
+	AFC_OP_DIR_CLOSE                 = 0x00000026,	/* DirectoryEnumeratorRefClose */
+	/* iOS 7+ */
+	AFC_OP_FILE_READ_OFFSET          = 0x00000027,	/* FileRefReadWithOffset */
+	AFC_OP_FILE_WRITE_OFFSET         = 0x00000028	/* FileRefWriteWithOffset */
+};
+
+afc_error_t afc_client_new_with_service_client(service_client_t service_client, afc_client_t *client);
+
+#endif

afc.pxi

@@ -0,0 +1,337 @@
+cdef extern from "libimobiledevice/afc.h":
+    cdef struct afc_client_private:
+        pass
+    ctypedef afc_client_private *afc_client_t
+    ctypedef enum afc_error_t:
+        AFC_E_SUCCESS = 0
+        AFC_E_UNKNOWN_ERROR = 1
+        AFC_E_OP_HEADER_INVALID = 2
+        AFC_E_NO_RESOURCES = 3
+        AFC_E_READ_ERROR = 4
+        AFC_E_WRITE_ERROR = 5
+        AFC_E_UNKNOWN_PACKET_TYPE = 6
+        AFC_E_INVALID_ARG = 7
+        AFC_E_OBJECT_NOT_FOUND = 8
+        AFC_E_OBJECT_IS_DIR = 9
+        AFC_E_PERM_DENIED = 10
+        AFC_E_SERVICE_NOT_CONNECTED = 11
+        AFC_E_OP_TIMEOUT = 12
+        AFC_E_TOO_MUCH_DATA = 13
+        AFC_E_END_OF_DATA = 14
+        AFC_E_OP_NOT_SUPPORTED = 15
+        AFC_E_OBJECT_EXISTS = 16
+        AFC_E_OBJECT_BUSY = 17
+        AFC_E_NO_SPACE_LEFT = 18
+        AFC_E_OP_WOULD_BLOCK = 19
+        AFC_E_IO_ERROR = 20
+        AFC_E_OP_INTERRUPTED = 21
+        AFC_E_OP_IN_PROGRESS = 22
+        AFC_E_INTERNAL_ERROR = 23
+        AFC_E_MUX_ERROR = 30
+        AFC_E_NO_MEM = 31
+        AFC_E_NOT_ENOUGH_DATA = 32
+        AFC_E_DIR_NOT_EMPTY = 33
+    ctypedef enum afc_file_mode_t:
+        AFC_FOPEN_RDONLY   = 0x00000001
+        AFC_FOPEN_RW       = 0x00000002
+        AFC_FOPEN_WRONLY   = 0x00000003
+        AFC_FOPEN_WR       = 0x00000004
+        AFC_FOPEN_APPEND   = 0x00000005
+        AFC_FOPEN_RDAPPEND = 0x00000006
+    ctypedef enum afc_link_type_t:
+        AFC_HARDLINK = 1
+        AFC_SYMLINK = 2
+    ctypedef enum afc_lock_op_t:
+        AFC_LOCK_SH = 1 | 4
+        AFC_LOCK_EX = 2 | 4
+        AFC_LOCK_UN = 8 | 4
+
+    afc_error_t afc_client_new(idevice_t device, lockdownd_service_descriptor_t descriptor, afc_client_t *client)
+    afc_error_t afc_client_free(afc_client_t client)
+    afc_error_t afc_get_device_info(afc_client_t client, char ***infos)
+    afc_error_t afc_read_directory(afc_client_t client, char *dir, char ***list)
+    afc_error_t afc_get_file_info(afc_client_t client, char *filename, char ***infolist)
+    afc_error_t afc_remove_path(afc_client_t client, char *path)
+    afc_error_t afc_remove_path_and_contents(afc_client_t client, char *path)
+    afc_error_t afc_rename_path(afc_client_t client, char *f, char *to)
+    afc_error_t afc_make_directory(afc_client_t client, char *dir)
+    afc_error_t afc_truncate(afc_client_t client, char *path, uint64_t newsize)
+    afc_error_t afc_make_link(afc_client_t client, afc_link_type_t linktype, char *target, char *linkname)
+    afc_error_t afc_set_file_time(afc_client_t client, char *path, uint64_t mtime)
+
+    afc_error_t afc_file_open(afc_client_t client, char *filename, afc_file_mode_t file_mode, uint64_t *handle)
+    afc_error_t afc_file_close(afc_client_t client, uint64_t handle)
+    afc_error_t afc_file_lock(afc_client_t client, uint64_t handle, afc_lock_op_t operation)
+    afc_error_t afc_file_read(afc_client_t client, uint64_t handle, char *data, uint32_t length, uint32_t *bytes_read)
+    afc_error_t afc_file_write(afc_client_t client, uint64_t handle, char *data, uint32_t length, uint32_t *bytes_written)
+    afc_error_t afc_file_seek(afc_client_t client, uint64_t handle, int64_t offset, int whence)
+    afc_error_t afc_file_tell(afc_client_t client, uint64_t handle, uint64_t *position)
+    afc_error_t afc_file_truncate(afc_client_t client, uint64_t handle, uint64_t newsize)
+
+LOCK_SH = AFC_LOCK_SH
+LOCK_EX = AFC_LOCK_EX
+LOCK_UN = AFC_LOCK_UN
+
+cdef class AfcError(BaseError):
+    def __init__(self, *args, **kwargs):
+        self._lookup_table = {
+            AFC_E_SUCCESS: "Success",
+            AFC_E_UNKNOWN_ERROR: "Unknown error",
+            AFC_E_OP_HEADER_INVALID: "OP header invalid",
+            AFC_E_NO_RESOURCES: "No resources",
+            AFC_E_READ_ERROR: "Read error",
+            AFC_E_WRITE_ERROR: "Write error",
+            AFC_E_UNKNOWN_PACKET_TYPE: "Unknown packet type",
+            AFC_E_INVALID_ARG: "Invalid argument",
+            AFC_E_OBJECT_NOT_FOUND: "Object not found",
+            AFC_E_OBJECT_IS_DIR: "Object is directory",
+            AFC_E_PERM_DENIED: "Permission denied",
+            AFC_E_SERVICE_NOT_CONNECTED: "Service not connected",
+            AFC_E_OP_TIMEOUT: "OP timeout",
+            AFC_E_TOO_MUCH_DATA: "Too much data",
+            AFC_E_END_OF_DATA: "End of data",
+            AFC_E_OP_NOT_SUPPORTED: "OP not supported",
+            AFC_E_OBJECT_EXISTS: "Object exists",
+            AFC_E_OBJECT_BUSY: "Object busy",
+            AFC_E_NO_SPACE_LEFT: "No space left",
+            AFC_E_OP_WOULD_BLOCK: "OP would block",
+            AFC_E_IO_ERROR: "IO error",
+            AFC_E_OP_INTERRUPTED: "OP interrupted",
+            AFC_E_OP_IN_PROGRESS: "OP in progress",
+            AFC_E_INTERNAL_ERROR: "Internal error",
+            AFC_E_MUX_ERROR: "MUX error",
+            AFC_E_NO_MEM: "No memory",
+            AFC_E_NOT_ENOUGH_DATA: "Not enough data",
+            AFC_E_DIR_NOT_EMPTY: "Directory not empty"
+        }
+        BaseError.__init__(self, *args, **kwargs)
+
+# forward declaration of AfcClient
+cdef class AfcClient(BaseService)
+
+cdef class AfcFile(Base):
+    cdef uint64_t _c_handle
+    cdef AfcClient _client
+    cdef bytes _filename
+
+    def __init__(self, *args, **kwargs):
+        raise TypeError("AfcFile cannot be instantiated")
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, type, value, traceback):
+        self.close()
+
+    cpdef close(self):
+        self.handle_error(afc_file_close(self._client._c_client, self._c_handle))
+
+    cpdef lock(self, int operation):
+        self.handle_error(afc_file_lock(self._client._c_client, self._c_handle, <afc_lock_op_t>operation))
+
+    cpdef seek(self, int64_t offset, int whence):
+        self.handle_error(afc_file_seek(self._client._c_client, self._c_handle, offset, whence))
+
+    cpdef uint64_t tell(self):
+        cdef uint64_t position
+        self.handle_error(afc_file_tell(self._client._c_client, self._c_handle, &position))
+        return position
+
+    cpdef truncate(self, uint64_t newsize):
+        self.handle_error(afc_file_truncate(self._client._c_client, self._c_handle, newsize))
+
+    cpdef bytes read(self, uint32_t size):
+        cdef:
+            uint32_t bytes_read
+            char* c_data = <char *>malloc(size)
+            bytes result
+        try:
+            self.handle_error(afc_file_read(self._client._c_client, self._c_handle, c_data, size, &bytes_read))
+            result = c_data[:bytes_read]
+            return result
+        except BaseError, e:
+            raise
+        finally:
+            free(c_data)
+
+    cpdef uint32_t write(self, bytes data):
+        cdef:
+            uint32_t bytes_written
+            char* c_data = data
+        try:
+            self.handle_error(afc_file_write(self._client._c_client, self._c_handle, c_data, len(data), &bytes_written))
+        except BaseError, e:
+            raise
+
+        return bytes_written
+
+    cdef inline BaseError _error(self, int16_t ret):
+        return AfcError(ret)
+
+cdef class AfcClient(BaseService):
+    __service_name__ = "com.apple.afc"
+    cdef afc_client_t _c_client
+
+    def __cinit__(self, iDevice device = None, LockdownServiceDescriptor descriptor = None, *args, **kwargs):
+        if (device is not None and descriptor is not None):
+            self.handle_error(afc_client_new(device._c_dev, descriptor._c_service_descriptor, &(self._c_client)))
+    
+    def __dealloc__(self):
+        cdef afc_error_t err
+        if self._c_client is not NULL:
+            err = afc_client_free(self._c_client)
+            self.handle_error(err)
+
+    cdef BaseError _error(self, int16_t ret):
+        return AfcError(ret)
+
+    cpdef list get_device_info(self):
+        cdef:
+            afc_error_t err
+            char** infos = NULL
+            bytes info
+            int i = 0
+            list result = []
+        err = afc_get_device_info(self._c_client, &infos)
+        try:
+            self.handle_error(err)
+        except BaseError, e:
+            raise
+        finally:
+            if infos != NULL:
+                while infos[i]:
+                    info = infos[i]
+                    result.append(info)
+                    free(infos[i])
+                    i = i + 1
+                free(infos)
+
+        return result
+
+    cpdef list read_directory(self, bytes directory):
+        cdef:
+            afc_error_t err
+            char** dir_list = NULL
+            bytes f
+            int i = 0
+            list result = []
+        err = afc_read_directory(self._c_client, directory, &dir_list)
+        try:
+            self.handle_error(err)
+        except BaseError, e:
+            raise
+        finally:
+            if dir_list != NULL:
+                while dir_list[i]:
+                    f = dir_list[i]
+                    result.append(f)
+                    free(dir_list[i])
+                    i = i + 1
+                free(dir_list)
+
+        return result
+
+    cpdef AfcFile open(self, bytes filename, bytes mode=b'r'):
+        cdef:
+            afc_file_mode_t c_mode
+            uint64_t handle
+            AfcFile f
+        if mode == b'r':
+            c_mode = AFC_FOPEN_RDONLY
+        elif mode == b'r+':
+            c_mode = AFC_FOPEN_RW
+        elif mode == b'w':
+            c_mode = AFC_FOPEN_WRONLY
+        elif mode == b'w+':
+            c_mode = AFC_FOPEN_WR
+        elif mode == b'a':
+            c_mode = AFC_FOPEN_APPEND
+        elif mode == b'a+':
+            c_mode = AFC_FOPEN_RDAPPEND
+        else:
+            raise ValueError("mode string must be 'r', 'r+', 'w', 'w+', 'a', or 'a+'")
+
+        self.handle_error(afc_file_open(self._c_client, filename, c_mode, &handle))
+        f = AfcFile.__new__(AfcFile)
+        f._c_handle = handle
+        f._client = self
+        f._filename = filename
+
+        return f
+
+    cpdef list get_file_info(self, bytes path):
+        cdef:
+            list result = []
+            char** c_result = NULL
+            int i = 0
+            bytes info
+        try:
+            self.handle_error(afc_get_file_info(self._c_client, path, &c_result))
+        except BaseError, e:
+            raise
+        finally:
+            if c_result != NULL:
+                while c_result[i]:
+                    info = c_result[i]
+                    result.append(info)
+                    free(c_result[i])
+                    i = i + 1
+                free(c_result)
+
+        return result
+
+    cpdef remove_path(self, bytes path):
+        self.handle_error(afc_remove_path(self._c_client, path))
+
+    cpdef remove_path_and_contents(self, bytes path):
+        self.handle_error(afc_remove_path_and_contents(self._c_client, path))
+
+    cpdef rename_path(self, bytes f, bytes t):
+        self.handle_error(afc_rename_path(self._c_client, f, t))
+
+    cpdef make_directory(self, bytes d):
+        self.handle_error(afc_make_directory(self._c_client, d))
+
+    cpdef truncate(self, bytes path, uint64_t newsize):
+        self.handle_error(afc_truncate(self._c_client, path, newsize))
+
+    cpdef link(self, bytes source, bytes link_name):
+        self.handle_error(afc_make_link(self._c_client, AFC_HARDLINK, source, link_name))
+
+    cpdef symlink(self, bytes source, bytes link_name):
+        self.handle_error(afc_make_link(self._c_client, AFC_SYMLINK, source, link_name))
+
+    cpdef set_file_time(self, bytes path, uint64_t mtime):
+        self.handle_error(afc_set_file_time(self._c_client, path, mtime))
+
+cdef class Afc2Client(AfcClient):
+    __service_name__ = "com.apple.afc2"
+
+    cpdef AfcFile open(self, bytes filename, bytes mode=b'r'):
+        cdef:
+            afc_file_mode_t c_mode
+            uint64_t handle
+            AfcFile f
+        if mode == b'r':
+            c_mode = AFC_FOPEN_RDONLY
+        elif mode == b'r+':
+            c_mode = AFC_FOPEN_RW
+        elif mode == b'w':
+            c_mode = AFC_FOPEN_WRONLY
+        elif mode == b'w+':
+            c_mode = AFC_FOPEN_WR
+        elif mode == b'a':
+            c_mode = AFC_FOPEN_APPEND
+        elif mode == b'a+':
+            c_mode = AFC_FOPEN_RDAPPEND
+        else:
+            raise ValueError("mode string must be 'r', 'r+', 'w', 'w+', 'a', or 'a+'")
+
+        self.handle_error(afc_file_open(self._c_client, filename, c_mode, &handle))
+        f = AfcFile.__new__(AfcFile)
+        f._c_handle = handle
+        f._client = <AfcClient>self
+        f._filename = filename
+
+        return f
+

afcclient.c

@@ -0,0 +1,1630 @@
+/*
+ * afcclient.c
+ * Utility to interact with AFC/HoustArrest service on the device
+ *
+ * Inspired by https://github.com/emonti/afcclient
+ * But entirely rewritten from scratch.
+ *
+ * Copyright (c) 2023 Nikias Bassen, All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define TOOL_NAME "afcclient"
+
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <getopt.h>
+#include <signal.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <time.h>
+#include <sys/stat.h>
+
+#ifdef _WIN32
+#include <windows.h>
+#include <sys/time.h>
+#include <conio.h>
+#define sleep(x) Sleep(x*1000)
+#define S_IFMT          0170000         /* [XSI] type of file mask */
+#define S_IFIFO         0010000         /* [XSI] named pipe (fifo) */
+#define S_IFCHR         0020000         /* [XSI] character special */
+#define S_IFBLK         0060000         /* [XSI] block special */
+#define S_IFLNK         0120000         /* [XSI] symbolic link */
+#define S_IFSOCK        0140000         /* [XSI] socket */
+#define S_ISBLK(m)      (((m) & S_IFMT) == S_IFBLK)     /* block special */
+#define S_ISCHR(m)      (((m) & S_IFMT) == S_IFCHR)     /* char special */
+#define S_ISFIFO(m)     (((m) & S_IFMT) == S_IFIFO)     /* fifo or socket */
+#define S_ISLNK(m)      (((m) & S_IFMT) == S_IFLNK)     /* symbolic link */
+#define S_ISSOCK(m)     (((m) & S_IFMT) == S_IFSOCK)    /* socket */
+#else
+#include <sys/time.h>
+#include <termios.h>
+#endif
+
+#ifdef HAVE_READLINE
+#include <readline/readline.h>
+#include <readline/history.h>
+#endif
+
+#include <libimobiledevice/libimobiledevice.h>
+#include <libimobiledevice/lockdown.h>
+#include <libimobiledevice/house_arrest.h>
+#include <libimobiledevice/afc.h>
+#include <plist/plist.h>
+
+#include <libimobiledevice-glue/termcolors.h>
+#include <libimobiledevice-glue/utils.h>
+
+#undef st_mtime
+#undef st_birthtime
+struct afc_file_stat {
+	uint16_t st_mode;
+	uint16_t st_nlink;
+	uint64_t st_size;
+	uint64_t st_mtime;
+	uint64_t st_birthtime;
+	uint32_t st_blocks;
+};
+
+static char* udid = NULL;
+static int connected = 0;
+static int use_network = 0;
+static idevice_subscription_context_t context = NULL;
+static char* curdir = NULL;
+static size_t curdir_len = 0;
+
+static int file_exists(const char* path)
+{
+	struct stat tst;
+#ifdef _WIN32
+	return (stat(path, &tst) == 0);
+#else
+	return (lstat(path, &tst) == 0);
+#endif
+}
+
+static int is_directory(const char* path)
+{
+	struct stat tst;
+#ifdef _WIN32
+	return (stat(path, &tst) == 0) && S_ISDIR(tst.st_mode);
+#else
+	return (lstat(path, &tst) == 0) && S_ISDIR(tst.st_mode);
+#endif
+}
+
+static void print_usage(int argc, char **argv, int is_error)
+{
+	char *name = strrchr(argv[0], '/');
+	fprintf(is_error ? stderr : stdout, "Usage: %s [OPTIONS]\n", (name ? name + 1: argv[0]));
+	fprintf(is_error ? stderr : stdout,
+		"\n"
+		"Interact with AFC/HouseArrest service on a connected device.\n"
+		"\n"
+		"OPTIONS:\n"
+		"  -u, --udid UDID       target specific device by UDID\n"
+		"  -n, --network         connect to network device (not recommended!)\n"
+		"  --container <appid>   Access container of given app\n"
+		"  --documents <appid>   Access Documents directory of given app\n"
+		"  -h, --help            prints usage information\n" \
+		"  -d, --debug           enable communication debugging\n" \
+		"  -v, --version         prints version information\n" \
+		"\n"
+	);
+	fprintf(is_error ? stderr : stdout,
+		"\n" \
+		"Homepage:    <" PACKAGE_URL ">\n"
+		"Bug Reports: <" PACKAGE_BUGREPORT ">\n"
+	);
+}
+
+#ifndef HAVE_READLINE
+#ifdef _WIN32
+#define BS_CC '\b'
+#else
+#define BS_CC 0x7f
+#define getch getchar
+#endif
+static void get_input(char *buf, int maxlen)
+{
+	int len = 0;
+	int c;
+
+	while ((c = getch())) {
+		if ((c == '\r') || (c == '\n')) {
+			break;
+		}
+		if (isprint(c)) {
+			if (len < maxlen-1)
+				buf[len++] = c;
+		} else if (c == BS_CC) {
+			if (len > 0) {
+				fputs("\b \b", stdout);
+				len--;
+			}
+		}
+	}
+	buf[len] = 0;
+}
+#endif
+
+#define OPT_DOCUMENTS 1
+#define OPT_CONTAINER 2
+
+int stop_requested = 0;
+
+static void handle_signal(int sig)
+{
+	stop_requested++;
+#ifdef _WIN32
+	GenerateConsoleCtrlEvent(CTRL_C_EVENT, 0);
+#else
+	kill(getpid(), SIGINT);
+#endif
+}
+
+static void handle_help(afc_client_t afc, int argc, char** argv)
+{
+	printf("Available commands:\n");
+	printf("help - print list of available commands\n");
+	printf("devinfo - print device information\n");
+	printf("info PATH - print file attributes of file at PATH\n");
+	printf("ls [-l] PATH - print directory contents of PATH\n");
+	printf("mv OLD NEW - rename file OLD to NEW\n");
+	printf("mkdir PATH - create directory at PATH\n");
+	printf("ln [-s] FILE [LINK] - create a (symbolic) link to file named LINKNAME\n");
+	printf("        NOTE: This feature has been disabled in newer versions of iOS.\n");
+	printf("rm PATH - remove item at PATH\n");
+	printf("get [-rf] PATH [LOCALPATH] - transfer file at PATH from device to LOCALPATH\n");
+	printf("put [-rf] LOCALPATH [PATH] - transfer local file at LOCALPATH to device at PATH\n");
+	printf("\n");
+}
+
+static const char* path_get_basename(const char* path)
+{
+	const char *p = strrchr(path, '/');
+	return p ? p + 1 : path;
+}
+
+static int timeval_subtract(struct timeval *result, struct timeval *x, struct timeval *y)
+{
+	/* Perform the carry for the later subtraction by updating y. */
+	if (x->tv_usec < y->tv_usec) {
+		int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1;
+		y->tv_usec -= 1000000 * nsec;
+		y->tv_sec += nsec;
+	}
+	if (x->tv_usec - y->tv_usec > 1000000) {
+		int nsec = (x->tv_usec - y->tv_usec) / 1000000;
+		y->tv_usec += 1000000 * nsec;
+		y->tv_sec -= nsec;
+	}
+	/* Compute the time remaining to wait.
+	   tv_usec is certainly positive. */
+	result->tv_sec = x->tv_sec - y->tv_sec;
+	result->tv_usec = x->tv_usec - y->tv_usec;
+	/* Return 1 if result is negative. */
+	return x->tv_sec < y->tv_sec;
+}
+
+struct str_item {
+	size_t len;
+	char* str;
+};
+
+static char* get_absolute_path(const char *path)
+{
+	if (*path == '/') {
+		return strdup(path);
+	} else {
+		size_t len = curdir_len + 1 + strlen(path) + 1;
+		char* result = (char*)malloc(len);
+		if (!strcmp(curdir, "/")) {
+			snprintf(result, len, "/%s", path);
+		} else {
+			snprintf(result, len, "%s/%s", curdir, path);
+		}
+		return result;
+	}
+}
+
+static char* get_realpath(const char* path)
+{
+	if (!path) return NULL;
+
+	int is_absolute = 0;
+	if (*path == '/') {
+		is_absolute = 1;
+	}
+
+	const char* p = path;
+	if (is_absolute) {
+		while (*p == '/') p++;
+	}
+	if (*p == '\0') {
+		return strdup("/");
+	}
+
+	int c_count = 1;
+	const char* start = p;
+	const char* end = p;
+	struct str_item* comps = NULL;
+
+	while (*p) {
+		if (*p == '/') {
+			p++;
+			end = p-1;
+			while (*p == '/') p++;
+			if (*p == '\0') break;
+			struct str_item* newcomps = (struct str_item*)realloc(comps, sizeof(struct str_item)*c_count);
+			if (!newcomps) {
+				free(comps);
+				printf("%s: out of memory?!\n", __func__);
+				return NULL;
+			}
+			comps = newcomps;
+			char *comp = (char*)malloc(end-start+1);
+			strncpy(comp, start, end-start);
+			comp[end-start] = '\0';
+			comps[c_count-1].len = end-start;
+			comps[c_count-1].str = comp;
+			c_count++;
+			start = p;
+			end = p;
+		}
+		p++;
+	}
+	if (p > start) {
+		if (start == end) {
+			end = p;
+		}
+		struct str_item* newcomps = (struct str_item*)realloc(comps, sizeof(struct str_item)*c_count);
+		if (!newcomps) {
+			free(comps);
+			printf("%s: out of memory?!\n", __func__);
+			return NULL;
+		}
+		comps = newcomps;
+		char *comp = (char*)malloc(end-start+1);
+		strncpy(comp, start, end-start);
+		comp[end-start] = '\0';
+		comps[c_count-1].len = end-start;
+		comps[c_count-1].str = comp;
+	}
+
+	struct str_item* comps_final = (struct str_item*)malloc(sizeof(struct str_item)*(c_count+1));
+	int o = 1;
+	if (is_absolute) {
+		comps_final[0].len = 1;
+		comps_final[0].str = (char*)"/";
+	} else {
+		comps_final[0].len = curdir_len;
+		comps_final[0].str = curdir;
+	}
+	size_t o_len = comps_final[0].len;
+
+	for (int i = 0; i < c_count; i++) {
+		if (!strcmp(comps[i].str, "..")) {
+			o--;
+			continue;
+		} else if (!strcmp(comps[i].str, ".")) {
+			continue;
+		}
+		o_len += comps[i].len;
+		comps_final[o].str = comps[i].str;
+		comps_final[o].len = comps[i].len;
+		o++;
+	}
+
+	o_len += o;
+	char* result = (char*)malloc(o_len);
+	char* presult = result;
+	for (int i = 0; i < o; i++) {
+		if (i > 0 && strcmp(comps_final[i-1].str, "/") != 0) {
+			*presult = '/';
+			presult++;
+		}
+		strncpy(presult, comps_final[i].str, comps_final[i].len);
+		presult+=comps_final[i].len;
+		*presult = '\0';
+	}
+	if (presult == result) {
+		*presult = '/';
+		presult++;
+		*presult = 0;
+	}
+
+	for (int i = 0; i < c_count; i++) {
+		free(comps[i].str);
+	}
+	free(comps);
+	free(comps_final);
+
+	return result;
+}
+
+static void handle_devinfo(afc_client_t afc, int argc, char** argv)
+{
+	plist_t info = NULL;
+	afc_error_t err = afc_get_device_info_plist(afc, &info);
+	if (err == AFC_E_SUCCESS && info) {
+		if (argc > 0 && !strcmp(argv[0], "--plain")) {
+			plist_write_to_stream(info, stdout, PLIST_FORMAT_LIMD, PLIST_OPT_NONE);
+		} else {
+			plist_write_to_stream(info, stdout, PLIST_FORMAT_JSON, PLIST_OPT_NONE);
+		}
+	} else {
+		printf("Error: Failed to get device info: %s (%d)\n", afc_strerror(err), err);
+	}
+	plist_free(info);
+}
+
+static int get_file_info_stat(afc_client_t afc, const char* path, struct afc_file_stat *stbuf)
+{
+	plist_t info = NULL;
+	afc_error_t ret = afc_get_file_info_plist(afc, path, &info);
+	memset(stbuf, 0, sizeof(struct afc_file_stat));
+	if (ret != AFC_E_SUCCESS) {
+		return -1;
+	} else if (!info) {
+		return -1;
+	}
+	stbuf->st_size = plist_dict_get_uint(info, "st_size");
+	stbuf->st_blocks = plist_dict_get_uint(info, "st_blocks");
+	const char* s_ifmt = plist_get_string_ptr(plist_dict_get_item(info, "st_ifmt"), NULL);
+	if (s_ifmt) {
+		if (!strcmp(s_ifmt, "S_IFREG")) {
+			stbuf->st_mode = S_IFREG;
+		} else if (!strcmp(s_ifmt, "S_IFDIR")) {
+			stbuf->st_mode = S_IFDIR;
+		} else if (!strcmp(s_ifmt, "S_IFLNK")) {
+			stbuf->st_mode = S_IFLNK;
+		} else if (!strcmp(s_ifmt, "S_IFBLK")) {
+			stbuf->st_mode = S_IFBLK;
+		} else if (!strcmp(s_ifmt, "S_IFCHR")) {
+			stbuf->st_mode = S_IFCHR;
+		} else if (!strcmp(s_ifmt, "S_IFIFO")) {
+			stbuf->st_mode = S_IFIFO;
+		} else if (!strcmp(s_ifmt, "S_IFSOCK")) {
+			stbuf->st_mode = S_IFSOCK;
+		}
+	}
+	stbuf->st_nlink = plist_dict_get_uint(info, "st_nlink");
+	stbuf->st_mtime = (time_t)(plist_dict_get_uint(info, "st_mtime") / 1000000000);
+	/* available on iOS 7+ */
+	stbuf->st_birthtime = (time_t)(plist_dict_get_uint(info, "st_birthtime") / 1000000000);
+	plist_free(info);
+	return 0;
+}
+
+static void handle_file_info(afc_client_t afc, int argc, char** argv)
+{
+	if (argc < 1) {
+		printf("Error: Missing PATH.\n");
+		return;
+	}
+
+	plist_t info = NULL;
+	char* abspath = get_absolute_path(argv[0]);
+	if (!abspath) {
+		printf("Error: Invalid argument\n");
+		return;
+	}
+	afc_error_t err = afc_get_file_info_plist(afc, abspath, &info);
+	if (err == AFC_E_SUCCESS && info) {
+		if (argc > 1 && !strcmp(argv[1], "--plain")) {
+			plist_write_to_stream(info, stdout, PLIST_FORMAT_LIMD, PLIST_OPT_NONE);
+		} else {
+			plist_write_to_stream(info, stdout, PLIST_FORMAT_JSON, PLIST_OPT_NONE);
+		}
+	} else {
+		printf("Error: Failed to get file info for %s: %s (%d)\n", argv[0], afc_strerror(err), err);
+	}
+	plist_free(info);
+	free(abspath);
+}
+
+static void print_file_info(afc_client_t afc, const char* path, int list_verbose)
+{
+	struct afc_file_stat st;
+	get_file_info_stat(afc, path, &st);
+	if (list_verbose) {
+		char timebuf[64];
+		time_t t = st.st_mtime;
+		if (S_ISDIR(st.st_mode)) {
+			printf("drwxr-xr-x");
+		} else if (S_ISLNK(st.st_mode)) {
+			printf("lrwxrwxrwx");
+		} else {
+			if (S_ISFIFO(st.st_mode)) {
+				printf("f");
+			} else if (S_ISBLK(st.st_mode)) {
+				printf("b");
+			} else if (S_ISCHR(st.st_mode)) {
+				printf("c");
+			} else if (S_ISSOCK(st.st_mode)) {
+				printf("s");
+			} else {
+				printf("-");
+			}
+			printf("rw-r--r--");
+		}
+		printf(" ");
+		printf("%4d", st.st_nlink);
+		printf(" ");
+		printf("mobile");
+		printf(" ");
+		printf("mobile");
+		printf(" ");
+		printf("%10lld", (long long)st.st_size);
+		printf(" ");
+#ifdef _WIN32
+		strftime(timebuf, 64, "%d %b %Y %H:%M:%S", localtime(&t));
+#else
+		strftime(timebuf, 64, "%d %h %Y %H:%M:%S", localtime(&t));
+#endif
+		printf("%s", timebuf);
+		printf(" ");
+	}
+	if (S_ISDIR(st.st_mode)) {
+		cprintf(FG_CYAN);
+	} else if (S_ISLNK(st.st_mode)) {
+		cprintf(FG_MAGENTA);
+	} else if (S_ISREG(st.st_mode)) {
+		cprintf(FG_DEFAULT);
+	} else {
+		cprintf(FG_YELLOW);
+	}
+	cprintf("%s" COLOR_RESET "\n", path_get_basename(path));
+}
+
+static void handle_list(afc_client_t afc, int argc, char** argv)
+{
+	const char* path = NULL;
+	int list_verbose = 0;
+	if (argc < 1) {
+		path = curdir;
+	} else {
+		if (!strcmp(argv[0], "-l")) {
+			list_verbose = 1;
+			if (argc == 2) {
+				path = argv[1];
+			} else {
+				path = curdir;
+			}
+		} else {
+			path = argv[0];
+		}
+	}
+	char* abspath = get_absolute_path(path);
+	if (!abspath) {
+		printf("Error: Invalid argument\n");
+		return;
+	}
+	int abspath_is_root = strcmp(abspath, "/") == 0;
+	size_t abspath_len = (abspath_is_root) ? 0 : strlen(abspath);
+	char** entries = NULL;
+	afc_error_t err = afc_read_directory(afc, abspath, &entries);
+	if (err == AFC_E_READ_ERROR) {
+		print_file_info(afc, abspath, list_verbose);
+		return;
+	} else if (err != AFC_E_SUCCESS) {
+		printf("Error: Failed to list '%s': %s (%d)\n", path, afc_strerror(err), err);
+		free(abspath);
+		return;
+	}
+
+	char** p = entries;
+	while (p && *p) {
+		if (strcmp(".", *p) == 0 || strcmp("..", *p) == 0) {
+			p++;
+			continue;
+		}
+		size_t len = abspath_len + 1 + strlen(*p) + 1;
+		char* testpath = (char*)malloc(len);
+		if (abspath_is_root) {
+			snprintf(testpath, len, "/%s", *p);
+		} else {
+			snprintf(testpath, len, "%s/%s", abspath, *p);
+		}
+		print_file_info(afc, testpath, list_verbose);
+		free(testpath);
+		p++;
+	}
+	afc_dictionary_free(entries);
+	free(abspath);
+}
+
+static void handle_rename(afc_client_t afc, int argc, char** argv)
+{
+	if (argc != 2) {
+		printf("Error: Invalid number of arguments\n");
+		return;
+	}
+	char* srcpath = get_absolute_path(argv[0]);
+	if (!srcpath) {
+		printf("Error: Invalid argument\n");
+		return;
+	}
+	char* dstpath = get_absolute_path(argv[1]);
+	if (!dstpath) {
+		free(srcpath);
+		printf("Error: Invalid argument\n");
+		return;
+	}
+	afc_error_t err = afc_rename_path(afc, srcpath, dstpath);
+	if (err != AFC_E_SUCCESS) {
+		printf("Error: Failed to rename '%s' -> '%s': %s (%d)\n", argv[0], argv[1], afc_strerror(err), err);
+	}
+	free(srcpath);
+	free(dstpath);
+}
+
+static void handle_mkdir(afc_client_t afc, int argc, char** argv)
+{
+	for (int i = 0; i < argc; i++) {
+		char* abspath = get_absolute_path(argv[i]);
+		if (!abspath) {
+			printf("Error: Invalid argument '%s'\n", argv[i]);
+			continue;
+		}
+		afc_error_t err = afc_make_directory(afc, abspath);
+		if (err != AFC_E_SUCCESS) {
+			printf("Error: Failed to create directory '%s': %s (%d)\n", argv[i], afc_strerror(err), err);
+		}
+		free(abspath);
+	}
+}
+
+static void handle_link(afc_client_t afc, int argc, char** argv)
+{
+	if (argc < 2) {
+		printf("Error: Invalid number of arguments\n");
+		return;
+	}
+	afc_link_type_t link_type = AFC_HARDLINK;
+	if (!strcmp(argv[0], "-s")) {
+		argc--;
+		argv++;
+		link_type = AFC_SYMLINK;
+	}
+	if (argc < 1 || argc > 2) {
+		printf("Error: Invalid number of arguments\n");
+		return;
+	}
+	const char *link_name = (argc == 1) ? path_get_basename(argv[0]) : argv[1];
+	char* abs_link_name = get_absolute_path(link_name);
+	if (!abs_link_name) {
+		printf("Error: Invalid argument\n");
+		return;
+	}
+	afc_error_t err = afc_make_link(afc, link_type, argv[0], link_name);
+	if (err != AFC_E_SUCCESS) {
+		printf("Error: Failed to create %s link for '%s' at '%s': %s (%d)\n", (link_type == AFC_HARDLINK) ? "hard" : "symbolic", argv[0], link_name, afc_strerror(err), err);
+	}
+}
+
+static int ask_yesno(const char* prompt)
+{
+	int ret = 0;
+#ifdef HAVE_READLINE
+	char* result = readline(prompt);
+	if (result && result[0] == 'y') {
+		ret = 1;
+	}
+#else
+	char cmdbuf[2] = {0, };
+	printf("%s", prompt);
+	fflush(stdout);
+	get_input(cmdbuf, sizeof(cmdbuf));
+	if (cmdbuf[0] == 'y') {
+		ret = 1;
+	}
+#endif
+#ifdef HAVE_READLINE
+	free(result);
+#endif
+	return ret;
+}
+
+static void handle_remove(afc_client_t afc, int argc, char** argv)
+{
+	int recursive = 0;
+	int force = 0;
+	int i = 0;
+	for (i = 0; i < argc; i++) {
+		if (!strcmp(argv[i], "--")) {
+			i++;
+			break;
+		} else if (!strcmp(argv[i], "-r")) {
+			recursive = 1;
+		} else if (!strcmp(argv[i], "-f")) {
+			force = 1;
+		} else if (!strcmp(argv[i], "-rf") || !strcmp(argv[i], "-fr")) {
+			recursive = 1;
+			force = 1;
+		} else {
+			break;
+		}
+	}
+	if (recursive && !force) {
+		if (!ask_yesno("WARNING: This operation will remove all contents of the given path(s). Continue? [y/N] ")) {
+			printf("Aborted.\n");
+			return;
+		}
+	}
+	for ( ; i < argc; i++) {
+		char* abspath = get_absolute_path(argv[i]);
+		if (!abspath) {
+			printf("Error: Invalid argument '%s'\n", argv[i]);
+			continue;
+		}
+		afc_error_t err;
+		if (recursive) {
+			err = afc_remove_path_and_contents(afc, abspath);
+		} else {
+			err = afc_remove_path(afc, abspath);
+		}
+		if (err != AFC_E_SUCCESS) {
+			printf("Error: Failed to remove '%s': %s (%d)\n", argv[i], afc_strerror(err), err);
+		}
+		free(abspath);
+	}
+}
+
+static uint8_t get_single_file(afc_client_t afc, const char *srcpath, const char *dstpath, uint64_t file_size, uint8_t force_overwrite)
+{
+	uint64_t fh = 0;
+	afc_error_t err = afc_file_open(afc, srcpath, AFC_FOPEN_RDONLY, &fh);
+	if (err != AFC_E_SUCCESS) {
+		printf("Error: Failed to open file '%s': %s (%d)\n", srcpath, afc_strerror(err), err);
+		return 0;
+	}
+	if (file_exists(dstpath) && !force_overwrite) {
+		printf("Error: Failed to overwrite existing file without '-f' option: %s\n", dstpath);
+		return 0;
+	}
+	FILE *f = fopen(dstpath, "wb");
+	if (!f) {
+		printf("Error: Failed to open local file '%s': %s\n", dstpath, strerror(errno));
+		return 0;
+	}
+	struct timeval t1;
+	struct timeval t2;
+	struct timeval tdiff;
+	size_t bufsize = 0x100000;
+	char *buf = malloc(bufsize);
+	size_t total = 0;
+	int progress = 0;
+	int lastprog = 0;
+	if (file_size > 0x400000) {
+		progress = 1;
+		gettimeofday(&t1, NULL);
+	}
+	uint8_t succeed = 1;
+	while (err == AFC_E_SUCCESS) {
+		uint32_t bytes_read = 0;
+		size_t chunk = 0;
+		err = afc_file_read(afc, fh, buf, bufsize, &bytes_read);
+		if (bytes_read == 0) {
+			break;
+		}
+		while (chunk < bytes_read) {
+			size_t wr = fwrite(buf + chunk, 1, bytes_read - chunk, f);
+			if (wr == 0) {
+				if (progress) {
+					printf("\n");
+				}
+				printf("Error: Failed to write to local file\n");
+				succeed = 0;
+				break;
+			}
+			chunk += wr;
+		}
+		total += chunk;
+		if (progress) {
+			int prog = (int) ((double) total / (double) file_size * 100.0f);
+			if (prog > lastprog) {
+				gettimeofday(&t2, NULL);
+				timeval_subtract(&tdiff, &t2, &t1);
+				double time_in_sec = (double) tdiff.tv_sec + (double) tdiff.tv_usec / 1000000;
+				printf("\r%d%% (%0.1f MB/s)   ", prog, (double) total / 1048576.0f / time_in_sec);
+				fflush(stdout);
+				lastprog = prog;
+			}
+		}
+	}
+	if (progress) {
+		printf("\n");
+	}
+	if (err != AFC_E_SUCCESS) {
+		printf("Error: Failed to read from file '%s': %s (%d)\n", srcpath, afc_strerror(err), err);
+		succeed = 0;
+	}
+	free(buf);
+	fclose(f);
+	afc_file_close(afc, fh);
+	return succeed;
+}
+
+static int __mkdir(const char* path)
+{
+#ifdef _WIN32
+	return mkdir(path);
+#else
+	return mkdir(path, 0755);
+#endif
+}
+
+static uint8_t get_file(afc_client_t afc, const char *srcpath, const char *dstpath, uint8_t force_overwrite, uint8_t recursive_get)
+{
+	plist_t info = NULL;
+	uint64_t file_size = 0;
+	afc_error_t err = afc_get_file_info_plist(afc, srcpath, &info);
+	if (err == AFC_E_OBJECT_NOT_FOUND) {
+		printf("Error: Failed to read from file '%s': %s (%d)\n", srcpath, afc_strerror(err), err);
+		return 0;
+	}
+	uint8_t is_dir = 0;
+	if (info) {
+		file_size = plist_dict_get_uint(info, "st_size");
+		const char* ifmt = plist_get_string_ptr(plist_dict_get_item(info, "st_ifmt"), NULL);
+		is_dir = (ifmt && !strcmp(ifmt, "S_IFDIR"));
+		plist_free(info);
+	}
+	uint8_t succeed = 1;
+	if (is_dir) {
+		if (!recursive_get) {
+			printf("Error: Failed to get a directory without '-r' option: %s\n", srcpath);
+			return 0;
+		}
+		char **entries = NULL;
+		err = afc_read_directory(afc, srcpath, &entries);
+		if (err != AFC_E_SUCCESS) {
+			printf("Error: Failed to list '%s': %s (%d)\n", srcpath, afc_strerror(err), err);
+			return 0;
+		}
+		char **p = entries;
+		size_t srcpath_len = strlen(srcpath);
+		uint8_t srcpath_is_root = strcmp(srcpath, "/") == 0;
+		// if directory exists, check force_overwrite flag
+		if (is_directory(dstpath)) {
+			if (!force_overwrite) {
+				printf("Error: Failed to write into existing directory without '-f': %s\n", dstpath);
+				return 0;
+			}
+		} else if (__mkdir(dstpath) != 0) {
+			printf("Error: Failed to create directory '%s': %s\n", dstpath, strerror(errno));
+			afc_dictionary_free(entries);
+			return 0;
+		}
+		while (p && *p) {
+			if (strcmp(".", *p) == 0 || strcmp("..", *p) == 0) {
+				p++;
+				continue;
+			}
+			size_t len = srcpath_is_root ? (strlen(*p) + 2) : (srcpath_len + 1 + strlen(*p) + 1);
+			char *testpath = (char *) malloc(len);
+			if (srcpath_is_root) {
+				snprintf(testpath, len, "/%s", *p);
+			} else {
+				snprintf(testpath, len, "%s/%s", srcpath, *p);
+			}
+			uint8_t dst_is_root = strcmp(srcpath, "/") == 0;
+			size_t dst_len = dst_is_root ? (strlen(*p) + 2) : (strlen(dstpath) + 1 + strlen(*p) + 1);
+			char *newdst = (char *) malloc(dst_len);
+			if (dst_is_root) {
+				snprintf(newdst, dst_len, "/%s", *p);
+			} else {
+				snprintf(newdst, dst_len, "%s/%s", dstpath, *p);
+			}
+			if (!get_file(afc, testpath, newdst, force_overwrite, recursive_get)) {
+				succeed = 0;
+				break;
+			}
+			free(testpath);
+			free(newdst);
+			p++;
+		}
+		afc_dictionary_free(entries);
+	} else {
+		succeed = get_single_file(afc, srcpath, dstpath, file_size, force_overwrite);
+	}
+	return succeed;
+}
+
+static void handle_get(afc_client_t afc, int argc, char **argv)
+{
+	if (argc < 1) {
+		printf("Error: Invalid number of arguments\n");
+		return;
+	}
+	uint8_t force_overwrite = 0, recursive_get = 0;
+	char *srcpath = NULL;
+	char *dstpath = NULL;
+	int i = 0;
+	for ( ; i < argc; i++) {
+		if (!strcmp(argv[i], "--")) {
+			i++;
+			break;
+		} else if (!strcmp(argv[i], "-r")) {
+			recursive_get = 1;
+		} else if (!strcmp(argv[i], "-f")) {
+			force_overwrite = 1;
+		} else if (!strcmp(argv[i], "-rf") || !strcmp(argv[i], "-fr")) {
+			recursive_get = 1;
+			force_overwrite = 1;
+		} else {
+			break;
+		}
+	}
+	if (argc - i == 1) {
+		char *tmp = strdup(argv[i]);
+		size_t src_len = strlen(tmp);
+		if (src_len > 1 && tmp[src_len - 1] == '/') {
+			tmp[src_len - 1] = '\0';
+		}
+		srcpath = get_absolute_path(tmp);
+		dstpath = strdup(path_get_basename(tmp));
+		free(tmp);
+	} else if (argc - i == 2) {
+		char *tmp = strdup(argv[i]);
+		size_t src_len = strlen(tmp);
+		if (src_len > 1 && tmp[src_len - 1] == '/') {
+			tmp[src_len - 1] = '\0';
+		}
+		srcpath = get_absolute_path(tmp);
+		dstpath = strdup(argv[i + 1]);
+		size_t dst_len = strlen(dstpath);
+		if (dst_len > 1 && dstpath[dst_len - 1] == '/') {
+			dstpath[dst_len - 1] = '\0';
+		}
+		free(tmp);
+	} else {
+		printf("Error: Invalid number of arguments\n");
+		return;
+	}
+
+	// target is a directory, put file under this target
+	if (is_directory(dstpath)) {
+		const char *basen = path_get_basename(srcpath);
+		uint8_t dst_is_root = strcmp(dstpath, "/") == 0;
+		size_t len = dst_is_root ? (strlen(basen) + 2) : (strlen(dstpath) + 1 + strlen(basen) + 1);
+		char *newdst = (char *) malloc(len);
+		if (dst_is_root) {
+			snprintf(newdst, len, "/%s", basen);
+		} else {
+			snprintf(newdst, len, "%s/%s", dstpath, basen);
+		}
+		get_file(afc, srcpath, newdst, force_overwrite, recursive_get);
+		free(srcpath);
+		free(newdst);
+		free(dstpath);
+	} else {
+		// target is not a dir or does not exist, just try to create or rewrite it
+		get_file(afc, srcpath, dstpath, force_overwrite, recursive_get);
+		free(srcpath);
+		free(dstpath);
+	}
+}
+
+static uint8_t put_single_file(afc_client_t afc, const char *srcpath, const char *dstpath, uint8_t force_overwrite)
+{
+	plist_t info = NULL;
+	afc_error_t ret = afc_get_file_info_plist(afc, dstpath, &info);
+	// file exists, only overwrite with '-f' option was set
+	if (ret == AFC_E_SUCCESS && info) {
+		plist_free(info);
+		if (!force_overwrite) {
+			printf("Error: Failed to write into existing file without '-f' option: %s\n", dstpath);
+			return 0;
+		}
+	}
+	FILE *f = fopen(srcpath, "rb");
+	if (!f) {
+		printf("Error: Failed to open local file '%s': %s\n", srcpath, strerror(errno));
+		return 0;
+	}
+	struct timeval t1;
+	struct timeval t2;
+	struct timeval tdiff;
+	struct stat fst;
+	int progress = 0;
+	size_t bufsize = 0x100000;
+	char *buf = malloc(bufsize);
+
+	fstat(fileno(f), &fst);
+	if (fst.st_size >= 0x400000) {
+		progress = 1;
+		gettimeofday(&t1, NULL);
+	}
+	size_t total = 0;
+	int lastprog = 0;
+	uint64_t fh = 0;
+	afc_error_t err = afc_file_open(afc, dstpath, AFC_FOPEN_RW, &fh);
+	uint8_t succeed = 1;
+	while (err == AFC_E_SUCCESS) {
+		uint32_t bytes_read = fread(buf, 1, bufsize, f);
+		if (bytes_read == 0) {
+			if (!feof(f)) {
+				if (progress) {
+					printf("\n");
+				}
+				printf("Error: Failed to read from local file\n");
+				succeed = 0;
+			}
+			break;
+		}
+		uint32_t chunk = 0;
+		while (chunk < bytes_read) {
+			uint32_t bytes_written = 0;
+			err = afc_file_write(afc, fh, buf + chunk, bytes_read - chunk, &bytes_written);
+			if (err != AFC_E_SUCCESS) {
+				if (progress) {
+					printf("\n");
+				}
+				printf("Error: Failed to write to device file\n");
+				succeed = 0;
+				break;
+			}
+			chunk += bytes_written;
+		}
+		total += chunk;
+		if (progress) {
+			int prog = (int) ((double) total / (double) fst.st_size * 100.0f);
+			if (prog > lastprog) {
+				gettimeofday(&t2, NULL);
+				timeval_subtract(&tdiff, &t2, &t1);
+				double time_in_sec = (double) tdiff.tv_sec + (double) tdiff.tv_usec / 1000000;
+				printf("\r%d%% (%0.1f MB/s)   ", prog, (double) total / 1048576.0f / time_in_sec);
+				fflush(stdout);
+				lastprog = prog;
+			}
+		}
+	}
+	free(buf);
+	afc_file_close(afc, fh);
+	fclose(f);
+	return succeed;
+}
+
+static uint8_t put_file(afc_client_t afc, const char *srcpath, const char *dstpath, uint8_t force_overwrite, uint8_t recursive_put)
+{
+	if (is_directory(srcpath)) {
+		if (!recursive_put) {
+			printf("Error: Failed to put directory without '-r' option: %s\n", srcpath);
+			return 0;
+		}
+		plist_t info = NULL;
+		afc_error_t err = afc_get_file_info_plist(afc, dstpath, &info);
+		//create if target directory does not exist
+		plist_free(info);
+		info = NULL;
+		if (err == AFC_E_OBJECT_NOT_FOUND) {
+			err = afc_make_directory(afc, dstpath);
+			if (err != AFC_E_SUCCESS) {
+				printf("Error: Failed to create directory '%s': %s (%d)\n", dstpath, afc_strerror(err), err);
+				return 0;
+			}
+		} else if (!force_overwrite) {
+			printf("Error: Failed to put existing directory without '-f' option: %s\n", dstpath);
+			return 0;
+		}
+		afc_get_file_info_plist(afc, dstpath, &info);
+		uint8_t is_dir = 0;
+		if (info) {
+			const char* ifmt = plist_get_string_ptr(plist_dict_get_item(info, "st_ifmt"), NULL);
+			is_dir = (ifmt && !strcmp(ifmt, "S_IFDIR"));
+			plist_free(info);
+		}
+		if (!is_dir) {
+			printf("Error: Failed to create or access directory: '%s'\n", dstpath);
+			return 0;
+		}
+
+		// walk dir recursively to put files
+		DIR *cur_dir = opendir(srcpath);
+		if (cur_dir) {
+			struct dirent *ep;
+			while ((ep = readdir(cur_dir))) {
+				if ((strcmp(ep->d_name, ".") == 0) || (strcmp(ep->d_name, "..") == 0)) {
+					continue;
+				}
+				char *fpath = string_build_path(srcpath, ep->d_name, NULL);
+				if (fpath) {
+					uint8_t dst_is_root = strcmp(dstpath, "/") == 0;
+					size_t len = dst_is_root ? (strlen(ep->d_name) + 2) : (strlen(dstpath) + 1 + strlen(ep->d_name) + 1);
+					char *newdst = (char *) malloc(len);
+					if (dst_is_root) {
+						snprintf(newdst, len, "/%s", ep->d_name);
+					} else {
+						snprintf(newdst, len, "%s/%s", dstpath, ep->d_name);
+					}
+					if (!put_file(afc, fpath, newdst, force_overwrite, recursive_put)) {
+						free(newdst);
+						free(fpath);
+						return 0;
+					}
+					free(newdst);
+					free(fpath);
+				}
+			}
+			closedir(cur_dir);
+		} else {
+			printf("Error: Failed to visit directory: '%s': %s\n", srcpath, strerror(errno));
+			return 0;
+		}
+	} else {
+		return put_single_file(afc, srcpath, dstpath, force_overwrite);
+	}
+	return 1;
+}
+
+static void handle_put(afc_client_t afc, int argc, char **argv)
+{
+	if (argc < 1) {
+		printf("Error: Invalid number of arguments\n");
+		return;
+	}
+	int i = 0;
+	uint8_t force_overwrite = 0, recursive_put = 0;
+	for ( ; i < argc; i++) {
+		if (!strcmp(argv[i], "--")) {
+			i++;
+			break;
+		} else if (!strcmp(argv[i], "-r")) {
+			recursive_put = 1;
+		} else if (!strcmp(argv[i], "-f")) {
+			force_overwrite = 1;
+		} else if (!strcmp(argv[i], "-rf") || !strcmp(argv[i], "-fr")) {
+			recursive_put = 1;
+			force_overwrite = 1;
+		} else {
+			break;
+		}
+	}
+	if (i >= argc) {
+		printf("Error: Invalid number of arguments\n");
+		return;
+	}
+	char *srcpath = strdup(argv[i]);
+	size_t src_len = strlen(srcpath);
+	if (src_len > 1 && srcpath[src_len - 1] == '/') {
+		srcpath[src_len - 1] = '\0';
+	}
+	char *dstpath = NULL;
+	if (argc - i == 1) {
+		dstpath = get_absolute_path(path_get_basename(srcpath));
+	} else if (argc - i == 2) {
+		char *tmp = strdup(argv[i + 1]);
+		size_t dst_len = strlen(tmp);
+		if (dst_len > 1 && tmp[dst_len - 1] == '/') {
+			tmp[dst_len - 1] = '\0';
+		}
+		dstpath = get_absolute_path(tmp);
+		free(tmp);
+	} else {
+		printf("Error: Invalid number of arguments\n");
+		return;
+	}
+	plist_t info = NULL;
+	afc_error_t err = afc_get_file_info_plist(afc, dstpath, &info);
+	// target does not exist, put directly
+	if (err == AFC_E_OBJECT_NOT_FOUND) {
+		put_file(afc, srcpath, dstpath, force_overwrite, recursive_put);
+		free(srcpath);
+		free(dstpath);
+	} else {
+		uint8_t is_dir = 0;
+		if (info) {
+			const char* ifmt = plist_get_string_ptr(plist_dict_get_item(info, "st_ifmt"), NULL);
+			is_dir = (ifmt && !strcmp(ifmt, "S_IFDIR"));
+			plist_free(info);
+		}
+		// target is a directory, try to put under this directory
+		if (is_dir) {
+			const char *basen = path_get_basename(srcpath);
+			uint8_t dst_is_root = strcmp(dstpath, "/") == 0;
+			size_t len = dst_is_root ? (strlen(basen) + 2) : (strlen(dstpath) + 1 + strlen(basen) + 1);
+			char *newdst = (char *) malloc(len);
+			if (dst_is_root) {
+				snprintf(newdst, len, "/%s", basen);
+			} else {
+				snprintf(newdst, len, "%s/%s", dstpath, basen);
+			}
+			free(dstpath);
+			dstpath = get_absolute_path(newdst);
+			free(newdst);
+			put_file(afc, srcpath, dstpath, force_overwrite, recursive_put);
+		} else {
+			//target is common file, rewrite it
+			put_file(afc, srcpath, dstpath, force_overwrite, recursive_put);
+		}
+		free(srcpath);
+		free(dstpath);
+	}
+}
+
+static void handle_pwd(afc_client_t afc, int argc, char** argv)
+{
+	printf("%s\n", curdir);
+}
+
+static void handle_cd(afc_client_t afc, int argc, char** argv)
+{
+	if (argc != 1) {
+		printf("Error: Invalid number of arguments\n");
+		return;
+	}
+
+	if (!strcmp(argv[0], ".")) {
+		return;
+	}
+
+	if (!strcmp(argv[0], "..")) {
+		if (!strcmp(curdir, "/")) {
+			return;
+		}
+		char *p = strrchr(curdir, '/');
+		if (!p) {
+			strcpy(curdir, "/");
+			return;
+		}
+		if (p == curdir) {
+			*(p+1) = '\0';
+		} else {
+			*p = '\0';
+		}
+		return;
+	}
+
+	char* path = get_realpath(argv[0]);
+	int is_dir = 0;
+	plist_t info = NULL;
+	afc_error_t err = afc_get_file_info_plist(afc, path, &info);
+	if (err == AFC_E_SUCCESS && info) {
+		const char* ifmt = plist_get_string_ptr(plist_dict_get_item(info, "st_ifmt"), NULL);
+		is_dir = (ifmt && !strcmp(ifmt, "S_IFDIR"));
+		plist_free(info);
+	} else {
+		printf("Error: Failed to get file info for %s: %s (%d)\n", path, afc_strerror(err), err);
+		free(path);
+		return;
+	}
+
+	if (!is_dir) {
+		printf("Error: '%s' is not a valid directory\n", path);
+		free(path);
+		return;
+	}
+
+	free(curdir);
+	curdir = path;
+	curdir_len = strlen(curdir);
+}
+
+static void parse_cmdline(int* p_argc, char*** p_argv, const char* cmdline)
+{
+	char **argv = NULL;
+	int argc = 0;
+	size_t maxlen = strlen(cmdline);
+	const char* pos = cmdline;
+	const char* qpos = NULL;
+	char *tmpbuf = NULL;
+	int tmplen = 0;
+	int is_error = 0;
+
+	/* skip initial whitespace */
+	while (isspace(*pos)) pos++;
+	maxlen -= (pos - cmdline);
+
+	tmpbuf = (char*)malloc(maxlen+1);
+
+	while (!is_error) {
+		if (*pos == '\\') {
+			pos++;
+			switch (*pos) {
+				case '"':
+				case '\'':
+				case '\\':
+				case ' ':
+					tmpbuf[tmplen++] = *pos;
+					pos++;
+					break;
+				default:
+					printf("Error: Invalid escape sequence\n");
+					is_error++;
+					break;
+			}
+		} else if (*pos == '"' || *pos == '\'') {
+			if (!qpos) {
+				qpos = pos;
+			} else {
+				qpos = NULL;
+			}
+			pos++;
+		} else if (*pos == '\0' || (!qpos && isspace(*pos))) {
+			tmpbuf[tmplen] = '\0';
+			if (*pos == '\0' && qpos) {
+				printf("Error: Unmatched `%c`\n", *qpos);
+				is_error++;
+				break;
+			}
+			char** new_argv = (char**)realloc(argv, (argc+1)*sizeof(char*));
+			if (new_argv == NULL) {
+				printf("Error: Out of memory?!\n");
+				is_error++;
+				break;
+			}
+			argv = new_argv;
+			/* shrink buffer to actual argument size */
+			argv[argc] = (char*)realloc(tmpbuf, tmplen+1);
+			if (!argv[argc]) {
+				printf("Error: Out of memory?!\n");
+				is_error++;
+				break;
+			}
+			argc++;
+			tmpbuf = NULL;
+			if (*pos == '\0') {
+				break;
+			}
+			maxlen -= tmplen;
+			tmpbuf = (char*)malloc(maxlen+1);
+			tmplen = 0;
+			while (isspace(*pos)) pos++;
+		} else {
+			tmpbuf[tmplen++] = *pos;
+			pos++;
+		}
+	}
+	if (tmpbuf) {
+		free(tmpbuf);
+	}
+	if (is_error) {
+		int i;
+		for (i = 0; argv && i < argc; i++) free(argv[i]);
+		free(argv);
+		return;
+	}
+
+	*p_argv = argv;
+	*p_argc = argc;
+}
+
+static int process_args(afc_client_t afc, int argc, char** argv)
+{
+	if (!strcmp(argv[0], "q") || !strcmp(argv[0], "quit") || !strcmp(argv[0], "exit")) {
+		return -1;
+	}
+	else if (!strcmp(argv[0], "help")) {
+		handle_help(afc, argc, argv);
+	}
+	else if (!strcmp(argv[0], "devinfo") || !strcmp(argv[0], "deviceinfo")) {
+		handle_devinfo(afc, argc-1, argv+1);
+	}
+	else if (!strcmp(argv[0], "info")) {
+		handle_file_info(afc, argc-1, argv+1);
+	}
+	else if (!strcmp(argv[0], "ls") || !strcmp(argv[0], "list")) {
+		handle_list(afc, argc-1, argv+1);
+	}
+	else if (!strcmp(argv[0], "mv") || !strcmp(argv[0], "rename")) {
+		handle_rename(afc, argc-1, argv+1);
+	}
+	else if (!strcmp(argv[0], "mkdir")) {
+		handle_mkdir(afc, argc-1, argv+1);
+	}
+	else if (!strcmp(argv[0], "ln")) {
+		handle_link(afc, argc-1, argv+1);
+	}
+	else if (!strcmp(argv[0], "rm") || !strcmp(argv[0], "remove")) {
+		handle_remove(afc, argc-1, argv+1);
+	}
+	else if (!strcmp(argv[0], "get")) {
+		handle_get(afc, argc-1, argv+1);
+	}
+	else if (!strcmp(argv[0], "put")) {
+		handle_put(afc, argc-1, argv+1);
+	}
+	else if (!strcmp(argv[0], "pwd")) {
+		handle_pwd(afc, argc-1, argv+1);
+	}
+	else if (!strcmp(argv[0], "cd")) {
+		handle_cd(afc, argc-1, argv+1);
+	}
+	else {
+		printf("Unknown command '%s'. Type 'help' to get a list of available commands.\n", argv[0]);
+	}
+	return 0;
+}
+
+static void start_cmdline(afc_client_t afc)
+{
+	while (!stop_requested) {
+		int argc = 0;
+		char **argv = NULL;
+		char prompt[128];
+		int plen = curdir_len;
+		char *ppath = curdir;
+		int plim = (int)(sizeof(prompt)/2)-8;
+		if (plen > plim) {
+			ppath = curdir + (plen - plim);
+			plen = plim;
+		}
+		snprintf(prompt, 128, FG_BLACK BG_LIGHT_GRAY "afc:" COLOR_RESET FG_BRIGHT_YELLOW BG_BLUE "%.*s" COLOR_RESET " > ", plen, ppath);
+#ifdef HAVE_READLINE
+		char* cmd = readline(prompt);
+		if (!cmd || !*cmd) {
+			free(cmd);
+			continue;
+		}
+		add_history(cmd);
+		parse_cmdline(&argc, &argv, cmd);
+#else
+		char cmdbuf[4096];
+		printf("%s", prompt);
+		fflush(stdout);
+		get_input(cmdbuf, sizeof(cmdbuf));
+		parse_cmdline(&argc, &argv, cmdbuf);
+#endif
+#ifdef HAVE_READLINE
+		free(cmd);
+#endif
+		/* process arguments */
+		if (argv && argv[0]) {
+			if (process_args(afc, argc, argv) < 0) {
+				break;
+			}
+		}
+	}
+}
+
+static void device_event_cb(const idevice_event_t* event, void* userdata)
+{
+	if (use_network && event->conn_type != CONNECTION_NETWORK) {
+		return;
+	} else if (!use_network && event->conn_type != CONNECTION_USBMUXD) {
+		return;
+	}
+	if (event->event == IDEVICE_DEVICE_ADD) {
+		if (!udid) {
+			udid = strdup(event->udid);
+		}
+		if (strcmp(udid, event->udid) == 0) {
+			connected = 1;
+		}
+	} else if (event->event == IDEVICE_DEVICE_REMOVE) {
+		if (strcmp(udid, event->udid) == 0) {
+			connected = 0;
+			printf("\n[disconnected]\n");
+			handle_signal(SIGINT);
+		}
+	}
+}
+
+int main(int argc, char** argv)
+{
+	const char* appid = NULL;
+	int ret = 0;
+	idevice_t device = NULL;
+	lockdownd_client_t lockdown = NULL;
+	lockdownd_error_t ldret = LOCKDOWN_E_UNKNOWN_ERROR;
+	lockdownd_service_descriptor_t service = NULL;
+	afc_client_t afc = NULL;
+	house_arrest_client_t house_arrest = NULL;
+	const char* service_name = AFC_SERVICE_NAME;
+	int use_container = 0;
+
+	int c = 0;
+	const struct option longopts[] = {
+		{ "udid", required_argument, NULL, 'u' },
+		{ "network", no_argument, NULL, 'n' },
+		{ "help", no_argument, NULL, 'h' },
+		{ "debug", no_argument, NULL, 'd' },
+		{ "version", no_argument, NULL, 'v' },
+		{ "documents", required_argument, NULL, OPT_DOCUMENTS },
+		{ "container", required_argument, NULL, OPT_CONTAINER },
+		{ NULL, 0, NULL, 0}
+	};
+
+	signal(SIGTERM, handle_signal);
+#ifndef _WIN32
+	signal(SIGQUIT, handle_signal);
+	signal(SIGPIPE, SIG_IGN);
+#endif
+
+	while ((c = getopt_long(argc, argv, "du:nhv", longopts, NULL)) != -1) {
+		switch (c) {
+		case 'd':
+			idevice_set_debug_level(1);
+			break;
+		case 'u':
+			if (!*optarg) {
+				fprintf(stderr, "ERROR: UDID must not be empty!\n");
+				print_usage(argc, argv, 1);
+				return 2;
+			}
+			udid = strdup(optarg);
+			break;
+		case 'n':
+			use_network = 1;
+			break;
+		case 'h':
+			print_usage(argc, argv, 0);
+			return 0;
+		case 'v':
+			printf("%s %s", TOOL_NAME, PACKAGE_VERSION);
+#ifdef HAVE_READLINE
+			printf(" (readline)");
+#endif
+			printf("\n");
+			return 0;
+		case OPT_DOCUMENTS:
+			if (!*optarg) {
+				fprintf(stderr, "ERROR: '--documents' requires a non-empty app ID!\n");
+				print_usage(argc, argv, 1);
+				return 2;
+			}
+			appid = optarg;
+			use_container = 0;
+			break;
+		case OPT_CONTAINER:
+			if (!*optarg) {
+				fprintf(stderr, "ERROR: '--container' requires a not-empty app ID!\n");
+				print_usage(argc, argv, 1);
+				return 2;
+			}
+			appid = optarg;
+			use_container = 1;
+			break;
+		default:
+			print_usage(argc, argv, 1);
+			return 2;
+		}
+	}
+
+	argc -= optind;
+	argv += optind;
+
+	int num = 0;
+	idevice_info_t *devices = NULL;
+	idevice_get_device_list_extended(&devices, &num);
+	int count = 0;
+	for (int i = 0; i < num; i++) {
+		if (devices[i]->conn_type == CONNECTION_NETWORK && use_network) {
+			count++;
+		} else if (devices[i]->conn_type == CONNECTION_USBMUXD) {
+			count++;
+		}
+	}
+	idevice_device_list_extended_free(devices);
+	if (count == 0) {
+		fprintf(stderr, "No device found. Plug in a device or pass UDID with -u to wait for device to be available.\n");
+		return 1;
+	}
+
+	idevice_events_subscribe(&context, device_event_cb, NULL);
+
+	while (!connected && !stop_requested) {
+#ifdef _WIN32
+		Sleep(100);
+#else
+		usleep(100000);
+#endif
+	}
+	if (stop_requested) {
+		return 0;
+	}
+
+	ret = idevice_new_with_options(&device, udid, (use_network) ? IDEVICE_LOOKUP_NETWORK : IDEVICE_LOOKUP_USBMUX);
+	if (ret != IDEVICE_E_SUCCESS) {
+		if (udid) {
+			fprintf(stderr, "ERROR: Device %s not found!\n", udid);
+		} else {
+			fprintf(stderr, "ERROR: No device found!\n");
+		}
+		return 1;
+	}
+
+	do {
+		if (LOCKDOWN_E_SUCCESS != (ldret = lockdownd_client_new_with_handshake(device, &lockdown, TOOL_NAME))) {
+			fprintf(stderr, "ERROR: Could not connect to lockdownd: %s (%d)\n", lockdownd_strerror(ldret), ldret);
+			ret = 1;
+			break;
+		}
+
+		if (appid) {
+			service_name = HOUSE_ARREST_SERVICE_NAME;
+		}
+
+		ldret = lockdownd_start_service(lockdown, service_name, &service);
+		if (ldret != LOCKDOWN_E_SUCCESS) {
+			fprintf(stderr, "ERROR: Failed to start service %s: %s (%d)\n", service_name, lockdownd_strerror(ldret), ldret);
+			ret = 1;
+			break;
+		}
+
+		if (appid) {
+			house_arrest_client_new(device, service, &house_arrest);
+			if (!house_arrest) {
+				fprintf(stderr, "Could not start document sharing service!\n");
+				ret = 1;
+				break;
+			}
+
+			if (house_arrest_send_command(house_arrest, use_container ? "VendContainer": "VendDocuments", appid) != HOUSE_ARREST_E_SUCCESS) {
+				fprintf(stderr, "Could not send house_arrest command!\n");
+				ret = 1;
+				break;
+			}
+
+			plist_t dict = NULL;
+			if (house_arrest_get_result(house_arrest, &dict) != HOUSE_ARREST_E_SUCCESS) {
+				fprintf(stderr, "Could not get result from document sharing service!\n");
+				break;
+			}
+			plist_t node = plist_dict_get_item(dict, "Error");
+			if (node) {
+				char *str = NULL;
+				plist_get_string_val(node, &str);
+				fprintf(stderr, "ERROR: %s\n", str);
+				if (str && !strcmp(str, "InstallationLookupFailed")) {
+					fprintf(stderr, "The App '%s' is either not present on the device, or the 'UIFileSharingEnabled' key is not set in its Info.plist. Starting with iOS 8.3 this key is mandatory to allow access to an app's Documents folder.\n", appid);
+				}
+				free(str);
+				plist_free(dict);
+				break;
+			}
+			plist_free(dict);
+			afc_client_new_from_house_arrest_client(house_arrest, &afc);
+		} else {
+			afc_client_new(device, service, &afc);
+		}
+		lockdownd_service_descriptor_free(service);
+		lockdownd_client_free(lockdown);
+		lockdown = NULL;
+
+		curdir = strdup("/");
+		curdir_len = 1;
+
+		if (argc > 0) {
+			// command line mode
+			process_args(afc, argc, argv);
+		} else {
+			// interactive mode
+			start_cmdline(afc);
+		}
+
+	} while (0);
+
+	if (afc) {
+		afc_client_free(afc);
+	}
+	if (lockdown) {
+		lockdownd_client_free(lockdown);
+	}
+	idevice_free(device);
+
+	return ret;
+}

as-compiler-flag.m4

@@ -0,0 +1,62 @@
+dnl as-compiler-flag.m4 0.1.0
+
+dnl autostars m4 macro for detection of compiler flags
+
+dnl David Schleef <ds@schleef.org>
+
+dnl $Id: as-compiler-flag.m4,v 1.1 2005/12/15 23:35:19 ds Exp $
+
+dnl AS_COMPILER_FLAG(CFLAGS, ACTION-IF-ACCEPTED, [ACTION-IF-NOT-ACCEPTED])
+dnl Tries to compile with the given CFLAGS.
+dnl Runs ACTION-IF-ACCEPTED if the compiler can compile with the flags,
+dnl and ACTION-IF-NOT-ACCEPTED otherwise.
+
+AC_DEFUN([AS_COMPILER_FLAG],
+[
+  AC_MSG_CHECKING([to see if compiler understands $1])
+
+  save_CFLAGS="$CFLAGS"
+  CFLAGS="$CFLAGS $1"
+
+  AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],[])], [flag_ok=yes], [flag_ok=no])
+  CFLAGS="$save_CFLAGS"
+
+  if test "X$flag_ok" = Xyes ; then
+    m4_ifvaln([$2],[$2])
+    true
+  else
+    m4_ifvaln([$3],[$3])
+    true
+  fi
+  AC_MSG_RESULT([$flag_ok])
+])
+
+dnl AS_COMPILER_FLAGS(VAR, FLAGS)
+dnl Tries to compile with the given CFLAGS.
+
+AC_DEFUN([AS_COMPILER_FLAGS],
+[
+  list=$2
+  flags_supported=""
+  flags_unsupported=""
+  AC_MSG_CHECKING([for supported compiler flags])
+  for each in $list
+  do
+    save_CFLAGS="$CFLAGS"
+    CFLAGS="$CFLAGS $each"
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],[])], [flag_ok=yes], [flag_ok=no])
+    CFLAGS="$save_CFLAGS"
+
+    if test "X$flag_ok" = Xyes ; then
+      flags_supported="$flags_supported $each"
+    else
+      flags_unsupported="$flags_unsupported $each"
+    fi
+  done
+  AC_MSG_RESULT([$flags_supported])
+  if test "X$flags_unsupported" != X ; then
+    AC_MSG_WARN([unsupported compiler flags: $flags_unsupported])
+  fi
+  $1="$$1 $flags_supported"
+])
+

asprintf.h

@@ -0,0 +1,36 @@
+#ifndef __ASPRINTF_H
+#define __ASPRINTF_H
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+
+#ifndef HAVE_VASPRINTF
+static inline int vasprintf(char **PTR, const char *TEMPLATE, va_list AP)
+{
+	int res;
+	char buf[16];
+	res = vsnprintf(buf, 16, TEMPLATE, AP);
+	if (res > 0) {
+		*PTR = (char*)malloc(res+1);
+		res = vsnprintf(*PTR, res+1, TEMPLATE, AP);
+	}
+	return res;
+}
+#endif
+
+#ifndef HAVE_ASPRINTF
+static inline int asprintf(char **PTR, const char *TEMPLATE, ...)
+{
+	int res;
+	va_list AP;
+	va_start(AP, TEMPLATE);
+	res = vasprintf(PTR, TEMPLATE, AP);
+	va_end(AP);
+	return res;
+}
+#endif
+
+#endif /* ASPRINTF_H */

asr.c

@@ -0,0 +1,461 @@
+/*
+ * asr.c
+ * Functions for handling asr connections
+ *
+ * Copyright (c) 2010-2012 Martin Szulecki. All Rights Reserved.
+ * Copyright (c) 2012 Nikias Bassen. All Rights Reserved.
+ * Copyright (c) 2010 Joshua Hill. All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <libimobiledevice/libimobiledevice.h>
+#ifdef HAVE_OPENSSL
+#include <openssl/sha.h>
+#else
+#include "sha1.h"
+#define SHA_CTX SHA1_CTX
+#define SHA1_Init SHA1Init
+#define SHA1_Update SHA1Update
+#define SHA1_Final SHA1Final
+#endif
+
+#include "asr.h"
+#include "idevicerestore.h"
+#include "common.h"
+
+#define ASR_VERSION 1
+#define ASR_STREAM_ID 1
+#define ASR_PORT 12345
+#define ASR_BUFFER_SIZE 65536
+#define ASR_FEC_SLICE_STRIDE 40
+#define ASR_PACKETS_PER_FEC 25
+#define ASR_PAYLOAD_PACKET_SIZE 1450
+#define ASR_PAYLOAD_CHUNK_SIZE 131072
+#define ASR_CHECKSUM_CHUNK_SIZE 131072
+
+int asr_open_with_timeout(idevice_t device, asr_client_t* asr)
+{
+	int i = 0;
+	int attempts = 10;
+	idevice_connection_t connection = NULL;
+	idevice_error_t device_error = IDEVICE_E_SUCCESS;
+
+	*asr = NULL;
+
+	if (device == NULL) {
+		return -1;
+	}
+
+	debug("Connecting to ASR\n");
+	for (i = 1; i <= attempts; i++) {
+		device_error = idevice_connect(device, ASR_PORT, &connection);
+		if (device_error == IDEVICE_E_SUCCESS) {
+			break;
+		}
+
+		if (i >= attempts) {
+			error("ERROR: Unable to connect to ASR client\n");
+			return -1;
+		}
+
+		sleep(2);
+		debug("Retrying connection...\n");
+	}
+
+	asr_client_t asr_loc = (asr_client_t)malloc(sizeof(struct asr_client));
+	memset(asr_loc, '\0', sizeof(struct asr_client));
+	asr_loc->connection = connection;
+
+	/* receive Initiate command message */
+	plist_t data = NULL;
+	asr_loc->checksum_chunks = 0;
+	if (asr_receive(asr_loc, &data) < 0) {
+		error("ERROR: Unable to receive data from ASR\n");
+		asr_free(asr_loc);
+		plist_free(data);
+		return -1;
+	}
+	plist_t node;
+	node = plist_dict_get_item(data, "Command");
+	if (node && (plist_get_node_type(node) == PLIST_STRING)) {
+		char* strval = NULL;
+		plist_get_string_val(node, &strval);
+		if (strval && (strcmp(strval, "Initiate") != 0)) {
+			error("ERROR: unexpected ASR plist received:\n");
+			debug_plist(data);
+			plist_free(data);
+			asr_free(asr_loc);
+			return -1;
+		}
+	}
+
+	node = plist_dict_get_item(data, "Checksum Chunks");
+	if (node && (plist_get_node_type(node) == PLIST_BOOLEAN)) {
+		plist_get_bool_val(node, &(asr_loc->checksum_chunks));
+	}
+	plist_free(data);
+
+	*asr = asr_loc;
+
+	return 0;
+}
+
+void asr_set_progress_callback(asr_client_t asr, asr_progress_cb_t cbfunc, void* userdata)
+{
+	if (!asr) {
+		return;
+	}
+	asr->progress_cb = cbfunc;
+	asr->progress_cb_data = userdata;
+}
+
+int asr_receive(asr_client_t asr, plist_t* data)
+{
+	uint32_t size = 0;
+	char* buffer = NULL;
+	plist_t request = NULL;
+	idevice_error_t device_error = IDEVICE_E_SUCCESS;
+
+	*data = NULL;
+
+	buffer = (char*)malloc(ASR_BUFFER_SIZE);
+	if (buffer == NULL) {
+		error("ERROR: Unable to allocate memory for ASR receive buffer\n");
+		return -1;
+	}
+
+	device_error = idevice_connection_receive(asr->connection, buffer, ASR_BUFFER_SIZE, &size);
+	if (device_error != IDEVICE_E_SUCCESS) {
+		error("ERROR: Unable to receive data from ASR\n");
+		free(buffer);
+		return -1;
+	}
+	plist_from_xml(buffer, size, &request);
+
+	*data = request;
+
+	debug("Received %d bytes:\n", size);
+	if (idevicerestore_debug)
+		debug_plist(request);
+	free(buffer);
+	return 0;
+}
+
+int asr_send(asr_client_t asr, plist_t data)
+{
+	uint32_t size = 0;
+	char* buffer = NULL;
+
+	plist_to_xml(data, &buffer, &size);
+	if (asr_send_buffer(asr, buffer, size) < 0) {
+		error("ERROR: Unable to send plist to ASR\n");
+		free(buffer);
+		return -1;
+	}
+
+	if (buffer)
+		free(buffer);
+	return 0;
+}
+
+int asr_send_buffer(asr_client_t asr, const char* data, uint32_t size)
+{
+	uint32_t bytes = 0;
+	idevice_error_t device_error = IDEVICE_E_SUCCESS;
+
+	device_error = idevice_connection_send(asr->connection, data, size, &bytes);
+	if (device_error != IDEVICE_E_SUCCESS || bytes != size) {
+		error("ERROR: Unable to send data to ASR. Sent %u of %u bytes.\n", bytes, size);
+		return -1;
+	}
+
+	return 0;
+}
+
+void asr_free(asr_client_t asr)
+{
+	if (asr != NULL) {
+		if (asr->connection != NULL) {
+			idevice_disconnect(asr->connection);
+			asr->connection = NULL;
+		}
+		free(asr);
+		asr = NULL;
+	}
+}
+
+int asr_perform_validation(asr_client_t asr, const char* filesystem)
+{
+	FILE* file = NULL;
+	uint64_t length = 0;
+	char* command = NULL;
+	plist_t node = NULL;
+	plist_t packet = NULL;
+	plist_t packet_info = NULL;
+	plist_t payload_info = NULL;
+	int attempts = 0;
+
+	file = fopen(filesystem, "rb");
+	if (file == NULL) {
+		return -1;
+	}
+
+#ifdef WIN32
+	length = _lseeki64(fileno(file), 0, SEEK_END);
+	_lseeki64(fileno(file), 0, SEEK_SET);
+	rewind(file);
+#else
+	fseeko(file, 0, SEEK_END);
+	length = ftello(file);
+	fseeko(file, 0, SEEK_SET);
+#endif
+
+	payload_info = plist_new_dict();
+	plist_dict_set_item(payload_info, "Port", plist_new_uint(1));
+	plist_dict_set_item(payload_info, "Size", plist_new_uint(length));
+
+	packet_info = plist_new_dict();
+	if (asr->checksum_chunks) {
+		plist_dict_set_item(packet_info, "Checksum Chunk Size", plist_new_uint(ASR_CHECKSUM_CHUNK_SIZE));
+	}
+	plist_dict_set_item(packet_info, "FEC Slice Stride", plist_new_uint(ASR_FEC_SLICE_STRIDE));
+	plist_dict_set_item(packet_info, "Packet Payload Size", plist_new_uint(ASR_PAYLOAD_PACKET_SIZE));
+	plist_dict_set_item(packet_info, "Packets Per FEC", plist_new_uint(ASR_PACKETS_PER_FEC));
+	plist_dict_set_item(packet_info, "Payload", payload_info);
+	plist_dict_set_item(packet_info, "Stream ID", plist_new_uint(ASR_STREAM_ID));
+	plist_dict_set_item(packet_info, "Version", plist_new_uint(ASR_VERSION));
+
+	if (asr_send(asr, packet_info)) {
+		error("ERROR: Unable to sent packet information to ASR\n");
+		plist_free(packet_info);
+		return -1;
+	}
+	plist_free(packet_info);
+
+	while (1) {
+		if (asr_receive(asr, &packet) < 0) {
+			error("ERROR: Unable to receive validation packet\n");
+			return -1;
+		}
+
+		if (packet == NULL) {
+			if (attempts < 5) {
+				info("Retrying to receive validation packet... %d\n", attempts);
+				attempts++;
+				sleep(1);
+				continue;
+			}
+		}
+
+		attempts = 0;
+
+		node = plist_dict_get_item(packet, "Command");
+		if (!node || plist_get_node_type(node) != PLIST_STRING) {
+			error("ERROR: Unable to find command node in validation request\n");
+			return -1;
+		}
+		plist_get_string_val(node, &command);
+
+		if (!strcmp(command, "OOBData")) {
+			int ret = asr_handle_oob_data_request(asr, packet, file);
+			plist_free(packet);
+			if (ret < 0)
+				return ret;
+		} else if(!strcmp(command, "Payload")) {
+			plist_free(packet);
+			break;
+
+		} else {
+			error("ERROR: Unknown command received from ASR\n");
+			plist_free(packet);
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+int asr_handle_oob_data_request(asr_client_t asr, plist_t packet, FILE* file)
+{
+	char* oob_data = NULL;
+	uint64_t oob_offset = 0;
+	uint64_t oob_length = 0;
+	plist_t oob_length_node = NULL;
+	plist_t oob_offset_node = NULL;
+
+	oob_length_node = plist_dict_get_item(packet, "OOB Length");
+	if (!oob_length_node || PLIST_UINT != plist_get_node_type(oob_length_node)) {
+		error("ERROR: Unable to find OOB data length\n");
+		return -1;
+	}
+	plist_get_uint_val(oob_length_node, &oob_length);
+
+	oob_offset_node = plist_dict_get_item(packet, "OOB Offset");
+	if (!oob_offset_node || PLIST_UINT != plist_get_node_type(oob_offset_node)) {
+		error("ERROR: Unable to find OOB data offset\n");
+		return -1;
+	}
+	plist_get_uint_val(oob_offset_node, &oob_offset);
+
+	oob_data = (char*) malloc(oob_length);
+	if (oob_data == NULL) {
+		error("ERROR: Out of memory\n");
+		return -1;
+	}
+
+#ifdef WIN32
+	rewind(file);
+	_lseeki64(fileno(file), oob_offset, SEEK_SET);
+#else
+	fseeko(file, oob_offset, SEEK_SET);
+#endif
+	if (fread(oob_data, 1, oob_length, file) != oob_length) {
+		error("ERROR: Unable to read OOB data from filesystem offset: %s\n", strerror(errno));
+		free(oob_data);
+		return -1;
+	}
+
+	if (asr_send_buffer(asr, oob_data, oob_length) < 0) {
+		error("ERROR: Unable to send OOB data to ASR\n");
+		free(oob_data);
+		return -1;
+	}
+	free(oob_data);
+	return 0;
+}
+
+int asr_send_payload(asr_client_t asr, const char* filesystem)
+{
+	char *data = NULL;
+	FILE* file = NULL;
+	uint64_t i, length, bytes = 0;
+	double progress = 0;
+
+	file = fopen(filesystem, "rb");
+	if (file == NULL) {
+		error("ERROR: Unable to open filesystem image %s: %s\n", filesystem, strerror(errno));
+		return -1;
+	}
+
+#ifdef WIN32
+	length = _lseeki64(fileno(file), 0, SEEK_END);
+	_lseeki64(fileno(file), 0, SEEK_SET);
+	rewind(file);
+#else
+	fseeko(file, 0, SEEK_END);
+	length = ftello(file);
+	fseeko(file, 0, SEEK_SET);
+#endif
+
+	int chunk = 0;
+	int add_checksum = 0;
+	data = (char*)malloc(ASR_PAYLOAD_CHUNK_SIZE);
+
+	SHA_CTX sha1;
+
+	if (asr->checksum_chunks) {
+		SHA1_Init(&sha1);
+	}
+
+	int size = 0;
+	for (i = length; i > 0; i -= size) {
+		size = ASR_PAYLOAD_CHUNK_SIZE;
+		if (i < ASR_PAYLOAD_CHUNK_SIZE) {
+			size = i;
+		}
+
+		if (add_checksum) {
+			add_checksum = 0;
+		}
+
+		if (asr->checksum_chunks && ((chunk + size) >= ASR_CHECKSUM_CHUNK_SIZE)) {
+			// reduce packet size to match checksum chunk size
+			size -= ((chunk + size) - ASR_CHECKSUM_CHUNK_SIZE);
+			add_checksum = 1;
+		}
+
+		if (fread(data, 1, size, file) != (size_t)size) {
+			error("Error reading filesystem\n");
+			free(data);
+			fclose(file);
+			return -1;
+		}
+
+		if (asr_send_buffer(asr, data, size) < 0) {
+			error("ERROR: Unable to send filesystem payload\n");
+			free(data);
+			fclose(file);
+			return -1;
+		}
+
+		if (asr->checksum_chunks) {
+			SHA1_Update(&sha1, (unsigned char*)data, size);
+			chunk += size;
+
+			if (add_checksum) {
+				// get sha1 of last chunk
+				SHA1_Final((unsigned char*)data, &sha1);
+
+				// send checksum
+				if (asr_send_buffer(asr, data, 20) < 0) {
+					error("ERROR: Unable to send chunk checksum\n");
+					free(data);
+					fclose(file);
+					return -1;
+				}
+
+				// reset SHA1 context
+				SHA1_Init(&sha1);
+
+				// reset chunk byte counter
+				chunk = 0;
+			}
+		}
+
+		bytes += size;
+		progress = ((double)bytes / (double)length);
+		if (asr->progress_cb && ((int)(progress*100) > asr->lastprogress)) {
+			asr->progress_cb(progress, asr->progress_cb_data);
+			asr->lastprogress = (int)(progress*100);
+		}
+	}
+
+	// if last chunk wasn't terminated with a checksum we do it here
+	if (asr->checksum_chunks && !add_checksum) {
+		// get sha1 of last chunk
+		SHA1_Final((unsigned char*)data, &sha1);
+
+		// send checksum
+		if (asr_send_buffer(asr, data, 20) < 0) {
+			error("ERROR: Unable to send chunk checksum\n");
+			free(data);
+			fclose(file);
+			return -1;
+		}
+	}
+
+	free(data);
+	fclose(file);
+	return 0;
+}

asr.h

@@ -0,0 +1,59 @@
+/*
+ * asr.h
+ * Functions for handling asr connections
+ *
+ * Copyright (c) 2012 Martin Szulecki. All Rights Reserved.
+ * Copyright (c) 2012 Nikias Bassen. All Rights Reserved.
+ * Copyright (c) 2010 Joshua Hill. All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef IDEVICERESTORE_ASR_H
+#define IDEVICERESTORE_ASR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <libimobiledevice/libimobiledevice.h>
+
+typedef void (*asr_progress_cb_t)(double, void*);
+
+struct asr_client {
+	idevice_connection_t connection;
+	uint8_t checksum_chunks;
+	int lastprogress;
+	asr_progress_cb_t progress_cb;
+	void* progress_cb_data;
+};
+typedef struct asr_client *asr_client_t;
+
+int asr_open_with_timeout(idevice_t device, asr_client_t* asr);
+void asr_set_progress_callback(asr_client_t asr, asr_progress_cb_t, void* userdata);
+int asr_send(asr_client_t asr, plist_t data);
+int asr_receive(asr_client_t asr, plist_t* data);
+int asr_send_buffer(asr_client_t asr, const char* data, uint32_t size);
+void asr_free(asr_client_t asr);
+int asr_perform_validation(asr_client_t asr, const char* filesystem);
+int asr_send_payload(asr_client_t asr, const char* filesystem);
+int asr_handle_oob_data_request(asr_client_t asr, plist_t packet, FILE* file);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

autogen.sh

@@ -0,0 +1,26 @@
+#!/bin/sh
+
+olddir=`pwd`
+srcdir=`dirname $0`
+test -z "$srcdir" && srcdir=.
+
+(
+  cd "$srcdir"
+
+  gprefix=`which glibtoolize 2>&1 >/dev/null`
+  if [ $? -eq 0 ]; then
+    glibtoolize --force
+  else
+    libtoolize --force
+  fi
+  aclocal -I m4
+  autoheader
+  automake --add-missing
+  autoconf
+
+  cd "$olddir"
+)
+
+if [ -z "$NOCONFIGURE" ]; then
+  $srcdir/configure "$@"
+fi

ax_pthread.m4

@@ -0,0 +1,522 @@
+# ===========================================================================
+#        https://www.gnu.org/software/autoconf-archive/ax_pthread.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_PTHREAD([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+#
+# DESCRIPTION
+#
+#   This macro figures out how to build C programs using POSIX threads. It
+#   sets the PTHREAD_LIBS output variable to the threads library and linker
+#   flags, and the PTHREAD_CFLAGS output variable to any special C compiler
+#   flags that are needed. (The user can also force certain compiler
+#   flags/libs to be tested by setting these environment variables.)
+#
+#   Also sets PTHREAD_CC and PTHREAD_CXX to any special C compiler that is
+#   needed for multi-threaded programs (defaults to the value of CC
+#   respectively CXX otherwise). (This is necessary on e.g. AIX to use the
+#   special cc_r/CC_r compiler alias.)
+#
+#   NOTE: You are assumed to not only compile your program with these flags,
+#   but also to link with them as well. For example, you might link with
+#   $PTHREAD_CC $CFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS $LIBS
+#   $PTHREAD_CXX $CXXFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS $LIBS
+#
+#   If you are only building threaded programs, you may wish to use these
+#   variables in your default LIBS, CFLAGS, and CC:
+#
+#     LIBS="$PTHREAD_LIBS $LIBS"
+#     CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+#     CXXFLAGS="$CXXFLAGS $PTHREAD_CFLAGS"
+#     CC="$PTHREAD_CC"
+#     CXX="$PTHREAD_CXX"
+#
+#   In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute constant
+#   has a nonstandard name, this macro defines PTHREAD_CREATE_JOINABLE to
+#   that name (e.g. PTHREAD_CREATE_UNDETACHED on AIX).
+#
+#   Also HAVE_PTHREAD_PRIO_INHERIT is defined if pthread is found and the
+#   PTHREAD_PRIO_INHERIT symbol is defined when compiling with
+#   PTHREAD_CFLAGS.
+#
+#   ACTION-IF-FOUND is a list of shell commands to run if a threads library
+#   is found, and ACTION-IF-NOT-FOUND is a list of commands to run it if it
+#   is not found. If ACTION-IF-FOUND is not specified, the default action
+#   will define HAVE_PTHREAD.
+#
+#   Please let the authors know if this macro fails on any platform, or if
+#   you have any other suggestions or comments. This macro was based on work
+#   by SGJ on autoconf scripts for FFTW (http://www.fftw.org/) (with help
+#   from M. Frigo), as well as ac_pthread and hb_pthread macros posted by
+#   Alejandro Forero Cuervo to the autoconf macro repository. We are also
+#   grateful for the helpful feedback of numerous users.
+#
+#   Updated for Autoconf 2.68 by Daniel Richard G.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Steven G. Johnson <stevenj@alum.mit.edu>
+#   Copyright (c) 2011 Daniel Richard G. <skunk@iSKUNK.ORG>
+#   Copyright (c) 2019 Marc Stevens <marc.stevens@cwi.nl>
+#
+#   This program is free software: you can redistribute it and/or modify it
+#   under the terms of the GNU General Public License as published by the
+#   Free Software Foundation, either version 3 of the License, or (at your
+#   option) any later version.
+#
+#   This program is distributed in the hope that it will be useful, but
+#   WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+#   Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program. If not, see <https://www.gnu.org/licenses/>.
+#
+#   As a special exception, the respective Autoconf Macro's copyright owner
+#   gives unlimited permission to copy, distribute and modify the configure
+#   scripts that are the output of Autoconf when processing the Macro. You
+#   need not follow the terms of the GNU General Public License when using
+#   or distributing such scripts, even though portions of the text of the
+#   Macro appear in them. The GNU General Public License (GPL) does govern
+#   all other use of the material that constitutes the Autoconf Macro.
+#
+#   This special exception to the GPL applies to versions of the Autoconf
+#   Macro released by the Autoconf Archive. When you make and distribute a
+#   modified version of the Autoconf Macro, you may extend this special
+#   exception to the GPL to apply to your modified version as well.
+
+#serial 31
+
+AU_ALIAS([ACX_PTHREAD], [AX_PTHREAD])
+AC_DEFUN([AX_PTHREAD], [
+AC_REQUIRE([AC_CANONICAL_HOST])
+AC_REQUIRE([AC_PROG_CC])
+AC_REQUIRE([AC_PROG_SED])
+AC_LANG_PUSH([C])
+ax_pthread_ok=no
+
+# We used to check for pthread.h first, but this fails if pthread.h
+# requires special compiler flags (e.g. on Tru64 or Sequent).
+# It gets checked for in the link test anyway.
+
+# First of all, check if the user has set any of the PTHREAD_LIBS,
+# etcetera environment variables, and if threads linking works using
+# them:
+if test "x$PTHREAD_CFLAGS$PTHREAD_LIBS" != "x"; then
+        ax_pthread_save_CC="$CC"
+        ax_pthread_save_CFLAGS="$CFLAGS"
+        ax_pthread_save_LIBS="$LIBS"
+        AS_IF([test "x$PTHREAD_CC" != "x"], [CC="$PTHREAD_CC"])
+        AS_IF([test "x$PTHREAD_CXX" != "x"], [CXX="$PTHREAD_CXX"])
+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+        LIBS="$PTHREAD_LIBS $LIBS"
+        AC_MSG_CHECKING([for pthread_join using $CC $PTHREAD_CFLAGS $PTHREAD_LIBS])
+        AC_LINK_IFELSE([AC_LANG_CALL([], [pthread_join])], [ax_pthread_ok=yes])
+        AC_MSG_RESULT([$ax_pthread_ok])
+        if test "x$ax_pthread_ok" = "xno"; then
+                PTHREAD_LIBS=""
+                PTHREAD_CFLAGS=""
+        fi
+        CC="$ax_pthread_save_CC"
+        CFLAGS="$ax_pthread_save_CFLAGS"
+        LIBS="$ax_pthread_save_LIBS"
+fi
+
+# We must check for the threads library under a number of different
+# names; the ordering is very important because some systems
+# (e.g. DEC) have both -lpthread and -lpthreads, where one of the
+# libraries is broken (non-POSIX).
+
+# Create a list of thread flags to try. Items with a "," contain both
+# C compiler flags (before ",") and linker flags (after ","). Other items
+# starting with a "-" are C compiler flags, and remaining items are
+# library names, except for "none" which indicates that we try without
+# any flags at all, and "pthread-config" which is a program returning
+# the flags for the Pth emulation library.
+
+ax_pthread_flags="pthreads none -Kthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config"
+
+# The ordering *is* (sometimes) important.  Some notes on the
+# individual items follow:
+
+# pthreads: AIX (must check this before -lpthread)
+# none: in case threads are in libc; should be tried before -Kthread and
+#       other compiler flags to prevent continual compiler warnings
+# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h)
+# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads), Tru64
+#           (Note: HP C rejects this with "bad form for `-t' option")
+# -pthreads: Solaris/gcc (Note: HP C also rejects)
+# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it
+#      doesn't hurt to check since this sometimes defines pthreads and
+#      -D_REENTRANT too), HP C (must be checked before -lpthread, which
+#      is present but should not be used directly; and before -mthreads,
+#      because the compiler interprets this as "-mt" + "-hreads")
+# -mthreads: Mingw32/gcc, Lynx/gcc
+# pthread: Linux, etcetera
+# --thread-safe: KAI C++
+# pthread-config: use pthread-config program (for GNU Pth library)
+
+case $host_os in
+
+        freebsd*)
+
+        # -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able)
+        # lthread: LinuxThreads port on FreeBSD (also preferred to -pthread)
+
+        ax_pthread_flags="-kthread lthread $ax_pthread_flags"
+        ;;
+
+        hpux*)
+
+        # From the cc(1) man page: "[-mt] Sets various -D flags to enable
+        # multi-threading and also sets -lpthread."
+
+        ax_pthread_flags="-mt -pthread pthread $ax_pthread_flags"
+        ;;
+
+        openedition*)
+
+        # IBM z/OS requires a feature-test macro to be defined in order to
+        # enable POSIX threads at all, so give the user a hint if this is
+        # not set. (We don't define these ourselves, as they can affect
+        # other portions of the system API in unpredictable ways.)
+
+        AC_EGREP_CPP([AX_PTHREAD_ZOS_MISSING],
+            [
+#            if !defined(_OPEN_THREADS) && !defined(_UNIX03_THREADS)
+             AX_PTHREAD_ZOS_MISSING
+#            endif
+            ],
+            [AC_MSG_WARN([IBM z/OS requires -D_OPEN_THREADS or -D_UNIX03_THREADS to enable pthreads support.])])
+        ;;
+
+        solaris*)
+
+        # On Solaris (at least, for some versions), libc contains stubbed
+        # (non-functional) versions of the pthreads routines, so link-based
+        # tests will erroneously succeed. (N.B.: The stubs are missing
+        # pthread_cleanup_push, or rather a function called by this macro,
+        # so we could check for that, but who knows whether they'll stub
+        # that too in a future libc.)  So we'll check first for the
+        # standard Solaris way of linking pthreads (-mt -lpthread).
+
+        ax_pthread_flags="-mt,-lpthread pthread $ax_pthread_flags"
+        ;;
+esac
+
+# Are we compiling with Clang?
+
+AC_CACHE_CHECK([whether $CC is Clang],
+    [ax_cv_PTHREAD_CLANG],
+    [ax_cv_PTHREAD_CLANG=no
+     # Note that Autoconf sets GCC=yes for Clang as well as GCC
+     if test "x$GCC" = "xyes"; then
+        AC_EGREP_CPP([AX_PTHREAD_CC_IS_CLANG],
+            [/* Note: Clang 2.7 lacks __clang_[a-z]+__ */
+#            if defined(__clang__) && defined(__llvm__)
+             AX_PTHREAD_CC_IS_CLANG
+#            endif
+            ],
+            [ax_cv_PTHREAD_CLANG=yes])
+     fi
+    ])
+ax_pthread_clang="$ax_cv_PTHREAD_CLANG"
+
+
+# GCC generally uses -pthread, or -pthreads on some platforms (e.g. SPARC)
+
+# Note that for GCC and Clang -pthread generally implies -lpthread,
+# except when -nostdlib is passed.
+# This is problematic using libtool to build C++ shared libraries with pthread:
+# [1] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=25460
+# [2] https://bugzilla.redhat.com/show_bug.cgi?id=661333
+# [3] https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=468555
+# To solve this, first try -pthread together with -lpthread for GCC
+
+AS_IF([test "x$GCC" = "xyes"],
+      [ax_pthread_flags="-pthread,-lpthread -pthread -pthreads $ax_pthread_flags"])
+
+# Clang takes -pthread (never supported any other flag), but we'll try with -lpthread first
+
+AS_IF([test "x$ax_pthread_clang" = "xyes"],
+      [ax_pthread_flags="-pthread,-lpthread -pthread"])
+
+
+# The presence of a feature test macro requesting re-entrant function
+# definitions is, on some systems, a strong hint that pthreads support is
+# correctly enabled
+
+case $host_os in
+        darwin* | hpux* | linux* | osf* | solaris*)
+        ax_pthread_check_macro="_REENTRANT"
+        ;;
+
+        aix*)
+        ax_pthread_check_macro="_THREAD_SAFE"
+        ;;
+
+        *)
+        ax_pthread_check_macro="--"
+        ;;
+esac
+AS_IF([test "x$ax_pthread_check_macro" = "x--"],
+      [ax_pthread_check_cond=0],
+      [ax_pthread_check_cond="!defined($ax_pthread_check_macro)"])
+
+
+if test "x$ax_pthread_ok" = "xno"; then
+for ax_pthread_try_flag in $ax_pthread_flags; do
+
+        case $ax_pthread_try_flag in
+                none)
+                AC_MSG_CHECKING([whether pthreads work without any flags])
+                ;;
+
+                *,*)
+                PTHREAD_CFLAGS=`echo $ax_pthread_try_flag | sed "s/^\(.*\),\(.*\)$/\1/"`
+                PTHREAD_LIBS=`echo $ax_pthread_try_flag | sed "s/^\(.*\),\(.*\)$/\2/"`
+                AC_MSG_CHECKING([whether pthreads work with "$PTHREAD_CFLAGS" and "$PTHREAD_LIBS"])
+                ;;
+
+                -*)
+                AC_MSG_CHECKING([whether pthreads work with $ax_pthread_try_flag])
+                PTHREAD_CFLAGS="$ax_pthread_try_flag"
+                ;;
+
+                pthread-config)
+                AC_CHECK_PROG([ax_pthread_config], [pthread-config], [yes], [no])
+                AS_IF([test "x$ax_pthread_config" = "xno"], [continue])
+                PTHREAD_CFLAGS="`pthread-config --cflags`"
+                PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`"
+                ;;
+
+                *)
+                AC_MSG_CHECKING([for the pthreads library -l$ax_pthread_try_flag])
+                PTHREAD_LIBS="-l$ax_pthread_try_flag"
+                ;;
+        esac
+
+        ax_pthread_save_CFLAGS="$CFLAGS"
+        ax_pthread_save_LIBS="$LIBS"
+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+        LIBS="$PTHREAD_LIBS $LIBS"
+
+        # Check for various functions.  We must include pthread.h,
+        # since some functions may be macros.  (On the Sequent, we
+        # need a special flag -Kthread to make this header compile.)
+        # We check for pthread_join because it is in -lpthread on IRIX
+        # while pthread_create is in libc.  We check for pthread_attr_init
+        # due to DEC craziness with -lpthreads.  We check for
+        # pthread_cleanup_push because it is one of the few pthread
+        # functions on Solaris that doesn't have a non-functional libc stub.
+        # We try pthread_create on general principles.
+
+        AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <pthread.h>
+#                       if $ax_pthread_check_cond
+#                        error "$ax_pthread_check_macro must be defined"
+#                       endif
+                        static void *some_global = NULL;
+                        static void routine(void *a)
+                          {
+                             /* To avoid any unused-parameter or
+                                unused-but-set-parameter warning.  */
+                             some_global = a;
+                          }
+                        static void *start_routine(void *a) { return a; }],
+                       [pthread_t th; pthread_attr_t attr;
+                        pthread_create(&th, 0, start_routine, 0);
+                        pthread_join(th, 0);
+                        pthread_attr_init(&attr);
+                        pthread_cleanup_push(routine, 0);
+                        pthread_cleanup_pop(0) /* ; */])],
+            [ax_pthread_ok=yes],
+            [])
+
+        CFLAGS="$ax_pthread_save_CFLAGS"
+        LIBS="$ax_pthread_save_LIBS"
+
+        AC_MSG_RESULT([$ax_pthread_ok])
+        AS_IF([test "x$ax_pthread_ok" = "xyes"], [break])
+
+        PTHREAD_LIBS=""
+        PTHREAD_CFLAGS=""
+done
+fi
+
+
+# Clang needs special handling, because older versions handle the -pthread
+# option in a rather... idiosyncratic way
+
+if test "x$ax_pthread_clang" = "xyes"; then
+
+        # Clang takes -pthread; it has never supported any other flag
+
+        # (Note 1: This will need to be revisited if a system that Clang
+        # supports has POSIX threads in a separate library.  This tends not
+        # to be the way of modern systems, but it's conceivable.)
+
+        # (Note 2: On some systems, notably Darwin, -pthread is not needed
+        # to get POSIX threads support; the API is always present and
+        # active.  We could reasonably leave PTHREAD_CFLAGS empty.  But
+        # -pthread does define _REENTRANT, and while the Darwin headers
+        # ignore this macro, third-party headers might not.)
+
+        # However, older versions of Clang make a point of warning the user
+        # that, in an invocation where only linking and no compilation is
+        # taking place, the -pthread option has no effect ("argument unused
+        # during compilation").  They expect -pthread to be passed in only
+        # when source code is being compiled.
+        #
+        # Problem is, this is at odds with the way Automake and most other
+        # C build frameworks function, which is that the same flags used in
+        # compilation (CFLAGS) are also used in linking.  Many systems
+        # supported by AX_PTHREAD require exactly this for POSIX threads
+        # support, and in fact it is often not straightforward to specify a
+        # flag that is used only in the compilation phase and not in
+        # linking.  Such a scenario is extremely rare in practice.
+        #
+        # Even though use of the -pthread flag in linking would only print
+        # a warning, this can be a nuisance for well-run software projects
+        # that build with -Werror.  So if the active version of Clang has
+        # this misfeature, we search for an option to squash it.
+
+        AC_CACHE_CHECK([whether Clang needs flag to prevent "argument unused" warning when linking with -pthread],
+            [ax_cv_PTHREAD_CLANG_NO_WARN_FLAG],
+            [ax_cv_PTHREAD_CLANG_NO_WARN_FLAG=unknown
+             # Create an alternate version of $ac_link that compiles and
+             # links in two steps (.c -> .o, .o -> exe) instead of one
+             # (.c -> exe), because the warning occurs only in the second
+             # step
+             ax_pthread_save_ac_link="$ac_link"
+             ax_pthread_sed='s/conftest\.\$ac_ext/conftest.$ac_objext/g'
+             ax_pthread_link_step=`AS_ECHO(["$ac_link"]) | sed "$ax_pthread_sed"`
+             ax_pthread_2step_ac_link="($ac_compile) && (echo ==== >&5) && ($ax_pthread_link_step)"
+             ax_pthread_save_CFLAGS="$CFLAGS"
+             for ax_pthread_try in '' -Qunused-arguments -Wno-unused-command-line-argument unknown; do
+                AS_IF([test "x$ax_pthread_try" = "xunknown"], [break])
+                CFLAGS="-Werror -Wunknown-warning-option $ax_pthread_try -pthread $ax_pthread_save_CFLAGS"
+                ac_link="$ax_pthread_save_ac_link"
+                AC_LINK_IFELSE([AC_LANG_SOURCE([[int main(void){return 0;}]])],
+                    [ac_link="$ax_pthread_2step_ac_link"
+                     AC_LINK_IFELSE([AC_LANG_SOURCE([[int main(void){return 0;}]])],
+                         [break])
+                    ])
+             done
+             ac_link="$ax_pthread_save_ac_link"
+             CFLAGS="$ax_pthread_save_CFLAGS"
+             AS_IF([test "x$ax_pthread_try" = "x"], [ax_pthread_try=no])
+             ax_cv_PTHREAD_CLANG_NO_WARN_FLAG="$ax_pthread_try"
+            ])
+
+        case "$ax_cv_PTHREAD_CLANG_NO_WARN_FLAG" in
+                no | unknown) ;;
+                *) PTHREAD_CFLAGS="$ax_cv_PTHREAD_CLANG_NO_WARN_FLAG $PTHREAD_CFLAGS" ;;
+        esac
+
+fi # $ax_pthread_clang = yes
+
+
+
+# Various other checks:
+if test "x$ax_pthread_ok" = "xyes"; then
+        ax_pthread_save_CFLAGS="$CFLAGS"
+        ax_pthread_save_LIBS="$LIBS"
+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+        LIBS="$PTHREAD_LIBS $LIBS"
+
+        # Detect AIX lossage: JOINABLE attribute is called UNDETACHED.
+        AC_CACHE_CHECK([for joinable pthread attribute],
+            [ax_cv_PTHREAD_JOINABLE_ATTR],
+            [ax_cv_PTHREAD_JOINABLE_ATTR=unknown
+             for ax_pthread_attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do
+                 AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <pthread.h>],
+                                                 [int attr = $ax_pthread_attr; return attr /* ; */])],
+                                [ax_cv_PTHREAD_JOINABLE_ATTR=$ax_pthread_attr; break],
+                                [])
+             done
+            ])
+        AS_IF([test "x$ax_cv_PTHREAD_JOINABLE_ATTR" != "xunknown" && \
+               test "x$ax_cv_PTHREAD_JOINABLE_ATTR" != "xPTHREAD_CREATE_JOINABLE" && \
+               test "x$ax_pthread_joinable_attr_defined" != "xyes"],
+              [AC_DEFINE_UNQUOTED([PTHREAD_CREATE_JOINABLE],
+                                  [$ax_cv_PTHREAD_JOINABLE_ATTR],
+                                  [Define to necessary symbol if this constant
+                                   uses a non-standard name on your system.])
+               ax_pthread_joinable_attr_defined=yes
+              ])
+
+        AC_CACHE_CHECK([whether more special flags are required for pthreads],
+            [ax_cv_PTHREAD_SPECIAL_FLAGS],
+            [ax_cv_PTHREAD_SPECIAL_FLAGS=no
+             case $host_os in
+             solaris*)
+             ax_cv_PTHREAD_SPECIAL_FLAGS="-D_POSIX_PTHREAD_SEMANTICS"
+             ;;
+             esac
+            ])
+        AS_IF([test "x$ax_cv_PTHREAD_SPECIAL_FLAGS" != "xno" && \
+               test "x$ax_pthread_special_flags_added" != "xyes"],
+              [PTHREAD_CFLAGS="$ax_cv_PTHREAD_SPECIAL_FLAGS $PTHREAD_CFLAGS"
+               ax_pthread_special_flags_added=yes])
+
+        AC_CACHE_CHECK([for PTHREAD_PRIO_INHERIT],
+            [ax_cv_PTHREAD_PRIO_INHERIT],
+            [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <pthread.h>]],
+                                             [[int i = PTHREAD_PRIO_INHERIT;
+                                               return i;]])],
+                            [ax_cv_PTHREAD_PRIO_INHERIT=yes],
+                            [ax_cv_PTHREAD_PRIO_INHERIT=no])
+            ])
+        AS_IF([test "x$ax_cv_PTHREAD_PRIO_INHERIT" = "xyes" && \
+               test "x$ax_pthread_prio_inherit_defined" != "xyes"],
+              [AC_DEFINE([HAVE_PTHREAD_PRIO_INHERIT], [1], [Have PTHREAD_PRIO_INHERIT.])
+               ax_pthread_prio_inherit_defined=yes
+              ])
+
+        CFLAGS="$ax_pthread_save_CFLAGS"
+        LIBS="$ax_pthread_save_LIBS"
+
+        # More AIX lossage: compile with *_r variant
+        if test "x$GCC" != "xyes"; then
+            case $host_os in
+                aix*)
+                AS_CASE(["x/$CC"],
+                    [x*/c89|x*/c89_128|x*/c99|x*/c99_128|x*/cc|x*/cc128|x*/xlc|x*/xlc_v6|x*/xlc128|x*/xlc128_v6],
+                    [#handle absolute path differently from PATH based program lookup
+                     AS_CASE(["x$CC"],
+                         [x/*],
+                         [
+			   AS_IF([AS_EXECUTABLE_P([${CC}_r])],[PTHREAD_CC="${CC}_r"])
+			   AS_IF([test "x${CXX}" != "x"], [AS_IF([AS_EXECUTABLE_P([${CXX}_r])],[PTHREAD_CXX="${CXX}_r"])])
+			 ],
+                         [
+			   AC_CHECK_PROGS([PTHREAD_CC],[${CC}_r],[$CC])
+			   AS_IF([test "x${CXX}" != "x"], [AC_CHECK_PROGS([PTHREAD_CXX],[${CXX}_r],[$CXX])])
+			 ]
+                     )
+                    ])
+                ;;
+            esac
+        fi
+fi
+
+test -n "$PTHREAD_CC" || PTHREAD_CC="$CC"
+test -n "$PTHREAD_CXX" || PTHREAD_CXX="$CXX"
+
+AC_SUBST([PTHREAD_LIBS])
+AC_SUBST([PTHREAD_CFLAGS])
+AC_SUBST([PTHREAD_CC])
+AC_SUBST([PTHREAD_CXX])
+
+# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
+if test "x$ax_pthread_ok" = "xyes"; then
+        ifelse([$1],,[AC_DEFINE([HAVE_PTHREAD],[1],[Define if you have POSIX threads libraries and header files.])],[$1])
+        :
+else
+        ax_pthread_ok=no
+        $2
+fi
+AC_LANG_POP
+])dnl AX_PTHREAD

ax_python_devel.m4

@@ -0,0 +1,468 @@
+# ===========================================================================
+#     https://www.gnu.org/software/autoconf-archive/ax_python_devel.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_PYTHON_DEVEL([version[,optional]])
+#
+# DESCRIPTION
+#
+#   Note: Defines as a precious variable "PYTHON_VERSION". Don't override it
+#   in your configure.ac.
+#
+#   This macro checks for Python and tries to get the include path to
+#   'Python.h'. It provides the $(PYTHON_CPPFLAGS) and $(PYTHON_LIBS) output
+#   variables. It also exports $(PYTHON_EXTRA_LIBS) and
+#   $(PYTHON_EXTRA_LDFLAGS) for embedding Python in your code.
+#
+#   You can search for some particular version of Python by passing a
+#   parameter to this macro, for example ">= '2.3.1'", or "== '2.4'". Please
+#   note that you *have* to pass also an operator along with the version to
+#   match, and pay special attention to the single quotes surrounding the
+#   version number. Don't use "PYTHON_VERSION" for this: that environment
+#   variable is declared as precious and thus reserved for the end-user.
+#
+#   By default this will fail if it does not detect a development version of
+#   python.  If you want it to continue, set optional to true, like
+#   AX_PYTHON_DEVEL([], [true]).  The ax_python_devel_found variable will be
+#   "no" if it fails.
+#
+#   This macro should work for all versions of Python >= 2.1.0. As an end
+#   user, you can disable the check for the python version by setting the
+#   PYTHON_NOVERSIONCHECK environment variable to something else than the
+#   empty string.
+#
+#   If you need to use this macro for an older Python version, please
+#   contact the authors. We're always open for feedback.
+#
+# LICENSE
+#
+#   Copyright (c) 2009 Sebastian Huber <sebastian-huber@web.de>
+#   Copyright (c) 2009 Alan W. Irwin
+#   Copyright (c) 2009 Rafael Laboissiere <rafael@laboissiere.net>
+#   Copyright (c) 2009 Andrew Collier
+#   Copyright (c) 2009 Matteo Settenvini <matteo@member.fsf.org>
+#   Copyright (c) 2009 Horst Knorr <hk_classes@knoda.org>
+#   Copyright (c) 2013 Daniel Mullner <muellner@math.stanford.edu>
+#
+#   This program is free software: you can redistribute it and/or modify it
+#   under the terms of the GNU General Public License as published by the
+#   Free Software Foundation, either version 3 of the License, or (at your
+#   option) any later version.
+#
+#   This program is distributed in the hope that it will be useful, but
+#   WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+#   Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program. If not, see <https://www.gnu.org/licenses/>.
+#
+#   As a special exception, the respective Autoconf Macro's copyright owner
+#   gives unlimited permission to copy, distribute and modify the configure
+#   scripts that are the output of Autoconf when processing the Macro. You
+#   need not follow the terms of the GNU General Public License when using
+#   or distributing such scripts, even though portions of the text of the
+#   Macro appear in them. The GNU General Public License (GPL) does govern
+#   all other use of the material that constitutes the Autoconf Macro.
+#
+#   This special exception to the GPL applies to versions of the Autoconf
+#   Macro released by the Autoconf Archive. When you make and distribute a
+#   modified version of the Autoconf Macro, you may extend this special
+#   exception to the GPL to apply to your modified version as well.
+
+#serial 37
+
+AU_ALIAS([AC_PYTHON_DEVEL], [AX_PYTHON_DEVEL])
+AC_DEFUN([AX_PYTHON_DEVEL],[
+	# Get whether it's optional
+	if test -z "$2"; then
+	   ax_python_devel_optional=false
+	else
+	   ax_python_devel_optional=$2
+	fi
+	ax_python_devel_found=yes
+
+	#
+	# Allow the use of a (user set) custom python version
+	#
+	AC_ARG_VAR([PYTHON_VERSION],[The installed Python
+		version to use, for example '2.3'. This string
+		will be appended to the Python interpreter
+		canonical name.])
+
+	AC_PATH_PROG([PYTHON],[python[$PYTHON_VERSION]])
+	if test -z "$PYTHON"; then
+	   AC_MSG_WARN([Cannot find python$PYTHON_VERSION in your system path])
+	   if ! $ax_python_devel_optional; then
+	      AC_MSG_ERROR([Giving up, python development not available])
+	   fi
+	   ax_python_devel_found=no
+	   PYTHON_VERSION=""
+	fi
+
+	if test $ax_python_devel_found = yes; then
+	   #
+	   # Check for a version of Python >= 2.1.0
+	   #
+	   AC_MSG_CHECKING([for a version of Python >= '2.1.0'])
+	   ac_supports_python_ver=`$PYTHON -c "import sys; \
+		ver = sys.version.split ()[[0]]; \
+		print (ver >= '2.1.0')"`
+	   if test "$ac_supports_python_ver" != "True"; then
+		if test -z "$PYTHON_NOVERSIONCHECK"; then
+			AC_MSG_RESULT([no])
+			AC_MSG_WARN([
+This version of the AC@&t@_PYTHON_DEVEL macro
+doesn't work properly with versions of Python before
+2.1.0. You may need to re-run configure, setting the
+variables PYTHON_CPPFLAGS, PYTHON_LIBS, PYTHON_SITE_PKG,
+PYTHON_EXTRA_LIBS and PYTHON_EXTRA_LDFLAGS by hand.
+Moreover, to disable this check, set PYTHON_NOVERSIONCHECK
+to something else than an empty string.
+])
+			if ! $ax_python_devel_optional; then
+			   AC_MSG_FAILURE([Giving up])
+			fi
+			ax_python_devel_found=no
+			PYTHON_VERSION=""
+		else
+			AC_MSG_RESULT([skip at user request])
+		fi
+	   else
+		AC_MSG_RESULT([yes])
+	   fi
+	fi
+
+	if test $ax_python_devel_found = yes; then
+	   #
+	   # If the macro parameter ``version'' is set, honour it.
+	   # A Python shim class, VPy, is used to implement correct version comparisons via
+	   # string expressions, since e.g. a naive textual ">= 2.7.3" won't work for
+	   # Python 2.7.10 (the ".1" being evaluated as less than ".3").
+	   #
+	   if test -n "$1"; then
+		AC_MSG_CHECKING([for a version of Python $1])
+                cat << EOF > ax_python_devel_vpy.py
+class VPy:
+    def vtup(self, s):
+        return tuple(map(int, s.strip().replace("rc", ".").split(".")))
+    def __init__(self):
+        import sys
+        self.vpy = tuple(sys.version_info)[[:3]]
+    def __eq__(self, s):
+        return self.vpy == self.vtup(s)
+    def __ne__(self, s):
+        return self.vpy != self.vtup(s)
+    def __lt__(self, s):
+        return self.vpy < self.vtup(s)
+    def __gt__(self, s):
+        return self.vpy > self.vtup(s)
+    def __le__(self, s):
+        return self.vpy <= self.vtup(s)
+    def __ge__(self, s):
+        return self.vpy >= self.vtup(s)
+EOF
+		ac_supports_python_ver=`$PYTHON -c "import ax_python_devel_vpy; \
+                        ver = ax_python_devel_vpy.VPy(); \
+			print (ver $1)"`
+                rm -rf ax_python_devel_vpy*.py* __pycache__/ax_python_devel_vpy*.py*
+		if test "$ac_supports_python_ver" = "True"; then
+			AC_MSG_RESULT([yes])
+		else
+			AC_MSG_RESULT([no])
+			AC_MSG_WARN([this package requires Python $1.
+If you have it installed, but it isn't the default Python
+interpreter in your system path, please pass the PYTHON_VERSION
+variable to configure. See ``configure --help'' for reference.
+])
+			if ! $ax_python_devel_optional; then
+			   AC_MSG_ERROR([Giving up])
+			fi
+			ax_python_devel_found=no
+			PYTHON_VERSION=""
+		fi
+	   fi
+	fi
+
+	if test $ax_python_devel_found = yes; then
+	   #
+	   # Check if you have distutils, else fail
+	   #
+	   AC_MSG_CHECKING([for the sysconfig Python package])
+	   ac_sysconfig_result=`$PYTHON -c "import sysconfig" 2>&1`
+	   if test $? -eq 0; then
+		AC_MSG_RESULT([yes])
+		IMPORT_SYSCONFIG="import sysconfig"
+	   else
+		AC_MSG_RESULT([no])
+
+		AC_MSG_CHECKING([for the distutils Python package])
+		ac_sysconfig_result=`$PYTHON -c "from distutils import sysconfig" 2>&1`
+		if test $? -eq 0; then
+			AC_MSG_RESULT([yes])
+			IMPORT_SYSCONFIG="from distutils import sysconfig"
+		else
+			AC_MSG_WARN([cannot import Python module "distutils".
+Please check your Python installation. The error was:
+$ac_sysconfig_result])
+			if ! $ax_python_devel_optional; then
+			   AC_MSG_ERROR([Giving up])
+			fi
+			ax_python_devel_found=no
+			PYTHON_VERSION=""
+		fi
+	   fi
+	fi
+
+	if test $ax_python_devel_found = yes; then
+	   #
+	   # Check for Python include path
+	   #
+	   AC_MSG_CHECKING([for Python include path])
+	   if test -z "$PYTHON_CPPFLAGS"; then
+		if test "$IMPORT_SYSCONFIG" = "import sysconfig"; then
+			# sysconfig module has different functions
+			python_path=`$PYTHON -c "$IMPORT_SYSCONFIG; \
+				print (sysconfig.get_path ('include'));"`
+			plat_python_path=`$PYTHON -c "$IMPORT_SYSCONFIG; \
+				print (sysconfig.get_path ('platinclude'));"`
+		else
+			# old distutils way
+			python_path=`$PYTHON -c "$IMPORT_SYSCONFIG; \
+				print (sysconfig.get_python_inc ());"`
+			plat_python_path=`$PYTHON -c "$IMPORT_SYSCONFIG; \
+				print (sysconfig.get_python_inc (plat_specific=1));"`
+		fi
+		if test -n "${python_path}"; then
+			if test "${plat_python_path}" != "${python_path}"; then
+				python_path="-I$python_path -I$plat_python_path"
+			else
+				python_path="-I$python_path"
+			fi
+		fi
+		PYTHON_CPPFLAGS=$python_path
+	   fi
+	   AC_MSG_RESULT([$PYTHON_CPPFLAGS])
+	   AC_SUBST([PYTHON_CPPFLAGS])
+
+	   #
+	   # Check for Python library path
+	   #
+	   AC_MSG_CHECKING([for Python library path])
+	   if test -z "$PYTHON_LIBS"; then
+		# (makes two attempts to ensure we've got a version number
+		# from the interpreter)
+		ac_python_version=`cat<<EOD | $PYTHON -
+
+# join all versioning strings, on some systems
+# major/minor numbers could be in different list elements
+from sysconfig import *
+e = get_config_var('VERSION')
+if e is not None:
+	print(e)
+EOD`
+
+		if test -z "$ac_python_version"; then
+			if test -n "$PYTHON_VERSION"; then
+				ac_python_version=$PYTHON_VERSION
+			else
+				ac_python_version=`$PYTHON -c "import sys; \
+					print ("%d.%d" % sys.version_info[[:2]])"`
+			fi
+		fi
+
+		# Make the versioning information available to the compiler
+		AC_DEFINE_UNQUOTED([HAVE_PYTHON], ["$ac_python_version"],
+                                   [If available, contains the Python version number currently in use.])
+
+		# First, the library directory:
+		ac_python_libdir=`cat<<EOD | $PYTHON -
+
+# There should be only one
+$IMPORT_SYSCONFIG
+e = sysconfig.get_config_var('LIBDIR')
+if e is not None:
+	print (e)
+EOD`
+
+		# Now, for the library:
+		ac_python_library=`cat<<EOD | $PYTHON -
+
+$IMPORT_SYSCONFIG
+c = sysconfig.get_config_vars()
+if 'LDVERSION' in c:
+	print ('python'+c[['LDVERSION']])
+else:
+	print ('python'+c[['VERSION']])
+EOD`
+
+		# This small piece shamelessly adapted from PostgreSQL python macro;
+		# credits goes to momjian, I think. I'd like to put the right name
+		# in the credits, if someone can point me in the right direction... ?
+		#
+		if test -n "$ac_python_libdir" -a -n "$ac_python_library"
+		then
+			# use the official shared library
+			ac_python_library=`echo "$ac_python_library" | sed "s/^lib//"`
+			PYTHON_LIBS="-L$ac_python_libdir -l$ac_python_library"
+		else
+			# old way: use libpython from python_configdir
+			ac_python_libdir=`$PYTHON -c \
+			  "from sysconfig import get_python_lib as f; \
+			  import os; \
+			  print (os.path.join(f(plat_specific=1, standard_lib=1), 'config'));"`
+			PYTHON_LIBS="-L$ac_python_libdir -lpython$ac_python_version"
+		fi
+
+		if test -z "$PYTHON_LIBS"; then
+			AC_MSG_WARN([
+  Cannot determine location of your Python DSO. Please check it was installed with
+  dynamic libraries enabled, or try setting PYTHON_LIBS by hand.
+			])
+			if ! $ax_python_devel_optional; then
+			   AC_MSG_ERROR([Giving up])
+			fi
+			ax_python_devel_found=no
+			PYTHON_VERSION=""
+		fi
+	   fi
+	fi
+
+	if test $ax_python_devel_found = yes; then
+	   AC_MSG_RESULT([$PYTHON_LIBS])
+	   AC_SUBST([PYTHON_LIBS])
+
+	   #
+	   # Check for site packages
+	   #
+	   AC_MSG_CHECKING([for Python site-packages path])
+	   if test -z "$PYTHON_SITE_PKG"; then
+		if test "$IMPORT_SYSCONFIG" = "import sysconfig"; then
+			PYTHON_SITE_PKG=`$PYTHON -c "
+$IMPORT_SYSCONFIG;
+if hasattr(sysconfig, 'get_default_scheme'):
+    scheme = sysconfig.get_default_scheme()
+else:
+    scheme = sysconfig._get_default_scheme()
+if scheme == 'posix_local':
+    # Debian's default scheme installs to /usr/local/ but we want to find headers in /usr/
+    scheme = 'posix_prefix'
+prefix = '$prefix'
+if prefix == 'NONE':
+    prefix = '$ac_default_prefix'
+sitedir = sysconfig.get_path('purelib', scheme, vars={'base': prefix})
+print(sitedir)"`
+		else
+			# distutils.sysconfig way
+			PYTHON_SITE_PKG=`$PYTHON -c "$IMPORT_SYSCONFIG; \
+				print (sysconfig.get_python_lib(0,0));"`
+		fi
+	   fi
+	   AC_MSG_RESULT([$PYTHON_SITE_PKG])
+	   AC_SUBST([PYTHON_SITE_PKG])
+
+	   #
+	   # Check for platform-specific site packages
+	   #
+	   AC_MSG_CHECKING([for Python platform specific site-packages path])
+	   if test -z "$PYTHON_PLATFORM_SITE_PKG"; then
+		if test "$IMPORT_SYSCONFIG" = "import sysconfig"; then
+			PYTHON_PLATFORM_SITE_PKG=`$PYTHON -c "
+$IMPORT_SYSCONFIG;
+if hasattr(sysconfig, 'get_default_scheme'):
+    scheme = sysconfig.get_default_scheme()
+else:
+    scheme = sysconfig._get_default_scheme()
+if scheme == 'posix_local':
+    # Debian's default scheme installs to /usr/local/ but we want to find headers in /usr/
+    scheme = 'posix_prefix'
+prefix = '$prefix'
+if prefix == 'NONE':
+    prefix = '$ac_default_prefix'
+sitedir = sysconfig.get_path('platlib', scheme, vars={'platbase': prefix})
+print(sitedir)"`
+		else
+			# distutils.sysconfig way
+			PYTHON_PLATFORM_SITE_PKG=`$PYTHON -c "$IMPORT_SYSCONFIG; \
+				print (sysconfig.get_python_lib(1,0));"`
+		fi
+	   fi
+	   AC_MSG_RESULT([$PYTHON_PLATFORM_SITE_PKG])
+	   AC_SUBST([PYTHON_PLATFORM_SITE_PKG])
+
+	   #
+	   # libraries which must be linked in when embedding
+	   #
+	   AC_MSG_CHECKING(python extra libraries)
+	   if test -z "$PYTHON_EXTRA_LIBS"; then
+	      PYTHON_EXTRA_LIBS=`$PYTHON -c "$IMPORT_SYSCONFIG; \
+                conf = sysconfig.get_config_var; \
+                print (conf('LIBS') + ' ' + conf('SYSLIBS'))"`
+	   fi
+	   AC_MSG_RESULT([$PYTHON_EXTRA_LIBS])
+	   AC_SUBST(PYTHON_EXTRA_LIBS)
+
+	   #
+	   # linking flags needed when embedding
+	   #
+	   AC_MSG_CHECKING(python extra linking flags)
+	   if test -z "$PYTHON_EXTRA_LDFLAGS"; then
+		PYTHON_EXTRA_LDFLAGS=`$PYTHON -c "$IMPORT_SYSCONFIG; \
+			conf = sysconfig.get_config_var; \
+			print (conf('LINKFORSHARED'))"`
+		# Hack for macos, it sticks this in here.
+		PYTHON_EXTRA_LDFLAGS=`echo $PYTHON_EXTRA_LDFLAGS | sed 's/CoreFoundation.*$/CoreFoundation/'`
+	   fi
+	   AC_MSG_RESULT([$PYTHON_EXTRA_LDFLAGS])
+	   AC_SUBST(PYTHON_EXTRA_LDFLAGS)
+
+	   #
+	   # final check to see if everything compiles alright
+	   #
+	   AC_MSG_CHECKING([consistency of all components of python development environment])
+	   # save current global flags
+	   ac_save_LIBS="$LIBS"
+	   ac_save_LDFLAGS="$LDFLAGS"
+	   ac_save_CPPFLAGS="$CPPFLAGS"
+	   LIBS="$ac_save_LIBS $PYTHON_LIBS $PYTHON_EXTRA_LIBS"
+	   LDFLAGS="$ac_save_LDFLAGS $PYTHON_EXTRA_LDFLAGS"
+	   CPPFLAGS="$ac_save_CPPFLAGS $PYTHON_CPPFLAGS"
+	   AC_LANG_PUSH([C])
+	   AC_LINK_IFELSE([
+		AC_LANG_PROGRAM([[#include <Python.h>]],
+				[[Py_Initialize();]])
+		],[pythonexists=yes],[pythonexists=no])
+	   AC_LANG_POP([C])
+	   # turn back to default flags
+	   CPPFLAGS="$ac_save_CPPFLAGS"
+	   LIBS="$ac_save_LIBS"
+	   LDFLAGS="$ac_save_LDFLAGS"
+
+	   AC_MSG_RESULT([$pythonexists])
+
+	   if test ! "x$pythonexists" = "xyes"; then
+	      AC_MSG_WARN([
+  Could not link test program to Python. Maybe the main Python library has been
+  installed in some non-standard library path. If so, pass it to configure,
+  via the LIBS environment variable.
+  Example: ./configure LIBS="-L/usr/non-standard-path/python/lib"
+  ============================================================================
+   ERROR!
+   You probably have to install the development version of the Python package
+   for your distribution.  The exact name of this package varies among them.
+  ============================================================================
+	      ])
+	      if ! $ax_python_devel_optional; then
+		 AC_MSG_ERROR([Giving up])
+	      fi
+	      ax_python_devel_found=no
+	      PYTHON_VERSION=""
+	   fi
+	fi
+
+	#
+	# all done!
+	#
+])

bt_packet_logger.c

@@ -0,0 +1,231 @@
+/*
+ * bt_packet_logger.c
+ * com.apple.bluetooth.BTPacketLogger service implementation.
+ *
+ * Copyright (c) 2021 Geoffrey Kruse, All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <string.h>
+#include <stdlib.h>
+
+#include "bt_packet_logger.h"
+#include "lockdown.h"
+#include "common/debug.h"
+
+struct bt_packet_logger_worker_thread {
+	bt_packet_logger_client_t client;
+	bt_packet_logger_receive_cb_t cbfunc;
+	void *user_data;
+	uint8_t rxbuff[BT_MAX_PACKET_SIZE];
+};
+
+#define SZ_READ_TIMEOUT 100
+#define PAYLOAD_READ_TIMEOUT 500
+
+/**
+ * Convert a service_error_t value to a bt_packet_logger_error_t value.
+ * Used internally to get correct error codes.
+ *
+ * @param err An service_error_t error code
+ *
+ * @return A matching bt_packet_logger_error_t error code,
+ *     BT_PACKET_LOGGER_E_UNKNOWN_ERROR otherwise.
+ */
+static bt_packet_logger_error_t bt_packet_logger_error(service_error_t err)
+{
+	switch (err) {
+		case SERVICE_E_SUCCESS:
+			return BT_PACKET_LOGGER_E_SUCCESS;
+		case SERVICE_E_INVALID_ARG:
+			return BT_PACKET_LOGGER_E_INVALID_ARG;
+		case SERVICE_E_MUX_ERROR:
+			return BT_PACKET_LOGGER_E_MUX_ERROR;
+		case SERVICE_E_SSL_ERROR:
+			return BT_PACKET_LOGGER_E_SSL_ERROR;
+		case SERVICE_E_NOT_ENOUGH_DATA:
+			return BT_PACKET_LOGGER_E_NOT_ENOUGH_DATA;
+		case SERVICE_E_TIMEOUT:
+			return BT_PACKET_LOGGER_E_TIMEOUT;
+		default:
+			break;
+	}
+	return BT_PACKET_LOGGER_E_UNKNOWN_ERROR;
+}
+
+bt_packet_logger_error_t bt_packet_logger_client_new(idevice_t device, lockdownd_service_descriptor_t service, bt_packet_logger_client_t * client)
+{
+	if (!device || !service || service->port == 0 || !client || *client) {
+		debug_info("Incorrect parameter passed to bt_packet_logger_client_new.");
+		return BT_PACKET_LOGGER_E_INVALID_ARG;
+	}
+
+	debug_info("Creating bt_packet_logger_client, port = %d.", service->port);
+
+	service_client_t parent = NULL;
+	bt_packet_logger_error_t ret = bt_packet_logger_error(service_client_new(device, service, &parent));
+	if (ret != BT_PACKET_LOGGER_E_SUCCESS) {
+		debug_info("Creating base service client failed. Error: %i", ret);
+		return ret;
+	}
+
+	bt_packet_logger_client_t client_loc = (bt_packet_logger_client_t) malloc(sizeof(struct bt_packet_logger_client_private));
+	client_loc->parent = parent;
+	client_loc->worker = THREAD_T_NULL;
+
+	*client = client_loc;
+
+	debug_info("bt_packet_logger_client successfully created.");
+	return 0;
+}
+
+bt_packet_logger_error_t bt_packet_logger_client_start_service(idevice_t device, bt_packet_logger_client_t * client, const char* label)
+{
+	bt_packet_logger_error_t err = BT_PACKET_LOGGER_E_UNKNOWN_ERROR;
+	service_client_factory_start_service(device, BT_PACKETLOGGER_SERVICE_NAME, (void**)client, label, SERVICE_CONSTRUCTOR(bt_packet_logger_client_new), &err);
+	return err;
+}
+
+bt_packet_logger_error_t bt_packet_logger_client_free(bt_packet_logger_client_t client)
+{
+	if (!client)
+		return BT_PACKET_LOGGER_E_INVALID_ARG;
+	bt_packet_logger_stop_capture(client);
+	bt_packet_logger_error_t err = bt_packet_logger_error(service_client_free(client->parent));
+	free(client);
+
+	return err;
+}
+
+bt_packet_logger_error_t bt_packet_logger_receive_with_timeout(bt_packet_logger_client_t client, char* data, uint32_t size, uint32_t *received, unsigned int timeout)
+{
+	bt_packet_logger_error_t res = BT_PACKET_LOGGER_E_UNKNOWN_ERROR;
+	int bytes = 0;
+
+	if (!client || !data || (size == 0)) {
+		return BT_PACKET_LOGGER_E_INVALID_ARG;
+	}
+
+	res = bt_packet_logger_error(service_receive_with_timeout(client->parent, data, size, (uint32_t*)&bytes, timeout));
+	if (res != BT_PACKET_LOGGER_E_SUCCESS && res != BT_PACKET_LOGGER_E_TIMEOUT && res != BT_PACKET_LOGGER_E_NOT_ENOUGH_DATA) {
+		debug_info("Could not read data, error %d", res);
+	}
+	if (received) {
+		*received = (uint32_t)bytes;
+	}
+
+	return res;
+}
+
+void *bt_packet_logger_worker(void *arg)
+{
+	bt_packet_logger_error_t ret = BT_PACKET_LOGGER_E_UNKNOWN_ERROR;
+	struct bt_packet_logger_worker_thread *btwt = (struct bt_packet_logger_worker_thread*)arg;
+
+	if (!btwt) {
+		return NULL;
+	}
+
+	debug_info("Running");
+
+	while (btwt->client->parent) {
+		uint32_t bytes = 0;
+		uint16_t len;
+
+		ret = bt_packet_logger_receive_with_timeout(btwt->client, (char*)&len, 2, &bytes, SZ_READ_TIMEOUT);
+
+		if (ret == BT_PACKET_LOGGER_E_TIMEOUT || ret == BT_PACKET_LOGGER_E_NOT_ENOUGH_DATA || ((bytes == 0) && (ret == BT_PACKET_LOGGER_E_SUCCESS))) {
+			continue;
+		} else if (ret < 0) {
+			debug_info("Connection to bt packet logger interrupted");
+			break;
+		}
+
+		// sanity check received length
+		if(bytes > 0 && len > sizeof(bt_packet_logger_header_t)) {
+			debug_info("Reading %u bytes\n", len);
+			ret = bt_packet_logger_receive_with_timeout(btwt->client, (char *)btwt->rxbuff, len, &bytes, PAYLOAD_READ_TIMEOUT);
+
+			if(len != bytes) {
+				debug_info("Failed Read Expected %u, Received %u\n", len, bytes);
+				continue;
+			}
+
+			if (ret == BT_PACKET_LOGGER_E_TIMEOUT || ret == BT_PACKET_LOGGER_E_NOT_ENOUGH_DATA || ((bytes == 0) && (ret == BT_PACKET_LOGGER_E_SUCCESS))) {
+				continue;
+			} else if (ret < 0) {
+				debug_info("Connection to bt packet logger interrupted");
+				break;
+			}
+
+			btwt->cbfunc(btwt->rxbuff, len, btwt->user_data);
+		}
+	}
+
+	// null check performed above
+	free(btwt);
+
+	debug_info("Exiting");
+
+	return NULL;
+}
+
+bt_packet_logger_error_t bt_packet_logger_start_capture(bt_packet_logger_client_t client, bt_packet_logger_receive_cb_t callback, void* user_data)
+{
+	if (!client || !callback)
+		return BT_PACKET_LOGGER_E_INVALID_ARG;
+
+	bt_packet_logger_error_t res = BT_PACKET_LOGGER_E_UNKNOWN_ERROR;
+
+	if (client->worker) {
+		debug_info("Another syslog capture thread appears to be running already.");
+		return res;
+	}
+
+	/* start worker thread */
+	struct bt_packet_logger_worker_thread *btwt = (struct bt_packet_logger_worker_thread*)malloc(sizeof(struct bt_packet_logger_worker_thread));
+	if (btwt) {
+		btwt->client = client;
+		btwt->cbfunc = callback;
+		btwt->user_data = user_data;
+
+		if (thread_new(&client->worker, bt_packet_logger_worker, btwt) == 0) {
+			res = BT_PACKET_LOGGER_E_SUCCESS;
+		}
+	}
+
+	return res;
+}
+
+
+bt_packet_logger_error_t bt_packet_logger_stop_capture(bt_packet_logger_client_t client)
+{
+	if (client->worker) {
+		/* notify thread to finish */
+		service_client_t parent = client->parent;
+		client->parent = NULL;
+		/* join thread to make it exit */
+		thread_join(client->worker);
+		thread_free(client->worker);
+		client->worker = THREAD_T_NULL;
+		client->parent = parent;
+	}
+
+	return BT_PACKET_LOGGER_E_SUCCESS;
+}

bt_packet_logger.h

@@ -0,0 +1,37 @@
+/*
+ * bt_packet_logger.h
+ * com.apple.bluetooth.BTPacketLogger service header file.
+ *
+ * Copyright (c) 2021 Geoffrey Kruse, All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef _BR_PACKET_LOGGER_H
+#define _BR_PACKET_LOGGER_H
+
+#include "idevice.h"
+#include "libimobiledevice/bt_packet_logger.h"
+#include "service.h"
+#include <libimobiledevice-glue/thread.h>
+
+struct bt_packet_logger_client_private {
+	service_client_t parent;
+	THREAD_T worker;
+};
+
+void *bt_packet_logger_worker(void *arg);
+
+#endif

common.c

@@ -0,0 +1,647 @@
+/*
+ * common.c
+ * Misc functions used in idevicerestore
+ *
+ * Copyright (c) 2012-2019 Nikias Bassen. All Rights Reserved.
+ * Copyright (c) 2012 Martin Szulecki. All Rights Reserved.
+ * Copyright (c) 2010 Joshua Hill. All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <libgen.h>
+#include <time.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <ctype.h>
+
+#ifdef WIN32
+#include <windows.h>
+#include <conio.h>
+#ifndef _O_EXCL
+#define _O_EXCL  0x0400
+#endif
+#ifndef O_EXCL
+#define O_EXCL   _O_EXCL
+#endif
+#else
+#include <sys/time.h>
+#include <pthread.h>
+#include <termios.h>
+#endif
+
+#include "common.h"
+#include "endianness.h"
+
+#define MAX_PRINT_LEN 64*1024
+
+struct idevicerestore_mode_t idevicerestore_modes[] = {
+	{  0, "WTF"      },
+	{  1, "DFU"      },
+	{  2, "Recovery" },
+	{  3, "Restore"  },
+	{  4, "Normal"   },
+	{ -1,  NULL      }
+};
+
+int idevicerestore_debug = 0;
+
+#define idevicerestore_err_buff_size 256
+static char idevicerestore_err_buff[idevicerestore_err_buff_size] = {0, };
+
+static FILE* info_stream = NULL;
+static FILE* error_stream = NULL;
+static FILE* debug_stream = NULL;
+
+static int info_disabled = 0;
+static int error_disabled = 0;
+static int debug_disabled = 0;
+
+void info(const char* format, ...)
+{
+	if (info_disabled) return;
+	va_list vargs;
+	va_start(vargs, format);
+	vfprintf((info_stream) ? info_stream : stdout, format, vargs);
+	va_end(vargs);
+}
+
+void error(const char* format, ...)
+{
+	va_list vargs, vargs2;
+	va_start(vargs, format);
+	va_copy(vargs2, vargs);
+	vsnprintf(idevicerestore_err_buff, idevicerestore_err_buff_size, format, vargs);
+	va_end(vargs);
+	if (!error_disabled) {
+		vfprintf((error_stream) ? error_stream : stderr, format, vargs2);
+	}
+	va_end(vargs2);
+}
+
+void debug(const char* format, ...)
+{
+	if (debug_disabled) return;
+	if (!idevicerestore_debug) {
+		return;
+	}
+	va_list vargs;
+	va_start(vargs, format);
+	vfprintf((debug_stream) ? debug_stream : stderr, format, vargs);
+	va_end(vargs);
+}
+
+void idevicerestore_set_info_stream(FILE* strm)
+{
+	if (strm) {
+		info_disabled = 0;
+		info_stream = strm;
+	} else {
+		info_disabled = 1;
+	}
+}
+
+void idevicerestore_set_error_stream(FILE* strm)
+{
+	if (strm) {
+		error_disabled = 0;
+		error_stream = strm;
+	} else {
+		error_disabled = 1;
+	}
+}
+
+void idevicerestore_set_debug_stream(FILE* strm)
+{
+	if (strm) {
+		debug_disabled = 0;
+		debug_stream = strm;
+	} else {
+		debug_disabled = 1;
+	}
+}
+
+const char* idevicerestore_get_error(void)
+{
+	if (idevicerestore_err_buff[0] == 0) {
+		return NULL;
+	} else {
+		char* p = NULL;
+		while ((strlen(idevicerestore_err_buff) > 0) && (p = strrchr(idevicerestore_err_buff, '\n'))) {
+			p[0] = '\0';
+		}
+		return (const char*)idevicerestore_err_buff;
+	}
+}
+
+int write_file(const char* filename, const void* data, size_t size) {
+	size_t bytes = 0;
+	FILE* file = NULL;
+
+	debug("Writing data to %s\n", filename);
+	file = fopen(filename, "wb");
+	if (file == NULL) {
+		error("write_file: Unable to open file %s\n", filename);
+		return -1;
+	}
+
+	bytes = fwrite(data, 1, size, file);
+	fclose(file);
+
+	if (bytes != size) {
+		error("ERROR: Unable to write entire file: %s: %d of %d\n", filename, (int)bytes, (int)size);
+		return -1;
+	}
+
+	return size;
+}
+
+int read_file(const char* filename, void** data, size_t* size) {
+	size_t bytes = 0;
+	size_t length = 0;
+	FILE* file = NULL;
+	char* buffer = NULL;
+	struct stat fst;
+
+	debug("Reading data from %s\n", filename);
+
+	*size = 0;
+	*data = NULL;
+
+	file = fopen(filename, "rb");
+	if (file == NULL) {
+		error("read_file: cannot open %s: %s\n", filename, strerror(errno));
+		return -1;
+	}
+
+	if (fstat(fileno(file), &fst) < 0) {
+		error("read_file: fstat: %s\n", strerror(errno));
+		return -1;
+	}
+	length = fst.st_size;
+
+	buffer = (char*) malloc(length);
+	if (buffer == NULL) {
+		error("ERROR: Out of memory\n");
+		fclose(file);
+		return -1;
+	}
+	bytes = fread(buffer, 1, length, file);
+	fclose(file);
+
+	if (bytes != length) {
+		error("ERROR: Unable to read entire file\n");
+		free(buffer);
+		return -1;
+	}
+
+	*size = length;
+	*data = buffer;
+	return 0;
+}
+
+void debug_plist(plist_t plist) {
+	uint32_t size = 0;
+	char* data = NULL;
+	plist_to_xml(plist, &data, &size);
+	if (size <= MAX_PRINT_LEN)
+		info("%s:printing %i bytes plist:\n%s", __FILE__, size, data);
+	else
+		info("%s:supressed printing %i bytes plist...\n", __FILE__, size);
+	free(data);
+}
+
+void print_progress_bar(double progress) {
+#ifndef WIN32
+	if (info_disabled) return;
+	int i = 0;
+	if(progress < 0) return;
+	if(progress > 100) progress = 100;
+	info("\r[");
+	for(i = 0; i < 50; i++) {
+		if(i < progress / 2) info("=");
+		else info(" ");
+	}
+	info("] %5.1f%%", progress);
+	if(progress >= 100) info("\n");
+	fflush((info_stream) ? info_stream : stdout);
+#endif
+}
+
+#define GET_RAND(min, max) ((rand() % (max - min)) + min)
+
+char *generate_guid(void)
+{
+	char *guid = (char *) malloc(sizeof(char) * 37);
+	const char *chars = "ABCDEF0123456789";
+	srand(time(NULL));
+	int i = 0;
+
+	for (i = 0; i < 36; i++) {
+		if (i == 8 || i == 13 || i == 18 || i == 23) {
+			guid[i] = '-';
+			continue;
+		} else {
+			guid[i] = chars[GET_RAND(0, 16)];
+		}
+	}
+	guid[36] = '\0';
+	return guid;
+}
+
+int mkdir_with_parents(const char *dir, int mode)
+{
+	if (!dir) return -1;
+	if (__mkdir(dir, mode) == 0) {
+		return 0;
+	} else {
+		if (errno == EEXIST) {
+			return 0;
+		} else if (errno == ENOENT) {
+			// ignore
+		} else {
+			return -1;
+		}
+	}
+	int res;
+	char *parent = strdup(dir);
+	char *parentdir = dirname(parent);
+	if (parentdir && (strcmp(parentdir, ".") != 0) && (strcmp(parentdir, dir) != 0)) {
+		res = mkdir_with_parents(parentdir, mode);
+	} else {
+		res = -1;
+	}
+	free(parent);
+	if (res == 0) {
+		mkdir_with_parents(dir, mode);
+	}
+	return res;
+}
+
+#ifndef HAVE_MKSTEMP
+/* Based on libc's __gen_tempname() from sysdeps/posix/tempname.c
+   Copyright (C) 1991-2018 Free Software Foundation, Inc.
+   With changes from https://stackoverflow.com/a/6036308 and some
+   additional changes. */
+int mkstemp(char *tmpl)
+{
+	static const char letters[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+	int len;
+	char *XXXXXX;
+	static unsigned long long value;
+	unsigned long long random_time_bits;
+	unsigned int count;
+	int fd = -1;
+	int save_errno = errno;
+
+	/* A lower bound on the number of temporary files to attempt to
+	   generate.  The maximum total number of temporary file names that
+	   can exist for a given template is 62**6.  It should never be
+	   necessary to try all these combinations.  Instead if a reasonable
+	   number of names is tried (we define reasonable as 62**3) fail to
+	   give the system administrator the chance to remove the problems.  */
+#define ATTEMPTS_MIN (62 * 62 * 62)
+
+	/* The number of times to attempt to generate a temporary file.  To
+	   conform to POSIX, this must be no smaller than TMP_MAX.  */
+#if ATTEMPTS_MIN < TMP_MAX
+	unsigned int attempts = TMP_MAX;
+#else
+	unsigned int attempts = ATTEMPTS_MIN;
+#endif
+
+	len = strlen (tmpl);
+	if (len < 6 || strcmp (&tmpl[len - 6], "XXXXXX"))
+	{
+		errno = EINVAL;
+		return -1;
+	}
+
+	/* This is where the Xs start.  */
+	XXXXXX = &tmpl[len - 6];
+
+	/* Get some more or less random data.  */
+#ifdef WIN32
+	{
+		SYSTEMTIME stNow;
+		FILETIME ftNow;
+
+		// get system time
+		GetSystemTime(&stNow);
+		if (!SystemTimeToFileTime(&stNow, &ftNow))
+		{
+			errno = -1;
+			return -1;
+		}
+
+		random_time_bits = (((unsigned long long)ftNow.dwHighDateTime << 32)
+		                    | (unsigned long long)ftNow.dwLowDateTime);
+	}
+	value += random_time_bits ^ ((unsigned long long)GetCurrentProcessId() << 32 | (unsigned long long)GetCurrentThreadId());
+#else
+	{
+		struct timeval tvNow = {0, 0};
+		gettimeofday(&tvNow, NULL);
+		random_time_bits = (((unsigned long long)tvNow.tv_sec << 32)
+		                    | (unsigned long long)tvNow.tv_usec);
+	}
+	value += random_time_bits ^ ((unsigned long long)getpid() << 32 | (unsigned long long)(uintptr_t)pthread_self());
+#endif
+
+	for (count = 0; count < attempts; value += 7777, ++count)
+	{
+		unsigned long long v = value;
+
+		/* Fill in the random bits.  */
+		XXXXXX[0] = letters[v % 62];
+		v /= 62;
+		XXXXXX[1] = letters[v % 62];
+		v /= 62;
+		XXXXXX[2] = letters[v % 62];
+		v /= 62;
+		XXXXXX[3] = letters[v % 62];
+		v /= 62;
+		XXXXXX[4] = letters[v % 62];
+		v /= 62;
+		XXXXXX[5] = letters[v % 62];
+
+#ifdef WIN32
+		fd = open (tmpl, O_RDWR | O_CREAT | O_EXCL, _S_IREAD | _S_IWRITE);
+#else
+		fd = open (tmpl, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
+#endif
+		if (fd >= 0)
+		{
+			errno = save_errno;
+			return fd;
+		}
+		else if (errno != EEXIST)
+			return -1;
+	}
+
+	/* We got out of the loop because we ran out of combinations to try.  */
+	errno = EEXIST;
+	return -1;
+}
+#endif
+
+char *get_temp_filename(const char *prefix)
+{
+	char *result = NULL;
+	char *tmpdir;
+	size_t lt;
+	size_t lp;
+	const char *TMPVARS[] = { "TMPDIR", "TMP", "TEMP", "TEMPDIR", NULL };
+	int i = 0;
+	int fd;
+
+	/* check the prefix parameter */
+	if (!prefix) {
+		prefix = "tmp_";
+	}
+#ifdef WIN32
+	if (strchr(prefix, '/') || strchr(prefix, '\\')) return NULL;
+#else
+	if (strchr(prefix, '/')) return NULL;
+#endif
+
+	while (TMPVARS[i] && ((tmpdir = getenv(TMPVARS[i])) == NULL)) i++;
+	if (!tmpdir || access(tmpdir, W_OK|X_OK) != 0) {
+#ifdef WIN32
+		tmpdir = "C:\\WINDOWS\\TEMP";
+#else
+		tmpdir = P_tmpdir;
+#endif
+	}
+	if (!tmpdir || access(tmpdir, W_OK|X_OK) != 0) {
+		return NULL;
+	}
+
+	lt = strlen(tmpdir);
+	if (lt < 1) {
+		return NULL;
+	}
+	lp = strlen(prefix);
+	result = malloc(lt + lp + 8);
+	memcpy(result, tmpdir, lt);
+#ifdef WIN32
+	if (tmpdir[lt-1] != '/' && tmpdir[lt-1] != '\\') result[lt++] = '\\';
+#else
+	if (tmpdir[lt-1] != '/') result[lt++] = '/';
+#endif
+	strncpy(result + lt, prefix, lp);
+	strcpy(result + lt + lp, "XXXXXX");
+	fd = mkstemp(result);
+	if (fd < 0) {
+		free(result);
+		result = NULL;
+	}
+	close(fd);
+	return result;
+}
+
+void idevicerestore_progress(struct idevicerestore_client_t* client, int step, double progress)
+{
+	if(client && client->progress_cb) {
+		client->progress_cb(step, progress, client->progress_cb_data);
+	} else {
+		// we don't want to be too verbose in regular idevicerestore.
+		if ((step == RESTORE_STEP_UPLOAD_FS) || (step == RESTORE_STEP_VERIFY_FS) || (step == RESTORE_STEP_FLASH_FW)) {
+			print_progress_bar(100.0 * progress);
+		}
+	}
+}
+
+#ifndef HAVE_STRSEP
+char* strsep(char** strp, const char* delim)
+{
+        char *p, *s;
+        if (strp == NULL || *strp == NULL || **strp == '\0') return NULL;
+        s = *strp;
+        p = s + strcspn(s, delim);
+        if (*p != '\0') *p++ = '\0';
+        *strp = p;
+        return s;
+}
+#endif
+
+#ifndef HAVE_REALPATH
+char* realpath(const char *filename, char *resolved_name)
+{
+#ifdef WIN32
+	if (access(filename, F_OK) != 0) {
+		return NULL;
+	}
+	if (GetFullPathName(filename, MAX_PATH, resolved_name, NULL) == 0) {
+		return NULL;
+	}
+	return resolved_name;
+#else
+#error please provide a realpath implementation for this platform
+	return NULL;
+#endif
+}
+#endif
+
+#ifdef WIN32
+#define BS_CC '\b'
+#define CTRL_C_CC 0x03
+#define ESC_CC 0x1B
+#define my_getch _getch
+#else
+#define BS_CC 0x7f
+static int my_getch(void)
+{
+	struct termios oldt, newt;
+	int ch;
+	tcgetattr(STDIN_FILENO, &oldt);
+	newt = oldt;
+	newt.c_lflag &= ~(ICANON | ECHO);
+	tcsetattr(STDIN_FILENO, TCSANOW, &newt);
+	ch = getchar();
+	tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
+	return ch;
+}
+#endif
+
+void get_user_input(char *buf, int maxlen, int secure)
+{
+	int len = 0;
+	int c;
+
+	while ((c = my_getch()) > 0) {
+		if ((c == '\r') || (c == '\n')) {
+			break;
+		} else if (isprint(c)) {
+			if (len < maxlen-1)
+				buf[len++] = c;
+			fputc((secure) ? '*' : c, stdout);
+		} else if (c == BS_CC) {
+			if (len > 0) {
+				fputs("\b \b", stdout);
+				len--;
+			}
+		}
+#ifdef WIN32
+		else if (c == CTRL_C_CC || c == ESC_CC) {
+			c = -1;
+			break;
+		}
+#endif
+	}
+	if (c < 0) {
+		len = 0;
+	}
+	fputs("\n", stdout);
+	buf[len] = 0;
+}
+
+uint64_t _plist_dict_get_uint(plist_t dict, const char *key)
+{
+	uint64_t uintval = 0;
+	char *strval = NULL;
+	uint64_t strsz = 0;
+	plist_t node = plist_dict_get_item(dict, key);
+	if (!node) {
+		return (uint64_t)-1LL;
+	}
+	switch (plist_get_node_type(node)) {
+	case PLIST_UINT:
+		plist_get_uint_val(node, &uintval);
+		break;
+	case PLIST_STRING:
+		plist_get_string_val(node, &strval);
+		if (strval) {
+			uintval = strtoull(strval, NULL, 0);
+			free(strval);
+		}
+		break;
+	case PLIST_DATA:
+		plist_get_data_val(node, &strval, &strsz);
+		if (strval) {
+			if (strsz == 8) {
+				uintval = le64toh(*(uint64_t*)strval);
+			} else if (strsz == 4) {
+				uintval = le32toh(*(uint32_t*)strval);
+			} else if (strsz == 2) {
+				uintval = le16toh(*(uint16_t*)strval);
+			} else if (strsz == 1) {
+				uintval = strval[0];
+			} else {
+				error("%s: ERROR: invalid size %" PRIu64 " for data to integer conversion\n", __func__, strsz);
+			}
+			free(strval);
+		}
+		break;
+	default:
+		break;
+	}
+	return uintval;
+}
+
+uint8_t _plist_dict_get_bool(plist_t dict, const char *key)
+{
+	uint8_t bval = 0;
+	uint64_t uintval = 0;
+	char *strval = NULL;
+	uint64_t strsz = 0;
+	plist_t node = plist_dict_get_item(dict, key);
+	if (!node) {
+		return 0;
+	}
+	switch (plist_get_node_type(node)) {
+	case PLIST_BOOLEAN:
+		plist_get_bool_val(node, &bval);
+		break;
+	case PLIST_UINT:
+		plist_get_uint_val(node, &uintval);
+		bval = (uint8_t)uintval;
+		break;
+	case PLIST_STRING:
+		plist_get_string_val(node, &strval);
+		if (strval) {
+			if (strcmp(strval, "true")) {
+				bval = 1;
+			} else if (strcmp(strval, "false")) {
+				bval = 0;
+			}
+			free(strval);
+		}
+		break;
+	case PLIST_DATA:
+		plist_get_data_val(node, &strval, &strsz);
+		if (strval) {
+			if (strsz == 1) {
+				bval = strval[0];
+			} else {
+				error("%s: ERROR: invalid size %" PRIu64 " for data to boolean conversion\n", __func__, strsz);
+			}
+			free(strval);
+		}
+		break;
+	default:
+		break;
+	}
+	return bval;
+}

common.h

@@ -0,0 +1,173 @@
+/*
+ * common.h
+ * Misc functions used in idevicerestore
+ *
+ * Copyright (c) 2012-2019 Nikias Bassen. All Rights Reserved.
+ * Copyright (c) 2012 Martin Szulecki. All Rights Reserved.
+ * Copyright (c) 2010 Joshua Hill. All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef IDEVICERESTORE_COMMON_H
+#define IDEVICERESTORE_COMMON_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <inttypes.h>
+#include <unistd.h>
+
+#include <plist/plist.h>
+#include <libirecovery.h>
+
+#include "idevicerestore.h"
+#include "thread.h"
+
+#define MODE_UNKNOWN        -1
+#define MODE_WTF             0
+#define MODE_DFU             1
+#define MODE_RECOVERY        2
+#define MODE_RESTORE         3
+#define MODE_NORMAL          4
+
+#define FLAG_QUIT            1
+
+#define CPFM_FLAG_SECURITY_MODE 1 << 0
+#define CPFM_FLAG_PRODUCTION_MODE 1 << 1
+
+#define IBOOT_FLAG_IMAGE4_AWARE  1 << 2
+#define IBOOT_FLAG_EFFECTIVE_SECURITY_MODE 1 << 3
+#define IBOOT_FLAG_EFFECTIVE_PRODUCTION_MODE 1 << 4
+
+#define USER_AGENT_STRING "InetURL/1.0"
+
+struct dfu_client_t;
+struct normal_client_t;
+struct restore_client_t;
+struct recovery_client_t;
+
+struct idevicerestore_mode_t {
+	int index;
+	const char* string;
+};
+
+struct idevicerestore_entry_t {
+	char* name;
+	char* path;
+	char* filename;
+	char* blob_data;
+	uint32_t blob_size;
+	struct idevicerestore_entry* next;
+	struct idevicerestore_entry* prev;
+};
+
+struct idevicerestore_client_t {
+	int flags;
+	plist_t tss;
+	char* tss_url;
+	plist_t version_data;
+	uint64_t ecid;
+	unsigned char* nonce;
+	int nonce_size;
+	int image4supported;
+	plist_t preflight_info;
+	char* udid;
+	char* srnm;
+	char* ipsw;
+	const char* filesystem;
+	struct dfu_client_t* dfu;
+	struct restore_client_t* restore;
+	struct recovery_client_t* recovery;
+	irecv_device_t device;
+	struct idevicerestore_entry_t** entries;
+	struct idevicerestore_mode_t* mode;
+	char* version;
+	char* build;
+	int build_major;
+	char* restore_boot_args;
+	char* cache_dir;
+	unsigned char* root_ticket;
+	int root_ticket_len;
+	idevicerestore_progress_cb_t progress_cb;
+	void* progress_cb_data;
+	irecv_device_event_context_t irecv_e_ctx;
+	void* idevice_e_ctx;
+	mutex_t device_event_mutex;
+	cond_t device_event_cond;
+	int ignore_device_add_events;
+};
+
+extern struct idevicerestore_mode_t idevicerestore_modes[];
+
+extern int idevicerestore_debug;
+
+__attribute__((format(printf, 1, 2)))
+void info(const char* format, ...);
+__attribute__((format(printf, 1, 2)))
+void error(const char* format, ...);
+__attribute__((format(printf, 1, 2)))
+void debug(const char* format, ...);
+
+void debug_plist(plist_t plist);
+void print_progress_bar(double progress);
+int read_file(const char* filename, void** data, size_t* size);
+int write_file(const char* filename, const void* data, size_t size);
+
+char *generate_guid(void);
+
+#ifdef WIN32
+#include <windows.h>
+#include <unistd.h>
+#define __mkdir(path, mode) mkdir(path)
+#ifndef sleep
+#define sleep(x) Sleep(x*1000)
+#endif
+#define __usleep(x) Sleep(x/1000)
+#else
+#include <sys/stat.h>
+#define __mkdir(path, mode) mkdir(path, mode)
+#define __usleep(x) usleep(x)
+#endif
+
+int mkdir_with_parents(const char *dir, int mode);
+
+char *get_temp_filename(const char *prefix);
+
+void idevicerestore_progress(struct idevicerestore_client_t* client, int step, double progress);
+
+#ifndef HAVE_STRSEP
+char* strsep(char** strp, const char* delim);
+#endif
+
+#ifndef HAVE_REALPATH
+char* realpath(const char *filename, char *resolved_name);
+#endif
+
+void get_user_input(char *buf, int maxlen, int secure);
+
+uint8_t _plist_dict_get_bool(plist_t dict, const char *key);
+uint64_t _plist_dict_get_uint(plist_t dict, const char *key);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

companion_proxy.c

@@ -0,0 +1,380 @@
+/*
+ * companion_proxy.c
+ * com.apple.companion_proxy service implementation.
+ *
+ * Copyright (c) 2019-2020 Nikias Bassen, All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <string.h>
+#include <stdlib.h>
+#include <plist/plist.h>
+
+#include "companion_proxy.h"
+#include "lockdown.h"
+#include "common/debug.h"
+
+/**
+ * Convert a property_list_service_error_t value to a companion_proxy_error_t value.
+ * Used internally to get correct error codes.
+ *
+ * @param err An property_list_service_error_t error code
+ *
+ * @return A matching companion_proxy_error_t error code,
+ *     COMPANION_PROXY_E_UNKNOWN_ERROR otherwise.
+ */
+static companion_proxy_error_t companion_proxy_error(property_list_service_error_t err)
+{
+	switch (err) {
+		case PROPERTY_LIST_SERVICE_E_SUCCESS:
+			return COMPANION_PROXY_E_SUCCESS;
+		case PROPERTY_LIST_SERVICE_E_INVALID_ARG:
+			return COMPANION_PROXY_E_INVALID_ARG;
+		case PROPERTY_LIST_SERVICE_E_PLIST_ERROR:
+			return COMPANION_PROXY_E_PLIST_ERROR;
+		case PROPERTY_LIST_SERVICE_E_MUX_ERROR:
+			return COMPANION_PROXY_E_MUX_ERROR;
+		case PROPERTY_LIST_SERVICE_E_SSL_ERROR:
+			return COMPANION_PROXY_E_SSL_ERROR;
+		case PROPERTY_LIST_SERVICE_E_NOT_ENOUGH_DATA:
+			return COMPANION_PROXY_E_NOT_ENOUGH_DATA;
+		case PROPERTY_LIST_SERVICE_E_RECEIVE_TIMEOUT:
+			return COMPANION_PROXY_E_TIMEOUT;
+		default:
+			break;
+	}
+	return COMPANION_PROXY_E_UNKNOWN_ERROR;
+}
+
+companion_proxy_error_t companion_proxy_client_new(idevice_t device, lockdownd_service_descriptor_t service, companion_proxy_client_t * client)
+{
+	*client = NULL;
+
+	if (!device || !service || service->port == 0 || !client || *client) {
+		debug_info("Incorrect parameter passed to companion_proxy_client_new.");
+		return COMPANION_PROXY_E_INVALID_ARG;
+	}
+
+	debug_info("Creating companion_proxy_client, port = %d.", service->port);
+
+	property_list_service_client_t plclient = NULL;
+	companion_proxy_error_t ret = companion_proxy_error(property_list_service_client_new(device, service, &plclient));
+	if (ret != COMPANION_PROXY_E_SUCCESS) {
+		debug_info("Creating a property list client failed. Error: %i", ret);
+		return ret;
+	}
+
+	companion_proxy_client_t client_loc = (companion_proxy_client_t) malloc(sizeof(struct companion_proxy_client_private));
+	client_loc->parent = plclient;
+	client_loc->event_thread = THREAD_T_NULL;
+
+	*client = client_loc;
+
+	debug_info("Created companion_proxy_client successfully.");
+	return COMPANION_PROXY_E_SUCCESS;
+}
+
+companion_proxy_error_t companion_proxy_client_start_service(idevice_t device, companion_proxy_client_t * client, const char* label)
+{
+	companion_proxy_error_t err = COMPANION_PROXY_E_UNKNOWN_ERROR;
+	service_client_factory_start_service(device, COMPANION_PROXY_SERVICE_NAME, (void**)client, label, SERVICE_CONSTRUCTOR(companion_proxy_client_new), &err);
+	return err;
+}
+
+companion_proxy_error_t companion_proxy_client_free(companion_proxy_client_t client)
+{
+	if (!client)
+		return COMPANION_PROXY_E_INVALID_ARG;
+
+	property_list_service_client_t parent = client->parent;
+	client->parent = NULL;
+	if (client->event_thread) {
+		debug_info("joining event thread");
+		thread_join(client->event_thread);
+		thread_free(client->event_thread);
+		client->event_thread = THREAD_T_NULL;
+	}
+	companion_proxy_error_t err = companion_proxy_error(property_list_service_client_free(parent));
+	free(client);
+
+	return err;
+}
+
+companion_proxy_error_t companion_proxy_send(companion_proxy_client_t client, plist_t plist)
+{
+	companion_proxy_error_t res = COMPANION_PROXY_E_UNKNOWN_ERROR;
+
+	res = companion_proxy_error(property_list_service_send_binary_plist(client->parent, plist));
+	if (res != COMPANION_PROXY_E_SUCCESS) {
+		debug_info("Sending plist failed with error %d", res);
+		return res;
+	}
+
+	return res;
+}
+
+companion_proxy_error_t companion_proxy_receive(companion_proxy_client_t client, plist_t * plist)
+{
+	companion_proxy_error_t res = COMPANION_PROXY_E_UNKNOWN_ERROR;
+	plist_t outplist = NULL;
+	res = companion_proxy_error(property_list_service_receive_plist_with_timeout(client->parent, &outplist, 10000));
+	if (res != COMPANION_PROXY_E_SUCCESS && res != COMPANION_PROXY_E_TIMEOUT) {
+		debug_info("Could not receive plist, error %d", res);
+		plist_free(outplist);
+	} else if (res == COMPANION_PROXY_E_SUCCESS) {
+		*plist = outplist;
+	}
+	return res;
+}
+
+companion_proxy_error_t companion_proxy_get_device_registry(companion_proxy_client_t client, plist_t* paired_devices)
+{
+	if (!client || !paired_devices) {
+		return COMPANION_PROXY_E_INVALID_ARG;
+	}
+
+	plist_t dict = plist_new_dict();
+	plist_dict_set_item(dict, "Command", plist_new_string("GetDeviceRegistry"));
+
+	companion_proxy_error_t res = companion_proxy_send(client, dict);
+	plist_free(dict);
+	dict = NULL;
+	if (res != COMPANION_PROXY_E_SUCCESS) {
+		return res;
+	}
+
+	res = companion_proxy_receive(client, &dict);
+	if (res != COMPANION_PROXY_E_SUCCESS) {
+		return res;
+	}
+	if (!dict || !PLIST_IS_DICT(dict)) {
+		return COMPANION_PROXY_E_PLIST_ERROR;
+	}
+	plist_t val = plist_dict_get_item(dict, "PairedDevicesArray");
+	if (val) {
+		*paired_devices = plist_copy(val);
+		res = COMPANION_PROXY_E_SUCCESS;
+	} else {
+		res = COMPANION_PROXY_E_UNKNOWN_ERROR;
+		val = plist_dict_get_item(dict, "Error");
+		if (val) {
+			if (plist_string_val_compare(val, "NoPairedWatches")) {
+				res = COMPANION_PROXY_E_NO_DEVICES;
+			}
+		}
+	}
+	plist_free(dict);
+	return res;
+}
+
+struct companion_proxy_cb_data {
+	companion_proxy_client_t client;
+	companion_proxy_device_event_cb_t cbfunc;
+	void* user_data;
+};
+
+static void* companion_proxy_event_thread(void* arg)
+{
+	struct companion_proxy_cb_data* data = (struct companion_proxy_cb_data*)arg;
+	companion_proxy_client_t client = data->client;
+	companion_proxy_error_t res;
+
+	plist_t command = plist_new_dict();
+	plist_dict_set_item(command, "Command", plist_new_string("StartListeningForDevices"));
+	res = companion_proxy_send(client, command);
+	plist_free(command);
+
+	if (res != COMPANION_PROXY_E_SUCCESS) {
+		free(data);
+		client->event_thread = THREAD_T_NULL;
+		return NULL;
+	}
+
+	while (client && client->parent) {
+		plist_t node = NULL;
+		res = companion_proxy_error(property_list_service_receive_plist_with_timeout(client->parent, &node, 1000));
+		if (res != COMPANION_PROXY_E_SUCCESS && res != COMPANION_PROXY_E_TIMEOUT) {
+			debug_info("could not receive plist, error %d", res);
+			break;
+		}
+
+		if (node) {
+			data->cbfunc(node, data->user_data);
+		}
+		plist_free(node);
+	}
+
+	client->event_thread = THREAD_T_NULL;
+	free(data);
+
+	return NULL;
+}
+
+companion_proxy_error_t companion_proxy_start_listening_for_devices(companion_proxy_client_t client, companion_proxy_device_event_cb_t callback, void* userdata)
+{
+	if (!client || !client->parent || !callback) {
+		return COMPANION_PROXY_E_INVALID_ARG;
+	}
+
+	if (client->event_thread) {
+		return COMPANION_PROXY_E_OP_IN_PROGRESS;
+	}
+
+	companion_proxy_error_t res = COMPANION_PROXY_E_UNKNOWN_ERROR;
+	struct companion_proxy_cb_data *data = (struct companion_proxy_cb_data*)malloc(sizeof(struct companion_proxy_cb_data));
+	if (data) {
+		data->client = client;
+		data->cbfunc = callback;
+		data->user_data = userdata;
+
+		if (thread_new(&client->event_thread, companion_proxy_event_thread, data) == 0) {
+			res = COMPANION_PROXY_E_SUCCESS;
+		} else {
+			free(data);
+		}
+	}
+	return res;
+}
+
+companion_proxy_error_t companion_proxy_stop_listening_for_devices(companion_proxy_client_t client)
+{
+	property_list_service_client_t parent = client->parent;
+	client->parent = NULL;
+	if (client->event_thread) {
+		debug_info("joining event thread");
+		thread_join(client->event_thread);
+		thread_free(client->event_thread);
+		client->event_thread = THREAD_T_NULL;
+	}
+	client->parent = parent;
+	return COMPANION_PROXY_E_SUCCESS;
+}
+
+companion_proxy_error_t companion_proxy_get_value_from_registry(companion_proxy_client_t client, const char* companion_udid, const char* key, plist_t* value)
+{
+	if (!client || !companion_udid || !key || !value) {
+		return COMPANION_PROXY_E_INVALID_ARG;
+	}
+
+	plist_t dict = plist_new_dict();
+	plist_dict_set_item(dict, "Command", plist_new_string("GetValueFromRegistry"));
+	plist_dict_set_item(dict, "GetValueGizmoUDIDKey", plist_new_string(companion_udid));
+	plist_dict_set_item(dict, "GetValueKeyKey", plist_new_string(key));
+
+	companion_proxy_error_t res = companion_proxy_send(client, dict);
+	plist_free(dict);
+	dict = NULL;
+	if (res != COMPANION_PROXY_E_SUCCESS) {
+		return res;
+	}
+
+	res = companion_proxy_receive(client, &dict);
+	if (res != COMPANION_PROXY_E_SUCCESS) {
+		return res;
+	}
+	if (!dict || !PLIST_IS_DICT(dict)) {
+		return COMPANION_PROXY_E_PLIST_ERROR;
+	}
+	plist_t val = plist_dict_get_item(dict, "RetrievedValueDictionary");
+	if (val) {
+		*value = plist_copy(val);
+		res = COMPANION_PROXY_E_SUCCESS;
+	} else {
+		res = COMPANION_PROXY_E_UNKNOWN_ERROR;
+		val = plist_dict_get_item(dict, "Error");
+		if (val) {
+			if (!plist_string_val_compare(val, "UnsupportedWatchKey")) {
+				res = COMPANION_PROXY_E_UNSUPPORTED_KEY;
+			} else if (plist_string_val_compare(val, "TimeoutReply")) {
+				res = COMPANION_PROXY_E_TIMEOUT_REPLY;
+			}
+		}
+	}
+	plist_free(dict);
+	return res;
+}
+
+companion_proxy_error_t companion_proxy_start_forwarding_service_port(companion_proxy_client_t client, uint16_t remote_port, const char* service_name, uint16_t* forward_port, plist_t options)
+{
+	if (!client) {
+		return COMPANION_PROXY_E_INVALID_ARG;
+	}
+
+	plist_t dict = plist_new_dict();
+	plist_dict_set_item(dict, "Command", plist_new_string("StartForwardingServicePort"));
+	plist_dict_set_item(dict, "GizmoRemotePortNumber", plist_new_uint(remote_port));
+	if (service_name) {
+		plist_dict_set_item(dict, "ForwardedServiceName", plist_new_string(service_name));
+	}
+	plist_dict_set_item(dict, "IsServiceLowPriority", plist_new_bool(0));
+	plist_dict_set_item(dict, "PreferWifi", plist_new_bool(0));
+	if (options) {
+		plist_dict_merge(&dict, options);
+	}
+
+	companion_proxy_error_t res = companion_proxy_send(client, dict);
+	plist_free(dict);
+	dict = NULL;
+	if (res != COMPANION_PROXY_E_SUCCESS) {
+		return res;
+	}
+
+	res = companion_proxy_receive(client, &dict);
+	if (res != COMPANION_PROXY_E_SUCCESS) {
+		return res;
+	}
+	plist_t val = plist_dict_get_item(dict, "CompanionProxyServicePort");
+	if (val) {
+		uint64_t u64val = 0;
+		plist_get_uint_val(val, &u64val);
+		*forward_port = (uint16_t)u64val;
+		res = COMPANION_PROXY_E_SUCCESS;
+	} else {
+		res = COMPANION_PROXY_E_UNKNOWN_ERROR;
+	}
+	plist_free(dict);
+
+	return res;
+}
+
+companion_proxy_error_t companion_proxy_stop_forwarding_service_port(companion_proxy_client_t client, uint16_t remote_port)
+{
+	if (!client) {
+		return COMPANION_PROXY_E_INVALID_ARG;
+	}
+
+	plist_t dict = plist_new_dict();
+	plist_dict_set_item(dict, "Command", plist_new_string("StopForwardingServicePort"));
+	plist_dict_set_item(dict, "GizmoRemotePortNumber", plist_new_uint(remote_port));
+
+	companion_proxy_error_t res = companion_proxy_send(client, dict);
+	plist_free(dict);
+	dict = NULL;
+	if (res != COMPANION_PROXY_E_SUCCESS) {
+		return res;
+	}
+
+	res = companion_proxy_receive(client, &dict);
+	if (res != COMPANION_PROXY_E_SUCCESS) {
+		return res;
+	}
+	plist_free(dict);
+
+	return res;
+}

companion_proxy.h

@@ -0,0 +1,35 @@
+/*
+ * companion_proxy.h
+ * com.apple.companion_proxy service header file.
+ *
+ * Copyright (c) 2019-2020 Nikias Bassen, All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef __COMPANION_PROXY_H
+#define __COMPANION_PROXY_H
+
+#include "idevice.h"
+#include "libimobiledevice/companion_proxy.h"
+#include "property_list_service.h"
+#include <libimobiledevice-glue/thread.h>
+
+struct companion_proxy_client_private {
+	property_list_service_client_t parent;
+	THREAD_T event_thread;
+};
+
+#endif

configure.ac

@@ -0,0 +1,356 @@
+#                                               -*- Autoconf -*-
+# Process this file with autoconf to produce a configure script.
+
+AC_PREREQ([2.68])
+AC_INIT([libimobiledevice], [m4_esyscmd(./git-version-gen $RELEASE_VERSION)], [https://github.com/libimobiledevice/libimobiledevice/issues], [], [https://libimobiledevice.org])
+AM_INIT_AUTOMAKE([dist-bzip2 no-dist-gzip check-news])
+m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES])
+AC_CONFIG_SRCDIR([src/])
+AC_CONFIG_HEADERS([config.h])
+AC_CONFIG_MACRO_DIR([m4])
+
+dnl libtool versioning
+# +1 : 0 : +1  == adds new functions to the interface
+# +1 : 0 : 0   == changes or removes functions (changes include both
+#                 changes to the signature and the semantic)
+#  ? :+1 : ?   == just internal changes
+# CURRENT : REVISION : AGE
+LIBIMOBILEDEVICE_SO_VERSION=7:0:1
+
+AC_SUBST(LIBIMOBILEDEVICE_SO_VERSION)
+
+# Check if we have a version defined
+if test -z $PACKAGE_VERSION; then
+  AC_MSG_ERROR([PACKAGE_VERSION is not defined. Make sure to configure a source tree checked out from git or that .tarball-version is present.])
+fi
+
+dnl Minimum package versions
+LIBUSBMUXD_VERSION=2.0.2
+LIBPLIST_VERSION=2.3.0
+LIMD_GLUE_VERSION=1.3.0
+LIBTATSU_VERSION=1.0.3
+
+AC_SUBST(LIBUSBMUXD_VERSION)
+AC_SUBST(LIBPLIST_VERSION)
+AC_SUBST(LIMD_GLUE_VERSION)
+
+# Checks for programs.
+AC_PROG_CC
+AC_PROG_CXX
+AM_PROG_CC_C_O
+LT_INIT
+
+# Checks for libraries.
+PKG_CHECK_MODULES(libusbmuxd, libusbmuxd-2.0 >= $LIBUSBMUXD_VERSION)
+PKG_CHECK_MODULES(libplist, libplist-2.0 >= $LIBPLIST_VERSION)
+PKG_CHECK_MODULES(limd_glue, libimobiledevice-glue-1.0 >= $LIMD_GLUE_VERSION)
+PKG_CHECK_MODULES(libtatsu, libtatsu-1.0 >= $LIBTATSU_VERSION)
+AC_ARG_WITH([readline],
+            [AS_HELP_STRING([--without-readline],
+            [build without support for libreadline (default is yes)])],
+            [check_libreadline=false],
+            [check_libreadline=true])
+if test "$check_libreadline" = "true"; then
+  PKG_CHECK_MODULES(readline, readline >= 1.0, have_readline=yes, have_readline=no)
+  if test "x$have_readline" = "xyes"; then
+    AC_DEFINE(HAVE_READLINE, 1, [Define if readline library is available])
+  fi
+fi
+AM_CONDITIONAL([HAVE_READLINE],[test "x$have_readline" = "xyes"])
+
+# Checks for header files.
+AC_CHECK_HEADERS([stdint.h stdlib.h string.h sys/time.h])
+
+# Checks for typedefs, structures, and compiler characteristics.
+AC_C_CONST
+AC_TYPE_SIZE_T
+AC_TYPE_SSIZE_T
+AC_TYPE_UINT16_T
+AC_TYPE_UINT32_T
+AC_TYPE_UINT8_T
+
+# Checks for library functions.
+AC_CHECK_FUNCS([asprintf strcasecmp strdup strerror strndup stpcpy vasprintf getifaddrs gettimeofday localtime_r])
+
+AC_CHECK_HEADER(endian.h, [ac_cv_have_endian_h="yes"], [ac_cv_have_endian_h="no"])
+if test "x$ac_cv_have_endian_h" = "xno"; then
+  AC_DEFINE(__LITTLE_ENDIAN,1234,[little endian])
+  AC_DEFINE(__BIG_ENDIAN,4321,[big endian])
+  AC_C_BIGENDIAN([ac_cv_c_bigendian="yes"], [ac_cv_c_bigendian="no"], [], [])
+  if test "x$ac_cv_c_bigendian" = "xyes"; then
+    AC_DEFINE(__BYTE_ORDER,4321,[big endian byte order])
+  else
+    AC_DEFINE(__BYTE_ORDER,1234,[little endian byte order])
+  fi
+fi
+
+CACHED_CFLAGS="$CFLAGS"
+CFLAGS+=" $libplist_CFLAGS -Werror"
+
+AC_CHECK_DECL([plist_from_json], [AC_DEFINE([HAVE_PLIST_JSON], [1], [Define if libplist has JSON support])], [], [[#include <plist/plist.h>]])
+
+# check if libplist has plist_new_unix_date()
+AC_CACHE_CHECK(for plist_new_unix_date, ac_cv_plist_unix_date,
+	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+		#include <plist/plist.h>
+		]], [[
+			return plist_new_unix_date(0) ? 0 : 1
+		]])],[ac_cv_plist_unix_date=yes],[ac_cv_plist_unix_date=no]))
+if test "$ac_cv_plist_unix_date" = "yes"; then
+	AC_DEFINE(HAVE_PLIST_UNIX_DATE, 1, [Define if libplist has new unix date API (>= 2.7.0)])
+fi
+
+CFLAGS="$CACHED_CFLAGS"
+
+# Check for operating system
+AC_MSG_CHECKING([for platform-specific build settings])
+case ${host_os} in
+  *mingw32*|*cygwin*)
+    AC_MSG_RESULT([${host_os}])
+    win32=true
+    AC_DEFINE(WINVER, 0x0501, [minimum Windows version])
+    deplibs_check_method='pass_all'
+    ;;
+  darwin*)
+    AC_MSG_RESULT([${host_os}])
+    darwin=true
+    ;;
+  *)
+    AC_MSG_RESULT([${host_os}])
+    AX_PTHREAD([], [AC_MSG_ERROR([pthread is required to build $PACKAGE_NAME])])
+    AC_CHECK_LIB(pthread, [pthread_once], [], [AC_MSG_ERROR([pthread with pthread_once required to build $PACKAGE_NAME])])
+    ;;
+esac
+AM_CONDITIONAL(WIN32, test x$win32 = xtrue)
+AM_CONDITIONAL(DARWIN, test x$darwin = xtrue)
+
+AC_CHECK_MEMBER(struct dirent.d_type, AC_DEFINE(HAVE_DIRENT_D_TYPE, 1, [define if struct dirent has member d_type]),, [#include <dirent.h>])
+
+# Cython Python Bindings
+AC_ARG_WITH([cython],
+            [AS_HELP_STRING([--without-cython],
+            [build Python bindings using Cython (default is yes)])],
+            [build_cython=false],
+            [build_cython=true])
+if test "$build_cython" = "true"; then
+            AC_PROG_CYTHON([3.0.0])
+            if [test "x$CYTHON" != "xfalse"]; then
+              AM_PATH_PYTHON([3.0], [
+                CYTHON_PYTHON
+                AS_COMPILER_FLAG([-Wno-cast-function-type -Werror], [
+                  CYTHON_CFLAGS+=" -Wno-cast-function-type"
+                  AC_SUBST([CYTHON_CFLAGS])
+                ], [])
+              ])
+            else
+              AC_MSG_WARN([Use the "--without-cython" option to avoid this warning.])
+            fi
+else
+            CYTHON=false
+fi
+if [test "x$CYTHON" != "xfalse"]; then
+            PKG_PROG_PKG_CONFIG
+            AC_MSG_CHECKING([for libplist Cython bindings])
+            CYTHON_PLIST_INCLUDE_DIR=$($PKG_CONFIG --variable=includedir libplist-2.0)/plist/cython
+            if [test ! -d "$CYTHON_PLIST_INCLUDE_DIR"]; then
+                CYTHON=false
+                CYTHON_SUB=
+                cython_python_bindings=no
+                AC_MSG_RESULT([no])
+                AC_MSG_WARN([Unable to find libplist Cython bindings. You should install your distribution specific libplist Cython bindings package.])
+            else
+                AC_SUBST([CYTHON_PLIST_INCLUDE_DIR])
+                AC_MSG_RESULT([$CYTHON_PLIST_INCLUDE_DIR])
+                CYTHON_SUB=cython
+                cython_python_bindings=yes
+            fi
+else
+            CYTHON_SUB=
+            cython_python_bindings=no
+fi
+AM_CONDITIONAL([HAVE_CYTHON],[test "x$CYTHON_SUB" = "xcython"])
+AC_SUBST([CYTHON_SUB])
+
+default_openssl=yes
+
+AC_ARG_WITH([mbedtls],
+            [AS_HELP_STRING([--without-mbedtls],
+            [Do not look for mbedtls])],
+            [use_mbedtls=$withval],
+            [use_mbedtls=no])
+if test "x$use_mbedtls" = "xyes"; then
+  default_openssl=no
+fi
+AC_ARG_WITH([gnutls],
+            [AS_HELP_STRING([--without-gnutls],
+            [Do not look for GnuTLS])],
+            [use_gnutls=$withval],
+            [use_gnutls=no])
+if test "x$use_gnutls" = "xyes"; then
+  default_openssl=no
+fi
+AC_ARG_WITH([openssl],
+            [AS_HELP_STRING([--without-openssl],
+            [Do not look for OpenSSL])],
+            [use_openssl=$withval],
+            [use_openssl=$default_openssl])
+
+if test "x$use_mbedtls" = "xyes"; then
+  CACHED_CFLAGS="$CFLAGS"
+  conf_mbedtls_CFLAGS=""
+  if test -n "$mbedtls_INCLUDES"; then
+    CFLAGS=" -I$mbedtls_INCLUDES"
+    conf_mbedtls_CFLAGS="-I$mbedtls_INCLUDES"
+  fi
+  conf_mbedtls_LIBS=""
+  if test -n "$mbedtls_LIBDIR"; then
+    conf_mbedtls_LIBS+=" -L$mbedtls_LIBDIR"
+  fi
+  if test -n "$mbedtls_LIBS"; then
+    conf_mbedtls_LIBS+=" $mbedtls_LIBS"
+  else
+    conf_mbedtls_LIBS+=" -lmbedtls -lmbedx509 -lmbedcrypto"
+  fi
+  AC_CHECK_HEADER(mbedtls/ssl.h, [break], [AC_MSG_ERROR([MbedTLS support explicitly requested, but includes could not be found. Try setting mbedtls_INCLUDES=/path/to/mbedtls/include])])
+  CFLAGS="$CACHED_CFLAGS"
+  AC_DEFINE(HAVE_MBEDTLS, 1, [Define if you have MbedTLS support])
+  ssl_lib_CFLAGS="$conf_mbedtls_CFLAGS"
+  ssl_lib_LIBS="$conf_mbedtls_LIBS"
+  AC_SUBST(ssl_lib_CFLAGS)
+  AC_SUBST(ssl_lib_LIBS)
+  ssl_provider="MbedTLS";
+  ssl_requires=""
+  AC_SUBST(ssl_requires)
+else
+  if test "x$use_openssl" = "xyes"; then
+    pkg_req_openssl="openssl >= 0.9.8"
+    PKG_CHECK_MODULES(openssl, $pkg_req_openssl, have_openssl=yes, have_openssl=no)
+    if test "x$have_openssl" != "xyes"; then
+      AC_MSG_ERROR([OpenSSL support explicitly requested but OpenSSL could not be found])
+    else
+      AC_DEFINE(HAVE_OPENSSL, 1, [Define if you have OpenSSL support])
+      ssl_lib_CFLAGS="$openssl_CFLAGS"
+      ssl_lib_LIBS="$openssl_LIBS"
+      AC_SUBST(ssl_lib_CFLAGS)
+      AC_SUBST(ssl_lib_LIBS)
+      ssl_provider="OpenSSL";
+      ssl_requires="$pkg_req_openssl"
+      # test if we have LibreSSL
+      CACHED_CFLAGS="$CFLAGS"
+      CFLAGS="$openssl_CFLAGS"
+      ac_cv_is_libressl=no
+      AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
+        [[
+          #include <openssl/opensslv.h>
+        ]], [
+          #ifndef LIBRESSL_VERSION_NUMBER
+          #error No LibreSSL
+          #endif
+        ])],
+        [
+          ac_cv_is_libressl=yes
+        ],
+      )
+      CFLAGS="$CACHED_CFLAGS"
+      if test "x$ac_cv_is_libressl" = "xyes"; then
+        ssl_provider="LibreSSL"
+        case ${host_os} in
+          darwin*)
+            case ${openssl_LIBS} in
+              *.tbd*)
+                # using system LibreSSL on Darwin
+                ssl_requires=""
+                ;;
+            esac
+            ;;
+        esac
+      fi
+      AC_SUBST(ssl_requires)
+    fi
+  else
+    if test "x$use_gnutls" = "xyes"; then
+      pkg_req_gnutls="gnutls >= 2.2.0"
+      pkg_req_libtasn1="libtasn1 >= 1.1"
+      PKG_CHECK_MODULES(libgnutls, $pkg_req_gnutls)
+      AC_CHECK_HEADERS([gcrypt.h])
+      AC_CHECK_LIB(gcrypt, gcry_control, [AC_SUBST(libgcrypt_LIBS,[-lgcrypt])], [AC_MSG_ERROR([libgcrypt is required to build libimobiledevice with GnuTLS])])
+      PKG_CHECK_MODULES(libtasn1, $pkg_req_libtasn1)
+      AC_DEFINE(HAVE_GCRYPT, 1, [Define if you have libgcrypt support])
+      AC_DEFINE(HAVE_GNUTLS, 1, [Define if you have GnuTLS support])
+      ssl_lib_CFLAGS="$libgnutls_CFLAGS $libtasn1_CFLAGS $libgcrypt_CFLAGS"
+      ssl_lib_LIBS="$libgnutls_LIBS $libtasn1_LIBS $libgcrypt_LIBS"
+      AC_SUBST(ssl_lib_CFLAGS)
+      AC_SUBST(ssl_lib_LIBS)
+      ssl_provider="GnuTLS"
+      ssl_requires="$pkg_req_gnutls $pkg_req_libtasn1"
+      AC_SUBST(ssl_requires)
+    else
+      AC_MSG_ERROR([No SSL library configured. $PACKAGE cannot be built without a supported SSL library.])
+    fi
+  fi
+fi
+AM_CONDITIONAL(HAVE_MBEDTLS, test "x$use_mbedtls" = "xyes")
+AM_CONDITIONAL(HAVE_OPENSSL, test "x$use_openssl" = "xyes")
+AM_CONDITIONAL(HAVE_GCRYPT, test "x$use_gnutls" = "xyes")
+
+AC_ARG_ENABLE([wireless-pairing],
+            [AS_HELP_STRING([--disable-wireless-pairing],
+            [Do not build with wirless pairing support (default is yes)])])
+if test "$enable_wireless_pairing" != "no"; then
+  AC_DEFINE(HAVE_WIRELESS_PAIRING,1,[Define if building with wireless pairing support])
+fi
+AM_CONDITIONAL(HAVE_WIRELESS_PAIRING, test "$enable_wireless_pairing" != "no")
+
+AC_ARG_ENABLE([debug],
+            [AS_HELP_STRING([--enable-debug],
+            [build debug message output code (default is no)])],
+            [no_debug_code=false],
+            [no_debug_code=true])
+if test "$no_debug_code" = true; then
+	building_debug_code=no
+	AC_DEFINE(STRIP_DEBUG_CODE,1,[Define if debug message output code should not be built.])
+else
+	building_debug_code=yes
+fi
+
+AS_COMPILER_FLAGS(GLOBAL_CFLAGS, "-Wall -Wextra -Wmissing-declarations -Wredundant-decls -Wshadow -Wpointer-arith -Wwrite-strings -Wswitch-default -Wno-unused-parameter -fsigned-char -fvisibility=hidden")
+
+if test "x$enable_static" = "xyes" -a "x$enable_shared" = "xno"; then
+  GLOBAL_CFLAGS+=" -DLIBIMOBILEDEVICE_STATIC"
+fi
+
+AC_SUBST(GLOBAL_CFLAGS)
+
+# check for large file support
+AC_SYS_LARGEFILE
+
+m4_ifdef([AM_SILENT_RULES],[AM_SILENT_RULES([yes])])
+
+AC_CONFIG_FILES([
+Makefile
+3rd_party/Makefile
+3rd_party/ed25519/Makefile
+3rd_party/libsrp6a-sha512/Makefile
+common/Makefile
+src/Makefile
+src/libimobiledevice-1.0.pc
+include/Makefile
+tools/Makefile
+cython/Makefile
+docs/Makefile
+doxygen.cfg
+])
+AC_OUTPUT
+
+echo "
+Configuration for $PACKAGE $VERSION:
+-------------------------------------------
+
+  Install prefix: .........: $prefix
+  Debug code ..............: $building_debug_code
+  Python bindings .........: $cython_python_bindings
+  SSL support backend .....: $ssl_provider
+
+  Now type 'make' to build $PACKAGE $VERSION,
+  and then 'make install' for installation.
+"

cython_python.m4

@@ -0,0 +1,7 @@
+AC_DEFUN([CYTHON_PYTHON],[
+        AC_REQUIRE([AC_PROG_CYTHON])
+        AC_REQUIRE([AX_PYTHON_DEVEL])
+        test "x$1" != "xno" || cython_shadow=" -noproxy"
+        AC_SUBST([CYTHON_PYTHON_OPT],[-python$cython_shadow])
+        AC_SUBST([CYTHON_PYTHON_CPPFLAGS],[$PYTHON_CPPFLAGS])
+])

debug.c

@@ -0,0 +1,174 @@
+/*
+ * debug.c
+ * contains utilitary functions for debugging
+ *
+ * Copyright (c) 2008 Jonathan Beck All Rights Reserved.
+ * Copyright (c) 2010 Martin S. All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <stdarg.h>
+#define _GNU_SOURCE 1
+#define __USE_GNU 1
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <time.h>
+#ifndef _WIN32
+#include <sys/time.h>
+#endif
+
+#include "src/idevice.h"
+#include "debug.h"
+#include "libimobiledevice/libimobiledevice.h"
+
+#ifndef STRIP_DEBUG_CODE
+#include "asprintf.h"
+#endif
+
+static int debug_level;
+
+void internal_set_debug_level(int level)
+{
+	debug_level = level;
+}
+
+#define MAX_PRINT_LEN (16*1024)
+
+#ifndef STRIP_DEBUG_CODE
+static void debug_print_line(const char *func, const char *file, int line, const char *buffer)
+{
+	char str_time[24];
+#ifdef _WIN32
+	SYSTEMTIME lt;
+	GetLocalTime(&lt);
+	snprintf(str_time, 24, "%02d:%02d:%02d.%03d", lt.wHour, lt.wMinute, lt.wSecond, lt.wMilliseconds);
+#else
+#ifdef HAVE_GETTIMEOFDAY
+	struct timeval tv;
+	struct tm *tp;
+	gettimeofday(&tv, NULL);
+#ifdef HAVE_LOCALTIME_R
+	struct tm tp_;
+	tp = localtime_r(&tv.tv_sec, &tp_);
+#else
+	tp = localtime(&tv.tv_sec);
+#endif
+	strftime(str_time, 9, "%H:%M:%S", tp);
+	snprintf(str_time+8, 10, ".%03d", (int)tv.tv_usec/1000);
+#else
+	time_t the_time;
+	time(&the_time);
+	strftime(str_time, 15, "%H:%M:%S", localtime (&the_time));
+#endif
+#endif
+	fprintf(stderr, "%s %s:%d %s(): %s\n", str_time, file, line, func, buffer);
+}
+#endif
+
+void debug_info_real(const char *func, const char *file, int line, const char *format, ...)
+{
+#ifndef STRIP_DEBUG_CODE
+	va_list args;
+	char *buffer = NULL;
+
+	if (!debug_level)
+		return;
+
+	/* run the real fprintf */
+	va_start(args, format);
+	if(vasprintf(&buffer, format, args)<0){}
+	va_end(args);
+
+	debug_print_line(func, file, line, buffer);
+
+	free(buffer);
+#endif
+}
+
+void debug_buffer(const char *data, const int length)
+{
+#ifndef STRIP_DEBUG_CODE
+	int i;
+	int j;
+	unsigned char c;
+
+	if (debug_level) {
+		for (i = 0; i < length; i += 16) {
+			fprintf(stderr, "%04x: ", i);
+			for (j = 0; j < 16; j++) {
+				if (i + j >= length) {
+					fprintf(stderr, "   ");
+					continue;
+				}
+				fprintf(stderr, "%02x ", *(data + i + j) & 0xff);
+			}
+			fprintf(stderr, "  | ");
+			for (j = 0; j < 16; j++) {
+				if (i + j >= length)
+					break;
+				c = *(data + i + j);
+				if ((c < 32) || (c > 127)) {
+					fprintf(stderr, ".");
+					continue;
+				}
+				fprintf(stderr, "%c", c);
+			}
+			fprintf(stderr, "\n");
+		}
+		fprintf(stderr, "\n");
+	}
+#endif
+}
+
+void debug_buffer_to_file(const char *file, const char *data, const int length)
+{
+#ifndef STRIP_DEBUG_CODE
+	if (debug_level) {
+		FILE *f = fopen(file, "wb");
+		fwrite(data, 1, length, f);
+		fflush(f);
+		fclose(f);
+	}
+#endif
+}
+
+void debug_plist_real(const char *func, const char *file, int line, plist_t plist)
+{
+#ifndef STRIP_DEBUG_CODE
+	if (!plist)
+		return;
+
+	char *buffer = NULL;
+	uint32_t length = 0;
+	plist_to_xml(plist, &buffer, &length);
+
+	/* get rid of ending newline as one is already added in the debug line */
+	if (buffer[length-1] == '\n')
+		buffer[length-1] = '\0';
+
+	if (length <= MAX_PRINT_LEN)
+		debug_info_real(func, file, line, "printing %i bytes plist:\n%s", length, buffer);
+	else
+		debug_info_real(func, file, line, "supress printing %i bytes plist...\n", length);
+
+	free(buffer);
+#endif
+}
+

debug.h

@@ -0,0 +1,53 @@
+/*
+ * debug.h
+ * contains utilitary functions for debugging
+ *
+ * Copyright (c) 2008 Jonathan Beck All Rights Reserved.
+ * Copyright (c) 2010 Martin S. All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef __DEBUG_H
+#define __DEBUG_H
+
+#include <plist/plist.h>
+
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L && !defined(STRIP_DEBUG_CODE)
+#define debug_info(...) debug_info_real (__func__, __FILE__, __LINE__, __VA_ARGS__)
+#define debug_plist(a) debug_plist_real (__func__, __FILE__, __LINE__, a)
+#elif defined(__GNUC__) && __GNUC__ >= 3 && !defined(STRIP_DEBUG_CODE)
+#define debug_info(...) debug_info_real (__FUNCTION__, __FILE__, __LINE__, __VA_ARGS__)
+#define debug_plist(a) debug_plist_real (__FUNCTION__, __FILE__, __LINE__, a)
+#else
+#define debug_info(...)
+#define debug_plist(a)
+#endif
+
+void debug_info_real(const char *func,
+											const char *file,
+											int	line,
+											const char *format, ...);
+
+void debug_buffer(const char *data, const int length);
+void debug_buffer_to_file(const char *file, const char *data, const int length);
+void debug_plist_real(const char *func,
+											const char *file,
+											int	line,
+											plist_t plist);
+
+void internal_set_debug_level(int level);
+
+#endif

debugserver.c

@@ -0,0 +1,657 @@
+/*
+ * debugserver.c
+ * com.apple.debugserver service implementation.
+ *
+ * Copyright (c) 2019 Nikias Bassen, All Rights Reserved.
+ * Copyright (c) 2014-2015 Martin Szulecki All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <string.h>
+#include <stdlib.h>
+#define _GNU_SOURCE 1
+#define __USE_GNU 1
+#include <stdio.h>
+
+#include <libimobiledevice-glue/utils.h>
+
+#include "debugserver.h"
+#include "lockdown.h"
+#include "common/debug.h"
+#include "asprintf.h"
+
+/**
+ * Convert a service_error_t value to a debugserver_error_t value.
+ * Used internally to get correct error codes.
+ *
+ * @param err An service_error_t error code
+ *
+ * @return A matching debugserver_error_t error code,
+ *     DEBUGSERVER_E_UNKNOWN_ERROR otherwise.
+ */
+static debugserver_error_t debugserver_error(service_error_t err)
+{
+	switch (err) {
+		case SERVICE_E_SUCCESS:
+			return DEBUGSERVER_E_SUCCESS;
+		case SERVICE_E_INVALID_ARG:
+			return DEBUGSERVER_E_INVALID_ARG;
+		case SERVICE_E_MUX_ERROR:
+			return DEBUGSERVER_E_MUX_ERROR;
+		case SERVICE_E_SSL_ERROR:
+			return DEBUGSERVER_E_SSL_ERROR;
+		case SERVICE_E_TIMEOUT:
+			return DEBUGSERVER_E_TIMEOUT;
+		default:
+			break;
+	}
+	return DEBUGSERVER_E_UNKNOWN_ERROR;
+}
+
+debugserver_error_t debugserver_client_new(idevice_t device, lockdownd_service_descriptor_t service, debugserver_client_t* client)
+{
+	*client = NULL;
+
+	if (!device || !service || service->port == 0 || !client || *client) {
+		debug_info("Incorrect parameter passed to debugserver_client_new.");
+		return DEBUGSERVER_E_INVALID_ARG;
+	}
+
+	debug_info("Creating debugserver_client, port = %d.", service->port);
+
+	service_client_t parent = NULL;
+	debugserver_error_t ret = debugserver_error(service_client_new(device, service, &parent));
+	if (ret != DEBUGSERVER_E_SUCCESS) {
+		debug_info("Creating base service client failed. Error: %i", ret);
+		return ret;
+	}
+
+	if (service->identifier && (strcmp(service->identifier, DEBUGSERVER_SECURE_SERVICE_NAME) != 0)) {
+		service_disable_bypass_ssl(parent, 1);
+	}
+
+	debugserver_client_t client_loc = (debugserver_client_t) malloc(sizeof(struct debugserver_client_private));
+	client_loc->parent = parent;
+	client_loc->noack_mode = 0;
+	client_loc->cancel_receive = NULL;
+	client_loc->receive_loop_timeout = 1000;
+
+	*client = client_loc;
+
+	debug_info("debugserver_client successfully created.");
+	return DEBUGSERVER_E_SUCCESS;
+}
+
+debugserver_error_t debugserver_client_start_service(idevice_t device, debugserver_client_t * client, const char* label)
+{
+	debugserver_error_t err = DEBUGSERVER_E_UNKNOWN_ERROR;
+	service_client_factory_start_service(device, DEBUGSERVER_SECURE_SERVICE_NAME, (void**)client, label, SERVICE_CONSTRUCTOR(debugserver_client_new), &err);
+	if (err != DEBUGSERVER_E_SUCCESS) {
+		err = DEBUGSERVER_E_UNKNOWN_ERROR;
+		service_client_factory_start_service(device, DEBUGSERVER_SERVICE_NAME, (void**)client, label, SERVICE_CONSTRUCTOR(debugserver_client_new), &err);
+	}
+	return err;
+}
+
+debugserver_error_t debugserver_client_free(debugserver_client_t client)
+{
+	if (!client)
+		return DEBUGSERVER_E_INVALID_ARG;
+
+	debugserver_error_t err = debugserver_error(service_client_free(client->parent));
+	client->parent = NULL;
+	free(client);
+
+	return err;
+}
+
+debugserver_error_t debugserver_client_send(debugserver_client_t client, const char* data, uint32_t size, uint32_t *sent)
+{
+	debugserver_error_t res = DEBUGSERVER_E_UNKNOWN_ERROR;
+	int bytes = 0;
+
+	if (!client || !data || (size == 0)) {
+		return DEBUGSERVER_E_INVALID_ARG;
+	}
+
+	debug_info("sending %d bytes", size);
+	res = debugserver_error(service_send(client->parent, data, size, (uint32_t*)&bytes));
+	if (bytes <= 0) {
+		debug_info("ERROR: sending to device failed.");
+	}
+	if (sent) {
+		*sent = (uint32_t)bytes;
+	}
+
+	return res;
+}
+
+debugserver_error_t debugserver_client_receive_with_timeout(debugserver_client_t client, char* data, uint32_t size, uint32_t *received, unsigned int timeout)
+{
+	debugserver_error_t res = DEBUGSERVER_E_UNKNOWN_ERROR;
+	int bytes = 0;
+
+	if (!client || !data || (size == 0)) {
+		return DEBUGSERVER_E_INVALID_ARG;
+	}
+
+	res = debugserver_error(service_receive_with_timeout(client->parent, data, size, (uint32_t*)&bytes, timeout));
+	if (bytes <= 0 && res != DEBUGSERVER_E_TIMEOUT) {
+		debug_info("Could not read data, error %d", res);
+	}
+	if (received) {
+		*received = (uint32_t)bytes;
+	}
+
+	return (bytes > 0) ? DEBUGSERVER_E_SUCCESS : res;
+}
+
+debugserver_error_t debugserver_client_receive(debugserver_client_t client, char* data, uint32_t size, uint32_t *received)
+{
+	debugserver_error_t res = DEBUGSERVER_E_UNKNOWN_ERROR;
+	do {
+		/* Is this allowed to return DEBUGSERVER_E_TIMEOUT and also set data and received? */
+		res = debugserver_client_receive_with_timeout(client, data, size, received, client->receive_loop_timeout);
+	} while (res == DEBUGSERVER_E_TIMEOUT && client->cancel_receive != NULL && !client->cancel_receive());
+	return res;
+}
+
+debugserver_error_t debugserver_command_new(const char* name, int argc, char* argv[], debugserver_command_t* command)
+{
+	int i;
+	debugserver_command_t tmp = (debugserver_command_t) malloc(sizeof(struct debugserver_command_private));
+
+	/* copy name */
+	tmp->name = strdup(name);
+
+	/* copy arguments */
+	tmp->argc = argc;
+	tmp->argv = NULL;
+	if (argc > 0) {
+		tmp->argv = malloc(sizeof(char*) * (argc + 2));
+		for (i = 0; i < argc; i++) {
+			tmp->argv[i] = strdup(argv[i]);
+		}
+		tmp->argv[i+1] = NULL;
+	}
+
+	/* return */
+	*command = tmp;
+
+	return DEBUGSERVER_E_SUCCESS;
+}
+
+debugserver_error_t debugserver_command_free(debugserver_command_t command)
+{
+	int i;
+	debugserver_error_t res = DEBUGSERVER_E_UNKNOWN_ERROR;
+
+	if (!command)
+		return DEBUGSERVER_E_INVALID_ARG;
+
+	if (command) {
+		if (command->name)
+			free(command->name);
+		if (command->argv && command->argc) {
+			for (i = 0; i < command->argc; i++) {
+				free(command->argv[i]);
+			}
+			free(command->argv);
+		}
+		free(command);
+		res = DEBUGSERVER_E_SUCCESS;
+	}
+
+	return res;
+}
+
+static int debugserver_hex2int(char c)
+{
+	if (c >= '0' && c <= '9')
+		return c - '0';
+	else if (c >= 'a' && c <= 'f')
+		return 10 + c - 'a';
+	else if (c >= 'A' && c <= 'F')
+		return 10 + c - 'A';
+	else
+		return c;
+}
+
+static char debugserver_int2hex(int x)
+{
+	const char *hexchars = "0123456789ABCDEF";
+	return hexchars[x];
+}
+
+#define DEBUGSERVER_HEX_ENCODE_FIRST_BYTE(byte) debugserver_int2hex(((byte) >> 0x4) & 0xf)
+#define DEBUGSERVER_HEX_ENCODE_SECOND_BYTE(byte) debugserver_int2hex((byte) & 0xf)
+#define DEBUGSERVER_HEX_DECODE_FIRST_BYTE(byte) (((byte) >> 0x4) & 0xf)
+#define DEBUGSERVER_HEX_DECODE_SECOND_BYTE(byte) ((byte) & 0xf)
+
+static uint32_t debugserver_get_checksum_for_buffer(const char* buffer, uint32_t size)
+{
+	uint32_t checksum = 0;
+	uint32_t i;
+
+	for (i = 0; i < size; i++) {
+		checksum += buffer[i];
+	}
+
+	return checksum;
+}
+
+static int debugserver_response_is_checksum_valid(const char* response, uint32_t size)
+{
+	uint32_t checksum = 0;
+	if ((size - DEBUGSERVER_CHECKSUM_HASH_LENGTH - 1) > 0)
+		checksum = debugserver_get_checksum_for_buffer(&response[1], size - DEBUGSERVER_CHECKSUM_HASH_LENGTH - 1);
+
+	debug_info("checksum: 0x%x", checksum);
+
+	if ((unsigned)debugserver_hex2int(response[size - 2]) != DEBUGSERVER_HEX_DECODE_FIRST_BYTE(checksum))
+		return 0;
+
+	if ((unsigned)debugserver_hex2int(response[size - 1]) != DEBUGSERVER_HEX_DECODE_SECOND_BYTE(checksum))
+		return 0;
+
+	debug_info("valid checksum");
+
+	return 1;
+}
+
+void debugserver_encode_string(const char* buffer, char** encoded_buffer, uint32_t* encoded_length)
+{
+	uint32_t position;
+	uint32_t index;
+	uint32_t length = strlen(buffer);
+	*encoded_length = (2 * length) + DEBUGSERVER_CHECKSUM_HASH_LENGTH + 1;
+
+	*encoded_buffer = malloc(sizeof(char) * (*encoded_length));
+	memset(*encoded_buffer, '\0', *encoded_length);
+	for (position = 0, index = 0; index < length; index++) {
+		position = (index * (2 * sizeof(char)));
+		(*encoded_buffer)[position] = DEBUGSERVER_HEX_ENCODE_FIRST_BYTE(buffer[index]);
+		(*encoded_buffer)[position + 1] = DEBUGSERVER_HEX_ENCODE_SECOND_BYTE(buffer[index]);
+	}
+}
+
+void debugserver_decode_string(const char *encoded_buffer, size_t encoded_length, char** buffer)
+{
+	*buffer = malloc(sizeof(char) * ((encoded_length / 2)+1));
+	char* t = *buffer;
+	const char *f = encoded_buffer;
+	const char *fend = f + encoded_length;
+	while (f < fend) {
+		*t++ = debugserver_hex2int(*f) << 4 | debugserver_hex2int(f[1]);
+		f += 2;
+	}
+	*t = '\0';
+}
+
+static void debugserver_format_command(const char* prefix, const char* command, const char* arguments, int calculate_checksum, char** buffer, uint32_t* size)
+{
+	char checksum_hash[DEBUGSERVER_CHECKSUM_HASH_LENGTH + 1] = {'#', '0', '0', '\0'};
+	char* encoded = NULL;
+	uint32_t encoded_length = 0;
+
+	if (arguments) {
+		/* arguments must be hex encoded */
+		debugserver_encode_string(arguments, &encoded, &encoded_length);
+	} else {
+		encoded = NULL;
+	}
+
+	char* encoded_command = string_concat(command, encoded, NULL);
+	encoded_length = strlen(encoded_command);
+
+	if (calculate_checksum) {
+		uint32_t checksum = debugserver_get_checksum_for_buffer(encoded_command, encoded_length);
+		checksum_hash[1] = DEBUGSERVER_HEX_ENCODE_FIRST_BYTE(checksum);
+		checksum_hash[2] = DEBUGSERVER_HEX_ENCODE_SECOND_BYTE(checksum);
+	}
+
+	*buffer = string_concat(prefix, encoded_command, checksum_hash, NULL);
+	*size = strlen(prefix) + strlen(encoded_command) + DEBUGSERVER_CHECKSUM_HASH_LENGTH;
+
+	debug_info("formatted command: %s size: %d checksum: 0x%s", *buffer, *size, checksum_hash);
+
+	if (encoded_command)
+		free(encoded_command);
+
+	if (encoded)
+		free(encoded);
+}
+
+static debugserver_error_t debugserver_client_send_ack(debugserver_client_t client)
+{
+	debug_info("sending ACK");
+	return debugserver_client_send(client, "+", sizeof(char), NULL);
+}
+
+static debugserver_error_t debugserver_client_send_noack(debugserver_client_t client)
+{
+	debug_info("sending !ACK");
+	return debugserver_client_send(client, "-", sizeof(char), NULL);
+}
+
+debugserver_error_t debugserver_client_set_ack_mode(debugserver_client_t client, int enabled)
+{
+	if (!client)
+		return DEBUGSERVER_E_INVALID_ARG;
+
+	client->noack_mode = (enabled == 0)? 1: 0;
+
+	debug_info("ack mode: %s", client->noack_mode == 0 ? "on": "off");
+
+	return DEBUGSERVER_E_SUCCESS;
+}
+
+debugserver_error_t debugserver_client_set_receive_params(debugserver_client_t client, int (*cancel_receive)(), int receive_loop_timeout)
+{
+	if (!client)
+		return DEBUGSERVER_E_INVALID_ARG;
+
+	client->cancel_receive = cancel_receive;
+	client->receive_loop_timeout = receive_loop_timeout;
+
+	debug_info("receive params: cancel_receive %s, receive_loop_timeout %dms", (client->cancel_receive == NULL ? "unset": "set"), client->receive_loop_timeout);
+
+	return DEBUGSERVER_E_SUCCESS;
+}
+
+static debugserver_error_t debugserver_client_receive_internal_char(debugserver_client_t client, char* received_char)
+{
+	debugserver_error_t res = DEBUGSERVER_E_SUCCESS;
+	uint32_t bytes = 0;
+
+	/* we loop here as we expect an answer */
+	res = debugserver_client_receive(client, received_char, sizeof(char), &bytes);
+	if (res != DEBUGSERVER_E_SUCCESS) {
+		return res;
+	}
+	if (bytes != 1) {
+		debug_info("received %d bytes when asking for %d!", bytes, sizeof(char));
+		return DEBUGSERVER_E_UNKNOWN_ERROR;
+	}
+	return res;
+}
+
+debugserver_error_t debugserver_client_receive_response(debugserver_client_t client, char** response, size_t* response_size)
+{
+	debugserver_error_t res = DEBUGSERVER_E_SUCCESS;
+
+	char data = '\0';
+	int skip_prefix = 0;
+
+	char* buffer = malloc(1024);
+	uint32_t buffer_size = 0;
+	uint32_t buffer_capacity = 1024;
+
+	if (response)
+		*response = NULL;
+
+	if (!client->noack_mode) {
+		debug_info("attempting to receive ACK (+)");
+		res = debugserver_client_receive_internal_char(client, &data);
+		if (res != DEBUGSERVER_E_SUCCESS) {
+			goto cleanup;
+		}
+		if (data == '+') {
+			debug_info("received ACK (+)");
+		} else if (data == '$') {
+			debug_info("received prefix ($)");
+			buffer[0] = '$';
+			buffer_size = 1;
+			skip_prefix = 1;
+		} else {
+			debug_info("unrecognized response when looking for ACK: %c", data);
+			goto cleanup;
+		}
+	}
+
+	debug_info("skip_prefix: %d", skip_prefix);
+
+	if (!skip_prefix) {
+		debug_info("attempting to receive prefix ($)");
+		res = debugserver_client_receive_internal_char(client, &data);
+		if (res != DEBUGSERVER_E_SUCCESS) {
+			goto cleanup;
+		}
+		if (data == '$') {
+			debug_info("received prefix ($)");
+			buffer[0] = '$';
+			buffer_size = 1;
+		} else {
+			debug_info("unrecognized response when looking for prefix: %c", data);
+			goto cleanup;
+		}
+	}
+
+	uint32_t checksum_length = DEBUGSERVER_CHECKSUM_HASH_LENGTH;
+	int receiving_checksum_response = 0;
+	debug_info("attempting to read up response until checksum");
+
+	while ((checksum_length > 0)) {
+		res = debugserver_client_receive_internal_char(client, &data);
+		if (res != DEBUGSERVER_E_SUCCESS) {
+			goto cleanup;
+		}
+		if (data == '#') {
+			receiving_checksum_response = 1;
+		}
+		if (receiving_checksum_response) {
+			checksum_length--;
+		}
+		if (buffer_size + 1 >= buffer_capacity) {
+			char* newbuffer = realloc(buffer, buffer_capacity+1024);
+			if (!newbuffer) {
+				return DEBUGSERVER_E_UNKNOWN_ERROR;
+			}
+			buffer = newbuffer;
+			buffer_capacity += 1024;
+		}
+		buffer[buffer_size] = data;
+		buffer_size += sizeof(char);
+	}
+	debug_info("validating response checksum...");
+	if (client->noack_mode || debugserver_response_is_checksum_valid(buffer, buffer_size)) {
+		if (response) {
+			/* assemble response string */
+			uint32_t resp_size = sizeof(char) * (buffer_size - DEBUGSERVER_CHECKSUM_HASH_LENGTH - 1);
+			*response = (char*)malloc(resp_size + 1);
+			memcpy(*response, buffer + 1, resp_size);
+			(*response)[resp_size] = '\0';
+			if (response_size) *response_size = resp_size;
+		}
+		if (!client->noack_mode) {
+			/* confirm valid command */
+			debugserver_client_send_ack(client);
+		}
+	} else {
+		/* response was invalid */
+		res = DEBUGSERVER_E_RESPONSE_ERROR;
+		if (!client->noack_mode) {
+			/* report invalid command */
+			debugserver_client_send_noack(client);
+		}
+	}
+
+cleanup:
+	if (response) {
+		debug_info("response: %s", *response);
+	}
+
+	if (buffer)
+		free(buffer);
+
+	return res;
+}
+
+debugserver_error_t debugserver_client_send_command(debugserver_client_t client, debugserver_command_t command, char** response, size_t* response_size)
+{
+	debugserver_error_t res = DEBUGSERVER_E_SUCCESS;
+	int i;
+	uint32_t bytes = 0;
+
+	char* send_buffer = NULL;
+	uint32_t send_buffer_size = 0;
+
+	char* command_arguments = NULL;
+
+	/* concat all arguments */
+	for (i = 0; i < command->argc; i++) {
+		debug_info("argv[%d]: %s", i, command->argv[i]);
+		command_arguments = string_append(command_arguments, command->argv[i], NULL);
+	}
+
+	debug_info("command_arguments(%d): %s", command->argc, command_arguments);
+
+	/* encode command arguments, add checksum if required and assemble entire command */
+	debugserver_format_command("$", command->name, command_arguments, 1, &send_buffer, &send_buffer_size);
+
+	debug_info("sending encoded command: %s", send_buffer);
+
+	res = debugserver_client_send(client, send_buffer, send_buffer_size, &bytes);
+	debug_info("command result: %d", res);
+	if (res != DEBUGSERVER_E_SUCCESS) {
+		goto cleanup;
+	}
+
+	/* receive response */
+	res = debugserver_client_receive_response(client, response, response_size);
+	debug_info("response result: %d", res);
+	if (res != DEBUGSERVER_E_SUCCESS) {
+		goto cleanup;
+	}
+
+	if (response) {
+		debug_info("received response: %s", *response);
+	}
+
+	/* disable sending ack on the client */
+	if (!strncmp(command->name, "QStartNoAckMode", 16)) {
+		debugserver_client_set_ack_mode(client, 0);
+	}
+
+cleanup:
+	if (command_arguments)
+		free(command_arguments);
+
+	if (send_buffer)
+		free(send_buffer);
+
+	return res;
+}
+
+debugserver_error_t debugserver_client_set_environment_hex_encoded(debugserver_client_t client, const char* env, char** response)
+{
+	if (!client || !env)
+		return DEBUGSERVER_E_INVALID_ARG;
+
+	debugserver_error_t result = DEBUGSERVER_E_UNKNOWN_ERROR;
+	char* env_tmp = strdup(env);
+	char* env_arg[2] = { env_tmp, NULL };
+
+	debugserver_command_t command = NULL;
+	debugserver_command_new("QEnvironmentHexEncoded:", 1, env_arg, &command);
+	result = debugserver_client_send_command(client, command, response, NULL);
+	debugserver_command_free(command);
+
+	free(env_tmp);
+
+	return result;
+}
+
+debugserver_error_t debugserver_client_set_argv(debugserver_client_t client, int argc, char* argv[], char** response)
+{
+	if (!client || !argc)
+		return DEBUGSERVER_E_INVALID_ARG;
+
+	debugserver_error_t result = DEBUGSERVER_E_UNKNOWN_ERROR;
+	char *pkt = NULL;
+	size_t pkt_len = 0;
+	int i = 0;
+
+	/* calculate total length */
+	while (i < argc && argv && argv[i]) {
+		char *prefix = NULL;
+		int ret = asprintf(&prefix, ",%zu,%d,", strlen(argv[i]) * 2, i);
+		if (ret < 0 || prefix == NULL) {
+			debug_info("asprintf failed, out of memory?");
+			return DEBUGSERVER_E_UNKNOWN_ERROR;
+		}
+		pkt_len += strlen(prefix) + strlen(argv[i]) * 2;
+		free(prefix);
+		i++;
+	}
+
+	/* allocate packet and initialize it */
+	pkt = (char *) malloc(pkt_len + 1);
+	memset(pkt, 0, pkt_len + 1);
+
+	char *pktp = pkt;
+
+	i = 0;
+	while (i < argc && argv && argv[i]) {
+		debug_info("argv[%d] = \"%s\"", i, argv[i]);
+
+		char *prefix = NULL;
+		char *m = NULL;
+		size_t arg_len = strlen(argv[i]);
+		size_t arg_hexlen = arg_len * 2;
+
+		int ret = asprintf(&prefix, ",%zu,%d,", arg_hexlen, i);
+		if (ret < 0 || prefix == NULL) {
+			debug_info("asprintf failed, out of memory?");
+			return DEBUGSERVER_E_UNKNOWN_ERROR;
+		}
+
+		m = (char *) malloc(arg_hexlen);
+		char *p = m;
+		char *q = (char*)argv[i];
+		while (*q) {
+			*p++ = DEBUGSERVER_HEX_ENCODE_FIRST_BYTE(*q);
+			*p++ = DEBUGSERVER_HEX_ENCODE_SECOND_BYTE(*q);
+			q++;
+		}
+
+		memcpy(pktp, prefix, strlen(prefix));
+		pktp += strlen(prefix);
+
+		memcpy(pktp, m, arg_hexlen);
+		pktp += arg_hexlen;
+
+		free(prefix);
+		free(m);
+
+		i++;
+	}
+
+	pkt[0] = 'A';
+
+	debugserver_command_t command = NULL;
+	debugserver_command_new(pkt, 0, NULL, &command);
+	result = debugserver_client_send_command(client, command, response, NULL);
+	debugserver_command_free(command);
+
+	if (pkt)
+		free(pkt);
+
+	return result;
+}

debugserver.h

@@ -0,0 +1,44 @@
+/*
+ * debugserver.h
+ * com.apple.debugserver service header file.
+ *
+ * Copyright (c) 2014 Martin Szulecki All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef _DEBUGSERVER_H
+#define _DEBUGSERVER_H
+
+#include "idevice.h"
+#include "libimobiledevice/debugserver.h"
+#include "service.h"
+
+#define DEBUGSERVER_CHECKSUM_HASH_LENGTH 0x3
+
+struct debugserver_client_private {
+	service_client_t parent;
+	int noack_mode;
+	int (*cancel_receive)();
+	int receive_loop_timeout;
+};
+
+struct debugserver_command_private {
+	char* name;
+	int argc;
+	char** argv;
+};
+
+#endif

debugserver.pxi

@@ -0,0 +1,246 @@
+cdef extern from "libimobiledevice/debugserver.h":
+    cdef struct debugserver_client_private:
+        pass
+    ctypedef debugserver_client_private *debugserver_client_t
+    cdef struct debugserver_command_private:
+        pass
+    ctypedef debugserver_command_private *debugserver_command_t
+    ctypedef enum debugserver_error_t:
+        DEBUGSERVER_E_SUCCESS = 0
+        DEBUGSERVER_E_INVALID_ARG = -1
+        DEBUGSERVER_E_MUX_ERROR = -2
+        DEBUGSERVER_E_SSL_ERROR = -3
+        DEBUGSERVER_E_RESPONSE_ERROR = -4
+        DEBUGSERVER_E_UNKNOWN_ERROR = -256
+
+    debugserver_error_t debugserver_client_new(idevice_t device, lockdownd_service_descriptor_t service, debugserver_client_t * client)
+    debugserver_error_t debugserver_client_free(debugserver_client_t client)
+
+    debugserver_error_t debugserver_client_send(debugserver_client_t client, const char* data, uint32_t size, uint32_t *sent)
+    debugserver_error_t debugserver_client_send_command(debugserver_client_t client, debugserver_command_t command, char** response, size_t* response_size)
+    debugserver_error_t debugserver_client_receive(debugserver_client_t client, char *data, uint32_t size, uint32_t *received)
+    debugserver_error_t debugserver_client_receive_with_timeout(debugserver_client_t client, char *data, uint32_t size, uint32_t *received, unsigned int timeout)
+    debugserver_error_t debugserver_client_receive_response(debugserver_client_t client, char** response, size_t* response_size)
+    debugserver_error_t debugserver_client_set_argv(debugserver_client_t client, int argc, char* argv[], char** response)
+    debugserver_error_t debugserver_client_set_environment_hex_encoded(debugserver_client_t client, const char* env, char** response)
+
+    debugserver_error_t debugserver_command_new(const char* name, int argc, const char* argv[], debugserver_command_t* command)
+    debugserver_error_t debugserver_command_free(debugserver_command_t command)
+    void debugserver_encode_string(const char* buffer, char** encoded_buffer, uint32_t* encoded_length)
+    void debugserver_decode_string(const char *encoded_buffer, size_t encoded_length, char** buffer)
+
+
+cdef class DebugServerError(BaseError):
+    def __init__(self, *args, **kwargs):
+        self._lookup_table = {
+            DEBUGSERVER_E_SUCCESS: "Success",
+            DEBUGSERVER_E_INVALID_ARG: "Invalid argument",
+            DEBUGSERVER_E_MUX_ERROR: "MUX error",
+            DEBUGSERVER_E_SSL_ERROR: "SSL error",
+            DEBUGSERVER_E_RESPONSE_ERROR: "Response error",
+            DEBUGSERVER_E_UNKNOWN_ERROR: "Unknown error",
+        }
+        BaseError.__init__(self, *args, **kwargs)
+
+
+from cpython.bytes cimport PyBytes_AsString as PyString_AsString
+cdef char ** to_cstring_array(list_str):
+    if not list_str:
+        return NULL
+    cdef char **ret = <char **>malloc(len(list_str) * sizeof(char *))
+    for i in xrange(len(list_str)):
+        ret[i] = PyString_AsString(list_str[i])
+    return ret
+
+
+cdef class DebugServerCommand(Base):
+    cdef debugserver_command_t _c_command
+
+    def __init__(self, bytes name, int argc = 0, argv = None, *args, **kwargs):
+        cdef:
+            char* c_name = name
+            char** c_argv = to_cstring_array(argv)
+
+        try:
+            self.handle_error(debugserver_command_new(c_name, argc, c_argv, &self._c_command))
+        except BaseError, e:
+            raise
+        finally:
+            free(c_argv)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, type, value, traceback):
+        self.free()
+
+    cdef free(self):
+        cdef debugserver_error_t err
+        if self._c_command is not NULL:
+            err = debugserver_command_free(self._c_command)
+            self.handle_error(err)
+
+    cdef inline BaseError _error(self, int16_t ret):
+        return DebugServerError(ret)
+
+
+cdef class DebugServerClient(BaseService):
+    __service_name__ = "com.apple.debugserver"
+    cdef debugserver_client_t _c_client
+
+    def __cinit__(self, iDevice device = None, LockdownServiceDescriptor descriptor = None, *args, **kwargs):
+        if (device is not None and descriptor is not None):
+            self.handle_error(debugserver_client_new(device._c_dev, descriptor._c_service_descriptor, &(self._c_client)))
+    
+    def __dealloc__(self):
+        cdef debugserver_error_t err
+        if self._c_client is not NULL:
+            err = debugserver_client_free(self._c_client)
+            self.handle_error(err)
+
+    cdef BaseError _error(self, int16_t ret):
+        return DebugServerError(ret)
+
+    cpdef uint32_t send(self, bytes data):
+        cdef:
+            uint32_t bytes_send
+            char* c_data = data
+        try:
+            self.handle_error(debugserver_client_send(self._c_client, c_data, len(data), &bytes_send))
+        except BaseError, e:
+            raise
+
+        return bytes_send
+
+    cpdef bytes send_command(self, DebugServerCommand command):
+        cdef:
+            char* c_response = NULL
+            bytes result
+
+        try:
+            self.handle_error(debugserver_client_send_command(self._c_client, command._c_command, &c_response, NULL))
+            if c_response:
+                result = c_response
+                return result
+            else:
+                return None
+        except BaseError, e:
+            raise
+        finally:
+            free(c_response)
+
+    cpdef bytes receive(self, uint32_t size):
+        cdef:
+            uint32_t bytes_received
+            char* c_data = <char *>malloc(size)
+            bytes result
+
+        try:
+            self.handle_error(debugserver_client_receive(self._c_client, c_data, size, &bytes_received))
+            result = c_data[:bytes_received]
+            return result
+        except BaseError, e:
+            raise
+        finally:
+            free(c_data)
+
+    cpdef bytes receive_with_timeout(self, uint32_t size, unsigned int timeout):
+        cdef:
+            uint32_t bytes_received
+            char* c_data = <char *>malloc(size)
+            bytes result
+
+        try:
+            self.handle_error(debugserver_client_receive_with_timeout(self._c_client, c_data, size, &bytes_received, timeout))
+            result = c_data[:bytes_received]
+            return result
+        except BaseError, e:
+            raise
+        finally:
+            free(c_data)
+
+    cpdef bytes receive_response(self):
+        cdef:
+            char* c_response = NULL
+            bytes result
+
+        try:
+            self.handle_error(debugserver_client_receive_response(self._c_client, &c_response, NULL))
+            if c_response:
+                result = c_response
+                return result
+            else:
+                return None
+        except BaseError, e:
+            raise
+        finally:
+            free(c_response)
+
+    cpdef bytes set_argv(self, int argc, argv):
+        cdef:
+            char** c_argv = to_cstring_array(argv)
+            char* c_response = NULL
+            bytes result
+
+        try:
+            self.handle_error(debugserver_client_set_argv(self._c_client, argc, c_argv, &c_response))
+            if c_response:
+                result = c_response
+                return result
+            else:
+                return None
+        except BaseError, e:
+            raise
+        finally:
+            free(c_argv)
+            free(c_response)
+
+    cpdef bytes set_environment_hex_encoded(self, bytes env):
+        cdef:
+            char* c_env = env
+            char* c_response = NULL
+            bytes result
+
+        try:
+            self.handle_error(debugserver_client_set_environment_hex_encoded(self._c_client, c_env, &c_response))
+            if c_response:
+                result = c_response
+                return result
+            else:
+                return None
+        except BaseError, e:
+            raise
+        finally:
+            free(c_response)
+
+    cpdef bytes encode_string(self, bytes buffer):
+        cdef:
+            char *c_buffer = buffer
+            uint32_t encoded_length = len(c_buffer) * 2 + 0x3 + 1
+            char* c_encoded_buffer = <char *>malloc(encoded_length)
+            bytes result
+
+        try:
+            debugserver_encode_string(c_buffer, &c_encoded_buffer, &encoded_length)
+            result = c_encoded_buffer[:encoded_length]
+            return result
+        except BaseError, e:
+            raise
+        finally:
+            free(c_encoded_buffer)
+
+    cpdef bytes decode_string(self, bytes encoded_buffer):
+        cdef:
+            char* c_encoded_buffer = encoded_buffer
+            uint32_t encoded_length = len(c_encoded_buffer)
+            char *c_buffer = <char *>malloc(encoded_length)
+            bytes result
+
+        try:
+            debugserver_decode_string(c_encoded_buffer, encoded_length, &c_buffer)
+            result = c_buffer
+            return result
+        except BaseError, e:
+            raise
+        finally:
+            free(c_buffer)

device_link_service.c

@@ -0,0 +1,474 @@
+/*
+ * device_link_service.c
+ * DeviceLink service implementation.
+ *
+ * Copyright (c) 2010-2019 Nikias Bassen, All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <string.h>
+#include <stdlib.h>
+#include "device_link_service.h"
+#include "property_list_service.h"
+#include "common/debug.h"
+
+static device_link_service_error_t device_link_error(property_list_service_error_t err)
+{
+	switch (err) {
+		case PROPERTY_LIST_SERVICE_E_SUCCESS:
+			return DEVICE_LINK_SERVICE_E_SUCCESS;
+		case PROPERTY_LIST_SERVICE_E_INVALID_ARG:
+			return DEVICE_LINK_SERVICE_E_INVALID_ARG;
+		case PROPERTY_LIST_SERVICE_E_PLIST_ERROR:
+			return DEVICE_LINK_SERVICE_E_PLIST_ERROR;
+		case PROPERTY_LIST_SERVICE_E_MUX_ERROR:
+			return DEVICE_LINK_SERVICE_E_MUX_ERROR;
+		case PROPERTY_LIST_SERVICE_E_SSL_ERROR:
+			return DEVICE_LINK_SERVICE_E_SSL_ERROR;
+		case PROPERTY_LIST_SERVICE_E_RECEIVE_TIMEOUT:
+			return DEVICE_LINK_SERVICE_E_RECEIVE_TIMEOUT;
+		default:
+			break;
+	}
+	return DEVICE_LINK_SERVICE_E_UNKNOWN_ERROR;
+}
+
+/**
+ * Internally used function to extract the message string from a DL* message
+ * plist.
+ *
+ * @param dl_msg The DeviceLink property list to parse.
+ * @param message A pointer that will be set to a newly allocated char*
+ *     containing the DLMessage* string from the given plist. It is up to
+ *     the caller to free the allocated memory. If this parameter is NULL
+ *     it will be ignored.
+ *
+ * @return 1 if the given plist is a DL* message, or 0 if the plist does not
+ *     contain any DL* message.
+ */
+static int device_link_service_get_message(plist_t dl_msg, char **message)
+{
+	plist_t cmd = NULL;
+	char *cmd_str = NULL;
+
+	/* sanity check */
+	if ((plist_get_node_type(dl_msg) != PLIST_ARRAY) || (plist_array_get_size(dl_msg) < 1)) {
+		return 0;
+	}
+
+	/* get dl command */
+	cmd = plist_array_get_item(dl_msg, 0);
+	if (!cmd || (plist_get_node_type(cmd) != PLIST_STRING)) {
+		return 0;
+	}
+
+	plist_get_string_val(cmd, &cmd_str);
+	if (!cmd_str) {
+		return 0;
+	}
+
+	if ((strlen(cmd_str) < 9) || (strncmp(cmd_str, "DL", 2) != 0)) {
+		free(cmd_str);
+		return 0;
+	}
+
+	if (message)
+		*message = cmd_str;
+
+	/* we got a DL* message */
+	return 1;
+}
+
+/**
+ * Creates a new device link service client.
+ *
+ * @param device The device to connect to.
+ * @param service The service descriptor returned by lockdownd_start_service.
+ * @param client Reference that will point to a newly allocated
+ *     device_link_service_client_t upon successful return.
+ *
+ * @return DEVICE_LINK_SERVICE_E_SUCCESS on success,
+ *     DEVICE_LINK_SERVICE_E_INVALID_ARG when one of the parameters is invalid,
+ *     or DEVICE_LINK_SERVICE_E_MUX_ERROR when the connection failed.
+ */
+device_link_service_error_t device_link_service_client_new(idevice_t device, lockdownd_service_descriptor_t service, device_link_service_client_t *client)
+{
+	if (!device || !service || service->port == 0 || !client || *client) {
+		return DEVICE_LINK_SERVICE_E_INVALID_ARG;
+	}
+
+	property_list_service_client_t plistclient = NULL;
+	device_link_service_error_t err = device_link_error(property_list_service_client_new(device, service, &plistclient));
+	if (err != DEVICE_LINK_SERVICE_E_SUCCESS) {
+		return err;
+	}
+
+	/* create client object */
+	device_link_service_client_t client_loc = (device_link_service_client_t) malloc(sizeof(struct device_link_service_client_private));
+	client_loc->parent = plistclient;
+
+	/* all done, return success */
+	*client = client_loc;
+	return DEVICE_LINK_SERVICE_E_SUCCESS;
+}
+
+/**
+ * Frees a device link service client.
+ *
+ * @param client The device_link_service_client_t to free.
+ *
+ * @return DEVICE_LINK_SERVICE_E_SUCCESS on success,
+ *     DEVICE_LINK_SERVICE_E_INVALID_ARG when one of client or client->parent
+ *     is invalid, or DEVICE_LINK_SERVICE_E_UNKNOWN_ERROR when the was an error
+ *     freeing the parent property_list_service client.
+ */
+device_link_service_error_t device_link_service_client_free(device_link_service_client_t client)
+{
+	if (!client)
+		return DEVICE_LINK_SERVICE_E_INVALID_ARG;
+
+	device_link_service_error_t err = device_link_error(property_list_service_client_free(client->parent));
+	free(client);
+
+	return err;
+}
+
+/**
+ * Performs the DLMessageVersionExchange with the connected device.
+ * This should be the first operation to be executed by an implemented
+ * device link service client.
+ *
+ * @param client The device_link_service client to use.
+ * @param version_major The major version number to check.
+ * @param version_minor The minor version number to check.
+ *
+ * @return DEVICE_LINK_SERVICE_E_SUCCESS on success,
+ *     DEVICE_LINK_SERVICE_E_INVALID_ARG when client is NULL,
+ *     DEVICE_LINK_SERVICE_E_MUX_ERROR when a communication error occurs,
+ *     DEVICE_LINK_SERVICE_E_PLIST_ERROR when the received plist has not the
+ *     expected contents, DEVICE_LINK_SERVICE_E_BAD_VERSION when the version
+ *     given by the device is larger than the given version,
+ *     or DEVICE_LINK_SERVICE_E_UNKNOWN_ERROR otherwise.
+ */
+device_link_service_error_t device_link_service_version_exchange(device_link_service_client_t client, uint64_t version_major, uint64_t version_minor)
+{
+	if (!client)
+		return DEVICE_LINK_SERVICE_E_INVALID_ARG;
+
+	device_link_service_error_t err = DEVICE_LINK_SERVICE_E_UNKNOWN_ERROR;
+
+	/* perform version exchange */
+	plist_t array = NULL;
+	char *msg = NULL;
+
+	/* receive DLMessageVersionExchange from device */
+	err = device_link_error(property_list_service_receive_plist(client->parent, &array));
+	if (err != DEVICE_LINK_SERVICE_E_SUCCESS) {
+		debug_info("Did not receive initial message from device!");
+		goto leave;
+	}
+	device_link_service_get_message(array, &msg);
+	if (!msg || strcmp(msg, "DLMessageVersionExchange") != 0) {
+		debug_info("Did not receive DLMessageVersionExchange from device!");
+		err = DEVICE_LINK_SERVICE_E_PLIST_ERROR;
+		goto leave;
+	}
+	free(msg);
+	msg = NULL;
+
+	/* get major and minor version number */
+	if (plist_array_get_size(array) < 3) {
+		debug_info("DLMessageVersionExchange has unexpected format!");
+		err = DEVICE_LINK_SERVICE_E_PLIST_ERROR;
+		goto leave;
+	}
+	plist_t maj = plist_array_get_item(array, 1);
+	plist_t min = plist_array_get_item(array, 2);
+	uint64_t vmajor = 0;
+	uint64_t vminor = 0;
+	if (maj) {
+		plist_get_uint_val(maj, &vmajor);
+	}
+	if (min) {
+		plist_get_uint_val(min, &vminor);
+	}
+	if (vmajor > version_major) {
+		debug_info("Version mismatch: device=(%lld,%lld) > expected=(%lld,%lld)", vmajor, vminor, version_major, version_minor);
+		err = DEVICE_LINK_SERVICE_E_BAD_VERSION;
+		goto leave;
+	} else if ((vmajor == version_major) && (vminor > version_minor)) {
+		debug_info("WARNING: Version mismatch: device=(%lld,%lld) > expected=(%lld,%lld)", vmajor, vminor, version_major, version_minor);
+		err = DEVICE_LINK_SERVICE_E_BAD_VERSION;
+		goto leave;
+	}
+	plist_free(array);
+
+	/* version is ok, send reply */
+	array = plist_new_array();
+	plist_array_append_item(array, plist_new_string("DLMessageVersionExchange"));
+	plist_array_append_item(array, plist_new_string("DLVersionsOk"));
+	plist_array_append_item(array, plist_new_uint(version_major));
+	err = device_link_error(property_list_service_send_binary_plist(client->parent, array));
+	if (err != DEVICE_LINK_SERVICE_E_SUCCESS) {
+		debug_info("Error when sending DLVersionsOk");
+		goto leave;
+	}
+	plist_free(array);
+
+	/* receive DeviceReady message */
+	array = NULL;
+	err = device_link_error(property_list_service_receive_plist(client->parent, &array));
+	if (err != DEVICE_LINK_SERVICE_E_SUCCESS) {
+		debug_info("Error when receiving DLMessageDeviceReady!");
+		goto leave;
+	}
+	device_link_service_get_message(array, &msg);
+	if (!msg || strcmp(msg, "DLMessageDeviceReady") != 0) {
+		debug_info("Did not get DLMessageDeviceReady!");
+		err = DEVICE_LINK_SERVICE_E_PLIST_ERROR;
+		goto leave;
+	}
+	err = DEVICE_LINK_SERVICE_E_SUCCESS;
+
+leave:
+	if (msg) {
+		free(msg);
+	}
+	if (array) {
+		plist_free(array);
+	}
+	return err;
+}
+
+/**
+ * Performs a disconnect with the connected device link service client.
+ *
+ * @param client The device link service client to disconnect.
+ * @param message Optional message to send send to the device or NULL.
+ *
+ * @return DEVICE_LINK_SERVICE_E_SUCCESS on success,
+ *     DEVICE_LINK_SERVICE_E_INVALID_ARG if client is NULL,
+ *     or DEVICE_LINK_SERVICE_E_MUX_ERROR when there's an error when sending
+ *     the the disconnect message.
+ */
+device_link_service_error_t device_link_service_disconnect(device_link_service_client_t client, const char *message)
+{
+	if (!client)
+		return DEVICE_LINK_SERVICE_E_INVALID_ARG;
+
+	plist_t array = plist_new_array();
+	plist_array_append_item(array, plist_new_string("DLMessageDisconnect"));
+	if (message)
+		plist_array_append_item(array, plist_new_string(message));
+	else
+		plist_array_append_item(array, plist_new_string("___EmptyParameterString___"));
+
+	device_link_service_error_t err = device_link_error(property_list_service_send_binary_plist(client->parent, array));
+	plist_free(array);
+
+	return err;
+}
+
+/**
+ * Sends a DLMessagePing plist.
+ *
+ * @param client The device link service client to use.
+ * @param message String to send as ping message.
+ *
+ * @return DEVICE_LINK_SERVICE_E_SUCCESS on success,
+ *     DEVICE_LINK_SERVICE_E_INVALID_ARG if client or message is invalid,
+ *     or DEVICE_LINK_SERVICE_E_MUX_ERROR if the DLMessagePing plist could
+ *     not be sent.
+ */
+device_link_service_error_t device_link_service_send_ping(device_link_service_client_t client, const char *message)
+{
+	if (!client || !client->parent || !message)
+		return DEVICE_LINK_SERVICE_E_INVALID_ARG;
+
+	plist_t array = plist_new_array();
+	plist_array_append_item(array, plist_new_string("DLMessagePing"));
+	plist_array_append_item(array, plist_new_string(message));
+
+	device_link_service_error_t err = device_link_error(property_list_service_send_binary_plist(client->parent, array));
+	plist_free(array);
+
+	return err;
+}
+
+/**
+ * Sends a DLMessageProcessMessage plist.
+ *
+ * @param client The device link service client to use.
+ * @param message PLIST_DICT to send.
+ *
+ * @return DEVICE_LINK_SERVICE_E_SUCCESS on success,
+ *     DEVICE_LINK_SERVICE_E_INVALID_ARG if client or message is invalid or
+ *     message is not a PLIST_DICT, or DEVICE_LINK_SERVICE_E_MUX_ERROR if
+ *     the DLMessageProcessMessage plist could not be sent.
+ */
+device_link_service_error_t device_link_service_send_process_message(device_link_service_client_t client, plist_t message)
+{
+	if (!client || !client->parent || !message)
+		return DEVICE_LINK_SERVICE_E_INVALID_ARG;
+
+	if (plist_get_node_type(message) != PLIST_DICT)
+		return DEVICE_LINK_SERVICE_E_INVALID_ARG;
+
+	plist_t array = plist_new_array();
+	plist_array_append_item(array, plist_new_string("DLMessageProcessMessage"));
+	plist_array_append_item(array, plist_copy(message));
+
+	device_link_service_error_t err = device_link_error(property_list_service_send_binary_plist(client->parent, array));
+	plist_free(array);
+
+	return err;
+}
+
+/**
+ * Receives a DL* message plist
+ *
+ * @param client The connected device link service client used for receiving.
+ * @param msg_plist Pointer to a plist that will be set to the contents of the
+ *    message plist upon successful return.
+ * @param dlmessage A pointer that will be set to a newly allocated char*
+ *     containing the DL* string from the given plist. It is up to the caller
+ *     to free the allocated memory. If this parameter is NULL
+ *     it will be ignored.
+ *
+ * @return DEVICE_LINK_SERVICE_E_SUCCESS if a DL* message was received,
+ *    DEVICE_LINK_SERVICE_E_INVALID_ARG if client or message is invalid,
+ *    DEVICE_LINK_SERVICE_E_PLIST_ERROR if the received plist is invalid
+ *    or is not a DL* message plist, or DEVICE_LINK_SERVICE_E_MUX_ERROR if
+ *    receiving from the device failed.
+ */
+device_link_service_error_t device_link_service_receive_message(device_link_service_client_t client, plist_t *msg_plist, char **dlmessage)
+{
+	if (!client || !client->parent || !msg_plist)
+		return DEVICE_LINK_SERVICE_E_INVALID_ARG;
+
+	*msg_plist = NULL;
+	device_link_service_error_t err = device_link_error(property_list_service_receive_plist(client->parent, msg_plist));
+	if (err != DEVICE_LINK_SERVICE_E_SUCCESS) {
+		return err;
+	}
+
+	if (!device_link_service_get_message(*msg_plist, dlmessage)) {
+		debug_info("Did not receive a DL* message as expected!");
+		return DEVICE_LINK_SERVICE_E_PLIST_ERROR;
+	}
+	return DEVICE_LINK_SERVICE_E_SUCCESS;
+}
+
+/**
+ * Receives a DLMessageProcessMessage plist.
+ *
+ * @param client The connected device link service client used for receiving.
+ * @param message Pointer to a plist that will be set to the contents of the
+ *    message contents upon successful return.
+ *
+ * @return DEVICE_LINK_SERVICE_E_SUCCESS when a DLMessageProcessMessage was
+ *    received, DEVICE_LINK_SERVICE_E_INVALID_ARG when client or message is
+ *    invalid, DEVICE_LINK_SERVICE_E_PLIST_ERROR if the received plist is
+ *    invalid or is not a DLMessageProcessMessage,
+ *    or DEVICE_LINK_SERVICE_E_MUX_ERROR if receiving from device fails.
+ */
+device_link_service_error_t device_link_service_receive_process_message(device_link_service_client_t client, plist_t *message)
+{
+	if (!client || !client->parent || !message)
+		return DEVICE_LINK_SERVICE_E_INVALID_ARG;
+
+	plist_t pmsg = NULL;
+	device_link_service_error_t err = device_link_error(property_list_service_receive_plist(client->parent, &pmsg));
+	if (err != DEVICE_LINK_SERVICE_E_SUCCESS) {
+		return err;
+	}
+
+	err = DEVICE_LINK_SERVICE_E_UNKNOWN_ERROR;
+
+	char *msg = NULL;
+	device_link_service_get_message(pmsg, &msg);
+	if (!msg || strcmp(msg, "DLMessageProcessMessage") != 0) {
+		debug_info("Did not receive DLMessageProcessMessage as expected!");
+		err = DEVICE_LINK_SERVICE_E_PLIST_ERROR;
+		goto leave;
+	}
+
+	if (plist_array_get_size(pmsg) != 2) {
+		debug_info("Malformed plist received for DLMessageProcessMessage");
+		err = DEVICE_LINK_SERVICE_E_PLIST_ERROR;
+		goto leave;
+	}
+
+	plist_t msg_loc = plist_array_get_item(pmsg, 1);
+	if (msg_loc) {
+		*message = plist_copy(msg_loc);
+		err = DEVICE_LINK_SERVICE_E_SUCCESS;
+	} else {
+		*message = NULL;
+		err = DEVICE_LINK_SERVICE_E_PLIST_ERROR;
+	}
+
+leave:
+	if (msg)
+		free(msg);
+	if (pmsg)
+		plist_free(pmsg);
+
+	return err;
+}
+
+/**
+ * Generic device link service send function.
+ *
+ * @param client The device link service client to use for sending
+ * @param plist The property list to send
+ *
+ * @return DEVICE_LINK_SERVICE_E_SUCCESS on success,
+ *     DEVICE_LINK_SERVICE_E_INVALID_ARG when client or plist is NULL,
+ *     or DEVICE_LINK_SERVICE_E_MUX_ERROR when the given property list could
+ *     not be sent.
+ */
+device_link_service_error_t device_link_service_send(device_link_service_client_t client, plist_t plist)
+{
+	if (!client || !plist) {
+		return DEVICE_LINK_SERVICE_E_INVALID_ARG;
+	}
+	return device_link_error(property_list_service_send_binary_plist(client->parent, plist));
+}
+
+/* Generic device link service receive function.
+ *
+ * @param client The device link service client to use for sending
+ * @param plist Pointer that will point to the property list received upon
+ *     successful return.
+ *
+ * @return DEVICE_LINK_SERVICE_E_SUCCESS on success,
+ *     DEVICE_LINK_SERVICE_E_INVALID_ARG when client or plist is NULL,
+ *     or DEVICE_LINK_SERVICE_E_MUX_ERROR when no property list could be
+ *     received.
+ */
+device_link_service_error_t device_link_service_receive(device_link_service_client_t client, plist_t *plist)
+{
+	if (!client || !plist || (plist && *plist)) {
+		return DEVICE_LINK_SERVICE_E_INVALID_ARG;
+	}
+
+	return device_link_error(property_list_service_receive_plist(client->parent, plist));
+}
+

device_link_service.h

@@ -0,0 +1,57 @@
+/*
+ * device_link_service.h
+ * Definitions for the DeviceLink service
+ *
+ * Copyright (c) 2010-2019 Nikias Bassen, All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef __DEVICE_LINK_SERVICE_H
+#define __DEVICE_LINK_SERVICE_H
+
+#include "idevice.h"
+#include "property_list_service.h"
+
+/* Error Codes */
+typedef enum {
+	DEVICE_LINK_SERVICE_E_SUCCESS         =    0,
+	DEVICE_LINK_SERVICE_E_INVALID_ARG     =   -1,
+	DEVICE_LINK_SERVICE_E_PLIST_ERROR     =   -2,
+	DEVICE_LINK_SERVICE_E_MUX_ERROR       =   -3,
+	DEVICE_LINK_SERVICE_E_SSL_ERROR       =   -4,
+	DEVICE_LINK_SERVICE_E_RECEIVE_TIMEOUT =   -5,
+	DEVICE_LINK_SERVICE_E_BAD_VERSION     =   -6,
+	DEVICE_LINK_SERVICE_E_UNKNOWN_ERROR   = -256
+} device_link_service_error_t;
+
+struct device_link_service_client_private {
+	property_list_service_client_t parent;
+};
+
+typedef struct device_link_service_client_private *device_link_service_client_t;
+
+device_link_service_error_t device_link_service_client_new(idevice_t device, lockdownd_service_descriptor_t service, device_link_service_client_t *client);
+device_link_service_error_t device_link_service_client_free(device_link_service_client_t client);
+device_link_service_error_t device_link_service_version_exchange(device_link_service_client_t client, uint64_t version_major, uint64_t version_minor);
+device_link_service_error_t device_link_service_send_ping(device_link_service_client_t client, const char *message);
+device_link_service_error_t device_link_service_receive_message(device_link_service_client_t client, plist_t *msg_plist, char **dlmessage);
+device_link_service_error_t device_link_service_send_process_message(device_link_service_client_t client, plist_t message);
+device_link_service_error_t device_link_service_receive_process_message(device_link_service_client_t client, plist_t *message);
+device_link_service_error_t device_link_service_disconnect(device_link_service_client_t client, const char *message);
+device_link_service_error_t device_link_service_send(device_link_service_client_t client, plist_t plist);
+device_link_service_error_t device_link_service_receive(device_link_service_client_t client, plist_t *plist);
+
+#endif

dfu.c

@@ -0,0 +1,470 @@
+/*
+ * dfu.c
+ * Functions for handling idevices in DFU mode
+ *
+ * Copyright (c) 2012-2019 Nikias Bassen. All Rights Reserved.
+ * Copyright (c) 2010-2013 Martin Szulecki. All Rights Reserved.
+ * Copyright (c) 2010 Joshua Hill. All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <libirecovery.h>
+
+#include "dfu.h"
+#include "tss.h"
+#include "recovery.h"
+#include "idevicerestore.h"
+#include "common.h"
+
+static int dfu_progress_callback(irecv_client_t client, const irecv_event_t* event) {
+	if (event->type == IRECV_PROGRESS) {
+		print_progress_bar(event->progress);
+	}
+	return 0;
+}
+
+int dfu_client_new(struct idevicerestore_client_t* client) {
+	int i = 0;
+	int attempts = 10;
+	irecv_client_t dfu = NULL;
+
+	if (client->dfu == NULL) {
+		client->dfu = (struct dfu_client_t*)malloc(sizeof(struct dfu_client_t));
+		memset(client->dfu, 0, sizeof(struct dfu_client_t));
+		if (client->dfu == NULL) {
+			error("ERROR: Out of memory\n");
+			return -1;
+		}
+	}
+
+	for (i = 1; i <= attempts; i++) {
+		if (irecv_open_with_ecid(&dfu, client->ecid) == IRECV_E_SUCCESS) {
+			break;
+		}
+
+		if (i >= attempts) {
+			error("ERROR: Unable to connect to device in DFU mode\n");
+			return -1;
+		}
+
+		sleep(1);
+		debug("Retrying connection...\n");
+	}
+
+	irecv_event_subscribe(dfu, IRECV_PROGRESS, &dfu_progress_callback, NULL);
+	client->dfu->client = dfu;
+	return 0;
+}
+
+void dfu_client_free(struct idevicerestore_client_t* client) {
+	if(client != NULL) {
+		if (client->dfu != NULL) {
+			if(client->dfu->client != NULL) {
+				irecv_close(client->dfu->client);
+				client->dfu->client = NULL;
+			}
+			free(client->dfu);
+		}
+		client->dfu = NULL;
+	}
+}
+
+int dfu_check_mode(struct idevicerestore_client_t* client, int* mode) {
+	irecv_client_t dfu = NULL;
+	int probe_mode = -1;
+
+	if (client->udid && client->ecid == 0) {
+		/* if we have a UDID but no ECID we can't make sure this is the correct device */
+		return -1;
+	}
+
+	irecv_init();
+	if (irecv_open_with_ecid(&dfu, client->ecid) != IRECV_E_SUCCESS) {
+		return -1;
+	}
+
+	irecv_get_mode(dfu, &probe_mode);
+
+	if ((probe_mode != IRECV_K_DFU_MODE) && (probe_mode != IRECV_K_WTF_MODE)) {
+		irecv_close(dfu);
+		return -1;
+	}
+
+	*mode = (probe_mode == IRECV_K_WTF_MODE) ? MODE_WTF : MODE_DFU;
+
+	irecv_close(dfu);
+
+	return 0;
+}
+
+irecv_device_t dfu_get_irecv_device(struct idevicerestore_client_t* client) {
+	irecv_client_t dfu = NULL;
+	irecv_error_t dfu_error = IRECV_E_SUCCESS;
+	irecv_device_t device = NULL;
+
+	irecv_init();
+	if (irecv_open_with_ecid(&dfu, client->ecid) != IRECV_E_SUCCESS) {
+		return NULL;
+	}
+
+	dfu_error = irecv_devices_get_device_by_client(dfu, &device);
+	irecv_close(dfu);
+	if (dfu_error != IRECV_E_SUCCESS) {
+		return NULL;
+	}
+
+	return device;
+}
+
+int dfu_send_buffer(struct idevicerestore_client_t* client, unsigned char* buffer, unsigned int size)
+{
+	irecv_error_t err = 0;
+
+	info("Sending data (%d bytes)...\n", size);
+
+	err = irecv_send_buffer(client->dfu->client, buffer, size, 1);
+	if (err != IRECV_E_SUCCESS) {
+		error("ERROR: Unable to send data: %s\n", irecv_strerror(err));
+		return -1;
+	}
+
+	return 0;
+}
+
+int dfu_send_component(struct idevicerestore_client_t* client, plist_t build_identity, const char* component) {
+	char* path = NULL;
+
+	if (client->tss) {
+		if (tss_response_get_path_by_entry(client->tss, component, &path) < 0) {
+			debug("NOTE: No path for component %s in TSS, will fetch from build_identity\n", component);
+		}
+	}
+	if (!path) {
+		if (build_identity_get_component_path(build_identity, component, &path) < 0) {
+			error("ERROR: Unable to get path for component '%s'\n", component);
+			free(path);
+			return -1;
+		}
+	}
+
+	unsigned char* component_data = NULL;
+	unsigned int component_size = 0;
+
+	if (extract_component(client->ipsw, path, &component_data, &component_size) < 0) {
+		error("ERROR: Unable to extract component: %s\n", component);
+		free(path);
+		return -1;
+	}
+	free(path);
+	path = NULL;
+
+	unsigned char* data = NULL;
+	uint32_t size = 0;
+
+	if (personalize_component(component, component_data, component_size, client->tss, &data, &size) < 0) {
+		error("ERROR: Unable to get personalized component: %s\n", component);
+		free(component_data);
+		return -1;
+	}
+	free(component_data);
+	component_data = NULL;
+
+	if (!client->image4supported && client->build_major > 8 && !(client->flags & FLAG_CUSTOM) && !strcmp(component, "iBEC")) {
+		unsigned char* ticket = NULL;
+		unsigned int tsize = 0;
+		if (tss_response_get_ap_ticket(client->tss, &ticket, &tsize) < 0) {
+			error("ERROR: Unable to get ApTicket from TSS request\n");
+			return -1;
+		}
+		uint32_t fillsize = 0;
+		if (tsize % 64 != 0) {
+			fillsize = ((tsize / 64) + 1) * 64;
+		}
+		debug("ticket size = %d\nfillsize = %d\n", tsize, fillsize);
+		unsigned char* newdata = (unsigned char*)malloc(size + fillsize);
+		memcpy(newdata, ticket, tsize);
+		memset(newdata + tsize, '\xFF', fillsize - tsize);
+		memcpy(newdata + fillsize, data, size);
+		free(data);
+		data = newdata;
+		size += fillsize;
+	}
+
+	info("Sending %s (%d bytes)...\n", component, size);
+
+	// FIXME: Did I do this right????
+	irecv_error_t err = irecv_send_buffer(client->dfu->client, data, size, 1);
+	if (err != IRECV_E_SUCCESS) {
+		error("ERROR: Unable to send %s component: %s\n", component, irecv_strerror(err));
+		free(data);
+		return -1;
+	}
+
+	free(data);
+	return 0;
+}
+
+int dfu_get_cpid(struct idevicerestore_client_t* client, unsigned int* cpid) {
+	if(client->dfu == NULL) {
+		if (dfu_client_new(client) < 0) {
+			return -1;
+		}
+	}
+
+	const struct irecv_device_info *device_info = irecv_get_device_info(client->dfu->client);
+	if (!device_info) {
+		return -1;
+	}
+
+	*cpid = device_info->cpid;
+
+	return 0;
+}
+
+int dfu_get_ecid(struct idevicerestore_client_t* client, uint64_t* ecid) {
+	if(client->dfu == NULL) {
+		if (dfu_client_new(client) < 0) {
+			return -1;
+		}
+	}
+
+	const struct irecv_device_info *device_info = irecv_get_device_info(client->dfu->client);
+	if (!device_info) {
+		return -1;
+	}
+
+	*ecid = device_info->ecid;
+
+	return 0;
+}
+
+int dfu_is_image4_supported(struct idevicerestore_client_t* client)
+{
+	if(client->dfu == NULL) {
+		if (dfu_client_new(client) < 0) {
+			return 0;
+		}
+	}
+
+	const struct irecv_device_info *device_info = irecv_get_device_info(client->dfu->client);
+	if (!device_info) {
+		return 0;
+	}
+
+	return (device_info->ibfl & IBOOT_FLAG_IMAGE4_AWARE);
+}
+
+int dfu_get_ap_nonce(struct idevicerestore_client_t* client, unsigned char** nonce, int* nonce_size) {
+	if(client->dfu == NULL) {
+		if (dfu_client_new(client) < 0) {
+			return -1;
+		}
+	}
+
+	const struct irecv_device_info *device_info = irecv_get_device_info(client->dfu->client);
+	if (!device_info) {
+		return -1;
+	}
+
+	if (device_info->ap_nonce && device_info->ap_nonce_size > 0) {
+		*nonce = (unsigned char*)malloc(device_info->ap_nonce_size);
+		if (!*nonce) {
+			return -1;
+		}
+		*nonce_size = device_info->ap_nonce_size;
+		memcpy(*nonce, device_info->ap_nonce, *nonce_size);
+	}
+
+	return 0;
+}
+
+int dfu_get_sep_nonce(struct idevicerestore_client_t* client, unsigned char** nonce, int* nonce_size) {
+	if(client->dfu == NULL) {
+		if (dfu_client_new(client) < 0) {
+			return -1;
+		}
+	}
+
+	const struct irecv_device_info *device_info = irecv_get_device_info(client->dfu->client);
+	if (!device_info) {
+		return -1;
+	}
+
+	if (device_info->sep_nonce && device_info->sep_nonce_size > 0) {
+		*nonce = (unsigned char*)malloc(device_info->sep_nonce_size);
+		if (!*nonce) {
+			return -1;
+		}
+		*nonce_size = device_info->sep_nonce_size;
+		memcpy(*nonce, device_info->sep_nonce, *nonce_size);
+	}
+
+	return 0;
+}
+
+int dfu_enter_recovery(struct idevicerestore_client_t* client, plist_t build_identity)
+{
+	int mode = 0;
+
+	if (dfu_client_new(client) < 0) {
+		error("ERROR: Unable to connect to DFU device\n");
+		return -1;
+	}
+
+	irecv_get_mode(client->dfu->client, &mode);
+
+	if (mode != IRECV_K_DFU_MODE) {
+		info("NOTE: device is not in DFU mode, assuming recovery mode.\n");
+		client->mode = &idevicerestore_modes[MODE_RECOVERY];
+		return 0;
+	}
+
+	mutex_lock(&client->device_event_mutex);
+
+	if (dfu_send_component(client, build_identity, "iBSS") < 0) {
+		error("ERROR: Unable to send iBSS to device\n");
+		irecv_close(client->dfu->client);
+		client->dfu->client = NULL;
+		return -1;
+	}
+	dfu_client_free(client);
+
+	if (client->build_major > 8) {
+		/* reconnect */
+		debug("Waiting for device to disconnect...\n");
+		cond_wait_timeout(&client->device_event_cond, &client->device_event_mutex, 10000);
+		if (client->mode != &idevicerestore_modes[MODE_UNKNOWN] || (client->flags & FLAG_QUIT)) {
+			mutex_unlock(&client->device_event_mutex);
+			if (!(client->flags & FLAG_QUIT)) {
+				error("ERROR: Device did not disconnect. Possibly invalid iBSS. Reset device and try again.\n");
+			}
+			return -1;
+		}
+		debug("Waiting for device to reconnect...\n");
+		cond_wait_timeout(&client->device_event_cond, &client->device_event_mutex, 10000);
+		if ((client->mode != &idevicerestore_modes[MODE_DFU] && client->mode != &idevicerestore_modes[MODE_RECOVERY]) || (client->flags & FLAG_QUIT)) {
+			mutex_unlock(&client->device_event_mutex);
+			if (!(client->flags & FLAG_QUIT)) {
+				error("ERROR: Device did not reconnect in DFU or recovery mode. Possibly invalid iBSS. Reset device and try again.\n");
+			}
+			return -1;
+		}
+		mutex_unlock(&client->device_event_mutex);
+		dfu_client_new(client);
+
+		/* get nonce */
+		unsigned char* nonce = NULL;
+		int nonce_size = 0;
+		int nonce_changed = 0;
+		if (dfu_get_ap_nonce(client, &nonce, &nonce_size) < 0) {
+			error("ERROR: Unable to get ApNonce from device!\n");
+			return -1;
+		}
+
+		if (!client->nonce || (nonce_size != client->nonce_size) || (memcmp(nonce, client->nonce, nonce_size) != 0)) {
+			nonce_changed = 1;
+			if (client->nonce) {
+				free(client->nonce);
+			}
+			client->nonce = nonce;
+			client->nonce_size = nonce_size;
+		} else {
+			free(nonce);
+		}
+
+		info("Nonce: ");
+		int i;
+		for (i = 0; i < client->nonce_size; i++) {
+			info("%02x ", client->nonce[i]);
+		}
+		info("\n");
+
+		if (nonce_changed && !(client->flags & FLAG_CUSTOM)) {
+			// Welcome iOS5. We have to re-request the TSS with our nonce.
+			plist_free(client->tss);
+			if (get_tss_response(client, build_identity, &client->tss) < 0) {
+				error("ERROR: Unable to get SHSH blobs for this device\n");
+				return -1;
+			}
+			if (!client->tss) {
+				error("ERROR: can't continue without TSS\n");
+				return -1;
+			}
+			fixup_tss(client->tss);
+		}
+
+		if (irecv_usb_set_configuration(client->dfu->client, 1) < 0) {
+			error("ERROR: set configuration failed\n");
+		}
+
+		mutex_lock(&client->device_event_mutex);
+
+		/* send iBEC */
+		if (dfu_send_component(client, build_identity, "iBEC") < 0) {
+			mutex_unlock(&client->device_event_mutex);
+			error("ERROR: Unable to send iBEC to device\n");
+			irecv_close(client->dfu->client);
+			client->dfu->client = NULL;
+			return -1;
+		}
+
+		if (client->mode == &idevicerestore_modes[MODE_RECOVERY]) {
+			if (irecv_send_command(client->dfu->client, "go") != IRECV_E_SUCCESS) {
+				mutex_unlock(&client->device_event_mutex);
+				error("ERROR: Unable to execute iBEC\n");
+				return -1;
+			}
+			irecv_usb_control_transfer(client->dfu->client, 0x21, 1, 0, 0, 0, 0, 5000);
+		}
+		dfu_client_free(client);
+	}
+
+	debug("Waiting for device to disconnect...\n");
+	cond_wait_timeout(&client->device_event_cond, &client->device_event_mutex, 10000);
+	if (client->mode != &idevicerestore_modes[MODE_UNKNOWN] || (client->flags & FLAG_QUIT)) {
+		mutex_unlock(&client->device_event_mutex);
+		if (!(client->flags & FLAG_QUIT)) {
+			error("ERROR: Device did not disconnect. Possibly invalid %s. Reset device and try again.\n", (client->build_major > 8) ? "iBEC" : "iBSS");
+		}
+		return -1;
+	}
+	debug("Waiting for device to reconnect in recovery mode...\n");
+	cond_wait_timeout(&client->device_event_cond, &client->device_event_mutex, 10000);
+	if (client->mode != &idevicerestore_modes[MODE_RECOVERY] || (client->flags & FLAG_QUIT)) {
+		mutex_unlock(&client->device_event_mutex);
+		if (!(client->flags & FLAG_QUIT)) {
+			error("ERROR: Device did not reconnect in recovery mode. Possibly invalid %s. Reset device and try again.\n", (client->build_major > 8) ? "iBEC" : "iBSS");
+		}
+		return -1;
+	}
+	mutex_unlock(&client->device_event_mutex);
+
+	if (recovery_client_new(client) < 0) {
+		error("ERROR: Unable to connect to recovery device\n");
+		if (client->recovery->client) {
+			irecv_close(client->recovery->client);
+			client->recovery->client = NULL;
+		}
+		return -1;
+	}
+
+	return 0;
+}
+

dfu.h

@@ -0,0 +1,58 @@
+/*
+ * dfu.h
+ * Functions for handling idevices in DFU mode
+ *
+ * Copyright (c) 2010-2013 Martin Szulecki. All Rights Reserved.
+ * Copyright (c) 2012-2015 Nikias Bassen. All Rights Reserved.
+ * Copyright (c) 2010 Joshua Hill. All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef IDEVICERESTORE_DFU_H
+#define IDEVICERESTORE_DFU_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <libirecovery.h>
+#include "common.h"
+
+struct dfu_client_t {
+	irecv_client_t client;
+	const char* ipsw;
+	plist_t tss;
+};
+
+int dfu_client_new(struct idevicerestore_client_t* client);
+void dfu_client_free(struct idevicerestore_client_t* client);
+int dfu_check_mode(struct idevicerestore_client_t* client, int* mode);
+irecv_device_t dfu_get_irecv_device(struct idevicerestore_client_t* client);
+int dfu_send_buffer(struct idevicerestore_client_t* client, unsigned char* buffer, unsigned int size);
+int dfu_send_component(struct idevicerestore_client_t* client, plist_t build_identity, const char* component);
+int dfu_get_cpid(struct idevicerestore_client_t* client, unsigned int* cpid);
+int dfu_get_ecid(struct idevicerestore_client_t* client, uint64_t* ecid);
+int dfu_is_image4_supported(struct idevicerestore_client_t* client);
+int dfu_get_ap_nonce(struct idevicerestore_client_t* client, unsigned char** nonce, int* nonce_size);
+int dfu_get_sep_nonce(struct idevicerestore_client_t* client, unsigned char** nonce, int* nonce_size);
+int dfu_enter_recovery(struct idevicerestore_client_t* client, plist_t build_identity);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

diagnostics_relay.c

@@ -0,0 +1,467 @@
+/*
+ * diagnostics_relay.c
+ * com.apple.mobile.diagnostics_relay service implementation.
+ *
+ * Copyright (c) 2012 Martin Szulecki, All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <string.h>
+#include <stdlib.h>
+#include "diagnostics_relay.h"
+#include "property_list_service.h"
+#include "common/debug.h"
+
+#define RESULT_SUCCESS 0
+#define RESULT_FAILURE 1
+#define RESULT_UNKNOWN_REQUEST 2
+
+/**
+ * Internally used function for checking the result from a service response
+ * plist to a previously sent request.
+ *
+ * @param dict The plist to evaluate.
+ *
+ * @return RESULT_SUCCESS when the result is 'Success',
+ *         RESULT_FAILURE when the result is 'Failure',
+ *         or a negative value if an error occurred during evaluation.
+ */
+static int diagnostics_relay_check_result(plist_t dict)
+{
+	int ret = -1;
+
+	plist_t result_node = plist_dict_get_item(dict, "Status");
+	if (!result_node)
+		return ret;
+
+	plist_type result_type = plist_get_node_type(result_node);
+	if (result_type == PLIST_STRING) {
+		char *result_value = NULL;
+
+		plist_get_string_val(result_node, &result_value);
+
+		if (result_value) {
+			if (!strcmp(result_value, "Success")) {
+				ret = RESULT_SUCCESS;
+			} else if (!strcmp(result_value, "Failure")) {
+				ret = RESULT_FAILURE;
+			} else if (!strcmp(result_value, "UnknownRequest")) {
+				ret = RESULT_UNKNOWN_REQUEST;
+			} else {
+				debug_info("ERROR: unknown result value '%s'", result_value);
+			}
+		}
+		if (result_value)
+			free(result_value);
+	}
+	return ret;
+}
+
+diagnostics_relay_error_t diagnostics_relay_client_new(idevice_t device, lockdownd_service_descriptor_t service, diagnostics_relay_client_t *client)
+{
+	if (!device || !service || service->port == 0 || !client || *client) {
+		return DIAGNOSTICS_RELAY_E_INVALID_ARG;
+	}
+
+	property_list_service_client_t plistclient = NULL;
+	if (property_list_service_client_new(device, service, &plistclient) != PROPERTY_LIST_SERVICE_E_SUCCESS) {
+		return DIAGNOSTICS_RELAY_E_MUX_ERROR;
+	}
+
+	/* create client object */
+	diagnostics_relay_client_t client_loc = (diagnostics_relay_client_t) malloc(sizeof(struct diagnostics_relay_client_private));
+	client_loc->parent = plistclient;
+
+	/* all done, return success */
+	*client = client_loc;
+	return DIAGNOSTICS_RELAY_E_SUCCESS;
+}
+
+diagnostics_relay_error_t diagnostics_relay_client_start_service(idevice_t device, diagnostics_relay_client_t * client, const char* label)
+{
+	diagnostics_relay_error_t err = DIAGNOSTICS_RELAY_E_UNKNOWN_ERROR;
+	service_client_factory_start_service(device, DIAGNOSTICS_RELAY_SERVICE_NAME, (void**)client, label, SERVICE_CONSTRUCTOR(diagnostics_relay_client_new), &err);
+	return err;
+}
+
+diagnostics_relay_error_t diagnostics_relay_client_free(diagnostics_relay_client_t client)
+{
+	if (!client)
+		return DIAGNOSTICS_RELAY_E_INVALID_ARG;
+
+	if (property_list_service_client_free(client->parent) != PROPERTY_LIST_SERVICE_E_SUCCESS) {
+		return DIAGNOSTICS_RELAY_E_UNKNOWN_ERROR;
+	}
+	free(client);
+	return DIAGNOSTICS_RELAY_E_SUCCESS;
+}
+
+/**
+ * Receives a plist from the service.
+ *
+ * @param client The diagnostics_relay client
+ * @param plist The plist to store the received data
+ *
+ * @return DIAGNOSTICS_RELAY_E_SUCCESS on success,
+ *  DIAGNOSTICS_RELAY_E_INVALID_ARG when client or plist is NULL
+ */
+static diagnostics_relay_error_t diagnostics_relay_receive(diagnostics_relay_client_t client, plist_t *plist)
+{
+	if (!client || !plist || (plist && *plist))
+		return DIAGNOSTICS_RELAY_E_INVALID_ARG;
+
+	diagnostics_relay_error_t ret = DIAGNOSTICS_RELAY_E_SUCCESS;
+	property_list_service_error_t err;
+
+	err = property_list_service_receive_plist(client->parent, plist);
+	if (err != PROPERTY_LIST_SERVICE_E_SUCCESS) {
+		ret = DIAGNOSTICS_RELAY_E_UNKNOWN_ERROR;
+	}
+
+	if (!*plist)
+		ret = DIAGNOSTICS_RELAY_E_PLIST_ERROR;
+
+	return ret;
+}
+
+/**
+ * Sends a plist to the service.
+ *
+ * @note This function is low-level and should only be used if you need to send
+ *        a new type of message.
+ *
+ * @param client The diagnostics_relay client
+ * @param plist The plist to send
+ *
+ * @return DIAGNOSTICS_RELAY_E_SUCCESS on success,
+ *  DIAGNOSTICS_RELAY_E_INVALID_ARG when client or plist is NULL
+ */
+static diagnostics_relay_error_t diagnostics_relay_send(diagnostics_relay_client_t client, plist_t plist)
+{
+	if (!client || !plist)
+		return DIAGNOSTICS_RELAY_E_INVALID_ARG;
+
+	diagnostics_relay_error_t ret = DIAGNOSTICS_RELAY_E_SUCCESS;
+	property_list_service_error_t err;
+
+	err = property_list_service_send_xml_plist(client->parent, plist);
+	if (err != PROPERTY_LIST_SERVICE_E_SUCCESS) {
+		ret = DIAGNOSTICS_RELAY_E_UNKNOWN_ERROR;
+	}
+	return ret;
+}
+
+diagnostics_relay_error_t diagnostics_relay_goodbye(diagnostics_relay_client_t client)
+{
+	if (!client)
+		return DIAGNOSTICS_RELAY_E_INVALID_ARG;
+
+	diagnostics_relay_error_t ret = DIAGNOSTICS_RELAY_E_UNKNOWN_ERROR;
+
+	plist_t dict = plist_new_dict();
+	plist_dict_set_item(dict, "Request", plist_new_string("Goodbye"));
+
+	ret = diagnostics_relay_send(client, dict);
+	plist_free(dict);
+	dict = NULL;
+
+	ret = diagnostics_relay_receive(client, &dict);
+	if (!dict) {
+		debug_info("did not get goodbye response back");
+		return DIAGNOSTICS_RELAY_E_PLIST_ERROR;
+	}
+
+	int check = diagnostics_relay_check_result(dict);
+	if (check == RESULT_SUCCESS) {
+		ret = DIAGNOSTICS_RELAY_E_SUCCESS;
+	} else if (check == RESULT_UNKNOWN_REQUEST) {
+		ret = DIAGNOSTICS_RELAY_E_UNKNOWN_REQUEST;
+	} else {
+		ret = DIAGNOSTICS_RELAY_E_UNKNOWN_ERROR;
+	}
+
+	plist_free(dict);
+	dict = NULL;
+	return ret;
+}
+
+diagnostics_relay_error_t diagnostics_relay_sleep(diagnostics_relay_client_t client)
+{
+	if (!client)
+		return DIAGNOSTICS_RELAY_E_INVALID_ARG;
+
+	diagnostics_relay_error_t ret = DIAGNOSTICS_RELAY_E_UNKNOWN_ERROR;
+
+	plist_t dict = plist_new_dict();
+
+	plist_dict_set_item(dict,"Request", plist_new_string("Sleep"));
+	ret = diagnostics_relay_send(client, dict);
+	plist_free(dict);
+	dict = NULL;
+
+	ret = diagnostics_relay_receive(client, &dict);
+	if (!dict) {
+		return DIAGNOSTICS_RELAY_E_PLIST_ERROR;
+	}
+
+	int check = diagnostics_relay_check_result(dict);
+	if (check == RESULT_SUCCESS) {
+		ret = DIAGNOSTICS_RELAY_E_SUCCESS;
+	} else if (check == RESULT_UNKNOWN_REQUEST) {
+		ret = DIAGNOSTICS_RELAY_E_UNKNOWN_REQUEST;
+	} else {
+		ret = DIAGNOSTICS_RELAY_E_UNKNOWN_ERROR;
+	}
+
+	plist_free(dict);
+	return ret;
+}
+
+static diagnostics_relay_error_t internal_diagnostics_relay_action(diagnostics_relay_client_t client, const char* name, diagnostics_relay_action_t flags)
+{
+	if (!client)
+		return DIAGNOSTICS_RELAY_E_INVALID_ARG;
+
+	diagnostics_relay_error_t ret = DIAGNOSTICS_RELAY_E_UNKNOWN_ERROR;
+
+	plist_t dict = plist_new_dict();
+	plist_dict_set_item(dict,"Request", plist_new_string(name));
+
+	if (flags & DIAGNOSTICS_RELAY_ACTION_FLAG_WAIT_FOR_DISCONNECT) {
+		plist_dict_set_item(dict, "WaitForDisconnect", plist_new_bool(1));
+	}
+
+	if (flags & DIAGNOSTICS_RELAY_ACTION_FLAG_DISPLAY_PASS) {
+		plist_dict_set_item(dict, "DisplayPass", plist_new_bool(1));
+	}
+
+	if (flags & DIAGNOSTICS_RELAY_ACTION_FLAG_DISPLAY_FAIL) {
+		plist_dict_set_item(dict, "DisplayFail", plist_new_bool(1));
+	}
+
+	ret = diagnostics_relay_send(client, dict);
+	plist_free(dict);
+	dict = NULL;
+
+	ret = diagnostics_relay_receive(client, &dict);
+	if (!dict) {
+		return DIAGNOSTICS_RELAY_E_PLIST_ERROR;
+	}
+
+	int check = diagnostics_relay_check_result(dict);
+	if (check == RESULT_SUCCESS) {
+		ret = DIAGNOSTICS_RELAY_E_SUCCESS;
+	} else if (check == RESULT_UNKNOWN_REQUEST) {
+		ret = DIAGNOSTICS_RELAY_E_UNKNOWN_REQUEST;
+	} else {
+		ret = DIAGNOSTICS_RELAY_E_UNKNOWN_ERROR;
+	}
+
+	plist_free(dict);
+	return ret;
+}
+
+diagnostics_relay_error_t diagnostics_relay_restart(diagnostics_relay_client_t client, diagnostics_relay_action_t flags)
+{
+	return internal_diagnostics_relay_action(client, "Restart", flags);
+}
+
+diagnostics_relay_error_t diagnostics_relay_shutdown(diagnostics_relay_client_t client, diagnostics_relay_action_t flags)
+{
+	return internal_diagnostics_relay_action(client, "Shutdown", flags);
+}
+
+diagnostics_relay_error_t diagnostics_relay_request_diagnostics(diagnostics_relay_client_t client, const char* type, plist_t* diagnostics)
+{
+	if (!client || diagnostics == NULL)
+		return DIAGNOSTICS_RELAY_E_INVALID_ARG;
+
+	diagnostics_relay_error_t ret = DIAGNOSTICS_RELAY_E_UNKNOWN_ERROR;
+
+	plist_t dict = plist_new_dict();
+	plist_dict_set_item(dict,"Request", plist_new_string(type));
+	ret = diagnostics_relay_send(client, dict);
+	plist_free(dict);
+	dict = NULL;
+	if (ret != DIAGNOSTICS_RELAY_E_SUCCESS) {
+		return ret;
+	}
+
+	ret = diagnostics_relay_receive(client, &dict);
+	if (!dict) {
+		return DIAGNOSTICS_RELAY_E_PLIST_ERROR;
+	}
+
+	int check = diagnostics_relay_check_result(dict);
+	if (check == RESULT_SUCCESS) {
+		ret = DIAGNOSTICS_RELAY_E_SUCCESS;
+	} else if (check == RESULT_UNKNOWN_REQUEST) {
+		ret = DIAGNOSTICS_RELAY_E_UNKNOWN_REQUEST;
+	} else {
+		ret = DIAGNOSTICS_RELAY_E_UNKNOWN_ERROR;
+	}
+
+	if (ret != DIAGNOSTICS_RELAY_E_SUCCESS) {
+		plist_free(dict);
+		return ret;
+	}
+
+	plist_t value_node = plist_dict_get_item(dict, "Diagnostics");
+	if (value_node) {
+		*diagnostics = plist_copy(value_node);
+	}
+
+	plist_free(dict);
+	return ret;
+}
+
+diagnostics_relay_error_t diagnostics_relay_query_mobilegestalt(diagnostics_relay_client_t client, plist_t keys, plist_t* result)
+{
+	if (!client || plist_get_node_type(keys) != PLIST_ARRAY || result == NULL)
+		return DIAGNOSTICS_RELAY_E_INVALID_ARG;
+
+	diagnostics_relay_error_t ret = DIAGNOSTICS_RELAY_E_UNKNOWN_ERROR;
+
+	plist_t dict = plist_new_dict();
+	plist_dict_set_item(dict,"MobileGestaltKeys", plist_copy(keys));
+	plist_dict_set_item(dict,"Request", plist_new_string("MobileGestalt"));
+	ret = diagnostics_relay_send(client, dict);
+	plist_free(dict);
+	dict = NULL;
+	if (ret != DIAGNOSTICS_RELAY_E_SUCCESS) {
+		return ret;
+	}
+
+	ret = diagnostics_relay_receive(client, &dict);
+	if (!dict) {
+		return DIAGNOSTICS_RELAY_E_PLIST_ERROR;
+	}
+
+	int check = diagnostics_relay_check_result(dict);
+	if (check == RESULT_SUCCESS) {
+		ret = DIAGNOSTICS_RELAY_E_SUCCESS;
+	} else if (check == RESULT_UNKNOWN_REQUEST) {
+		ret = DIAGNOSTICS_RELAY_E_UNKNOWN_REQUEST;
+	} else {
+		ret = DIAGNOSTICS_RELAY_E_UNKNOWN_ERROR;
+	}
+
+	if (ret != DIAGNOSTICS_RELAY_E_SUCCESS) {
+		plist_free(dict);
+		return ret;
+	}
+
+	plist_t value_node = plist_dict_get_item(dict, "Diagnostics");
+	if (value_node) {
+		*result = plist_copy(value_node);
+	}
+
+	plist_free(dict);
+	return ret;
+}
+
+diagnostics_relay_error_t diagnostics_relay_query_ioregistry_entry(diagnostics_relay_client_t client, const char* entry_name, const char* entry_class, plist_t* result)
+{
+	if (!client || (entry_name == NULL && entry_class == NULL) || result == NULL)
+		return DIAGNOSTICS_RELAY_E_INVALID_ARG;
+
+	diagnostics_relay_error_t ret = DIAGNOSTICS_RELAY_E_UNKNOWN_ERROR;
+
+	plist_t dict = plist_new_dict();
+	if (entry_name)
+		plist_dict_set_item(dict,"EntryName", plist_new_string(entry_name));
+	if (entry_class)
+		plist_dict_set_item(dict,"EntryClass", plist_new_string(entry_class));
+	plist_dict_set_item(dict,"Request", plist_new_string("IORegistry"));
+	ret = diagnostics_relay_send(client, dict);
+	plist_free(dict);
+	dict = NULL;
+	if (ret != DIAGNOSTICS_RELAY_E_SUCCESS) {
+		return ret;
+	}
+
+	ret = diagnostics_relay_receive(client, &dict);
+	if (!dict) {
+		return DIAGNOSTICS_RELAY_E_PLIST_ERROR;
+	}
+
+	int check = diagnostics_relay_check_result(dict);
+	if (check == RESULT_SUCCESS) {
+		ret = DIAGNOSTICS_RELAY_E_SUCCESS;
+	} else if (check == RESULT_UNKNOWN_REQUEST) {
+		ret = DIAGNOSTICS_RELAY_E_UNKNOWN_REQUEST;
+	} else {
+		ret = DIAGNOSTICS_RELAY_E_UNKNOWN_ERROR;
+	}
+
+	if (ret != DIAGNOSTICS_RELAY_E_SUCCESS) {
+		plist_free(dict);
+		return ret;
+	}
+
+	plist_t value_node = plist_dict_get_item(dict, "Diagnostics");
+	if (value_node) {
+		*result = plist_copy(value_node);
+	}
+
+	plist_free(dict);
+	return ret;
+}
+
+diagnostics_relay_error_t diagnostics_relay_query_ioregistry_plane(diagnostics_relay_client_t client, const char* plane, plist_t* result)
+{
+	if (!client || plane == NULL || result == NULL)
+		return DIAGNOSTICS_RELAY_E_INVALID_ARG;
+
+	diagnostics_relay_error_t ret = DIAGNOSTICS_RELAY_E_UNKNOWN_ERROR;
+
+	plist_t dict = plist_new_dict();
+	plist_dict_set_item(dict,"CurrentPlane", plist_new_string(plane));
+	plist_dict_set_item(dict,"Request", plist_new_string("IORegistry"));
+	ret = diagnostics_relay_send(client, dict);
+	plist_free(dict);
+	dict = NULL;
+
+	ret = diagnostics_relay_receive(client, &dict);
+	if (!dict) {
+		return DIAGNOSTICS_RELAY_E_PLIST_ERROR;
+	}
+
+	int check = diagnostics_relay_check_result(dict);
+	if (check == RESULT_SUCCESS) {
+		ret = DIAGNOSTICS_RELAY_E_SUCCESS;
+	} else if (check == RESULT_UNKNOWN_REQUEST) {
+		ret = DIAGNOSTICS_RELAY_E_UNKNOWN_REQUEST;
+	} else {
+		ret = DIAGNOSTICS_RELAY_E_UNKNOWN_ERROR;
+	}
+
+	if (ret != DIAGNOSTICS_RELAY_E_SUCCESS) {
+		plist_free(dict);
+		return ret;
+	}
+
+	plist_t value_node = plist_dict_get_item(dict, "Diagnostics");
+	if (value_node) {
+		*result = plist_copy(value_node);
+	}
+
+	plist_free(dict);
+	return ret;
+}

diagnostics_relay.h

@@ -0,0 +1,33 @@
+/*
+ * diagnostics_relay.h
+ * com.apple.mobile.diagnostics_relay service header file.
+ *
+ * Copyright (c) 2012 Martin Szulecki, All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef __DIAGNOSTICS_RELAY_H
+#define __DIAGNOSTICS_RELAY_H
+
+#include "idevice.h"
+#include "libimobiledevice/diagnostics_relay.h"
+#include "property_list_service.h"
+
+struct diagnostics_relay_client_private {
+	property_list_service_client_t parent;
+};
+
+#endif

diagnostics_relay.pxi

@@ -0,0 +1,128 @@
+REQUEST_TYPE_ALL = "All"
+REQUEST_TYPE_WIFI = "WiFi"
+REQUEST_TYPE_GAS_GAUGE = "GasGauge"
+REQUEST_TYPE_NAND = "NAND"
+
+cdef extern from "libimobiledevice/diagnostics_relay.h":
+    cdef struct diagnostics_relay_client_private:
+        pass
+    ctypedef diagnostics_relay_client_private *diagnostics_relay_client_t
+
+    ctypedef enum diagnostics_relay_error_t:
+        DIAGNOSTICS_RELAY_E_SUCCESS = 0
+        DIAGNOSTICS_RELAY_E_INVALID_ARG = -1
+        DIAGNOSTICS_RELAY_E_PLIST_ERROR = -2
+        DIAGNOSTICS_RELAY_E_MUX_ERROR = -3
+        DIAGNOSTICS_RELAY_E_UNKNOWN_REQUEST = -4
+        DIAGNOSTICS_RELAY_E_UNKNOWN_ERROR = -256
+    ctypedef enum diagnostics_relay_action_t:
+        DIAGNOSTICS_RELAY_ACTION_FLAG_WAIT_FOR_DISCONNECT = (1 << 1)
+        DIAGNOSTICS_RELAY_ACTION_FLAG_DISPLAY_PASS = (1 << 2)
+        DIAGNOSTICS_RELAY_ACTION_FLAG_DISPLAY_FAIL = (1 << 3)
+
+    diagnostics_relay_error_t diagnostics_relay_client_new(idevice_t device, lockdownd_service_descriptor_t descriptor, diagnostics_relay_client_t * client)
+    diagnostics_relay_error_t diagnostics_relay_client_free(diagnostics_relay_client_t client)
+
+    diagnostics_relay_error_t diagnostics_relay_goodbye(diagnostics_relay_client_t client)
+    diagnostics_relay_error_t diagnostics_relay_sleep(diagnostics_relay_client_t client)
+    diagnostics_relay_error_t diagnostics_relay_restart(diagnostics_relay_client_t client, diagnostics_relay_action_t flags)
+    diagnostics_relay_error_t diagnostics_relay_shutdown(diagnostics_relay_client_t client, diagnostics_relay_action_t flags)
+    diagnostics_relay_error_t diagnostics_relay_request_diagnostics(diagnostics_relay_client_t client, char* type, plist.plist_t* diagnostics)
+    diagnostics_relay_error_t diagnostics_relay_query_mobilegestalt(diagnostics_relay_client_t client, plist.plist_t keys, plist.plist_t* result)
+    diagnostics_relay_error_t diagnostics_relay_query_ioregistry_entry(diagnostics_relay_client_t client, char* name, char* class_name, plist.plist_t* result)
+    diagnostics_relay_error_t diagnostics_relay_query_ioregistry_plane(diagnostics_relay_client_t client, char* plane, plist.plist_t* result)
+
+cdef class DiagnosticsRelayError(BaseError):
+    def __init__(self, *args, **kwargs):
+        self._lookup_table = {
+            DIAGNOSTICS_RELAY_E_SUCCESS: "Success",
+            DIAGNOSTICS_RELAY_E_INVALID_ARG: "Invalid argument",
+            DIAGNOSTICS_RELAY_E_PLIST_ERROR: "Property list error",
+            DIAGNOSTICS_RELAY_E_MUX_ERROR: "MUX error",
+            DIAGNOSTICS_RELAY_E_UNKNOWN_REQUEST: "Unknown request",
+            DIAGNOSTICS_RELAY_E_UNKNOWN_ERROR: "Unknown error"
+        }
+        BaseError.__init__(self, *args, **kwargs)
+
+cdef class DiagnosticsRelayClient(PropertyListService):
+    __service_name__ = "com.apple.mobile.diagnostics_relay"
+    cdef diagnostics_relay_client_t _c_client
+
+    def __cinit__(self, iDevice device not None, LockdownServiceDescriptor descriptor, *args, **kwargs):
+        self.handle_error(diagnostics_relay_client_new(device._c_dev, descriptor._c_service_descriptor, &self._c_client))
+
+    def __dealloc__(self):
+        cdef diagnostics_relay_error_t err
+        if self._c_client is not NULL:
+            err = diagnostics_relay_client_free(self._c_client)
+            self.handle_error(err)
+
+    cdef inline BaseError _error(self, int16_t ret):
+        return DiagnosticsRelayError(ret)
+
+    cpdef goodbye(self):
+        self.handle_error(diagnostics_relay_goodbye(self._c_client))
+
+    cpdef sleep(self):
+        self.handle_error(diagnostics_relay_sleep(self._c_client))
+
+    cpdef restart(self, diagnostics_relay_action_t flags):
+        self.handle_error(diagnostics_relay_restart(self._c_client, flags))
+
+    cpdef shutdown(self, diagnostics_relay_action_t flags):
+        self.handle_error(diagnostics_relay_shutdown(self._c_client, flags))
+
+    cpdef plist.Node request_diagnostics(self, bytes type):
+        cdef:
+            plist.plist_t c_node = NULL
+            diagnostics_relay_error_t err
+        err = diagnostics_relay_request_diagnostics(self._c_client, type, &c_node)
+        try:
+            self.handle_error(err)
+            return plist.plist_t_to_node(c_node)
+        except BaseError, e:
+            if c_node != NULL:
+                plist.plist_free(c_node)
+            raise
+
+    cpdef plist.Node query_mobilegestalt(self, plist.Node keys = None):
+        cdef:
+            plist.plist_t c_node = NULL
+            diagnostics_relay_error_t err
+            plist.plist_t keys_c_node = NULL
+        if keys is not None:
+            keys_c_node = keys._c_node
+        err = diagnostics_relay_query_mobilegestalt(self._c_client, keys_c_node, &c_node)
+        try:
+            self.handle_error(err)
+            return plist.plist_t_to_node(c_node)
+        except BaseError, e:
+            if c_node != NULL:
+                plist.plist_free(c_node)
+            raise
+
+    cpdef plist.Node query_ioregistry_entry(self, bytes name, bytes class_name):
+        cdef:
+            plist.plist_t c_node = NULL
+            diagnostics_relay_error_t err
+        err = diagnostics_relay_query_ioregistry_entry(self._c_client, name, class_name, &c_node)
+        try:
+            self.handle_error(err)
+            return plist.plist_t_to_node(c_node)
+        except BaseError, e:
+            if c_node != NULL:
+                plist.plist_free(c_node)
+            raise
+
+    cpdef plist.Node query_ioregistry_plane(self, bytes plane = None):
+        cdef:
+            plist.plist_t c_node = NULL
+            diagnostics_relay_error_t err
+        err = diagnostics_relay_query_ioregistry_plane(self._c_client, plane, &c_node)
+        try:
+            self.handle_error(err)
+            return plist.plist_t_to_node(c_node)
+        except BaseError, e:
+            if c_node != NULL:
+                plist.plist_free(c_node)
+            raise

download.c

@@ -0,0 +1,156 @@
+/*
+ * download.c
+ * file download helper functions
+ *
+ * Copyright (c) 2012-2019 Nikias Bassen. All Rights Reserved.
+ * Copyright (c) 2012-2013 Martin Szulecki. All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <curl/curl.h>
+
+#include "download.h"
+#include "common.h"
+
+typedef struct {
+	int length;
+	char* content;
+} curl_response;
+
+static size_t download_write_buffer_callback(char* data, size_t size, size_t nmemb, curl_response* response) {
+	size_t total = size * nmemb;
+	if (total != 0) {
+		response->content = realloc(response->content, response->length + total + 1);
+		memcpy(response->content + response->length, data, total);
+		response->content[response->length + total] = '\0';
+		response->length += total;
+	}
+	return total;
+}
+
+int download_to_buffer(const char* url, char** buf, uint32_t* length)
+{
+	int res = 0;
+	CURL* handle = curl_easy_init();
+	if (handle == NULL) {
+		error("ERROR: could not initialize CURL\n");
+		return -1;
+	}
+
+	curl_response response;
+	response.length = 0;
+	response.content = malloc(1);
+	response.content[0] = '\0';
+
+	if (idevicerestore_debug)
+		curl_easy_setopt(handle, CURLOPT_VERBOSE, 1);
+
+	/* disable SSL verification to allow download from untrusted https locations */
+	curl_easy_setopt(handle, CURLOPT_SSL_VERIFYPEER, 0);
+
+	curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, (curl_write_callback)&download_write_buffer_callback);
+	curl_easy_setopt(handle, CURLOPT_WRITEDATA, &response);
+	if (strncmp(url, "https://api.ipsw.me/", 20) == 0) {
+		curl_easy_setopt(handle, CURLOPT_USERAGENT, USER_AGENT_STRING " idevicerestore/" PACKAGE_VERSION);
+	} else {
+		curl_easy_setopt(handle, CURLOPT_USERAGENT, USER_AGENT_STRING);
+	}
+	curl_easy_setopt(handle, CURLOPT_FOLLOWLOCATION, 1);
+	curl_easy_setopt(handle, CURLOPT_URL, url);
+
+	curl_easy_perform(handle);
+	curl_easy_cleanup(handle);
+
+	if (response.length > 0) {
+		*length = response.length;
+		*buf = response.content;
+	} else {
+		res = -1;
+	}
+
+	return res;
+}
+
+static int lastprogress = 0;
+
+static int download_progress(void *clientp, double dltotal, double dlnow, double ultotal, double ulnow)
+{
+	double p = (dlnow / dltotal) * 100;
+
+	if (p < 100.0) {
+		if ((int)p > lastprogress) {
+			info("downloading: %d%%\n", (int)p);
+			lastprogress = (int)p;
+		}
+	}
+
+	return 0;
+}
+
+int download_to_file(const char* url, const char* filename, int enable_progress)
+{
+	int res = 0;
+	CURL* handle = curl_easy_init();
+	if (handle == NULL) {
+		error("ERROR: could not initialize CURL\n");
+		return -1;
+	}
+
+	FILE* f = fopen(filename, "wb");
+	if (!f) {
+		error("ERROR: cannot open '%s' for writing\n", filename);
+		return -1;
+	}
+
+	lastprogress = 0;
+
+	if (idevicerestore_debug)
+		curl_easy_setopt(handle, CURLOPT_VERBOSE, 1);
+
+	/* disable SSL verification to allow download from untrusted https locations */
+	curl_easy_setopt(handle, CURLOPT_SSL_VERIFYPEER, 0);
+
+	curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, NULL);
+	curl_easy_setopt(handle, CURLOPT_WRITEDATA, f);
+
+	if (enable_progress > 0)
+		curl_easy_setopt(handle, CURLOPT_PROGRESSFUNCTION, (curl_progress_callback)&download_progress);
+
+	curl_easy_setopt(handle, CURLOPT_NOPROGRESS, enable_progress > 0 ? 0: 1);
+	curl_easy_setopt(handle, CURLOPT_USERAGENT, USER_AGENT_STRING);
+	curl_easy_setopt(handle, CURLOPT_FOLLOWLOCATION, 1);
+	curl_easy_setopt(handle, CURLOPT_URL, url);
+
+	curl_easy_perform(handle);
+	curl_easy_cleanup(handle);
+
+#ifdef WIN32
+	fflush(f);
+	uint64_t sz = _lseeki64(fileno(f), 0, SEEK_CUR);
+#else
+	off_t sz = ftello(f);
+#endif
+	fclose(f);
+
+	if ((sz == 0) || ((int64_t)sz == (int64_t)-1)) {
+		res = -1;
+		remove(filename);
+	}
+
+	return res;
+}

download.h

@@ -0,0 +1,38 @@
+/*
+ * download.h
+ * file download helper functions (header file)
+ *
+ * Copyright (c) 2012 Martin Szulecki. All Rights Reserved.
+ * Copyright (c) 2012 Nikias Bassen. All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef IDEVICERESTORE_DOWNLOAD_H
+#define IDEVICERESTORE_DOWNLOAD_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+int download_to_buffer(const char* url, char** buf, uint32_t* length);
+int download_to_file(const char* url, const char* filename, int enable_progress);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

endianness.h

@@ -0,0 +1,123 @@
+#ifndef ENDIANNESS_H
+#define ENDIANNESS_H
+
+#ifndef __LITTLE_ENDIAN
+#define __LITTLE_ENDIAN 1234
+#endif
+
+#ifndef __BIG_ENDIAN
+#define __BIG_ENDIAN 4321
+#endif
+
+#ifndef __BYTE_ORDER
+#ifdef __LITTLE_ENDIAN__
+#define __BYTE_ORDER __LITTLE_ENDIAN
+#else
+#ifdef __BIG_ENDIAN__
+#define __BYTE_ORDER __BIG_ENDIAN
+#endif
+#endif
+#endif
+
+#ifndef be16toh
+#if __BYTE_ORDER == __BIG_ENDIAN
+#define be16toh(x) (x)
+#else
+#define be16toh(x) ((((x) & 0xFF00) >> 8) | (((x) & 0x00FF) << 8))
+#endif
+#endif
+
+#ifndef htobe16
+#define htobe16 be16toh
+#endif
+
+#ifndef le16toh
+#if __BYTE_ORDER == __BIG_ENDIAN
+#define le16toh(x) ((((x) & 0xFF00) >> 8) | (((x) & 0x00FF) << 8))
+#else
+#define le16toh(x) (x)
+#endif
+#endif
+
+#ifndef htole16
+#define htole16 le16toh
+#endif
+
+#ifndef __bswap_32
+#define __bswap_32(x) ((((x) & 0xFF000000) >> 24) \
+                    | (((x) & 0x00FF0000) >> 8) \
+                    | (((x) & 0x0000FF00) << 8) \
+                    | (((x) & 0x000000FF) << 24))
+#endif
+
+#ifndef be32toh
+#if __BYTE_ORDER == __BIG_ENDIAN
+#define be32toh(x) (x)
+#else
+#define be32toh(x) __bswap_32(x)
+#endif
+#endif
+
+#ifndef htobe32
+#define htobe32 be32toh
+#endif
+
+#ifndef le32toh
+#if __BYTE_ORDER == __BIG_ENDIAN
+#define le32toh(x) __bswap_32(x)
+#else
+#define le32toh(x) (x)
+#endif
+#endif
+
+#ifndef htole32
+#define htole32 le32toh
+#endif
+
+#ifndef __bswap_64
+#define __bswap_64(x) ((((x) & 0xFF00000000000000ull) >> 56) \
+                    | (((x) & 0x00FF000000000000ull) >> 40) \
+                    | (((x) & 0x0000FF0000000000ull) >> 24) \
+                    | (((x) & 0x000000FF00000000ull) >> 8) \
+                    | (((x) & 0x00000000FF000000ull) << 8) \
+                    | (((x) & 0x0000000000FF0000ull) << 24) \
+                    | (((x) & 0x000000000000FF00ull) << 40) \
+                    | (((x) & 0x00000000000000FFull) << 56))
+#endif
+
+#ifndef htobe64
+#if __BYTE_ORDER == __BIG_ENDIAN
+#define htobe64(x) (x)
+#else
+#define htobe64(x) __bswap_64(x)
+#endif
+#endif
+
+#ifndef be64toh
+#define be64toh htobe64
+#endif
+
+#ifndef le64toh
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+#define le64toh(x) (x)
+#else
+#define le64toh(x) __bswap_64(x)
+#endif
+#endif
+
+#ifndef htole64
+#define htole64 le64toh
+#endif
+
+#if (defined(__BIG_ENDIAN__) \
+     && !defined(__FLOAT_WORD_ORDER__)) \
+ || (defined(__FLOAT_WORD_ORDER__) \
+     && __FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__)
+#define float_bswap64(x) __bswap_64(x)
+#define float_bswap32(x) __bswap_32(x)
+#else
+#define float_bswap64(x) (x)
+#define float_bswap32(x) (x)
+#endif
+
+#endif /* ENDIANNESS_H */

fdr.c

@@ -0,0 +1,629 @@
+/*
+ * fdr.c
+ * Connection proxy service used by FDR
+ *
+ * Copyright (c) 2014 BALATON Zoltan. All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <libimobiledevice/libimobiledevice.h>
+
+#include "socket.h" /* from libimobiledevice/common */
+#include "common.h"
+#include "idevicerestore.h"
+#include "fdr.h"
+#include <endianness.h> /* from libimobiledevice */
+
+#define CTRL_PORT 0x43a /*1082*/
+#define CTRLCMD  "BeginCtrl"
+#define HELLOCTRLCMD "HelloCtrl"
+#define HELLOCMD "HelloConn"
+
+#define FDR_SYNC_MSG  0x1
+#define FDR_PROXY_MSG 0x105
+#define FDR_PLIST_MSG 0xbbaa
+
+static uint64_t conn_port;
+static int ctrlprotoversion = 2;
+static int serial;
+
+static int fdr_receive_plist(fdr_client_t fdr, plist_t* data);
+static int fdr_send_plist(fdr_client_t fdr, plist_t data);
+static int fdr_ctrl_handshake(fdr_client_t fdr);
+static int fdr_sync_handshake(fdr_client_t fdr);
+static int fdr_handle_sync_cmd(fdr_client_t fdr);
+static int fdr_handle_plist_cmd(fdr_client_t fdr);
+static int fdr_handle_proxy_cmd(fdr_client_t fdr);
+
+int fdr_connect(idevice_t device, fdr_type_t type, fdr_client_t* fdr)
+{
+	int res = -1, i = 0;
+	int attempts = 10;
+	idevice_connection_t connection = NULL;
+	idevice_error_t device_error = IDEVICE_E_SUCCESS;
+	uint16_t port = (type == FDR_CONN ? conn_port : CTRL_PORT);
+
+	*fdr = NULL;
+
+	debug("Connecting to FDR client at port %u\n", port);
+
+	for (i = 1; i <= attempts; i++) {
+		device_error = idevice_connect(device, port, &connection);
+		if (device_error == IDEVICE_E_SUCCESS) {
+			break;
+		}
+
+		if (i >= attempts) {
+			error("ERROR: Unable to connect to FDR client (%d)\n", device_error);
+			return -1;
+		}
+
+		sleep(2);
+		debug("Retrying connection...\n");
+	}
+
+	fdr_client_t fdr_loc = calloc(1, sizeof(struct fdr_client));
+	if (!fdr_loc) {
+		error("ERROR: Unable to allocate memory\n");
+		return -1;
+	}
+	fdr_loc->connection = connection;
+	fdr_loc->device = device;
+	fdr_loc->type = type;
+
+	/* Do handshake */
+	if (type == FDR_CTRL)
+		res = fdr_ctrl_handshake(fdr_loc);
+	else if (type == FDR_CONN)
+		res = fdr_sync_handshake(fdr_loc);
+
+	if (res) {
+		fdr_free(fdr_loc);
+		return -1;
+	}
+
+	*fdr = fdr_loc;
+
+	return 0;
+}
+
+void fdr_disconnect(fdr_client_t fdr)
+{
+	if (!fdr)
+		return;
+
+	if (fdr->connection) {
+		idevice_connection_t conn = fdr->connection;
+		fdr->connection = NULL;
+		idevice_disconnect(conn);
+	}
+}
+
+void fdr_free(fdr_client_t fdr)
+{
+	if (!fdr)
+		return;
+
+	fdr_disconnect(fdr);
+
+	free(fdr);
+	fdr = NULL;
+}
+
+int fdr_poll_and_handle_message(fdr_client_t fdr)
+{
+	idevice_error_t device_error = IDEVICE_E_SUCCESS;
+	uint32_t bytes = 0;
+	uint16_t cmd;
+
+	if (!fdr) {
+		error("ERROR: Invalid FDR client\n");
+		return -1;
+	}
+
+	device_error = idevice_connection_receive_timeout(fdr->connection, (char *)&cmd, sizeof(cmd), &bytes, 20000);
+#ifdef HAVE_IDEVICE_E_TIMEOUT
+	if (device_error == IDEVICE_E_TIMEOUT || (device_error == IDEVICE_E_SUCCESS && bytes != sizeof(cmd)))
+#else
+	if (device_error == IDEVICE_E_SUCCESS && bytes != sizeof(cmd))
+#endif
+	{
+		debug("FDR %p timeout waiting for command\n", fdr);
+		return 0;
+	}
+	else if (device_error != IDEVICE_E_SUCCESS) {
+		if (fdr->connection) {
+			error("ERROR: Unable to receive message from FDR %p (%d). %u/%u bytes\n", fdr, device_error, bytes, (uint32_t)sizeof(cmd));
+		}
+		return -1;
+	}
+
+	if (cmd == FDR_SYNC_MSG) {
+		debug("FDR %p got sync message\n", fdr);
+		return fdr_handle_sync_cmd(fdr);
+	}
+
+	if (cmd == FDR_PROXY_MSG) {
+		debug("FDR %p got proxy message\n", fdr);
+		return fdr_handle_proxy_cmd(fdr);
+	}
+
+	if (cmd == FDR_PLIST_MSG) {
+		debug("FDR %p got plist message\n", fdr);
+		return fdr_handle_plist_cmd(fdr);
+	}
+
+	error("WARNING: FDR %p received unknown packet %#x of size %u\n", fdr, cmd, bytes);
+	return 0;
+}
+
+void *fdr_listener_thread(void *cdata)
+{
+	fdr_client_t fdr = cdata;
+	int res;
+
+	while (fdr && fdr->connection) {
+		debug("FDR %p waiting for message...\n", fdr);
+		res = fdr_poll_and_handle_message(fdr);
+		if (fdr->type == FDR_CTRL && res >= 0)
+			continue; // main thread should always retry
+		if (res != 0)
+			break;
+	}
+	debug("FDR %p terminating...\n", fdr);
+	fdr_free(fdr);
+	return (void *)(intptr_t)res;
+}
+
+static int fdr_receive_plist(fdr_client_t fdr, plist_t* data)
+{
+	idevice_error_t device_error = IDEVICE_E_SUCCESS;
+	uint32_t len, bytes = 0;
+	char* buf = NULL;
+
+	device_error = idevice_connection_receive(fdr->connection, (char*)&len, sizeof(len), &bytes);
+	if (device_error != IDEVICE_E_SUCCESS) {
+		error("ERROR: Unable to receive packet length from FDR (%d)\n", device_error);
+		return -1;
+	}
+
+	buf = calloc(1, len);
+	if (!buf) {
+		error("ERROR: Unable to allocate memory for FDR receive buffer\n");
+		return -1;
+	}
+
+	device_error = idevice_connection_receive(fdr->connection, buf, len, &bytes);
+	if (device_error != IDEVICE_E_SUCCESS) {
+		error("ERROR: Unable to receive data from FDR\n");
+		free(buf);
+		return -1;
+	}
+	plist_from_bin(buf, bytes, data);
+	free(buf);
+
+	debug("FDR Received %d bytes\n", bytes);
+
+	return 0;
+}
+
+static int fdr_send_plist(fdr_client_t fdr, plist_t data)
+{
+	idevice_error_t device_error = IDEVICE_E_SUCCESS;
+	char *buf = NULL;
+	uint32_t len = 0, bytes = 0;
+
+	if (!data)
+		return -1;
+
+	plist_to_bin(data, &buf, &len);
+	if (!buf)
+		return -1;
+
+	debug("FDR sending %d bytes:\n", len);
+	if (idevicerestore_debug)
+		debug_plist(data);
+	device_error = idevice_connection_send(fdr->connection, (char *)&len, sizeof(len), &bytes);
+	if (device_error != IDEVICE_E_SUCCESS || bytes != sizeof(len)) {
+		error("ERROR: FDR unable to send data length. (%d) Sent %u of %u bytes.\n",
+		      device_error, bytes, (uint32_t)sizeof(len));
+		free(buf);
+		return -1;
+	}
+	device_error = idevice_connection_send(fdr->connection, buf, len, &bytes);
+	free(buf);
+	if (device_error != IDEVICE_E_SUCCESS || bytes != len) {
+		error("ERROR: FDR unable to send data (%d). Sent %u of %u bytes.\n",
+		      device_error, bytes, len);
+		return -1;
+	}
+
+	debug("FDR Sent %d bytes\n", bytes);
+	return 0;
+}
+
+static int fdr_ctrl_handshake(fdr_client_t fdr)
+{
+	idevice_error_t device_error = IDEVICE_E_SUCCESS;
+	uint32_t bytes = 0, len = sizeof(CTRLCMD);
+	plist_t dict, node;
+	int res;
+
+	debug("About to do ctrl handshake\n");
+
+	ctrlprotoversion = 2;
+
+	device_error = idevice_connection_send(fdr->connection, CTRLCMD, len, &bytes);
+	if (device_error != IDEVICE_E_SUCCESS || bytes != len) {
+		debug("Hmm... lookes like the device doesn't like the newer protocol, using the old one\n");
+		ctrlprotoversion = 1;
+		len = sizeof(HELLOCTRLCMD);
+		device_error = idevice_connection_send(fdr->connection, HELLOCTRLCMD, len, &bytes);
+		if (device_error != IDEVICE_E_SUCCESS || bytes != len) {
+			error("ERROR: FDR unable to send BeginCtrl. Sent %u of %u bytes.\n", bytes, len);
+			return -1;
+		}
+	}
+
+	if (ctrlprotoversion == 2) {
+		dict = plist_new_dict();
+		plist_dict_set_item(dict, "Command", plist_new_string(CTRLCMD));
+		plist_dict_set_item(dict, "CtrlProtoVersion", plist_new_uint(ctrlprotoversion));
+		res = fdr_send_plist(fdr, dict);
+		plist_free(dict);
+		if (res) {
+			error("ERROR: FDR could not send Begin command.\n");
+			return -1;
+		}
+
+		if (fdr_receive_plist(fdr, &dict)) {
+			error("ERROR: FDR did not get Begin command reply.\n");
+			return -1;
+		}
+		if (idevicerestore_debug)
+			debug_plist(dict);
+		node = plist_dict_get_item(dict, "ConnPort");
+		if (node && plist_get_node_type(node) == PLIST_UINT) {
+			plist_get_uint_val(node, &conn_port);
+		} else {
+			error("ERROR: Could not get FDR ConnPort value\n");
+			return -1;
+		}
+
+		plist_free(dict);
+	} else {
+		char buf[16];
+		uint16_t cport = 0;
+
+		memset(buf, '\0', sizeof(buf));
+
+		bytes = 0;
+		device_error = idevice_connection_receive(fdr->connection, buf, 10, &bytes);
+		if (device_error != IDEVICE_E_SUCCESS) {
+			error("ERROR: Could not receive reply to HelloCtrl command\n");
+			return -1;
+		}
+		if (memcmp(buf, "HelloCtrl", 10) != 0) {
+			buf[9] = '\0';
+			error("ERROR: Did not receive HelloCtrl as reply, but %s\n", buf);
+			return -1;
+		}
+
+		bytes = 0;
+		device_error = idevice_connection_receive(fdr->connection, (char*)&cport, 2, &bytes);
+		if (device_error != IDEVICE_E_SUCCESS) {
+			error("ERROR: Failed to receive conn port\n");
+			return -1;
+		}
+
+		conn_port = le16toh(cport);
+	}
+
+	debug("Ctrl handshake done (ConnPort = %" PRIu64 ")\n", (uint64_t)conn_port);
+
+	return 0;
+}
+
+static int fdr_sync_handshake(fdr_client_t fdr)
+{
+	idevice_error_t device_error = IDEVICE_E_SUCCESS;
+	uint32_t bytes = 0, len = sizeof(HELLOCMD);
+	plist_t reply;
+
+	device_error = idevice_connection_send(fdr->connection, HELLOCMD, len, &bytes);
+	if (device_error != IDEVICE_E_SUCCESS || bytes != len) {
+		error("ERROR: FDR unable to send Hello. Sent %u of %u bytes.\n", bytes, len);
+		return -1;
+	}
+
+	if (ctrlprotoversion == 2) {
+		if (fdr_receive_plist(fdr, &reply)) {
+			error("ERROR: FDR did not get HelloConn reply.\n");
+			return -1;
+		}
+		char* identifier = NULL;
+		char* cmd = NULL;
+		plist_t node = NULL;
+		node = plist_dict_get_item(reply, "Command");
+		if (node) {
+			plist_get_string_val(node, &cmd);
+		}
+		node = plist_dict_get_item(reply, "Identifier");
+		if (node) {
+			plist_get_string_val(node, &identifier);
+		}
+		plist_free(reply);
+
+		if (!cmd || (strcmp(cmd, "HelloConn") != 0)) {
+			if (cmd) {
+				free(cmd);
+			}
+			if (identifier) {
+				free(identifier);
+			}
+			error("ERROR: Did not receive HelloConn reply...\n");
+			return -1;
+		}
+		free(cmd);
+
+		if (identifier) {
+			debug("Got device identifier %s\n", identifier);
+			free(identifier);
+		}
+
+	} else {
+		char buf[16];
+		memset(buf, '\0', sizeof(buf));
+		bytes = 0;
+		device_error = idevice_connection_receive(fdr->connection, buf, 10, &bytes);
+		if (device_error != IDEVICE_E_SUCCESS) {
+			error("ERROR: Could not receive reply to HelloConn command\n");
+			return -1;
+		}
+		if (memcmp(buf, "HelloConn", 10) != 0) {
+			buf[9] = '\0';
+			error("ERROR: Did not receive HelloConn as reply, but %s\n", buf);
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+static int fdr_handle_sync_cmd(fdr_client_t fdr_ctrl)
+{
+	idevice_error_t device_error = IDEVICE_E_SUCCESS;
+	fdr_client_t fdr;
+	thread_t fdr_thread = (thread_t)NULL;
+	int res = 0;
+	uint32_t bytes = 0;
+	char buf[4096];
+
+	device_error = idevice_connection_receive(fdr_ctrl->connection, buf, sizeof(buf), &bytes);
+	if (device_error != IDEVICE_E_SUCCESS || bytes != 2) {
+		error("ERROR: Unexpected data from FDR\n");
+		return -1;
+	}
+	/* Open a new connection and wait for messages on it */
+	if (fdr_connect(fdr_ctrl->device, FDR_CONN, &fdr)) {
+		error("ERROR: Failed to connect to FDR port\n");
+		return -1;
+	}
+	debug("FDR connected in reply to sync message, starting command thread\n");
+	res = thread_new(&fdr_thread, fdr_listener_thread, fdr);
+	if(res) {
+		error("ERROR: Failed to start FDR command thread\n");
+		fdr_free(fdr);
+	}
+	return res;
+}
+
+static int fdr_handle_plist_cmd(fdr_client_t fdr)
+{
+	int res = 0;
+	plist_t dict;
+
+	if (fdr_receive_plist(fdr, &dict)) {
+		error("ERROR: FDR %p could not receive plist command.\n", fdr);
+		return -1;
+	}
+	plist_t node = plist_dict_get_item(dict, "Command");
+	if (!node || (plist_get_node_type(node) != PLIST_STRING)) {
+		error("ERROR: FDR %p Could not find Command in plist command\n", fdr);
+		plist_free(dict);
+		return -1;
+	}
+	char *command = NULL;
+	plist_get_string_val(node, &command);
+	plist_free(dict);
+
+	if (!command) {
+		info("FDR %p received empty plist command\n", fdr);
+		return -1;
+	}
+
+	if (!strcmp(command, "Ping")) {
+		dict = plist_new_dict();
+		plist_dict_set_item(dict, "Pong", plist_new_bool(1));
+		res = fdr_send_plist(fdr, dict);
+		plist_free(dict);
+		if (res) {
+			error("ERROR: FDR %p could not send Ping command reply.\n", fdr);
+			free(command);
+			return -1;
+		}
+	} else {
+ 		error("WARNING: FDR %p received unknown plist command: %s\n", fdr, command);
+		free(command);
+		return -1;
+	}
+
+	free(command);
+	/* FDR connection will be terminated remotely. Next receive will get nothing, error and terminate this worker thread. */
+	return 0;
+}
+
+static int fdr_handle_proxy_cmd(fdr_client_t fdr)
+{
+	idevice_error_t device_error = IDEVICE_E_SUCCESS;
+	char *buf = NULL;
+	size_t bufsize = 1048576;
+	uint32_t sent = 0, bytes = 0;
+	char *host = NULL;
+	uint16_t port = 0;
+
+	buf = malloc(bufsize);
+	if (!buf) {
+		error("ERROR: %s: malloc failed\n", __func__);
+		return -1;
+	}
+
+	device_error = idevice_connection_receive(fdr->connection, buf, bufsize, &bytes);
+	if (device_error != IDEVICE_E_SUCCESS) {
+		free(buf);
+		error("ERROR: FDR %p failed to read data for proxy command\n", fdr);
+		return -1;
+	}
+	debug("Got proxy command with %u bytes\n", bytes);
+
+	/* Just return success here unconditionally because we don't know
+	 * anything else and we will eventually abort on failure anyway */
+	uint16_t ack = 5;
+	device_error = idevice_connection_send(fdr->connection, (char *)&ack, sizeof(ack), &sent);
+	if (device_error != IDEVICE_E_SUCCESS || sent != sizeof(ack)) {
+		free(buf);
+		error("ERROR: FDR %p unable to send ack. Sent %u of %u bytes.\n",
+		      fdr, sent, (uint32_t)sizeof(ack));
+		return -1;
+	}
+
+	if (bytes < 3) {
+		debug("FDR %p proxy command data too short, retrying\n", fdr);
+		return fdr_poll_and_handle_message(fdr);
+	}
+
+	/* ack command data too */
+	device_error = idevice_connection_send(fdr->connection, buf, bytes, &sent);
+	if (device_error != IDEVICE_E_SUCCESS || sent != bytes) {
+		free(buf);
+		error("ERROR: FDR %p unable to send data. Sent %u of %u bytes.\n",
+		      fdr, sent, bytes);
+		return -1;
+	}
+
+	/* Now try to handle actual messages */
+	/* Connect: 0 3 hostlen <host> <port> */
+	if (buf[0] == 0 && buf[1] == 3) {
+		uint16_t *p = (uint16_t *)&buf[bytes - 2];
+		port = be16toh(*p);
+		buf[bytes - 2] = '\0';
+		host = strdup(&buf[3]);
+		debug("FDR %p Proxy connect request to %s:%u\n", fdr, host, port);
+	}
+
+	if (!host || !buf[2]) {
+		/* missing or zero length host name */
+		free(buf);
+		return 0;
+	}
+
+	/* else wait for messages and forward them */
+	int sockfd = socket_connect(host, port);
+	free(host);
+	if (sockfd < 0) {
+		free(buf);
+		error("ERROR: Failed to connect socket: %s\n", strerror(errno));
+		return -1;
+	}
+
+	int res = 0, bytes_ret;
+	while (1) {
+		bytes = 0;
+		device_error = idevice_connection_receive_timeout(fdr->connection, buf, bufsize, &bytes, 100);
+#ifdef HAVE_IDEVICE_E_TIMEOUT
+		if (device_error == IDEVICE_E_TIMEOUT || (device_error == IDEVICE_E_SUCCESS && !bytes))
+#else
+		if (device_error == IDEVICE_E_SUCCESS && !bytes)
+#endif
+		{
+			//debug("WARNING: Timeout waiting for proxy payload. %p\n", fdr);
+		}
+		else if (device_error != IDEVICE_E_SUCCESS) {
+			error("ERROR: FDR %p Unable to receive proxy payload (%d)\n", fdr, device_error);
+			res = -1;
+			break;
+		}
+		if (bytes) {
+			debug("FDR %p got payload of %u bytes, now try to proxy it\n", fdr, bytes);
+			debug("Sending %u bytes of data\n", bytes);
+			sent = 0;
+			while (sent < bytes) {
+				int s = socket_send(sockfd, buf + sent, bytes - sent);
+				if (s < 0) {
+					break;
+				}
+				sent += s;
+			}
+			if (sent != bytes) {
+				error("ERROR: Sending proxy payload failed: %s. Sent %u of %u bytes. \n", strerror(errno), sent, bytes);
+				socket_close(sockfd);
+				res = -1;
+				break;
+			}
+		}
+		bytes_ret = socket_receive_timeout(sockfd, buf, bufsize, 0, 100);
+		if (bytes_ret < 0) {
+			if (errno)
+				error("ERROR: FDR %p receiving proxy payload failed: %s\n",
+				      fdr, strerror(errno));
+			else
+				res = 1; /* close connection if no data with no error */
+			break;
+		}
+
+		bytes = bytes_ret;
+		if (bytes) {
+			debug("FDR %p Received %u bytes reply data,%s sending to device\n",
+			      fdr, bytes, (bytes ? "" : " not"));
+
+			sent = 0;
+			while (sent < bytes) {
+				uint32_t s;
+				device_error = idevice_connection_send(fdr->connection, buf + sent, bytes - sent, &s);
+				if (device_error != IDEVICE_E_SUCCESS) {
+					break;
+				}
+				sent += s;
+			}
+			if (device_error != IDEVICE_E_SUCCESS || bytes != sent) {
+				error("ERROR: FDR %p unable to send data (%d). Sent %u of %u bytes.\n", fdr, device_error, sent, bytes);
+				res = -1;
+				break;
+			}
+		} else serial++;
+	}
+	socket_close(sockfd);
+	free(buf);
+	return res;
+}

fdr.h

@@ -0,0 +1,54 @@
+/*
+ * fdr.h
+ * Functions for handling FDR connections
+ *
+ * Copyright (c) 2014 BALATON Zoltan. All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef IDEVICERESTORE_FDR_H
+#define IDEVICERESTORE_FDR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <libimobiledevice/libimobiledevice.h>
+#include "thread.h" /* from libimobiledevice/common */
+
+typedef enum {
+	FDR_CTRL,
+	FDR_CONN
+} fdr_type_t;
+
+struct fdr_client {
+	idevice_connection_t connection;
+	idevice_t device;
+	fdr_type_t type;
+};
+typedef struct fdr_client *fdr_client_t;
+
+int fdr_connect(idevice_t device, fdr_type_t type, fdr_client_t *fdr);
+void fdr_disconnect(fdr_client_t fdr);
+void fdr_free(fdr_client_t fdr);
+int fdr_poll_and_handle_message(fdr_client_t fdr);
+void *fdr_listener_thread(void *cdata);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

file_relay.c

@@ -0,0 +1,165 @@
+/*
+ * file_relay.c
+ * com.apple.mobile.file_relay service implementation.
+ *
+ * Copyright (c) 2010 Nikias Bassen, All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <string.h>
+#include <stdlib.h>
+#include "file_relay.h"
+#include "property_list_service.h"
+#include "common/debug.h"
+
+file_relay_error_t file_relay_client_new(idevice_t device, lockdownd_service_descriptor_t service, file_relay_client_t *client)
+{
+	if (!device || !service || service->port == 0 || !client || *client) {
+		return FILE_RELAY_E_INVALID_ARG;
+	}
+
+	property_list_service_client_t plistclient = NULL;
+	if (property_list_service_client_new(device, service, &plistclient) != PROPERTY_LIST_SERVICE_E_SUCCESS) {
+		return FILE_RELAY_E_MUX_ERROR;
+	}
+
+	/* create client object */
+	file_relay_client_t client_loc = (file_relay_client_t) malloc(sizeof(struct file_relay_client_private));
+	client_loc->parent = plistclient;
+
+	/* all done, return success */
+	*client = client_loc;
+	return FILE_RELAY_E_SUCCESS;
+}
+
+file_relay_error_t file_relay_client_start_service(idevice_t device, file_relay_client_t * client, const char* label)
+{
+	file_relay_error_t err = FILE_RELAY_E_UNKNOWN_ERROR;
+	service_client_factory_start_service(device, FILE_RELAY_SERVICE_NAME, (void**)client, label, SERVICE_CONSTRUCTOR(file_relay_client_new), &err);
+	return err;
+}
+
+file_relay_error_t file_relay_client_free(file_relay_client_t client)
+{
+	if (!client)
+		return FILE_RELAY_E_INVALID_ARG;
+
+	if (property_list_service_client_free(client->parent) != PROPERTY_LIST_SERVICE_E_SUCCESS) {
+		return FILE_RELAY_E_UNKNOWN_ERROR;
+	}
+	free(client);
+	return FILE_RELAY_E_SUCCESS;
+}
+
+file_relay_error_t file_relay_request_sources_timeout(file_relay_client_t client, const char **sources, idevice_connection_t *connection, unsigned int timeout)
+{
+	if (!client || !client->parent || !sources || !sources[0]) {
+		return FILE_RELAY_E_INVALID_ARG;
+	}
+	*connection = NULL;
+	file_relay_error_t err = FILE_RELAY_E_UNKNOWN_ERROR;
+	/* set up request plist */
+	plist_t array = plist_new_array();
+	int i = 0;
+	while (sources[i]) {
+		plist_array_append_item(array, plist_new_string(sources[i]));
+		i++;
+	}
+	plist_t dict = plist_new_dict();
+	plist_dict_set_item(dict, "Sources", array);
+
+	if (property_list_service_send_xml_plist(client->parent, dict) != PROPERTY_LIST_SERVICE_E_SUCCESS) {
+		debug_info("ERROR: Could not send request to device!");
+		err = FILE_RELAY_E_MUX_ERROR;
+		goto leave;
+	}
+	plist_free(dict);
+
+	dict = NULL;
+	if (property_list_service_receive_plist_with_timeout(client->parent, &dict, timeout) != PROPERTY_LIST_SERVICE_E_SUCCESS) {
+		debug_info("ERROR: Could not receive answer from device!");
+		err = FILE_RELAY_E_MUX_ERROR;
+		goto leave;
+	}
+
+	if (!dict) {
+		debug_info("ERROR: Did not receive any plist!");
+		err = FILE_RELAY_E_PLIST_ERROR;
+		goto leave;
+	}
+
+	plist_t error = plist_dict_get_item(dict, "Error");
+	if (error) {
+		char *errmsg = NULL;
+		plist_get_string_val(error, &errmsg);
+		if (errmsg) {
+			if (!strcmp(errmsg, "InvalidSource")) {
+				debug_info("ERROR: One or more given sources are invalid!");
+				err = FILE_RELAY_E_INVALID_SOURCE;
+			} else if (!strcmp(errmsg, "StagingEmpty")) {
+				debug_info("ERROR: StagingEmpty - No data available!");
+				err = FILE_RELAY_E_STAGING_EMPTY;
+			} else if (!strcmp(errmsg, "PermissionDenied")) {
+				debug_info("ERROR: Permission denied.");
+				err = FILE_RELAY_E_PERMISSION_DENIED;
+			} else {
+				debug_info("ERROR: Unknown error '%s'", errmsg);
+			}
+			free(errmsg);
+		} else {
+			debug_info("ERROR: Could not get error message!");
+		}
+		goto leave;
+	}
+
+	plist_t status = plist_dict_get_item(dict, "Status");
+	if (!status) {
+		debug_info("ERROR: Unexpected plist received!");
+		debug_plist(dict);
+		err = FILE_RELAY_E_PLIST_ERROR;
+		goto leave;
+	}
+
+	char *ack = NULL;
+	plist_get_string_val(status, &ack);
+	if (!ack) {
+		debug_info("ERROR: Could not get 'Acknowledged' string!");
+		goto leave;
+	}
+
+	if (strcmp(ack, "Acknowledged") != 0) {
+		debug_info("ERROR: Did not receive 'Acknowledged' but '%s'", ack);
+		goto leave;
+	}
+	free(ack);
+	err = FILE_RELAY_E_SUCCESS;
+
+	*connection = client->parent->parent->connection;
+
+leave:
+	if (dict) {
+		plist_free(dict);
+	}
+	return err;
+}
+
+file_relay_error_t file_relay_request_sources(file_relay_client_t client, const char **sources, idevice_connection_t *connection)
+{
+	return file_relay_request_sources_timeout(client, sources, connection, 60000);
+}

file_relay.h

@@ -0,0 +1,33 @@
+/*
+ * file_relay.h
+ * com.apple.mobile.file_relay service header file.
+ *
+ * Copyright (c) 2010 Nikias Bassen, All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef __FILE_RELAY_H
+#define __FILE_RELAY_H
+
+#include "idevice.h"
+#include "libimobiledevice/file_relay.h"
+#include "property_list_service.h"
+
+struct file_relay_client_private {
+	property_list_service_client_t parent;
+};
+
+#endif

file_relay.pxi

@@ -0,0 +1,68 @@
+cdef extern from "libimobiledevice/file_relay.h":
+    cdef struct file_relay_client_private:
+        pass
+    ctypedef file_relay_client_private *file_relay_client_t
+    ctypedef char** const_sources_t "const char**"
+
+    ctypedef enum file_relay_error_t:
+        FILE_RELAY_E_SUCCESS = 0
+        FILE_RELAY_E_INVALID_ARG = -1
+        FILE_RELAY_E_PLIST_ERROR = -2
+        FILE_RELAY_E_MUX_ERROR = -3
+        FILE_RELAY_E_INVALID_SOURCE = -4
+        FILE_RELAY_E_STAGING_EMPTY = -5
+        FILE_RELAY_E_PERMISSION_DENIED = -6
+        FILE_RELAY_E_UNKNOWN_ERROR = -256
+
+    file_relay_error_t file_relay_client_new(idevice_t device, lockdownd_service_descriptor_t descriptor, file_relay_client_t *client)
+    file_relay_error_t file_relay_client_free(file_relay_client_t client)
+
+    file_relay_error_t file_relay_request_sources(file_relay_client_t client, const_sources_t sources, idevice_connection_t *connection)
+
+cdef class FileRelayError(BaseError):
+    def __init__(self, *args, **kwargs):
+        self._lookup_table = {
+            FILE_RELAY_E_SUCCESS: "Success",
+            FILE_RELAY_E_INVALID_ARG: "Invalid argument",
+            FILE_RELAY_E_PLIST_ERROR: "Property list error",
+            FILE_RELAY_E_MUX_ERROR: "MUX error",
+            FILE_RELAY_E_INVALID_SOURCE: "Invalid source",
+            FILE_RELAY_E_STAGING_EMPTY: "Staging empty",
+            FILE_RELAY_E_PERMISSION_DENIED: "Permission denied",
+            FILE_RELAY_E_UNKNOWN_ERROR: "Unknown error"
+        }
+        BaseError.__init__(self, *args, **kwargs)
+
+from libc.stdlib cimport *
+
+cdef class FileRelayClient(PropertyListService):
+    __service_name__ = "com.apple.mobile.file_relay"
+    cdef file_relay_client_t _c_client
+
+    def __cinit__(self, iDevice device not None, LockdownServiceDescriptor descriptor, *args, **kwargs):
+        self.handle_error(file_relay_client_new(device._c_dev, descriptor._c_service_descriptor, &self._c_client))
+
+    def __dealloc__(self):
+        cdef file_relay_error_t err
+        if self._c_client is not NULL:
+            err = file_relay_client_free(self._c_client)
+            self.handle_error(err)
+
+    cpdef iDeviceConnection request_sources(self, list sources):
+        cdef:
+            file_relay_error_t err
+            Py_ssize_t count = len(sources)
+            char** c_sources = <char**>malloc(sizeof(char*) * (count + 1))
+            iDeviceConnection conn = iDeviceConnection.__new__(iDeviceConnection)
+
+        for i, value in enumerate(sources):
+            c_sources[i] = value
+        c_sources[count] = NULL
+
+        err = file_relay_request_sources(self._c_client, <const_sources_t>c_sources, &conn._c_connection)
+        free(c_sources)
+        self.handle_error(err)
+        return conn
+
+    cdef inline BaseError _error(self, int16_t ret):
+        return FileRelayError(ret)

fls.c

@@ -0,0 +1,338 @@
+/*
+ * fls.c
+ * support for .fls file format (found in .bbfw files)
+ *
+ * Copyright (c) 2012 Nikias Bassen. All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "fls.h"
+#include "common.h"
+
+#ifndef offsetof
+#define offsetof(type, member)  __builtin_offsetof (type, member)
+#endif
+
+static void fls_parse_elements(fls_file* fls)
+{
+	/* FIXME: the following code is not big endian safe */
+	if (!fls || !fls->data) {
+		return;
+	}
+	uint32_t offset = 0;
+	fls->max_elements = 32;
+	fls->elements = (fls_element**)malloc(sizeof(fls_element*) * fls->max_elements);
+
+	fls_element* cur = NULL;
+	do {
+		void* p = fls->data + offset;
+		uint32_t hdrsize = 0;
+		cur = (fls_element*)p;
+		if ((offset + cur->size) > fls->size) {
+			break;
+		}
+		fls_element* ne;
+		switch (cur->type) {
+		case 0x0c:
+			{
+			hdrsize = offsetof(fls_0c_element, data);
+			fls_0c_element* xe = (fls_0c_element*)malloc(sizeof(fls_0c_element));
+			memset(xe, '\0', sizeof(fls_0c_element));
+			memcpy((void*)xe, p, hdrsize);
+			xe->data = (xe->size > hdrsize) ? p + hdrsize : NULL;
+			ne = (fls_element*)xe;
+			fls->c_element = xe;
+			}
+			break;
+		case 0x10:
+			{
+			hdrsize = offsetof(fls_10_element, data);
+			fls_10_element* xe = (fls_10_element*)malloc(sizeof(fls_10_element));
+			memset(xe, '\0', sizeof(fls_10_element));
+			memcpy((void*)xe, p, hdrsize);
+			xe->data = (xe->size > hdrsize) ? p + hdrsize : NULL;
+			ne = (fls_element*)xe;
+			}
+			break;
+		case 0x14:
+			{
+			hdrsize = offsetof(fls_14_element, data);
+			fls_14_element* xe = (fls_14_element*)malloc(sizeof(fls_14_element));
+			memset(xe, '\0', sizeof(fls_14_element));
+			memcpy((void*)xe, p, hdrsize);
+			xe->data = (xe->size > hdrsize) ? p + hdrsize : NULL;
+			ne = (fls_element*)xe;
+			}
+			break;
+		default:
+			hdrsize = offsetof(fls_element, data);
+			ne = (fls_element*)malloc(sizeof(fls_element));
+			memset(ne, '\0', sizeof(fls_element));
+			ne->type = cur->type;
+			ne->size = cur->size;
+			ne->data = (ne->size > hdrsize) ? p + hdrsize : NULL;
+			break;
+		}
+		if ((fls->num_elements + 1) > fls->max_elements) {
+			fls->max_elements += 10;
+			fls->elements = (fls_element**)realloc(fls->elements, sizeof(fls_element*) * fls->max_elements);
+		}
+		fls->elements[fls->num_elements++] = ne;
+		offset += cur->size;
+	} while (offset < fls->size);
+	if (offset != fls->size) {
+		error("ERROR: %s: error parsing elements\n", __func__);
+		return;
+	}
+}
+
+fls_file* fls_parse(unsigned char* data, unsigned int size)
+{
+	fls_file* fls = (fls_file*)malloc(sizeof(fls_file));
+	if (!fls) {
+		return NULL;
+	}
+	memset(fls, '\0', sizeof(fls_file));
+	fls->data = malloc(size);
+	fls->size = size;
+	memcpy(fls->data, data, size);
+	fls_parse_elements(fls);
+	return fls;
+}
+
+void fls_free(fls_file* fls)
+{
+	if (fls) {
+		if (fls->num_elements > 0) {
+			int i;
+			for (i = fls->num_elements-1; i >=0; i--) {
+				free(fls->elements[i]);
+			}
+			free(fls->elements);
+		}
+		if (fls->data) {
+			free(fls->data);
+		}
+		free(fls);
+	}
+}
+
+int fls_update_sig_blob(fls_file* fls, const unsigned char* sigdata, unsigned int siglen)
+{
+	/* FIXME: the code in this function is not big endian safe */
+	if (!fls || !fls->num_elements) {
+		error("ERROR: %s: no data\n", __func__);
+		return -1;
+	}
+	if (!fls->c_element) {
+		error("ERROR: %s: no fls_0c_element in fls data\n", __func__);
+		return -1;
+	}
+
+	uint32_t datasize = *(uint32_t*)(fls->c_element->data + 0x10);
+	if (datasize != fls->c_element->data_size) {
+		error("ERROR: %s: data size mismatch (0x%x != 0x%x)\n", __func__, datasize, fls->c_element->data_size);
+		return -1;
+	}
+	uint32_t sigoffset = *(uint32_t*)(fls->c_element->data + 0x14);
+	if (sigoffset > datasize) {
+		error("ERROR: %s: signature offset greater than data size (0x%x > 0x%x)\n", __func__, sigoffset, datasize);
+		return -1;
+	}
+
+	uint32_t oldsiglen = datasize - sigoffset;
+	uint32_t newsize = fls->size - oldsiglen + siglen;
+
+	unsigned int i;
+	uint32_t offset = 0;
+	void* newdata = malloc(newsize);
+	if (!newdata) {
+		error("ERROR: %s: out of memory\n", __func__);
+		return -1;
+	}
+	uint32_t hdrsize = 0;
+	uint32_t firstpartlen = 0;
+	for (i = 0; i < fls->num_elements; i++) {
+		switch (fls->elements[i]->type) {
+		case 0x0c:
+			hdrsize = offsetof(fls_0c_element, data);
+			// update offset
+			((fls_0c_element*)fls->elements[i])->offset = offset+hdrsize;
+			// copy first part of data
+			firstpartlen = fls->elements[i]->size - hdrsize - oldsiglen;
+			memcpy(newdata+offset+hdrsize, ((fls_0c_element*)fls->elements[i])->data, firstpartlen);
+			// copy new signature data
+			memcpy(newdata+offset+hdrsize+firstpartlen, sigdata, siglen);
+			((fls_0c_element*)fls->elements[i])->data = newdata+offset+hdrsize;
+			fls->elements[i]->size -= oldsiglen;
+			fls->elements[i]->size += siglen;
+			((fls_0c_element*)fls->elements[i])->data_size -= oldsiglen;
+			((fls_0c_element*)fls->elements[i])->data_size += siglen;
+			memcpy(newdata+offset+hdrsize+0x10, &(((fls_0c_element*)fls->elements[i])->data_size), 4);
+			// copy header
+			memcpy(newdata+offset, fls->elements[i], hdrsize);
+			break;
+		case 0x10:
+			hdrsize = offsetof(fls_10_element, data);
+			// update offset
+			((fls_10_element*)fls->elements[i])->offset = offset+hdrsize;
+			// copy header
+			memcpy(newdata+offset, fls->elements[i], hdrsize);
+			// copy data
+			if (fls->elements[i]->size > hdrsize) {
+				memcpy(newdata+offset+hdrsize, ((fls_10_element*)fls->elements[i])->data, fls->elements[i]->size - hdrsize);
+				((fls_10_element*)fls->elements[i])->data = newdata+offset+hdrsize;
+			} else {
+				((fls_10_element*)fls->elements[i])->data = NULL;
+			}
+			break;
+		case 0x14:
+			hdrsize = offsetof(fls_14_element, data);
+			// update offset
+			((fls_14_element*)fls->elements[i])->offset = offset+hdrsize;
+			// copy header
+			memcpy(newdata+offset, fls->elements[i], hdrsize);
+			// copy data
+			if (fls->elements[i]->size > hdrsize) {
+				memcpy(newdata+offset+hdrsize, ((fls_14_element*)fls->elements[i])->data, fls->elements[i]->size - hdrsize);
+				((fls_14_element*)fls->elements[i])->data = newdata+offset+hdrsize;
+			} else {
+				((fls_14_element*)fls->elements[i])->data = NULL;
+			}
+			break;
+		default:
+			hdrsize = offsetof(fls_element, data);
+			// copy header
+			memcpy(newdata+offset, fls->elements[i], hdrsize);
+			// copy data
+			if (fls->elements[i]->size > hdrsize) {
+				memcpy(newdata+offset+hdrsize, fls->elements[i]->data, fls->elements[i]->size - hdrsize);
+				fls->elements[i]->data = newdata+offset+hdrsize;
+			} else {
+				fls->elements[i]->data = NULL;
+			}
+			break;
+		}
+		offset += fls->elements[i]->size;
+	}
+	if (fls->data) {
+		free(fls->data);
+	}
+	fls->data = newdata;
+	fls->size = newsize;
+
+	return 0;
+}
+
+int fls_insert_ticket(fls_file* fls, const unsigned char* data, unsigned int size)
+{
+	/* FIXME: the code in this function is not big endian safe */
+	if (!fls || !fls->num_elements) {
+		error("ERROR: %s: no data\n", __func__);
+		return -1;
+	}
+	if (!fls->c_element) {
+		error("ERROR: %s: no fls_0c_element in fls data\n", __func__);
+		return -1;
+	}
+
+	uint32_t padding = 0;
+	if (size%4 != 0) {
+		padding = 4-(size%4);
+	}
+	uint32_t newsize = fls->size + size + padding;
+	unsigned int i;
+	uint32_t offset = 0;
+	void* newdata = malloc(newsize);
+	if (!newdata) {
+		error("ERROR: %s: out of memory\n", __func__);
+		return -1;
+	}
+	uint32_t hdrsize = 0;
+	for (i = 0; i < fls->num_elements; i++) {
+		switch (fls->elements[i]->type) {
+		case 0x0c:
+			hdrsize = offsetof(fls_0c_element, data);
+			// update offset
+			((fls_0c_element*)fls->elements[i])->offset = offset+hdrsize;
+			// copy ticket data
+			memcpy(newdata+offset+hdrsize, data, size);
+			if (padding > 0) {
+				// padding
+				memset(newdata+offset+hdrsize+size, '\xFF', padding);
+			}
+			// copy remaining data
+			memcpy(newdata+offset+hdrsize+size+padding, ((fls_0c_element*)fls->elements[i])->data, fls->elements[i]->size);
+			((fls_0c_element*)fls->elements[i])->data = newdata+offset+hdrsize;
+			fls->elements[i]->size += (size + padding);
+			((fls_0c_element*)fls->elements[i])->data_size += (size + padding);
+			// copy header
+			memcpy(newdata+offset, fls->elements[i], hdrsize);
+			break;
+		case 0x10:
+			hdrsize = offsetof(fls_10_element, data);
+			// update offset
+			((fls_10_element*)fls->elements[i])->offset = offset+hdrsize;
+			// copy header
+			memcpy(newdata+offset, fls->elements[i], hdrsize);
+			// copy data
+			if (fls->elements[i]->size > hdrsize) {
+				memcpy(newdata+offset+hdrsize, ((fls_10_element*)fls->elements[i])->data, fls->elements[i]->size - hdrsize);
+				((fls_10_element*)fls->elements[i])->data = newdata+offset+hdrsize;
+			} else {
+				((fls_10_element*)fls->elements[i])->data = NULL;
+			}
+			break;
+		case 0x14:
+			hdrsize = offsetof(fls_14_element, data);
+			// update offset
+			((fls_14_element*)fls->elements[i])->offset = offset+hdrsize;
+			// copy header
+			memcpy(newdata+offset, fls->elements[i], hdrsize);
+			// copy data
+			if (fls->elements[i]->size > hdrsize) {
+				memcpy(newdata+offset+hdrsize, ((fls_14_element*)fls->elements[i])->data, fls->elements[i]->size - hdrsize);
+				((fls_14_element*)fls->elements[i])->data = newdata+offset+hdrsize;
+			} else {
+				((fls_14_element*)fls->elements[i])->data = NULL;
+			}
+			break;
+		default:
+			hdrsize = offsetof(fls_element, data);
+			// copy header
+			memcpy(newdata+offset, fls->elements[i], hdrsize);
+			// copy data
+			if (fls->elements[i]->size > hdrsize) {
+				memcpy(newdata+offset+hdrsize, fls->elements[i]->data, fls->elements[i]->size - hdrsize);
+				fls->elements[i]->data = newdata+offset+hdrsize;
+			} else {
+				fls->elements[i]->data = NULL;
+			}
+			break;
+		}
+		offset += fls->elements[i]->size;
+	}
+	if (fls->data) {
+		free(fls->data);
+	}
+	fls->data = newdata;
+	fls->size = newsize;
+
+	return 0;
+}
+

fls.h

@@ -0,0 +1,85 @@
+/*
+ * fls.h
+ * support for .fls file format (found in .bbfw files)
+ *
+ * Copyright (c) 2012 Nikias Bassen. All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef FLS_H
+#define FLS_H
+
+#include <stdint.h>
+
+struct _fls_element {
+	uint32_t type;
+	uint32_t size;
+	uint32_t empty;
+	const unsigned char* data;
+} __attribute__((packed));
+typedef struct _fls_element fls_element;
+
+struct _fls_0c_element {
+	uint32_t type;
+	uint32_t size;
+	uint32_t empty;
+	uint32_t off_0x0c;
+	uint32_t off_0x10;
+	uint32_t off_0x14;
+	uint32_t off_0x18;
+	uint32_t data_size; // size without header
+	uint32_t off_0x20;
+	uint32_t offset; // absolute offset of data in file
+	const unsigned char* data; // data+0x14 contains offset to sig blob
+} __attribute__((packed));
+typedef struct _fls_0c_element fls_0c_element;
+
+struct _fls_10_element {
+	uint32_t type;
+	uint32_t size;
+	uint32_t empty;
+	uint32_t data_size; // size without header
+	uint32_t off_0x10;
+	uint32_t offset;
+	const unsigned char* data;
+} __attribute__((packed));
+typedef struct _fls_10_element fls_10_element;
+
+struct _fls_14_element {
+	uint32_t type;
+	uint32_t size;
+	uint32_t empty;
+	uint32_t data_size; // size without header
+	uint32_t off_0x10;
+	uint32_t offset;
+	const unsigned char* data;
+} __attribute__((packed));
+typedef struct _fls_14_element fls_14_element;
+
+typedef struct {
+	unsigned int num_elements;
+	unsigned int max_elements;
+	fls_element** elements;
+	const fls_0c_element* c_element;
+	void* data;
+	uint32_t size;
+} fls_file;
+
+fls_file* fls_parse(unsigned char* data, unsigned int size);
+void fls_free(fls_file* fls);
+int fls_update_sig_blob(fls_file* fls, const unsigned char* data, unsigned int size);
+int fls_insert_ticket(fls_file* fls, const unsigned char* data, unsigned int size);
+
+#endif

ftab.c

@@ -0,0 +1,197 @@
+/*
+ * ftab.c
+ * Functions for handling the ftab format
+ *
+ * Copyright (c) 2019 Nikias Bassen. All Rights Reserved.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#include "ftab.h"
+#include "common.h"
+#include "endianness.h"
+
+int ftab_parse(unsigned char *data, unsigned int data_size, ftab_t *ftab, uint32_t *tag)
+{
+	if (!data || !data_size || !ftab) {
+		return -1;
+	}
+
+	if (data_size < sizeof(struct ftab_header)) {
+		error("ERROR: %s: Buffer too small for ftab data\n", __func__);
+		return -1;
+	}
+
+	struct ftab_header *hdr_ptr = (struct ftab_header*)data;
+	if (be32toh(hdr_ptr->magic) != 'ftab') {
+		error("ERROR: %s: Unexpected magic value 0x%08x\n", __func__, le32toh(hdr_ptr->magic));
+		return -1;
+	}
+
+	/* copy header */
+	ftab_t ftab_new = (ftab_t)calloc(1, sizeof(struct ftab_fmt));
+	memcpy(&ftab_new->header, data, sizeof(struct ftab_header));
+
+	ftab_new->header.always_01 = le32toh(ftab_new->header.always_01);
+	ftab_new->header.always_ff = le32toh(ftab_new->header.always_ff);
+	ftab_new->header.tag = be32toh(ftab_new->header.tag);
+	if (tag) {
+		*tag = ftab_new->header.tag;
+	}
+	ftab_new->header.magic = be32toh(ftab_new->header.magic);
+	ftab_new->header.num_entries = le32toh(ftab_new->header.num_entries);
+
+	/* copy entries */
+	ftab_new->entries = (struct ftab_entry*)malloc(sizeof(struct ftab_entry) * ftab_new->header.num_entries);
+	memcpy(ftab_new->entries, data + sizeof(struct ftab_header), sizeof(struct ftab_entry) * ftab_new->header.num_entries);
+
+	/* create data storage */
+	ftab_new->storage = (unsigned char**)calloc(ftab_new->header.num_entries, sizeof(unsigned char*));
+
+	/* fill data storage */
+	uint32_t i = 0;
+	for (i = 0; i < ftab_new->header.num_entries; i++) {
+		ftab_new->entries[i].tag = be32toh(ftab_new->entries[i].tag);
+		ftab_new->entries[i].offset = le32toh(ftab_new->entries[i].offset);
+		ftab_new->entries[i].size = le32toh(ftab_new->entries[i].size);
+
+		ftab_new->storage[i] = malloc(ftab_new->entries[i].size);
+		memcpy(ftab_new->storage[i], data + ftab_new->entries[i].offset, ftab_new->entries[i].size);
+	}
+
+	*ftab = ftab_new;
+
+	return 0;
+}
+
+int ftab_get_entry_ptr(ftab_t ftab, uint32_t tag, unsigned char **data, unsigned int *data_size)
+{
+	if (!ftab || !tag || !data || !data_size) {
+		return -1;
+	}
+
+	uint32_t i;
+	int res = -1;
+	for (i = 0; i < ftab->header.num_entries; i++) {
+		if (ftab->entries[i].tag == tag) {
+			*data = ftab->storage[i];
+			*data_size = ftab->entries[i].size;
+			res = 0;
+		}
+	}
+	return res;
+}
+
+int ftab_add_entry(ftab_t ftab, uint32_t tag, unsigned char *data, unsigned int data_size)
+{
+	if (!ftab || !tag || !data || !data_size) {
+		return -1;
+	}
+
+	uint32_t new_index = ftab->header.num_entries;
+	struct ftab_entry *new_entries = realloc(ftab->entries, sizeof(struct ftab_entry) * (ftab->header.num_entries + 1));
+	if (!new_entries) {
+		error("ERROR: %s: realloc failed!\n", __func__);
+		return -1;
+	}
+	ftab->entries = new_entries;
+	unsigned char **new_storage = realloc(ftab->storage, sizeof(unsigned char*) * (ftab->header.num_entries + 1));
+	if (!new_storage) {
+		error("ERROR: %s: realloc failed!\n", __func__);
+		return -1;
+	}
+	ftab->storage = new_storage;
+
+	unsigned char *data_copy = (unsigned char*)malloc(data_size);
+	if (!data_copy) {
+		return -1;
+	}
+	memcpy(data_copy, data, data_size);
+
+	ftab->storage[new_index] = data_copy;
+	ftab->entries[new_index].tag = tag;
+	ftab->entries[new_index].size = data_size;
+	ftab->header.num_entries++;
+
+	uint32_t off = sizeof(struct ftab_header) + sizeof(struct ftab_entry) * ftab->header.num_entries;
+	uint32_t i;
+	for (i = 0; i < ftab->header.num_entries; i++) {
+		ftab->entries[i].offset = off;
+		off += ftab->entries[i].size;
+	}
+
+	return 0;
+}
+
+int ftab_write(ftab_t ftab, unsigned char **data, unsigned int *data_size)
+{
+	uint32_t i;
+	unsigned int total_size = sizeof(struct ftab_header);
+	total_size += ftab->header.num_entries * sizeof(struct ftab_entry);
+	for (i = 0; i < ftab->header.num_entries; i++) {
+		total_size += ftab->entries[i].size;
+	}
+
+	unsigned char *data_out = (unsigned char*)malloc(total_size);
+	if (!data_out) {
+		error("ERROR: %s: Out of memory?!\n", __func__);
+		return -1;
+	}
+
+	struct ftab_header *ftab_header = (struct ftab_header*)data_out;
+	memset(ftab_header, '\0', sizeof(struct ftab_header));
+	ftab_header->always_01 = htole32(ftab->header.always_01);
+	ftab_header->always_ff = htole32(ftab->header.always_ff);
+	ftab_header->tag = htobe32(ftab->header.tag);
+	ftab_header->magic = htobe32(ftab->header.magic);
+	ftab_header->num_entries = htole32(ftab->header.num_entries);
+
+	for (i = 0; i < ftab->header.num_entries; i++) {
+		struct ftab_entry* entry = (struct ftab_entry*)(data_out + sizeof(struct ftab_header) + (sizeof(struct ftab_entry) * i));
+		entry->tag = htobe32(ftab->entries[i].tag);
+		entry->offset = htole32(ftab->entries[i].offset);
+		entry->size = htole32(ftab->entries[i].size);
+		entry->pad_0x0C = 0;
+	}
+
+	unsigned char *p = data_out + sizeof(struct ftab_header) + (sizeof(struct ftab_entry) * ftab->header.num_entries);
+	for (i = 0; i < ftab->header.num_entries; i++) {
+		memcpy(p, ftab->storage[i], ftab->entries[i].size);
+		p += ftab->entries[i].size;
+	}
+
+	*data = data_out;
+	*data_size = total_size;
+
+	return 0;
+}
+
+int ftab_free(ftab_t ftab)
+{
+	if (!ftab) return -1;
+	uint32_t i = 0;
+	for (i = 0; i < ftab->header.num_entries; i++) {
+		free(ftab->storage[i]);
+	}
+	free(ftab->storage);
+	free(ftab->entries);
+	free(ftab);
+	return 0;
+}