diff options
| -rw-r--r-- | .gitignore | 36 | ||||
| -rw-r--r-- | COPYING | 502 | ||||
| -rw-r--r-- | Makefile.am | 10 | ||||
| -rw-r--r-- | README.md | 101 | ||||
| -rwxr-xr-x | autogen.sh | 26 | ||||
| -rw-r--r-- | configure.ac | 99 | ||||
| -rw-r--r-- | include/Makefile.am | 5 | ||||
| -rw-r--r-- | include/libimobiledevice-glue/collection.h | 52 | ||||
| -rw-r--r-- | include/libimobiledevice-glue/socket.h | 68 | ||||
| -rw-r--r-- | include/libimobiledevice-glue/thread.h | 87 | ||||
| -rw-r--r-- | include/libimobiledevice-glue/utils.h | 59 | ||||
| -rw-r--r-- | m4/as-compiler-flag.m4 | 62 | ||||
| -rw-r--r-- | m4/ax_pthread.m4 | 485 | ||||
| -rw-r--r-- | src/Makefile.am | 23 | ||||
| -rw-r--r-- | src/collection.c | 101 | ||||
| -rw-r--r-- | src/common.h | 38 | ||||
| -rw-r--r-- | src/libimobiledevice-glue-1.0.pc.in | 11 | ||||
| -rw-r--r-- | src/socket.c | 1169 | ||||
| -rw-r--r-- | src/thread.c | 203 | ||||
| -rw-r--r-- | src/utils.c | 551 |
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 @@ -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); + } +} |