Initial check-in of sources

20 files changed, 3688 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..08da54b
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,36 @@
+# git-ls-files --others --exclude-from=.git/info/exclude
+# Lines that start with '#' are comments.
+# For a project mostly in C, the following would be a good set of
+# exclude patterns (uncomment them if you want to use them):
+*.[oa]
+*~
+*.po
+*.lo
+*.la
+autom4te.cache/*
+*.in
+*/.deps/*
+m4/*
+swig/*
+*.swp
+*.patch
+aclocal.m4
+config.h
+config.log
+config.sub
+config.guess
+config.status
+configure
+depcomp
+install-sh
+compile
+main
+ltmain.sh
+missing
+mkinstalldirs
+libtool
+*Makefile
+py-compile
+stamp-h1
+src/.libs
+src/libimobiledevice-glue-1.0.pc
diff --git a/COPYING b/COPYING
new file mode 100644
index 0000000..732811e
--- /dev/null
+++ b/COPYING
@@ -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!
diff --git a/Makefile.am b/Makefile.am
new file mode 100644
index 0000000..149678b
--- /dev/null
+++ b/Makefile.am
@@ -0,0 +1,10 @@
+AUTOMAKE_OPTIONS = foreign
+ACLOCAL_AMFLAGS = -I m4
+SUBDIRS = src include
+
+EXTRA_DIST = \
+	README.md
+
+indent:
+	indent -kr -ut -ts4 -l120 src/*.c src/*.h
+
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..caddead
--- /dev/null
+++ b/README.md
@@ -0,0 +1,101 @@
+# libimobiledevice-glue
+
+Library with common code used by the libraries and tools around the
+**libimobiledevice** project.
+
+## Features
+
+The main functionality provided by this library are **socket** helper
+functions and a platform independent **thread/mutex** implementation.
+Besides that it comes with a number of string, file, and plist helper
+functions, as well as some other commonly used code that was originally
+duplicated in the dedicated projects.
+
+## Projects using this library
+
+- [libusbmuxd](https://github.com/libimobiledevice/libusbmuxd)
+- [libimobiledevice](https://github.com/libimobiledevice/libimobiledevice)
+- [usbmuxd](https://github.com/libimobiledevice/usbmuxd)
+- [idevicerestore](https://github.com/libimobiledevice/idevicerestore)
+
+## Installation / Getting started
+
+### Debian / Ubuntu Linux
+
+First install all required dependencies and build tools:
+```shell
+sudo apt-get install \
+	build-essential \
+	checkinstall \
+	git \
+	autoconf \
+	automake \
+	libtool-bin \
+	libplist-dev \
+```
+
+Then clone the actual project repository:
+```shell
+git clone https://github.com/libimobiledevice/libimobiledevice-glue.git
+cd libimobiledevice-glue
+```
+
+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
+make
+sudo make install
+```
+
+## Usage
+
+This library is directly used by libusbmuxd, libimobiledevice, etc., so there
+is no need to do anything in particular.
+
+## 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 to short
+* Try to split larger changes into individual commits of a common domain
+
+## Links
+
+* Homepage: https://libimobiledevice.org/
+* Repository: https://git.libimobiledevice.org/libimobiledevice-glue.git
+* Repository (Mirror): https://github.com/libimobiledevice/libimobiledevice-glue.git
+* Issue Tracker: https://github.com/libimobiledevice/libimobiledevice-glue/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: 2021-06-07
diff --git a/autogen.sh b/autogen.sh
new file mode 100755
index 0000000..5a0ec43
--- /dev/null
+++ b/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
diff --git a/configure.ac b/configure.ac
new file mode 100644
index 0000000..880c1d1
--- /dev/null
+++ b/configure.ac
@@ -0,0 +1,99 @@
+#                                               -*- Autoconf -*-
+# Process this file with autoconf to produce a configure script.
+
+AC_PREREQ(2.64)
+AC_INIT([libimobiledevice-glue], [1.0.0], [https://github.com/libimobiledevice/libimobiledevice-glue/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_GLUE_SO_VERSION=0:0:0
+
+dnl Minimum package versions
+LIBPLIST_VERSION=2.2.0
+
+AC_SUBST(LIBIMOBILEDEVICE_GLUE_SO_VERSION)
+AC_SUBST(LIBPLIST_VERSION)
+
+# Checks for programs.
+AC_PROG_CC
+#AC_PROG_CXX
+AM_PROG_CC_C_O
+AC_PROG_LIBTOOL
+
+# Checks for libraries.
+PKG_CHECK_MODULES(libplist, libplist-2.0 >= $LIBPLIST_VERSION)
+
+# Checks for header files.
+AC_HEADER_STDC
+AC_CHECK_HEADERS([stdint.h stdlib.h string.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])
+
+# 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])
+    ;;
+  darwin*)
+    AC_MSG_RESULT([${host_os}])
+    ;;
+  *)
+    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)
+
+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>])
+
+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")
+AC_SUBST(GLOBAL_CFLAGS)
+
+case "$GLOBAL_CFLAGS" in
+  *-fvisibility=hidden*)
+    AC_DEFINE([HAVE_FVISIBILITY], [1], [Define if compiled with -fvisibility=hidden])
+esac
+
+# check for large file support
+AC_SYS_LARGEFILE
+
+m4_ifdef([AM_SILENT_RULES],[AM_SILENT_RULES([yes])])
+
+AC_OUTPUT([
+Makefile
+src/Makefile
+src/libimobiledevice-glue-1.0.pc
+include/Makefile
+])
+
+echo "
+Configuration for $PACKAGE $VERSION:
+-------------------------------------------
+
+  Install prefix: .........: $prefix
+
+  Now type 'make' to build $PACKAGE $VERSION,
+  and then 'make install' for installation.
+"
diff --git a/include/Makefile.am b/include/Makefile.am
new file mode 100644
index 0000000..5d54892
--- /dev/null
+++ b/include/Makefile.am
@@ -0,0 +1,5 @@
+nobase_include_HEADERS = \
+	libimobiledevice-glue/socket.h \
+	libimobiledevice-glue/thread.h \
+	libimobiledevice-glue/utils.h \
+	libimobiledevice-glue/collection.h
diff --git a/include/libimobiledevice-glue/collection.h b/include/libimobiledevice-glue/collection.h
new file mode 100644
index 0000000..df1680c
--- /dev/null
+++ b/include/libimobiledevice-glue/collection.h
@@ -0,0 +1,52 @@
+/*
+ * collection.h
+ *
+ * Copyright (C) 2009 Hector Martin <hector@marcansoft.com>
+ * Copyright (C) 2009 Nikias Bassen <nikias@gmx.li>
+ *
+ * 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 COLLECTION_H
+#define COLLECTION_H
+
+struct collection {
+	void **list;
+	int capacity;
+};
+
+void collection_init(struct collection *col);
+void collection_add(struct collection *col, void *element);
+int collection_remove(struct collection *col, void *element);
+int collection_count(struct collection *col);
+void collection_free(struct collection *col);
+void collection_copy(struct collection *dest, struct collection *src);
+
+#define MERGE_(a,b) a ## _ ## b
+#define LABEL_(a,b) MERGE_(a, b)
+#define UNIQUE_VAR(a) LABEL_(a, __LINE__)
+
+#define FOREACH(var, col) \
+	do { \
+		int UNIQUE_VAR(_iter); \
+		for(UNIQUE_VAR(_iter)=0; UNIQUE_VAR(_iter)<(col)->capacity; UNIQUE_VAR(_iter)++) { \
+			if(!(col)->list[UNIQUE_VAR(_iter)]) continue; \
+			var = (col)->list[UNIQUE_VAR(_iter)];
+
+#define ENDFOREACH \
+		} \
+	} while(0);
+
+#endif
diff --git a/include/libimobiledevice-glue/socket.h b/include/libimobiledevice-glue/socket.h
new file mode 100644
index 0000000..9567270
--- /dev/null
+++ b/include/libimobiledevice-glue/socket.h
@@ -0,0 +1,68 @@
+/*
+ * socket.h
+ *
+ * Copyright (C) 2012-2020 Nikias Bassen <nikias@gmx.li>
+ * Copyright (C) 2012 Martin Szulecki <m.szulecki@libimobiledevice.org>
+ *
+ * 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 SOCKET_SOCKET_H
+#define SOCKET_SOCKET_H
+
+#include <stdlib.h>
+#include <stdint.h>
+
+enum fd_mode {
+	FDM_READ,
+	FDM_WRITE,
+	FDM_EXCEPT
+};
+typedef enum fd_mode fd_mode;
+
+#ifdef WIN32
+#include <winsock2.h>
+#define SHUT_RD SD_READ
+#define SHUT_WR SD_WRITE
+#define SHUT_RDWR SD_BOTH
+#else
+#include <sys/socket.h>
+#endif
+
+#ifndef WIN32
+int socket_create_unix(const char *filename);
+int socket_connect_unix(const char *filename);
+#endif
+int socket_create(const char *addr, uint16_t port);
+int socket_connect_addr(struct sockaddr *addr, uint16_t port);
+int socket_connect(const char *addr, uint16_t port);
+int socket_check_fd(int fd, fd_mode fdm, unsigned int timeout);
+int socket_accept(int fd, uint16_t port);
+
+int socket_shutdown(int fd, int how);
+int socket_close(int fd);
+
+int socket_receive(int fd, void *data, size_t length);
+int socket_peek(int fd, void *data, size_t length);
+int socket_receive_timeout(int fd, void *data, size_t length, int flags,
+					 unsigned int timeout);
+
+int socket_send(int fd, void *data, size_t length);
+
+void socket_set_verbose(int level);
+
+const char *socket_addr_to_string(struct sockaddr *addr, char *addr_out, size_t addr_out_size);
+
+#endif	/* SOCKET_SOCKET_H */
diff --git a/include/libimobiledevice-glue/thread.h b/include/libimobiledevice-glue/thread.h
new file mode 100644
index 0000000..2aadc6e
--- /dev/null
+++ b/include/libimobiledevice-glue/thread.h
@@ -0,0 +1,87 @@
+/*
+ * thread.h
+ *
+ * Copyright (c) 2012-2019 Nikias Bassen, All Rights Reserved.
+ * 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 __THREAD_H
+#define __THREAD_H
+
+#include <stddef.h>
+
+#ifdef WIN32
+#include <windows.h>
+typedef HANDLE THREAD_T;
+typedef CRITICAL_SECTION mutex_t;
+typedef struct {
+	HANDLE sem;
+} cond_t;
+typedef volatile struct {
+	LONG lock;
+	int state;
+} thread_once_t;
+#define THREAD_ONCE_INIT {0, 0}
+#define THREAD_ID GetCurrentThreadId()
+#define THREAD_T_NULL (THREAD_T)NULL
+#else
+#include <pthread.h>
+#include <signal.h>
+#include <sys/time.h>
+typedef pthread_t THREAD_T;
+typedef pthread_mutex_t mutex_t;
+typedef pthread_cond_t cond_t;
+typedef pthread_once_t thread_once_t;
+#define THREAD_ONCE_INIT PTHREAD_ONCE_INIT
+#define THREAD_ID pthread_self()
+#define THREAD_T_NULL (THREAD_T)NULL
+#endif
+
+typedef void* (*thread_func_t)(void* data);
+
+int thread_new(THREAD_T* thread, thread_func_t thread_func, void* data);
+void thread_detach(THREAD_T thread);
+void thread_free(THREAD_T thread);
+int thread_join(THREAD_T thread);
+int thread_alive(THREAD_T thread);
+
+int thread_cancel(THREAD_T thread);
+
+#ifdef WIN32
+#undef HAVE_THREAD_CLEANUP
+#else
+#ifdef HAVE_PTHREAD_CANCEL
+#define HAVE_THREAD_CLEANUP 1
+#define thread_cleanup_push(routine, arg) pthread_cleanup_push(routine, arg)
+#define thread_cleanup_pop(execute) pthread_cleanup_pop(execute)
+#endif
+#endif
+
+void mutex_init(mutex_t* mutex);
+void mutex_destroy(mutex_t* mutex);
+void mutex_lock(mutex_t* mutex);
+void mutex_unlock(mutex_t* mutex);
+
+void thread_once(thread_once_t *once_control, void (*init_routine)(void));
+
+void cond_init(cond_t* cond);
+void cond_destroy(cond_t* cond);
+int cond_signal(cond_t* cond);
+int cond_wait(cond_t* cond, mutex_t* mutex);
+int cond_wait_timeout(cond_t* cond, mutex_t* mutex, unsigned int timeout_ms);
+
+#endif
diff --git a/include/libimobiledevice-glue/utils.h b/include/libimobiledevice-glue/utils.h
new file mode 100644
index 0000000..515339a
--- /dev/null
+++ b/include/libimobiledevice-glue/utils.h
@@ -0,0 +1,59 @@
+/*
+ * utils.h
+ * Miscellaneous utilities for string manipulation,
+ * file I/O and plist helper.
+ *
+ * Copyright (c) 2014-2019 Nikias Bassen, All Rights Reserved.
+ * Copyright (c) 2013-2014 Martin Szulecki, All Rights Reserved.
+ * Copyright (c) 2013 Federico Mena Quintero
+ *
+ * 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 __UTILS_H
+#define __UTILS_H
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef WIN32
+#include <windows.h>
+#endif
+
+#include <stdio.h>
+#include <plist/plist.h>
+
+char *string_concat(const char *str, ...);
+char *string_append(char *str, ...);
+char *string_build_path(const char *elem, ...);
+char *string_format_size(uint64_t size);
+char *string_toupper(char *str);
+char *generate_uuid(void);
+
+int buffer_read_from_filename(const char *filename, char **buffer, uint64_t *length);
+int buffer_write_to_filename(const char *filename, const char *buffer, uint64_t length);
+
+enum plist_format_t {
+	PLIST_FORMAT_XML,
+	PLIST_FORMAT_BINARY
+};
+
+int plist_read_from_filename(plist_t *plist, const char *filename);
+int plist_write_to_filename(plist_t plist, const char *filename, enum plist_format_t format);
+
+void plist_print_to_stream(plist_t plist, FILE* stream);
+
+#endif
diff --git a/m4/as-compiler-flag.m4 b/m4/as-compiler-flag.m4
new file mode 100644
index 0000000..0f660cf
--- /dev/null
+++ b/m4/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_TRY_COMPILE([ ], [], [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_TRY_COMPILE([ ], [], [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"
+])
+
diff --git a/m4/ax_pthread.m4 b/m4/ax_pthread.m4
new file mode 100644
index 0000000..5fbf9fe
--- /dev/null
+++ b/m4/ax_pthread.m4
@@ -0,0 +1,485 @@
+# ===========================================================================
+#        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 to any special C compiler that is needed for
+#   multi-threaded programs (defaults to the value of CC otherwise). (This
+#   is necessary on AIX to use the special 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
+#
+#   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"
+#     CC="$PTHREAD_CC"
+#
+#   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>
+#
+#   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 24
+
+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"])
+        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 starting with a "-" are
+# C compiler flags, and other 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,pthread pthread $ax_pthread_flags"
+        ;;
+esac
+
+# GCC generally uses -pthread, or -pthreads on some platforms (e.g. SPARC)
+
+AS_IF([test "x$GCC" = "xyes"],
+      [ax_pthread_flags="-pthread -pthreads $ax_pthread_flags"])
+
+# 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)"])
+
+# 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"
+
+ax_pthread_clang_warning=no
+
+# 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.)
+
+        PTHREAD_CFLAGS="-pthread"
+        PTHREAD_LIBS=
+
+        ax_pthread_ok=yes
+
+        # 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
+
+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])
+                ;;
+
+                -mt,pthread)
+                AC_MSG_CHECKING([whether pthreads work with -mt -lpthread])
+                PTHREAD_CFLAGS="-mt"
+                PTHREAD_LIBS="-lpthread"
+                ;;
+
+                -*)
+                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 routine(void *a) { a = 0; }
+                        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
+
+# 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;]])],
+                            [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"])],
+                         [AC_CHECK_PROGS([PTHREAD_CC],[${CC}_r],[$CC])])])
+                ;;
+            esac
+        fi
+fi
+
+test -n "$PTHREAD_CC" || PTHREAD_CC="$CC"
+
+AC_SUBST([PTHREAD_LIBS])
+AC_SUBST([PTHREAD_CFLAGS])
+AC_SUBST([PTHREAD_CC])
+
+# 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
diff --git a/src/Makefile.am b/src/Makefile.am
new file mode 100644
index 0000000..2856eab
--- /dev/null
+++ b/src/Makefile.am
@@ -0,0 +1,23 @@
+AM_CPPFLAGS = -I$(top_srcdir)/include -I$(top_srcdir)
+
+AM_CFLAGS = $(GLOBAL_CFLAGS) $(PTHREAD_CFLAGS) $(libplist_CFLAGS)
+
+AM_LDFLAGS = $(PTHREAD_LIBS) $(libplist_LIBS)
+
+lib_LTLIBRARIES = libimobiledevice-glue-1.0.la
+libimobiledevice_glue_1_0_la_LDFLAGS = $(AM_LDFLAGS) -version-info $(LIBIMOBILEDEVICE_GLUE_SO_VERSION) -no-undefined
+libimobiledevice_glue_1_0_la_LIBADD =
+libimobiledevice_glue_1_0_la_SOURCES =	\
+	socket.c				\
+	thread.c				\
+	utils.c					\
+	collection.c				\
+	common.h
+
+if WIN32
+libimobiledevice_glue_1_0_la_LDFLAGS += -avoid-version -static-libgcc
+libimobiledevice_glue_1_0_la_LIBADD += -lws2_32 -lIphlpapi
+endif
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = libimobiledevice-glue-1.0.pc
diff --git a/src/collection.c b/src/collection.c
new file mode 100644
index 0000000..ef47217
--- /dev/null
+++ b/src/collection.c
@@ -0,0 +1,101 @@
+/*
+ * collection.c
+ *
+ * Copyright (C) 2009 Hector Martin <hector@marcansoft.com>
+ * Copyright (C) 2009 Nikias Bassen <nikias@gmx.li>
+ *
+ * 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 <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "common.h"
+#include "libimobiledevice-glue/collection.h"
+
+#undef NDEBUG // we need to make sure we still get assertions because we can't handle memory allocation errors
+#include <assert.h>
+
+#define INIT_NULL(addr, count) { unsigned int i_ = 0; for (i_ = 0; i_ < (count); i_++) ((void**)(addr))[i_] = NULL; }
+
+#define CAPACITY_STEP 8
+
+LIBIMOBILEDEVICE_GLUE_API void collection_init(struct collection *col)
+{
+	col->list = malloc(sizeof(void *) * CAPACITY_STEP);
+	assert(col->list);
+	INIT_NULL(col->list, CAPACITY_STEP);
+	col->capacity = CAPACITY_STEP;
+}
+
+LIBIMOBILEDEVICE_GLUE_API void collection_free(struct collection *col)
+{
+	free(col->list);
+	col->list = NULL;
+	col->capacity = 0;
+}
+
+LIBIMOBILEDEVICE_GLUE_API void collection_add(struct collection *col, void *element)
+{
+	int i;
+	for(i=0; i<col->capacity; i++) {
+		if(!col->list[i]) {
+			col->list[i] = element;
+			return;
+		}
+	}
+	void **newlist = realloc(col->list, sizeof(void*) * (col->capacity + CAPACITY_STEP));
+	assert(newlist);
+	col->list = newlist;
+	INIT_NULL(&col->list[col->capacity], CAPACITY_STEP);
+	col->list[col->capacity] = element;
+	col->capacity += CAPACITY_STEP;
+}
+
+LIBIMOBILEDEVICE_GLUE_API int collection_remove(struct collection *col, void *element)
+{
+	int i;
+	for(i=0; i<col->capacity; i++) {
+		if(col->list[i] == element) {
+			col->list[i] = NULL;
+			return 0;
+		}
+	}
+	fprintf(stderr, "%s: WARNING: element %p not present in collection %p (cap %d)", __func__, element, col, col->capacity);
+	return -1;
+}
+
+LIBIMOBILEDEVICE_GLUE_API int collection_count(struct collection *col)
+{
+	int i, cnt = 0;
+	for(i=0; i<col->capacity; i++) {
+		if(col->list[i])
+			cnt++;
+	}
+	return cnt;
+}
+
+LIBIMOBILEDEVICE_GLUE_API void collection_copy(struct collection *dest, struct collection *src)
+{
+	if (!dest || !src) return;
+	dest->capacity = src->capacity;
+	dest->list = malloc(sizeof(void*) * src->capacity);
+	memcpy(dest->list, src->list, sizeof(void*) * src->capacity);
+}
diff --git a/src/common.h b/src/common.h
new file mode 100644
index 0000000..bd22e3d
--- /dev/null
+++ b/src/common.h
@@ -0,0 +1,38 @@
+/*
+ * common.h
+ *
+ * Copyright (c) 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 __COMMON_H
+#define __COMMON_H
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef WIN32
+#define LIBIMOBILEDEVICE_GLUE_API __declspec( dllexport )
+#else
+#ifdef HAVE_FVISIBILITY
+#define LIBIMOBILEDEVICE_GLUE_API __attribute__((visibility("default")))
+#else
+#define LIBIMOBILEDEVICE_GLUE_API
+#endif
+#endif
+
+#endif
diff --git a/src/libimobiledevice-glue-1.0.pc.in b/src/libimobiledevice-glue-1.0.pc.in
new file mode 100644
index 0000000..814a33c
--- /dev/null
+++ b/src/libimobiledevice-glue-1.0.pc.in
@@ -0,0 +1,11 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: @PACKAGE_NAME@
+Description: Common library for libimobiledevice and co.
+Version: @PACKAGE_VERSION@
+Libs: -L${libdir} -limobiledevice-glue-1.0
+Cflags: -I${includedir}
+Requires: libplist-2.0 >= @LIBPLIST_VERSION@
diff --git a/src/socket.c b/src/socket.c
new file mode 100644
index 0000000..067ef41
--- /dev/null
+++ b/src/socket.c
@@ -0,0 +1,1169 @@
+/*
+ * socket.c
+ *
+ * Copyright (C) 2012-2020 Nikias Bassen <nikias@gmx.li>
+ * Copyright (C) 2012 Martin Szulecki <m.szulecki@libimobiledevice.org>
+ *
+ * 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 <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+#ifdef WIN32
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <windows.h>
+#ifndef HAVE_GETIFADDRS
+#include <iphlpapi.h>
+#endif
+static int wsa_init = 0;
+#ifndef IFF_RUNNING
+#define IFF_RUNNING IFF_UP
+#endif
+#ifndef AI_NUMERICSERV
+#define AI_NUMERICSERV 0
+#endif
+#else
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <netdb.h>
+#include <arpa/inet.h>
+#include <fcntl.h>
+#ifdef AF_INET6
+#include <net/if.h>
+#include <ifaddrs.h>
+#endif
+#endif
+#include "common.h"
+#include "libimobiledevice-glue/socket.h"
+
+#define RECV_TIMEOUT 20000
+#define SEND_TIMEOUT 10000
+#define CONNECT_TIMEOUT 5000
+
+#ifndef EAFNOSUPPORT
+#define EAFNOSUPPORT 102
+#endif
+#ifndef ECONNRESET
+#define ECONNRESET 108
+#endif
+#ifndef ETIMEDOUT
+#define ETIMEDOUT 138
+#endif
+
+static int verbose = 0;
+
+LIBIMOBILEDEVICE_GLUE_API void socket_set_verbose(int level)
+{
+	verbose = level;
+}
+
+LIBIMOBILEDEVICE_GLUE_API const char *socket_addr_to_string(struct sockaddr *addr, char *addr_out, size_t addr_out_size)
+{
+#ifdef WIN32
+	WSADATA wsa_data;
+	if (!wsa_init) {
+		if (WSAStartup(MAKEWORD(2,2), &wsa_data) != ERROR_SUCCESS) {
+			fprintf(stderr, "WSAStartup failed!\n");
+			ExitProcess(-1);
+		}
+		wsa_init = 1;
+	}
+	DWORD addr_out_len = addr_out_size;
+	DWORD addrlen = 0;
+
+	if (addr->sa_family == AF_INET) {
+		addrlen = sizeof(struct sockaddr_in);
+	}
+#ifdef AF_INET6
+	else if (addr->sa_family == AF_INET6) {
+		addrlen = sizeof(struct sockaddr_in6);
+	}
+#endif
+	else {
+		errno = EAFNOSUPPORT;
+		return NULL;
+	}
+
+	if (WSAAddressToString(addr, addrlen, NULL, addr_out, &addr_out_len) == 0) {
+		return addr_out;
+	}
+#else
+	const void *addrdata = NULL;
+
+	if (addr->sa_family == AF_INET) {
+		addrdata = &((struct sockaddr_in*)addr)->sin_addr;
+	}
+#ifdef AF_INET6
+	else if (addr->sa_family == AF_INET6) {
+		addrdata = &((struct sockaddr_in6*)addr)->sin6_addr;
+	}
+#endif
+	else {
+		errno = EAFNOSUPPORT;
+		return NULL;
+	}
+
+	if (inet_ntop(addr->sa_family, addrdata, addr_out, addr_out_size)) {
+		return addr_out;
+	}
+#endif
+	return NULL;
+}
+
+#ifndef WIN32
+LIBIMOBILEDEVICE_GLUE_API int socket_create_unix(const char *filename)
+{
+	struct sockaddr_un name;
+	int sock;
+#ifdef SO_NOSIGPIPE
+	int yes = 1;
+#endif
+
+	// remove if still present
+	unlink(filename);
+
+	/* Create the socket. */
+	sock = socket(PF_UNIX, SOCK_STREAM, 0);
+	if (sock < 0) {
+		perror("socket");
+		return -1;
+	}
+
+#ifdef SO_NOSIGPIPE
+	if (setsockopt(sock, SOL_SOCKET, SO_NOSIGPIPE, (void*)&yes, sizeof(int)) == -1) {
+		perror("setsockopt()");
+		socket_close(sock);
+		return -1;
+	}
+#endif
+
+	/* Bind a name to the socket. */
+	name.sun_family = AF_UNIX;
+	strncpy(name.sun_path, filename, sizeof(name.sun_path));
+	name.sun_path[sizeof(name.sun_path) - 1] = '\0';
+
+	if (bind(sock, (struct sockaddr*)&name, sizeof(name)) < 0) {
+		perror("bind");
+		socket_close(sock);
+		return -1;
+	}
+
+	if (listen(sock, 100) < 0) {
+		perror("listen");
+		socket_close(sock);
+		return -1;
+	}
+
+	return sock;
+}
+
+LIBIMOBILEDEVICE_GLUE_API int socket_connect_unix(const char *filename)
+{
+	struct sockaddr_un name;
+	int sfd = -1;
+	struct stat fst;
+#ifdef SO_NOSIGPIPE
+	int yes = 1;
+#endif
+	int bufsize = 0x20000;
+
+	// check if socket file exists...
+	if (stat(filename, &fst) != 0) {
+		if (verbose >= 2)
+			fprintf(stderr, "%s: stat '%s': %s\n", __func__, filename,
+					strerror(errno));
+		return -1;
+	}
+	// ... and if it is a unix domain socket
+	if (!S_ISSOCK(fst.st_mode)) {
+		if (verbose >= 2)
+			fprintf(stderr, "%s: File '%s' is not a socket!\n", __func__,
+					filename);
+		return -1;
+	}
+	// make a new socket
+	if ((sfd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
+		if (verbose >= 2)
+			fprintf(stderr, "%s: socket: %s\n", __func__, strerror(errno));
+		return -1;
+	}
+
+	if (setsockopt(sfd, SOL_SOCKET, SO_SNDBUF, (void*)&bufsize, sizeof(int)) == -1) {
+		perror("Could not set send buffer for socket");
+	}
+
+	if (setsockopt(sfd, SOL_SOCKET, SO_RCVBUF, (void*)&bufsize, sizeof(int)) == -1) {
+		perror("Could not set receive buffer for socket");
+	}
+
+#ifdef SO_NOSIGPIPE
+	if (setsockopt(sfd, SOL_SOCKET, SO_NOSIGPIPE, (void*)&yes, sizeof(int)) == -1) {
+		perror("setsockopt()");
+		socket_close(sfd);
+		return -1;
+	}
+#endif
+	// and connect to 'filename'
+	name.sun_family = AF_UNIX;
+	strncpy(name.sun_path, filename, sizeof(name.sun_path));
+	name.sun_path[sizeof(name.sun_path) - 1] = 0;
+
+	int flags = fcntl(sfd, F_GETFL, 0);
+	fcntl(sfd, F_SETFL, flags | O_NONBLOCK);
+
+	do {
+		if (connect(sfd, (struct sockaddr*)&name, sizeof(name)) != -1) {
+			break;
+		}
+		if (errno == EINPROGRESS) {
+			fd_set fds;
+			FD_ZERO(&fds);
+			FD_SET(sfd, &fds);
+
+			struct timeval timeout;
+			timeout.tv_sec = CONNECT_TIMEOUT / 1000;
+			timeout.tv_usec = (CONNECT_TIMEOUT - (timeout.tv_sec * 1000)) * 1000;
+			if (select(sfd + 1, NULL, &fds, NULL, &timeout) == 1) {
+				int so_error;
+				socklen_t len = sizeof(so_error);
+				getsockopt(sfd, SOL_SOCKET, SO_ERROR, (void*)&so_error, &len);
+				if (so_error == 0) {
+					break;
+				}
+			}
+		}
+		socket_close(sfd);
+		sfd = -1;
+	} while (0);
+
+	if (sfd < 0) {
+		if (verbose >= 2)
+			fprintf(stderr, "%s: connect: %s\n", __func__, strerror(errno));
+		return -1;
+	}
+
+	return sfd;
+}
+#endif
+
+LIBIMOBILEDEVICE_GLUE_API int socket_create(const char* addr, uint16_t port)
+{
+	int sfd = -1;
+	int yes = 1;
+	struct addrinfo hints;
+	struct addrinfo *result, *rp;
+	char portstr[8];
+	int res;
+#ifdef WIN32
+	WSADATA wsa_data;
+	if (!wsa_init) {
+		if (WSAStartup(MAKEWORD(2,2), &wsa_data) != ERROR_SUCCESS) {
+			fprintf(stderr, "WSAStartup failed!\n");
+			ExitProcess(-1);
+		}
+		wsa_init = 1;
+	}
+#endif
+
+	memset(&hints, '\0', sizeof(struct addrinfo));
+	hints.ai_family = AF_UNSPEC;
+	hints.ai_socktype = SOCK_STREAM;
+	hints.ai_flags = AI_PASSIVE | AI_NUMERICSERV;
+	hints.ai_protocol = IPPROTO_TCP;
+
+	sprintf(portstr, "%d", port);
+
+	if (!addr) {
+		addr = "localhost";
+	}
+	res = getaddrinfo(addr, portstr, &hints, &result);
+	if (res != 0) {
+		fprintf(stderr, "%s: getaddrinfo: %s\n", __func__, gai_strerror(res));
+		return -1;
+	}
+
+	for (rp = result; rp != NULL; rp = rp->ai_next) {
+		sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
+		if (sfd == -1) {
+			continue;
+		}
+
+		if (setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, (void*)&yes, sizeof(int)) == -1) {
+			perror("setsockopt()");
+			socket_close(sfd);
+			continue;
+		}
+
+#ifdef SO_NOSIGPIPE
+		if (setsockopt(sfd, SOL_SOCKET, SO_NOSIGPIPE, (void*)&yes, sizeof(int)) == -1) {
+			perror("setsockopt()");
+			socket_close(sfd);
+			continue;
+		}
+#endif
+
+#if defined(AF_INET6) && defined(IPV6_V6ONLY)
+		if (rp->ai_family == AF_INET6) {
+			if (setsockopt(sfd, IPPROTO_IPV6, IPV6_V6ONLY, (void*)&yes, sizeof(int)) == -1) {
+				perror("setsockopt() IPV6_V6ONLY");
+			}
+		}
+#endif
+
+		if (bind(sfd, rp->ai_addr, rp->ai_addrlen) < 0) {
+			perror("bind()");
+			socket_close(sfd);
+			continue;
+		}
+
+		if (listen(sfd, 100) < 0) {
+			perror("listen()");
+			socket_close(sfd);
+			continue;
+		}
+		break;
+	}
+
+	freeaddrinfo(result);
+
+	if (rp == NULL) {
+		return -1;
+	}
+
+	return sfd;
+}
+
+#ifdef AF_INET6
+static uint32_t _in6_addr_scope(struct in6_addr* addr)
+{
+	uint32_t scope = 0;
+
+	if (IN6_IS_ADDR_MULTICAST(addr)) {
+		if (IN6_IS_ADDR_MC_NODELOCAL(addr)) {
+			scope = 1;
+		} else if (IN6_IS_ADDR_MC_LINKLOCAL(addr)) {
+			scope = 2;
+		} else if (IN6_IS_ADDR_MC_SITELOCAL(addr)) {
+			scope = 5;
+		}
+
+		return scope;
+	}
+
+	if (IN6_IS_ADDR_LINKLOCAL(addr)) {
+		scope = 2;
+	} else if (IN6_IS_ADDR_LOOPBACK(addr)) {
+		scope = 2;
+	} else if (IN6_IS_ADDR_SITELOCAL(addr)) {
+		scope = 5;
+	} else if (IN6_IS_ADDR_UNSPECIFIED(addr)) {
+		scope = 0;
+	}
+
+	return scope;
+}
+
+#ifndef HAVE_GETIFADDRS
+#ifdef WIN32
+
+struct ifaddrs {
+	struct ifaddrs  *ifa_next;    /* Next item in list */
+	char            *ifa_name;    /* Name of interface */
+	unsigned int     ifa_flags;   /* Flags from SIOCGIFFLAGS */
+	struct sockaddr *ifa_addr;    /* Address of interface */
+	struct sockaddr *ifa_netmask; /* Netmask of interface */
+	union {
+		struct sockaddr *ifu_broadaddr; /* Broadcast address of interface */
+		struct sockaddr *ifu_dstaddr;   /* Point-to-point destination address */
+	} ifa_ifu;
+#define                  ifa_broadaddr ifa_ifu.ifu_broadaddr
+#define                  ifa_dstaddr   ifa_ifu.ifu_dstaddr
+	void            *ifa_data;    /* Address-specific data */
+};
+
+#define WORKING_BUFFER_SIZE 15000
+#define MAX_TRIES 3
+
+static void freeifaddrs(struct ifaddrs *ifa)
+{
+	if (!ifa) {
+		return;
+	}
+	free(ifa->ifa_name);
+	free(ifa->ifa_addr);
+	free(ifa->ifa_netmask);
+	free(ifa->ifa_dstaddr);
+	freeifaddrs(ifa->ifa_next);
+	free(ifa);
+}
+
+/*
+ * getifaddrs() reference implementation for win32.
+ * Heavily based on openpgm's implementation found here:
+ * https://github.com/steve-o/openpgm/blob/master/openpgm/pgm/getifaddrs.c
+ */
+static int getifaddrs(struct ifaddrs** ifap)
+{
+	struct ifaddrs* ifa = NULL;
+
+	DWORD dwRetVal = 0;
+
+	PIP_ADAPTER_ADDRESSES pAddresses = NULL;
+	ULONG outBufLen = 0;
+	ULONG Iterations = 0;
+
+	ULONG flags = GAA_FLAG_INCLUDE_PREFIX |
+		GAA_FLAG_SKIP_ANYCAST |
+		GAA_FLAG_SKIP_DNS_SERVER |
+		GAA_FLAG_SKIP_FRIENDLY_NAME |
+		GAA_FLAG_SKIP_MULTICAST;
+
+	PIP_ADAPTER_ADDRESSES adapter = NULL;
+
+	if (!ifap) {
+		errno = EINVAL;
+		return -1;
+	}
+	*ifap = NULL;
+
+	outBufLen = WORKING_BUFFER_SIZE;
+	do {
+		pAddresses = (IP_ADAPTER_ADDRESSES*)malloc(outBufLen);
+		if (pAddresses == NULL) {
+			printf("Memory allocation failed for IP_ADAPTER_ADDRESSES struct\n");
+			return -1;
+		}
+		dwRetVal = GetAdaptersAddresses(AF_UNSPEC, flags, NULL, pAddresses, &outBufLen);
+		if (dwRetVal == ERROR_BUFFER_OVERFLOW) {
+			free(pAddresses);
+			pAddresses = NULL;
+		} else {
+			break;
+		}
+		Iterations++;
+	} while ((dwRetVal == ERROR_BUFFER_OVERFLOW) && (Iterations < MAX_TRIES));
+
+	if (dwRetVal != NO_ERROR) {
+		free(pAddresses);
+		return -1;
+	}
+
+	for (adapter = pAddresses; adapter; adapter = adapter->Next) {
+		int unicastIndex = 0;
+		for (IP_ADAPTER_UNICAST_ADDRESS *unicast = adapter->FirstUnicastAddress; unicast; unicast = unicast->Next, ++unicastIndex) {
+			/* ensure IP adapter */
+			if (AF_INET != unicast->Address.lpSockaddr->sa_family && AF_INET6 != unicast->Address.lpSockaddr->sa_family) {
+				continue;
+			}
+
+			if (!ifa) {
+				ifa = malloc(sizeof(struct ifaddrs));
+				if (!ifa) {
+					errno = ENOMEM;
+					free(pAddresses);
+					return -1;
+				}
+				*ifap = ifa;
+				ifa->ifa_next = NULL;
+			} else {
+				struct ifaddrs* ifanew = malloc(sizeof(struct ifaddrs));
+				if (!ifanew) {
+					freeifaddrs(*ifap);
+					free(pAddresses);
+					errno = ENOMEM;
+					return -1;
+				}
+				ifa->ifa_next = ifanew;
+				ifa = ifanew;
+				ifa->ifa_next = NULL;
+			}
+
+			/* name */
+			ifa->ifa_name = strdup(adapter->AdapterName);
+
+			/* flags */
+			ifa->ifa_flags = 0;
+			if (IfOperStatusUp == adapter->OperStatus)
+				ifa->ifa_flags |= IFF_UP;
+			if (IF_TYPE_SOFTWARE_LOOPBACK == adapter->IfType)
+				ifa->ifa_flags |= IFF_LOOPBACK;
+			if (!(adapter->Flags & IP_ADAPTER_NO_MULTICAST))
+				ifa->ifa_flags |= IFF_MULTICAST;
+
+			/* address */
+			ifa->ifa_addr = (struct sockaddr*)malloc(sizeof(struct sockaddr_storage));
+			memcpy(ifa->ifa_addr, unicast->Address.lpSockaddr, unicast->Address.iSockaddrLength);
+
+			/* netmask */
+			ifa->ifa_netmask = (struct sockaddr*)malloc(sizeof(struct sockaddr_storage));
+			memset(ifa->ifa_netmask, 0, sizeof(struct sockaddr_storage));
+
+/* pre-Vista must hunt for matching prefix in linked list, otherwise use
+ * OnLinkPrefixLength from IP_ADAPTER_UNICAST_ADDRESS structure.
+ * FirstPrefix requires Windows XP SP1, from SP1 to pre-Vista provides a
+ * single adapter prefix for each IP address.  Vista and later provides
+ * host IP address prefix, subnet IP address, and subnet broadcast IP
+ * address.  In addition there is a multicast and broadcast address prefix.
+ */
+			ULONG prefixLength = 0;
+
+#if defined( _WIN32 ) && ( _WIN32_WINNT >= 0x0600 )
+/* For a unicast IPv4 address, any value greater than 32 is an illegal
+ * value. For a unicast IPv6 address, any value greater than 128 is an
+ * illegal value. A value of 255 is commonly used to represent an illegal
+ * value.
+ *
+ * Windows 7 SP1 returns 64 for Teredo links which is incorrect.
+ */
+
+#define IN6_IS_ADDR_TEREDO(addr) \
+	(((const uint32_t *)(addr))[0] == ntohl (0x20010000))
+
+			if (AF_INET6 == unicast->Address.lpSockaddr->sa_family &&
+/* TunnelType only applies to one interface on the adapter and no
+ * convenient method is provided to determine which.
+ */
+				TUNNEL_TYPE_TEREDO == adapter->TunnelType &&
+/* Test the interface with the known Teredo network prefix.
+ */
+				IN6_IS_ADDR_TEREDO( &((struct sockaddr_in6*)(unicast->Address.lpSockaddr))->sin6_addr) &&
+/* Test that this version is actually wrong, subsequent releases from Microsoft
+ * may resolve the issue.
+ */
+				32 != unicast->OnLinkPrefixLength)
+			{
+				prefixLength = 32;
+			}
+			else
+				prefixLength = unicast->OnLinkPrefixLength;
+#else
+/* The order of linked IP_ADAPTER_UNICAST_ADDRESS structures pointed to by
+ * the FirstUnicastAddress member does not have any relationship with the
+ * order of linked IP_ADAPTER_PREFIX structures pointed to by the FirstPrefix
+ * member.
+ *
+ * Example enumeration:
+ *    [ no subnet ]
+ *   ::1/128            - address
+ *   ff00::%1/8         - multicast (no IPv6 broadcast)
+ *   127.0.0.0/8        - subnet
+ *   127.0.0.1/32       - address
+ *   127.255.255.255/32 - subnet broadcast
+ *   224.0.0.0/4        - multicast
+ *   255.255.255.255/32 - broadcast
+ *
+ * Which differs from most adapters listing three IPv6:
+ *   fe80::%10/64       - subnet
+ *   fe80::51e9:5fe5:4202:325a%10/128 - address
+ *   ff00::%10/8        - multicast
+ *
+ * !IfOperStatusUp IPv4 addresses are skipped:
+ *   fe80::%13/64       - subnet
+ *   fe80::d530:946d:e8df:8c91%13/128 - address
+ *   ff00::%13/8        - multicast
+ *    [ no subnet  ]
+ *    [ no address ]
+ *   224.0.0.0/4        - multicast
+ *   255.255.255.255/32 - broadcast
+ *
+ * On PTP links no multicast or broadcast addresses are returned:
+ *    [ no subnet ]
+ *   fe80::5efe:10.203.9.30/128 - address
+ *    [ no multicast ]
+ *    [ no multicast ]
+ *    [ no broadcast ]
+ *
+ * Active primary IPv6 interfaces are a bit overloaded:
+ *   ::/0               - default route
+ *   2001::/32          - global subnet
+ *   2001:0:4137:9e76:2443:d6:ba87:1a2a/128 - global address
+ *   fe80::/64          - link-local subnet
+ *   fe80::2443:d6:ba87:1a2a/128 - link-local address
+ *   ff00::/8           - multicast
+ */
+
+#define IN_LINKLOCAL(a)	((((uint32_t) (a)) & 0xaffff0000) == 0xa9fe0000)
+
+			for (IP_ADAPTER_PREFIX *prefix = adapter->FirstPrefix; prefix; prefix = prefix->Next) {
+				LPSOCKADDR lpSockaddr = prefix->Address.lpSockaddr;
+				if (lpSockaddr->sa_family != unicast->Address.lpSockaddr->sa_family)
+					continue;
+/* special cases */
+/* RFC2863: IPv4 interface not up */
+				if (AF_INET == lpSockaddr->sa_family && adapter->OperStatus != IfOperStatusUp) {
+/* RFC3927: link-local IPv4 always has 16-bit CIDR */
+					if (IN_LINKLOCAL( ntohl (((struct sockaddr_in*)(unicast->Address.lpSockaddr))->sin_addr.s_addr))) {
+						prefixLength = 16;
+					}
+					break;
+				}
+/* default IPv6 route */
+				if (AF_INET6 == lpSockaddr->sa_family && 0 == prefix->PrefixLength && IN6_IS_ADDR_UNSPECIFIED( &((struct sockaddr_in6*)(lpSockaddr))->sin6_addr)) {
+					continue;
+				}
+/* Assume unicast address for first prefix of operational adapter */
+				if (AF_INET == lpSockaddr->sa_family)
+					if (IN_MULTICAST( ntohl (((struct sockaddr_in*)(lpSockaddr))->sin_addr.s_addr))) {
+						fprintf(stderr, "FATAL: first prefix is non a unicast address\n");
+						break;
+					}
+				if (AF_INET6 == lpSockaddr->sa_family)
+					if (IN6_IS_ADDR_MULTICAST( &((struct sockaddr_in6*)(lpSockaddr))->sin6_addr)) {
+						fprintf(stderr, "FATAL: first prefix is not a unicast address\n");
+						break;
+					}
+/* Assume subnet or host IP address for XP backward compatibility */
+
+				prefixLength = prefix->PrefixLength;
+				break;
+			}
+#endif /* defined( _WIN32 ) && ( _WIN32_WINNT >= 0x0600 ) */
+
+/* map prefix to netmask */
+			ifa->ifa_netmask->sa_family = unicast->Address.lpSockaddr->sa_family;
+			switch (unicast->Address.lpSockaddr->sa_family) {
+			case AF_INET:
+				if (0 == prefixLength || prefixLength > 32) {
+					prefixLength = 32;
+				}
+#if defined( _WIN32) && ( _WIN32_WINNT >= 0x0600 )
+/* Added in Vista, but no IPv6 equivalent. */
+				{
+				ULONG Mask;
+				ConvertLengthToIpv4Mask (prefixLength, &Mask);
+				((struct sockaddr_in*)ifa->ifa_netmask)->sin_addr.s_addr = Mask;	/* network order */
+				}
+#else
+/* NB: left-shift of full bit-width is undefined in C standard. */
+				((struct sockaddr_in*)ifa->ifa_netmask)->sin_addr.s_addr = htonl( 0xffffffffU << ( 32 - prefixLength ) );
+#endif
+				break;
+
+			case AF_INET6:
+				if (0 == prefixLength || prefixLength > 128) {
+					prefixLength = 128;
+				}
+				for (LONG i = prefixLength, j = 0; i > 0; i -= 8, ++j) {
+					((struct sockaddr_in6*)ifa->ifa_netmask)->sin6_addr.s6_addr[ j ] = i >= 8 ? 0xff : (ULONG)(( 0xffU << ( 8 - i ) ) & 0xffU );
+				}
+				break;
+			default:
+				break;
+			}
+		}
+	}
+	free(pAddresses);
+
+	return 0;
+}
+#else
+#error No reference implementation for getifaddrs available for this platform.
+#endif
+#endif
+
+static int32_t _sockaddr_in6_scope_id(struct sockaddr_in6* addr)
+{
+	int32_t res = -1;
+	struct ifaddrs *ifaddr = NULL, *ifa = NULL;
+	uint32_t addr_scope;
+
+	/* get scope for requested address */
+	addr_scope = _in6_addr_scope(&addr->sin6_addr);
+	if (addr_scope == 0) {
+		/* global scope doesn't need a specific scope id */
+		return addr_scope;
+	}
+
+	/* get interfaces */
+	if (getifaddrs(&ifaddr) == -1) {
+		perror("getifaddrs");
+		return res;
+	}
+
+	/* loop over interfaces */
+	for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
+		/* skip if no address is available */
+		if (ifa->ifa_addr == NULL) {
+			continue;
+		}
+
+		/* skip if wrong family */
+		if (ifa->ifa_addr->sa_family != AF_INET6) {
+			continue;
+		}
+
+		/* skip if not up */
+		if ((ifa->ifa_flags & IFF_UP) == 0) {
+			continue;
+		}
+
+		/* skip if not running */
+		if ((ifa->ifa_flags & IFF_RUNNING) == 0) {
+			continue;
+		}
+
+		struct sockaddr_in6* addr_in = (struct sockaddr_in6*)ifa->ifa_addr;
+
+		/* skip if scopes do not match */
+		if (_in6_addr_scope(&addr_in->sin6_addr) != addr_scope) {
+			continue;
+		}
+
+		/* use if address is equal */
+		if (memcmp(&addr->sin6_addr.s6_addr, &addr_in->sin6_addr.s6_addr, sizeof(addr_in->sin6_addr.s6_addr)) == 0) {
+			/* if scope id equals the requested one then assume it was valid */
+			if (addr->sin6_scope_id == addr_in->sin6_scope_id) {
+				res = addr_in->sin6_scope_id;
+				break;
+			}
+
+			if ((addr_in->sin6_scope_id > addr->sin6_scope_id) && (res >= 0)) {
+				// use last valid scope id as we're past the requested scope id
+				break;
+			}
+			res = addr_in->sin6_scope_id;
+			continue;
+		}
+
+		/* skip loopback interface if not already matched exactly above */
+		if ((ifa->ifa_flags & IFF_LOOPBACK) != 0) {
+			continue;
+		}
+
+		if ((addr_in->sin6_scope_id > addr->sin6_scope_id) && (res >= 0)) {
+			// use last valid scope id as we're past the requested scope id
+			break;
+		}
+
+		res = addr_in->sin6_scope_id;
+
+		/* if scope id equals the requested one then assume it was valid */
+		if (addr->sin6_scope_id == addr_in->sin6_scope_id) {
+			/* set the scope id of this interface as most likely candidate */
+			break;
+		}
+	}
+
+	freeifaddrs(ifaddr);
+
+	return res;
+}
+#endif
+
+LIBIMOBILEDEVICE_GLUE_API int socket_connect_addr(struct sockaddr* addr, uint16_t port)
+{
+	int sfd = -1;
+	int yes = 1;
+	int bufsize = 0x20000;
+	int addrlen = 0;
+#ifdef WIN32
+	u_long l_yes = 1;
+	WSADATA wsa_data;
+	if (!wsa_init) {
+		if (WSAStartup(MAKEWORD(2,2), &wsa_data) != ERROR_SUCCESS) {
+			fprintf(stderr, "WSAStartup failed!\n");
+			ExitProcess(-1);
+		}
+		wsa_init = 1;
+	}
+#endif
+
+	if (addr->sa_family == AF_INET) {
+		struct sockaddr_in* addr_in = (struct sockaddr_in*)addr;
+		addr_in->sin_port = htons(port);
+		addrlen = sizeof(struct sockaddr_in);
+	}
+#ifdef AF_INET6
+	else if (addr->sa_family == AF_INET6) {
+		struct sockaddr_in6* addr_in = (struct sockaddr_in6*)addr;
+		addr_in->sin6_port = htons(port);
+
+		/*
+		 * IPv6 Routing Magic:
+		 *
+		 * If the scope of the address is a link-local one, IPv6 requires the
+		 * scope id set to an interface number to allow proper routing. However,
+		 * as the provided sockaddr might contain a wrong scope id, we must find
+		 * a scope id from a suitable interface on this system or routing might
+		 * fail. An IPv6 guru should have another look though...
+		 */
+		addr_in->sin6_scope_id = _sockaddr_in6_scope_id(addr_in);
+
+		addrlen = sizeof(struct sockaddr_in6);
+	}
+#endif
+	else {
+		fprintf(stderr, "ERROR: Unsupported address family");
+		return -1;
+	}
+
+	sfd = socket(addr->sa_family, SOCK_STREAM, IPPROTO_TCP);
+	if (sfd == -1) {
+		perror("socket()");
+		return -1;
+	}
+
+#ifdef SO_NOSIGPIPE
+	if (setsockopt(sfd, SOL_SOCKET, SO_NOSIGPIPE, (void*)&yes, sizeof(int)) == -1) {
+		perror("setsockopt()");
+		socket_close(sfd);
+		return -1;
+	}
+#endif
+
+	if (setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, (void*)&yes, sizeof(int)) == -1) {
+		perror("setsockopt()");
+		socket_close(sfd);
+		return -1;
+	}
+
+#ifdef WIN32
+	ioctlsocket(sfd, FIONBIO, &l_yes);
+#else
+	int flags = fcntl(sfd, F_GETFL, 0);
+	fcntl(sfd, F_SETFL, flags | O_NONBLOCK);
+#endif
+
+	do {
+		if (connect(sfd, addr, addrlen) != -1) {
+			break;
+		}
+#ifdef WIN32
+		if (WSAGetLastError() == WSAEWOULDBLOCK)
+#else
+		if (errno == EINPROGRESS)
+#endif
+		{
+			fd_set fds;
+			FD_ZERO(&fds);
+			FD_SET(sfd, &fds);
+
+			struct timeval timeout;
+			timeout.tv_sec = CONNECT_TIMEOUT / 1000;
+			timeout.tv_usec = (CONNECT_TIMEOUT - (timeout.tv_sec * 1000)) * 1000;
+			if (select(sfd + 1, NULL, &fds, NULL, &timeout) == 1) {
+				int so_error;
+				socklen_t len = sizeof(so_error);
+				getsockopt(sfd, SOL_SOCKET, SO_ERROR, (void*)&so_error, &len);
+				if (so_error == 0) {
+					errno = 0;
+					break;
+				}
+				errno = so_error;
+			}
+		}
+		socket_close(sfd);
+		sfd = -1;
+	} while (0);
+
+	if (sfd < 0) {
+		if (verbose >= 2) {
+			char addrtxt[48];
+			socket_addr_to_string(addr, addrtxt, sizeof(addrtxt));
+			fprintf(stderr, "%s: Could not connect to %s port %d\n", __func__, addrtxt, port);
+		}
+		return -1;
+	}
+
+	if (setsockopt(sfd, IPPROTO_TCP, TCP_NODELAY, (void*)&yes, sizeof(int)) == -1) {
+		perror("Could not set TCP_NODELAY on socket");
+	}
+
+	if (setsockopt(sfd, SOL_SOCKET, SO_SNDBUF, (void*)&bufsize, sizeof(int)) == -1) {
+		perror("Could not set send buffer for socket");
+	}
+
+	if (setsockopt(sfd, SOL_SOCKET, SO_RCVBUF, (void*)&bufsize, sizeof(int)) == -1) {
+		perror("Could not set receive buffer for socket");
+	}
+
+	return sfd;
+}
+
+LIBIMOBILEDEVICE_GLUE_API int socket_connect(const char *addr, uint16_t port)
+{
+	int sfd = -1;
+	int yes = 1;
+	int bufsize = 0x20000;
+	struct addrinfo hints;
+	struct addrinfo *result, *rp;
+	char portstr[8];
+	int res;
+#ifdef WIN32
+	u_long l_yes = 1;
+	WSADATA wsa_data;
+	if (!wsa_init) {
+		if (WSAStartup(MAKEWORD(2,2), &wsa_data) != ERROR_SUCCESS) {
+			fprintf(stderr, "WSAStartup failed!\n");
+			ExitProcess(-1);
+		}
+		wsa_init = 1;
+	}
+#else
+	int flags = 0;
+#endif
+
+	if (!addr) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	memset(&hints, '\0', sizeof(struct addrinfo));
+	hints.ai_family = AF_UNSPEC;
+	hints.ai_socktype = SOCK_STREAM;
+	hints.ai_flags = AI_NUMERICSERV;
+	hints.ai_protocol = IPPROTO_TCP;
+
+	sprintf(portstr, "%d", port);
+
+	res = getaddrinfo(addr, portstr, &hints, &result);
+	if (res != 0) {
+		fprintf(stderr, "%s: getaddrinfo: %s\n", __func__, gai_strerror(res));
+		return -1;
+	}
+
+	for (rp = result; rp != NULL; rp = rp->ai_next) {
+		sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
+		if (sfd == -1) {
+			continue;
+		}
+
+#ifdef SO_NOSIGPIPE
+		if (setsockopt(sfd, SOL_SOCKET, SO_NOSIGPIPE, (void*)&yes, sizeof(int)) == -1) {
+			perror("setsockopt()");
+			socket_close(sfd);
+			return -1;
+		}
+#endif
+
+		if (setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, (void*)&yes, sizeof(int)) == -1) {
+			perror("setsockopt()");
+			socket_close(sfd);
+			continue;
+		}
+
+#ifdef WIN32
+		ioctlsocket(sfd, FIONBIO, &l_yes);
+#else
+		flags = fcntl(sfd, F_GETFL, 0);
+		fcntl(sfd, F_SETFL, flags | O_NONBLOCK);
+#endif
+
+		if (connect(sfd, rp->ai_addr, rp->ai_addrlen) != -1) {
+			break;
+		}
+#ifdef WIN32
+		if (WSAGetLastError() == WSAEWOULDBLOCK)
+#else
+		if (errno == EINPROGRESS)
+#endif
+		{
+			fd_set fds;
+			FD_ZERO(&fds);
+			FD_SET(sfd, &fds);
+
+			struct timeval timeout;
+			timeout.tv_sec = CONNECT_TIMEOUT / 1000;
+			timeout.tv_usec = (CONNECT_TIMEOUT - (timeout.tv_sec * 1000)) * 1000;
+			if (select(sfd + 1, NULL, &fds, NULL, &timeout) == 1) {
+				int so_error;
+				socklen_t len = sizeof(so_error);
+				getsockopt(sfd, SOL_SOCKET, SO_ERROR, (void*)&so_error, &len);
+				if (so_error == 0) {
+					break;
+				}
+			}
+		}
+		socket_close(sfd);
+	}
+
+	freeaddrinfo(result);
+
+	if (rp == NULL) {
+		if (verbose >= 2)
+			fprintf(stderr, "%s: Could not connect to %s:%d\n", __func__, addr, port);
+		return -1;
+	}
+
+	if (setsockopt(sfd, IPPROTO_TCP, TCP_NODELAY, (void*)&yes, sizeof(int)) == -1) {
+		perror("Could not set TCP_NODELAY on socket");
+	}
+
+	if (setsockopt(sfd, SOL_SOCKET, SO_SNDBUF, (void*)&bufsize, sizeof(int)) == -1) {
+		perror("Could not set send buffer for socket");
+	}
+
+	if (setsockopt(sfd, SOL_SOCKET, SO_RCVBUF, (void*)&bufsize, sizeof(int)) == -1) {
+		perror("Could not set receive buffer for socket");
+	}
+
+	return sfd;
+}
+
+LIBIMOBILEDEVICE_GLUE_API int socket_check_fd(int fd, fd_mode fdm, unsigned int timeout)
+{
+	fd_set fds;
+	int sret;
+	int eagain;
+	struct timeval to;
+	struct timeval *pto;
+
+	if (fd < 0) {
+		if (verbose >= 2)
+			fprintf(stderr, "ERROR: invalid fd in check_fd %d\n", fd);
+		return -1;
+	}
+
+	FD_ZERO(&fds);
+	FD_SET(fd, &fds);
+
+	sret = -1;
+
+	do {
+		if (timeout > 0) {
+			to.tv_sec = (time_t) (timeout / 1000);
+			to.tv_usec = (time_t) ((timeout - (to.tv_sec * 1000)) * 1000);
+			pto = &to;
+		} else {
+			pto = NULL;
+		}
+		eagain = 0;
+		switch (fdm) {
+		case FDM_READ:
+			sret = select(fd + 1, &fds, NULL, NULL, pto);
+			break;
+		case FDM_WRITE:
+			sret = select(fd + 1, NULL, &fds, NULL, pto);
+			break;
+		case FDM_EXCEPT:
+			sret = select(fd + 1, NULL, NULL, &fds, pto);
+			break;
+		default:
+			return -1;
+		}
+
+		if (sret < 0) {
+			switch (errno) {
+			case EINTR:
+				// interrupt signal in select
+				if (verbose >= 2)
+					fprintf(stderr, "%s: EINTR\n", __func__);
+				eagain = 1;
+				break;
+			case EAGAIN:
+				if (verbose >= 2)
+					fprintf(stderr, "%s: EAGAIN\n", __func__);
+				break;
+			default:
+				if (verbose >= 2)
+					fprintf(stderr, "%s: select failed: %s\n", __func__,
+							strerror(errno));
+				return -1;
+			}
+		} else if (sret == 0) {
+			return -ETIMEDOUT;
+		}
+	} while (eagain);
+
+	return sret;
+}
+
+LIBIMOBILEDEVICE_GLUE_API int socket_accept(int fd, uint16_t port)
+{
+#ifdef WIN32
+	int addr_len;
+#else
+	socklen_t addr_len;
+#endif
+	int result;
+	struct sockaddr_storage addr;
+	addr_len = sizeof(addr);
+
+	result = accept(fd, (struct sockaddr*)&addr, &addr_len);
+
+	return result;
+}
+
+LIBIMOBILEDEVICE_GLUE_API int socket_shutdown(int fd, int how)
+{
+	return shutdown(fd, how);
+}
+
+LIBIMOBILEDEVICE_GLUE_API int socket_close(int fd) {
+#ifdef WIN32
+	return closesocket(fd);
+#else
+	return close(fd);
+#endif
+}
+
+LIBIMOBILEDEVICE_GLUE_API int socket_receive(int fd, void *data, size_t length)
+{
+	return socket_receive_timeout(fd, data, length, 0, RECV_TIMEOUT);
+}
+
+LIBIMOBILEDEVICE_GLUE_API int socket_peek(int fd, void *data, size_t length)
+{
+	return socket_receive_timeout(fd, data, length, MSG_PEEK, RECV_TIMEOUT);
+}
+
+LIBIMOBILEDEVICE_GLUE_API int socket_receive_timeout(int fd, void *data, size_t length, int flags, unsigned int timeout)
+{
+	int res;
+	int result;
+
+	// check if data is available
+	res = socket_check_fd(fd, FDM_READ, timeout);
+	if (res <= 0) {
+		return res;
+	}
+	// if we get here, there _is_ data available
+	result = recv(fd, data, length, flags);
+	if (res > 0 && result == 0) {
+		// but this is an error condition
+		if (verbose >= 3)
+			fprintf(stderr, "%s: fd=%d recv returned 0\n", __func__, fd);
+		return -ECONNRESET;
+	}
+	if (result < 0) {
+		return -errno;
+	}
+	return result;
+}
+
+LIBIMOBILEDEVICE_GLUE_API int socket_send(int fd, void *data, size_t length)
+{
+	int flags = 0;
+	int res = socket_check_fd(fd, FDM_WRITE, SEND_TIMEOUT);
+	if (res <= 0) {
+		return res;
+	}
+#ifdef MSG_NOSIGNAL
+	flags |= MSG_NOSIGNAL;
+#endif
+	return send(fd, data, length, flags);
+}
diff --git a/src/thread.c b/src/thread.c
new file mode 100644
index 0000000..dbe93c8
--- /dev/null
+++ b/src/thread.c
@@ -0,0 +1,203 @@
+/*
+ * thread.c
+ *
+ * Copyright (c) 2012-2019 Nikias Bassen, All Rights Reserved.
+ * 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 "common.h"
+#include "libimobiledevice-glue/thread.h"
+
+LIBIMOBILEDEVICE_GLUE_API int thread_new(THREAD_T *thread, thread_func_t thread_func, void* data)
+{
+#ifdef WIN32
+	HANDLE th = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)thread_func, data, 0, NULL);
+	if (th == NULL) {
+		return -1;
+	}
+	*thread = th;
+	return 0;
+#else
+	int res = pthread_create(thread, NULL, thread_func, data);
+	return res;
+#endif
+}
+
+LIBIMOBILEDEVICE_GLUE_API void thread_detach(THREAD_T thread)
+{
+#ifdef WIN32
+	CloseHandle(thread);
+#else
+	pthread_detach(thread);
+#endif
+}
+
+LIBIMOBILEDEVICE_GLUE_API void thread_free(THREAD_T thread)
+{
+#ifdef WIN32
+	CloseHandle(thread);
+#endif
+}
+
+LIBIMOBILEDEVICE_GLUE_API int thread_join(THREAD_T thread)
+{
+	/* wait for thread to complete */
+#ifdef WIN32
+	return (int)WaitForSingleObject(thread, INFINITE);
+#else
+	return pthread_join(thread, NULL);
+#endif
+}
+
+LIBIMOBILEDEVICE_GLUE_API int thread_alive(THREAD_T thread)
+{
+	if (!thread)
+		return 0;
+#ifdef WIN32
+	return WaitForSingleObject(thread, 0) == WAIT_TIMEOUT;
+#else
+	return pthread_kill(thread, 0) == 0;
+#endif
+}
+
+LIBIMOBILEDEVICE_GLUE_API int thread_cancel(THREAD_T thread)
+{
+#ifdef WIN32
+	return -1;
+#else
+#ifdef HAVE_PTHREAD_CANCEL
+	return pthread_cancel(thread);
+#else
+	return -1;
+#endif
+#endif
+}
+
+LIBIMOBILEDEVICE_GLUE_API void mutex_init(mutex_t* mutex)
+{
+#ifdef WIN32
+	InitializeCriticalSection(mutex);
+#else
+	pthread_mutex_init(mutex, NULL);
+#endif
+}
+
+LIBIMOBILEDEVICE_GLUE_API void mutex_destroy(mutex_t* mutex)
+{
+#ifdef WIN32
+	DeleteCriticalSection(mutex);
+#else
+	pthread_mutex_destroy(mutex);
+#endif
+}
+
+LIBIMOBILEDEVICE_GLUE_API void mutex_lock(mutex_t* mutex)
+{
+#ifdef WIN32
+	EnterCriticalSection(mutex);
+#else
+	pthread_mutex_lock(mutex);
+#endif
+}
+
+LIBIMOBILEDEVICE_GLUE_API void mutex_unlock(mutex_t* mutex)
+{
+#ifdef WIN32
+	LeaveCriticalSection(mutex);
+#else
+	pthread_mutex_unlock(mutex);
+#endif
+}
+
+LIBIMOBILEDEVICE_GLUE_API void thread_once(thread_once_t *once_control, void (*init_routine)(void))
+{
+#ifdef WIN32
+	while (InterlockedExchange(&(once_control->lock), 1) != 0) {
+		Sleep(1);
+	}
+	if (!once_control->state) {
+		once_control->state = 1;
+		init_routine();
+	}
+	InterlockedExchange(&(once_control->lock), 0);
+#else
+	pthread_once(once_control, init_routine);
+#endif
+}
+
+void cond_init(cond_t* cond)
+{
+#ifdef WIN32
+	cond->sem = CreateSemaphore(NULL, 0, 32767, NULL);
+#else
+	pthread_cond_init(cond, NULL);
+#endif
+}
+
+void cond_destroy(cond_t* cond)
+{
+#ifdef WIN32
+	CloseHandle(cond->sem);
+#else
+	pthread_cond_destroy(cond);
+#endif
+}
+
+int cond_signal(cond_t* cond)
+{
+#ifdef WIN32
+	int result = 0;
+	if (!ReleaseSemaphore(cond->sem, 1, NULL)) {
+		result = -1;
+	}
+	return result;
+#else
+	return pthread_cond_signal(cond);
+#endif
+}
+
+int cond_wait(cond_t* cond, mutex_t* mutex)
+{
+#ifdef WIN32
+	mutex_unlock(mutex);
+	WaitForSingleObject(cond->sem, INFINITE);
+#else
+	return pthread_cond_wait(cond, mutex);
+#endif
+}
+
+int cond_wait_timeout(cond_t* cond, mutex_t* mutex, unsigned int timeout_ms)
+{
+#ifdef WIN32
+	mutex_unlock(mutex);
+	WaitForSingleObject(cond->sem, timeout_ms);
+#else
+	struct timespec ts;
+	struct timeval now;
+	gettimeofday(&now, NULL);
+
+	ts.tv_sec = now.tv_sec + timeout_ms / 1000;
+	ts.tv_nsec = now.tv_usec * 1000 + 1000 * 1000 * (timeout_ms % 1000);
+	ts.tv_sec += ts.tv_nsec / (1000 * 1000 * 1000);
+	ts.tv_nsec %= (1000 * 1000 * 1000);
+
+	return pthread_cond_timedwait(cond, mutex, &ts);
+#endif
+}
diff --git a/src/utils.c b/src/utils.c
new file mode 100644
index 0000000..2c70b80
--- /dev/null
+++ b/src/utils.c
@@ -0,0 +1,551 @@
+/*
+ * utils.c
+ * Miscellaneous utilities for string manipulation,
+ * file I/O and plist helper.
+ *
+ * Copyright (c) 2014-2019 Nikias Bassen, All Rights Reserved.
+ * Copyright (c) 2013-2014 Martin Szulecki, All Rights Reserved.
+ * Copyright (c) 2013 Federico Mena Quintero
+ *
+ * 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>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <sys/time.h>
+#include <inttypes.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include "common.h"
+#include "libimobiledevice-glue/utils.h"
+
+#ifndef HAVE_STPCPY
+/**
+ * Copy characters from one string into another
+ *
+ * @note: The strings should not overlap, as the behavior is undefined.
+ *
+ * @s1: The source string.
+ * @s2: The destination string.
+ *
+ * @return a pointer to the terminating `\0' character of @s1,
+ * or NULL if @s1 or @s2 is NULL.
+ */
+char *stpcpy(char *s1, const char *s2)
+{
+	if (s1 == NULL || s2 == NULL)
+		return NULL;
+
+	strcpy(s1, s2);
+
+	return s1 + strlen(s2);
+}
+#endif
+
+/**
+ * Concatenate strings into a newly allocated string
+ *
+ * @note: Specify NULL for the last string in the varargs list
+ *
+ * @str: The first string in the list
+ * @...: Subsequent strings.  Use NULL for the last item.
+ *
+ * @return a newly allocated string, or NULL if @str is NULL.  This will also
+ * return NULL and set errno to ENOMEM if memory is exhausted.
+ */
+LIBIMOBILEDEVICE_GLUE_API char *string_concat(const char *str, ...)
+{
+	size_t len;
+	va_list args;
+	char *s;
+	char *result;
+	char *dest;
+
+	if (!str)
+		return NULL;
+
+	/* Compute final length */
+
+	len = strlen(str) + 1; /* plus 1 for the null terminator */
+
+	va_start(args, str);
+	s = va_arg(args, char *);
+	while (s) {
+		len += strlen(s);
+		s = va_arg(args, char*);
+	}
+	va_end(args);
+
+	/* Concat each string */
+
+	result = malloc(len);
+	if (!result)
+		return NULL; /* errno remains set */
+
+	dest = result;
+
+	dest = stpcpy(dest, str);
+
+	va_start(args, str);
+	s = va_arg(args, char *);
+	while (s) {
+		dest = stpcpy(dest, s);
+		s = va_arg(args, char *);
+	}
+	va_end(args);
+
+	return result;
+}
+
+LIBIMOBILEDEVICE_GLUE_API char *string_append(char* str, ...)
+{
+	size_t len = 0;
+	size_t slen;
+	va_list args;
+	char *s;
+	char *result;
+	char *dest;
+
+	/* Compute final length */
+
+	if (str) {
+		len = strlen(str);
+	}
+	slen = len;
+	len++; /* plus 1 for the null terminator */
+
+	va_start(args, str);
+	s = va_arg(args, char *);
+	while (s) {
+		len += strlen(s);
+		s = va_arg(args, char*);
+	}
+	va_end(args);
+
+	result = realloc(str, len);
+	if (!result)
+		return NULL; /* errno remains set */
+
+	dest = result + slen;
+
+	/* Concat additional strings */
+
+	va_start(args, str);
+	s = va_arg(args, char *);
+	while (s) {
+		dest = stpcpy(dest, s);
+		s = va_arg(args, char *);
+	}
+	va_end(args);
+
+	return result;
+}
+
+LIBIMOBILEDEVICE_GLUE_API char *string_build_path(const char *elem, ...)
+{
+	if (!elem)
+		return NULL;
+	va_list args;
+	int len = strlen(elem)+1;
+	va_start(args, elem);
+	char *arg = va_arg(args, char*);
+	while (arg) {
+		len += strlen(arg)+1;
+		arg = va_arg(args, char*);
+	}
+	va_end(args);
+
+	char* out = (char*)malloc(len);
+	strcpy(out, elem);
+
+	va_start(args, elem);
+	arg = va_arg(args, char*);
+	while (arg) {
+		strcat(out, "/");
+		strcat(out, arg);
+		arg = va_arg(args, char*);
+	}
+	va_end(args);
+	return out;
+}
+
+LIBIMOBILEDEVICE_GLUE_API char *string_format_size(uint64_t size)
+{
+	char buf[80];
+	double sz;
+	if (size >= 1000000000000LL) {
+		sz = ((double)size / 1000000000000.0f);
+		sprintf(buf, "%0.1f TB", sz);
+	} else if (size >= 1000000000LL) {
+		sz = ((double)size / 1000000000.0f);
+		sprintf(buf, "%0.1f GB", sz);
+	} else if (size >= 1000000LL) {
+		sz = ((double)size / 1000000.0f);
+		sprintf(buf, "%0.1f MB", sz);
+	} else if (size >= 1000LL) {
+		sz = ((double)size / 1000.0f);
+		sprintf(buf, "%0.1f KB", sz);
+	} else {
+		sprintf(buf, "%d Bytes", (int)size);
+	}
+	return strdup(buf);
+}
+
+LIBIMOBILEDEVICE_GLUE_API char *string_toupper(char* str)
+{
+	char *res = strdup(str);
+	unsigned int i;
+	for (i = 0; i < strlen(res); i++) {
+		res[i] = toupper(res[i]);
+	}
+	return res;
+}
+
+static int get_rand(int min, int max)
+{
+	int retval = (rand() % (max - min)) + min;
+	return retval;
+}
+
+LIBIMOBILEDEVICE_GLUE_API char *generate_uuid()
+{
+	const char *chars = "ABCDEF0123456789";
+	int i = 0;
+	char *uuid = (char *) malloc(sizeof(char) * 37);
+
+	srand(time(NULL));
+
+	for (i = 0; i < 36; i++) {
+		if (i == 8 || i == 13 || i == 18 || i == 23) {
+			uuid[i] = '-';
+			continue;
+		} else {
+			uuid[i] = chars[get_rand(0, 16)];
+		}
+	}
+
+	/* make it a real string */
+	uuid[36] = '\0';
+
+	return uuid;
+}
+
+LIBIMOBILEDEVICE_GLUE_API int buffer_read_from_filename(const char *filename, char **buffer, uint64_t *length)
+{
+	FILE *f;
+	uint64_t size;
+
+	*length = 0;
+
+	f = fopen(filename, "rb");
+	if (!f) {
+		return 0;
+	}
+
+	fseek(f, 0, SEEK_END);
+	size = ftell(f);
+	rewind(f);
+
+	if (size == 0) {
+		fclose(f);
+		return 0;
+	}
+
+	*buffer = (char*)malloc(sizeof(char)*(size+1));
+
+	if (!buffer) {
+		return 0;
+	}
+
+	int ret = 1;
+	if (fread(*buffer, sizeof(char), size, f) != size) {
+		free(*buffer);
+		ret = 0;
+		errno = EIO;
+	}
+	fclose(f);
+
+	*length = size;
+	return ret;
+}
+
+LIBIMOBILEDEVICE_GLUE_API int buffer_write_to_filename(const char *filename, const char *buffer, uint64_t length)
+{
+	FILE *f;
+
+	f = fopen(filename, "wb");
+	if (f) {
+		size_t written = fwrite(buffer, sizeof(char), length, f);
+		fclose(f);
+
+		if (written == length) {
+			return 1;
+		}
+		else {
+			// Not all data could be written.
+			errno = EIO;
+			return 0;
+		}
+	}
+	else {
+		// Failed to open the file, let the caller know.
+		return 0;
+	}
+}
+
+LIBIMOBILEDEVICE_GLUE_API int plist_read_from_filename(plist_t *plist, const char *filename)
+{
+	char *buffer = NULL;
+	uint64_t length;
+
+	if (!filename)
+		return 0;
+
+	if (!buffer_read_from_filename(filename, &buffer, &length)) {
+		return 0;
+	}
+
+	if ((length > 8) && (memcmp(buffer, "bplist00", 8) == 0)) {
+		plist_from_bin(buffer, length, plist);
+	} else {
+		plist_from_xml(buffer, length, plist);
+	}
+
+	free(buffer);
+
+	return 1;
+}
+
+LIBIMOBILEDEVICE_GLUE_API int plist_write_to_filename(plist_t plist, const char *filename, enum plist_format_t format)
+{
+	char *buffer = NULL;
+	uint32_t length;
+
+	if (!plist || !filename)
+		return 0;
+
+	if (format == PLIST_FORMAT_XML)
+		plist_to_xml(plist, &buffer, &length);
+	else if (format == PLIST_FORMAT_BINARY)
+		plist_to_bin(plist, &buffer, &length);
+	else
+		return 0;
+
+	int res = buffer_write_to_filename(filename, buffer, length);
+
+	free(buffer);
+
+	return res;
+}
+
+static const char base64_str[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+static const char base64_pad = '=';
+
+static char *base64encode(const unsigned char *buf, size_t size)
+{
+	if (!buf || !(size > 0)) return NULL;
+	int outlen = (size / 3) * 4;
+	char *outbuf = (char*)malloc(outlen+5); // 4 spare bytes + 1 for '\0'
+	size_t n = 0;
+	size_t m = 0;
+	unsigned char input[3];
+	unsigned int output[4];
+	while (n < size) {
+		input[0] = buf[n];
+		input[1] = (n+1 < size) ? buf[n+1] : 0;
+		input[2] = (n+2 < size) ? buf[n+2] : 0;
+		output[0] = input[0] >> 2;
+		output[1] = ((input[0] & 3) << 4) + (input[1] >> 4);
+		output[2] = ((input[1] & 15) << 2) + (input[2] >> 6);
+		output[3] = input[2] & 63;
+		outbuf[m++] = base64_str[(int)output[0]];
+		outbuf[m++] = base64_str[(int)output[1]];
+		outbuf[m++] = (n+1 < size) ? base64_str[(int)output[2]] : base64_pad;
+		outbuf[m++] = (n+2 < size) ? base64_str[(int)output[3]] : base64_pad;
+		n+=3;
+	}
+	outbuf[m] = 0; // 0-termination!
+	return outbuf;
+}
+
+static void plist_node_print_to_stream(plist_t node, int* indent_level, FILE* stream);
+
+static void plist_array_print_to_stream(plist_t node, int* indent_level, FILE* stream)
+{
+	/* iterate over items */
+	int i, count;
+	plist_t subnode = NULL;
+
+	count = plist_array_get_size(node);
+
+	for (i = 0; i < count; i++) {
+		subnode = plist_array_get_item(node, i);
+		fprintf(stream, "%*s", *indent_level, "");
+		fprintf(stream, "%d: ", i);
+		plist_node_print_to_stream(subnode, indent_level, stream);
+	}
+}
+
+static void plist_dict_print_to_stream(plist_t node, int* indent_level, FILE* stream)
+{
+	/* iterate over key/value pairs */
+	plist_dict_iter it = NULL;
+
+	char* key = NULL;
+	plist_t subnode = NULL;
+	plist_dict_new_iter(node, &it);
+	plist_dict_next_item(node, it, &key, &subnode);
+	while (subnode)
+	{
+		fprintf(stream, "%*s", *indent_level, "");
+		fprintf(stream, "%s", key);
+		if (plist_get_node_type(subnode) == PLIST_ARRAY)
+			fprintf(stream, "[%d]: ", plist_array_get_size(subnode));
+		else
+			fprintf(stream, ": ");
+		free(key);
+		key = NULL;
+		plist_node_print_to_stream(subnode, indent_level, stream);
+		plist_dict_next_item(node, it, &key, &subnode);
+	}
+	free(it);
+}
+
+static void plist_node_print_to_stream(plist_t node, int* indent_level, FILE* stream)
+{
+	char *s = NULL;
+	char *data = NULL;
+	double d;
+	uint8_t b;
+	uint64_t u = 0;
+	struct timeval tv = { 0, 0 };
+
+	plist_type t;
+
+	if (!node)
+		return;
+
+	t = plist_get_node_type(node);
+
+	switch (t) {
+	case PLIST_BOOLEAN:
+		plist_get_bool_val(node, &b);
+		fprintf(stream, "%s\n", (b ? "true" : "false"));
+		break;
+
+	case PLIST_UINT:
+		plist_get_uint_val(node, &u);
+		fprintf(stream, "%"PRIu64"\n", u);
+		break;
+
+	case PLIST_REAL:
+		plist_get_real_val(node, &d);
+		fprintf(stream, "%f\n", d);
+		break;
+
+	case PLIST_STRING:
+		plist_get_string_val(node, &s);
+		fprintf(stream, "%s\n", s);
+		free(s);
+		break;
+
+	case PLIST_KEY:
+		plist_get_key_val(node, &s);
+		fprintf(stream, "%s: ", s);
+		free(s);
+		break;
+
+	case PLIST_DATA:
+		plist_get_data_val(node, &data, &u);
+		if (u > 0) {
+			s = base64encode((unsigned char*)data, u);
+			free(data);
+			if (s) {
+				fprintf(stream, "%s\n", s);
+				free(s);
+			} else {
+				fprintf(stream, "\n");
+			}
+		} else {
+			fprintf(stream, "\n");
+		}
+		break;
+
+	case PLIST_DATE:
+		plist_get_date_val(node, (int32_t*)&tv.tv_sec, (int32_t*)&tv.tv_usec);
+		{
+			time_t ti = (time_t)tv.tv_sec;
+			struct tm *btime = localtime(&ti);
+			if (btime) {
+				s = (char*)malloc(24);
+ 				memset(s, 0, 24);
+				if (strftime(s, 24, "%Y-%m-%dT%H:%M:%SZ", btime) <= 0) {
+					free (s);
+					s = NULL;
+				}
+			}
+		}
+		if (s) {
+			fprintf(stream, "%s\n", s);
+			free(s);
+		} else {
+			fprintf(stream, "\n");
+		}
+		break;
+
+	case PLIST_ARRAY:
+		fprintf(stream, "\n");
+		(*indent_level)++;
+		plist_array_print_to_stream(node, indent_level, stream);
+		(*indent_level)--;
+		break;
+
+	case PLIST_DICT:
+		fprintf(stream, "\n");
+		(*indent_level)++;
+		plist_dict_print_to_stream(node, indent_level, stream);
+		(*indent_level)--;
+		break;
+
+	default:
+		break;
+	}
+}
+
+LIBIMOBILEDEVICE_GLUE_API void plist_print_to_stream(plist_t plist, FILE* stream)
+{
+	int indent = 0;
+
+	if (!plist || !stream)
+		return;
+
+	switch (plist_get_node_type(plist)) {
+	case PLIST_DICT:
+		plist_dict_print_to_stream(plist, &indent, stream);
+		break;
+	case PLIST_ARRAY:
+		plist_array_print_to_stream(plist, &indent, stream);
+		break;
+	default:
+		plist_node_print_to_stream(plist, &indent, stream);
+	}
+}