diff options
Diffstat (limited to 'tests/deckard/contrib')
102 files changed, 19518 insertions, 0 deletions
diff --git a/tests/deckard/contrib/deckard.vim b/tests/deckard/contrib/deckard.vim new file mode 100644 index 0000000..3ae687a --- /dev/null +++ b/tests/deckard/contrib/deckard.vim @@ -0,0 +1,26 @@ +" Deckard syntax highlighting & folding +" +" Usage: Put following lines into ~/.vim/ftdetect/deckard.vim +" au BufRead,BufNewFile *.rpl set filetype=deckard +" au BufRead,BufNewFile *.stc set foldmethod=syntax + +syntax keyword Keyword MATCH STEP ADJUST MANDATORY RAW +syntax keyword Structure CONFIG_END +syntax keyword Function CHECK_ANSWER QUERY TIME_PASSES + +syntax region deckardEntry matchgroup=Structure start="ENTRY_BEGIN" end="ENTRY_END" fold transparent +syntax region deckardRange matchgroup=Structure start="RANGE_BEGIN" end="RANGE_END" fold transparent +syntax region deckardScenario matchgroup=Structure start="SCENARIO_BEGIN" end="SCENARIO_END" fold transparent + +syntax match deckardSection 'SECTION \+[^ ]\+' +syntax match deckardReply 'REPLY.*' + +syntax match Comment ';.*$' + +hi def link deckardEntry Folded +hi def link deckardRange Folded +hi def link deckardScenario Folded +hi def link deckardSection Special +hi def link deckardReply String + +let b:current_syntax = 'deckard' diff --git a/tests/deckard/contrib/libfaketime/.gitignore b/tests/deckard/contrib/libfaketime/.gitignore new file mode 100644 index 0000000..d45f99a --- /dev/null +++ b/tests/deckard/contrib/libfaketime/.gitignore @@ -0,0 +1,9 @@ +*.o +*.so.1 +timetest + +src/libfaketime.dylib.1 +src/libfaketime.1.dylib +src/core +src/faketime + diff --git a/tests/deckard/contrib/libfaketime/COPYING b/tests/deckard/contrib/libfaketime/COPYING new file mode 100644 index 0000000..d159169 --- /dev/null +++ b/tests/deckard/contrib/libfaketime/COPYING @@ -0,0 +1,339 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Lesser General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + <one line to give the program's name and a brief idea of what it does.> + Copyright (C) <year> <name of author> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along + with this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + <signature of Ty Coon>, 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. diff --git a/tests/deckard/contrib/libfaketime/Makefile b/tests/deckard/contrib/libfaketime/Makefile new file mode 100644 index 0000000..d88e35a --- /dev/null +++ b/tests/deckard/contrib/libfaketime/Makefile @@ -0,0 +1,34 @@ +INSTALL ?= install + +UNAME=$(shell uname) +SELECTOR:=$(shell if test "${UNAME}" = "Darwin" ; then echo "-f Makefile.OSX" ; fi) + +all: + $(MAKE) $(SELECTOR) -C src all + +test: + $(MAKE) $(SELECTOR) -C test all + +install: + $(MAKE) $(SELECTOR) -C src install + $(MAKE) $(SELECTOR) -C man install + $(INSTALL) -dm0755 "${DESTDIR}${PREFIX}/share/doc/faketime/" + $(INSTALL) -m0644 README "${DESTDIR}${PREFIX}/share/doc/faketime/README" + $(INSTALL) -m0644 NEWS "${DESTDIR}${PREFIX}/share/doc/faketime/NEWS" + +uninstall: + $(MAKE) $(SELECTOR) -C src uninstall + $(MAKE) $(SELECTOR) -C man uninstall + rm -f "${DESTDIR}${PREFIX}/share/doc/faketime/README" + rm -f "${DESTDIR}${PREFIX}/share/doc/faketime/NEWS" + rmdir "${DESTDIR}${PREFIX}/share/doc/faketime" + +clean: + $(MAKE) $(SELECTOR) -C src clean + $(MAKE) $(SELECTOR) -C test clean + +distclean: + $(MAKE) $(SELECTOR) -C src distclean + $(MAKE) $(SELECTOR) -C test distclean + +.PHONY: all test install uninstall clean distclean diff --git a/tests/deckard/contrib/libfaketime/NEWS b/tests/deckard/contrib/libfaketime/NEWS new file mode 100644 index 0000000..8836d80 --- /dev/null +++ b/tests/deckard/contrib/libfaketime/NEWS @@ -0,0 +1,134 @@ +Since 0.9.6: + - Julien Gilli added an option to disable monotonic time faking + - Azat Khuzhin added support for COARSE clocks + - Preliminary support for CLOCK_BOOTTIME (Linux) + - Fixed compilation on macOS (High) Sierra and various compiler warnings + - Support for select() call added by Hitoshi Harada (umitanuki) + - Updated documentation + +Since 0.9.5: + - fixed crashes that happened when other LD_PRELOAD libraries were used + - fixed passing through of return values when using the faketime wrapper + - fixed compile-time issues with CLOCK_MONOTONIC_RAW on some platforms + - rbalint added Filter commands: FAKETIME_ONLY_CMDS and + FAKETIME_SKIP_CMDS control which (sub-)processes libfaketime + is applied to. + +Since 0.9: + - ryandesign at MacPorts provided a Portfile for MacPorts and + fixed various build issues on OSX. + - Balint Reczey added support for nanosecond resolution, saving + timestamps to files, speeding up and slowing down per-process + timers, CLOCK_MONOTONIC and CLOCK_MONOTONIC_RAW, faketime + support for system calls such as sleep() and alarm(). + - Applied a patch by Gerardo Malazdrewicz and Toni G to restore + compatibility with newer versions of glibc. + - Balint Reczey added an option to use the same global clock setting + for all libfaketime-spawned processes. + - Balint Reczey has rewritten the faketime wrapper shell script in C + and refactored libfaketime. + - Balint Reczey added support for advancing the time with each time- + related system call ("deterministic time"). + - Added "timeprivacy" wrapper by adrelanos; it ensures that programs + are started with unique timestamps. + - Code and documentation cleanup by Tomi Ollila. + - Reworked Makefiles for more flexible installation, including fixes + by Lukas Fleischner, Daniel Kahm Gillmor, and Hugues Andreux. + - Fixed license issues as pointed out by Paul Wouters. + - Mac OS X support has been improved for OS X 10.7 and 10.8; due to + changes to the underlying libraries on OS X, libfaketime 0.9.5 will + no longer work with OS X < 10.6; use libfaketime 0.9(.1) for older + OS X installations. + - Don Fong has contributed a new framework for functional tests. + Petr Salinger ensured its compatibility with GNU/kFreeBSD. + +Since 0.8.2: + - Added support for "limited faking". + You can optionally specify when libfaketime starts to fake the + returned timestamps and when it shall stop doing so. For example, + a program can be started regularly, and after 5 minutes run-time + it will be sent two years into the future. Those limiting + start and stop times can be specified in seconds or as the + number of any time-related function calls within the program. + - Added a feature to spawn an external process after x seconds + or y time-related system calls. This can, for example, be used + to execute an arbitrary shell script x seconds after a program + has been started. + +Since 0.8.1: + - Added a MacOS port. + Thanks to Daria Phoebe Brashear! + - Added a functional test framework that aids in automatically + determining whether libfaketime works properly on the current + machine. Thanks to Don Fong! + +Since 0.8: + - Changed directory layout and Makefile structure. + Thanks to Lukas Fleischer! + +Since 0.7: + - Added support for fstatat() and fstatat64() which were introduced in + Linux kernel 2.6.16 and used in recent coreutils. + Thanks to Daniel Kahn Gillmor for the report! + This can be disabled by passing -DNO_ATFILE in the Makefile. + - Added a simple wrapper shell script and a man page for it. Makes it + easier to run commands under faked system times. It assumes that the + libraries will be copied to /usr/lib/faketime during installation, + please adjust this path if necessary. The "install" target in the + Makefile has been adapted accordingly. + - Added support for fractional time offsets, such as FAKETIME="+1,5h". + Please note that either , or . has to be used as a delimiter + depending on your locale. Thanks to Karl Chen! + - Added support for speeding the clock up or slowing it down. For + example, FAKETIME="+5d x2,0" will set the faked time 5 days into + the future and make the clock run twice as fast for the specified + program. Slowing it down can be done e.g. by using FAKETIME="+0 x0,5". + Again, the delimiter to use for the fraction depends on your locale. + Thanks to Karl Chen! + +Since 0.6: + Main version 0.7 contributions by David North, TDI: + - Added ability to 'start clock at' a specific time. + - Added pthread synchronization support + - Added a 2 second delay to timetest.c so one can observe if the + clock is relative or absolute + - Added test.sh example of 'start clock at' + - Added ability to disable the FAKE_STAT functionality at library-start + in the case that the library was compiled -DFAKE_STAT, and added another + test case for demonstrating this + - Repaired a bug w.r.t. strptime/mktime wherein 'isdst' was uninitialized + which led to pseudorandom +/- 1 hour results being returned in 'start at' + or absolute time modes + + Other enhancements: + - Fixed missing interceptions to libc-internal functions and added notes + about a workaround for running Java programs with faked times in the + future (they worked properly, but often locked up at exiting). Thanks to + Jamie Cameron of Google for in-depth analysis and prototype solution! + +Since 0.5: + - Performance enhancements by means of caching the data read + e.g. from $HOME/.faketimerc for 10 seconds. + - Several file timestamp related system calls such as fstat() will be + intercepted now. See the README file on how to turn this off if you + do not need it. Thanks to Philipp Hachtmann! + - A system-wide /etc/faketimerc file will now be used if no FAKETIME + environment variable has been set and no $HOME/.faketimerc is present. + Thanks to David Burley, Jacob Moorman, and Wayne Davison of + SourceForge, Inc.! + - Added trivial Makefile targets clean/distclean/install + - Changed Makefile target test to run new test.sh script + - Added new test cases to timetest.c + +Since 0.4: + - Allow "y" for years of offset specification. Thanks to Bas ten Berge! + +Since 0.3: + - Support for FAKETIME_FMT environment variable. Thanks to Moreno Baricevic! + +Since 0.2: + - Intercept clock_gettime(). Thanks to Andreas Thienemann! + +Since 0.1: + - Fixed segfault when calling time(NULL). Thanks to Andres Ojamaa! + - Added additional sanity checks. diff --git a/tests/deckard/contrib/libfaketime/README b/tests/deckard/contrib/libfaketime/README new file mode 100644 index 0000000..248bc92 --- /dev/null +++ b/tests/deckard/contrib/libfaketime/README @@ -0,0 +1,534 @@ +libfaketime, version 0.9.7 (November 2017) +========================================== + + +Content of this file: +--------------------- + +1. Introduction +2. Compatibility issues +3. Installation +4. Usage + a) Basics + b) Using absolute dates + c) Using 'start at' dates + d) Using offsets for relative dates + e) Advanced features and caveats + f) Faking the date and time system-wide + g) Using the "faketime" wrapper script + h) "Limiting" libfaketime based on elapsed time or number of calls + i) "Limiting" libfaketime per process + j) Spawning an external process + k) Saving timestamps to file, loading them from file +5. License +6. Contact + + +1. Introduction +--------------- + +libfaketime intercepts various system calls that programs use to retrieve the +current date and time. It then reports modified (faked) dates and times (as +specified by you, the user) to these programs. This means you can modify the +system time a program sees without having to change the time system-wide. + +libfaketime allows you to specify both absolute dates (e.g., 01/01/2004) and +relative dates (e.g., 10 days ago). + +libfaketime might be used for various purposes, for example + +- deterministic build processes +- debugging time-related issues, such as expired SSL certificates +- testing software for year-2038 compliance + +libfaketime ships with a command line wrapper called "faketime" that makes it +easier to use, but does not expose all of libfaketime's functionality. If your +use case is not covered by the faketime command, make sure to look in this +documentation whether it can be achieved by using libfaketime directly. + + +2. Compatibility issues +----------------------- + +- libfaketime is supposed to work on Linux and macOS. + Your mileage may vary; some other *NIXes have been reported to work as well. + +- libfaketime uses the library preload mechanism of your operating system's + linker (which is involved in starting programs) and thus cannot work with + statically linked binaries or binaries that have the setuid-flag set (e.g., + suidroot programs like "ping" or "passwd"). Please see you system linker's + manpage for further details. + +- libfaketime supports the pthreads environment. A separate library is built + (libfaketimeMT.so.1), which contains the pthread synchronization calls. This + library also single-threads calls through the time() intercept because + several variables are statically cached by the library and could cause issues + when accessed without synchronization. + + However, the performance penalty for this might be an issue for some + applications. If this is the case, you can try using an unsynchronized time() + intercept by removing the -DPTHREAD_SINGLETHREADED_TIME from the Makefile and + rebuilding libfaketimeMT.so.1 + +* Java-/JVM-based applications work but you need to pass in an extra argument + (DONT_FAKE_MONOTONIC). See usage basics below for details. Without this + argument the java command usually hangs. + +* libfaketime will eventually be bypassed by applications that dynamically load + system libraries, such as librt, explicitly themselves instead of relying on + the linker to do so at application start time. libfaketime will not work with + those applications unless you can modify them. + +* Applications can explicitly be designed to prevent libfaketime from working, + e.g., by checking whether certain environment variables are set or whether + libfaketime-specific files are present. + + +3. Installation +--------------- + +Running "make" compiles both library versions and a test program, which it then +also executes. + +If the test works fine, you should copy the libfaketime libraries +(libfaketime.so.1, and libfaketimeMT.so.1) to the place you want them in. +Running "make install" will attempt to place them in /usr/local/lib/faketime +and will install the wrapper shell script "faketime" in /usr/local/bin, both of +which most likely will require root privileges. However, from a technical point +of view, there is no necessity for a system-wide installation, so you can use +libfaketime also on machines where you do not have root privileges. You may +want to adjust the PREFIX variable in the Makefiles accordingly. + +By default, the Makefile compiles/links libfaketime for your default system +architecture. If you need to build, e.g., 32-bit files on a 64-bit platform, +please see the notes about CFLAGS and LDFLAGS in src/Makefile. + +Since version 0.6, system calls to file timestamps are also intercepted, +thanks to a contribution by Philipp Hachtmann. This is especially useful in +combination with relative time offsets as explained in section 4d) below, if a +program writes and reads files whose timestamps also shall be faked. If you do +not need this feature or if it confuses the application you want to use FTPL +with, define the environment variable NO_FAKE_STAT, and the intercepted stat +calls will be passed through unaltered. + +On macOS, it is necessary to compile differently, due to the different +behavior dyld has. Use the Makefile.OSX file provided to compile +libfaketime.1.dylib. Additionally, instead of using LD_PRELOAD, +the variable DYLD_INSERT_LIBRARIES should be set to the path to +libfaketime.1.dylib, and the variable DYLD_FORCE_FLAT_NAMESPACE should be +set (to anything). macOS users should read README.OSX for additional +details. + + +4. Usage +-------- + +4a) Usage basics +---------------- + +Using libfaketime on a program of your choice consists of two steps: + +1. Making sure libfaketime gets loaded by the system's linker. +2. Specify the faked time. + +As an example, we want the "date" command to report our faked time. To do so, +we could use the following command line on Linux: + +user@host> date +Tue Nov 23 12:01:05 CEST 2016 + +user@host> LD_PRELOAD=/usr/local/lib/libfaketime.so.1 FAKETIME="-15d" date +Mon Nov 8 12:01:12 CEST 2016 + +user@host> LD_PRELOAD=/usr/local/lib/libfaketime.so.1 FAKETIME="-15d" +DONT_FAKE_MONOTONIC=1 java -version +java version "1.8.0_111" +Java(TM) SE Runtime Environment (build 1.8.0_111-b14) +Java HotSpot(TM) 64-Bit Server VM (build 25.111-b14, mixed mode) + +The basic way of running any command/program with libfaketime enabled is to +make sure the environment variable LD_PRELOAD contains the path and +filename of the libfaketime library. This can either be done by setting it once +beforehand: + +export LD_PRELOAD=/path/to/libfaketime.so.1 +(now run any command you want) + +Or it can be done by specifying it on the command line itself: + +LD_PRELOAD=/path/to/libfaketime.so.1 your_command_here + +(These examples are for the bash shell; how environment variables are set may +vary on your system.) + +On Linux, library search paths can be set as part of the linker configuration. +LD_PRELOAD then also works with relative paths. For example, when libfaketime.so.1 +is installed as /path/to/libfaketime.so.1, you can add /path/to to an appropriate +linker configuration file, e.g., /etc/ld.so.conf.d/local.conf, and then run +the "ldconfig" command. Afterwards, using LD_PRELOAD=libfaketime.so.1 suffices. + +However, also the faked time should be specified; otherwise, libfaketime will +be loaded, but just report the real system time. There are three ways to +specify the faked time: + +a) By setting the environment variable FAKETIME. +b) By using the file given in the environment variable FAKETIME_TIMESTAMP_FILE +c) By using the file .faketimerc in your home directory. +d) By using the file /etc/faketimerc for a system-wide default. + +If you want to use b) c) or d), $HOME/.faketimerc or /etc/faketimerc consist of +only one line of text with exactly the same content as the FAKETIME environment +variable, which is described below. Note that /etc/faketimerc will only be used +if there is no $HOME/.faketimerc and no FAKETIME_TIMESTAMP_FILE file exists. +Also, the FAKETIME environment variable _always_ has priority over the files. + + +4b) Using absolute dates +------------------------ + +The format that _must_ be used for _absolute_ dates is "YYYY-MM-DD hh:mm:ss". +For example, the 24th of December, 2020, 8:30 PM would have to be specified as +FAKETIME="2020-12-24 20:30:00". + + +4c) Using 'start at' dates +-------------------------- + +(Thanks to a major contribution by David North, TDI in version 0.7) + +The format that _must_ be used for _start_at_ dates is "@YYYY-MM-DD hh:mm:ss". +For example, the 24th of December, 2020, 8:30 PM would have to be specified as +FAKETIME="@2020-12-24 20:30:00". + +The absolute dates described in 4b) simulate a STOPPED system clock at the +specified absolute time. The 'start at' format allows a 'relative' clock +operation as described below in section 4d), but using a 'start at' time +instead of an offset time. + + +4d) Using offsets for relative dates +------------------------------------ + +Relative date offsets can be positive or negative, thus what you put into +FAKETIME _must_ either start with a + or a -, followed by a number, and +optionally followed by a multiplier: + +- By default, the offset you specify is in seconds. Example: + + export FAKETIME="-120" will set the faked time 2 minutes (120 seconds) behind + the real time. + +- The multipliers "m", "h", "d" and "y" can be used to specify the offset in + minutes, hours, days and years (365 days each), respectively. Examples: + + export FAKETIME="-10m" sets the faked time 10 minutes behind the real time. + export FAKETIME="+14d" sets the faked time to 14 days in the future. + +You now should understand the complete example we've used before: + +LD_PRELOAD=/usr/local/lib/libfaketime.so.1 FAKETIME="-15d" date + +This command line makes sure libfaketime gets loaded and sets the faked time to +15 days in the past. + +Moreno Baricevic has contributed support for the FAKETIME_FMT environment +variable, which allows you to optionally set the strptime() format: + +Some simple examples: +LD_PRELOAD=./libfaketime.so.1 FAKETIME_FMT=%s FAKETIME="`date +%s -d'1 year ago'`" date +LD_PRELOAD=./libfaketime.so.1 FAKETIME_FMT=%s FAKETIME="`stat -c %Y somefile`" date +LD_PRELOAD=./libfaketime.so.1 FAKETIME_FMT=%c FAKETIME="`date`" date + + +4e) Advanced features and caveats +--------------------------------- + +Advanced time specification options: +------------------------------------ + +Since version 0.8, thanks to a contribution by Karl Chen, fractions can be used +in the specification of time offsets. For example, + +FAKETIME="+1,5h" + +is equivalent to FAKETIME="+90m". Please be aware that the fraction delimiter +depends on your locale settings, so actually you might need to use + +FAKETIME="+1.5h" + +You should figure out the proper delimiter, e.g., by using libfaketime on +a command like /bin/date where you immediately can verify whether it worked as +expected. + +Also contributed by Karl Chen in v0.8 is the option to speed up or slow +down the wall clock time for the program which is executed using libfaketime. +For example, + +FAKETIME="+1y x2" + +will set the faked time one year into the future and will make the clock run +twice as fast. Similarly, + +FAKETIME="+1y x0,5" + +will make the clock run only half as fast. As stated above, the fraction +delimiter depends on your locale. Furthermore, + +FAKETIME="+1y i2,0" + +will make the clock step two seconds per each time(), etc. call, being +completely independently of the system clock. It helps running programs +with some determinism. In this single case all spawned processes will use +the same global clock without restarting it at the start of each process. + +For testing, your should run a command like + +LD_PRELOAD=./libfaketime.so.1 FAKETIME="+1,5y x10,0" \ +/bin/bash -c 'while true; do echo $SECONDS ; sleep 1 ; done' + +For each second that the endless loop sleeps, the executed bash shell will +think that 10 seconds have passed ($SECONDS is a bash-internal variable +measuring the time since the shell was started). + +(Please note that replacing "echo $SECONDS" e.g. with a call to "/bin/date" +will not give the expected result, since /bin/date will always be started as a +new process for which also libfaketime will be re-initialized. It will show the +correct offset (1.5 years in the future), but no speed-ups or slow-downs.) + +For applications that should use a different date & time each time they are +run, consider using the included timeprivacy wrapper shellscript (contributed +by adrelanos at riseup dot net). + + +Caveats: +-------- + +Whenever possible, you should use relative offsets or 'start at' dates, +and not use absolute dates. + +Why? Because the absolute date/time you set is fixed, i.e., if a program +retrieves the current time, and retrieves the current time again 5 minutes +later, it will still get the same result twice. This is likely to break +programs which measure the time passing by (e.g., a mail program which checks +for new mail every X minutes). + +Using relative offsets or 'start at' dates solves this problem. +libfaketime then will always report the faked time based on the real +current time and the offset you've specified. + +Please also note that your default specification of the fake time is cached for +10 seconds in order to enhance the library's performance. Thus, if you change the +content of $HOME/.faketimerc or /etc/faketimerc while a program is running, it +may take up to 10 seconds before the new fake time is applied. If this is a +problem in your scenario, you can change number of seconds before the file is read +again with environment variable FAKETIME_CACHE_DURATION, or disable caching at all +with FAKETIME_NO_CACHE=1. Remember that disabling the cache may negatively +influence the performance. + + +4f) Faking the date and time system-wide +---------------------------------------- + +David Burley of SourceForge, Inc. reported an interesting use case of applying +libfaketime system-wide: Currently, all virtual machines running inside +an OpenVZ host have the same system date and time. In order to use multiple +sandboxes with different system dates, the libfaketime library can be put into +/etc/ld.so.preload; it will then be applied to all commands and programs +automatically. This is of course best used with a system-wide /etc/faketimerc +file. Kudos to SourceForge, Inc. for providing the patch! + +Caveat: If you run a virtual machine, its real-time clock might be reset to the +real world date & time when you reboot. Depending on your FAKETIME setting, +this may lead to side effects, such as forced file system checks on each reboot. +System-wide faked time may also lead to unexpected side effects with software +auto-update tools, if the offset between real world time and faked system time +is too large. If in doubt, set your system's date to the faked time and try out +whether everything still works as expected before applying libfaketime +system-wide. + + +4g) Using the "faketime" wrapper +-------------------------------- + +As of version 0.8, libfaketime provides a command named "faketime", which is +placed into /usr/bin by "make install". It spares the hassle of setting +the LD_PRELOAD and FAKETIME environment variables manually, but only exposes +a subset of libfaketime's functionality. On the other hand, it uses the date +interpretation function by /bin/date in order to provide higher flexibility +regarding the specification of the faked date and time. For example, you +can use + +faketime 'last Friday 5 pm' /your/command/here + +Of course, also absolute dates can be used, such as in + +faketime '2018-12-24 08:15:42' /bin/date + +Thanks to Daniel Kahn Gillmor for providing these suggestions! + +Balint Reczey has rewritten the wrapper in 0.9.5 from a simple shell script +to an efficient wrapper application. + + +4h) "Limiting" libfaketime based on elapsed time or number of calls +------------------------------------------------------------------- + +Starting with version 0.9, libfaketime can be configured to not be continuously +active, but only during a certain time interval. + +For example, you might want to start a program with the real current time, but +after 5 minutes of usage, you might want it to see a faked time, e.g., a year +in the future. + +Dynamic changes to the faked time are alternatively possible by + +- changing the FAKETIME environment variable at run-time; this is the preferred + way if you use libfaketime for debugging and testing as a programmer, as it + gives you the most direct control of libfaketime without any performance + penalties. + +- not using the FAKETIME environment variable, but specifying the fake time in + a file (such as ~/.faketimerc). You can change the content of this file at + run-time. This works best with caching disabled, but comes at a performance + cost because this file has to be read and evaluated each time. + +The feature described here works based on two pairs of environment variables, + + FAKETIME_START_AFTER_SECONDS and FAKETIME_STOP_AFTER_SECONDS, and + FAKETIME_START_AFTER_NUMCALLS and FAKETIME_STOP_AFTER_NUMCALLS + +The default value for each of these environment variables is -1, which means +"ignore this value". + +If you want libfaketime to be only active during the run-time minutes 2 to 5 +of your application, you would set + + FAKETIME_START_AFTER_SECONDS=60 + FAKETIME_STOP_AFTER_SECONDS=300 + +This means that your application will work with the real time from start (second +0) up to second 60. It will then see a faked time from run-time seconds 60 to +300 (minutes 2, 3, 4, and 5). After run-time second 600, it will again see the +real (not-faked) time. + +This approach is not as flexible as changing the FAKETIME environment variable +during runtime, but may be easier to use, works on a per-program (and not a +per-user or system-wide) scope, and has only a minor performance overhead. + +Using the other pair of environment variables, you can limit the activity time +of libfaketime not based on wall-clock seconds, but on the number of +time-related function calls the started program performs. This alternative is +probably only suitable for programmers who either know the code of the program +in order to determine useful start/stop values or want to perform fuzzing +tests. + +Both pairs of environment variables can be combined to further restrict +libfaketime activity, although this is only useful in very few scenarios. + +Limiting libfaketime activity in this way is not recommended in general. Many +programs will break when they are subject to sudden changes in time, especially +if they are started using the current (real) time and are then sent back into +the past after, e.g., 5 minutes. For example, they may appear to be frozen or +stuck because they are waiting until a certain point in time that, however, is +never reached due to the delayed libfaketime activity. Avoid using this +functionality unless you are sure you really need it and know what you are +doing. + + +4i) "Limiting" libfaketime per process +-------------------------------------- + +faketime can be instructed to fake time related calls only for selected +commands or to fake time for each command except for a certain subset of +commands. + +The environment variables are FAKETIME_ONLY_CMDS and FAKETIME_SKIP_CMDS +respectively. + +Example: + FAKETIME_ONLY_CMDS=javadoc faketime '2008-12-24 08:15:42' make +will run the "make" command but the time faking will only be applied +to javadoc processes. + +Multiple commands are separated by commas. + +Example: + FAKETIME_SKIP_CMDS="javadoc,ctags" faketime '2008-12-24 08:15:42' make +will run the "make" command and apply time faking for everything "make" +does except for javadoc and ctags processes. + +FAKETIME_ONLY_CMDS and FAKETIME_SKIP_CMDS are mutually exclusive, i.e., +you cannot set them both at the same time. faketime will terminate with +an error message if both environment variables are set. + + +4j) Spawning an external process +-------------------------------- + +From version 0.9 on, libfaketime can execute a shell command once after a) an +arbitrary number of seconds has passed or b) a number of time-related system +calls has been made by the program since it started. This has two limitations +one needs to be aware of: + +* Spawning the external process happens during a time-related system call + of the original program. If you want the external process to be started + 5 seconds after program start, but this program does not make any time- + related system calls before run-time second 8, the start of your external + process will be delayed until run-time second 8. + +* The original program is blocked until the external process is finished, + because the intercepting time-related system call will not return earlier. If + you need to start a long-running external process, make sure it forks into the + background. + +Spawning the external process is controlled using three environment variables: +FAKETIME_SPAWN_TARGET, FAKETIME_SPAWN_SECONDS, FAKETIME_SPAWN_NUMCALLS. + +Example (using bash on Linux): + +(... usual libfaketime setup here, setting LD_PRELOAD and FAKETIME ...) +export FAKETIME_SPAWN_TARGET="/bin/echo 'Hello world'" +export FAKETIME_SPAWN_SECONDS=5 +/opt/local/bin/myprogram + +This will run the "echo" command with the given parameter during the first +time-related system function call that "myprogram" performs after running for 5 +seconds. + + +4k) Saving timestamps to file, loading them from file +----------------------------------------------------- + +faketime can save faked timestamps to a file specified by FAKETIME_SAVE_FILE +environment variable. It can also use the file specified by FAKETIME_LOAD_FILE +to replay timestamps from it. After consuming the whole file, libfaketime +returns to using the rule set in FAKETIME variable, but the timestamp processes +will start counting from will be the last timestamp in the file. + +The file stores each timestamp in a stream of saved_timestamp structs +without any metadata or padding: + +/* Storage format for timestamps written to file. Big endian. */ +struct saved_timestamp { + int64_t sec; + uint64_t nsec; +}; + +faketime needs to be run using the faketime wrapper to use these files. This +functionality has been added by Balint Reczey in v0.9.5. + + +5. License +---------- + +libfaketime has been released under the GNU General Public License, GPL. +Please see the included COPYING file. + + +6. Contact +----------- + +Bug reports, feature suggestions, success reports, and patches/pull +requests are highly appreciated: + + https://github.com/wolfcw/libfaketime diff --git a/tests/deckard/contrib/libfaketime/README.OSX b/tests/deckard/contrib/libfaketime/README.OSX new file mode 100644 index 0000000..7f17a63 --- /dev/null +++ b/tests/deckard/contrib/libfaketime/README.OSX @@ -0,0 +1,144 @@ +README file for libfaketime on macOS +==================================== + +Support for macOS has meanwhile matured and many command line and +GUI applications will run stable. + +Developments and tests are done on High Sierra currently. +Use libfaketime 0.9.6 or earlier on OS X (i.e., before Sierra). + +Version 0.9.5 and higher no longer works with OSX <= 10.6 due to +changes in the underlying system libraries. If you need libfaketime +on OSX <= 10.6, please use libfaketime version 0.9. + + +Installing and using libfaketime on OS X is slightly different than +on Linux. Please make sure to read the README file for general +setup and usage, and refer to this file only about OS X specifics. + + +1) Installing libfaketime on macOS +---------------------------------- + +If you use MacPorts, libfaketime can be installed on the command line +as follows: + + sudo port install libfaketime + +Or, if you use Fink, install using: + + fink install libfaketime + +Or, if you use Homebrew, install using: + + brew install libfaketime + +Otherwise, you have to compile and install libfaketime manually; this +will require a working installation of Xcode and its command line tools +on your machine. + +You can compile libfaketime by running the command + + make + +in libfaketime's top-level directory. + +The resulting library will be named libfaketime.1.dylib ; to check +whether it works properly, run the test suite and verify whether its +output is correct: + + cd test + make -f Makefile.OSX + + +2) Using libfaketime from the command line on macOS +--------------------------------------------------- + +You will need to set three environment variables. In a Terminal.app +or iTerm2 session, the following commands can be used: + +export DYLD_FORCE_FLAT_NAMESPACE=1 +export DYLD_INSERT_LIBRARIES=/path/to/libfaketime.1.dylib +export FAKETIME="your favorite faketime-spec here" + +Please refer to the general README file concerning the format +of the FAKETIME environment variable value and other environment +variables that are related to it. + +The "faketime" wrapper application has been adapted to macOS; +it offers the same limited libfaketime functionality as on Linux +in a simple-to-use manner without the need to manually set +those environment variables. Run "faketime" without parameters +for help and use "man faketime" for details. + + +3) Integrating libfaketime with applications +-------------------------------------------- + +Given the limited number of system calls libfaketime intercepts, +it may not work too well with specific GUI applications on OS X. +This can result in crashes after a seemingly random time, or an +application will not or at least not always see the faked time, +and so on. + +A safe way to try out whether a specific application works fine +with libfaketime is to start it from the command line. Perform +the steps outlined above and run the application by issuing the +following command: + +/Applications/ApplicationName.app/Contents/MacOS/ApplicationName + +(Make sure to replace "ApplicationName" twice in that command with +the name of your actual application.) + +If it works fine, you can configure the application to permanently +run with libfaketime by editing its Info.plist file. Add the +LSEnvironment key unless it is already there and add a dictionary +with the three keys like this: + + <key>LSEnvironment</key> + <dict> + <key>DYLD_FORCE_FLAT_NAMESPACE</key> + <string>1</string> + <key>DYLD_INSERT_LIBRARIES</key> + <string>/path/to/libfaketime.1.dylib</string> + <key>FAKETIME</key> + <string>value of FAKETIME here</string> + </dict> + +(If the application is installed in /Applications instead of in +$HOME/Applications, you eventually will need root privileges. If +the application's Info.plist is not in XML, but in binary format, +use appropriate editing or conversion tools.) + +Afterwards, you will probably need to run + + /System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister -v -f /Applications/ApplicationName.app + +to make sure the change to Info.plist does not go unnoticed. + +Please note that modifications to Info.plist will be lost when the +application is updated, so this process needs to be repeated after +such updates, including own new builds when using Xcode. + +Please feel free to report non-working applications on the Github +libfaketime issues website. This may help us to identify further +time-related system calls that need to be intercepted on macOS. + + https://github.com/wolfcw/libfaketime/issues + +Important: When reporting non-working applications, please make +sure that your issue is not related to SIP (system integrity +protection). For example, on a SIP-enabled, default macOS installation, +libfaketime will not work for programs like /bin/bash because +the path /bin is SIP-protected. Copy your application to a +non-SIP-protected path, and if libfaketime still does not work, +feel free to report it. + + +4) Notes for developers of macOS applications +--------------------------------------------- + +The environment variable FAKETIME can be changed at application run-time +and always takes precedence over other user-controlled settings. It can +be re-set to 0 (zero) to work around potential incompatibilities. diff --git a/tests/deckard/contrib/libfaketime/README.developers b/tests/deckard/contrib/libfaketime/README.developers new file mode 100644 index 0000000..b8df57f --- /dev/null +++ b/tests/deckard/contrib/libfaketime/README.developers @@ -0,0 +1,106 @@ +This file contains information for libfaketime developers and contributors. + + +GENERAL +======= + +Starting with libfaketime v0.9.5, development and issue handling is +completely done via Github: + + https://github.com/wolfcw/libfaketime + +- Official releases are tagged. +- Code contributions and bugfixes are merged into the "development" branch, + which is considered unstable and may contain code that is not yet fully + tested. +- The "master" branch is updated with tested code only; it is ensured that + it compiles and works cleanly at least on current Linux and OS X systems. + +Code contributions are highly welcome, preferably via pull requests on Github. + + +CODE STYLE +========== + +Please try to stick to the following code formatting style guidelines: + +- No tabs, only spaces for indentation. +- Avoid trailing whitespace. +- Indentation is 2 spaces for each level. +- Opening and closing curly brackets have to be on lines of their own. +- Use under_score_names for function and variable names; avoid using camelCase. +- // and /*...*/ style comments may and shall be used. + +Example: + +/* This function will do nothing */ +void do_nothing(int how_often) +{ + int counter; + for (counter = 0; counter < how_often; counter++) + { + counter = counter; // our do-nothing algorithm + } +} + +- Use -DDEBUG and #ifdef DEBUG for development and testing. Avoid printing + to stdout or stderr outside "#ifdef DEBUG"; if it is necessary to inform + the user a run-time, prefix your output with "faketime" or make otherwise + sure that the user knows where the message is coming from. + +- If you add new functions to libfaketime.c, try placing them somewhere + where they fit will: Usually, functions are grouped by functionality + (e.g., all functions related to faking file timestamps). If that's not + possible, group them by contributor, or document your placement strategy + in the commit message. + + +DEVELOPMENT, BUILDING, AND TESTING +================================== + +- Don't break existing behaviour. Backward compatibility matters (unless + the modification fixes bugs :-)). + +- Add tests for new features. Extend test/timetest.c appropriately and + try to use the functional testing framework wherever possible. + +- Compiler and linker warnings are treated as errors and not acceptable. + +- If you cannot test the code on both Linux and OS X yourself, please + let us know and consider wrapping your code in #ifdef / #ifndef __APPLE__ + statements. + + +DOCUMENTATION +============= + +For anything more than small bugfixes, please update the user documentation +and credits appropriately: + +- The NEWS file should mention the change and your credits. +- The README and README.OSX files should be updated whenever functionality + is added or modified. +- The manpage man/faketime.1 should be updated when the wrapper application + is modified. + +For credits, please either mention your real name, your Github username, or +your email address. + +In your own interest, please be verbose on user documentation and comments +in the source code. Users will not know about new features unless they are +documented. Other authors and maintainers will need to understand your code +easily. + + +RELEASES +======== + +Official new releases are created whenever a significant amount of changes +(bugfixes or new functionality) has piled up; on average, there is one new +official release per year. Users who need to stick to the bleeding edge +are supposed to use the current state of the "master" branch at any time. + +libfaketime maintainers for several Linux distributions are informed about +release candidates and new releases by email. Contact wolfcw on Github if +you are interested in receiving notifications, or use Github functionality +to get informed about updates. diff --git a/tests/deckard/contrib/libfaketime/TODO b/tests/deckard/contrib/libfaketime/TODO new file mode 100644 index 0000000..b8c801c --- /dev/null +++ b/tests/deckard/contrib/libfaketime/TODO @@ -0,0 +1,9 @@ +Open issues / next steps for libfaketime development + +- add more functional tests that check more than the basic functionality +- use the testing framework to also implement unit tests +- fake timer_create and friends +- work around thread local storage issue, e.g., by using pthreads +- add autoconf/automake support to get rid of separate Makefile.OSX +- improve pthread support + diff --git a/tests/deckard/contrib/libfaketime/man/Makefile b/tests/deckard/contrib/libfaketime/man/Makefile new file mode 100644 index 0000000..807c157 --- /dev/null +++ b/tests/deckard/contrib/libfaketime/man/Makefile @@ -0,0 +1,14 @@ +INSTALL ?= install + +PREFIX ?= /usr/local + +all: + +install: + $(INSTALL) -Dm0644 faketime.1 "${DESTDIR}${PREFIX}/share/man/man1/faketime.1" + gzip -f "${DESTDIR}${PREFIX}/share/man/man1/faketime.1" + +uninstall: + rm -f "${DESTDIR}${PREFIX}/share/man/man1/faketime.1.gz" + +.PHONY: all install uninstall diff --git a/tests/deckard/contrib/libfaketime/man/Makefile.OSX b/tests/deckard/contrib/libfaketime/man/Makefile.OSX new file mode 100644 index 0000000..5451acd --- /dev/null +++ b/tests/deckard/contrib/libfaketime/man/Makefile.OSX @@ -0,0 +1,15 @@ +INSTALL ?= install + +PREFIX ?= /usr/local + +all: + +install: + $(INSTALL) -dm0755 "${DESTDIR}${PREFIX}/share/man/man1" + $(INSTALL) -m0644 faketime.1 "${DESTDIR}${PREFIX}/share/man/man1/faketime.1" + gzip -f "${DESTDIR}${PREFIX}/share/man/man1/faketime.1" + +uninstall: + rm -f "${DESTDIR}${PREFIX}/share/man/man1/faketime.1.gz" + +.PHONY: all install uninstall diff --git a/tests/deckard/contrib/libfaketime/man/faketime.1 b/tests/deckard/contrib/libfaketime/man/faketime.1 new file mode 100644 index 0000000..89c279d --- /dev/null +++ b/tests/deckard/contrib/libfaketime/man/faketime.1 @@ -0,0 +1,82 @@ +.TH FAKETIME "1" "November 2017" "faketime 0.9.7" wolfcw +.SH NAME +faketime \- manipulate the system time for a given command +.SH SYNOPSIS +.B faketime +\fI[options] timestamp program [arguments...]\fR +.SH DESCRIPTION +.\" \fIfaketime\fR will trick the given program into seeing the specified timestamp as its starting date and time. +.PP +The given command will be tricked into believing that the current system time is the one specified in the timestamp. Filesystem timestamps will also be +reported relative to this timestamp. The wall clock will continue to run from this date and time unless specified otherwise (see advanced options). +Actually, faketime is a simple wrapper for libfaketime, which uses the LD_PRELOAD mechanism to load a small library which intercepts system calls to +functions such as \fItime(2)\fR and \fIfstat(2)\fR. This wrapper exposes only a subset of libfaketime's functionality; please refer to the README file +that came with faketime for more details and advanced options, or have a look at http://github.com/wolfcw/libfaketime +.SH OPTIONS +.TP +\fB\-\-help\fR +show usage information and quit. +.TP +\fB\-\-version\fR +show version information and quit. +.TP +\fB\-m\fR +use the multi-threading variant of libfaketime. +.TP +\fB\-f\fR +use the advanced timestamp specification format. +.TP +\fB\--exclude-monotonic\fR +Do not fake time when the program makes a call to clock_gettime with a CLOCK_MONOTONIC clock. + +.SH EXAMPLES +.nf +faketime 'last Friday 5 pm' /bin/date +faketime '2008-12-24 08:15:42' /bin/date +faketime -f '+2,5y x10,0' /bin/bash -c 'date; while true; do echo $SECONDS ; sleep 1 ; done' +faketime -f '+2,5y x0,50' /bin/bash -c 'date; while true; do echo $SECONDS ; sleep 1 ; done' +faketime -f '+2,5y i2,0' /bin/bash -c 'while true; do date ; sleep 1 ; done' +In this single case all spawned processes will use the same global clock without restarting it at the start of each process. + +(Please note that it depends on your locale settings whether . or , has to be used for fractional offsets) +.fi +.SH ADVANCED TIMESTAMP FORMAT +The simple timestamp format used by default applies the \fB/bin/date -d\fR command to parse user-friendly specifications such as 'last friday'. When using +the faketime option \fB\-f\fR, the timestamp specified on the command line is directly passed to libfaketime, which enables a couple of additional features +such as speeding the clock up or slowing it down for the target program. It is strongly recommended that you have a look at the libfaketime documentation. Summary: +.TP +Freeze clock at absolute timestamp: \fB"YYYY-MM-DD hh:mm:ss"\fR +If you want to specify an absolute point in time, exactly this format must be used. Please note that freezing the clock is usually not what you want and may break the application. Only use if you know what you're doing! +.TP +Relative time offset: \fB"[+/-]123[m/h/d/y]\fR, e.g. "+60m", "+2y" +This is the most often used format and specifies the faked time relatively to the current real time. The first character of the format string \fBmust\fR be a + or a -. The numeric value by default represents seconds, but the modifiers m, h, d, and y can be used to specify minutes, hours, days, or years, respectively. For example, "-2y" means "two years ago". Fractional time offsets can be used, e.g. "+2,5y", which means "two and a half years in the future". Please note that the fraction delimiter depends on your locale settings, so if "+2,5y" does not work, you might want to try "+2.5y". +.TP +Start-at timestamps: \fB"@YYYY-MM-DD hh:mm:ss"\fR +The wall clock will start counting at the given timestamp for the program. This can be used for specifying absolute timestamps without freezing the clock. +.SH ADVANCED USAGE +When using relative time offsets or start-at timestamps (see ADVANCED TIMESTAMP FORMAT above and option \fB\-f\fR), the clock speed can be adjusted, i.e. time may run faster or slower for the executed program. For example, \fB"+5y x10"\fR will set the faked time 5 years into the future and make the time pass 10 times as fast (one real second equals 10 seconds measured by the program). Similarly, the flow of time can be slowed, e.g. using \fB"-7d x0,2"\fR, which will set the faked time 7 days in the past and set the clock speed to 20 percent, i.e. it takes five real world seconds for one second measured by the program. Again, depending on your locale, either "x2.0" or "x2,0" may be required regarding the delimiter. You can also make faketime to advance the reported time by a preset interval upon each time() call independently from the system's time using \fB"-7d i2,0"\fR, where +\fB"i"\fR is followed by the increase interval in seconds. +.PP +Faking times for multiple programs or even system-wide can be simplified by using ~/.faketimerc files and /etc/faketimerc. Please refer to the README that came with faketime for warnings and details. +.PP +Faking of filesystem timestamps may be disabled by setting the NO_FAKE_STAT environment variable to a non-empty value. +.SH AUTHOR +Please see the README and NEWS files for contributors. +.SH BUGS +Due to limitations of the LD_PRELOAD mechanism, faketime will not work with suidroot and statically linked programs. +While timestamps and time offsets will work for child processes, speeding the clock up or slowing it down might not +work for child processes spawned by the executed program as expected; a new instance of libfaketime is used for each +child process, which means that the libfaketime start time, which is used in speed adjustments, will also be +re-initialized. Some programs may dynamically load system libraries, such as librt, at run-time and therefore bypass libfaketime. You may report programs that do not work with libfaketime, but only if they are available as open source. +.SH "REPORTING BUGS" +Please use https://github.com/wolfcw/libfaketime/issues +.SH COPYRIGHT +Copyright \(co 2003-2013 by the libfaketime authors. +.PP +There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. You may redistribute copies of faketime under the +terms of the GNU General Public License. +.br +For more information about these matters, see the file named COPYING. +.SH "SEE ALSO" +ld.so(1), time(2), fstat(2) diff --git a/tests/deckard/contrib/libfaketime/packaging/Linux/Arch/PKGBUILD-32bit.txt b/tests/deckard/contrib/libfaketime/packaging/Linux/Arch/PKGBUILD-32bit.txt new file mode 100644 index 0000000..a87dc35 --- /dev/null +++ b/tests/deckard/contrib/libfaketime/packaging/Linux/Arch/PKGBUILD-32bit.txt @@ -0,0 +1,25 @@ +# Maintainer: Robert Orzanna <orschiro@gmail.com> + +_pkgbasename=libfaketime +pkgname=lib32-$_pkgbasename +pkgver=0.9.5 +pkgrel=1 +pkgdesc='Report fake dates and times to programs without having to change the system-wide time.' +arch=('x86_64') +url='http://www.code-wizards.com/projects/libfaketime/' +license=('GPL2') +source=("http://www.code-wizards.com/projects/${_pkgbasename}/${_pkgbasename}-${pkgver}.tar.gz" + 'lib32.patch') +md5sums=('89b5c71e6c6a93b1c6feba374ac37719' + '0a01f842df4c8acbd2b081be046e8d67') + +build() { + cd "${_pkgbasename}-${pkgver}" + patch -p1 -i ../lib32.patch + make +} + +package() { + cd "${_pkgbasename}-${pkgver}" + make PREFIX=/usr DESTDIR="${pkgdir}" install +}
\ No newline at end of file diff --git a/tests/deckard/contrib/libfaketime/packaging/Linux/Debian/avoid-spurious-lrt.patch b/tests/deckard/contrib/libfaketime/packaging/Linux/Debian/avoid-spurious-lrt.patch new file mode 100644 index 0000000..c2f3f3f --- /dev/null +++ b/tests/deckard/contrib/libfaketime/packaging/Linux/Debian/avoid-spurious-lrt.patch @@ -0,0 +1,30 @@ +Author: Daniel Kahn Gillmor <dkg@fifthhorseman.net> + +On i386 systems, for some reason if i do not clean up this extra -lrt, i get the following error: + + [...] +make[1]: Entering directory `/home/dkg/src/faketime/faketime/src' +cc -o libfaketime.o -c -g -O2 -fstack-protector --param=ssp-buffer-size=4 -Wformat -Werror=format-security -std=gnu99 -Wall -Wextra -Werror -DFAKE_STAT -DFAKE_SLEEP -DFAKE_TIMERS -DFAKE_INTERNAL_CALLS -fPIC -DPREFIX='"'/usr/local'"' -DLIBDIRNAME='"'/lib/faketime'"' -DMULTI_ARCH libfaketime.c +cc -o libfaketime.so.1 -Wl,-soname,libfaketime.so.1 -Wl,-z,relro -Wl,--version-script=libfaketime.map -lrt -shared libfaketime.o -ldl -lm -lpthread -lrt +libfaketime.o: In function `ft_cleanup': +/home/dkg/src/faketime/faketime/src/libfaketime.c:1277: multiple definition of `timer_gettime' +/home/dkg/src/faketime/faketime/src/libfaketime.c:1277: multiple definition of `timer_settime' +collect2: error: ld returned 1 exit status +make[1]: *** [libfaketime.so.1] Error 1 + [...] + +I confess i don't really understand why removing this would fix +things, but i also don't see the need to have multiple attempts to +link to librt. + +--- a/src/Makefile ++++ b/src/Makefile +@@ -69,7 +69,7 @@ + + CFLAGS += -std=gnu99 -Wall -Wextra -Werror -DFAKE_STAT -DFAKE_SLEEP -DFAKE_TIMERS -DFAKE_INTERNAL_CALLS -fPIC -DPREFIX='"'$(PREFIX)'"' -DLIBDIRNAME='"'$(LIBDIRNAME)'"' + LIB_LDFLAGS += -shared +-LDFLAGS += -Wl,--version-script=libfaketime.map -lrt ++LDFLAGS += -Wl,--version-script=libfaketime.map + LDADD += -ldl -lm -lpthread -lrt + + SRC = libfaketime.c diff --git a/tests/deckard/contrib/libfaketime/packaging/Linux/Debian/control b/tests/deckard/contrib/libfaketime/packaging/Linux/Debian/control new file mode 100644 index 0000000..e8291a8 --- /dev/null +++ b/tests/deckard/contrib/libfaketime/packaging/Linux/Debian/control @@ -0,0 +1,40 @@ +Source: faketime +Section: utils +Priority: extra +Maintainer: Daniel Kahn Gillmor <dkg@fifthhorseman.net> +Build-Depends: + debhelper (>= 9), + dh-exec (>= 0.3) +Standards-Version: 3.9.4 +Homepage: http://www.code-wizards.com/projects/libfaketime/ +Vcs-Browser: http://anonscm.debian.org/gitweb/?p=collab-maint/faketime.git +Vcs-Git: git://anonscm.debian.org/collab-maint/faketime.git + +Package: faketime +Architecture: any +Pre-Depends: multiarch-support +Depends: ${shlibs:Depends}, ${misc:Depends}, libfaketime (= ${binary:Version}) +Multi-Arch: foreign +Description: report faked system time to programs + The Fake Time Preload Library (FTPL, a.k.a. libfaketime) intercepts + various system calls which programs use to retrieve the current date + and time. It can then report faked dates and times (as specified by + you, the user) to these programs. This means you can modify the + system time a program sees without having to change the time + system-wide. FTPL allows you to specify both absolute dates (e.g., + 2004-01-01) and relative dates (e.g., 10 days ago). + +Package: libfaketime +Architecture: any +Pre-Depends: multiarch-support +Multi-Arch: same +Depends: ${shlibs:Depends}, ${misc:Depends} +Description: report faked system time to programs + The Fake Time Preload Library (FTPL, a.k.a. libfaketime) intercepts + various system calls which programs use to retrieve the current date + and time. It can then report faked dates and times (as specified by + you, the user) to these programs. This means you can modify the + system time a program sees without having to change the time + system-wide. FTPL allows you to specify both absolute dates (e.g., + 2004-01-01) and relative dates (e.g., 10 days ago). + diff --git a/tests/deckard/contrib/libfaketime/packaging/Linux/Debian/fix-infinite-recursion-on-real_clock_gettime.patch b/tests/deckard/contrib/libfaketime/packaging/Linux/Debian/fix-infinite-recursion-on-real_clock_gettime.patch new file mode 100644 index 0000000..2fd64f5 --- /dev/null +++ b/tests/deckard/contrib/libfaketime/packaging/Linux/Debian/fix-infinite-recursion-on-real_clock_gettime.patch @@ -0,0 +1,29 @@ +From: Gerardo Malazdrewicz <gerardo@malazdrewicz.com.ar> +To: 699559@bugs.debian.org +Subject: Avoiding loop (very dirty patch) +Date: Tue, 26 Mar 2013 01:18:05 +0100 + +[Message part 1 (text/plain, inline)] + +Attached patch works for me, but it is very very dirty. + +Possibly side effects. + +Alternative seems to be to protect the call to real_clock_gettime so it is +executed just once (to validate the parameters). Subsequent calls are not +needed (parameters have been validated). + +Thanks, + Gerardo + +--- a/src/libfaketime.c ++++ b/src/libfaketime.c +@@ -1380,7 +1380,7 @@ void __attribute__ ((constructor)) ftpl_init(void) + real_clock_get_time = dlsym(RTLD_NEXT, "clock_get_time"); + real_clock_gettime = apple_clock_gettime; + #else +- real_clock_gettime = dlsym(RTLD_NEXT, "clock_gettime"); ++ real_clock_gettime = dlsym(RTLD_NEXT, "__clock_gettime"); + #ifdef FAKE_TIMERS + real_timer_settime_22 = dlvsym(RTLD_NEXT, "timer_settime","GLIBC_2.2"); + real_timer_settime_233 = dlvsym(RTLD_NEXT, "timer_settime","GLIBC_2.3.3"); diff --git a/tests/deckard/contrib/libfaketime/packaging/Linux/Debian/libfaketime.install b/tests/deckard/contrib/libfaketime/packaging/Linux/Debian/libfaketime.install new file mode 100755 index 0000000..0c2fb6b --- /dev/null +++ b/tests/deckard/contrib/libfaketime/packaging/Linux/Debian/libfaketime.install @@ -0,0 +1,3 @@ +#!/usr/bin/dh-exec +src/libfaketime.so.1 usr/lib/${DEB_HOST_MULTIARCH}/faketime/ +src/libfaketimeMT.so.1 usr/lib/${DEB_HOST_MULTIARCH}/faketime/ diff --git a/tests/deckard/contrib/libfaketime/packaging/Linux/Debian/rules b/tests/deckard/contrib/libfaketime/packaging/Linux/Debian/rules new file mode 100755 index 0000000..cf3813a --- /dev/null +++ b/tests/deckard/contrib/libfaketime/packaging/Linux/Debian/rules @@ -0,0 +1,17 @@ +#!/usr/bin/make -f + +# Author: Daniel Kahn Gillmor <dkg@fifthhorseman.net> +# Date: Tue, 26 Aug 2008 14:24:50 -0400 + +export DEB_CFLAGS_MAINT_APPEND=-DMULTI_ARCH + +# make sure dh_makeshlibs does not modify post{inst,rm} scripts: +# (avoids lintian's postinst-has-useless-call-to-ldconfig) +override_dh_makeshlibs: + dh_makeshlibs --noscripts + +override_dh_installchangelogs: + dh_installchangelogs NEWS + +%: + PREFIX=/usr dh $@ diff --git a/tests/deckard/contrib/libfaketime/packaging/Linux/Redhat/libfaketime-fix-infinite-recursion-on-real_clock_gettime.patch b/tests/deckard/contrib/libfaketime/packaging/Linux/Redhat/libfaketime-fix-infinite-recursion-on-real_clock_gettime.patch new file mode 100644 index 0000000..9d81e5e --- /dev/null +++ b/tests/deckard/contrib/libfaketime/packaging/Linux/Redhat/libfaketime-fix-infinite-recursion-on-real_clock_gettime.patch @@ -0,0 +1,13 @@ +diff --git a/src/libfaketime.c b/src/libfaketime.c +index 3ec372b..f70283b 100644 +--- a/src/libfaketime.c ++++ b/src/libfaketime.c +@@ -1380,7 +1380,7 @@ void __attribute__ ((constructor)) ftpl_init(void) + real_clock_get_time = dlsym(RTLD_NEXT, "clock_get_time"); + real_clock_gettime = apple_clock_gettime; + #else +- real_clock_gettime = dlsym(RTLD_NEXT, "clock_gettime"); ++ real_clock_gettime = dlsym(RTLD_NEXT, "__clock_gettime"); + #ifdef FAKE_TIMERS + real_timer_settime_22 = dlvsym(RTLD_NEXT, "timer_settime","GLIBC_2.2"); + real_timer_settime_233 = dlvsym(RTLD_NEXT, "timer_settime","GLIBC_2.3.3"); diff --git a/tests/deckard/contrib/libfaketime/packaging/Linux/Redhat/libfaketime.spec.txt b/tests/deckard/contrib/libfaketime/packaging/Linux/Redhat/libfaketime.spec.txt new file mode 100644 index 0000000..48f3305 --- /dev/null +++ b/tests/deckard/contrib/libfaketime/packaging/Linux/Redhat/libfaketime.spec.txt @@ -0,0 +1,55 @@ +Summary: Manipulate system time per process for testing purposes +Name: libfaketime +Version: 0.9.5 +Release: 4%{?dist} +License: GPLv2+ +Url: http://www.code-wizards.com/projects/%{name}/ +Source: http://www.code-wizards.com/projects/%{name}/%{name}-%{version}.tar.gz +Group: System Environment/Libraries +Patch1: libfaketime-0.9.5-fix-infinite-recursion-on-real_clock_gettime.patch + +%description +libfaketime intercepts various system calls which programs use to +retrieve the current date and time. It can then report faked dates and +times (as specified by you, the user) to these programs. This means you +can modify the system time a program sees without having to change the +time system- wide. + +%prep +%setup -q +%patch1 -p1 +# work around from upstream for autodetecting glibc version bug on i686 +sed -i -e 's/__asm__(".symver timer_gettime_22/\/\/__asm__(".symver timer_gettime_22/' src/libfaketime.c +sed -i -e 's/__asm__(".symver timer_settime_22/\/\/__asm__(".symver timer_settime_22/' src/libfaketime.c + + +%build +cd src ; CFLAGS="$RPM_OPT_FLAGS -Wno-strict-aliasing" make %{?_smp_mflags} \ + PREFIX="%{_prefix}" LIBDIRNAME="/%{_lib}/faketime" all + +%check +make %{?_smp_mflags} -C test all + +%install +make PREFIX="%{_prefix}" DESTDIR=%{buildroot} LIBDIRNAME="/%{_lib}/faketime" install +rm -r %{buildroot}/%{_docdir}/faketime + +%files +%{_bindir}/faketime +%{_libdir}/faketime/libfaketime*so.* +%doc README COPYING NEWS README README.developers +%{_mandir}/man1/* + +%changelog +* Tue Oct 15 2013 Paul Wouters <pwouters@redhat.com> - 0.9.5-4 +- Infinite recursion patch is still needed, make test causes + segfaults otherwise. + +* Mon Oct 14 2013 Paul Wouters <pwouters@redhat.com> - 0.9.5-3 +- Work around from upstream for autodetecting glibc version bug on i686 + +* Mon Oct 14 2013 Paul Wouters <pwouters@redhat.com> - 0.9.5-2 +- Remove use of ifarch for _lib macro for multilib + +* Sun Oct 13 2013 Paul Wouters <pwouters@redhat.com> - 0.9.5-1 +- Initial package diff --git a/tests/deckard/contrib/libfaketime/packaging/OSX/Fink/libfaketime.info b/tests/deckard/contrib/libfaketime/packaging/OSX/Fink/libfaketime.info new file mode 100644 index 0000000..9f1b3ba --- /dev/null +++ b/tests/deckard/contrib/libfaketime/packaging/OSX/Fink/libfaketime.info @@ -0,0 +1,53 @@ +Package: libfaketime +Version: 0.9.7 +Revision: 1 + +Source: http://www.code-wizards.com/projects/%n/%n-%v.tar.gz +Source-MD5: 8617e2c6caf0977b3ce9a271f867302c + +Maintainer: Wolfgang Hommel <wolf@fink.code-wizards.com> +HomePage: https://github.com/wolfcw/libfaketime +License: GPL + +Description: Modify system time for single applications + +DescDetail: << +libfaketime is a library that is dynamically linked to applications +or system commands at run-time by using the DYLD_INSERT_LIBRARIES +mechanism. It then intercepts various system calls, which programs +use to retrieve the current date and time. libfaketime can then +report faked dates and times to these programs. This means you can +modify the system time a program uses without having to change the +date and time system-wide. +<< + +DescUsage: << +libfaketime includes a simple wrapper called faketime. Run the +command faketime without any parameters for usage information. +For information on how to use libfaketime without the wrapper +and access its full raw functionality, please see +%p/share/doc/libfaketime/README* +<< + +BuildDepends: fink (>= 0.28) +Distribution: 10.7, 10.8, 10.9, 10.10, 10.11, 10.12 + +CompileScript: << +#! /bin/sh -ev +make -f Makefile.OSX -C src PREFIX=%{p} +<< + +InfoTest: << + TestScript: make -f Makefile.OSX test || exit 2 +<< + +InstallScript: << +#! /bin/sh -ev +make -f Makefile.OSX -C src install PREFIX=%{i} +<< + +DocFiles: COPYING README README.OSX + +Shlibs: << + !%p/lib/faketime/%N.1.dylib +<< diff --git a/tests/deckard/contrib/libfaketime/packaging/OSX/Homebrew/libfaketime.rb b/tests/deckard/contrib/libfaketime/packaging/OSX/Homebrew/libfaketime.rb new file mode 100644 index 0000000..8d92b76 --- /dev/null +++ b/tests/deckard/contrib/libfaketime/packaging/OSX/Homebrew/libfaketime.rb @@ -0,0 +1,21 @@ +require 'formula' + +class Libfaketime < Formula + homepage 'https://github.com/wolfcw/libfaketime' + url 'https://github.com/wolfcw/libfaketime/archive/v0.9.7.tar.gz' + sha1 'eb1cbacf548aefa36214bea1345f35b8763027a1' + + depends_on :macos => :sierra + + fails_with :llvm do + build 2336 + cause 'No thread local storage support' + end + + def install + system "make", "-C", "src", "-f", "Makefile.OSX", "PREFIX=#{prefix}" + bin.install 'src/faketime' + (lib/'faketime').install 'src/libfaketime.1.dylib' + man1.install 'man/faketime.1' + end +end diff --git a/tests/deckard/contrib/libfaketime/packaging/OSX/MacPorts/Portfile b/tests/deckard/contrib/libfaketime/packaging/OSX/MacPorts/Portfile new file mode 100644 index 0000000..d4104ad --- /dev/null +++ b/tests/deckard/contrib/libfaketime/packaging/OSX/MacPorts/Portfile @@ -0,0 +1,45 @@ +# -*- coding: utf-8; mode: tcl; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- vim:fenc=utf-8:ft=tcl:et:sw=4:ts=4:sts=4 +# $Id: Portfile 112093 2013-10-11 19:57:13Z ryandesign@macports.org $ + +PortSystem 1.0 +PortGroup github 1.0 + +github.setup wolfcw libfaketime 0.9.7 v + +checksums rmd160 8874d43bb212976d929c3007db0cf978311b3596 \ + sha256 4d65f368b2d53ee2f93a25d5e9541ce27357f2b95e5e5afff210e0805042811e + +categories sysutils +platforms darwin +maintainers code-wizards.com:wolf openmaintainer +license GPL-2 + +description libfaketime modifies the system time for a single application + +long_description libfaketime intercepts various system calls that applications use to \ + retrieve the current date and time. It can then report user-specified \ + faked dates and times to these applications. This allows us to modify \ + the system time an application sees without having to change the time \ + system-wide. The faketime wrapper can be used from command line. \ + Check the documentation on how to integrate into installed applications. + +patchfiles patch-test-Makefile.OSX.diff + +use_configure no + +variant universal {} + +compiler.blacklist *cc* *dragonegg* + +build.args -f Makefile.OSX +build.env CC="${configure.cc}" \ + CFLAGS="[get_canonical_archflags cc]" \ + LDFLAGS="[get_canonical_archflags ld]" \ + PREFIX=${prefix} + +test.run yes +test.args ${build.args} +eval test.env ${build.env} + +destroot.args ${build.args} +eval destroot.env ${build.env} diff --git a/tests/deckard/contrib/libfaketime/packaging/OSX/MacPorts/patch-test-Makefile.OSX.diff b/tests/deckard/contrib/libfaketime/packaging/OSX/MacPorts/patch-test-Makefile.OSX.diff new file mode 100644 index 0000000..f60968a --- /dev/null +++ b/tests/deckard/contrib/libfaketime/packaging/OSX/MacPorts/patch-test-Makefile.OSX.diff @@ -0,0 +1,12 @@ +--- test/Makefile.OSX.orig 2013-10-11 09:42:38.000000000 -0500 ++++ test/Makefile.OSX 2013-10-11 14:46:11.000000000 -0500 +@@ -1,7 +1,6 @@ +-CC = gcc ++CC ?= clang + +-CFLAGS = -std=gnu99 -Wall -DFAKE_STAT +-LDFLAGS = ++CFLAGS += -std=gnu99 -Wall -DFAKE_STAT + + SRC = timetest.c + OBJ = ${SRC:.c=.o} diff --git a/tests/deckard/contrib/libfaketime/packaging/OSX/README b/tests/deckard/contrib/libfaketime/packaging/OSX/README new file mode 100644 index 0000000..03b43fa --- /dev/null +++ b/tests/deckard/contrib/libfaketime/packaging/OSX/README @@ -0,0 +1,65 @@ +# Packaging for OS X + +Several software tools assist with the installation of open source software +on OS X. The authors of libfaketime maintain the libfaketime build spec files +for MacPorts, Homebrew, and Fink. + + +## MacPorts + +Installing libfaketime via MacPorts is based on the provided Portfile, which +has been included in the official MacPorts distribution since October, 2013. +Users therefore can use "sudo port install libfaketime" as installation +command. + +Some libfaketime Portfile caveats: + +- Github-based source file distribution +- Non-clang-compilers need to be blacklisted +- MacPorts folks have requested to avoid a platform-specific Makefile.OSX in + the future + +Portfile submission is documented in https://www.macports.org/guide/#project.contributing +and handled via a ticketing system: + +- https://trac.macports.org/ticket/40662 +- https://trac.macports.org/ticket/40748 + + +## Homebrew + +The libfaketime 'formula' for Homebrew is available since November, 2013. +Homebrew users can use 'brew install libfaketime' as installation command. + +Some libfaketime formula caveats: + +- "depends_on :macos => :lion" must be set for libfaketime >=0.9.5 +- :llvm builds <= 2336 must be blacklisted because libfaketime =0.9.5 + requires a compiler with thread local storage support. + +Formula submission is handled via pull request on Github following the +"one formula per commit, one commit per formula" rule, which necessitates +squashing commits and forced pushes when applying fixes. Style issues +complementary to the documentation have been discussed in + + https://github.com/mxcl/homebrew/pull/23245 + + +## Fink + +A libfaketime.info file is included in the Fink 10.7 tree since October, +2013, and installed using + + fink install libfaketime + +Some libfaketime fink info file caveats: + +- The dynamic library must be declared as private Shlib; this also necessitates + BuildDepends: fink (>= 0.28) +- "Distribution: 10.7, 10.8, 10.9" is required because libfaketime >=0.9.5 does + not work on OS X 10.6 or before anymore. +- When compiling, PREFIX=%{p} needs to be used because this path is hardcoded + into the wrapper. However, "make install" needs to deploy into PREFIX=%{i} to + make packaging work. + +Submission is via https://sourceforge.net/p/fink/package-submissions/ diff --git a/tests/deckard/contrib/libfaketime/packaging/README b/tests/deckard/contrib/libfaketime/packaging/README new file mode 100644 index 0000000..7dc6152 --- /dev/null +++ b/tests/deckard/contrib/libfaketime/packaging/README @@ -0,0 +1,14 @@ +# libfaketime packaging + +Not everyone feels comfortable with installing tools and libraries manually +by downloading and building them from source. Luckily enough, voluntary +maintainers prepare new libfaketime releases for various platforms and make +them available as binary packages or otherwise automatically installable +software. + +In this directory, we collect build specification files for the platforms +that we are aware of being actively supported. They help us to analyze +build issues, create awareness for platform-specific patches that had to +be applied and might be merged with our code, and provide the contact +information for future "early release warnings". + diff --git a/tests/deckard/contrib/libfaketime/src/Makefile b/tests/deckard/contrib/libfaketime/src/Makefile new file mode 100644 index 0000000..e2f047a --- /dev/null +++ b/tests/deckard/contrib/libfaketime/src/Makefile @@ -0,0 +1,118 @@ +# +# Notes: +# +# * Compilation Defines: +# +# FAKE_STAT +# - Enables time faking also for files' timestamps. +# +# NO_ATFILE +# - Disables support for the fstatat() group of functions +# +# PTHREAD_SINGLETHREADED_TIME +# - Define this if you want to single-thread time() ... there ARE +# possible caching side-effects in a multithreaded environment +# without this, but the performance impact may require you to +# try it unsynchronized. +# +# FAKE_INTERNAL_CALLS +# - Also intercept libc internal __functions, e.g. not just time(), +# but also __time(). Enhances compatibility with applications +# that make use of low-level system calls, such as Java Virtual +# Machines. +# +# FAKE_SLEEP +# - Also intercept sleep(), nanosleep(), usleep(), alarm(), [p]poll() +# +# FAKE_TIMERS +# - Also intercept timer_settime() and timer_gettime() +# +# FAKE_PTHREAD +# - Intercept pthread_cond_timedwait +# +# MULTI_ARCH +# - If MULTI_ARCH is set, the faketime wrapper program will put a literal +# $LIB into the LD_PRELOAD environment variable it creates, which makes +# ld automatically choose the correct library version to use for the +# target binary. Use for Linux platforms with Multi-Arch support only! +# +# * Compilation addition: second libMT target added for building the pthread- +# enabled library as a separate library +# +# * Compilation switch change: previous versions compiled using '-nostartfiles' +# This is no longer the case since there is a 'startup' constructor for the library +# which is used to activate the start-at times when specified. This also initializes +# the dynamic disabling of the FAKE_STAT calls. +# +# By default, libfaketime will be compiled for your system's default architecture. +# To build 32-bit libraries and binaries, add -m32 to CFLAGS and LDFLAGS. +# +# Change PREFIX to where you want libfaketime (libraries and wrapper binary) installed. +# LIBDIRNAME is relative to PREFIX. The default is to install into $PREFIX/lib/faketime, +# but you can set LIBDIRNAME to, e.g., /lib64 if you want to install it elsewhere. +# LIBDIRNAME has been introduced to support MultiLib systems. Please do not change the +# default value on MultiArch systems. +# +# For testing in the current directory without installation, try make PREFIX= LIBDIRNAME='.' + +CC ?= gcc +INSTALL ?= install + +PREFIX ?= /usr/local +LIBDIRNAME ?= /lib/faketime +PLATFORM ?=$(shell uname) + +CFLAGS += -std=gnu99 -Wall -Wextra -Werror -Wno-nonnull-compare -DFAKE_PTHREAD -DFAKE_STAT -DFAKE_SLEEP -DFAKE_TIMERS -DFAKE_INTERNAL_CALLS -fPIC -DPREFIX='"'$(PREFIX)'"' -DLIBDIRNAME='"'$(LIBDIRNAME)'"' +ifeq ($(PLATFORM),SunOS) +CFLAGS += -D__EXTENSIONS__ -D_XOPEN_SOURCE=600 +endif + +LIB_LDFLAGS += -shared + +LDFLAGS += -lpthread +ifneq ($(PLATFORM),SunOS) +LDFLAGS += -Wl,--version-script=libfaketime.map +endif + +LDADD += -ldl -lm -lrt +BIN_LDFLAGS += -lrt + +SRC = libfaketime.c +LIBS_OBJ = libfaketime.o libfaketimeMT.o +BINS = faketime + +SONAME = 1 +LIBS = libfaketime.so.${SONAME} libfaketimeMT.so.${SONAME} + +all: ${LIBS} ${BINS} + +libfaketimeMT.o: EXTRA_FLAGS := -DPTHREAD_SINGLETHREADED_TIME + +${LIBS_OBJ}: libfaketime.c + ${CC} -o $@ -c ${CFLAGS} ${CPPFLAGS} ${EXTRA_FLAGS} $< + +%.so.${SONAME}: %.o libfaketime.map + ${CC} -o $@ -Wl,-soname,$@ ${LDFLAGS} ${LIB_LDFLAGS} $< ${LDADD} + +${BINS}: faketime.c + ${CC} -o $@ ${CFLAGS} ${CPPFLAGS} ${EXTRA_FLAGS} $< ${LDFLAGS} ${BIN_LDFLAGS} + +clean: + @rm -f ${LIBS_OBJ} ${LIBS} ${BINS} + +distclean: clean + @echo + +install: ${LIBS} ${BINS} + @echo + @echo "Copying the faketime libraries to ${DESTDIR}${PREFIX}${LIBDIRNAME} and the faketime wrapper script to ${DESTDIR}${PREFIX}/bin ..." + $(INSTALL) -dm0755 "${DESTDIR}${PREFIX}${LIBDIRNAME}/" + $(INSTALL) -m0644 ${LIBS} "${DESTDIR}${PREFIX}${LIBDIRNAME}/" + $(INSTALL) -Dm0755 faketime "${DESTDIR}${PREFIX}/bin/faketime" + +uninstall: + for f in ${LIBS}; do rm -f "${DESTDIR}${PREFIX}${LIBDIRNAME}/$$f"; done + rmdir "${DESTDIR}${PREFIX}${LIBDIRNAME}" + rm -f "${DESTDIR}${PREFIX}/bin/faketime" + +.PHONY: all clean distclean install uninstall diff --git a/tests/deckard/contrib/libfaketime/src/Makefile.OSX b/tests/deckard/contrib/libfaketime/src/Makefile.OSX new file mode 100644 index 0000000..683ad04 --- /dev/null +++ b/tests/deckard/contrib/libfaketime/src/Makefile.OSX @@ -0,0 +1,75 @@ +# +# Notes: +# +# * Compilation Defines: +# +# FAKE_STAT +# - Enables time faking also for files' timestamps. +# +# NO_ATFILE +# - Disables support for the fstatat() group of functions +# +# PTHREAD +# - Define this to enable multithreading support. +# +# PTHREAD_SINGLETHREADED_TIME +# - Define this if you want to single-thread time() ... there ARE +# possible caching side-effects in a multithreaded environment +# without this, but the performance impact may require you to +# try it unsynchronized. +# +# FAKE_SLEEP +# - Also intercept sleep(), nanosleep(), usleep(), alarm(), [p]poll() +# +# * Compilation addition: second libMT target added for building the pthread- +# enabled library as a separate library +# +# * Compilation switch change: previous versions compiled using '-nostartfiles' +# This is no longer the case since there is a 'startup' constructor for the library +# which is used to activate the start-at times when specified. This also initializes +# the dynamic disabling of the FAKE_STAT calls. +# +# By default, libfaketime will be compiled for your system's default architecture. +# To build for a different architecture, add -arch flags to CFLAGS and LDFLAGS. +# +# default to clang to support thread local variables +CC ?= clang +INSTALL ?= install + +PREFIX ?= /usr/local + +CFLAGS += -DFAKE_SLEEP -DFAKE_INTERNAL_CALLS -DPREFIX='"'${PREFIX}'"' +LIB_LDFLAGS += -dynamiclib -current_version 0.9.7 -compatibility_version 0.7 + +SONAME = 1 +LIBS = libfaketime.${SONAME}.dylib +BINS = faketime + +all: ${LIBS} ${BINS} + +libfaketime.${SONAME}.dylib: libfaketime.c + ${CC} -o $@ ${CFLAGS} ${LDFLAGS} ${LIB_LDFLAGS} -install_name ${PREFIX}/lib/faketime/$@ $< + +faketime: faketime.c + ${CC} -o $@ ${CFLAGS} ${LDFLAGS} $< + +clean: + @rm -f ${OBJ} ${LIBS} ${BINS} + +distclean: clean + @echo + +install: ${LIBS} ${BINS} + @echo + @echo "Copying the faketime libraries to ${DESTDIR}${PREFIX}/lib/faketime and the faketime wrapper script to ${DESTDIR}${PREFIX}/bin ..." + $(INSTALL) -dm0755 "${DESTDIR}${PREFIX}/lib/faketime/" + $(INSTALL) -m0644 ${LIBS} "${DESTDIR}${PREFIX}/lib/faketime/" + $(INSTALL) -dm0755 "${DESTDIR}${PREFIX}/bin" + $(INSTALL) -m0755 faketime "${DESTDIR}${PREFIX}/bin/faketime" + +uninstall: + for f in ${LIBS}; do rm -f "${DESTDIR}${PREFIX}/lib/faketime/$$f"; done + rmdir "${DESTDIR}${PREFIX}/lib/faketime" + rm -f "${DESTDIR}${PREFIX}/bin/faketime" + +.PHONY: all clean distclean install uninstall diff --git a/tests/deckard/contrib/libfaketime/src/faketime.c b/tests/deckard/contrib/libfaketime/src/faketime.c new file mode 100644 index 0000000..037d749 --- /dev/null +++ b/tests/deckard/contrib/libfaketime/src/faketime.c @@ -0,0 +1,385 @@ +/* + * libfaketime wrapper command + * + * This file is part of libfaketime, version 0.9.7 + * + * libfaketime is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License v2 as published by the + * Free Software Foundation. + * + * libfaketime 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 v2 along + * with the libfaketime; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Converted from shell script by Balint Reczey with the following credits + * and comments: + * + * Thanks to Daniel Kahn Gillmor for improvement suggestions. + + * This wrapper exposes only a small subset of the libfaketime functionality. + * Please see libfaketime's README file and man page for more details. + + * Acknowledgment: Parts of the functionality of this wrapper have been + * inspired by Matthias Urlichs' datefudge 1.14. + + * Compile time configuration: Path where the libfaketime libraries can be found + * on Linux/UNIX + * + */ + +#include <stdio.h> +#include <unistd.h> +#include <stdlib.h> +#include <stdbool.h> +#include <stdint.h> +#include <string.h> +#include <time.h> +#include <fcntl.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <sys/wait.h> +#include <sys/mman.h> +#include <semaphore.h> + +#include "faketime_common.h" + +const char version[] = "0.9.7"; + +#ifdef __APPLE__ +static const char *date_cmd = "gdate"; +#else +static const char *date_cmd = "date"; +#endif + +#define PATH_BUFSIZE 4096 + +/* semaphore and shared memory names */ +char sem_name[PATH_BUFSIZE] = {0}, shm_name[PATH_BUFSIZE] = {0}; + +void usage(const char *name) +{ + printf("\n" + "Usage: %s [switches] <timestamp> <program with arguments>\n" + "\n" + "This will run the specified 'program' with the given 'arguments'.\n" + "The program will be tricked into seeing the given 'timestamp' as its starting date and time.\n" + "The clock will continue to run from this timestamp. Please see the manpage (man faketime)\n" + "for advanced options, such as stopping the wall clock and make it run faster or slower.\n" + "\n" + "The optional switches are:\n" + " -m : Use the multi-threaded version of libfaketime\n" + " -f : Use the advanced timestamp specification format (see manpage)\n" + " --exclude-monotonic : Prevent monotonic clock from drifting (not the raw monotonic one)\n" + "\n" + "Examples:\n" + "%s 'last friday 5 pm' /bin/date\n" + "%s '2008-12-24 08:15:42' /bin/date\n" + "%s -f '+2,5y x10,0' /bin/bash -c 'date; while true; do echo $SECONDS ; sleep 1 ; done'\n" + "%s -f '+2,5y x0,50' /bin/bash -c 'date; while true; do echo $SECONDS ; sleep 1 ; done'\n" + "%s -f '+2,5y i2,0' /bin/bash -c 'date; while true; do date; sleep 1 ; done'\n" + "In this single case all spawned processes will use the same global clock\n" + "without restarting it at the start of each process.\n\n" + "(Please note that it depends on your locale settings whether . or , has to be used for fractions)\n" + "\n", name, name, name, name, name, name); +} + +/** Clean up shared objects */ +static void cleanup_shobjs() +{ + if (-1 == sem_unlink(sem_name)) + { + perror("sem_unlink"); + } + if (-1 == shm_unlink(shm_name)) + { + perror("shm_unlink"); + } +} + +int main (int argc, char **argv) +{ + pid_t child_pid; + int curr_opt = 1; + bool use_mt = false, use_direct = false; + long offset; + + while(curr_opt < argc) + { + if (0 == strcmp(argv[curr_opt], "-m")) + { + use_mt = true; + curr_opt++; + continue; + } + else if (0 == strcmp(argv[curr_opt], "-f")) + { + use_direct = true; + curr_opt++; + continue; + } + else if (0 == strcmp(argv[curr_opt], "--exclude-monotonic")) + { + setenv("DONT_FAKE_MONOTONIC", "1", true); + curr_opt++; + continue; + } + else if ((0 == strcmp(argv[curr_opt], "-v")) || + (0 == strcmp(argv[curr_opt], "--version"))) + { + printf("\n%s: Version %s\n" + "For usage information please use '%s --help'.\n", + argv[0], version, argv[0]); + exit(EXIT_SUCCESS); + } + else if ((0 == strcmp(argv[curr_opt], "-h")) || + (0 == strcmp(argv[curr_opt], "-?")) || + (0 == strcmp(argv[curr_opt], "--help"))) + { + usage(argv[0]); + exit(EXIT_SUCCESS); + } + else + { + /* we parsed all options */ + break; + } + } + + /* we need at least a timestamp string and a command to run */ + if (argc - curr_opt < 2) + { + usage(argv[0]); + exit(EXIT_FAILURE); + } + + if (!use_direct) + { + // TODO get seconds + int pfds[2]; + (void) (pipe(pfds) + 1); + int ret = EXIT_SUCCESS; + + if (0 == (child_pid = fork())) + { + close(1); /* close normal stdout */ + (void) (dup(pfds[1]) + 1); /* make stdout same as pfds[1] */ + close(pfds[0]); /* we don't need this */ + if (EXIT_SUCCESS != execlp(date_cmd, date_cmd, "-d", argv[curr_opt], "+%s",(char *) NULL)) + { + perror("Running (g)date failed"); + exit(EXIT_FAILURE); + } + } + else + { + char buf[256] = {0}; /* e will have way less than 256 digits */ + close(pfds[1]); /* we won't write to this */ + (void) (read(pfds[0], buf, 256) + 1); + waitpid(child_pid, &ret, 0); + if (ret != EXIT_SUCCESS) + { + printf("Error: Timestamp to fake not recognized, please re-try with a " + "different timestamp.\n"); + exit(EXIT_FAILURE); + } + offset = atol(buf) - time(NULL); + ret = snprintf(buf, sizeof(buf), "%s%ld", (offset >= 0)?"+":"", offset); + setenv("FAKETIME", buf, true); + close(pfds[0]); /* finished reading */ + } + } + else + { + /* simply pass format string along */ + setenv("FAKETIME", argv[curr_opt], true); + } + int keepalive_fds[2]; + (void) (pipe(keepalive_fds) + 1); + + /* we just consumed the timestamp option */ + curr_opt++; + + { + /* create semaphores and shared memory */ + int shm_fd; + sem_t *sem; + struct ft_shared_s *ft_shared; + char shared_objs[PATH_BUFSIZE * 2 + 1]; + + /* + * Casting of getpid() return value to long needed to make GCC on SmartOS + * happy, since getpid's return value's type on SmartOS is long. Since + * getpid's return value's type is int on most other systems, and that + * sizeof(long) always >= sizeof(int), this works on all platforms without + * the need for crazy #ifdefs. + */ + snprintf(sem_name, PATH_BUFSIZE -1 ,"/faketime_sem_%ld", (long)getpid()); + snprintf(shm_name, PATH_BUFSIZE -1 ,"/faketime_shm_%ld", (long)getpid()); + + if (SEM_FAILED == (sem = sem_open(sem_name, O_CREAT|O_EXCL, S_IWUSR|S_IRUSR, 1))) + { + perror("sem_open"); + exit(EXIT_FAILURE); + } + + /* create shm */ + if (-1 == (shm_fd = shm_open(shm_name, O_CREAT|O_EXCL|O_RDWR, S_IWUSR|S_IRUSR))) + { + perror("shm_open"); + if (-1 == sem_unlink(argv[2])) + { + perror("sem_unlink"); + } + exit(EXIT_FAILURE); + } + + /* set shm size */ + if (-1 == ftruncate(shm_fd, sizeof(uint64_t))) + { + perror("ftruncate"); + cleanup_shobjs(); + exit(EXIT_FAILURE); + } + + /* map shm */ + if (MAP_FAILED == (ft_shared = mmap(NULL, sizeof(struct ft_shared_s), PROT_READ|PROT_WRITE, + MAP_SHARED, shm_fd, 0))) + { + perror("mmap"); + cleanup_shobjs(); + exit(EXIT_FAILURE); + } + + if (sem_wait(sem) == -1) + { + perror("sem_wait"); + cleanup_shobjs(); + exit(EXIT_FAILURE); + } + + /* init elapsed time ticks to zero */ + ft_shared->ticks = 0; + ft_shared->file_idx = 0; + ft_shared->start_time.real.tv_sec = 0; + ft_shared->start_time.real.tv_nsec = -1; + ft_shared->start_time.mon.tv_sec = 0; + ft_shared->start_time.mon.tv_nsec = -1; + ft_shared->start_time.mon_raw.tv_sec = 0; + ft_shared->start_time.mon_raw.tv_nsec = -1; + + if (-1 == munmap(ft_shared, (sizeof(struct ft_shared_s)))) + { + perror("munmap"); + cleanup_shobjs(); + exit(EXIT_FAILURE); + } + + if (sem_post(sem) == -1) + { + perror("semop"); + cleanup_shobjs(); + exit(EXIT_FAILURE); + } + + snprintf(shared_objs, sizeof(shared_objs), "%s %s", sem_name, shm_name); + setenv("FAKETIME_SHARED", shared_objs, true); + sem_close(sem); + } + + { + char *ftpl_path; +#ifdef __APPLE__ + ftpl_path = PREFIX "/libfaketime.1.dylib"; + FILE *check; + check = fopen(ftpl_path, "ro"); + if (check == NULL) + { + ftpl_path = PREFIX "/lib/faketime/libfaketime.1.dylib"; + } + else + { + fclose(check); + } + setenv("DYLD_INSERT_LIBRARIES", ftpl_path, true); + setenv("DYLD_FORCE_FLAT_NAMESPACE", "1", true); +#else + { + char *ld_preload_new, *ld_preload = getenv("LD_PRELOAD"); + size_t len; + if (use_mt) + { + /* + * on MultiArch platforms, such as Debian, we put a literal $LIB into LD_PRELOAD. + */ +#ifndef MULTI_ARCH + ftpl_path = PREFIX LIBDIRNAME "/libfaketimeMT.so.1"; +#else + ftpl_path = PREFIX "/$LIB/faketime/libfaketimeMT.so.1"; +#endif + } + else + { +#ifndef MULTI_ARCH + ftpl_path = PREFIX LIBDIRNAME "/libfaketime.so.1"; +#else + ftpl_path = PREFIX "/$LIB/faketime/libfaketime.so.1"; +#endif + } + len = ((ld_preload)?strlen(ld_preload) + 1: 0) + 1 + strlen(ftpl_path); + ld_preload_new = malloc(len); + snprintf(ld_preload_new, len ,"%s%s%s", (ld_preload)?ld_preload:"", + (ld_preload)?":":"", ftpl_path); + setenv("LD_PRELOAD", ld_preload_new, true); + free(ld_preload_new); + } +#endif + } + + /* run command and clean up shared objects */ + if (0 == (child_pid = fork())) + { + close(keepalive_fds[0]); /* only parent needs to read this */ + if (EXIT_SUCCESS != execvp(argv[curr_opt], &argv[curr_opt])) + { + perror("Running specified command failed"); + exit(EXIT_FAILURE); + } + } + else + { + int ret; + char buf; + close(keepalive_fds[1]); /* only children need keep this open */ + waitpid(child_pid, &ret, 0); + (void) (read(keepalive_fds[0], &buf, 1) + 1); /* reads 0B when all children exit */ + cleanup_shobjs(); + if (WIFSIGNALED(ret)) + { + fprintf(stderr, "Caught %s\n", strsignal(WTERMSIG(ret))); + exit(EXIT_FAILURE); + } + exit(WEXITSTATUS(ret)); + } + + return EXIT_SUCCESS; +} + +/* + * Editor modelines + * + * Local variables: + * c-basic-offset: 2 + * tab-width: 2 + * indent-tabs-mode: nil + * End: + * + * vi: set shiftwidth=2 tabstop=2 expandtab: + * :indentSize=2:tabSize=2:noTabs=true: + */ + +/* eof */ diff --git a/tests/deckard/contrib/libfaketime/src/faketime_common.h b/tests/deckard/contrib/libfaketime/src/faketime_common.h new file mode 100644 index 0000000..9fda6a7 --- /dev/null +++ b/tests/deckard/contrib/libfaketime/src/faketime_common.h @@ -0,0 +1,61 @@ +/* + * Faketime's common definitions + * + * Copyright 2013 Balint Reczey <balint@balintreczey.hu> + * + * This file is part of the libfaketime. + * + * libfaketime is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License v2 as published by the Free + * Software Foundation. + * + * libfaketime 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 v2 along + * with libfaketime; if not, write to the Free Software Foundation, Inc., + * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef FAKETIME_COMMON_H +#define FAKETIME_COMMON_H + +#include <stdint.h> + +struct system_time_s +{ + /* System time according to CLOCK_REALTIME */ + struct timespec real; + /* System time according to CLOCK_MONOTONIC */ + struct timespec mon; + /* System time according to CLOCK_MONOTONIC_RAW */ + struct timespec mon_raw; +#ifdef CLOCK_BOOTTIME + /* System time according to CLOCK_BOOTTIME */ + struct timespec boot; +#endif +}; + +/* Data shared among faketime-spawned processes */ +struct ft_shared_s +{ + /* + * When advancing time linearly with each time(), etc. call, the calls are + * counted here */ + uint64_t ticks; + /* Index of timstamp to be loaded from file */ + uint64_t file_idx; + /* System time Faketime started at */ + struct system_time_s start_time; +}; + +/* These are all needed in order to properly build on OSX */ +#ifdef __APPLE__ +#include <mach/clock.h> +#include <mach/mach_host.h> +#include <mach/mach_port.h> +#endif + +#endif diff --git a/tests/deckard/contrib/libfaketime/src/libfaketime.c b/tests/deckard/contrib/libfaketime/src/libfaketime.c new file mode 100644 index 0000000..5823701 --- /dev/null +++ b/tests/deckard/contrib/libfaketime/src/libfaketime.c @@ -0,0 +1,2646 @@ +/* + * This file is part of libfaketime, version 0.9.7 + * + * libfaketime is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License v2 as published by the + * Free Software Foundation. + * + * libfaketime 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 v2 along + * with the libfaketime; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +/* + * ======================================================================= + * Global settings, includes, and macros === HEAD + * ======================================================================= + */ + +#define _GNU_SOURCE /* required to get RTLD_NEXT defined */ + +#include <stdio.h> +#include <stdlib.h> +#include <stdint.h> +#include <stdbool.h> +#include <unistd.h> +#include <fcntl.h> +#include <poll.h> +#include <time.h> +#include <math.h> +#include <errno.h> +#include <string.h> +#include <semaphore.h> +#include <sys/mman.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <netinet/in.h> +#include <limits.h> + +#include "uthash.h" + +#include "time_ops.h" +#include "faketime_common.h" + + +/* pthread-handling contributed by David North, TDI in version 0.7 */ +#if defined PTHREAD_SINGLETHREADED_TIME || defined FAKE_PTHREAD +#include <pthread.h> +#endif + +#include <sys/timeb.h> +#include <dlfcn.h> + +#define BUFFERLEN 256 + +#ifndef __APPLE__ +extern char *__progname; +#ifdef __sun +#include "sunos_endian.h" +#else +#include <endian.h> +#endif +#else +/* endianness related macros */ +#ifndef OSSwapHostToBigInt64 +#define OSSwapHostToBigInt64(x) ((uint64_t)(x)) +#endif +#define htobe64(x) OSSwapHostToBigInt64(x) +#ifndef OSSwapHostToLittleInt64 +#define OSSwapHostToLittleInt64(x) OSSwapInt64(x) +#endif +#define htole64(x) OSSwapHostToLittleInt64(x) +#ifndef OSSwapBigToHostInt64 +#define OSSwapBigToHostInt64(x) ((uint64_t)(x)) +#endif +#define be64toh(x) OSSwapBigToHostInt64(x) +#ifndef OSSwapLittleToHostInt64 +#define OSSwapLittleToHostInt64(x) OSSwapInt64(x) +#endif +#define le64toh(x) OSSwapLittleToHostInt64(x) + +/* clock_gettime() and related clock definitions are missing on __APPLE__ */ +#ifndef CLOCK_REALTIME +/* from GNU C Library time.h */ +/* Identifier for system-wide realtime clock. ( == 1) */ +#define CLOCK_REALTIME CALENDAR_CLOCK +/* Monotonic system-wide clock. (== 0) */ +#define CLOCK_MONOTONIC SYSTEM_CLOCK +/* High-resolution timer from the CPU. */ +#define CLOCK_PROCESS_CPUTIME_ID 2 +/* Thread-specific CPU-time clock. */ +#define CLOCK_THREAD_CPUTIME_ID 3 +/* Monotonic system-wide clock, not adjusted for frequency scaling. */ +#define CLOCK_MONOTONIC_RAW 4 +typedef int clockid_t; +#include <mach/clock.h> +#include <mach/mach.h> +#endif +#endif + +/* some systems lack raw clock */ +#ifndef CLOCK_MONOTONIC_RAW +#define CLOCK_MONOTONIC_RAW (CLOCK_MONOTONIC + 1) +#endif + +/* + * Per thread variable, which we turn on inside real_* calls to avoid modifying + * time multiple times of for the whole process to prevent faking time + */ +static __thread bool dont_fake = false; + +/* Wrapper for function calls, which we want to return system time */ +#define DONT_FAKE_TIME(call) \ + { \ + bool dont_fake_orig = dont_fake; \ + if (!dont_fake) \ + { \ + dont_fake = true; \ + } \ + call; \ + dont_fake = dont_fake_orig; \ + } while (0) + +/* pointers to real (not faked) functions */ +static int (*real_stat) (int, const char *, struct stat *); +static int (*real_fstat) (int, int, struct stat *); +static int (*real_fstatat) (int, int, const char *, struct stat *, int); +static int (*real_lstat) (int, const char *, struct stat *); +static int (*real_stat64) (int, const char *, struct stat64 *); +static int (*real_fstat64) (int, int , struct stat64 *); +static int (*real_fstatat64) (int, int , const char *, struct stat64 *, int); +static int (*real_lstat64) (int, const char *, struct stat64 *); +static time_t (*real_time) (time_t *); +static int (*real_ftime) (struct timeb *); +static int (*real_gettimeofday) (struct timeval *, void *); +static int (*real_clock_gettime) (clockid_t clk_id, struct timespec *tp); +#ifdef FAKE_INTERNAL_CALLS +static int (*real___ftime) (struct timeb *); +static int (*real___gettimeofday) (struct timeval *, void *); +static int (*real___clock_gettime) (clockid_t clk_id, struct timespec *tp); +#endif +#ifdef FAKE_PTHREAD +static int (*real_pthread_cond_timedwait_225) (pthread_cond_t *, pthread_mutex_t*, struct timespec *); +static int (*real_pthread_cond_timedwait_232) (pthread_cond_t *, pthread_mutex_t*, struct timespec *); +static int (*real_pthread_cond_init_232) (pthread_cond_t *restrict, const pthread_condattr_t *restrict); +static int (*real_pthread_cond_destroy_232) (pthread_cond_t *); +#endif + +#ifndef __APPLEOSX__ +#ifdef FAKE_TIMERS +static int (*real_timer_settime_22) (int timerid, int flags, const struct itimerspec *new_value, + struct itimerspec * old_value); +static int (*real_timer_settime_233) (timer_t timerid, int flags, + const struct itimerspec *new_value, + struct itimerspec * old_value); +static int (*real_timer_gettime_22) (int timerid, + struct itimerspec *curr_value); +static int (*real_timer_gettime_233) (timer_t timerid, + struct itimerspec *curr_value); +#endif +#endif +#ifdef FAKE_SLEEP +static int (*real_nanosleep) (const struct timespec *req, struct timespec *rem); +static int (*real_usleep) (useconds_t usec); +static unsigned int (*real_sleep) (unsigned int seconds); +static unsigned int (*real_alarm) (unsigned int seconds); +static int (*real_poll) (struct pollfd *, nfds_t, int); +static int (*real_ppoll) (struct pollfd *, nfds_t, const struct timespec *, const sigset_t *); +static int (*real_select) (int nfds, fd_set *restrict readfds, + fd_set *restrict writefds, + fd_set *restrict errorfds, + struct timeval *restrict timeout); +static int (*real_sem_timedwait) (sem_t*, const struct timespec*); +#endif +#ifdef __APPLEOSX__ +static int (*real_clock_get_time) (clock_serv_t clock_serv, mach_timespec_t *cur_timeclockid_t); +static int apple_clock_gettime (clockid_t clk_id, struct timespec *tp); +static clock_serv_t clock_serv_real; +#endif + +static int initialized = 0; + +/* prototypes */ +static int fake_gettimeofday(struct timeval *tv); +static int fake_clock_gettime(clockid_t clk_id, struct timespec *tp); + +/** Semaphore protecting shared data */ +static sem_t *shared_sem = NULL; + +/** Data shared among faketime-spawned processes */ +static struct ft_shared_s *ft_shared = NULL; + +/** Storage format for timestamps written to file. Big endian.*/ +struct saved_timestamp +{ + int64_t sec; + uint64_t nsec; +}; + +static inline void timespec_from_saved (struct timespec *tp, + struct saved_timestamp *saved) +{ + /* read as big endian */ + tp->tv_sec = be64toh(saved->sec); + tp->tv_nsec = be64toh(saved->nsec); +} + +/** Saved timestamps */ +static struct saved_timestamp *stss = NULL; +static size_t infile_size; +static bool infile_set = false; + +/** File fd to save timestamps to */ +static int outfile = -1; + +static bool limited_faking = false; +static long callcounter = 0; +static long ft_start_after_secs = -1; +static long ft_stop_after_secs = -1; +static long ft_start_after_ncalls = -1; +static long ft_stop_after_ncalls = -1; + +static bool spawnsupport = false; +static int spawned = 0; +static char ft_spawn_target[1024]; +static long ft_spawn_secs = -1; +static long ft_spawn_ncalls = -1; + +static int fake_monotonic_clock = 1; +static int cache_enabled = 1; +static int cache_duration = 10; /* cache fake time input for 10 seconds */ + +/* + * Static timespec to store our startup time, followed by a load-time library + * initialization declaration. + */ +#ifndef CLOCK_BOOTTIME +static struct system_time_s ftpl_starttime = {{0, -1}, {0, -1}, {0, -1}}; +#else +static struct system_time_s ftpl_starttime = {{0, -1}, {0, -1}, {0, -1}, {0, -1}}; +#endif + +static char user_faked_time_fmt[BUFSIZ] = {0}; + +/* User supplied base time to fake */ +static struct timespec user_faked_time_timespec = {0, -1}; +/* User supplied base time is set */ +static bool user_faked_time_set = false; +static char user_faked_time_saved[BUFFERLEN] = {0}; + +/* Fractional user offset provided through FAKETIME env. var.*/ +static struct timespec user_offset = {0, -1}; +/* Speed up or slow down clock */ +static double user_rate = 1.0; +static bool user_rate_set = false; +static struct timespec user_per_tick_inc = {0, -1}; +static bool user_per_tick_inc_set = false; + +enum ft_mode_t {FT_FREEZE, FT_START_AT, FT_NOOP} ft_mode = FT_FREEZE; + +/* Time to fake is not provided through FAKETIME env. var. */ +static bool parse_config_file = true; + +static void ft_cleanup (void) __attribute__ ((destructor)); +static void ftpl_init (void) __attribute__ ((constructor)); + + +/* + * ======================================================================= + * Shared memory related functions === SHM + * ======================================================================= + */ + +static void ft_shm_init (void) +{ + int ticks_shm_fd; + char sem_name[256], shm_name[256], *ft_shared_env = getenv("FAKETIME_SHARED"); + + if (ft_shared_env != NULL) + { + if (sscanf(ft_shared_env, "%255s %255s", sem_name, shm_name) < 2) + { + printf("Error parsing semaphore name and shared memory id from string: %s", ft_shared_env); + exit(1); + } + + if (SEM_FAILED == (shared_sem = sem_open(sem_name, 0))) + { + perror("sem_open"); + exit(1); + } + + if (-1 == (ticks_shm_fd = shm_open(shm_name, O_CREAT|O_RDWR, S_IWUSR|S_IRUSR))) + { + perror("shm_open"); + exit(1); + } + + if (MAP_FAILED == (ft_shared = mmap(NULL, sizeof(struct ft_shared_s), PROT_READ|PROT_WRITE, + MAP_SHARED, ticks_shm_fd, 0))) + { + perror("mmap"); + exit(1); + } + } +} + +static void ft_cleanup (void) +{ + /* detach from shared memory */ + if (ft_shared != NULL) + { + munmap(ft_shared, sizeof(uint64_t)); + } + if (stss != NULL) + { + munmap(stss, infile_size); + } + if (shared_sem != NULL) + { + sem_close(shared_sem); + } +} + + +/* + * ======================================================================= + * Internal time retrieval === INTTIME + * ======================================================================= + */ + +/* Get system time from system for all clocks */ +static void system_time_from_system (struct system_time_s * systime) +{ +#ifdef __APPLEOSX__ + /* from http://stackoverflow.com/questions/5167269/clock-gettime-alternative-in-mac-os-x */ + clock_serv_t cclock; + mach_timespec_t mts; + host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &clock_serv_real); + (*real_clock_get_time)(clock_serv_real, &mts); + systime->real.tv_sec = mts.tv_sec; + systime->real.tv_nsec = mts.tv_nsec; + host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &cclock); + (*real_clock_get_time)(cclock, &mts); + mach_port_deallocate(mach_task_self(), cclock); + systime->mon.tv_sec = mts.tv_sec; + systime->mon.tv_nsec = mts.tv_nsec; + systime->mon_raw.tv_sec = mts.tv_sec; + systime->mon_raw.tv_nsec = mts.tv_nsec; +#else + DONT_FAKE_TIME((*real_clock_gettime)(CLOCK_REALTIME, &systime->real)) + ; + DONT_FAKE_TIME((*real_clock_gettime)(CLOCK_MONOTONIC, &systime->mon)) + ; + DONT_FAKE_TIME((*real_clock_gettime)(CLOCK_MONOTONIC_RAW, &systime->mon_raw)) + ; +#ifdef CLOCK_BOOTTIME + DONT_FAKE_TIME((*real_clock_gettime)(CLOCK_BOOTTIME, &systime->boot)) + ; +#endif +#endif +} + +static void next_time(struct timespec *tp, struct timespec *ticklen) +{ + if (shared_sem != NULL) + { + struct timespec inc; + /* lock */ + if (sem_wait(shared_sem) == -1) + { + perror("sem_wait"); + exit(1); + } + /* calculate and update elapsed time */ + timespecmul(ticklen, ft_shared->ticks, &inc); + timespecadd(&user_faked_time_timespec, &inc, tp); + (ft_shared->ticks)++; + /* unlock */ + if (sem_post(shared_sem) == -1) + { + perror("sem_post"); + exit(1); + } + } +} + + +/* + * ======================================================================= + * Saving & loading time === SAVE + * ======================================================================= + */ + +static void save_time(struct timespec *tp) +{ + if ((shared_sem != NULL) && (outfile != -1)) + { + struct saved_timestamp time_write; + ssize_t written; + size_t n = 0; + + time_write.sec = htobe64(tp->tv_sec); + time_write.nsec = htobe64(tp->tv_nsec); + + /* lock */ + if (sem_wait(shared_sem) == -1) + { + perror("sem_wait"); + exit(1); + } + + lseek(outfile, 0, SEEK_END); + do + { + written = write(outfile, &(((char*)&time_write)[n]), sizeof(time_write) - n); + } + while (((written == -1) && (errno == EINTR)) || + (sizeof(time_write) < (n += written))); + + if ((written == -1) || (n < sizeof(time_write))) + { + perror("Saving timestamp to file failed"); + } + + /* unlock */ + if (sem_post(shared_sem) == -1) + { + perror("sem_post"); + exit(1); + } + } +} + +/* + * Provide faked time from file. + * @return time is set from filen + */ +static bool load_time(struct timespec *tp) +{ + bool ret = false; + if ((shared_sem != NULL) && (infile_set)) + { + /* lock */ + if (sem_wait(shared_sem) == -1) + { + perror("sem_wait"); + exit(1); + } + + if ((sizeof(stss[0]) * (ft_shared->file_idx + 1)) > infile_size) + { + /* we are out of timstamps to replay, return to faking time by rules + * using last timestamp from file as the user provided timestamp */ + timespec_from_saved(&user_faked_time_timespec, &stss[(infile_size / sizeof(stss[0])) - 1 ]); + + if (ft_shared->ticks == 0) + { + /* we set shared memory to stop using infile */ + ft_shared->ticks = 1; + system_time_from_system(&ftpl_starttime); + ft_shared->start_time = ftpl_starttime; + } + else + { + ftpl_starttime = ft_shared->start_time; + } + + munmap(stss, infile_size); + infile_set = false; + } + else + { + timespec_from_saved(tp, &stss[ft_shared->file_idx]); + ft_shared->file_idx++; + ret = true; + } + + /* unlock */ + if (sem_post(shared_sem) == -1) + { + perror("sem_post"); + exit(1); + } + } + return ret; +} + + +/* + * ======================================================================= + * Faked system functions: file related === FAKE(FILE) + * ======================================================================= + */ + +#ifdef FAKE_STAT + +#ifndef NO_ATFILE +#ifndef _ATFILE_SOURCE +#define _ATFILE_SOURCE +#endif +#include <fcntl.h> /* Definition of AT_* constants */ +#endif + +#include <sys/stat.h> + +static int fake_stat_disabled = 0; + +#define FAKE_STRUCT_STAT_TIME(which) { \ + struct timespec t = {buf->st_##which##time, \ + buf->st_##which##timensec}; \ + fake_clock_gettime(CLOCK_REALTIME, &t); \ + buf->st_##which##time = t.tv_sec; \ + buf->st_##which##timensec = t.tv_nsec; \ + } while (0) + +static inline void fake_statbuf (struct stat *buf) { +#ifndef st_atime + FAKE_STRUCT_STAT_TIME(c); + FAKE_STRUCT_STAT_TIME(a); + FAKE_STRUCT_STAT_TIME(m); +#else + fake_clock_gettime(CLOCK_REALTIME, &buf->st_ctim); + fake_clock_gettime(CLOCK_REALTIME, &buf->st_atim); + fake_clock_gettime(CLOCK_REALTIME, &buf->st_mtim); +#endif +} + +static inline void fake_stat64buf (struct stat64 *buf) { +#ifndef st_atime + FAKE_STRUCT_STAT_TIME(c); + FAKE_STRUCT_STAT_TIME(a); + FAKE_STRUCT_STAT_TIME(m); +#else + fake_clock_gettime(CLOCK_REALTIME, &buf->st_ctim); + fake_clock_gettime(CLOCK_REALTIME, &buf->st_atim); + fake_clock_gettime(CLOCK_REALTIME, &buf->st_mtim); +#endif +} + +/* Contributed by Philipp Hachtmann in version 0.6 */ +int __xstat (int ver, const char *path, struct stat *buf) +{ + if (!initialized) + { + ftpl_init(); + } + if (NULL == real_stat) + { /* dlsym() failed */ +#ifdef DEBUG + (void) fprintf(stderr, "faketime problem: original stat() not found.\n"); +#endif + return -1; /* propagate error to caller */ + } + + int result; + DONT_FAKE_TIME(result = real_stat(ver, path, buf)); + if (result == -1) + { + return -1; + } + + if (buf != NULL) + { + if (!fake_stat_disabled) + { + fake_statbuf(buf); + } + } + + return result; +} + +/* Contributed by Philipp Hachtmann in version 0.6 */ +int __fxstat (int ver, int fildes, struct stat *buf) +{ + if (!initialized) + { + ftpl_init(); + } + if (NULL == real_fstat) + { /* dlsym() failed */ +#ifdef DEBUG + (void) fprintf(stderr, "faketime problem: original fstat() not found.\n"); +#endif + return -1; /* propagate error to caller */ + } + + int result; + DONT_FAKE_TIME(result = real_fstat(ver, fildes, buf)); + if (result == -1) + { + return -1; + } + + if (buf != NULL) + { + if (!fake_stat_disabled) + { + fake_statbuf(buf); + } + } + return result; +} + +/* Added in v0.8 as suggested by Daniel Kahn Gillmor */ +#ifndef NO_ATFILE +int __fxstatat(int ver, int fildes, const char *filename, struct stat *buf, int flag) +{ + if (!initialized) + { + ftpl_init(); + } + if (NULL == real_fstatat) + { /* dlsym() failed */ +#ifdef DEBUG + (void) fprintf(stderr, "faketime problem: original fstatat() not found.\n"); +#endif + return -1; /* propagate error to caller */ + } + + int result; + DONT_FAKE_TIME(result = real_fstatat(ver, fildes, filename, buf, flag)); + if (result == -1) + { + return -1; + } + + if (buf != NULL) + { + if (!fake_stat_disabled) + { + fake_statbuf(buf); + } + } + return result; +} +#endif + +/* Contributed by Philipp Hachtmann in version 0.6 */ +int __lxstat (int ver, const char *path, struct stat *buf) +{ + if (!initialized) + { + ftpl_init(); + } + if (NULL == real_lstat) + { /* dlsym() failed */ +#ifdef DEBUG + (void) fprintf(stderr, "faketime problem: original lstat() not found.\n"); +#endif + return -1; /* propagate error to caller */ + } + + int result; + DONT_FAKE_TIME(result = real_lstat(ver, path, buf)); + if (result == -1) + { + return -1; + } + + if (buf != NULL) + { + if (!fake_stat_disabled) + { + fake_statbuf(buf); + } + } + return result; +} + +/* Contributed by Philipp Hachtmann in version 0.6 */ +int __xstat64 (int ver, const char *path, struct stat64 *buf) +{ + if (!initialized) + { + ftpl_init(); + } + if (NULL == real_stat64) + { /* dlsym() failed */ +#ifdef DEBUG + (void) fprintf(stderr, "faketime problem: original stat() not found.\n"); +#endif + return -1; /* propagate error to caller */ + } + + int result; + DONT_FAKE_TIME(result = real_stat64(ver, path, buf)); + if (result == -1) + { + return -1; + } + + if (buf != NULL) + { + if (!fake_stat_disabled) + { + fake_stat64buf(buf); + } + } + return result; +} + +/* Contributed by Philipp Hachtmann in version 0.6 */ +int __fxstat64 (int ver, int fildes, struct stat64 *buf) +{ + if (!initialized) + { + ftpl_init(); + } + if (NULL == real_fstat64) + { /* dlsym() failed */ +#ifdef DEBUG + (void) fprintf(stderr, "faketime problem: original fstat() not found.\n"); +#endif + return -1; /* propagate error to caller */ + } + + int result; + DONT_FAKE_TIME(result = real_fstat64(ver, fildes, buf)); + if (result == -1) + { + return -1; + } + + if (buf != NULL) + { + if (!fake_stat_disabled) + { + fake_stat64buf(buf); + } + } + return result; +} + +/* Added in v0.8 as suggested by Daniel Kahn Gillmor */ +#ifndef NO_ATFILE +int __fxstatat64 (int ver, int fildes, const char *filename, struct stat64 *buf, int flag) +{ + if (!initialized) + { + ftpl_init(); + } + if (NULL == real_fstatat64) + { /* dlsym() failed */ +#ifdef DEBUG + (void) fprintf(stderr, "faketime problem: original fstatat64() not found.\n"); +#endif + return -1; /* propagate error to caller */ + } + + int result; + DONT_FAKE_TIME(result = real_fstatat64(ver, fildes, filename, buf, flag)); + if (result == -1) + { + return -1; + } + + if (buf != NULL) + { + if (!fake_stat_disabled) + { + fake_stat64buf(buf); + } + } + return result; +} +#endif + +/* Contributed by Philipp Hachtmann in version 0.6 */ +int __lxstat64 (int ver, const char *path, struct stat64 *buf) +{ + if (!initialized) + { + ftpl_init(); + } + if (NULL == real_lstat64) + { /* dlsym() failed */ +#ifdef DEBUG + (void) fprintf(stderr, "faketime problem: original lstat() not found.\n"); +#endif + return -1; /* propagate error to caller */ + } + + int result; + DONT_FAKE_TIME(result = real_lstat64(ver, path, buf)); + if (result == -1) + { + return -1; + } + + if (buf != NULL) + { + if (!fake_stat_disabled) + { + fake_stat64buf(buf); + } + } + return result; +} +#endif + +/* + * ======================================================================= + * Faked system functions: sleep/alarm/poll/timer related === FAKE(SLEEP) + * ======================================================================= + * Contributed by Balint Reczey in v0.9.5 + */ + +#ifdef FAKE_SLEEP +/* + * Faked nanosleep() + */ +int nanosleep(const struct timespec *req, struct timespec *rem) +{ + int result; + struct timespec real_req; + + if (!initialized) + { + ftpl_init(); + } + if (real_nanosleep == NULL) + { + return -1; + } + if (req != NULL) + { + if (user_rate_set && !dont_fake) + { + timespecmul(req, 1.0 / user_rate, &real_req); + } + else + { + real_req = *req; + } + } + else + { + return -1; + } + + DONT_FAKE_TIME(result = (*real_nanosleep)(&real_req, rem)); + if (result == -1) + { + return result; + } + + /* fake returned parts */ + if ((rem != NULL) && ((rem->tv_sec != 0) || (rem->tv_nsec != 0))) + { + if (user_rate_set && !dont_fake) + { + timespecmul(rem, user_rate, rem); + } + } + /* return the result to the caller */ + return result; +} + +/* + * Faked usleep() + */ +int usleep(useconds_t usec) +{ + int result; + + if (!initialized) + { + ftpl_init(); + } + if (user_rate_set && !dont_fake) + { + struct timespec real_req; + + if (real_nanosleep == NULL) + { + /* fall back to usleep() */ + if (real_usleep == NULL) + { + return -1; + } + DONT_FAKE_TIME(result = (*real_usleep)((1.0 / user_rate) * usec)); + return result; + } + + real_req.tv_sec = usec / 1000000; + real_req.tv_nsec = (usec % 1000000) * 1000; + timespecmul(&real_req, 1.0 / user_rate, &real_req); + DONT_FAKE_TIME(result = (*real_nanosleep)(&real_req, NULL)); + } + else + { + DONT_FAKE_TIME(result = (*real_usleep)(usec)); + } + return result; +} + +/* + * Faked sleep() + */ +unsigned int sleep(unsigned int seconds) +{ + if (!initialized) + { + ftpl_init(); + } + if (user_rate_set && !dont_fake) + { + if (real_nanosleep == NULL) + { + /* fall back to sleep */ + unsigned int ret; + if (real_sleep == NULL) + { + return 0; + } + DONT_FAKE_TIME(ret = (*real_sleep)((1.0 / user_rate) * seconds)); + return (user_rate_set && !dont_fake)?(user_rate * ret):ret; + } + else + { + int result; + struct timespec real_req = {seconds, 0}, rem; + timespecmul(&real_req, 1.0 / user_rate, &real_req); + DONT_FAKE_TIME(result = (*real_nanosleep)(&real_req, &rem)); + if (result == -1) + { + return 0; + } + + /* fake returned parts */ + if ((rem.tv_sec != 0) || (rem.tv_nsec != 0)) + { + timespecmul(&rem, user_rate, &rem); + } + /* return the result to the caller */ + return rem.tv_sec; + } + } + else + { + /* no need to fake anything */ + unsigned int ret; + DONT_FAKE_TIME(ret = (*real_sleep)(seconds)); + return ret; + } +} + +/* + * Faked alarm() + * @note due to rounding alarm(2) with faketime -f '+0 x7' won't wait 2/7 + * wall clock seconds but 0 seconds + */ +unsigned int alarm(unsigned int seconds) +{ + unsigned int ret; + unsigned int seconds_real = (user_rate_set && !dont_fake)?((1.0 / user_rate) * seconds):seconds; + + if (!initialized) + { + ftpl_init(); + } + if (real_alarm == NULL) + { + return -1; + } + + DONT_FAKE_TIME(ret = (*real_alarm)(seconds_real)); + return (user_rate_set && !dont_fake)?(user_rate * ret):ret; +} + +/* + * Faked ppoll() + */ +int ppoll(struct pollfd *fds, nfds_t nfds, + const struct timespec *timeout_ts, const sigset_t *sigmask) +{ + struct timespec real_timeout, *real_timeout_pt; + int ret; + + if (!initialized) + { + ftpl_init(); + } + if (real_ppoll == NULL) + { + return -1; + } + if (timeout_ts != NULL) + { + if (user_rate_set && !dont_fake && (timeout_ts->tv_sec > 0)) + { + timespecmul(timeout_ts, 1.0 / user_rate, &real_timeout); + real_timeout_pt = &real_timeout; + } + else + { + /* cast away constness */ + real_timeout_pt = (struct timespec *)timeout_ts; + } + } + else + { + real_timeout_pt = NULL; + } + + DONT_FAKE_TIME(ret = (*real_ppoll)(fds, nfds, real_timeout_pt, sigmask)); + return ret; +} + +/* + * Faked poll() + */ +int poll(struct pollfd *fds, nfds_t nfds, int timeout) +{ + int ret, timeout_real = (user_rate_set && !dont_fake && (timeout > 0))?(timeout / user_rate):timeout; + + if (!initialized) + { + ftpl_init(); + } + if (real_poll == NULL) + { + return -1; + } + + DONT_FAKE_TIME(ret = (*real_poll)(fds, nfds, timeout_real)); + return ret; +} + +/* + * Faked select() + */ +int select(int nfds, fd_set *readfds, + fd_set *writefds, + fd_set *errorfds, + struct timeval *timeout) +{ + int ret; + struct timeval timeout_real; + + if (!initialized) + { + ftpl_init(); + } + + if (real_select == NULL) + { + return -1; + } + + if (timeout != NULL) + { + if (user_rate_set && !dont_fake && (timeout->tv_sec > 0 || timeout->tv_usec > 0)) + { + struct timespec ts; + + ts.tv_sec = timeout->tv_sec; + ts.tv_nsec = timeout->tv_usec * 1000; + + timespecmul(&ts, 1.0 / user_rate, &ts); + + timeout_real.tv_sec = ts.tv_sec; + timeout_real.tv_usec = ts.tv_nsec / 1000; + } + else + { + timeout_real.tv_sec = timeout->tv_sec; + timeout_real.tv_usec = timeout->tv_usec; + } + } + + DONT_FAKE_TIME(ret = (*real_select)(nfds, readfds, writefds, errorfds, timeout == NULL ? timeout : &timeout_real)); + return ret; +} + +int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout) +{ + int result; + struct timespec real_abs_timeout, *real_abs_timeout_pt; + + /* sanity check */ + if (abs_timeout == NULL) + { + return -1; + } + + if (NULL == real_sem_timedwait) + { /* dlsym() failed */ +#ifdef DEBUG + (void) fprintf(stderr, "faketime problem: original sem_timedwait() not found.\n"); +#endif + return -1; /* propagate error to caller */ + } + + if (!dont_fake) + { + struct timespec tdiff, timeadj; + + timespecsub(abs_timeout, &user_faked_time_timespec, &tdiff); + + if (user_rate_set) + { + timespecmul(&tdiff, user_rate, &timeadj); + } + else + { + timeadj = tdiff; + } + timespecadd(&ftpl_starttime.real, &timeadj, &real_abs_timeout); + real_abs_timeout_pt = &real_abs_timeout; + } + else + { + /* cast away constness */ + real_abs_timeout_pt = (struct timespec *)abs_timeout; + } + + DONT_FAKE_TIME(result = (*real_sem_timedwait)(sem, real_abs_timeout_pt)); + return result; +} +#endif + +#ifndef __APPLE__ +#ifdef FAKE_TIMERS + +/* timer related functions and structures */ +typedef union { + int int_member; + timer_t timer_t_member; +} timer_t_or_int; + +/* + * Faketime's function implementation's compatibility mode + */ +typedef enum {FT_COMPAT_GLIBC_2_2, FT_COMPAT_GLIBC_2_3_3} ft_lib_compat_timer; + + +/* + * Faked timer_settime() + * Does not affect timer speed when stepping clock with each time() call. + */ +static int +timer_settime_common(timer_t_or_int timerid, int flags, + const struct itimerspec *new_value, + struct itimerspec *old_value, ft_lib_compat_timer compat) +{ + int result; + struct itimerspec new_real; + struct itimerspec *new_real_pt = &new_real; + + if (!initialized) + { + ftpl_init(); + } + if (new_value == NULL) + { + new_real_pt = NULL; + } + else if (dont_fake) + { + /* cast away constness*/ + new_real_pt = (struct itimerspec *)new_value; + } + else + { + /* set it_value */ + if ((new_value->it_value.tv_sec != 0) || + (new_value->it_value.tv_nsec != 0)) + { + if (flags & TIMER_ABSTIME) + { + struct timespec tdiff, timeadj; + timespecsub(&new_value->it_value, &user_faked_time_timespec, &timeadj); + if (user_rate_set) + { + timespecmul(&timeadj, 1.0/user_rate, &tdiff); + } + else + { + tdiff = timeadj; + } + /* only CLOCK_REALTIME is handled */ + timespecadd(&ftpl_starttime.real, &tdiff, &new_real.it_value); + } + else + { + if (user_rate_set) + { + timespecmul(&new_value->it_value, 1.0/user_rate, &new_real.it_value); + } + else + { + new_real.it_value = new_value->it_value; + } + } + } + else + { + new_real.it_value = new_value->it_value; + } + /* set it_interval */ + if (user_rate_set && ((new_value->it_interval.tv_sec != 0) || + (new_value->it_interval.tv_nsec != 0))) + { + timespecmul(&new_value->it_interval, 1.0/user_rate, &new_real.it_interval); + } + else + { + new_real.it_interval = new_value->it_interval; + } + } + + switch (compat) + { + case FT_COMPAT_GLIBC_2_2: + DONT_FAKE_TIME(result = (*real_timer_settime_22)(timerid.int_member, flags, + new_real_pt, old_value)); + break; + case FT_COMPAT_GLIBC_2_3_3: + DONT_FAKE_TIME(result = (*real_timer_settime_233)(timerid.timer_t_member, + flags, new_real_pt, old_value)); + break; + default: + result = -1; + break; + } + + if (result == -1) + { + return result; + } + + /* fake returned parts */ + if ((old_value != NULL) && !dont_fake) + { + if ((old_value->it_value.tv_sec != 0) || + (old_value->it_value.tv_nsec != 0)) + { + result = fake_clock_gettime(CLOCK_REALTIME, &old_value->it_value); + } + if (user_rate_set && ((old_value->it_interval.tv_sec != 0) || + (old_value->it_interval.tv_nsec != 0))) + { + timespecmul(&old_value->it_interval, user_rate, &old_value->it_interval); + } + } + + /* return the result to the caller */ + return result; +} + +/* + * Faked timer_settime() compatible with implementation in GLIBC 2.2 + */ +int timer_settime_22(int timerid, int flags, + const struct itimerspec *new_value, + struct itimerspec *old_value) +{ + if (!initialized) + { + ftpl_init(); + } + if (real_timer_settime_22 == NULL) + { + return -1; + } + else + { + return (timer_settime_common((timer_t_or_int)timerid, flags, new_value, old_value, + FT_COMPAT_GLIBC_2_2)); + } +} + +/* + * Faked timer_settime() compatible with implementation in GLIBC 2.3.3 + */ +int timer_settime_233(timer_t timerid, int flags, + const struct itimerspec *new_value, + struct itimerspec *old_value) +{ + if (!initialized) + { + ftpl_init(); + } + if (real_timer_settime_233 == NULL) + { + return -1; + } + else + { + return (timer_settime_common((timer_t_or_int)timerid, flags, new_value, old_value, + FT_COMPAT_GLIBC_2_3_3)); + } +} + +/* + * Faked timer_gettime() + * Does not affect timer speed when stepping clock with each time() call. + */ +int timer_gettime_common(timer_t_or_int timerid, struct itimerspec *curr_value, ft_lib_compat_timer compat) +{ + int result; + + if (!initialized) + { + ftpl_init(); + } + if (real_timer_gettime_233 == NULL) + { + return -1; + } + + switch (compat) + { + case FT_COMPAT_GLIBC_2_2: + DONT_FAKE_TIME(result = (*real_timer_gettime_22)(timerid.int_member, curr_value)); + break; + case FT_COMPAT_GLIBC_2_3_3: + DONT_FAKE_TIME(result = (*real_timer_gettime_233)(timerid.timer_t_member, curr_value)); + break; + default: + result = -1; + break; + } + + if (result == -1) + { + return result; + } + + /* fake returned parts */ + if (curr_value != NULL) + { + if (user_rate_set && !dont_fake) + { + timespecmul(&curr_value->it_interval, user_rate, &curr_value->it_interval); + timespecmul(&curr_value->it_value, user_rate, &curr_value->it_value); + } + } + /* return the result to the caller */ + return result; +} + +/* + * Faked timer_gettime() compatible with implementation in GLIBC 2.2 + */ +int timer_gettime_22(timer_t timerid, struct itimerspec *curr_value) +{ + if (!initialized) + { + ftpl_init(); + } + if (real_timer_gettime_22 == NULL) + { + return -1; + } + else + { + return (timer_gettime_common((timer_t_or_int)timerid, curr_value, + FT_COMPAT_GLIBC_2_2)); + } +} + +/* + * Faked timer_gettime() compatible with implementation in GLIBC 2.3.3 + */ +int timer_gettime_233(timer_t timerid, struct itimerspec *curr_value) +{ + if (!initialized) + { + ftpl_init(); + } + if (real_timer_gettime_233 == NULL) + { + return -1; + } + else + { + return (timer_gettime_common((timer_t_or_int)timerid, curr_value, + FT_COMPAT_GLIBC_2_3_3)); + } +} + +__asm__(".symver timer_gettime_22, timer_gettime@GLIBC_2.2"); +__asm__(".symver timer_gettime_233, timer_gettime@@GLIBC_2.3.3"); +__asm__(".symver timer_settime_22, timer_settime@GLIBC_2.2"); +__asm__(".symver timer_settime_233, timer_settime@@GLIBC_2.3.3"); + +#endif +#endif + + +/* + * ======================================================================= + * Faked system functions: basic time functions === FAKE(TIME) + * ======================================================================= + */ + +/* + * time() implementation using clock_gettime() + * @note Does not check for EFAULT, see man 2 time + */ +time_t time(time_t *time_tptr) +{ + struct timespec tp; + time_t result; + + if (!initialized) + { + ftpl_init(); + } + DONT_FAKE_TIME(result = (*real_clock_gettime)(CLOCK_REALTIME, &tp)); + if (result == -1) return -1; + + /* pass the real current time to our faking version, overwriting it */ + (void)fake_clock_gettime(CLOCK_REALTIME, &tp); + + if (time_tptr != NULL) + { + *time_tptr = tp.tv_sec; + } + return tp.tv_sec; +} + +int ftime(struct timeb *tb) +{ + struct timespec tp; + int result; + + if (!initialized) + { + ftpl_init(); + } + /* sanity check */ + if (tb == NULL) + return 0; /* ftime() always returns 0, see manpage */ + + /* Check whether we've got a pointer to the real ftime() function yet */ + if (NULL == real_ftime) + { /* dlsym() failed */ +#ifdef DEBUG + (void) fprintf(stderr, "faketime problem: original ftime() not found.\n"); +#endif + return 0; /* propagate error to caller */ + } + + /* initialize our TZ result with the real current time */ + DONT_FAKE_TIME(result = (*real_ftime)(tb)); + if (result == -1) + { + return result; + } + + DONT_FAKE_TIME(result = (*real_clock_gettime)(CLOCK_REALTIME, &tp)); + if (result == -1) return -1; + + /* pass the real current time to our faking version, overwriting it */ + (void)fake_clock_gettime(CLOCK_REALTIME, &tp); + + tb->time = tp.tv_sec; + tb->millitm = tp.tv_nsec / 1000000; + + /* return the result to the caller */ + return result; /* will always be 0 (see manpage) */ +} + +int gettimeofday(struct timeval *tv, void *tz) +{ + int result; + + if (!initialized) + { + ftpl_init(); + } + /* sanity check */ + if (tv == NULL) + { + return -1; + } + + /* Check whether we've got a pointer to the real ftime() function yet */ + if (NULL == real_gettimeofday) + { /* dlsym() failed */ +#ifdef DEBUG + (void) fprintf(stderr, "faketime problem: original gettimeofday() not found.\n"); +#endif + return -1; /* propagate error to caller */ + } + + /* initialize our result with the real current time */ + DONT_FAKE_TIME(result = (*real_gettimeofday)(tv, tz)); + if (result == -1) return result; /* original function failed */ + + /* pass the real current time to our faking version, overwriting it */ + result = fake_gettimeofday(tv); + + /* return the result to the caller */ + return result; +} + +int clock_gettime(clockid_t clk_id, struct timespec *tp) +{ + int result; + + if (!initialized) + { + ftpl_init(); + } + /* sanity check */ + if (tp == NULL) + { + return -1; + } + + if (NULL == real_clock_gettime) + { /* dlsym() failed */ +#ifdef DEBUG + (void) fprintf(stderr, "faketime problem: original clock_gettime() not found.\n"); +#endif + return -1; /* propagate error to caller */ + } + + /* initialize our result with the real current time */ + DONT_FAKE_TIME(result = (*real_clock_gettime)(clk_id, tp)); + if (result == -1) return result; /* original function failed */ + + /* pass the real current time to our faking version, overwriting it */ + if (fake_monotonic_clock || (clk_id != CLOCK_MONOTONIC && clk_id != CLOCK_MONOTONIC_RAW +#ifdef CLOCK_MONOTONIC_COARSE + && clk_id != CLOCK_MONOTONIC_COARSE +#endif +#ifdef CLOCK_BOOTTIME + && clk_id != CLOCK_BOOTTIME +#endif + )) + { + result = fake_clock_gettime(clk_id, tp); + } + + /* return the result to the caller */ + return result; +} + + +/* + * ======================================================================= + * Parsing the user's faketime requests === PARSE + * ======================================================================= + */ + +static void parse_ft_string(const char *user_faked_time) +{ + struct tm user_faked_time_tm; + char * tmp_time_fmt; + + if (!strncmp(user_faked_time, user_faked_time_saved, BUFFERLEN)) + { + /* No change */ + return; + } + + /* check whether the user gave us an absolute time to fake */ + switch (user_faked_time[0]) + { + + default: /* Try and interpret this as a specified time */ + if (ft_mode != FT_NOOP) ft_mode = FT_FREEZE; + user_faked_time_tm.tm_isdst = -1; + if (NULL != strptime(user_faked_time, user_faked_time_fmt, &user_faked_time_tm)) + { + user_faked_time_timespec.tv_sec = mktime(&user_faked_time_tm); + user_faked_time_timespec.tv_nsec = 0; + user_faked_time_set = true; + } + else + { + perror("Failed to parse FAKETIME timestamp"); + fprintf(stderr, "Please check specification %s with format %s\n", user_faked_time, user_faked_time_fmt); + exit(EXIT_FAILURE); + } + break; + + case '+': + case '-': /* User-specified offset */ + if (ft_mode != FT_NOOP) ft_mode = FT_START_AT; + /* fractional time offsets contributed by Karl Chen in v0.8 */ + double frac_offset = atof(user_faked_time); + + /* offset is in seconds by default, but the string may contain + * multipliers... + */ + if (strchr(user_faked_time, 'm') != NULL) frac_offset *= 60; + else if (strchr(user_faked_time, 'h') != NULL) frac_offset *= 60 * 60; + else if (strchr(user_faked_time, 'd') != NULL) frac_offset *= 60 * 60 * 24; + else if (strchr(user_faked_time, 'y') != NULL) frac_offset *= 60 * 60 * 24 * 365; + + user_offset.tv_sec = floor(frac_offset); + user_offset.tv_nsec = (frac_offset - user_offset.tv_sec) * SEC_TO_nSEC; + timespecadd(&ftpl_starttime.real, &user_offset, &user_faked_time_timespec); + goto parse_modifiers; + break; + + /* Contributed by David North, TDI in version 0.7 */ + case '@': /* Specific time, but clock along relative to that starttime */ + ft_mode = FT_START_AT; + user_faked_time_tm.tm_isdst = -1; + (void) strptime(&user_faked_time[1], user_faked_time_fmt, &user_faked_time_tm); + + user_faked_time_timespec.tv_sec = mktime(&user_faked_time_tm); + user_faked_time_timespec.tv_nsec = 0; + + /* Reset starttime */ + system_time_from_system(&ftpl_starttime); + goto parse_modifiers; + break; + + case 'i': + case 'x': /* Only modifiers are passed, don't fall back to strptime */ +parse_modifiers: + /* Speed-up / slow-down contributed by Karl Chen in v0.8 */ + if (strchr(user_faked_time, 'x') != NULL) + { + user_rate = atof(strchr(user_faked_time, 'x')+1); + user_rate_set = true; + } + else if (NULL != (tmp_time_fmt = strchr(user_faked_time, 'i'))) + { + double tick_inc = atof(tmp_time_fmt + 1); + /* increment time with every time() call*/ + user_per_tick_inc.tv_sec = floor(tick_inc); + user_per_tick_inc.tv_nsec = (tick_inc - user_per_tick_inc.tv_sec) * SEC_TO_nSEC ; + user_per_tick_inc_set = true; + } + break; + } // end of switch + + strncpy(user_faked_time_saved, user_faked_time, BUFFERLEN-1); + user_faked_time_saved[BUFFERLEN-1] = 0; +#ifdef DEBUG + fprintf(stderr, "new FAKETIME: %s\n", user_faked_time_saved); +#endif +} + + +/* + * ======================================================================= + * Initialization === INIT + * ======================================================================= + */ + +static void ftpl_init(void) +{ + char *tmp_env; + bool dont_fake_final; + +#ifdef __APPLE__ + const char *progname = getprogname(); +#else + const char *progname = __progname; +#endif + + /* Look up all real_* functions. NULL will mark missing ones. */ + real_stat = dlsym(RTLD_NEXT, "__xstat"); + real_fstat = dlsym(RTLD_NEXT, "__fxstat"); + real_fstatat = dlsym(RTLD_NEXT, "__fxstatat"); + real_lstat = dlsym(RTLD_NEXT, "__lxstat"); + real_stat64 = dlsym(RTLD_NEXT,"__xstat64"); + real_fstat64 = dlsym(RTLD_NEXT, "__fxstat64"); + real_fstatat64 = dlsym(RTLD_NEXT, "__fxstatat64"); + real_lstat64 = dlsym(RTLD_NEXT, "__lxstat64"); + real_time = dlsym(RTLD_NEXT, "time"); + real_ftime = dlsym(RTLD_NEXT, "ftime"); +#if defined(__alpha__) && defined(__GLIBC__) + real_gettimeofday = dlvsym(RTLD_NEXT, "gettimeofday", "GLIBC_2.1"); +#else + real_gettimeofday = dlsym(RTLD_NEXT, "gettimeofday"); +#endif +#ifdef FAKE_SLEEP + real_nanosleep = dlsym(RTLD_NEXT, "nanosleep"); + real_usleep = dlsym(RTLD_NEXT, "usleep"); + real_sleep = dlsym(RTLD_NEXT, "sleep"); + real_alarm = dlsym(RTLD_NEXT, "alarm"); + real_poll = dlsym(RTLD_NEXT, "poll"); + real_ppoll = dlsym(RTLD_NEXT, "ppoll"); + real_select = dlsym(RTLD_NEXT, "select"); + real_sem_timedwait = dlsym(RTLD_NEXT, "sem_timedwait"); +#endif +#ifdef FAKE_INTERNAL_CALLS + real___ftime = dlsym(RTLD_NEXT, "__ftime"); +# if defined(__alpha__) && defined(__GLIBC__) + real___gettimeofday = dlvsym(RTLD_NEXT, "__gettimeofday", "GLIBC_2.1"); +# else + real___gettimeofday = dlsym(RTLD_NEXT, "__gettimeofday"); +# endif + real___clock_gettime = dlsym(RTLD_NEXT, "__clock_gettime"); +#endif +#ifdef FAKE_PTHREAD + +#ifdef __GLIBC__ + real_pthread_cond_timedwait_225 = dlvsym(RTLD_NEXT, "pthread_cond_timedwait", "GLIBC_2.2.5"); + + real_pthread_cond_timedwait_232 = dlvsym(RTLD_NEXT, "pthread_cond_timedwait", "GLIBC_2.3.2"); + real_pthread_cond_init_232 = dlvsym(RTLD_NEXT, "pthread_cond_init", "GLIBC_2.3.2"); + real_pthread_cond_destroy_232 = dlvsym(RTLD_NEXT, "pthread_cond_destroy", "GLIBC_2.3.2"); +#endif + + if (NULL == real_pthread_cond_timedwait_232) + { + real_pthread_cond_timedwait_232 = dlsym(RTLD_NEXT, "pthread_cond_timedwait"); + } + if (NULL == real_pthread_cond_init_232) + { + real_pthread_cond_init_232 = dlsym(RTLD_NEXT, "pthread_cond_init"); + } + if (NULL == real_pthread_cond_destroy_232) + { + real_pthread_cond_destroy_232 = dlsym(RTLD_NEXT, "pthread_cond_destroy"); + } +#endif +#ifdef __APPLEOSX__ + real_clock_get_time = dlsym(RTLD_NEXT, "clock_get_time"); + real_clock_gettime = apple_clock_gettime; +#else + real_clock_gettime = dlsym(RTLD_NEXT, "__clock_gettime"); + if (NULL == real_clock_gettime) + { + real_clock_gettime = dlsym(RTLD_NEXT, "clock_gettime"); + } +#ifdef FAKE_TIMERS +#if defined(__sun) + real_timer_gettime_233 = dlsym(RTLD_NEXT, "timer_gettime"); + real_timer_settime_233 = dlsym(RTLD_NEXT, "timer_settime"); +#else +#ifdef __GLIBC__ + real_timer_settime_22 = dlvsym(RTLD_NEXT, "timer_settime","GLIBC_2.2"); + real_timer_settime_233 = dlvsym(RTLD_NEXT, "timer_settime","GLIBC_2.3.3"); +#endif + if (NULL == real_timer_settime_233) + { + real_timer_settime_233 = dlsym(RTLD_NEXT, "timer_settime"); + } +#ifdef __GLIBC__ + real_timer_gettime_22 = dlvsym(RTLD_NEXT, "timer_gettime","GLIBC_2.2"); + real_timer_gettime_233 = dlvsym(RTLD_NEXT, "timer_gettime","GLIBC_2.3.3"); +#endif + if (NULL == real_timer_gettime_233) + { + real_timer_gettime_233 = dlsym(RTLD_NEXT, "timer_gettime"); + } +#endif +#endif +#endif + + dont_fake = true; // Do not fake times during initialization + dont_fake_final = false; + initialized = 1; + + ft_shm_init(); +#ifdef FAKE_STAT + if (getenv("NO_FAKE_STAT")!=NULL) + { + fake_stat_disabled = 1; //Note that this is NOT re-checked + } +#endif + + if ((tmp_env = getenv("FAKETIME_CACHE_DURATION")) != NULL) + { + cache_duration = atoi(tmp_env); + } + if ((tmp_env = getenv("FAKETIME_NO_CACHE")) != NULL) + { + if (0 == strcmp(tmp_env, "1")) + { + cache_enabled = 0; + } + } + if ((tmp_env = getenv("DONT_FAKE_MONOTONIC")) != NULL) + { + if (0 == strcmp(tmp_env, "1")) + { + fake_monotonic_clock = 0; + } + } + /* Check whether we actually should be faking the returned timestamp. */ + + /* We can prevent faking time for specified commands */ + if ((tmp_env = getenv("FAKETIME_SKIP_CMDS")) != NULL) + { + char *skip_cmd, *saveptr, *tmpvar; + /* Don't mess with the env variable directly. */ + tmpvar = strdup(tmp_env); + if (tmpvar != NULL) + { + skip_cmd = strtok_r(tmpvar, ",", &saveptr); + while (skip_cmd != NULL) + { + if (0 == strcmp(progname, skip_cmd)) + { + ft_mode = FT_NOOP; + dont_fake_final = true; + break; + } + skip_cmd = strtok_r(NULL, ",", &saveptr); + } + free(tmpvar); + tmpvar = NULL; + } + else + { + fprintf(stderr, "Error: Could not copy the environment variable value.\n"); + exit(EXIT_FAILURE); + } + } + + /* We can limit faking time to specified commands */ + if ((tmp_env = getenv("FAKETIME_ONLY_CMDS")) != NULL) + { + char *only_cmd, *saveptr, *tmpvar; + bool cmd_matched = false; + + if (getenv("FAKETIME_SKIP_CMDS") != NULL) + { + fprintf(stderr, "Error: Both FAKETIME_SKIP_CMDS and FAKETIME_ONLY_CMDS can't be set.\n"); + exit(EXIT_FAILURE); + } + + /* Don't mess with the env variable directly. */ + tmpvar = strdup(tmp_env); + if (tmpvar != NULL) { + only_cmd = strtok_r(tmpvar, ",", &saveptr); + while (only_cmd != NULL) + { + if (0 == strcmp(progname, only_cmd)) + { + cmd_matched = true; + break; + } + only_cmd = strtok_r(NULL, ",", &saveptr); + } + + if (!cmd_matched) + { + ft_mode = FT_NOOP; + dont_fake_final = true; + } + free(tmpvar); + } else { + fprintf(stderr, "Error: Could not copy the environment variable value.\n"); + exit(EXIT_FAILURE); + } + } + + if ((tmp_env = getenv("FAKETIME_START_AFTER_SECONDS")) != NULL) + { + ft_start_after_secs = atol(tmp_env); + limited_faking = true; + } + if ((tmp_env = getenv("FAKETIME_STOP_AFTER_SECONDS")) != NULL) + { + ft_stop_after_secs = atol(tmp_env); + limited_faking = true; + } + if ((tmp_env = getenv("FAKETIME_START_AFTER_NUMCALLS")) != NULL) + { + ft_start_after_ncalls = atol(tmp_env); + limited_faking = true; + } + if ((tmp_env = getenv("FAKETIME_STOP_AFTER_NUMCALLS")) != NULL) + { + ft_stop_after_ncalls = atol(tmp_env); + limited_faking = true; + } + + /* check whether we should spawn an external command */ + if ((tmp_env = getenv("FAKETIME_SPAWN_TARGET")) != NULL) + { + spawnsupport = true; + (void) strncpy(ft_spawn_target, getenv("FAKETIME_SPAWN_TARGET"), sizeof(ft_spawn_target) - 1); + ft_spawn_target[sizeof(ft_spawn_target) - 1] = 0; + if ((tmp_env = getenv("FAKETIME_SPAWN_SECONDS")) != NULL) + { + ft_spawn_secs = atol(tmp_env); + } + if ((tmp_env = getenv("FAKETIME_SPAWN_NUMCALLS")) != NULL) + { + ft_spawn_ncalls = atol(tmp_env); + } + } + + if ((tmp_env = getenv("FAKETIME_SAVE_FILE")) != NULL) + { + if (-1 == (outfile = open(tmp_env, O_RDWR | O_APPEND | O_CLOEXEC | O_CREAT, + S_IWUSR | S_IRUSR))) + { + perror("Opening file for saving timestamps failed"); + exit(EXIT_FAILURE); + } + } + + /* load file only if reading timstamps from it is not finished yet */ + if ((tmp_env = getenv("FAKETIME_LOAD_FILE")) != NULL) + { + int infile = -1; + struct stat sb; + if (-1 == (infile = open(tmp_env, O_RDONLY|O_CLOEXEC))) + { + perror("Opening file for loading timestamps failed"); + exit(EXIT_FAILURE); + } + + fstat(infile, &sb); + if (sizeof(stss[0]) > (infile_size = sb.st_size)) + { + printf("There are no timestamps in the provided file to load timestamps from"); + exit(EXIT_FAILURE); + } + + if ((infile_size % sizeof(stss[0])) != 0) + { + printf("File size is not multiple of timestamp size. It is probably damaged."); + exit(EXIT_FAILURE); + } + + stss = mmap(NULL, infile_size, PROT_READ, MAP_SHARED, infile, 0); + if (stss == MAP_FAILED) + { + perror("Mapping file for loading timestamps failed"); + exit(EXIT_FAILURE); + } + infile_set = true; + } + + tmp_env = getenv("FAKETIME_FMT"); + if (tmp_env == NULL) + { + strcpy(user_faked_time_fmt, "%Y-%m-%d %T"); + } + else + { + strncpy(user_faked_time_fmt, tmp_env, BUFSIZ - 1); + user_faked_time_fmt[BUFSIZ - 1] = 0; + } + + if (shared_sem != 0) + { + if (sem_wait(shared_sem) == -1) + { + perror("sem_wait"); + exit(1); + } + if (ft_shared->start_time.real.tv_nsec == -1) + { + /* set up global start time */ + system_time_from_system(&ftpl_starttime); + ft_shared->start_time = ftpl_starttime; + } + else + { + /** get preset start time */ + ftpl_starttime = ft_shared->start_time; + } + if (sem_post(shared_sem) == -1) + { + perror("sem_post"); + exit(1); + } + } + else + { + system_time_from_system(&ftpl_starttime); + } + /* fake time supplied as environment variable? */ + if (NULL != (tmp_env = getenv("FAKETIME"))) + { + parse_config_file = false; + parse_ft_string(tmp_env); + } + + dont_fake = dont_fake_final; +} + + +/* + * ======================================================================= + * Helper functions === HELPER + * ======================================================================= + */ + +static void remove_trailing_eols(char *line) +{ + char *endp = line + strlen(line); + /* + * erase the last char if it's a newline + * or carriage return, and back up. + * keep doing this, but don't back up + * past the beginning of the string. + */ +# define is_eolchar(c) ((c) == '\n' || (c) == '\r') + while (endp > line && is_eolchar(endp[-1])) + { + *--endp = '\0'; + } +} + + +/* + * ======================================================================= + * Implementation of faked functions === FAKE(FAKE) + * ======================================================================= + */ + +#ifdef PTHREAD_SINGLETHREADED_TIME +static void pthread_cleanup_mutex_lock(void *data) +{ + pthread_mutex_t *mutex = data; + pthread_mutex_unlock(mutex); +} +#endif + +int fake_clock_gettime(clockid_t clk_id, struct timespec *tp) +{ + /* variables used for caching, introduced in version 0.6 */ + static time_t last_data_fetch = 0; /* not fetched previously at first call */ + static int cache_expired = 1; /* considered expired at first call */ + + if (dont_fake) return 0; + /* Per process timers are only sped up or slowed down */ + if ((clk_id == CLOCK_PROCESS_CPUTIME_ID ) || (clk_id == CLOCK_THREAD_CPUTIME_ID)) + { + if (user_rate_set) + { + timespecmul(tp, user_rate, tp); + } + return 0; + } + + /* Sanity check by Karl Chan since v0.8 */ + if (tp == NULL) return -1; + +#ifdef PTHREAD_SINGLETHREADED_TIME + static pthread_mutex_t time_mutex=PTHREAD_MUTEX_INITIALIZER; + pthread_mutex_lock(&time_mutex); + pthread_cleanup_push(pthread_cleanup_mutex_lock, &time_mutex); +#endif + + if ((limited_faking && + ((ft_start_after_ncalls != -1) || (ft_stop_after_ncalls != -1))) || + (spawnsupport && ft_spawn_ncalls)) + { + if (callcounter < LONG_MAX) callcounter++; + } + + if (limited_faking || spawnsupport) + { + struct timespec tmp_ts; + /* For debugging, output #seconds and #calls */ + switch (clk_id) + { + case CLOCK_REALTIME: +#ifdef CLOCK_REALTIME_COARSE + case CLOCK_REALTIME_COARSE: +#endif + timespecsub(tp, &ftpl_starttime.real, &tmp_ts); + break; + case CLOCK_MONOTONIC: +#ifdef CLOCK_MONOTONIC_COARSE + case CLOCK_MONOTONIC_COARSE: +#endif + timespecsub(tp, &ftpl_starttime.mon, &tmp_ts); + break; + case CLOCK_MONOTONIC_RAW: + timespecsub(tp, &ftpl_starttime.mon_raw, &tmp_ts); + break; +#ifdef CLOCK_BOOTTIME + case CLOCK_BOOTTIME: + timespecsub(tp, &ftpl_starttime.boot, &tmp_ts); + break; +#endif + default: + timespecsub(tp, &ftpl_starttime.real, &tmp_ts); + break; + } + + if (limited_faking) + { + /* Check whether we actually should be faking the returned timestamp. */ + /* fprintf(stderr, "(libfaketime limits -> runtime: %lu, callcounter: %lu\n", (*time_tptr - ftpl_starttime), callcounter); */ + if ((ft_start_after_secs != -1) && (tmp_ts.tv_sec < ft_start_after_secs)) return 0; + if ((ft_stop_after_secs != -1) && (tmp_ts.tv_sec >= ft_stop_after_secs)) return 0; + if ((ft_start_after_ncalls != -1) && (callcounter < ft_start_after_ncalls)) return 0; + if ((ft_stop_after_ncalls != -1) && (callcounter >= ft_stop_after_ncalls)) return 0; + /* fprintf(stderr, "(libfaketime limits -> runtime: %lu, callcounter: %lu continues\n", (*time_tptr - ftpl_starttime), callcounter); */ + } + + if (spawnsupport) + { + /* check whether we should spawn an external command */ + if (spawned == 0) + { /* exec external command once only */ + if (((tmp_ts.tv_sec == ft_spawn_secs) || (callcounter == ft_spawn_ncalls)) && (spawned == 0)) + { + spawned = 1; + (void) (system(ft_spawn_target) + 1); + } + } + } + } + + if (last_data_fetch > 0) + { + if ((tp->tv_sec - last_data_fetch) > cache_duration) + { + cache_expired = 1; + } + else + { + cache_expired = 0; + } + } + + if (cache_enabled == 0) + { + cache_expired = 1; + } + + if (cache_expired == 1) + { + static char user_faked_time[BUFFERLEN]; /* changed to static for caching in v0.6 */ + /* initialize with default or env. variable */ + char *tmp_env; + + /* Can be enabled for testing ... + fprintf(stderr, "***************++ Cache expired ++**************\n"); + */ + + if (NULL != (tmp_env = getenv("FAKETIME"))) + { + strncpy(user_faked_time, tmp_env, BUFFERLEN - 1); + user_faked_time[BUFFERLEN - 1] = 0; + } + else + { + snprintf(user_faked_time, BUFFERLEN, "+0"); + } + + last_data_fetch = tp->tv_sec; + /* fake time supplied as environment variable? */ + if (parse_config_file) + { + char custom_filename[BUFSIZ]; + char filename[BUFSIZ]; + FILE *faketimerc; + /* check whether there's a .faketimerc in the user's home directory, or + * a system-wide /etc/faketimerc present. + * The /etc/faketimerc handling has been contributed by David Burley, + * Jacob Moorman, and Wayne Davison of SourceForge, Inc. in version 0.6 */ + (void) snprintf(custom_filename, BUFSIZ, "%s", getenv("FAKETIME_TIMESTAMP_FILE")); + (void) snprintf(filename, BUFSIZ, "%s/.faketimerc", getenv("HOME")); + if ((faketimerc = fopen(custom_filename, "rt")) != NULL || + (faketimerc = fopen(filename, "rt")) != NULL || + (faketimerc = fopen("/etc/faketimerc", "rt")) != NULL) + { + char line[BUFFERLEN]; + while(fgets(line, BUFFERLEN, faketimerc) != NULL) + { + if ((strlen(line) > 1) && (line[0] != ' ') && + (line[0] != '#') && (line[0] != ';')) + { + remove_trailing_eols(line); + strncpy(user_faked_time, line, BUFFERLEN-1); + user_faked_time[BUFFERLEN-1] = 0; + break; + } + } + fclose(faketimerc); + } + } /* read fake time from file */ + parse_ft_string(user_faked_time); + } /* cache had expired */ + + if (infile_set) + { + if (load_time(tp)) + { + return 0; + } + } + + /* check whether the user gave us an absolute time to fake */ + switch (ft_mode) + { + case FT_FREEZE: /* a specified time */ + if (user_faked_time_set) + { + *tp = user_faked_time_timespec; + } + break; + + case FT_START_AT: /* User-specified offset */ + if (user_per_tick_inc_set) + { + /* increment time with every time() call*/ + next_time(tp, &user_per_tick_inc); + } + else + { + /* Speed-up / slow-down contributed by Karl Chen in v0.8 */ + struct timespec tdiff, timeadj; + switch (clk_id) + { + case CLOCK_REALTIME: +#ifdef CLOCK_REALTIME_COARSE + case CLOCK_REALTIME_COARSE: +#endif + timespecsub(tp, &ftpl_starttime.real, &tdiff); + break; + case CLOCK_MONOTONIC: +#ifdef CLOCK_MONOTONIC_COARSE + case CLOCK_MONOTONIC_COARSE: +#endif + timespecsub(tp, &ftpl_starttime.mon, &tdiff); + break; + case CLOCK_MONOTONIC_RAW: + timespecsub(tp, &ftpl_starttime.mon_raw, &tdiff); + break; +#ifdef CLOCK_BOOTTIME + case CLOCK_BOOTTIME: + timespecsub(tp, &ftpl_starttime.boot, &tdiff); + break; +#endif + default: + timespecsub(tp, &ftpl_starttime.real, &tdiff); + break; + } // end of switch (clk_id) + if (user_rate_set) + { + timespecmul(&tdiff, user_rate, &timeadj); + } + else + { + timeadj = tdiff; + } + timespecadd(&user_faked_time_timespec, &timeadj, tp); + } + break; + + default: + return -1; + } // end of switch(ft_mode) + +#ifdef PTHREAD_SINGLETHREADED_TIME + pthread_cleanup_pop(1); +#endif + save_time(tp); + return 0; +} + +int fake_gettimeofday(struct timeval *tv) +{ + struct timespec ts; + int ret; + ts.tv_sec = tv->tv_sec; + ts.tv_nsec = tv->tv_usec * 1000 + ftpl_starttime.real.tv_nsec % 1000; + + ret = fake_clock_gettime(CLOCK_REALTIME, &ts); + tv->tv_sec = ts.tv_sec; + tv->tv_usec =ts.tv_nsec / 1000; + + return ret; +} + + +/* + * ======================================================================= + * Faked system functions: Apple Mac OS X specific === FAKE(OSX) + * ======================================================================= + */ + +#ifdef __APPLEOSX__ +/* + * clock_gettime implementation for __APPLE__ + * @note It always behave like being called with CLOCK_REALTIME. + */ +static int apple_clock_gettime(clockid_t clk_id, struct timespec *tp) +{ + int result; + mach_timespec_t cur_timeclockid_t; + (void) clk_id; /* unused */ + + if (NULL == real_clock_get_time) + { /* dlsym() failed */ +#ifdef DEBUG + (void) fprintf(stderr, "faketime problem: original clock_get_time() not found.\n"); +#endif + return -1; /* propagate error to caller */ + } + + DONT_FAKE_TIME(result = (*real_clock_get_time)(clock_serv_real, &cur_timeclockid_t)); + tp->tv_sec = cur_timeclockid_t.tv_sec; + tp->tv_nsec = cur_timeclockid_t.tv_nsec; + return result; +} + +int clock_get_time(clock_serv_t clock_serv, mach_timespec_t *cur_timeclockid_t) +{ + int result; + struct timespec ts; + + /* + * Initialize our result with the real current time from CALENDAR_CLOCK. + * This is a bit of cheating, but we don't keep track of obtained clock + * services. + */ + DONT_FAKE_TIME(result = (*real_clock_gettime)(CLOCK_REALTIME, &ts)); + if (result == -1) return result; /* original function failed */ + + /* pass the real current time to our faking version, overwriting it */ + result = fake_clock_gettime(CLOCK_REALTIME, &ts); + cur_timeclockid_t->tv_sec = ts.tv_sec; + cur_timeclockid_t->tv_nsec = ts.tv_nsec; + + /* return the result to the caller */ + return result; +} +#endif + + +/* + * ======================================================================= + * Faked system-internal functions === FAKE(INT) + * ======================================================================= + */ + +#ifdef FAKE_INTERNAL_CALLS +int __gettimeofday(struct timeval *tv, void *tz) +{ + int result; + + /* sanity check */ + if (tv == NULL) + { + return -1; + } + + /* Check whether we've got a pointer to the real ftime() function yet */ + if (NULL == real___gettimeofday) + { /* dlsym() failed */ +#ifdef DEBUG + (void) fprintf(stderr, "faketime problem: original __gettimeofday() not found.\n"); +#endif + return -1; /* propagate error to caller */ + } + + /* initialize our result with the real current time */ + DONT_FAKE_TIME(result = (*real___gettimeofday)(tv, tz)); + if (result == -1) return result; /* original function failed */ + + /* pass the real current time to our faking version, overwriting it */ + result = fake_gettimeofday(tv); + + /* return the result to the caller */ + return result; +} + +int __clock_gettime(clockid_t clk_id, struct timespec *tp) +{ + int result; + + /* sanity check */ + if (tp == NULL) + { + return -1; + } + + if (NULL == real___clock_gettime) + { /* dlsym() failed */ +#ifdef DEBUG + (void) fprintf(stderr, "faketime problem: original __clock_gettime() not found.\n"); +#endif + return -1; /* propagate error to caller */ + } + + /* initialize our result with the real current time */ + DONT_FAKE_TIME(result = (*real___clock_gettime)(clk_id, tp)); + if (result == -1) return result; /* original function failed */ + + /* pass the real current time to our faking version, overwriting it */ + if (fake_monotonic_clock || (clk_id != CLOCK_MONOTONIC && clk_id != CLOCK_MONOTONIC_RAW +#ifdef CLOCK_MONOTONIC_COARSE + && clk_id != CLOCK_MONOTONIC_COARSE +#endif +#ifdef CLOCK_BOOTTIME + && clk_id != CLOCK_BOOTTIME +#endif + )) + + { + result = fake_clock_gettime(clk_id, tp); + } + + /* return the result to the caller */ + return result; +} + +time_t __time(time_t *time_tptr) +{ + struct timespec tp; + time_t result; + + DONT_FAKE_TIME(result = (*real_clock_gettime)(CLOCK_REALTIME, &tp)); + if (result == -1) return -1; + + /* pass the real current time to our faking version, overwriting it */ + (void)fake_clock_gettime(CLOCK_REALTIME, &tp); + + if (time_tptr != NULL) + { + *time_tptr = tp.tv_sec; + } + return tp.tv_sec; +} + +int __ftime(struct timeb *tb) +{ + struct timespec tp; + int result; + + /* sanity check */ + if (tb == NULL) + return 0; /* ftime() always returns 0, see manpage */ + + /* Check whether we've got a pointer to the real ftime() function yet */ + if (NULL == real___ftime) + { /* dlsym() failed */ +#ifdef DEBUG + (void) fprintf(stderr, "faketime problem: original ftime() not found.\n"); +#endif + return 0; /* propagate error to caller */ + } + + /* initialize our TZ result with the real current time */ + DONT_FAKE_TIME(result = (*real___ftime)(tb)); + if (result == -1) + { + return result; + } + + DONT_FAKE_TIME(result = (*real_clock_gettime)(CLOCK_REALTIME, &tp)); + if (result == -1) return -1; + + /* pass the real current time to our faking version, overwriting it */ + (void)fake_clock_gettime(CLOCK_REALTIME, &tp); + + tb->time = tp.tv_sec; + tb->millitm = tp.tv_nsec / 1000000; + + /* return the result to the caller */ + return result; /* will always be 0 (see manpage) */ +} + +#endif + +/* + * ======================================================================= + * Faked pthread_cond_timedwait === FAKE(pthread) + * ======================================================================= + */ + +/* pthread_cond_timedwait + + The specified absolute time in pthread_cond_timedwait is directly + passed to the kernel via the futex syscall. The kernel, however, + does not know about the fake time. In 99.9% of cases, the time + until this function should wait is calculated by an application + relatively to the current time, which has been faked in the + application. Hence, we should convert the waiting time back to real + time. + + pthread_cond_timedwait in GLIBC_2_2_5 only supports + CLOCK_REALTIME. Since the init and destroy functions are not + redefined for GLIBC_2_2_5, a corresponding cond will never be + added to monotonic_conds and hence the correct branch will + always be taken. +*/ + + +#ifdef FAKE_PTHREAD + +typedef enum {FT_COMPAT_GLIBC_2_2_5, FT_COMPAT_GLIBC_2_3_2} ft_lib_compat_pthread; + +struct pthread_cond_monotonic { + pthread_cond_t *ptr; + UT_hash_handle hh; +}; + +static struct pthread_cond_monotonic *monotonic_conds = NULL; + +int pthread_cond_init_232(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr) +{ + clockid_t clock_id; + int result; + + result = real_pthread_cond_init_232(cond, attr); + + if (result != 0 || attr == NULL) + return result; + + pthread_condattr_getclock(attr, &clock_id); + + if (clock_id == CLOCK_MONOTONIC) { + struct pthread_cond_monotonic *e = (struct pthread_cond_monotonic*)malloc(sizeof(struct pthread_cond_monotonic)); + e->ptr = cond; + HASH_ADD_PTR(monotonic_conds, ptr, e); + } + + return result; +} + +int pthread_cond_destroy_232(pthread_cond_t *cond) +{ + struct pthread_cond_monotonic* e; + HASH_FIND_PTR(monotonic_conds, &cond, e); + if (e) { + HASH_DEL(monotonic_conds, e); + free(e); + } + + return real_pthread_cond_destroy_232(cond); +} + +int pthread_cond_timedwait_common(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime, ft_lib_compat_pthread compat) +{ + struct timespec tp, tdiff_actual, realtime, faketime; + struct timespec *tf = NULL; + struct pthread_cond_monotonic* e; + char *tmp_env; + int wait_ms; + clockid_t clk_id; + int result = 0; + + if (abstime != NULL) + { + HASH_FIND_PTR(monotonic_conds, &cond, e); + if (e != NULL) + clk_id = CLOCK_MONOTONIC; + else + clk_id = CLOCK_REALTIME; + + DONT_FAKE_TIME(result = (*real_clock_gettime)(clk_id, &realtime)); + if (result == -1) + { + return EINVAL; + } + faketime = realtime; + (void)fake_clock_gettime(clk_id, &faketime); + + if ((tmp_env = getenv("FAKETIME_WAIT_MS")) != NULL) + { + wait_ms = atol(tmp_env); + DONT_FAKE_TIME(result = (*real_clock_gettime)(clk_id, &realtime)); + if (result == -1) + { + return EINVAL; + } + + tdiff_actual.tv_sec = wait_ms / 1000; + tdiff_actual.tv_nsec = (wait_ms % 1000) * 1000000; + timespecadd(&realtime, &tdiff_actual, &tp); + + tf = &tp; + } + else + { + timespecsub(abstime, &faketime, &tp); + if (user_rate_set) + { + timespecmul(&tp, 1.0 / user_rate, &tdiff_actual); + } + else + { + tdiff_actual = tp; + } + } + + /* For CLOCK_MONOTONIC, pthread_cond_timedwait uses clock_gettime + internally to calculate the appropriate duration for the + waiting time. This already uses the faked functions, hence, the + fake time needs to be passed to pthread_cond_timedwait for + CLOCK_MONOTONIC. */ + if(clk_id == CLOCK_MONOTONIC) + timespecadd(&faketime, &tdiff_actual, &tp); + else + timespecadd(&realtime, &tdiff_actual, &tp); + + tf = &tp; + } + + switch (compat) { + case FT_COMPAT_GLIBC_2_3_2: + result = real_pthread_cond_timedwait_232(cond, mutex, tf); + break; + case FT_COMPAT_GLIBC_2_2_5: + result = real_pthread_cond_timedwait_225(cond, mutex, tf); + break; + } + return result; +} + +int pthread_cond_timedwait_225(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime) +{ + return pthread_cond_timedwait_common(cond, mutex, abstime, FT_COMPAT_GLIBC_2_2_5); +} + +int pthread_cond_timedwait_232(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime) +{ + return pthread_cond_timedwait_common(cond, mutex, abstime, FT_COMPAT_GLIBC_2_3_2); +} + +__asm__(".symver pthread_cond_timedwait_225, pthread_cond_timedwait@GLIBC_2.2.5"); +__asm__(".symver pthread_cond_timedwait_232, pthread_cond_timedwait@@GLIBC_2.3.2"); +__asm__(".symver pthread_cond_init_232, pthread_cond_init@@GLIBC_2.3.2"); +__asm__(".symver pthread_cond_destroy_232, pthread_cond_destroy@@GLIBC_2.3.2"); + +#endif + + +/* + * Editor modelines + * + * Local variables: + * c-basic-offset: 2 + * tab-width: 2 + * indent-tabs-mode: nil + * End: + * + * vi: set shiftwidth=2 tabstop=2 expandtab: + * :indentSize=2:tabSize=2:noTabs=true: + */ + +/* eof */ diff --git a/tests/deckard/contrib/libfaketime/src/libfaketime.map b/tests/deckard/contrib/libfaketime/src/libfaketime.map new file mode 100644 index 0000000..eb873e7 --- /dev/null +++ b/tests/deckard/contrib/libfaketime/src/libfaketime.map @@ -0,0 +1,21 @@ +GLIBC_2.2 { + global: + + timer_gettime; timer_settime; + local: timer_settime_*; timer_gettime_*; +}; + +GLIBC_2.3.3 { + # Changed timer_t. + timer_gettime; timer_settime; +} GLIBC_2.2; + +GLIBC_2.2.5 { + global: pthread_cond_timedwait; + local: pthread_cond_timedwait_*; pthread_cond_init_*; pthread_cond_destroy*; +}; + +GLIBC_2.3.2 { + pthread_cond_timedwait; pthread_cond_init; pthread_cond_destroy; +} GLIBC_2.2.5; + diff --git a/tests/deckard/contrib/libfaketime/src/sunos_endian.h b/tests/deckard/contrib/libfaketime/src/sunos_endian.h new file mode 100644 index 0000000..b15996a --- /dev/null +++ b/tests/deckard/contrib/libfaketime/src/sunos_endian.h @@ -0,0 +1,12 @@ + +#ifndef SUN_OS_ENDIAN_H +#define SUN_OS_ENDIAN_H + +#include <sys/byteorder.h> + +#define htobe64(x) BE_64(x) +#define be64toh(x) BE_64(x) +#define htole64(x) LE_64(x) +#define le64toh(x) LE_64(x) + +#endif /* SUN_OS_ENDIAN_H */
\ No newline at end of file diff --git a/tests/deckard/contrib/libfaketime/src/time_ops.h b/tests/deckard/contrib/libfaketime/src/time_ops.h new file mode 100644 index 0000000..59ab1ee --- /dev/null +++ b/tests/deckard/contrib/libfaketime/src/time_ops.h @@ -0,0 +1,104 @@ +/* + * Time operation macros based on sys/time.h + * Copyright 2013 Balint Reczey <balint@balintreczey.hu> + * + * This file is part of libfaketime. + * + * libfaketime is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License v2 as published by the Free + * Software Foundation. + * + * libfaketime 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 v2 along + * with libfaketime; if not, write to the Free Software Foundation, Inc., + * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef TIME_OPS_H +#define TIME_OPS_H +#include <time.h> + +#define SEC_TO_uSEC 1000000 +#define SEC_TO_nSEC 1000000000 + +/* Convenience macros for operations on timevals. + NOTE: `timercmp' does not work for >= or <=. */ +#define timerisset2(tvp, prefix) ((tvp)->tv_sec || (tvp)->tv_##prefix##sec) +#define timerclear2(tvp, prefix) ((tvp)->tv_sec = (tvp)->tv_##prefix##sec = 0) +#define timercmp2(a, b, CMP, prefix) \ + (((a)->tv_sec == (b)->tv_sec) ? \ + ((a)->tv_##prefix##sec CMP (b)->tv_##prefix##sec) : \ + ((a)->tv_sec CMP (b)->tv_sec)) +#define timeradd2(a, b, result, prefix) \ + do \ + { \ + (result)->tv_sec = (a)->tv_sec + (b)->tv_sec; \ + (result)->tv_##prefix##sec = (a)->tv_##prefix##sec + \ + (b)->tv_##prefix##sec; \ + if ((result)->tv_##prefix##sec >= SEC_TO_##prefix##SEC) \ + { \ + ++(result)->tv_sec; \ + (result)->tv_##prefix##sec -= SEC_TO_##prefix##SEC; \ + } \ + } while (0) +#define timersub2(a, b, result, prefix) \ + do \ + { \ + (result)->tv_sec = (a)->tv_sec - (b)->tv_sec; \ + (result)->tv_##prefix##sec = (a)->tv_##prefix##sec - \ + (b)->tv_##prefix##sec; \ + if ((result)->tv_##prefix##sec < 0) \ + { \ + --(result)->tv_sec; \ + (result)->tv_##prefix##sec += SEC_TO_##prefix##SEC; \ + } \ + } while (0) +#define timermul2(tvp, c, result, prefix) \ + do \ + { \ + long long tmp_time; \ + tmp_time = (c) * ((tvp)->tv_sec * SEC_TO_##prefix##SEC + \ + (tvp)->tv_##prefix##sec); \ + (result)->tv_##prefix##sec = tmp_time % SEC_TO_##prefix##SEC; \ + (result)->tv_sec = (tmp_time - (result)->tv_##prefix##sec) / \ + SEC_TO_##prefix##SEC; \ + if ((result)->tv_##prefix##sec < 0) \ + { \ + (result)->tv_##prefix##sec += SEC_TO_##prefix##SEC; \ + (result)->tv_sec -= 1; \ + } \ + } while (0) + +/* ops for microsecs */ +#ifndef timerisset +#define timerisset(tvp) timerisset2(tvp,u) +#endif +#ifndef timerclear +#define timerclear(tvp) timerclear2(tvp, u) +#endif +#ifndef timercmp +#define timercmp(a, b, CMP) timercmp2(a, b, CMP, u) +#endif +#ifndef timeradd +#define timeradd(a, b, result) timeradd2(a, b, result, u) +#endif +#ifndef timersub +#define timersub(a, b, result) timersub2(a, b, result, u) +#endif +#ifndef timersub +#define timermul(a, c, result) timermul2(a, c, result, u) +#endif + +/* ops for nanosecs */ +#define timespecisset(tvp) timerisset2(tvp,n) +#define timespecclear(tvp) timerclear2(tvp, n) +#define timespeccmp(a, b, CMP) timercmp2(a, b, CMP, n) +#define timespecadd(a, b, result) timeradd2(a, b, result, n) +#define timespecsub(a, b, result) timersub2(a, b, result, n) +#define timespecmul(a, c, result) timermul2(a, c, result, n) + +#endif diff --git a/tests/deckard/contrib/libfaketime/src/timeprivacy b/tests/deckard/contrib/libfaketime/src/timeprivacy new file mode 100644 index 0000000..5fd6fd7 --- /dev/null +++ b/tests/deckard/contrib/libfaketime/src/timeprivacy @@ -0,0 +1,270 @@ +#!/bin/bash + +## Copyright (c) 2013, adrelanos at riseup dot net +## All rights reserved. +## +## Redistribution and use in source and binary forms, with or without +## modification, are permitted provided that the following conditions are met: +## +## 1. Redistributions of source code must retain the above copyright notice, this +## list of conditions and the following disclaimer. +## 2. Redistributions in binary form must reproduce the above copyright notice, +## this list of conditions and the following disclaimer in the documentation +## and/or other materials provided with the distribution. +## +## THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +## ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +## WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +## DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +## ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +## (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +## LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +## ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +## (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +## SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#set -x + +SCRIPTNAME="$(basename $0)" + +usage() { + echo "$SCRIPTNAME + +Usage: $SCRIPTNAME [-h help] [-d day] [-m month] [-y year] [-i increment in seconds (0-60)] [-r random increment in seconds (0-60)] [-f history folder] +Example: $SCRIPTNAME -d 30 -m 12 -y 2013 -i 10 -f /tmp/$SCRIPTNAMEtest + sudo $SCRIPTNAME -d 30 -m 12 -y 2013 -r -f /tmp/$SCRIPTNAMEtest" +} + +_randomincrement="none" +_increment="none" + +while [ -n "$1" ]; do + case "$1" in + -h) + usage + exit 0 + ;; + -d) + _day="$2" + shift + ;; + -m) + _month="$2" + shift + ;; + -y) + _year="$2" + shift + ;; + -i) + _increment="$2" + shift + ;; + -r) + _randomincrement="$2" + shift + ;; + -f) + TIMEDIR="$2" + shift + ;; + *) + command="$(which $1)" + ## From now on the complete to-be wrapped command + its args + ## are stored in $@, which will expand like we want it for + ## handling quoted arguments with whitespaces in it, etc. + break + esac + shift +done + +if [ -z "$_day" ]; then + _day="$(date +"%d")" +fi + +if [ -z "$_month" ]; then + _month="$(date +"%m")" +fi + +if [ -z "$_year" ]; then + _year="$(date +"%Y")" +fi + +if [ "$_randomincrement" = "none" ] && [ "$_increment" = "none" ]; then + _increment="1" +fi + +if [ "$_randomincrement" = "none" ]; then + if [ -z "$_increment" ]; then + _increment="1" + fi +elif [ "$_increment" = "none" ]; then + if [ "$_randomincrement" = "" ]; then + echo "randomincrement must be a positive number." + exit 1 + else + ## random number between 1 and $_randomincrement + random_number="$(( 0+($(od -An -N2 -i /dev/random) )%($_randomincrement-0+1) ))" + _increment="$random_number" + fi +else + echo "You can not combine -r and -i." + exit 1 +fi + +if [ -z "$TIMEDIR" ]; then + TIMEDIR=~/.timeprivacy +fi + +nodigits="$(echo $_increment | sed 's/[[:digit:]]//g')" +if [ ! -z "$nodigits" ]; then + echo "increment is not a digit." + exit 1 +fi + +nodigits="$(echo $_year | sed 's/[[:digit:]]//g')" +if [ ! -z "$nodigits" ]; then + echo "_day is not a digit." + exit 1 +fi + +nodigits="$(echo $_year | sed 's/[[:digit:]]//g')" +if [ ! -z "$nodigits" ]; then + echo "year is not a digit." + exit 1 +fi + +nodigits="$(echo $_month | sed 's/[[:digit:]]//g')" +if [ ! -z "$nodigits" ]; then + echo "month is not a digit." + exit 1 +fi + +nodigits="$(echo $_day | sed 's/[[:digit:]]//g')" +if [ ! -z "$nodigits" ]; then + echo "day is not a digit." + exit 1 +fi + +nodigits="$(echo $_increment | sed 's/[[:digit:]]//g')" +if [ ! -z "$nodigits" ]; then + echo "increment is not a digit." + exit 1 +fi + +SECONDS_FILE="$TIMEDIR/seconds_file" +MINUTES_FILE="$TIMEDIR/minutes_file" +HOURS_FILE="$TIMEDIR/hours_file" + +#DAYS_FILE="$TIMEDIR/days_file" +#MONTHS_FILE="$TIMEDIR/months_file" +#YEARS_FILE="$TIMEDIR/years_file" + +#true "TIMEDIR: $TIMEDIR" +#true "year: $_year" +#true "month: $_month" +#true "day: $_day" +#true "_randomincrement: $_randomincrement" +#true "_increment: $_increment" + +read_date_file() { + if [ ! -d "$TIMEDIR" ]; then + mkdir -p "$TIMEDIR" + fi + + if [ ! -f "$SECONDS_FILE" ]; then + echo "0" > "$SECONDS_FILE" + fi + + if [ ! -f "$MINUTES_FILE" ]; then + echo "0" > "$MINUTES_FILE" + fi + + if [ ! -f "$HOURS_FILE" ]; then + echo "0" > "$HOURS_FILE" + fi + + #if [ ! -f "$DAYS_FILE" ]; then + #echo "1" > "$DAYS_FILE" + #fi + + #if [ ! -f "$MONTHS_FILE" ]; then + #echo "1" > "$MONTHS_FILE" + #fi + + #if [ ! -f "$YEARS_FILE" ]; then + #echo "2013" > "$YEARS_FILE" + #fi + + SECONDS="$(cat "$SECONDS_FILE")" + MINUTES="$(cat "$MINUTES_FILE")" + HOURS="$(cat "$HOURS_FILE")" + + if [ -z "$SECONDS" ]; then + SECONDS="0" + fi + + if [ -z "$MINUTES" ]; then + MINUTES="0" + fi + + if [ -z "$HOURS" ]; then + HOURS="0" + fi + + local nodigits="$(echo $SECONDS | sed 's/[[:digit:]]//g')" + if [ ! -z "$nodigits" ]; then + SECONDS="0" + fi + + local nodigits="$(echo $MINUTES | sed 's/[[:digit:]]//g')" + if [ ! -z "$nodigits" ]; then + MINUTES="0" + fi + + local nodigits="$(echo $HOURS | sed 's/[[:digit:]]//g')" + if [ ! -z "$nodigits" ]; then + HOURS="0" + fi + + SECONDS="$(expr "$SECONDS" + "$_increment")" || true + if [ "$SECONDS" -ge "60" ]; then + SECONDS="0" + + MINUTES="$(expr "$MINUTES" + "1")" || true + if [ "$MINUTES" -ge "60" ]; then + MINUTES="0" + + HOURS="$(expr "$HOURS" + "1")" || true + if [ "$HOURS" -ge "24" ]; then + HOURS="0" + fi + echo "$HOURS" > "$HOURS_FILE" + + fi + echo "$MINUTES" > "$MINUTES_FILE" + + fi + + echo "$SECONDS" > "$SECONDS_FILE" + + #echo "$HOURS $MINUTES $SECONDS" +} + +need_new_date() { + ## Testing + #while [ 1 ]; do + # read_date_file + #done + + read_date_file + + ## Testing + #echo "faketime '$_year-$_month-$_day $HOURS:$MINUTES:$SECONDS' /bin/date" + #faketime "$_year-$_month-$_day $HOURS:$MINUTES:$SECONDS" /bin/date + + echo "$_year-$_month-$_day $HOURS:$MINUTES:$SECONDS" +} + +need_new_date + diff --git a/tests/deckard/contrib/libfaketime/src/uthash.h b/tests/deckard/contrib/libfaketime/src/uthash.h new file mode 100644 index 0000000..7e64cac --- /dev/null +++ b/tests/deckard/contrib/libfaketime/src/uthash.h @@ -0,0 +1,1208 @@ +/* +Copyright (c) 2003-2017, Troy D. Hanson http://troydhanson.github.com/uthash/ +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS +IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED +TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER +OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#ifndef UTHASH_H +#define UTHASH_H + +#define UTHASH_VERSION 2.0.2 + +#include <string.h> /* memcmp, memset, strlen */ +#include <stddef.h> /* ptrdiff_t */ +#include <stdlib.h> /* exit */ + +/* These macros use decltype or the earlier __typeof GNU extension. + As decltype is only available in newer compilers (VS2010 or gcc 4.3+ + when compiling c++ source) this code uses whatever method is needed + or, for VS2008 where neither is available, uses casting workarounds. */ +#if !defined(DECLTYPE) && !defined(NO_DECLTYPE) +#if defined(_MSC_VER) /* MS compiler */ +#if _MSC_VER >= 1600 && defined(__cplusplus) /* VS2010 or newer in C++ mode */ +#define DECLTYPE(x) (decltype(x)) +#else /* VS2008 or older (or VS2010 in C mode) */ +#define NO_DECLTYPE +#endif +#elif defined(__BORLANDC__) || defined(__ICCARM__) || defined(__LCC__) || defined(__WATCOMC__) +#define NO_DECLTYPE +#else /* GNU, Sun and other compilers */ +#define DECLTYPE(x) (__typeof(x)) +#endif +#endif + +#ifdef NO_DECLTYPE +#define DECLTYPE(x) +#define DECLTYPE_ASSIGN(dst,src) \ +do { \ + char **_da_dst = (char**)(&(dst)); \ + *_da_dst = (char*)(src); \ +} while (0) +#else +#define DECLTYPE_ASSIGN(dst,src) \ +do { \ + (dst) = DECLTYPE(dst)(src); \ +} while (0) +#endif + +/* a number of the hash function use uint32_t which isn't defined on Pre VS2010 */ +#if defined(_WIN32) +#if defined(_MSC_VER) && _MSC_VER >= 1600 +#include <stdint.h> +#elif defined(__WATCOMC__) || defined(__MINGW32__) || defined(__CYGWIN__) +#include <stdint.h> +#else +typedef unsigned int uint32_t; +typedef unsigned char uint8_t; +#endif +#elif defined(__GNUC__) && !defined(__VXWORKS__) +#include <stdint.h> +#else +typedef unsigned int uint32_t; +typedef unsigned char uint8_t; +#endif + +#ifndef uthash_malloc +#define uthash_malloc(sz) malloc(sz) /* malloc fcn */ +#endif +#ifndef uthash_free +#define uthash_free(ptr,sz) free(ptr) /* free fcn */ +#endif +#ifndef uthash_bzero +#define uthash_bzero(a,n) memset(a,'\0',n) +#endif +#ifndef uthash_memcmp +#define uthash_memcmp(a,b,n) memcmp(a,b,n) +#endif +#ifndef uthash_strlen +#define uthash_strlen(s) strlen(s) +#endif + +#ifndef uthash_noexpand_fyi +#define uthash_noexpand_fyi(tbl) /* can be defined to log noexpand */ +#endif +#ifndef uthash_expand_fyi +#define uthash_expand_fyi(tbl) /* can be defined to log expands */ +#endif + +#ifndef HASH_NONFATAL_OOM +#define HASH_NONFATAL_OOM 0 +#endif + +#if HASH_NONFATAL_OOM +/* malloc failures can be recovered from */ + +#ifndef uthash_nonfatal_oom +#define uthash_nonfatal_oom(obj) do {} while (0) /* non-fatal OOM error */ +#endif + +#define HASH_RECORD_OOM(oomed) do { (oomed) = 1; } while (0) +#define IF_HASH_NONFATAL_OOM(x) x + +#else +/* malloc failures result in lost memory, hash tables are unusable */ + +#ifndef uthash_fatal +#define uthash_fatal(msg) exit(-1) /* fatal OOM error */ +#endif + +#define HASH_RECORD_OOM(oomed) uthash_fatal("out of memory") +#define IF_HASH_NONFATAL_OOM(x) + +#endif + +/* initial number of buckets */ +#define HASH_INITIAL_NUM_BUCKETS 32U /* initial number of buckets */ +#define HASH_INITIAL_NUM_BUCKETS_LOG2 5U /* lg2 of initial number of buckets */ +#define HASH_BKT_CAPACITY_THRESH 10U /* expand when bucket count reaches */ + +/* calculate the element whose hash handle address is hhp */ +#define ELMT_FROM_HH(tbl,hhp) ((void*)(((char*)(hhp)) - ((tbl)->hho))) +/* calculate the hash handle from element address elp */ +#define HH_FROM_ELMT(tbl,elp) ((UT_hash_handle *)(((char*)(elp)) + ((tbl)->hho))) + +#define HASH_ROLLBACK_BKT(hh, head, itemptrhh) \ +do { \ + struct UT_hash_handle *_hd_hh_item = (itemptrhh); \ + unsigned _hd_bkt; \ + HASH_TO_BKT(_hd_hh_item->hashv, (head)->hh.tbl->num_buckets, _hd_bkt); \ + (head)->hh.tbl->buckets[_hd_bkt].count++; \ + _hd_hh_item->hh_next = NULL; \ + _hd_hh_item->hh_prev = NULL; \ +} while (0) + +#define HASH_VALUE(keyptr,keylen,hashv) \ +do { \ + HASH_FCN(keyptr, keylen, hashv); \ +} while (0) + +#define HASH_FIND_BYHASHVALUE(hh,head,keyptr,keylen,hashval,out) \ +do { \ + (out) = NULL; \ + if (head) { \ + unsigned _hf_bkt; \ + HASH_TO_BKT(hashval, (head)->hh.tbl->num_buckets, _hf_bkt); \ + if (HASH_BLOOM_TEST((head)->hh.tbl, hashval) != 0) { \ + HASH_FIND_IN_BKT((head)->hh.tbl, hh, (head)->hh.tbl->buckets[ _hf_bkt ], keyptr, keylen, hashval, out); \ + } \ + } \ +} while (0) + +#define HASH_FIND(hh,head,keyptr,keylen,out) \ +do { \ + unsigned _hf_hashv; \ + HASH_VALUE(keyptr, keylen, _hf_hashv); \ + HASH_FIND_BYHASHVALUE(hh, head, keyptr, keylen, _hf_hashv, out); \ +} while (0) + +#ifdef HASH_BLOOM +#define HASH_BLOOM_BITLEN (1UL << HASH_BLOOM) +#define HASH_BLOOM_BYTELEN (HASH_BLOOM_BITLEN/8UL) + (((HASH_BLOOM_BITLEN%8UL)!=0UL) ? 1UL : 0UL) +#define HASH_BLOOM_MAKE(tbl,oomed) \ +do { \ + (tbl)->bloom_nbits = HASH_BLOOM; \ + (tbl)->bloom_bv = (uint8_t*)uthash_malloc(HASH_BLOOM_BYTELEN); \ + if (!(tbl)->bloom_bv) { \ + HASH_RECORD_OOM(oomed); \ + } else { \ + uthash_bzero((tbl)->bloom_bv, HASH_BLOOM_BYTELEN); \ + (tbl)->bloom_sig = HASH_BLOOM_SIGNATURE; \ + } \ +} while (0) + +#define HASH_BLOOM_FREE(tbl) \ +do { \ + uthash_free((tbl)->bloom_bv, HASH_BLOOM_BYTELEN); \ +} while (0) + +#define HASH_BLOOM_BITSET(bv,idx) (bv[(idx)/8U] |= (1U << ((idx)%8U))) +#define HASH_BLOOM_BITTEST(bv,idx) (bv[(idx)/8U] & (1U << ((idx)%8U))) + +#define HASH_BLOOM_ADD(tbl,hashv) \ + HASH_BLOOM_BITSET((tbl)->bloom_bv, ((hashv) & (uint32_t)((1UL << (tbl)->bloom_nbits) - 1U))) + +#define HASH_BLOOM_TEST(tbl,hashv) \ + HASH_BLOOM_BITTEST((tbl)->bloom_bv, ((hashv) & (uint32_t)((1UL << (tbl)->bloom_nbits) - 1U))) + +#else +#define HASH_BLOOM_MAKE(tbl,oomed) +#define HASH_BLOOM_FREE(tbl) +#define HASH_BLOOM_ADD(tbl,hashv) +#define HASH_BLOOM_TEST(tbl,hashv) (1) +#define HASH_BLOOM_BYTELEN 0U +#endif + +#define HASH_MAKE_TABLE(hh,head,oomed) \ +do { \ + (head)->hh.tbl = (UT_hash_table*)uthash_malloc(sizeof(UT_hash_table)); \ + if (!(head)->hh.tbl) { \ + HASH_RECORD_OOM(oomed); \ + } else { \ + uthash_bzero((head)->hh.tbl, sizeof(UT_hash_table)); \ + (head)->hh.tbl->tail = &((head)->hh); \ + (head)->hh.tbl->num_buckets = HASH_INITIAL_NUM_BUCKETS; \ + (head)->hh.tbl->log2_num_buckets = HASH_INITIAL_NUM_BUCKETS_LOG2; \ + (head)->hh.tbl->hho = (char*)(&(head)->hh) - (char*)(head); \ + (head)->hh.tbl->buckets = (UT_hash_bucket*)uthash_malloc( \ + HASH_INITIAL_NUM_BUCKETS * sizeof(struct UT_hash_bucket)); \ + (head)->hh.tbl->signature = HASH_SIGNATURE; \ + if (!(head)->hh.tbl->buckets) { \ + HASH_RECORD_OOM(oomed); \ + uthash_free((head)->hh.tbl, sizeof(UT_hash_table)); \ + } else { \ + uthash_bzero((head)->hh.tbl->buckets, \ + HASH_INITIAL_NUM_BUCKETS * sizeof(struct UT_hash_bucket)); \ + HASH_BLOOM_MAKE((head)->hh.tbl, oomed); \ + IF_HASH_NONFATAL_OOM( \ + if (oomed) { \ + uthash_free((head)->hh.tbl->buckets, \ + HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket)); \ + uthash_free((head)->hh.tbl, sizeof(UT_hash_table)); \ + } \ + ) \ + } \ + } \ +} while (0) + +#define HASH_REPLACE_BYHASHVALUE_INORDER(hh,head,fieldname,keylen_in,hashval,add,replaced,cmpfcn) \ +do { \ + (replaced) = NULL; \ + HASH_FIND_BYHASHVALUE(hh, head, &((add)->fieldname), keylen_in, hashval, replaced); \ + if (replaced) { \ + HASH_DELETE(hh, head, replaced); \ + } \ + HASH_ADD_KEYPTR_BYHASHVALUE_INORDER(hh, head, &((add)->fieldname), keylen_in, hashval, add, cmpfcn); \ +} while (0) + +#define HASH_REPLACE_BYHASHVALUE(hh,head,fieldname,keylen_in,hashval,add,replaced) \ +do { \ + (replaced) = NULL; \ + HASH_FIND_BYHASHVALUE(hh, head, &((add)->fieldname), keylen_in, hashval, replaced); \ + if (replaced) { \ + HASH_DELETE(hh, head, replaced); \ + } \ + HASH_ADD_KEYPTR_BYHASHVALUE(hh, head, &((add)->fieldname), keylen_in, hashval, add); \ +} while (0) + +#define HASH_REPLACE(hh,head,fieldname,keylen_in,add,replaced) \ +do { \ + unsigned _hr_hashv; \ + HASH_VALUE(&((add)->fieldname), keylen_in, _hr_hashv); \ + HASH_REPLACE_BYHASHVALUE(hh, head, fieldname, keylen_in, _hr_hashv, add, replaced); \ +} while (0) + +#define HASH_REPLACE_INORDER(hh,head,fieldname,keylen_in,add,replaced,cmpfcn) \ +do { \ + unsigned _hr_hashv; \ + HASH_VALUE(&((add)->fieldname), keylen_in, _hr_hashv); \ + HASH_REPLACE_BYHASHVALUE_INORDER(hh, head, fieldname, keylen_in, _hr_hashv, add, replaced, cmpfcn); \ +} while (0) + +#define HASH_APPEND_LIST(hh, head, add) \ +do { \ + (add)->hh.next = NULL; \ + (add)->hh.prev = ELMT_FROM_HH((head)->hh.tbl, (head)->hh.tbl->tail); \ + (head)->hh.tbl->tail->next = (add); \ + (head)->hh.tbl->tail = &((add)->hh); \ +} while (0) + +#define HASH_AKBI_INNER_LOOP(hh,head,add,cmpfcn) \ +do { \ + do { \ + if (cmpfcn(DECLTYPE(head)(_hs_iter), add) > 0) { \ + break; \ + } \ + } while ((_hs_iter = HH_FROM_ELMT((head)->hh.tbl, _hs_iter)->next)); \ +} while (0) + +#ifdef NO_DECLTYPE +#undef HASH_AKBI_INNER_LOOP +#define HASH_AKBI_INNER_LOOP(hh,head,add,cmpfcn) \ +do { \ + char *_hs_saved_head = (char*)(head); \ + do { \ + DECLTYPE_ASSIGN(head, _hs_iter); \ + if (cmpfcn(head, add) > 0) { \ + DECLTYPE_ASSIGN(head, _hs_saved_head); \ + break; \ + } \ + DECLTYPE_ASSIGN(head, _hs_saved_head); \ + } while ((_hs_iter = HH_FROM_ELMT((head)->hh.tbl, _hs_iter)->next)); \ +} while (0) +#endif + +#if HASH_NONFATAL_OOM + +#define HASH_ADD_TO_TABLE(hh,head,keyptr,keylen_in,hashval,add,oomed) \ +do { \ + if (!(oomed)) { \ + unsigned _ha_bkt; \ + (head)->hh.tbl->num_items++; \ + HASH_TO_BKT(hashval, (head)->hh.tbl->num_buckets, _ha_bkt); \ + HASH_ADD_TO_BKT((head)->hh.tbl->buckets[_ha_bkt], hh, &(add)->hh, oomed); \ + if (oomed) { \ + HASH_ROLLBACK_BKT(hh, head, &(add)->hh); \ + HASH_DELETE_HH(hh, head, &(add)->hh); \ + (add)->hh.tbl = NULL; \ + uthash_nonfatal_oom(add); \ + } else { \ + HASH_BLOOM_ADD((head)->hh.tbl, hashval); \ + HASH_EMIT_KEY(hh, head, keyptr, keylen_in); \ + } \ + } else { \ + (add)->hh.tbl = NULL; \ + uthash_nonfatal_oom(add); \ + } \ +} while (0) + +#else + +#define HASH_ADD_TO_TABLE(hh,head,keyptr,keylen_in,hashval,add,oomed) \ +do { \ + unsigned _ha_bkt; \ + (head)->hh.tbl->num_items++; \ + HASH_TO_BKT(hashval, (head)->hh.tbl->num_buckets, _ha_bkt); \ + HASH_ADD_TO_BKT((head)->hh.tbl->buckets[_ha_bkt], hh, &(add)->hh, oomed); \ + HASH_BLOOM_ADD((head)->hh.tbl, hashval); \ + HASH_EMIT_KEY(hh, head, keyptr, keylen_in); \ +} while (0) + +#endif + + +#define HASH_ADD_KEYPTR_BYHASHVALUE_INORDER(hh,head,keyptr,keylen_in,hashval,add,cmpfcn) \ +do { \ + IF_HASH_NONFATAL_OOM( int _ha_oomed = 0; ) \ + (add)->hh.hashv = (hashval); \ + (add)->hh.key = (char*) (keyptr); \ + (add)->hh.keylen = (unsigned) (keylen_in); \ + if (!(head)) { \ + (add)->hh.next = NULL; \ + (add)->hh.prev = NULL; \ + HASH_MAKE_TABLE(hh, add, _ha_oomed); \ + IF_HASH_NONFATAL_OOM( if (!_ha_oomed) { ) \ + (head) = (add); \ + IF_HASH_NONFATAL_OOM( } ) \ + } else { \ + void *_hs_iter = (head); \ + (add)->hh.tbl = (head)->hh.tbl; \ + HASH_AKBI_INNER_LOOP(hh, head, add, cmpfcn); \ + if (_hs_iter) { \ + (add)->hh.next = _hs_iter; \ + if (((add)->hh.prev = HH_FROM_ELMT((head)->hh.tbl, _hs_iter)->prev)) { \ + HH_FROM_ELMT((head)->hh.tbl, (add)->hh.prev)->next = (add); \ + } else { \ + (head) = (add); \ + } \ + HH_FROM_ELMT((head)->hh.tbl, _hs_iter)->prev = (add); \ + } else { \ + HASH_APPEND_LIST(hh, head, add); \ + } \ + } \ + HASH_ADD_TO_TABLE(hh, head, keyptr, keylen_in, hashval, add, _ha_oomed); \ + HASH_FSCK(hh, head, "HASH_ADD_KEYPTR_BYHASHVALUE_INORDER"); \ +} while (0) + +#define HASH_ADD_KEYPTR_INORDER(hh,head,keyptr,keylen_in,add,cmpfcn) \ +do { \ + unsigned _hs_hashv; \ + HASH_VALUE(keyptr, keylen_in, _hs_hashv); \ + HASH_ADD_KEYPTR_BYHASHVALUE_INORDER(hh, head, keyptr, keylen_in, _hs_hashv, add, cmpfcn); \ +} while (0) + +#define HASH_ADD_BYHASHVALUE_INORDER(hh,head,fieldname,keylen_in,hashval,add,cmpfcn) \ + HASH_ADD_KEYPTR_BYHASHVALUE_INORDER(hh, head, &((add)->fieldname), keylen_in, hashval, add, cmpfcn) + +#define HASH_ADD_INORDER(hh,head,fieldname,keylen_in,add,cmpfcn) \ + HASH_ADD_KEYPTR_INORDER(hh, head, &((add)->fieldname), keylen_in, add, cmpfcn) + +#define HASH_ADD_KEYPTR_BYHASHVALUE(hh,head,keyptr,keylen_in,hashval,add) \ +do { \ + IF_HASH_NONFATAL_OOM( int _ha_oomed = 0; ) \ + (add)->hh.hashv = (hashval); \ + (add)->hh.key = (char*) (keyptr); \ + (add)->hh.keylen = (unsigned) (keylen_in); \ + if (!(head)) { \ + (add)->hh.next = NULL; \ + (add)->hh.prev = NULL; \ + HASH_MAKE_TABLE(hh, add, _ha_oomed); \ + IF_HASH_NONFATAL_OOM( if (!_ha_oomed) { ) \ + (head) = (add); \ + IF_HASH_NONFATAL_OOM( } ) \ + } else { \ + (add)->hh.tbl = (head)->hh.tbl; \ + HASH_APPEND_LIST(hh, head, add); \ + } \ + HASH_ADD_TO_TABLE(hh, head, keyptr, keylen_in, hashval, add, _ha_oomed); \ + HASH_FSCK(hh, head, "HASH_ADD_KEYPTR_BYHASHVALUE"); \ +} while (0) + +#define HASH_ADD_KEYPTR(hh,head,keyptr,keylen_in,add) \ +do { \ + unsigned _ha_hashv; \ + HASH_VALUE(keyptr, keylen_in, _ha_hashv); \ + HASH_ADD_KEYPTR_BYHASHVALUE(hh, head, keyptr, keylen_in, _ha_hashv, add); \ +} while (0) + +#define HASH_ADD_BYHASHVALUE(hh,head,fieldname,keylen_in,hashval,add) \ + HASH_ADD_KEYPTR_BYHASHVALUE(hh, head, &((add)->fieldname), keylen_in, hashval, add) + +#define HASH_ADD(hh,head,fieldname,keylen_in,add) \ + HASH_ADD_KEYPTR(hh, head, &((add)->fieldname), keylen_in, add) + +#define HASH_TO_BKT(hashv,num_bkts,bkt) \ +do { \ + bkt = ((hashv) & ((num_bkts) - 1U)); \ +} while (0) + +/* delete "delptr" from the hash table. + * "the usual" patch-up process for the app-order doubly-linked-list. + * The use of _hd_hh_del below deserves special explanation. + * These used to be expressed using (delptr) but that led to a bug + * if someone used the same symbol for the head and deletee, like + * HASH_DELETE(hh,users,users); + * We want that to work, but by changing the head (users) below + * we were forfeiting our ability to further refer to the deletee (users) + * in the patch-up process. Solution: use scratch space to + * copy the deletee pointer, then the latter references are via that + * scratch pointer rather than through the repointed (users) symbol. + */ +#define HASH_DELETE(hh,head,delptr) \ + HASH_DELETE_HH(hh, head, &(delptr)->hh) + +#define HASH_DELETE_HH(hh,head,delptrhh) \ +do { \ + struct UT_hash_handle *_hd_hh_del = (delptrhh); \ + if ((_hd_hh_del->prev == NULL) && (_hd_hh_del->next == NULL)) { \ + HASH_BLOOM_FREE((head)->hh.tbl); \ + uthash_free((head)->hh.tbl->buckets, \ + (head)->hh.tbl->num_buckets * sizeof(struct UT_hash_bucket)); \ + uthash_free((head)->hh.tbl, sizeof(UT_hash_table)); \ + (head) = NULL; \ + } else { \ + unsigned _hd_bkt; \ + if (_hd_hh_del == (head)->hh.tbl->tail) { \ + (head)->hh.tbl->tail = HH_FROM_ELMT((head)->hh.tbl, _hd_hh_del->prev); \ + } \ + if (_hd_hh_del->prev != NULL) { \ + HH_FROM_ELMT((head)->hh.tbl, _hd_hh_del->prev)->next = _hd_hh_del->next; \ + } else { \ + DECLTYPE_ASSIGN(head, _hd_hh_del->next); \ + } \ + if (_hd_hh_del->next != NULL) { \ + HH_FROM_ELMT((head)->hh.tbl, _hd_hh_del->next)->prev = _hd_hh_del->prev; \ + } \ + HASH_TO_BKT(_hd_hh_del->hashv, (head)->hh.tbl->num_buckets, _hd_bkt); \ + HASH_DEL_IN_BKT((head)->hh.tbl->buckets[_hd_bkt], _hd_hh_del); \ + (head)->hh.tbl->num_items--; \ + } \ + HASH_FSCK(hh, head, "HASH_DELETE_HH"); \ +} while (0) + +/* convenience forms of HASH_FIND/HASH_ADD/HASH_DEL */ +#define HASH_FIND_STR(head,findstr,out) \ + HASH_FIND(hh,head,findstr,(unsigned)uthash_strlen(findstr),out) +#define HASH_ADD_STR(head,strfield,add) \ + HASH_ADD(hh,head,strfield[0],(unsigned)uthash_strlen(add->strfield),add) +#define HASH_REPLACE_STR(head,strfield,add,replaced) \ + HASH_REPLACE(hh,head,strfield[0],(unsigned)uthash_strlen(add->strfield),add,replaced) +#define HASH_FIND_INT(head,findint,out) \ + HASH_FIND(hh,head,findint,sizeof(int),out) +#define HASH_ADD_INT(head,intfield,add) \ + HASH_ADD(hh,head,intfield,sizeof(int),add) +#define HASH_REPLACE_INT(head,intfield,add,replaced) \ + HASH_REPLACE(hh,head,intfield,sizeof(int),add,replaced) +#define HASH_FIND_PTR(head,findptr,out) \ + HASH_FIND(hh,head,findptr,sizeof(void *),out) +#define HASH_ADD_PTR(head,ptrfield,add) \ + HASH_ADD(hh,head,ptrfield,sizeof(void *),add) +#define HASH_REPLACE_PTR(head,ptrfield,add,replaced) \ + HASH_REPLACE(hh,head,ptrfield,sizeof(void *),add,replaced) +#define HASH_DEL(head,delptr) \ + HASH_DELETE(hh,head,delptr) + +/* HASH_FSCK checks hash integrity on every add/delete when HASH_DEBUG is defined. + * This is for uthash developer only; it compiles away if HASH_DEBUG isn't defined. + */ +#ifdef HASH_DEBUG +#define HASH_OOPS(...) do { fprintf(stderr,__VA_ARGS__); exit(-1); } while (0) +#define HASH_FSCK(hh,head,where) \ +do { \ + struct UT_hash_handle *_thh; \ + if (head) { \ + unsigned _bkt_i; \ + unsigned _count = 0; \ + char *_prev; \ + for (_bkt_i = 0; _bkt_i < (head)->hh.tbl->num_buckets; ++_bkt_i) { \ + unsigned _bkt_count = 0; \ + _thh = (head)->hh.tbl->buckets[_bkt_i].hh_head; \ + _prev = NULL; \ + while (_thh) { \ + if (_prev != (char*)(_thh->hh_prev)) { \ + HASH_OOPS("%s: invalid hh_prev %p, actual %p\n", \ + (where), (void*)_thh->hh_prev, (void*)_prev); \ + } \ + _bkt_count++; \ + _prev = (char*)(_thh); \ + _thh = _thh->hh_next; \ + } \ + _count += _bkt_count; \ + if ((head)->hh.tbl->buckets[_bkt_i].count != _bkt_count) { \ + HASH_OOPS("%s: invalid bucket count %u, actual %u\n", \ + (where), (head)->hh.tbl->buckets[_bkt_i].count, _bkt_count); \ + } \ + } \ + if (_count != (head)->hh.tbl->num_items) { \ + HASH_OOPS("%s: invalid hh item count %u, actual %u\n", \ + (where), (head)->hh.tbl->num_items, _count); \ + } \ + _count = 0; \ + _prev = NULL; \ + _thh = &(head)->hh; \ + while (_thh) { \ + _count++; \ + if (_prev != (char*)_thh->prev) { \ + HASH_OOPS("%s: invalid prev %p, actual %p\n", \ + (where), (void*)_thh->prev, (void*)_prev); \ + } \ + _prev = (char*)ELMT_FROM_HH((head)->hh.tbl, _thh); \ + _thh = (_thh->next ? HH_FROM_ELMT((head)->hh.tbl, _thh->next) : NULL); \ + } \ + if (_count != (head)->hh.tbl->num_items) { \ + HASH_OOPS("%s: invalid app item count %u, actual %u\n", \ + (where), (head)->hh.tbl->num_items, _count); \ + } \ + } \ +} while (0) +#else +#define HASH_FSCK(hh,head,where) +#endif + +/* When compiled with -DHASH_EMIT_KEYS, length-prefixed keys are emitted to + * the descriptor to which this macro is defined for tuning the hash function. + * The app can #include <unistd.h> to get the prototype for write(2). */ +#ifdef HASH_EMIT_KEYS +#define HASH_EMIT_KEY(hh,head,keyptr,fieldlen) \ +do { \ + unsigned _klen = fieldlen; \ + write(HASH_EMIT_KEYS, &_klen, sizeof(_klen)); \ + write(HASH_EMIT_KEYS, keyptr, (unsigned long)fieldlen); \ +} while (0) +#else +#define HASH_EMIT_KEY(hh,head,keyptr,fieldlen) +#endif + +/* default to Jenkin's hash unless overridden e.g. DHASH_FUNCTION=HASH_SAX */ +#ifdef HASH_FUNCTION +#define HASH_FCN HASH_FUNCTION +#else +#define HASH_FCN HASH_JEN +#endif + +/* The Bernstein hash function, used in Perl prior to v5.6. Note (x<<5+x)=x*33. */ +#define HASH_BER(key,keylen,hashv) \ +do { \ + unsigned _hb_keylen = (unsigned)keylen; \ + const unsigned char *_hb_key = (const unsigned char*)(key); \ + (hashv) = 0; \ + while (_hb_keylen-- != 0U) { \ + (hashv) = (((hashv) << 5) + (hashv)) + *_hb_key++; \ + } \ +} while (0) + + +/* SAX/FNV/OAT/JEN hash functions are macro variants of those listed at + * http://eternallyconfuzzled.com/tuts/algorithms/jsw_tut_hashing.aspx */ +#define HASH_SAX(key,keylen,hashv) \ +do { \ + unsigned _sx_i; \ + const unsigned char *_hs_key = (const unsigned char*)(key); \ + hashv = 0; \ + for (_sx_i=0; _sx_i < keylen; _sx_i++) { \ + hashv ^= (hashv << 5) + (hashv >> 2) + _hs_key[_sx_i]; \ + } \ +} while (0) +/* FNV-1a variation */ +#define HASH_FNV(key,keylen,hashv) \ +do { \ + unsigned _fn_i; \ + const unsigned char *_hf_key = (const unsigned char*)(key); \ + (hashv) = 2166136261U; \ + for (_fn_i=0; _fn_i < keylen; _fn_i++) { \ + hashv = hashv ^ _hf_key[_fn_i]; \ + hashv = hashv * 16777619U; \ + } \ +} while (0) + +#define HASH_OAT(key,keylen,hashv) \ +do { \ + unsigned _ho_i; \ + const unsigned char *_ho_key=(const unsigned char*)(key); \ + hashv = 0; \ + for(_ho_i=0; _ho_i < keylen; _ho_i++) { \ + hashv += _ho_key[_ho_i]; \ + hashv += (hashv << 10); \ + hashv ^= (hashv >> 6); \ + } \ + hashv += (hashv << 3); \ + hashv ^= (hashv >> 11); \ + hashv += (hashv << 15); \ +} while (0) + +#define HASH_JEN_MIX(a,b,c) \ +do { \ + a -= b; a -= c; a ^= ( c >> 13 ); \ + b -= c; b -= a; b ^= ( a << 8 ); \ + c -= a; c -= b; c ^= ( b >> 13 ); \ + a -= b; a -= c; a ^= ( c >> 12 ); \ + b -= c; b -= a; b ^= ( a << 16 ); \ + c -= a; c -= b; c ^= ( b >> 5 ); \ + a -= b; a -= c; a ^= ( c >> 3 ); \ + b -= c; b -= a; b ^= ( a << 10 ); \ + c -= a; c -= b; c ^= ( b >> 15 ); \ +} while (0) + +#define HASH_JEN(key,keylen,hashv) \ +do { \ + unsigned _hj_i,_hj_j,_hj_k; \ + unsigned const char *_hj_key=(unsigned const char*)(key); \ + hashv = 0xfeedbeefu; \ + _hj_i = _hj_j = 0x9e3779b9u; \ + _hj_k = (unsigned)(keylen); \ + while (_hj_k >= 12U) { \ + _hj_i += (_hj_key[0] + ( (unsigned)_hj_key[1] << 8 ) \ + + ( (unsigned)_hj_key[2] << 16 ) \ + + ( (unsigned)_hj_key[3] << 24 ) ); \ + _hj_j += (_hj_key[4] + ( (unsigned)_hj_key[5] << 8 ) \ + + ( (unsigned)_hj_key[6] << 16 ) \ + + ( (unsigned)_hj_key[7] << 24 ) ); \ + hashv += (_hj_key[8] + ( (unsigned)_hj_key[9] << 8 ) \ + + ( (unsigned)_hj_key[10] << 16 ) \ + + ( (unsigned)_hj_key[11] << 24 ) ); \ + \ + HASH_JEN_MIX(_hj_i, _hj_j, hashv); \ + \ + _hj_key += 12; \ + _hj_k -= 12U; \ + } \ + hashv += (unsigned)(keylen); \ + switch ( _hj_k ) { \ + case 11: hashv += ( (unsigned)_hj_key[10] << 24 ); /* FALLTHROUGH */ \ + case 10: hashv += ( (unsigned)_hj_key[9] << 16 ); /* FALLTHROUGH */ \ + case 9: hashv += ( (unsigned)_hj_key[8] << 8 ); /* FALLTHROUGH */ \ + case 8: _hj_j += ( (unsigned)_hj_key[7] << 24 ); /* FALLTHROUGH */ \ + case 7: _hj_j += ( (unsigned)_hj_key[6] << 16 ); /* FALLTHROUGH */ \ + case 6: _hj_j += ( (unsigned)_hj_key[5] << 8 ); /* FALLTHROUGH */ \ + case 5: _hj_j += _hj_key[4]; /* FALLTHROUGH */ \ + case 4: _hj_i += ( (unsigned)_hj_key[3] << 24 ); /* FALLTHROUGH */ \ + case 3: _hj_i += ( (unsigned)_hj_key[2] << 16 ); /* FALLTHROUGH */ \ + case 2: _hj_i += ( (unsigned)_hj_key[1] << 8 ); /* FALLTHROUGH */ \ + case 1: _hj_i += _hj_key[0]; \ + } \ + HASH_JEN_MIX(_hj_i, _hj_j, hashv); \ +} while (0) + +/* The Paul Hsieh hash function */ +#undef get16bits +#if (defined(__GNUC__) && defined(__i386__)) || defined(__WATCOMC__) \ + || defined(_MSC_VER) || defined (__BORLANDC__) || defined (__TURBOC__) +#define get16bits(d) (*((const uint16_t *) (d))) +#endif + +#if !defined (get16bits) +#define get16bits(d) ((((uint32_t)(((const uint8_t *)(d))[1])) << 8) \ + +(uint32_t)(((const uint8_t *)(d))[0]) ) +#endif +#define HASH_SFH(key,keylen,hashv) \ +do { \ + unsigned const char *_sfh_key=(unsigned const char*)(key); \ + uint32_t _sfh_tmp, _sfh_len = (uint32_t)keylen; \ + \ + unsigned _sfh_rem = _sfh_len & 3U; \ + _sfh_len >>= 2; \ + hashv = 0xcafebabeu; \ + \ + /* Main loop */ \ + for (;_sfh_len > 0U; _sfh_len--) { \ + hashv += get16bits (_sfh_key); \ + _sfh_tmp = ((uint32_t)(get16bits (_sfh_key+2)) << 11) ^ hashv; \ + hashv = (hashv << 16) ^ _sfh_tmp; \ + _sfh_key += 2U*sizeof (uint16_t); \ + hashv += hashv >> 11; \ + } \ + \ + /* Handle end cases */ \ + switch (_sfh_rem) { \ + case 3: hashv += get16bits (_sfh_key); \ + hashv ^= hashv << 16; \ + hashv ^= (uint32_t)(_sfh_key[sizeof (uint16_t)]) << 18; \ + hashv += hashv >> 11; \ + break; \ + case 2: hashv += get16bits (_sfh_key); \ + hashv ^= hashv << 11; \ + hashv += hashv >> 17; \ + break; \ + case 1: hashv += *_sfh_key; \ + hashv ^= hashv << 10; \ + hashv += hashv >> 1; \ + } \ + \ + /* Force "avalanching" of final 127 bits */ \ + hashv ^= hashv << 3; \ + hashv += hashv >> 5; \ + hashv ^= hashv << 4; \ + hashv += hashv >> 17; \ + hashv ^= hashv << 25; \ + hashv += hashv >> 6; \ +} while (0) + +#ifdef HASH_USING_NO_STRICT_ALIASING +/* The MurmurHash exploits some CPU's (x86,x86_64) tolerance for unaligned reads. + * For other types of CPU's (e.g. Sparc) an unaligned read causes a bus error. + * MurmurHash uses the faster approach only on CPU's where we know it's safe. + * + * Note the preprocessor built-in defines can be emitted using: + * + * gcc -m64 -dM -E - < /dev/null (on gcc) + * cc -## a.c (where a.c is a simple test file) (Sun Studio) + */ +#if (defined(__i386__) || defined(__x86_64__) || defined(_M_IX86)) +#define MUR_GETBLOCK(p,i) p[i] +#else /* non intel */ +#define MUR_PLUS0_ALIGNED(p) (((unsigned long)p & 3UL) == 0UL) +#define MUR_PLUS1_ALIGNED(p) (((unsigned long)p & 3UL) == 1UL) +#define MUR_PLUS2_ALIGNED(p) (((unsigned long)p & 3UL) == 2UL) +#define MUR_PLUS3_ALIGNED(p) (((unsigned long)p & 3UL) == 3UL) +#define WP(p) ((uint32_t*)((unsigned long)(p) & ~3UL)) +#if (defined(__BIG_ENDIAN__) || defined(SPARC) || defined(__ppc__) || defined(__ppc64__)) +#define MUR_THREE_ONE(p) ((((*WP(p))&0x00ffffff) << 8) | (((*(WP(p)+1))&0xff000000) >> 24)) +#define MUR_TWO_TWO(p) ((((*WP(p))&0x0000ffff) <<16) | (((*(WP(p)+1))&0xffff0000) >> 16)) +#define MUR_ONE_THREE(p) ((((*WP(p))&0x000000ff) <<24) | (((*(WP(p)+1))&0xffffff00) >> 8)) +#else /* assume little endian non-intel */ +#define MUR_THREE_ONE(p) ((((*WP(p))&0xffffff00) >> 8) | (((*(WP(p)+1))&0x000000ff) << 24)) +#define MUR_TWO_TWO(p) ((((*WP(p))&0xffff0000) >>16) | (((*(WP(p)+1))&0x0000ffff) << 16)) +#define MUR_ONE_THREE(p) ((((*WP(p))&0xff000000) >>24) | (((*(WP(p)+1))&0x00ffffff) << 8)) +#endif +#define MUR_GETBLOCK(p,i) (MUR_PLUS0_ALIGNED(p) ? ((p)[i]) : \ + (MUR_PLUS1_ALIGNED(p) ? MUR_THREE_ONE(p) : \ + (MUR_PLUS2_ALIGNED(p) ? MUR_TWO_TWO(p) : \ + MUR_ONE_THREE(p)))) +#endif +#define MUR_ROTL32(x,r) (((x) << (r)) | ((x) >> (32 - (r)))) +#define MUR_FMIX(_h) \ +do { \ + _h ^= _h >> 16; \ + _h *= 0x85ebca6bu; \ + _h ^= _h >> 13; \ + _h *= 0xc2b2ae35u; \ + _h ^= _h >> 16; \ +} while (0) + +#define HASH_MUR(key,keylen,hashv) \ +do { \ + const uint8_t *_mur_data = (const uint8_t*)(key); \ + const int _mur_nblocks = (int)(keylen) / 4; \ + uint32_t _mur_h1 = 0xf88D5353u; \ + uint32_t _mur_c1 = 0xcc9e2d51u; \ + uint32_t _mur_c2 = 0x1b873593u; \ + uint32_t _mur_k1 = 0; \ + const uint8_t *_mur_tail; \ + const uint32_t *_mur_blocks = (const uint32_t*)(_mur_data+(_mur_nblocks*4)); \ + int _mur_i; \ + for (_mur_i = -_mur_nblocks; _mur_i != 0; _mur_i++) { \ + _mur_k1 = MUR_GETBLOCK(_mur_blocks,_mur_i); \ + _mur_k1 *= _mur_c1; \ + _mur_k1 = MUR_ROTL32(_mur_k1,15); \ + _mur_k1 *= _mur_c2; \ + \ + _mur_h1 ^= _mur_k1; \ + _mur_h1 = MUR_ROTL32(_mur_h1,13); \ + _mur_h1 = (_mur_h1*5U) + 0xe6546b64u; \ + } \ + _mur_tail = (const uint8_t*)(_mur_data + (_mur_nblocks*4)); \ + _mur_k1=0; \ + switch ((keylen) & 3U) { \ + case 0: break; \ + case 3: _mur_k1 ^= (uint32_t)_mur_tail[2] << 16; /* FALLTHROUGH */ \ + case 2: _mur_k1 ^= (uint32_t)_mur_tail[1] << 8; /* FALLTHROUGH */ \ + case 1: _mur_k1 ^= (uint32_t)_mur_tail[0]; \ + _mur_k1 *= _mur_c1; \ + _mur_k1 = MUR_ROTL32(_mur_k1,15); \ + _mur_k1 *= _mur_c2; \ + _mur_h1 ^= _mur_k1; \ + } \ + _mur_h1 ^= (uint32_t)(keylen); \ + MUR_FMIX(_mur_h1); \ + hashv = _mur_h1; \ +} while (0) +#endif /* HASH_USING_NO_STRICT_ALIASING */ + +/* iterate over items in a known bucket to find desired item */ +#define HASH_FIND_IN_BKT(tbl,hh,head,keyptr,keylen_in,hashval,out) \ +do { \ + if ((head).hh_head != NULL) { \ + DECLTYPE_ASSIGN(out, ELMT_FROM_HH(tbl, (head).hh_head)); \ + } else { \ + (out) = NULL; \ + } \ + while ((out) != NULL) { \ + if ((out)->hh.hashv == (hashval) && (out)->hh.keylen == (keylen_in)) { \ + if (uthash_memcmp((out)->hh.key, keyptr, keylen_in) == 0) { \ + break; \ + } \ + } \ + if ((out)->hh.hh_next != NULL) { \ + DECLTYPE_ASSIGN(out, ELMT_FROM_HH(tbl, (out)->hh.hh_next)); \ + } else { \ + (out) = NULL; \ + } \ + } \ +} while (0) + +/* add an item to a bucket */ +#define HASH_ADD_TO_BKT(head,hh,addhh,oomed) \ +do { \ + UT_hash_bucket *_ha_head = &(head); \ + _ha_head->count++; \ + (addhh)->hh_next = _ha_head->hh_head; \ + (addhh)->hh_prev = NULL; \ + if (_ha_head->hh_head != NULL) { \ + _ha_head->hh_head->hh_prev = (addhh); \ + } \ + _ha_head->hh_head = (addhh); \ + if ((_ha_head->count >= ((_ha_head->expand_mult + 1U) * HASH_BKT_CAPACITY_THRESH)) \ + && !(addhh)->tbl->noexpand) { \ + HASH_EXPAND_BUCKETS(addhh,(addhh)->tbl, oomed); \ + IF_HASH_NONFATAL_OOM( \ + if (oomed) { \ + HASH_DEL_IN_BKT(head,addhh); \ + } \ + ) \ + } \ +} while (0) + +/* remove an item from a given bucket */ +#define HASH_DEL_IN_BKT(head,delhh) \ +do { \ + UT_hash_bucket *_hd_head = &(head); \ + _hd_head->count--; \ + if (_hd_head->hh_head == (delhh)) { \ + _hd_head->hh_head = (delhh)->hh_next; \ + } \ + if ((delhh)->hh_prev) { \ + (delhh)->hh_prev->hh_next = (delhh)->hh_next; \ + } \ + if ((delhh)->hh_next) { \ + (delhh)->hh_next->hh_prev = (delhh)->hh_prev; \ + } \ +} while (0) + +/* Bucket expansion has the effect of doubling the number of buckets + * and redistributing the items into the new buckets. Ideally the + * items will distribute more or less evenly into the new buckets + * (the extent to which this is true is a measure of the quality of + * the hash function as it applies to the key domain). + * + * With the items distributed into more buckets, the chain length + * (item count) in each bucket is reduced. Thus by expanding buckets + * the hash keeps a bound on the chain length. This bounded chain + * length is the essence of how a hash provides constant time lookup. + * + * The calculation of tbl->ideal_chain_maxlen below deserves some + * explanation. First, keep in mind that we're calculating the ideal + * maximum chain length based on the *new* (doubled) bucket count. + * In fractions this is just n/b (n=number of items,b=new num buckets). + * Since the ideal chain length is an integer, we want to calculate + * ceil(n/b). We don't depend on floating point arithmetic in this + * hash, so to calculate ceil(n/b) with integers we could write + * + * ceil(n/b) = (n/b) + ((n%b)?1:0) + * + * and in fact a previous version of this hash did just that. + * But now we have improved things a bit by recognizing that b is + * always a power of two. We keep its base 2 log handy (call it lb), + * so now we can write this with a bit shift and logical AND: + * + * ceil(n/b) = (n>>lb) + ( (n & (b-1)) ? 1:0) + * + */ +#define HASH_EXPAND_BUCKETS(hh,tbl,oomed) \ +do { \ + unsigned _he_bkt; \ + unsigned _he_bkt_i; \ + struct UT_hash_handle *_he_thh, *_he_hh_nxt; \ + UT_hash_bucket *_he_new_buckets, *_he_newbkt; \ + _he_new_buckets = (UT_hash_bucket*)uthash_malloc( \ + 2UL * (tbl)->num_buckets * sizeof(struct UT_hash_bucket)); \ + if (!_he_new_buckets) { \ + HASH_RECORD_OOM(oomed); \ + } else { \ + uthash_bzero(_he_new_buckets, \ + 2UL * (tbl)->num_buckets * sizeof(struct UT_hash_bucket)); \ + (tbl)->ideal_chain_maxlen = \ + ((tbl)->num_items >> ((tbl)->log2_num_buckets+1U)) + \ + ((((tbl)->num_items & (((tbl)->num_buckets*2U)-1U)) != 0U) ? 1U : 0U); \ + (tbl)->nonideal_items = 0; \ + for (_he_bkt_i = 0; _he_bkt_i < (tbl)->num_buckets; _he_bkt_i++) { \ + _he_thh = (tbl)->buckets[ _he_bkt_i ].hh_head; \ + while (_he_thh != NULL) { \ + _he_hh_nxt = _he_thh->hh_next; \ + HASH_TO_BKT(_he_thh->hashv, (tbl)->num_buckets * 2U, _he_bkt); \ + _he_newbkt = &(_he_new_buckets[_he_bkt]); \ + if (++(_he_newbkt->count) > (tbl)->ideal_chain_maxlen) { \ + (tbl)->nonideal_items++; \ + _he_newbkt->expand_mult = _he_newbkt->count / (tbl)->ideal_chain_maxlen; \ + } \ + _he_thh->hh_prev = NULL; \ + _he_thh->hh_next = _he_newbkt->hh_head; \ + if (_he_newbkt->hh_head != NULL) { \ + _he_newbkt->hh_head->hh_prev = _he_thh; \ + } \ + _he_newbkt->hh_head = _he_thh; \ + _he_thh = _he_hh_nxt; \ + } \ + } \ + uthash_free((tbl)->buckets, (tbl)->num_buckets * sizeof(struct UT_hash_bucket)); \ + (tbl)->num_buckets *= 2U; \ + (tbl)->log2_num_buckets++; \ + (tbl)->buckets = _he_new_buckets; \ + (tbl)->ineff_expands = ((tbl)->nonideal_items > ((tbl)->num_items >> 1)) ? \ + ((tbl)->ineff_expands+1U) : 0U; \ + if ((tbl)->ineff_expands > 1U) { \ + (tbl)->noexpand = 1; \ + uthash_noexpand_fyi(tbl); \ + } \ + uthash_expand_fyi(tbl); \ + } \ +} while (0) + + +/* This is an adaptation of Simon Tatham's O(n log(n)) mergesort */ +/* Note that HASH_SORT assumes the hash handle name to be hh. + * HASH_SRT was added to allow the hash handle name to be passed in. */ +#define HASH_SORT(head,cmpfcn) HASH_SRT(hh,head,cmpfcn) +#define HASH_SRT(hh,head,cmpfcn) \ +do { \ + unsigned _hs_i; \ + unsigned _hs_looping,_hs_nmerges,_hs_insize,_hs_psize,_hs_qsize; \ + struct UT_hash_handle *_hs_p, *_hs_q, *_hs_e, *_hs_list, *_hs_tail; \ + if (head != NULL) { \ + _hs_insize = 1; \ + _hs_looping = 1; \ + _hs_list = &((head)->hh); \ + while (_hs_looping != 0U) { \ + _hs_p = _hs_list; \ + _hs_list = NULL; \ + _hs_tail = NULL; \ + _hs_nmerges = 0; \ + while (_hs_p != NULL) { \ + _hs_nmerges++; \ + _hs_q = _hs_p; \ + _hs_psize = 0; \ + for (_hs_i = 0; _hs_i < _hs_insize; ++_hs_i) { \ + _hs_psize++; \ + _hs_q = ((_hs_q->next != NULL) ? \ + HH_FROM_ELMT((head)->hh.tbl, _hs_q->next) : NULL); \ + if (_hs_q == NULL) { \ + break; \ + } \ + } \ + _hs_qsize = _hs_insize; \ + while ((_hs_psize != 0U) || ((_hs_qsize != 0U) && (_hs_q != NULL))) { \ + if (_hs_psize == 0U) { \ + _hs_e = _hs_q; \ + _hs_q = ((_hs_q->next != NULL) ? \ + HH_FROM_ELMT((head)->hh.tbl, _hs_q->next) : NULL); \ + _hs_qsize--; \ + } else if ((_hs_qsize == 0U) || (_hs_q == NULL)) { \ + _hs_e = _hs_p; \ + if (_hs_p != NULL) { \ + _hs_p = ((_hs_p->next != NULL) ? \ + HH_FROM_ELMT((head)->hh.tbl, _hs_p->next) : NULL); \ + } \ + _hs_psize--; \ + } else if ((cmpfcn( \ + DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl, _hs_p)), \ + DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl, _hs_q)) \ + )) <= 0) { \ + _hs_e = _hs_p; \ + if (_hs_p != NULL) { \ + _hs_p = ((_hs_p->next != NULL) ? \ + HH_FROM_ELMT((head)->hh.tbl, _hs_p->next) : NULL); \ + } \ + _hs_psize--; \ + } else { \ + _hs_e = _hs_q; \ + _hs_q = ((_hs_q->next != NULL) ? \ + HH_FROM_ELMT((head)->hh.tbl, _hs_q->next) : NULL); \ + _hs_qsize--; \ + } \ + if ( _hs_tail != NULL ) { \ + _hs_tail->next = ((_hs_e != NULL) ? \ + ELMT_FROM_HH((head)->hh.tbl, _hs_e) : NULL); \ + } else { \ + _hs_list = _hs_e; \ + } \ + if (_hs_e != NULL) { \ + _hs_e->prev = ((_hs_tail != NULL) ? \ + ELMT_FROM_HH((head)->hh.tbl, _hs_tail) : NULL); \ + } \ + _hs_tail = _hs_e; \ + } \ + _hs_p = _hs_q; \ + } \ + if (_hs_tail != NULL) { \ + _hs_tail->next = NULL; \ + } \ + if (_hs_nmerges <= 1U) { \ + _hs_looping = 0; \ + (head)->hh.tbl->tail = _hs_tail; \ + DECLTYPE_ASSIGN(head, ELMT_FROM_HH((head)->hh.tbl, _hs_list)); \ + } \ + _hs_insize *= 2U; \ + } \ + HASH_FSCK(hh, head, "HASH_SRT"); \ + } \ +} while (0) + +/* This function selects items from one hash into another hash. + * The end result is that the selected items have dual presence + * in both hashes. There is no copy of the items made; rather + * they are added into the new hash through a secondary hash + * hash handle that must be present in the structure. */ +#define HASH_SELECT(hh_dst, dst, hh_src, src, cond) \ +do { \ + unsigned _src_bkt, _dst_bkt; \ + void *_last_elt = NULL, *_elt; \ + UT_hash_handle *_src_hh, *_dst_hh, *_last_elt_hh=NULL; \ + ptrdiff_t _dst_hho = ((char*)(&(dst)->hh_dst) - (char*)(dst)); \ + if ((src) != NULL) { \ + for (_src_bkt=0; _src_bkt < (src)->hh_src.tbl->num_buckets; _src_bkt++) { \ + for (_src_hh = (src)->hh_src.tbl->buckets[_src_bkt].hh_head; \ + _src_hh != NULL; \ + _src_hh = _src_hh->hh_next) { \ + _elt = ELMT_FROM_HH((src)->hh_src.tbl, _src_hh); \ + if (cond(_elt)) { \ + IF_HASH_NONFATAL_OOM( int _hs_oomed = 0; ) \ + _dst_hh = (UT_hash_handle*)(((char*)_elt) + _dst_hho); \ + _dst_hh->key = _src_hh->key; \ + _dst_hh->keylen = _src_hh->keylen; \ + _dst_hh->hashv = _src_hh->hashv; \ + _dst_hh->prev = _last_elt; \ + _dst_hh->next = NULL; \ + if (_last_elt_hh != NULL) { \ + _last_elt_hh->next = _elt; \ + } \ + if ((dst) == NULL) { \ + DECLTYPE_ASSIGN(dst, _elt); \ + HASH_MAKE_TABLE(hh_dst, dst, _hs_oomed); \ + IF_HASH_NONFATAL_OOM( \ + if (_hs_oomed) { \ + uthash_nonfatal_oom(_elt); \ + (dst) = NULL; \ + continue; \ + } \ + ) \ + } else { \ + _dst_hh->tbl = (dst)->hh_dst.tbl; \ + } \ + HASH_TO_BKT(_dst_hh->hashv, _dst_hh->tbl->num_buckets, _dst_bkt); \ + HASH_ADD_TO_BKT(_dst_hh->tbl->buckets[_dst_bkt], hh_dst, _dst_hh, _hs_oomed); \ + (dst)->hh_dst.tbl->num_items++; \ + IF_HASH_NONFATAL_OOM( \ + if (_hs_oomed) { \ + HASH_ROLLBACK_BKT(hh_dst, dst, _dst_hh); \ + HASH_DELETE_HH(hh_dst, dst, _dst_hh); \ + _dst_hh->tbl = NULL; \ + uthash_nonfatal_oom(_elt); \ + continue; \ + } \ + ) \ + HASH_BLOOM_ADD(_dst_hh->tbl, _dst_hh->hashv); \ + _last_elt = _elt; \ + _last_elt_hh = _dst_hh; \ + } \ + } \ + } \ + } \ + HASH_FSCK(hh_dst, dst, "HASH_SELECT"); \ +} while (0) + +#define HASH_CLEAR(hh,head) \ +do { \ + if ((head) != NULL) { \ + HASH_BLOOM_FREE((head)->hh.tbl); \ + uthash_free((head)->hh.tbl->buckets, \ + (head)->hh.tbl->num_buckets*sizeof(struct UT_hash_bucket)); \ + uthash_free((head)->hh.tbl, sizeof(UT_hash_table)); \ + (head) = NULL; \ + } \ +} while (0) + +#define HASH_OVERHEAD(hh,head) \ + (((head) != NULL) ? ( \ + (size_t)(((head)->hh.tbl->num_items * sizeof(UT_hash_handle)) + \ + ((head)->hh.tbl->num_buckets * sizeof(UT_hash_bucket)) + \ + sizeof(UT_hash_table) + \ + (HASH_BLOOM_BYTELEN))) : 0U) + +#ifdef NO_DECLTYPE +#define HASH_ITER(hh,head,el,tmp) \ +for(((el)=(head)), ((*(char**)(&(tmp)))=(char*)((head!=NULL)?(head)->hh.next:NULL)); \ + (el) != NULL; ((el)=(tmp)), ((*(char**)(&(tmp)))=(char*)((tmp!=NULL)?(tmp)->hh.next:NULL))) +#else +#define HASH_ITER(hh,head,el,tmp) \ +for(((el)=(head)), ((tmp)=DECLTYPE(el)((head!=NULL)?(head)->hh.next:NULL)); \ + (el) != NULL; ((el)=(tmp)), ((tmp)=DECLTYPE(el)((tmp!=NULL)?(tmp)->hh.next:NULL))) +#endif + +/* obtain a count of items in the hash */ +#define HASH_COUNT(head) HASH_CNT(hh,head) +#define HASH_CNT(hh,head) ((head != NULL)?((head)->hh.tbl->num_items):0U) + +typedef struct UT_hash_bucket { + struct UT_hash_handle *hh_head; + unsigned count; + + /* expand_mult is normally set to 0. In this situation, the max chain length + * threshold is enforced at its default value, HASH_BKT_CAPACITY_THRESH. (If + * the bucket's chain exceeds this length, bucket expansion is triggered). + * However, setting expand_mult to a non-zero value delays bucket expansion + * (that would be triggered by additions to this particular bucket) + * until its chain length reaches a *multiple* of HASH_BKT_CAPACITY_THRESH. + * (The multiplier is simply expand_mult+1). The whole idea of this + * multiplier is to reduce bucket expansions, since they are expensive, in + * situations where we know that a particular bucket tends to be overused. + * It is better to let its chain length grow to a longer yet-still-bounded + * value, than to do an O(n) bucket expansion too often. + */ + unsigned expand_mult; + +} UT_hash_bucket; + +/* random signature used only to find hash tables in external analysis */ +#define HASH_SIGNATURE 0xa0111fe1u +#define HASH_BLOOM_SIGNATURE 0xb12220f2u + +typedef struct UT_hash_table { + UT_hash_bucket *buckets; + unsigned num_buckets, log2_num_buckets; + unsigned num_items; + struct UT_hash_handle *tail; /* tail hh in app order, for fast append */ + ptrdiff_t hho; /* hash handle offset (byte pos of hash handle in element */ + + /* in an ideal situation (all buckets used equally), no bucket would have + * more than ceil(#items/#buckets) items. that's the ideal chain length. */ + unsigned ideal_chain_maxlen; + + /* nonideal_items is the number of items in the hash whose chain position + * exceeds the ideal chain maxlen. these items pay the penalty for an uneven + * hash distribution; reaching them in a chain traversal takes >ideal steps */ + unsigned nonideal_items; + + /* ineffective expands occur when a bucket doubling was performed, but + * afterward, more than half the items in the hash had nonideal chain + * positions. If this happens on two consecutive expansions we inhibit any + * further expansion, as it's not helping; this happens when the hash + * function isn't a good fit for the key domain. When expansion is inhibited + * the hash will still work, albeit no longer in constant time. */ + unsigned ineff_expands, noexpand; + + uint32_t signature; /* used only to find hash tables in external analysis */ +#ifdef HASH_BLOOM + uint32_t bloom_sig; /* used only to test bloom exists in external analysis */ + uint8_t *bloom_bv; + uint8_t bloom_nbits; +#endif + +} UT_hash_table; + +typedef struct UT_hash_handle { + struct UT_hash_table *tbl; + void *prev; /* prev element in app order */ + void *next; /* next element in app order */ + struct UT_hash_handle *hh_prev; /* previous hh in bucket order */ + struct UT_hash_handle *hh_next; /* next hh in bucket order */ + void *key; /* ptr to enclosing struct's key */ + unsigned keylen; /* enclosing struct's key len */ + unsigned hashv; /* result of hash-fcn(key) */ +} UT_hash_handle; + +#endif /* UTHASH_H */ diff --git a/tests/deckard/contrib/libfaketime/test/Makefile b/tests/deckard/contrib/libfaketime/test/Makefile new file mode 100644 index 0000000..94d1a2e --- /dev/null +++ b/tests/deckard/contrib/libfaketime/test/Makefile @@ -0,0 +1,31 @@ +CC = gcc + +CFLAGS = -std=gnu99 -Wall -DFAKE_STAT -Werror -Wextra +LDFLAGS = -lrt -lpthread + +SRC = timetest.c +OBJ = ${SRC:.c=.o} + +all: timetest test + +.c.o: + ${CC} -c ${CFLAGS} $< + +timetest: ${OBJ} + ${CC} -o $@ ${OBJ} ${LDFLAGS} + +test: timetest functest + @echo + @./test.sh + +# run functional tests +functest: + ./testframe.sh functests + +clean: + @rm -f ${OBJ} timetest + +distclean: clean + @echo + +.PHONY: all test clean distclean diff --git a/tests/deckard/contrib/libfaketime/test/Makefile.OSX b/tests/deckard/contrib/libfaketime/test/Makefile.OSX new file mode 100644 index 0000000..209d19f --- /dev/null +++ b/tests/deckard/contrib/libfaketime/test/Makefile.OSX @@ -0,0 +1,30 @@ +CC ?= clang + +CFLAGS += -std=gnu99 -Wall -DFAKE_STAT + +SRC = timetest.c +OBJ = ${SRC:.c=.o} + +all: timetest test + +.c.o: + ${CC} -c ${CFLAGS} $< + +timetest: ${OBJ} + ${CC} -o $@ ${OBJ} ${LDFLAGS} + +test: timetest functest + @echo + @./test_OSX.sh + +# run functional tests +functest: + ./testframe.sh functests + +clean: + @rm -f ${OBJ} timetest + +distclean: clean + @echo + +.PHONY: all test clean distclean diff --git a/tests/deckard/contrib/libfaketime/test/README-testframe.txt b/tests/deckard/contrib/libfaketime/test/README-testframe.txt new file mode 100644 index 0000000..d6980c3 --- /dev/null +++ b/tests/deckard/contrib/libfaketime/test/README-testframe.txt @@ -0,0 +1,39 @@ +# here's how the testframe script works. +# +# Usage for testing: +# usage: testframe.sh DIR +# testframe.sh runs each testsuite script found within DIR. +# (in the context of libfaketime, the DIR is functest.) +# exits with status 0 if all tests succeed. +# +# Interface: +# by convention, each testsuite script (within DIR) must be +# a bash script named test_*.sh. the script must define a +# function named "run". run takes no arguments. run is +# expected to call the framework-provided function +# run_testcase once for each test function. run_testcase +# uses the global vars NFAIL and NSUCC to keep track of how +# many testcases failed/succeeded. +# +# the test function is expected to call something like +# asserteq or assertneq (again, framework-provided). +# +# fine print: for each testsuite, the framework creates a +# subshell and dots in the script. also dotted in are +# testframe.inc and DIR/common.inc (if it exists). the +# testsuite script can make use of any functions defined +# in these inc files. the environment variable +# TESTSUITE_NAME is set to the filename of the testsuite +# script, for possible use in warning or info messages. +# +# see functests/test_true.sh for a simple example of +# a test suite script. +# +# Simple steps to add a new testsuite: +# 1. decide its name - eg, XXX. +# 2. choose a DIR of similar testsuites to put it in, or create a new one. +# 3. create DIR/test_XXX.sh. +# 4. write a run function and testcase functions in DIR/test_XXX.sh. +# 5. within the run function, call run_testcase for each testcase function. +# 6. within each testcase function, call assertneq or asserteq, or do +# the equivalent. diff --git a/tests/deckard/contrib/libfaketime/test/functests/common.inc b/tests/deckard/contrib/libfaketime/test/functests/common.inc new file mode 100644 index 0000000..d184ae2 --- /dev/null +++ b/tests/deckard/contrib/libfaketime/test/functests/common.inc @@ -0,0 +1,63 @@ +# libfaketime-specific common support routines for tests + +# say which *_fakecmd wrapper to use +platform() +{ + # may want to expand the pattern for linuxlike + typeset out=$(uname) + case "$out" in + *Darwin*) echo "mac" ;; + *Linux*) echo "linuxlike" ;; + GNU|GNU/kFreeBSD) echo "linuxlike" ;; + *SunOS*) echo "sunos" ;; + *) echo 1>&2 unsupported platform, uname=\"$out\" ;; + esac +} + +# run faked command on a mac +# UNTESTED +mac_fakecmd() +{ + typeset timestring="$1"; shift + typeset fakelib=../src/libfaketime.1.dylib + export DYLD_INSERT_LIBRARIES=$fakelib + export DYLD_FORCE_FLAT_NAMESPACE=1 + FAKETIME="$timestring" \ + "$@" +} + +sunos_fakecmd() +{ + typeset timestring="$1"; shift + typeset fakelib=../src/libfaketime.so.1 + export LD_PRELOAD=$fakelib + FAKETIME="$timestring" \ + "$@" +} + +# run faked command on linuxlike OS +linuxlike_fakecmd() +{ + typeset timestring="$1"; shift + typeset fakelib=../src/libfaketime.so.1 + export LD_PRELOAD=$fakelib + FAKETIME="$timestring" \ + "$@" +} + +# run a command with libfaketime using the given timestring +fakecmd() +{ + ${PLATFORM}_fakecmd "$@" +} + +# generate a sequence of numbers from a to b +range() +{ + typeset a=$1 b=$2 + typeset i=$a + while ((i <= b)); do + echo $i + ((i = i+1)) + done +} diff --git a/tests/deckard/contrib/libfaketime/test/functests/dont_test_false.sh b/tests/deckard/contrib/libfaketime/test/functests/dont_test_false.sh new file mode 100644 index 0000000..65457ef --- /dev/null +++ b/tests/deckard/contrib/libfaketime/test/functests/dont_test_false.sh @@ -0,0 +1,6 @@ +# a testsuite that will force failure - for testing purposes + +run() +{ + run_testcase false +} diff --git a/tests/deckard/contrib/libfaketime/test/functests/test_exclude_mono.sh b/tests/deckard/contrib/libfaketime/test/functests/test_exclude_mono.sh new file mode 100644 index 0000000..f68fc20 --- /dev/null +++ b/tests/deckard/contrib/libfaketime/test/functests/test_exclude_mono.sh @@ -0,0 +1,87 @@ +# Checks that setting DONT_FAKE_MONOTONIC actually prevent +# libfaketime from faking monotonic clocks. +# +# We do this by freezing time at a specific and arbitrary date with faketime, +# and making sure that if we set DONT_FAKE_MONOTONIC to 1, calling +# clock_gettime(CLOCK_MONOTONIC) returns two different values. +# +# We also make sure that if we don't set DONT_FAKE_MONOTONIC to 1, in other +# words when we use the default behavior, two subsequent calls to +# clock_gettime(CLOCK_MONOTONIC) do return different values. + +init() +{ + typeset testsuite="$1" + PLATFORM=$(platform) + if [ -z "$PLATFORM" ]; then + echo "$testsuite: unknown platform! quitting" + return 1 + fi + echo "# PLATFORM=$PLATFORM" + return 0 +} + +run() +{ + init + + run_testcase dont_fake_mono + run_testcase fake_mono +} + +get_token() +{ + string=$1 + token_index=$2 + separator=$3 + + echo $string | cut -d "$separator" -f $token_index +} + +assert_timestamps_neq() +{ + timestamps=$1 + msg=$2 + + first_timestamp=$(get_token "${timestamps}" 1 ' ') + second_timestamp=$(get_token "${timestamps}" 2 ' ') + + assertneq "${first_timestamp}" "${second_timestamp}" "${msg}" +} + +assert_timestamps_eq() +{ + timestamps=$1 + msg=$2 + + first_timestamp=$(get_token "${timestamps}" 1 ' ') + second_timestamp=$(get_token "${timestamps}" 2 ' ') + + asserteq "${first_timestamp}" "${second_timestamp}" "${msg}" +} + +get_monotonic_time() +{ + dont_fake_mono=$1; shift; + clock_id=$1; shift; + DONT_FAKE_MONOTONIC=${dont_fake_mono} fakecmd "2014-07-21 09:00:00" \ + /bin/bash -c "for i in 1 2; do \ + perl -w -MTime::HiRes=clock_gettime,${clock_id} -E \ + 'say clock_gettime(${clock_id})'; \ + sleep 1; \ + done" +} + +dont_fake_mono() +{ + timestamps=$(get_monotonic_time 1 CLOCK_MONOTONIC) + msg="When not faking monotonic time, timestamps should be different" + assert_timestamps_neq "${timestamps}" "${msg}" +} + +fake_mono() +{ + timestamps=$(get_monotonic_time 0 CLOCK_MONOTONIC) + msg="When faking monotonic, timestamps should be equal" + assert_timestamps_eq "${timestamps}" "${msg}" +} diff --git a/tests/deckard/contrib/libfaketime/test/functests/test_null.sh b/tests/deckard/contrib/libfaketime/test/functests/test_null.sh new file mode 100644 index 0000000..09e7560 --- /dev/null +++ b/tests/deckard/contrib/libfaketime/test/functests/test_null.sh @@ -0,0 +1,13 @@ +# check that the date doesn't happen to be 0. + +run() +{ + run_testcase nulltest +} + +nulltest() +{ + typeset tdate=${I2DATES[0]} + + assertneq 0 "$(date +%s)" "($tdate)" +} diff --git a/tests/deckard/contrib/libfaketime/test/functests/test_true.sh b/tests/deckard/contrib/libfaketime/test/functests/test_true.sh new file mode 100644 index 0000000..0025bcf --- /dev/null +++ b/tests/deckard/contrib/libfaketime/test/functests/test_true.sh @@ -0,0 +1,7 @@ +# test suite that always succeeds - for testing framework + +run() +{ + run_testcase true + return 0 +} diff --git a/tests/deckard/contrib/libfaketime/test/functests/test_walkone.sh b/tests/deckard/contrib/libfaketime/test/functests/test_walkone.sh new file mode 100755 index 0000000..b27df9a --- /dev/null +++ b/tests/deckard/contrib/libfaketime/test/functests/test_walkone.sh @@ -0,0 +1,67 @@ +# walking-1 test. +# sourced in from testframe.sh. +# +# this script defines a suite of functional tests +# that verifies the correct operation of libfaketime +# with the date command. + +run() +{ + init + + for i in $(range 0 30); do + run_testcase test_with_i $i + done +} + +# ----- support routines +init() +{ + typeset testsuite="$1" + PLATFORM=$(platform) + if [ -z "$PLATFORM" ]; then + echo "$testsuite: unknown platform! quitting" + return 1 + fi + echo "# PLATFORM=$PLATFORM" + return 0 +} + + +# run date cmd under faketime, print time in secs +fakedate() +{ + # + # let the time format be raw seconds since Epoch + # for both input to libfaketime, and output of the date cmd. + # + typeset fmt='%s' + export FAKETIME_FMT=$fmt + fakecmd "$1" date +$fmt +} + +# +# compute x**n. +# use only the shell, in case we need to run on machines +# without bc, dc, perl, etc. +# +pow() +{ + typeset x="$1" n="$2" + typeset r=1 + typeset i=0 + while ((i < n)); do + ((r = r*x)) + ((i++)) + done + echo $r +} + +# run a fakedate test with a given time t +test_with_i() +{ + typeset i="$1" + typeset t=$(pow 2 $i) + + asserteq $(fakedate $t) $t "(secs since Epoch)" +} diff --git a/tests/deckard/contrib/libfaketime/test/test.sh b/tests/deckard/contrib/libfaketime/test/test.sh new file mode 100755 index 0000000..630cec6 --- /dev/null +++ b/tests/deckard/contrib/libfaketime/test/test.sh @@ -0,0 +1,66 @@ +#!/bin/sh + +if [ -f /etc/faketimerc ] ; then + echo "Running the test program with your system-wide default in /etc/faketimerc" + echo "\$ LD_PRELOAD=../src/libfaketime.so.1 ./timetest" + LD_PRELOAD=../src/libfaketime.so.1 ./timetest + echo +else + echo "Running the test program with no faked time specified" + echo "\$ LD_PRELOAD=../src/libfaketime.so.1 ./timetest" + LD_PRELOAD=../src/libfaketime.so.1 ./timetest + echo +fi + +echo "=============================================================================" +echo + +echo "Running the test program with absolute date 2003-01-01 10:00:05 specified" +echo "\$ LD_PRELOAD=../src/libfaketime.so.1 FAKETIME=\"2003-01-01 10:00:05\" ./timetest" +LD_PRELOAD=../src/libfaketime.so.1 FAKETIME="2003-01-01 10:00:05" ./timetest +echo + +echo "=============================================================================" +echo + +echo "Running the test program with START date @2005-03-29 14:14:14 specified" +echo "\$ LD_PRELOAD=../src/libfaketime.so.1 FAKETIME=\"@2005-03-29 14:14:14\" ./timetest" +LD_PRELOAD=../src/libfaketime.so.1 FAKETIME="@2005-03-29 14:14:14" ./timetest +echo + +echo "=============================================================================" +echo + +echo "Running the test program with 10 days negative offset specified" +echo "LD_PRELOAD=../src/libfaketime.so.1 FAKETIME=\"-10d\" ./timetest" +LD_PRELOAD=../src/libfaketime.so.1 FAKETIME="-10d" ./timetest +echo + +echo "=============================================================================" +echo + +echo "Running the test program with 10 days negative offset specified, and FAKE_STAT disabled" +echo "\$ LD_PRELOAD=../src/libfaketime.so.1 FAKETIME=\"-10d\" NO_FAKE_STAT=1 ./timetest" +LD_PRELOAD=../src/libfaketime.so.1 FAKETIME="-10d" NO_FAKE_STAT=1 ./timetest +echo + +echo "=============================================================================" +echo + +echo "Running the test program with 10 days positive offset specified, and sped up 2 times" +echo "\$ LD_PRELOAD=../src/libfaketime.so.1 FAKETIME=\"+10d x2\" ./timetest" +LD_PRELOAD=../src/libfaketime.so.1 FAKETIME="+10d x2" NO_FAKE_STAT=1 ./timetest +echo + +echo "=============================================================================" +echo + +echo "Running the 'date' command with 15 days negative offset specified" +echo "\$ LD_PRELOAD=../src/libfaketime.so.1 FAKETIME=\"-15d\" date" +LD_PRELOAD=../src/libfaketime.so.1 FAKETIME="-15d" date +echo + +echo "=============================================================================" +echo "Testing finished." + +exit 0 diff --git a/tests/deckard/contrib/libfaketime/test/test_OSX.sh b/tests/deckard/contrib/libfaketime/test/test_OSX.sh new file mode 100755 index 0000000..a259275 --- /dev/null +++ b/tests/deckard/contrib/libfaketime/test/test_OSX.sh @@ -0,0 +1,46 @@ +#!/bin/sh + +export DYLD_FORCE_FLAT_NAMESPACE=1 +export DYLD_INSERT_LIBRARIES=../src/libfaketime.1.dylib + +if [ -f /etc/faketimerc ] ; then + echo "Running the test program with your system-wide default in /etc/faketimerc" + ./timetest + echo +else + echo "Running the test program with no faked time specified" + ./timetest + echo +fi + +echo "Running the test program with absolute date 2003-01-01 10:00:05 specified" +echo "FAKETIME=\"2003-01-01 10:00:05\" ./timetest" +FAKETIME="2003-01-01 10:00:05" ./timetest +echo + +echo "Running the test program with START date @2005-03-29 14:14:14 specified" +echo "FAKETIME=\"@2005-03-29 14:14:14\" ./timetest" +FAKETIME="@2005-03-29 14:14:14" ./timetest +echo + +echo "Running the test program with 10 days negative offset specified" +echo "FAKETIME=\"-10d\" ./timetest" +FAKETIME="-10d" ./timetest +echo + +echo "Running the test program with 10 days negative offset specified, and FAKE_STAT disabled" +echo "FAKETIME=\"-10d\" NO_FAKE_STAT=1 ./timetest" +FAKETIME="-10d" NO_FAKE_STAT=1 ./timetest +echo + +echo "Running the test program with 10 days positive offset specified, and sped up 2 times" +echo "FAKETIME=\"+10d x2\" ./timetest" +FAKETIME="+10d x2" NO_FAKE_STAT=1 ./timetest +echo + +echo "Running the 'date' command with 15 days negative offset specified" +echo "FAKETIME=\"-15d\" date" +FAKETIME="-15d" date +echo + +exit 0 diff --git a/tests/deckard/contrib/libfaketime/test/testframe.inc b/tests/deckard/contrib/libfaketime/test/testframe.inc new file mode 100644 index 0000000..b5f66a3 --- /dev/null +++ b/tests/deckard/contrib/libfaketime/test/testframe.inc @@ -0,0 +1,55 @@ +# framework common functions for use in test suites and test cases + +# +# run a test and keep stats on success/failure. +# arguments: a command, possibly a shell function. +# return value: 0 on success, 1 on failure. +# side effects: increments global var NSUCC on success, NFAIL on failure. +# +run_testcase() +{ + if "$@"; then + ((NSUCC++)) + return 0 + else + ((NFAIL++)) + return 1 + fi +} + +# +# verbosely check that the test output matches the expected value. +# arguments: the test output, the expected value, and a description. +# return value: 0 on if test output equals expected value; 1 otherwise. +# side effects: prints a descriptive message. +# +asserteq() +{ + typeset out="$1" expected="$2" desc="$3" + echo -n "out=$out $desc" + if [ "$out" = "$expected" ]; then + echo " - ok" + return 0 + else + echo " expected=$expected - bad" + return 1 + fi +} + +# +# verbosely check that the test output doesn't match the reference value. +# return value: 1 on if test output equals expected value; 0 if not equal. +# side effects: prints descriptive message. +# +assertneq() +{ + typeset out="$1" ref="$2" desc="$3" + echo -n "out=$out $desc" + if [ "$out" = "$ref" ]; then + echo " ref=$ref - bad" + return 1 + else + echo " ref=$ref - ok" + return 0 + fi +} diff --git a/tests/deckard/contrib/libfaketime/test/testframe.sh b/tests/deckard/contrib/libfaketime/test/testframe.sh new file mode 100755 index 0000000..22975b6 --- /dev/null +++ b/tests/deckard/contrib/libfaketime/test/testframe.sh @@ -0,0 +1,99 @@ +#! /bin/bash +# testframe.sh DIR +# bare-bones testing framework. +# run the test suites in the given DIR; +# exit with nonzero status if any of them failed. +# see README.testframe.txt for details. +# + +# echo labelled error/warning message to stderr +report() +{ + echo $PROG: $* 1>&2 +} + +# echo OK or BAD depending on argument (0 or not) +status_word() +{ + if [ "$1" -eq 0 ]; then + echo OK + else + echo BAD + fi +} + +# run the given testsuite, return nonzero if any testcase failed. +run_testsuite() +{ + typeset testsuite="$1" + + NFAIL=0 + NSUCC=0 + + # add testsuite dir to PATH for convenience + typeset dir=$(dirname $testsuite) + PATH=$dir:$PATH + . testframe.inc + if [ -f $dir/common.inc ]; then + . $dir/common.inc + fi + . $testsuite + export TESTSUITE_NAME=$testsuite + + echo "" + echo "# Begin $testsuite" + + run + typeset runstat=$? + + echo "# $testsuite summary: $NSUCC succeeded, $NFAIL failed" + if [ $runstat -ne 0 ]; then + ((NFAIL++)) + report "error: $testsuite run exit_status=$runstat!" + fi + echo "# End $testsuite -" $(status_word $NFAIL) + [ $NFAIL -eq 0 ] +} + +# +# list all testsuite scripts in the given directories. +# a testsuite file must be a bash script whose name is of the form test_*.sh . +# +list_testsuites() +{ + for dir in "$@"; do + ls $dir/test_*.sh 2>/dev/null + done +} + +main() +{ + TS_NFAIL=0 + TS_NSUCC=0 + + echo "# Begin Test Suites in $*" + typeset testsuites=$(list_testsuites "$@") + + if [ -z "$testsuites" ]; then + report "error: no testsuites found" + exit 1 + fi + + for testsuite in $testsuites; do + if run_testsuite $testsuite; then + ((TS_NSUCC++)) + else + ((TS_NFAIL++)) + fi + done + + echo "" + echo "# Test Suites summary: $TS_NSUCC succeeded, $TS_NFAIL failed" + echo "# End Test Suites -" $(status_word $TS_NFAIL) + [ $TS_NFAIL -eq 0 ] +} + +# ----- start of mainline code +PROG=${0##*/} + +main "${@:-.}" diff --git a/tests/deckard/contrib/libfaketime/test/timetest.c b/tests/deckard/contrib/libfaketime/test/timetest.c new file mode 100644 index 0000000..4e3515c --- /dev/null +++ b/tests/deckard/contrib/libfaketime/test/timetest.c @@ -0,0 +1,284 @@ +/* + * Copyright (C) 2003,2007 Wolfgang Hommel + * + * This file is part of the FakeTime Preload Library. + * + * The FakeTime Preload Library is free software; you can redistribute it + * and/or modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * The FakeTime Preload 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with the FakeTime Preload Library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#define _GNU_SOURCE +#include <stdio.h> +#include <stdlib.h> +#include <time.h> +#include <sys/time.h> +#include <sys/timeb.h> + +#ifdef FAKE_STAT +#include <sys/types.h> +#include <sys/stat.h> +#include <unistd.h> +#endif + +#ifndef __APPLE__ +#include <pthread.h> +#include <errno.h> +#include <signal.h> + +#define VERBOSE 0 + +#define SIG SIGUSR1 + +static void +handler(int sig, siginfo_t *si, void *uc) +{ + /* Note: calling printf() from a signal handler is not + strictly correct, since printf() is not async-signal-safe; + see signal(7) */ + + if ((si == NULL) || (si != uc)) + { + printf("Caught signal %d\n", sig); + } +} + +void* pthread_test(void* args) +{ + pthread_mutex_t fakeMutex = PTHREAD_MUTEX_INITIALIZER; + pthread_cond_t fakeCond = PTHREAD_COND_INITIALIZER; + + pthread_cond_t monotonic_cond; + pthread_condattr_t attr; + + struct timespec timeToWait, now; + int rt; + + args = args; // silence compiler warning about unused argument + + clock_gettime(CLOCK_REALTIME, &now); + timeToWait.tv_sec = now.tv_sec+1; + timeToWait.tv_nsec = now.tv_nsec; + + printf("pthread_cond_timedwait: CLOCK_REALTIME test\n"); + printf("(Intentionally sleeping 1 second...)\n"); + fflush(stdout); + + pthread_mutex_lock(&fakeMutex); + rt = pthread_cond_timedwait(&fakeCond, &fakeMutex, &timeToWait); + if (rt != ETIMEDOUT) + { + printf("pthread_cond_timedwait failed\n"); + exit(EXIT_FAILURE); + } + pthread_mutex_unlock(&fakeMutex); + + + pthread_condattr_init(&attr); + pthread_condattr_setclock(&attr, CLOCK_MONOTONIC); + pthread_cond_init(&monotonic_cond, &attr); + + clock_gettime(CLOCK_MONOTONIC, &now); + timeToWait.tv_sec = now.tv_sec+1; + timeToWait.tv_nsec = now.tv_nsec; + + printf("pthread_cond_timedwait: CLOCK_MONOTONIC test\n"); + printf("(Intentionally sleeping 1 second...)\n"); + fflush(stdout); + + pthread_mutex_lock(&fakeMutex); + rt = pthread_cond_timedwait(&monotonic_cond, &fakeMutex, &timeToWait); + if (rt != ETIMEDOUT) + { + printf("pthread_cond_timedwait failed\n"); + exit(EXIT_FAILURE); + } + pthread_mutex_unlock(&fakeMutex); + + pthread_cond_destroy(&monotonic_cond); + + return NULL; +} + +#endif + +int main (int argc, char **argv) +{ + time_t now; + struct timeb tb; + struct timeval tv; +#ifndef __APPLE__ + struct timespec ts; + timer_t timerid1 = 0, timerid2; + struct sigevent sev; + struct itimerspec its; + sigset_t mask; + struct sigaction sa; +#endif +#ifdef FAKE_STAT + struct stat buf; +#endif + +#ifndef __APPLE__ + pthread_t thread; + void *ret; + + pthread_create(&thread, NULL, pthread_test, NULL); + pthread_join(thread, &ret); + + sa.sa_flags = SA_SIGINFO; + sa.sa_sigaction = handler; + sigemptyset(&sa.sa_mask); + if (sigaction(SIGUSR1, &sa, NULL) == -1) + { + perror("sigaction"); + exit(EXIT_FAILURE); + } + + /* Block timer signal temporarily */ + printf("Blocking signal %d\n", SIGUSR1); + sigemptyset(&mask); + sigaddset(&mask, SIGUSR1); + if (sigprocmask(SIG_SETMASK, &mask, NULL) == -1) + { + perror("sigaction"); + exit(EXIT_FAILURE); + } + + /* Create the timer */ + sev.sigev_notify = SIGEV_SIGNAL; + sev.sigev_signo = SIGUSR1; + sev.sigev_value.sival_ptr = &timerid1; + if (timer_create(CLOCK_REALTIME, &sev, &timerid1) == -1) + { + perror("timer_create"); + exit(EXIT_FAILURE); + } + + /* Start timer1 */ + + /* start timer ticking after one second */ + its.it_value.tv_sec = 1; + its.it_value.tv_nsec = 0; + /* fire in every 0.3 seconds */ + its.it_interval.tv_sec = 0; + its.it_interval.tv_nsec = 300000000; + + if (timer_settime(timerid1, 0, &its, NULL) == -1) + { + perror("timer_settime"); + exit(EXIT_FAILURE); + } + + sev.sigev_value.sival_ptr = &timerid2; + if (timer_create(CLOCK_REALTIME, &sev, &timerid2) == -1) + { + perror("timer_create"); + exit(EXIT_FAILURE); + } + + /* Start timer2 */ + + clock_gettime(CLOCK_REALTIME, &its.it_value); + /* start timer ticking after one second */ + its.it_value.tv_sec += 3; + /* fire once */ + its.it_interval.tv_sec = 0; + its.it_interval.tv_nsec = 0; + + if (timer_settime(timerid2, TIMER_ABSTIME, &its, NULL) == -1) + { + perror("timer_settime"); + exit(EXIT_FAILURE); + } +#endif + + time(&now); + printf("time() : Current date and time: %s", ctime(&now)); + printf("time(NULL) : Seconds since Epoch : %u\n", (unsigned int)time(NULL)); + + ftime(&tb); + printf("ftime() : Current date and time: %s", ctime(&tb.time)); + + printf("(Intentionally sleeping 2 seconds...)\n"); + fflush(stdout); + if (argc < 3) + { + sleep(1); + usleep(1000000); + } + + gettimeofday(&tv, NULL); + printf("gettimeofday() : Current date and time: %s", ctime(&tv.tv_sec)); + +#ifndef __APPLE__ + if (sigprocmask(SIG_UNBLOCK, &mask, NULL) == -1) + { + perror("sigprocmask"); + exit(EXIT_FAILURE); + } + + clock_gettime(CLOCK_REALTIME, &ts); + printf("clock_gettime(): Current date and time: %s", ctime(&ts.tv_sec)); + + int timer_getoverrun_timerid1 = timer_getoverrun(timerid1); + if (timer_getoverrun_timerid1 != 3) + { + printf("timer_getoverrun(timerid1) FAILED, must be 3 but got: %d\n", timer_getoverrun_timerid1); + } + + timer_gettime(timerid1, &its); + if (VERBOSE == 1) + { + printf("timer_gettime(timerid1, &its); its = {{%ld, %ld}, {%ld, %ld}}}\n", + (long)its.it_interval.tv_sec, (long)its.it_interval.tv_nsec, + (long)its.it_value.tv_sec, (long)its.it_value.tv_nsec); + } + + int timer_getoverrun_timerid2 = timer_getoverrun(timerid2); + if (timer_getoverrun_timerid2 != 0) + { + printf("timer_getoverrun(timerid2) FAILED, must be 0 but got: %d\n", timer_getoverrun_timerid2); + } + + timer_gettime(timerid2, &its); + if (VERBOSE == 1) + { + printf("timer_gettime(timerid2, &its); its = {{%ld, %ld}, {%ld, %ld}}}\n", + (long)its.it_interval.tv_sec, (long)its.it_interval.tv_nsec, + (long)its.it_value.tv_sec, (long)its.it_value.tv_nsec); + } +#endif + +#ifdef FAKE_STAT + lstat(argv[0], &buf); + printf("stat(): mod. time of file '%s': %s", argv[0], ctime(&buf.st_mtime)); +#endif + + return 0; +} + +/* + * Editor modelines + * + * Local variables: + * c-basic-offset: 2 + * tab-width: 2 + * indent-tabs-mode: nil + * End: + * + * vi: set shiftwidth=2 tabstop=2 expandtab: + * :indentSize=2:tabSize=2:noTabs=true: + */ + +/* eof */ diff --git a/tests/deckard/contrib/libswrap/.gitignore b/tests/deckard/contrib/libswrap/.gitignore new file mode 100644 index 0000000..5d8f581 --- /dev/null +++ b/tests/deckard/contrib/libswrap/.gitignore @@ -0,0 +1,9 @@ +*.a +*.o +.* +*.swp +*~ +build +obj +cscope.* +tags diff --git a/tests/deckard/contrib/libswrap/AUTHORS b/tests/deckard/contrib/libswrap/AUTHORS new file mode 100644 index 0000000..b29dad2 --- /dev/null +++ b/tests/deckard/contrib/libswrap/AUTHORS @@ -0,0 +1,3 @@ +Jelmer Vernooij <jelmer@samba.org> +Stefan Metzmacher <metze@samba.org> +Andreas Schneider <asn@samba.org> diff --git a/tests/deckard/contrib/libswrap/CMakeLists.txt b/tests/deckard/contrib/libswrap/CMakeLists.txt new file mode 100644 index 0000000..4d7c12e --- /dev/null +++ b/tests/deckard/contrib/libswrap/CMakeLists.txt @@ -0,0 +1,86 @@ +project(socket_wrapper C) + +# Required cmake version +cmake_minimum_required(VERSION 2.8.5) + +# global needed variables +set(APPLICATION_NAME ${PROJECT_NAME}) + +set(APPLICATION_VERSION_MAJOR "1") +set(APPLICATION_VERSION_MINOR "1") +set(APPLICATION_VERSION_PATCH "7") + +set(APPLICATION_VERSION "${APPLICATION_VERSION_MAJOR}.${APPLICATION_VERSION_MINOR}.${APPLICATION_VERSION_PATCH}") + +# SOVERSION scheme: CURRENT.AGE.REVISION +# If there was an incompatible interface change: +# Increment CURRENT. Set AGE and REVISION to 0 +# If there was a compatible interface change: +# Increment AGE. Set REVISION to 0 +# If the source code was changed, but there were no interface changes: +# Increment REVISION. +set(LIBRARY_VERSION "0.1.7") +set(LIBRARY_SOVERSION "0") + +# where to look first for cmake modules, before ${CMAKE_ROOT}/Modules/ is checked +set(CMAKE_MODULE_PATH + ${CMAKE_SOURCE_DIR}/cmake/Modules +) + +# add definitions +include(DefineCMakeDefaults) +include(DefinePlatformDefaults) +include(DefineCompilerFlags) +include(DefineInstallationPaths) +include(DefineOptions.cmake) +include(CPackConfig.cmake) + +# disallow in-source build +include(MacroEnsureOutOfSourceBuild) +macro_ensure_out_of_source_build("${PROJECT_NAME} requires an out of source build. Please create a separate build directory and run 'cmake /path/to/${PROJECT_NAME} [options]' there.") + +# Find out if we have threading available +set(CMAKE_THREAD_PREFER_PTHREADS ON) +find_package(Threads) + +# config.h checks +include(ConfigureChecks.cmake) +configure_file(config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config.h) + +# check subdirectories +add_subdirectory(src) + +if (UNIT_TESTING) + find_package(cmocka 0.4.1 REQUIRED) + + include(AddCMockaTest) + add_subdirectory(tests) +endif (UNIT_TESTING) + +# pkg-config file +get_filename_component(SOCKET_WRAPPER_LIB ${SOCKET_WRAPPER_LOCATION} NAME) + +configure_file(socket_wrapper.pc.cmake ${CMAKE_CURRENT_BINARY_DIR}/socket_wrapper.pc @ONLY) +install( + FILES + ${CMAKE_CURRENT_BINARY_DIR}/socket_wrapper.pc + DESTINATION + ${LIB_INSTALL_DIR}/pkgconfig + COMPONENT + pkgconfig +) + +# cmake config files +configure_file(socket_wrapper-config-version.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/socket_wrapper-config-version.cmake @ONLY) +configure_file(socket_wrapper-config.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/socket_wrapper-config.cmake @ONLY) +install( + FILES + ${CMAKE_CURRENT_BINARY_DIR}/socket_wrapper-config-version.cmake + ${CMAKE_CURRENT_BINARY_DIR}/socket_wrapper-config.cmake + DESTINATION + ${CMAKE_INSTALL_DIR}/socket_wrapper + COMPONENT + devel +) + +add_subdirectory(doc) diff --git a/tests/deckard/contrib/libswrap/COPYING b/tests/deckard/contrib/libswrap/COPYING new file mode 100644 index 0000000..e6227e1 --- /dev/null +++ b/tests/deckard/contrib/libswrap/COPYING @@ -0,0 +1,32 @@ +Copyright (C) Jelmer Vernooij 2005,2008 <jelmer@samba.org> +Copyright (C) Stefan Metzmacher 2006-2009 <metze@samba.org> +Copyright (C) Andreas Schneider 2013 <asn@samba.org> + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +3. Neither the name of the author nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +SUCH DAMAGE. diff --git a/tests/deckard/contrib/libswrap/CPackConfig.cmake b/tests/deckard/contrib/libswrap/CPackConfig.cmake new file mode 100644 index 0000000..dc74dfa --- /dev/null +++ b/tests/deckard/contrib/libswrap/CPackConfig.cmake @@ -0,0 +1,53 @@ +# For help take a look at: +# http://www.cmake.org/Wiki/CMake:CPackConfiguration + +### general settings +set(CPACK_PACKAGE_NAME ${APPLICATION_NAME}) +set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "The SSH library") +set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_SOURCE_DIR}/README") +set(CPACK_PACKAGE_VENDOR "The SSH Library Development Team") +set(CPACK_PACKAGE_INSTALL_DIRECTORY ${CPACK_PACKAGE_NAME}) +set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/COPYING") + + +### versions +set(CPACK_PACKAGE_VERSION_MAJOR "${APPLICATION_VERSION_MAJOR}") +set(CPACK_PACKAGE_VERSION_MINOR "${APPLICATION_VERSION_MINOR}") +set(CPACK_PACKAGE_VERSION_PATCH "${APPLICATION_VERSION_PATCH}") +set(CPACK_PACKAGE_VERSION "${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}") + + +### source generator +set(CPACK_SOURCE_GENERATOR "TGZ") +set(CPACK_SOURCE_IGNORE_FILES "~$;[.]swp$;/[.]svn/;/[.]git/;.gitignore;/build/;/obj/;tags;cscope.*") +set(CPACK_SOURCE_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}") + +if (WIN32) + set(CPACK_GENERATOR "ZIP") + + ### nsis generator + find_package(NSIS) + if (NSIS_MAKE) + set(CPACK_GENERATOR "${CPACK_GENERATOR};NSIS") + set(CPACK_NSIS_DISPLAY_NAME "The SSH Library") + set(CPACK_NSIS_COMPRESSOR "/SOLID zlib") + set(CPACK_NSIS_MENU_LINKS "http://www.libssh.org/" "libssh homepage") + endif (NSIS_MAKE) +endif (WIN32) + +set(CPACK_PACKAGE_INSTALL_DIRECTORY "libssh") + +set(CPACK_PACKAGE_FILE_NAME ${APPLICATION_NAME}-${CPACK_PACKAGE_VERSION}) + +set(CPACK_COMPONENT_LIBRARIES_DISPLAY_NAME "Libraries") +set(CPACK_COMPONENT_HEADERS_DISPLAY_NAME "C/C++ Headers") +set(CPACK_COMPONENT_LIBRARIES_DESCRIPTION + "Libraries used to build programs which use libssh") +set(CPACK_COMPONENT_HEADERS_DESCRIPTION + "C/C++ header files for use with libssh") +set(CPACK_COMPONENT_HEADERS_DEPENDS libraries) +#set(CPACK_COMPONENT_APPLICATIONS_GROUP "Runtime") +set(CPACK_COMPONENT_LIBRARIES_GROUP "Development") +set(CPACK_COMPONENT_HEADERS_GROUP "Development") + +include(CPack) diff --git a/tests/deckard/contrib/libswrap/CTestConfig.cmake b/tests/deckard/contrib/libswrap/CTestConfig.cmake new file mode 100644 index 0000000..3c29af3 --- /dev/null +++ b/tests/deckard/contrib/libswrap/CTestConfig.cmake @@ -0,0 +1,9 @@ +set(UPDATE_TYPE "true") + +set(CTEST_PROJECT_NAME "socketwrapper") +set(CTEST_NIGHTLY_START_TIME "01:00:00 UTC") + +set(CTEST_DROP_METHOD "https") +set(CTEST_DROP_SITE "mock.cryptomilk.org") +set(CTEST_DROP_LOCATION "/submit.php?project=socketwrapper") +set(CTEST_DROP_SITE_CDASH TRUE) diff --git a/tests/deckard/contrib/libswrap/ChangeLog b/tests/deckard/contrib/libswrap/ChangeLog new file mode 100644 index 0000000..dd03665 --- /dev/null +++ b/tests/deckard/contrib/libswrap/ChangeLog @@ -0,0 +1,60 @@ +ChangeLog +========== + +version 1.1.7 (released 2016-05-20) + * Added support for accept4() + * Added support for OpenBSD + * Fixed sendto() with UDP and a connected socket + * Fixed AF_RAWLINK sockets + +version 1.1.6 (released 2016-03-15) + * Added a wrapper for write() + * Added support for automatic binding of ephemeral ports + * Fixed recvmsg() with UDP + * Fixed AF_NETLINK sockets + +version 1.1.5 (released 2015-10-15) + * Added support for TCP_NODELAY in setsockopt/getsockopt + * Fixed cmsg space calculation + +version 1.1.4 (released 2015-08-25) + * Fixed handling of msg_name in recvmsg() + * Fixed sendmsg()/recvmsg() TCP support + * Fixed several compile warnings + * Added environment variable to change MTU + +version 1.1.3 (released 2015-02-23) + * Added support for address sanitizer. + * Fixed leaking of memory and fds of stale sockets. + * Fixed the library loading code. + +version 1.1.2 (released 2014-10-01) + * Added support for fnctl(F_DUPFD). + * Added support for glibc 2.20.90. + +version 1.1.1 (released 2014-06-05) + * Disable incomplete address in use check in bind(). + +version 1.1.0 (released 2014-06-02) + * Added support for IP_PKTINFO in recvmsg(). + * Added support for IPV6_PKTINFO in recvmsg(). + * Added support for IP_RECVDSTADDR in recvmsg() on BSD. + * Added support for more socket options in getsockopt(). + * Added support for bindresvport(). + * Fixed rebinding on connect(). + * Fixed sockaddr buffer truncation in getsockname() and getpeername(). + * Fixed special cases in bind(). + * Fixed loading libc on some platforms. + +version 1.0.2 (released 2014-05-05) + * Fixed memory leaks + * Fixed calling open from libc. + * Fixed loading libc functions on some platforms. + +version 1.0.1 (released 2014-02-04) + * Added --libs to pkg-config. + * Added socket_wrapper-config.cmake + * Fixed a bug packaging the obj directory. + +version 1.0.0 (released 2014-02-02) + * Initial release diff --git a/tests/deckard/contrib/libswrap/ConfigureChecks.cmake b/tests/deckard/contrib/libswrap/ConfigureChecks.cmake new file mode 100644 index 0000000..48455ef --- /dev/null +++ b/tests/deckard/contrib/libswrap/ConfigureChecks.cmake @@ -0,0 +1,232 @@ +include(CheckIncludeFile) +include(CheckSymbolExists) +include(CheckFunctionExists) +include(CheckLibraryExists) +include(CheckTypeSize) +include(CheckStructHasMember) +include(CheckPrototypeDefinition) +include(TestBigEndian) + +set(PACKAGE ${APPLICATION_NAME}) +set(VERSION ${APPLICATION_VERSION}) +set(DATADIR ${DATA_INSTALL_DIR}) +set(LIBDIR ${LIB_INSTALL_DIR}) +set(PLUGINDIR "${PLUGIN_INSTALL_DIR}-${LIBRARY_SOVERSION}") +set(SYSCONFDIR ${SYSCONF_INSTALL_DIR}) + +set(BINARYDIR ${CMAKE_BINARY_DIR}) +set(SOURCEDIR ${CMAKE_SOURCE_DIR}) + +function(COMPILER_DUMPVERSION _OUTPUT_VERSION) + # Remove whitespaces from the argument. + # This is needed for CC="ccache gcc" cmake .. + string(REPLACE " " "" _C_COMPILER_ARG "${CMAKE_C_COMPILER_ARG1}") + + execute_process( + COMMAND + ${CMAKE_C_COMPILER} ${_C_COMPILER_ARG} -dumpversion + OUTPUT_VARIABLE _COMPILER_VERSION + ) + + string(REGEX REPLACE "([0-9])\\.([0-9])(\\.[0-9])?" "\\1\\2" + _COMPILER_VERSION "${_COMPILER_VERSION}") + + set(${_OUTPUT_VERSION} ${_COMPILER_VERSION} PARENT_SCOPE) +endfunction() + +if(CMAKE_COMPILER_IS_GNUCC AND NOT MINGW AND NOT OS2) + compiler_dumpversion(GNUCC_VERSION) + if (NOT GNUCC_VERSION EQUAL 34) + set(CMAKE_REQUIRED_FLAGS "-fvisibility=hidden") + check_c_source_compiles( +"void __attribute__((visibility(\"default\"))) test() {} +int main(void){ return 0; } +" WITH_VISIBILITY_HIDDEN) + set(CMAKE_REQUIRED_FLAGS "") + endif (NOT GNUCC_VERSION EQUAL 34) +endif(CMAKE_COMPILER_IS_GNUCC AND NOT MINGW AND NOT OS2) + +# HEADERS +check_include_file(sys/filio.h HAVE_SYS_FILIO_H) +check_include_file(sys/signalfd.h HAVE_SYS_SIGNALFD_H) +check_include_file(sys/eventfd.h HAVE_SYS_EVENTFD_H) +check_include_file(sys/timerfd.h HAVE_SYS_TIMERFD_H) +check_include_file(gnu/lib-names.h HAVE_GNU_LIB_NAMES_H) +check_include_file(rpc/rpc.h HAVE_RPC_RPC_H) + +# FUNCTIONS +check_function_exists(strncpy HAVE_STRNCPY) +check_function_exists(vsnprintf HAVE_VSNPRINTF) +check_function_exists(snprintf HAVE_SNPRINTF) +check_function_exists(signalfd HAVE_SIGNALFD) +check_function_exists(eventfd HAVE_EVENTFD) +check_function_exists(timerfd_create HAVE_TIMERFD_CREATE) +check_function_exists(bindresvport HAVE_BINDRESVPORT) +check_function_exists(accept4 HAVE_ACCEPT4) + +check_function_exists(pledge HAVE_PLEDGE) + + +if (UNIX) + if (NOT LINUX) + # libsocket (Solaris) + check_library_exists(socket getaddrinfo "" HAVE_LIBSOCKET) + if (HAVE_LIBSOCKET) + set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} socket) + endif (HAVE_LIBSOCKET) + + # libnsl/inet_pton (Solaris) + check_library_exists(nsl inet_pton "" HAVE_LIBNSL) + if (HAVE_LIBNSL) + set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} nsl) + endif (HAVE_LIBNSL) + endif (NOT LINUX) + + check_function_exists(getaddrinfo HAVE_GETADDRINFO) +endif (UNIX) + +set(SWRAP_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} CACHE INTERNAL "socket_wrapper required system libraries") + +# STRUCTS +check_struct_has_member("struct in_pktinfo" ipi_addr "sys/types.h;sys/socket.h;netinet/in.h" HAVE_STRUCT_IN_PKTINFO) +set(CMAKE_REQUIRED_FLAGS -D_GNU_SOURCE) +check_struct_has_member("struct in6_pktinfo" ipi6_addr "sys/types.h;sys/socket.h;netinet/in.h" HAVE_STRUCT_IN6_PKTINFO) +set(CMAKE_REQUIRED_FLAGS) + +# STRUCT MEMBERS +check_struct_has_member("struct sockaddr" sa_len "sys/types.h;sys/socket.h;netinet/in.h" HAVE_STRUCT_SOCKADDR_SA_LEN) +check_struct_has_member("struct msghdr" msg_control "sys/types.h;sys/socket.h" HAVE_STRUCT_MSGHDR_MSG_CONTROL) + +# PROTOTYPES +check_prototype_definition(gettimeofday + "int gettimeofday(struct timeval *tv, struct timezone *tz)" + "-1" + "sys/time.h" + HAVE_GETTIMEOFDAY_TZ) + +check_prototype_definition(gettimeofday + "int gettimeofday(struct timeval *tv, void *tzp)" + "-1" + "sys/time.h" + HAVE_GETTIMEOFDAY_TZ_VOID) + +check_prototype_definition(accept + "int accept(int s, struct sockaddr *addr, Psocklen_t addrlen)" + "-1" + "sys/types.h;sys/socket.h" + HAVE_ACCEPT_PSOCKLEN_T) + +check_prototype_definition(ioctl + "int ioctl(int s, int r, ...)" + "-1" + "unistd.h;sys/ioctl.h" + HAVE_IOCTL_INT) + +if (HAVE_EVENTFD) + check_prototype_definition(eventfd + "int eventfd(unsigned int count, int flags)" + "-1" + "sys/eventfd.h" + HAVE_EVENTFD_UNSIGNED_INT) +endif (HAVE_EVENTFD) + +# IPV6 +check_c_source_compiles(" + #include <stdlib.h> + #include <sys/socket.h> + #include <netdb.h> + #include <netinet/in.h> + #include <net/if.h> + +int main(void) { + struct sockaddr_storage sa_store; + struct addrinfo *ai = NULL; + struct in6_addr in6addr; + int idx = if_nametoindex(\"iface1\"); + int s = socket(AF_INET6, SOCK_STREAM, 0); + int ret = getaddrinfo(NULL, NULL, NULL, &ai); + if (ret != 0) { + const char *es = gai_strerror(ret); + } + + freeaddrinfo(ai); + { + int val = 1; +#ifdef HAVE_LINUX_IPV6_V6ONLY_26 +#define IPV6_V6ONLY 26 +#endif + ret = setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, + (const void *)&val, sizeof(val)); + } + + return 0; +}" HAVE_IPV6) + +check_c_source_compiles(" +#include <sys/socket.h> + +int main(void) { + struct sockaddr_storage s; + + return 0; +}" HAVE_SOCKADDR_STORAGE) + +check_c_source_compiles(" +void test_destructor_attribute(void) __attribute__ ((destructor)); + +void test_destructor_attribute(void) +{ + return; +} + +int main(void) { + return 0; +}" HAVE_DESTRUCTOR_ATTRIBUTE) + +check_c_source_compiles(" +__thread int tls; + +int main(void) { + return 0; +}" HAVE_GCC_THREAD_LOCAL_STORAGE) + +check_c_source_compiles(" +void log_fn(const char *format, ...) __attribute__ ((format (printf, 1, 2))); + +int main(void) { + return 0; +}" HAVE_FUNCTION_ATTRIBUTE_FORMAT) + +# If this produces a warning treat it as error! +set(CMAKE_REQUIRED_FLAGS "-Werror") +check_c_source_compiles(" +void test_address_sanitizer_attribute(void) __attribute__((no_sanitize_address)); + +void test_address_sanitizer_attribute(void) +{ + return; +} + +int main(void) { + return 0; +}" HAVE_ADDRESS_SANITIZER_ATTRIBUTE) +set(CMAKE_REQUIRED_FLAGS) + +check_library_exists(dl dlopen "" HAVE_LIBDL) +if (HAVE_LIBDL) + find_library(DLFCN_LIBRARY dl) + set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${DLFCN_LIBRARY}) +endif (HAVE_LIBDL) + +if (OSX) + set(HAVE_APPLE 1) +endif (OSX) + +# ENDIAN +if (NOT WIN32) + test_big_endian(WORDS_BIGENDIAN) +endif (NOT WIN32) + +check_type_size(pid_t SIZEOF_PID_T) + +set(SWRAP_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} CACHE INTERNAL "swrap required system libraries") diff --git a/tests/deckard/contrib/libswrap/DefineOptions.cmake b/tests/deckard/contrib/libswrap/DefineOptions.cmake new file mode 100644 index 0000000..6030e79 --- /dev/null +++ b/tests/deckard/contrib/libswrap/DefineOptions.cmake @@ -0,0 +1 @@ +option(UNIT_TESTING "Build with unit tests" OFF) diff --git a/tests/deckard/contrib/libswrap/README b/tests/deckard/contrib/libswrap/README new file mode 100644 index 0000000..fd08cc4 --- /dev/null +++ b/tests/deckard/contrib/libswrap/README @@ -0,0 +1,21 @@ +SOCKET_WRAPPER +============== + +This is a modification of initial socket_wrapper (https://cwrap.org/socket_wrapper.html) library. +Essence : functionally both libraries are equal. But here implemented some minor changes intended +to ensure the possibility of using arbitrary IP addresses instead of private-range IP addresses. + +DESCRIPTION +----------- + +More details can be found in the manpage: + + man -l ./doc/socket_wrapper.1 + +or the raw text version: + + less ./doc/socket_wrapper.1.txt + +For installation instructions please take a look at the README.install file. + + diff --git a/tests/deckard/contrib/libswrap/README.install b/tests/deckard/contrib/libswrap/README.install new file mode 100644 index 0000000..6fe012f --- /dev/null +++ b/tests/deckard/contrib/libswrap/README.install @@ -0,0 +1,78 @@ +Obtaining the sources +===================== + +Source tarballs for socket_wrapper can be downloaded from + + https://ftp.samba.org/pub/cwrap/ + +The source code repository for socket wrapper is located under + + git://git.samba.org/socket_wrapper.git + +To create a local copy, run + + $ git clone git://git.samba.org/socket_wrapper.git + $ cd socket_wrapper + +Building from sources +===================== + +socket_wrapper uses cmake (www.cmake.org) as its build system. + +In an unpacked sources base directory, create a directory to +contain the build results, e.g. + + $ mkdir obj + $ cd obj + +Note that "obj" is just an example. The directory can +be named arbitrarily. + +Next, run cmake to configure the build, e.g. + + $ cmake -DCMAKE_INSTALL_PREFIX=<prefix> .. + +or on a 64 bit red hat system: + + $ cmake -DCMAKE_INSTALL_PREFIX=<prefix> -DLIB_SUFFIX=64 .. + +The "<prefix>" should be replaced by the intended installation +target prefix directory, typically /usr or /usr/local. + +Note that the target directory does not have to be a direct +or indirect subdirectory of the source base directory: It can +be an arbitrary directory in the system. In the general case, +".." has to be replaced by a relative or absolute path of the +source base directory in the "cmake" command line. + +One can control the build type with "-DCMAKE_BUILD_TYPE=<mode>" +where <mode> can be one of Debug, Release, RelWithDebInfo, and +some more (see cmake.org). The default is "RelWithDebInfo". + +After configuring with cmake, run the build with + + $ make + +Unit testing +============ + +In order to support running the test suite after building, +the cmocka unit test framework needs to be installed (cmocka.org), +and you need to specify + + -DUNIT_TESTING=ON + +in the cmake run. After running "make", + + $ make test + +runs the test suite. + +Installing +========== + +socket_wrapper is installed into the prefix directory +after running "cmake" and "make" with + + $ make install + diff --git a/tests/deckard/contrib/libswrap/TODO b/tests/deckard/contrib/libswrap/TODO new file mode 100644 index 0000000..147c166 --- /dev/null +++ b/tests/deckard/contrib/libswrap/TODO @@ -0,0 +1,33 @@ +TODO +===== + +This is the TODO list of this project. It should give you some hints of things +which need to be implemented. If you can spend some time on this project, then +look at the list below. + + +Library: +--------- + +Goals: +* Thread safety +* The proposed way ==> - fd-passing for tcp sockets (for free) + Approach: + - tdb "in small". So a "db file". + - for each socket an entry in the db file + (file, mmap, robust mutex. e.g. one file per local ip addr) + - socket_info : structure in db. protected by pthread robust mutexes + - socket_info_fd : --> pointer into mmap area of db + - free-list + - fd-passing: pass index in array + - the last element we pass is not a fd but the index number in the + mmaped file +* Use realpath() in socket_wrapper_dir(). + +Testing: +--------- +* Add a test to make sure detect stale file descriptors. +* Add a test for sento() to broadcast 255.255.255.255. +* Add a test to check that read/readv/send/ only work on connected sockets. +* Add unit tests for conversion functions like convert_in_un_remote(). +* Add threaded tests. diff --git a/tests/deckard/contrib/libswrap/cmake/Modules/AddCMockaTest.cmake b/tests/deckard/contrib/libswrap/cmake/Modules/AddCMockaTest.cmake new file mode 100644 index 0000000..b2d1ca8 --- /dev/null +++ b/tests/deckard/contrib/libswrap/cmake/Modules/AddCMockaTest.cmake @@ -0,0 +1,23 @@ +# - ADD_CHECK_TEST(test_name test_source linklib1 ... linklibN) + +# Copyright (c) 2007 Daniel Gollub <dgollub@suse.de> +# Copyright (c) 2007-2010 Andreas Schneider <asn@cynapses.org> +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. + +enable_testing() +include(CTest) + +if(CMAKE_COMPILER_IS_GNUCC AND NOT MINGW) + set(CMAKE_C_FLAGS_PROFILING "-g -O0 -Wall -W -Wshadow -Wunused-variable -Wunused-parameter -Wunused-function -Wunused -Wno-system-headers -Wwrite-strings -fprofile-arcs -ftest-coverage" CACHE STRING "Profiling Compiler Flags") + set(CMAKE_SHARED_LINKER_FLAGS_PROFILING " -fprofile-arcs -ftest-coverage" CACHE STRING "Profiling Linker Flags") + set(CMAKE_MODULE_LINKER_FLAGS_PROFILING " -fprofile-arcs -ftest-coverage" CACHE STRING "Profiling Linker Flags") + set(CMAKE_EXEC_LINKER_FLAGS_PROFILING " -fprofile-arcs -ftest-coverage" CACHE STRING "Profiling Linker Flags") +endif(CMAKE_COMPILER_IS_GNUCC AND NOT MINGW) + +function (ADD_CMOCKA_TEST _testName _testSource) + add_executable(${_testName} ${_testSource}) + target_link_libraries(${_testName} ${ARGN}) + add_test(${_testName} ${CMAKE_CURRENT_BINARY_DIR}/${_testName}) +endfunction (ADD_CMOCKA_TEST) diff --git a/tests/deckard/contrib/libswrap/cmake/Modules/COPYING-CMAKE-SCRIPTS b/tests/deckard/contrib/libswrap/cmake/Modules/COPYING-CMAKE-SCRIPTS new file mode 100644 index 0000000..4b41776 --- /dev/null +++ b/tests/deckard/contrib/libswrap/cmake/Modules/COPYING-CMAKE-SCRIPTS @@ -0,0 +1,22 @@ +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. The name of the author may not be used to endorse or promote products + derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/tests/deckard/contrib/libswrap/cmake/Modules/CheckCCompilerFlagSSP.cmake b/tests/deckard/contrib/libswrap/cmake/Modules/CheckCCompilerFlagSSP.cmake new file mode 100644 index 0000000..2fe4395 --- /dev/null +++ b/tests/deckard/contrib/libswrap/cmake/Modules/CheckCCompilerFlagSSP.cmake @@ -0,0 +1,26 @@ +# - Check whether the C compiler supports a given flag in the +# context of a stack checking compiler option. + +# CHECK_C_COMPILER_FLAG_SSP(FLAG VARIABLE) +# +# FLAG - the compiler flag +# VARIABLE - variable to store the result +# +# This actually calls check_c_source_compiles. +# See help for CheckCSourceCompiles for a listing of variables +# that can modify the build. + +# Copyright (c) 2006, Alexander Neundorf, <neundorf@kde.org> +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. + + +include(CheckCSourceCompiles) + +function(CHECK_C_COMPILER_FLAG_SSP _FLAG _RESULT) + set(SAFE_CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS}") + set(CMAKE_REQUIRED_DEFINITIONS "${_FLAG}") + check_c_source_compiles("int main(int argc, char **argv) { char buffer[256]; return buffer[argc]=0;}" ${_RESULT}) + set(CMAKE_REQUIRED_DEFINITIONS "${SAFE_CMAKE_REQUIRED_DEFINITIONS}") +endfunction(CHECK_C_COMPILER_FLAG_SSP) diff --git a/tests/deckard/contrib/libswrap/cmake/Modules/DefineCMakeDefaults.cmake b/tests/deckard/contrib/libswrap/cmake/Modules/DefineCMakeDefaults.cmake new file mode 100644 index 0000000..a6cd47e --- /dev/null +++ b/tests/deckard/contrib/libswrap/cmake/Modules/DefineCMakeDefaults.cmake @@ -0,0 +1,30 @@ +# Always include srcdir and builddir in include path +# This saves typing ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY} in +# about every subdir +# since cmake 2.4.0 +set(CMAKE_INCLUDE_CURRENT_DIR ON) + +# Put the include dirs which are in the source or build tree +# before all other include dirs, so the headers in the sources +# are preferred over the already installed ones +# since cmake 2.4.1 +set(CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE ON) + +# Use colored output +# since cmake 2.4.0 +set(CMAKE_COLOR_MAKEFILE ON) + +# Define the generic version of the libraries here +set(GENERIC_LIB_VERSION "0.1.0") +set(GENERIC_LIB_SOVERSION "0") + +# Set the default build type to release with debug info +if (NOT CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE RelWithDebInfo + CACHE STRING + "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel." + ) +endif (NOT CMAKE_BUILD_TYPE) + +# Create the compile command database for clang by default +set(CMAKE_EXPORT_COMPILE_COMMANDS ON) diff --git a/tests/deckard/contrib/libswrap/cmake/Modules/DefineCompilerFlags.cmake b/tests/deckard/contrib/libswrap/cmake/Modules/DefineCompilerFlags.cmake new file mode 100644 index 0000000..53481c3 --- /dev/null +++ b/tests/deckard/contrib/libswrap/cmake/Modules/DefineCompilerFlags.cmake @@ -0,0 +1,93 @@ +# define system dependent compiler flags + +include(CheckCCompilerFlag) +include(CheckCCompilerFlagSSP) + +if (UNIX AND NOT WIN32) + # + # Define GNUCC compiler flags + # + if (${CMAKE_C_COMPILER_ID} MATCHES "(GNU|Clang)") + + # add -Wconversion ? + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu99") + + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wshadow -Wmissing-prototypes -Wdeclaration-after-statement") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wunused -Wfloat-equal -Wpointer-arith -Wwrite-strings -Wformat-security") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wmissing-format-attribute -Wcast-align -Wcast-qual") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-missing-field-initializers") + + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror=pointer-arith -Werror=declaration-after-statement") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror=implicit-function-declaration -Werror=write-strings") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror=int-to-pointer-cast -Werror=pointer-to-int-cast") + # -Werror=strict-aliasing is broken + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fstrict-aliasing -Wstrict-aliasing=2") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fstrict-overflow -Wstrict-overflow=5 -Werror=strict-overflow") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_GNU_SOURCE") + + if (OSX) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D__APPLE_USE_RFC_3542") + endif (OSX) + + # with -fPIC + check_c_compiler_flag("-fPIC" WITH_FPIC) + if (WITH_FPIC) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC") + endif (WITH_FPIC) + + check_c_compiler_flag_ssp("-fstack-protector" WITH_STACK_PROTECTOR) + if (WITH_STACK_PROTECTOR) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fstack-protector") + endif (WITH_STACK_PROTECTOR) + + if (CMAKE_BUILD_TYPE) + string(TOLOWER "${CMAKE_BUILD_TYPE}" CMAKE_BUILD_TYPE_LOWER) + if (CMAKE_BUILD_TYPE_LOWER MATCHES (release|relwithdebinfo|minsizerel)) + check_c_compiler_flag("-Wp,-D_FORTIFY_SOURCE=2" WITH_FORTIFY_SOURCE) + if (WITH_FORTIFY_SOURCE) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wp,-D_FORTIFY_SOURCE=2") + endif (WITH_FORTIFY_SOURCE) + + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror=uninitialized") + endif() + endif() + endif (${CMAKE_C_COMPILER_ID} MATCHES "(GNU|Clang)") + + # + # Check for large filesystem support + # + if (CMAKE_SIZEOF_VOID_P MATCHES "8") + # with large file support + execute_process( + COMMAND + getconf LFS64_CFLAGS + OUTPUT_VARIABLE + _lfs_CFLAGS + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + else (CMAKE_SIZEOF_VOID_P MATCHES "8") + # with large file support + execute_process( + COMMAND + getconf LFS_CFLAGS + OUTPUT_VARIABLE + _lfs_CFLAGS + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + endif (CMAKE_SIZEOF_VOID_P MATCHES "8") + if (_lfs_CFLAGS) + string(REGEX REPLACE "[\r\n]" " " "${_lfs_CFLAGS}" "${${_lfs_CFLAGS}}") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${_lfs_CFLAGS}") + endif (_lfs_CFLAGS) + +endif (UNIX AND NOT WIN32) + +if (MSVC) + # Use secure functions by defaualt and suppress warnings about + #"deprecated" functions + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /D _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES=1") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /D _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT=1") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /D _CRT_NONSTDC_NO_WARNINGS=1 /D _CRT_SECURE_NO_WARNINGS=1") +endif (MSVC) diff --git a/tests/deckard/contrib/libswrap/cmake/Modules/DefineInstallationPaths.cmake b/tests/deckard/contrib/libswrap/cmake/Modules/DefineInstallationPaths.cmake new file mode 100644 index 0000000..a415f3d --- /dev/null +++ b/tests/deckard/contrib/libswrap/cmake/Modules/DefineInstallationPaths.cmake @@ -0,0 +1,109 @@ +if (UNIX OR OS2) + IF (NOT APPLICATION_NAME) + MESSAGE(STATUS "${PROJECT_NAME} is used as APPLICATION_NAME") + SET(APPLICATION_NAME ${PROJECT_NAME}) + ENDIF (NOT APPLICATION_NAME) + + # Suffix for Linux + SET(LIB_SUFFIX + CACHE STRING "Define suffix of directory name (32/64)" + ) + + SET(EXEC_INSTALL_PREFIX + "${CMAKE_INSTALL_PREFIX}" + CACHE PATH "Base directory for executables and libraries" + ) + SET(SHARE_INSTALL_PREFIX + "${CMAKE_INSTALL_PREFIX}/share" + CACHE PATH "Base directory for files which go to share/" + ) + SET(DATA_INSTALL_PREFIX + "${SHARE_INSTALL_PREFIX}/${APPLICATION_NAME}" + CACHE PATH "The parent directory where applications can install their data") + + # The following are directories where stuff will be installed to + SET(BIN_INSTALL_DIR + "${EXEC_INSTALL_PREFIX}/bin" + CACHE PATH "The ${APPLICATION_NAME} binary install dir (default prefix/bin)" + ) + SET(SBIN_INSTALL_DIR + "${EXEC_INSTALL_PREFIX}/sbin" + CACHE PATH "The ${APPLICATION_NAME} sbin install dir (default prefix/sbin)" + ) + SET(LIB_INSTALL_DIR + "${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX}" + CACHE PATH "The subdirectory relative to the install prefix where libraries will be installed (default is prefix/lib)" + ) + SET(LIBEXEC_INSTALL_DIR + "${EXEC_INSTALL_PREFIX}/libexec" + CACHE PATH "The subdirectory relative to the install prefix where libraries will be installed (default is prefix/libexec)" + ) + SET(PLUGIN_INSTALL_DIR + "${LIB_INSTALL_DIR}/${APPLICATION_NAME}" + CACHE PATH "The subdirectory relative to the install prefix where plugins will be installed (default is prefix/lib/${APPLICATION_NAME})" + ) + SET(INCLUDE_INSTALL_DIR + "${CMAKE_INSTALL_PREFIX}/include" + CACHE PATH "The subdirectory to the header prefix (default prefix/include)" + ) + + set(CMAKE_INSTALL_DIR + "${LIB_INSTALL_DIR}/cmake" + CACHE PATH "The subdirectory to install cmake config files") + + SET(DATA_INSTALL_DIR + "${DATA_INSTALL_PREFIX}" + CACHE PATH "The parent directory where applications can install their data (default prefix/share/${APPLICATION_NAME})" + ) + SET(HTML_INSTALL_DIR + "${DATA_INSTALL_PREFIX}/doc/HTML" + CACHE PATH "The HTML install dir for documentation (default data/doc/html)" + ) + SET(ICON_INSTALL_DIR + "${DATA_INSTALL_PREFIX}/icons" + CACHE PATH "The icon install dir (default data/icons/)" + ) + SET(SOUND_INSTALL_DIR + "${DATA_INSTALL_PREFIX}/sounds" + CACHE PATH "The install dir for sound files (default data/sounds)" + ) + + SET(LOCALE_INSTALL_DIR + "${SHARE_INSTALL_PREFIX}/locale" + CACHE PATH "The install dir for translations (default prefix/share/locale)" + ) + + SET(XDG_APPS_DIR + "${SHARE_INSTALL_PREFIX}/applications/" + CACHE PATH "The XDG apps dir" + ) + SET(XDG_DIRECTORY_DIR + "${SHARE_INSTALL_PREFIX}/desktop-directories" + CACHE PATH "The XDG directory" + ) + + SET(SYSCONF_INSTALL_DIR + "${EXEC_INSTALL_PREFIX}/etc" + CACHE PATH "The ${APPLICATION_NAME} sysconfig install dir (default prefix/etc)" + ) + SET(MAN_INSTALL_DIR + "${SHARE_INSTALL_PREFIX}/man" + CACHE PATH "The ${APPLICATION_NAME} man install dir (default prefix/man)" + ) + SET(INFO_INSTALL_DIR + "${SHARE_INSTALL_PREFIX}/info" + CACHE PATH "The ${APPLICATION_NAME} info install dir (default prefix/info)" + ) +else() + # Same same + set(BIN_INSTALL_DIR "bin" CACHE PATH "-") + set(SBIN_INSTALL_DIR "sbin" CACHE PATH "-") + set(LIB_INSTALL_DIR "lib${LIB_SUFFIX}" CACHE PATH "-") + set(INCLUDE_INSTALL_DIR "include" CACHE PATH "-") + set(CMAKE_INSTALL_DIR "CMake" CACHE PATH "-") + set(PLUGIN_INSTALL_DIR "plugins" CACHE PATH "-") + set(HTML_INSTALL_DIR "doc/HTML" CACHE PATH "-") + set(ICON_INSTALL_DIR "icons" CACHE PATH "-") + set(SOUND_INSTALL_DIR "sounds" CACHE PATH "-") + set(LOCALE_INSTALL_DIR "lang" CACHE PATH "-") +endif () diff --git a/tests/deckard/contrib/libswrap/cmake/Modules/DefinePlatformDefaults.cmake b/tests/deckard/contrib/libswrap/cmake/Modules/DefinePlatformDefaults.cmake new file mode 100644 index 0000000..f36d9e6 --- /dev/null +++ b/tests/deckard/contrib/libswrap/cmake/Modules/DefinePlatformDefaults.cmake @@ -0,0 +1,32 @@ +# Set system vars + +if (CMAKE_SYSTEM_NAME MATCHES "Linux") + set(LINUX TRUE) +endif(CMAKE_SYSTEM_NAME MATCHES "Linux") + +if (CMAKE_SYSTEM_NAME MATCHES "FreeBSD") + set(FREEBSD TRUE) + set(BSD TRUE) +endif (CMAKE_SYSTEM_NAME MATCHES "FreeBSD") + +if (CMAKE_SYSTEM_NAME MATCHES "OpenBSD") + set(OPENBSD TRUE) + set(BSD TRUE) +endif (CMAKE_SYSTEM_NAME MATCHES "OpenBSD") + +if (CMAKE_SYSTEM_NAME MATCHES "NetBSD") + set(NETBSD TRUE) + set(BSD TRUE) +endif (CMAKE_SYSTEM_NAME MATCHES "NetBSD") + +if (CMAKE_SYSTEM_NAME MATCHES "(Solaris|SunOS)") + set(SOLARIS TRUE) +endif (CMAKE_SYSTEM_NAME MATCHES "(Solaris|SunOS)") + +if (CMAKE_SYSTEM_NAME MATCHES "OS2") + set(OS2 TRUE) +endif (CMAKE_SYSTEM_NAME MATCHES "OS2") + +if (CMAKE_SYSTEM_NAME MATCHES "Darwin") + set(OSX TRUE) +endif (CMAKE_SYSTEM_NAME MATCHES "Darwin") diff --git a/tests/deckard/contrib/libswrap/cmake/Modules/MacroEnsureOutOfSourceBuild.cmake b/tests/deckard/contrib/libswrap/cmake/Modules/MacroEnsureOutOfSourceBuild.cmake new file mode 100644 index 0000000..a2e9480 --- /dev/null +++ b/tests/deckard/contrib/libswrap/cmake/Modules/MacroEnsureOutOfSourceBuild.cmake @@ -0,0 +1,17 @@ +# - MACRO_ENSURE_OUT_OF_SOURCE_BUILD(<errorMessage>) +# MACRO_ENSURE_OUT_OF_SOURCE_BUILD(<errorMessage>) + +# Copyright (c) 2006, Alexander Neundorf, <neundorf@kde.org> +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. + +macro (MACRO_ENSURE_OUT_OF_SOURCE_BUILD _errorMessage) + + string(COMPARE EQUAL "${CMAKE_SOURCE_DIR}" "${CMAKE_BINARY_DIR}" _insource) + if (_insource) + message(SEND_ERROR "${_errorMessage}") + message(FATAL_ERROR "Remove the file CMakeCache.txt in ${CMAKE_SOURCE_DIR} first.") + endif (_insource) + +endmacro (MACRO_ENSURE_OUT_OF_SOURCE_BUILD) diff --git a/tests/deckard/contrib/libswrap/config.h.cmake b/tests/deckard/contrib/libswrap/config.h.cmake new file mode 100644 index 0000000..a9b8ce8 --- /dev/null +++ b/tests/deckard/contrib/libswrap/config.h.cmake @@ -0,0 +1,74 @@ +/* Name of package */ +#cmakedefine PACKAGE "${APPLICATION_NAME}" + +/* Version number of package */ +#cmakedefine VERSION "${APPLICATION_VERSION}" + +#cmakedefine LOCALEDIR "${LOCALE_INSTALL_DIR}" +#cmakedefine DATADIR "${DATADIR}" +#cmakedefine LIBDIR "${LIBDIR}" +#cmakedefine PLUGINDIR "${PLUGINDIR}" +#cmakedefine SYSCONFDIR "${SYSCONFDIR}" +#cmakedefine BINARYDIR "${BINARYDIR}" +#cmakedefine SOURCEDIR "${SOURCEDIR}" + +/************************** HEADER FILES *************************/ + +#cmakedefine HAVE_SYS_FILIO_H 1 +#cmakedefine HAVE_SYS_SIGNALFD_H 1 +#cmakedefine HAVE_SYS_EVENTFD_H 1 +#cmakedefine HAVE_SYS_TIMERFD_H 1 +#cmakedefine HAVE_GNU_LIB_NAMES_H 1 +#cmakedefine HAVE_RPC_RPC_H 1 + +/**************************** STRUCTS ****************************/ + +#cmakedefine HAVE_STRUCT_IN_PKTINFO 1 +#cmakedefine HAVE_STRUCT_IN6_PKTINFO 1 + +/************************ STRUCT MEMBERS *************************/ + +#cmakedefine HAVE_STRUCT_SOCKADDR_SA_LEN 1 +#cmakedefine HAVE_STRUCT_MSGHDR_MSG_CONTROL 1 + +/*************************** FUNCTIONS ***************************/ + +/* Define to 1 if you have the `getaddrinfo' function. */ +#cmakedefine HAVE_GETADDRINFO 1 +#cmakedefine HAVE_SIGNALFD 1 +#cmakedefine HAVE_EVENTFD 1 +#cmakedefine HAVE_TIMERFD_CREATE 1 +#cmakedefine HAVE_BINDRESVPORT 1 +#cmakedefine HAVE_ACCEPT4 1 +#cmakedefine HAVE_PLEDGE 1 + +#cmakedefine HAVE_ACCEPT_PSOCKLEN_T 1 +#cmakedefine HAVE_IOCTL_INT 1 +#cmakedefine HAVE_EVENTFD_UNSIGNED_INT 1 + +/*************************** LIBRARIES ***************************/ + +#cmakedefine HAVE_GETTIMEOFDAY_TZ 1 +#cmakedefine HAVE_GETTIMEOFDAY_TZ_VOID 1 + +/*************************** DATA TYPES***************************/ + +#cmakedefine SIZEOF_PID_T @SIZEOF_PID_T@ + +/**************************** OPTIONS ****************************/ + +#cmakedefine HAVE_GCC_THREAD_LOCAL_STORAGE 1 +#cmakedefine HAVE_DESTRUCTOR_ATTRIBUTE 1 +#cmakedefine HAVE_ADDRESS_SANITIZER_ATTRIBUTE 1 +#cmakedefine HAVE_SOCKADDR_STORAGE 1 +#cmakedefine HAVE_IPV6 1 +#cmakedefine HAVE_FUNCTION_ATTRIBUTE_FORMAT 1 + +#cmakedefine HAVE_APPLE 1 +#cmakedefine HAVE_LIBSOCKET 1 + +/*************************** ENDIAN *****************************/ + +/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most + significant byte first (like Motorola and SPARC, unlike Intel). */ +#cmakedefine WORDS_BIGENDIAN 1 diff --git a/tests/deckard/contrib/libswrap/doc/CMakeLists.txt b/tests/deckard/contrib/libswrap/doc/CMakeLists.txt new file mode 100644 index 0000000..57552d6 --- /dev/null +++ b/tests/deckard/contrib/libswrap/doc/CMakeLists.txt @@ -0,0 +1,4 @@ +install(FILES + socket_wrapper.1 + DESTINATION + ${MAN_INSTALL_DIR}/man1) diff --git a/tests/deckard/contrib/libswrap/doc/README b/tests/deckard/contrib/libswrap/doc/README new file mode 100644 index 0000000..dbe07f7 --- /dev/null +++ b/tests/deckard/contrib/libswrap/doc/README @@ -0,0 +1,3 @@ +The manpage is written with asciidoc. To generate the manpage use: + +a2x --doctype manpage --format manpage doc/socket_wrapper.1.txt diff --git a/tests/deckard/contrib/libswrap/doc/socket_wrapper.1 b/tests/deckard/contrib/libswrap/doc/socket_wrapper.1 new file mode 100644 index 0000000..c3cf835 --- /dev/null +++ b/tests/deckard/contrib/libswrap/doc/socket_wrapper.1 @@ -0,0 +1,204 @@ +'\" t +.\" Title: socket_wrapper +.\" Author: [FIXME: author] [see http://docbook.sf.net/el/author] +.\" Generator: DocBook XSL Stylesheets v1.78.1 <http://docbook.sf.net/> +.\" Date: 2015-08-11 +.\" Manual: \ \& +.\" Source: \ \& +.\" Language: English +.\" +.TH "SOCKET_WRAPPER" "1" "2015\-08\-11" "\ \&" "\ \&" +.\" ----------------------------------------------------------------- +.\" * Define some portability stuff +.\" ----------------------------------------------------------------- +.\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +.\" http://bugs.debian.org/507673 +.\" http://lists.gnu.org/archive/html/groff/2009-02/msg00013.html +.\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +.ie \n(.g .ds Aq \(aq +.el .ds Aq ' +.\" ----------------------------------------------------------------- +.\" * set default formatting +.\" ----------------------------------------------------------------- +.\" disable hyphenation +.nh +.\" disable justification (adjust text to left margin only) +.ad l +.\" ----------------------------------------------------------------- +.\" * MAIN CONTENT STARTS HERE * +.\" ----------------------------------------------------------------- +.SH "NAME" +socket_wrapper \- A library passing all socket communications through unix sockets\&. +.SH "SYNOPSIS" +.sp +LD_PRELOAD=libsocket_wrapper\&.so SOCKET_WRAPPER_DIR=/tmp/tmp\&.bQRELqDrhM SOCKET_WRAPPER_DEFAULT_IFACE=10 \fB\&./myapplication\fR +.SH "DESCRIPTION" +.sp +socket_wrapper aims to help client/server software development teams willing to gain full functional test coverage\&. It makes possible to run several instances of the full software stack on the same machine and perform locally functional testing of complex network configurations\&. +.sp +.RS 4 +.ie n \{\ +\h'-04'\(bu\h'+03'\c +.\} +.el \{\ +.sp -1 +.IP \(bu 2.3 +.\} +Redirects all network communication to happen over unix sockets\&. +.RE +.sp +.RS 4 +.ie n \{\ +\h'-04'\(bu\h'+03'\c +.\} +.el \{\ +.sp -1 +.IP \(bu 2.3 +.\} +Support for IPv4 and IPv6 socket and addressing emulation\&. +.RE +.sp +.RS 4 +.ie n \{\ +\h'-04'\(bu\h'+03'\c +.\} +.el \{\ +.sp -1 +.IP \(bu 2.3 +.\} +Ablility to capture network traffic in pcap format\&. +.RE +.SH "ENVIRONMENT VARIABLES" +.PP +\fBSOCKET_WRAPPER_DIR\fR +.RS 4 +The user defines a directory where to put all the unix sockets using the envionment variable "SOCKET_WRAPPER_DIR=/path/to/socket_dir"\&. When a server opens a port or a client wants to connect, socket_wrapper will translate IP addresses to a special socket_wrapper name and look for the relevant unix socket in the SOCKET_WRAPPER_DIR\&. +.RE +.PP +\fBSOCKET_WRAPPER_DEFAULT_IFACE\fR +.RS 4 +Additionally, the default interface to be used by an application is defined with "SOCKET_WRAPPER_DEFAULT_IFACE=<ID>" where <ID> is between 2 and 254\&. This is analogous to use the IPv4 addresses "127\&.0\&.0\&.<ID>" or IPv6 addresses "fd00::5357:5f<IDx>" (where <IDx> is a hexadecimal presentation of <ID>)\&. You should always set the default interface\&. If you listen on INADDR_ANY then it will use the default interface to listen on\&. +.RE +.PP +\fBSOCKET_WRAPPER_PCAP_FILE\fR +.RS 4 +When debugging, it is often interesting to investigate the network traffic between the client and server within your application\&. If you define SOCKET_WRAPPER_PCAP_FILE=/path/to/file\&.pcap, socket_wrapper will dump all your network traffic to the specified file\&. After the test has been finished you\(cqre able to open the file for example with Wireshark\&. +.RE +.PP +\fBSOCKET_WRAPPER_MTU\fR +.RS 4 +With this variable you can change the MTU size\&. However we do not recomment to do that as the default size of 1500 byte is best for formatting PCAP files\&. +.RE +.sp +The minimum value you can set is 512 and the maximum 32768\&. +.PP +\fBSOCKET_WRAPPER_DEBUGLEVEL\fR +.RS 4 +If you need to see what is going on in socket_wrapper itself or try to find a bug, you can enable logging support in socket_wrapper if you built it with debug symbols\&. +.sp +.RS 4 +.ie n \{\ +\h'-04'\(bu\h'+03'\c +.\} +.el \{\ +.sp -1 +.IP \(bu 2.3 +.\} +0 = ERROR +.RE +.sp +.RS 4 +.ie n \{\ +\h'-04'\(bu\h'+03'\c +.\} +.el \{\ +.sp -1 +.IP \(bu 2.3 +.\} +1 = WARNING +.RE +.sp +.RS 4 +.ie n \{\ +\h'-04'\(bu\h'+03'\c +.\} +.el \{\ +.sp -1 +.IP \(bu 2.3 +.\} +2 = DEBUG +.RE +.sp +.RS 4 +.ie n \{\ +\h'-04'\(bu\h'+03'\c +.\} +.el \{\ +.sp -1 +.IP \(bu 2.3 +.\} +3 = TRACE +.RE +.RE +.SH "EXAMPLE" +.sp +.if n \{\ +.RS 4 +.\} +.nf +# Open a console and create a directory for the unix sockets\&. +$ mktemp \-d +/tmp/tmp\&.bQRELqDrhM +.fi +.if n \{\ +.RE +.\} +.sp +.if n \{\ +.RS 4 +.\} +.nf +# Then start nc to listen for network traffic using the temporary directory\&. +$ LD_PRELOAD=libsocket_wrapper\&.so \e + SOCKET_WRAPPER_DIR=/tmp/tmp\&.bQRELqDrhM \e + SOCKET_WRAPPER_DEFAULT_IFACE=10 nc \-v \-l 127\&.0\&.0\&.10 7 +.fi +.if n \{\ +.RE +.\} +.sp +.if n \{\ +.RS 4 +.\} +.nf +# (If nc, listens on 0\&.0\&.0\&.0 then listener will be open on 127\&.0\&.0\&.10 because +# it is the default interface) +.fi +.if n \{\ +.RE +.\} +.sp +.if n \{\ +.RS 4 +.\} +.nf +# Now open another console and start \*(Aqnc\*(Aq as a client to connect to the server: +$ LD_PRELOAD=libsocket_wrapper\&.so \e + SOCKET_WRAPPER_DIR=/tmp/tmp\&.bQRELqDrhM \e + SOCKET_WRAPPER_DEFAULT_IFACE=100 nc \-v 127\&.0\&.0\&.10 7 +.fi +.if n \{\ +.RE +.\} +.sp +.if n \{\ +.RS 4 +.\} +.nf +# (The client will use the address 127\&.0\&.0\&.100 when connecting to the server) +# Now you can type \*(AqHello!\*(Aq which will be sent to the server and should appear +# in the console output of the server\&. +.fi +.if n \{\ +.RE +.\} diff --git a/tests/deckard/contrib/libswrap/doc/socket_wrapper.1.txt b/tests/deckard/contrib/libswrap/doc/socket_wrapper.1.txt new file mode 100644 index 0000000..f4e82a8 --- /dev/null +++ b/tests/deckard/contrib/libswrap/doc/socket_wrapper.1.txt @@ -0,0 +1,95 @@ +socket_wrapper(1) +================= +:revdate: 2015-08-11 + +NAME +---- + +socket_wrapper - A library passing all socket communications through unix sockets. + +SYNOPSIS +-------- + +LD_PRELOAD=libsocket_wrapper.so SOCKET_WRAPPER_DIR=/tmp/tmp.bQRELqDrhM SOCKET_WRAPPER_DEFAULT_IFACE=10 *./myapplication* + +DESCRIPTION +----------- + +socket_wrapper aims to help client/server software development teams willing to +gain full functional test coverage. It makes possible to run several instances +of the full software stack on the same machine and perform locally functional +testing of complex network configurations. + +- Redirects all network communication to happen over unix sockets. +- Support for IPv4 and IPv6 socket and addressing emulation. +- Ablility to capture network traffic in pcap format. + +ENVIRONMENT VARIABLES +--------------------- + +*SOCKET_WRAPPER_DIR*:: + +The user defines a directory where to put all the unix sockets using the +envionment variable "SOCKET_WRAPPER_DIR=/path/to/socket_dir". When a server +opens a port or a client wants to connect, socket_wrapper will translate IP +addresses to a special socket_wrapper name and look for the relevant unix +socket in the SOCKET_WRAPPER_DIR. + +*SOCKET_WRAPPER_DEFAULT_IFACE*:: + +Additionally, the default interface to be used by an application is defined +with "SOCKET_WRAPPER_DEFAULT_IFACE=<ID>" where <ID> is between 2 and 254. This +is analogous to use the IPv4 addresses "127.0.0.<ID>" or IPv6 addresses +"fd00::5357:5f<IDx>" (where <IDx> is a hexadecimal presentation of <ID>). You +should always set the default interface. If you listen on INADDR_ANY then it +will use the default interface to listen on. + +*SOCKET_WRAPPER_PCAP_FILE*:: + +When debugging, it is often interesting to investigate the network traffic +between the client and server within your application. If you define +SOCKET_WRAPPER_PCAP_FILE=/path/to/file.pcap, socket_wrapper will dump all your +network traffic to the specified file. After the test has been finished you're +able to open the file for example with Wireshark. + +*SOCKET_WRAPPER_MTU*:: + +With this variable you can change the MTU size. However we do not recomment to +do that as the default size of 1500 byte is best for formatting PCAP files. + +The minimum value you can set is 512 and the maximum 32768. + +*SOCKET_WRAPPER_DEBUGLEVEL*:: + +If you need to see what is going on in socket_wrapper itself or try to find a +bug, you can enable logging support in socket_wrapper if you built it with +debug symbols. + +- 0 = ERROR +- 1 = WARNING +- 2 = DEBUG +- 3 = TRACE + +EXAMPLE +------- + + # Open a console and create a directory for the unix sockets. + $ mktemp -d + /tmp/tmp.bQRELqDrhM + + # Then start nc to listen for network traffic using the temporary directory. + $ LD_PRELOAD=libsocket_wrapper.so \ + SOCKET_WRAPPER_DIR=/tmp/tmp.bQRELqDrhM \ + SOCKET_WRAPPER_DEFAULT_IFACE=10 nc -v -l 127.0.0.10 7 + + # (If nc, listens on 0.0.0.0 then listener will be open on 127.0.0.10 because + # it is the default interface) + + # Now open another console and start 'nc' as a client to connect to the server: + $ LD_PRELOAD=libsocket_wrapper.so \ + SOCKET_WRAPPER_DIR=/tmp/tmp.bQRELqDrhM \ + SOCKET_WRAPPER_DEFAULT_IFACE=100 nc -v 127.0.0.10 7 + + # (The client will use the address 127.0.0.100 when connecting to the server) + # Now you can type 'Hello!' which will be sent to the server and should appear + # in the console output of the server. diff --git a/tests/deckard/contrib/libswrap/example/openssh.sh b/tests/deckard/contrib/libswrap/example/openssh.sh new file mode 100755 index 0000000..bb74f03 --- /dev/null +++ b/tests/deckard/contrib/libswrap/example/openssh.sh @@ -0,0 +1,66 @@ +#!/bin/bash + +SSH_DIRECTORY=$(mktemp -d /tmp/tmp.swrap.XXXXXXXX) +SERVER_ADDRESS="127.0.0.10" +mkdir ${SSH_DIRECTORY}/swrap + +cleanup_and_exit () { + trap EXIT + test -z "$1" && set 0 + + echo + echo "CLEANING UP" + echo + + kill -TERM $(< ${SSH_DIRECTORY}/sshd.pid) + rm -rf ${SSH_DIRECTORY} + + exit $1 +} + +# Setup exit handler +trap cleanup_and_exit SIGINT SIGTERM + +echo Generating ${SSH_DIRECTORY}/ssh_host_key. +ssh-keygen -t rsa1 -b 2048 -f ${SSH_DIRECTORY}/ssh_host_key -N '' 2>/dev/null +echo Generating ${SSH_DIRECTORY}/ssh_host_dsa_key. +ssh-keygen -t dsa -f ${SSH_DIRECTORY}/ssh_host_dsa_key -N '' 2>/dev/null +echo Generating ${SSH_DIRECTORY}/ssh_host_rsa_key. +ssh-keygen -t rsa -b 2048 -f ${SSH_DIRECTORY}/ssh_host_rsa_key -N '' 2>/dev/null +#echo Generating ${SSH_DIRECTORY}/ssh_host_ecdsa_key. +#ssh-keygen -t ecdsa -b 256 -f ${SSH_DIRECTORY}/ssh_host_ecdsa_key -N '' 2>/dev/null + +# Create sshd_config file +cat > ${SSH_DIRECTORY}/sshd_config << EOT +Port 22 +ListenAddress ${SERVER_ADDRESS} +HostKey ${SSH_DIRECTORY}/ssh_host_key +HostKey ${SSH_DIRECTORY}/ssh_host_rsa_key +HostKey ${SSH_DIRECTORY}/ssh_host_dsa_key +#HostKey ${SSH_DIRECTORY}/ssh_host_ecdsa_key +Subsystem sftp /usr/lib/ssh/sftp-server + +LogLevel DEBUG1 + +AcceptEnv LANG LC_CTYPE LC_NUMERIC LC_TIME LC_COLLATE LC_MONETARY LC_MESSAGES +AcceptEnv LC_PAPER LC_NAME LC_ADDRESS LC_TELEPHONE LC_MEASUREMENT +AcceptEnv LC_IDENTIFICATION LC_ALL + +PidFile ${SSH_DIRECTORY}/sshd.pid +EOT + +export SOCKET_WRAPPER_DIR="${SSH_DIRECTORY}/swrap" +export SOCKET_WRAPPER_DEFAULT_IFACE=11 + +echo +echo "Starting SSHD with SOCKET_WRAPPER_DIR=${SSH_DIRECTORY}/swrap ..." +DYLD_INSERT_LIBRARIES=libsocket_wrapper.dylib LD_PRELOAD=libsocket_wrapper.so /usr/sbin/sshd -f ${SSH_DIRECTORY}/sshd_config -e 2> ${SSH_DIRECTORY}/sshd_log || cleanup_and_exit 1 +echo "done" + +echo +echo "Connecting to the ${SERVER_ADDRESS} ssh server using ssh binary." +echo "You can check the sshd log file at ${SSH_DIRECTORY}/sshd_log." +echo "If you logout sshd will be stopped and the environment cleaned up." +DYLD_INSERT_LIBRARIES=libsocket_wrapper.dylib LD_PRELOAD=libsocket_wrapper.so ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no ${SERVER_ADDRESS} + +cleanup_and_exit 0 diff --git a/tests/deckard/contrib/libswrap/socket_wrapper-config-version.cmake.in b/tests/deckard/contrib/libswrap/socket_wrapper-config-version.cmake.in new file mode 100644 index 0000000..98f292c --- /dev/null +++ b/tests/deckard/contrib/libswrap/socket_wrapper-config-version.cmake.in @@ -0,0 +1,11 @@ +set(PACKAGE_VERSION @APPLICATION_VERSION@) + +# Check whether the requested PACKAGE_FIND_VERSION is compatible +if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}") + set(PACKAGE_VERSION_COMPATIBLE FALSE) +else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if ("${PACKAGE_VERSION}" VERSION_EQUAL "${PACKAGE_FIND_VERSION}") + set(PACKAGE_VERSION_EXACT TRUE) + endif() +endif() diff --git a/tests/deckard/contrib/libswrap/socket_wrapper-config.cmake.in b/tests/deckard/contrib/libswrap/socket_wrapper-config.cmake.in new file mode 100644 index 0000000..7bedd79 --- /dev/null +++ b/tests/deckard/contrib/libswrap/socket_wrapper-config.cmake.in @@ -0,0 +1 @@ +set(SOCKET_WRAPPER_LIBRARY @LIB_INSTALL_DIR@/@SOCKET_WRAPPER_LIB@) diff --git a/tests/deckard/contrib/libswrap/socket_wrapper.pc.cmake b/tests/deckard/contrib/libswrap/socket_wrapper.pc.cmake new file mode 100644 index 0000000..6dc71f7 --- /dev/null +++ b/tests/deckard/contrib/libswrap/socket_wrapper.pc.cmake @@ -0,0 +1,4 @@ +Name: @APPLICATION_NAME@ +Description: The socket_wrapper library +Version: @APPLICATION_VERSION@ +Libs: @LIB_INSTALL_DIR@/@SOCKET_WRAPPER_LIB@ diff --git a/tests/deckard/contrib/libswrap/src/CMakeLists.txt b/tests/deckard/contrib/libswrap/src/CMakeLists.txt new file mode 100644 index 0000000..e5f2fbb --- /dev/null +++ b/tests/deckard/contrib/libswrap/src/CMakeLists.txt @@ -0,0 +1,26 @@ +project(libsocket_wrapper C) + +include_directories(${CMAKE_BINARY_DIR}) + +add_library(socket_wrapper SHARED socket_wrapper.c) + +target_link_libraries(socket_wrapper ${SWRAP_REQUIRED_LIBRARIES}) + +install( + TARGETS + socket_wrapper + RUNTIME DESTINATION ${BIN_INSTALL_DIR} + LIBRARY DESTINATION ${LIB_INSTALL_DIR} + ARCHIVE DESTINATION ${LIB_INSTALL_DIR} +) + +set_target_properties( + socket_wrapper + PROPERTIES + VERSION + ${LIBRARY_VERSION} + SOVERSION + ${LIBRARY_SOVERSION} +) + +set(SOCKET_WRAPPER_LOCATION "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}socket_wrapper${CMAKE_SHARED_LIBRARY_SUFFIX}" PARENT_SCOPE) diff --git a/tests/deckard/contrib/libswrap/src/socket_wrapper.c b/tests/deckard/contrib/libswrap/src/socket_wrapper.c new file mode 100644 index 0000000..bc4f4ab --- /dev/null +++ b/tests/deckard/contrib/libswrap/src/socket_wrapper.c @@ -0,0 +1,5475 @@ +/* + * Copyright (c) 2005-2008 Jelmer Vernooij <jelmer@samba.org> + * Copyright (C) 2006-2014 Stefan Metzmacher <metze@samba.org> + * Copyright (C) 2013-2014 Andreas Schneider <asn@samba.org> + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the author nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + */ + +/* + Socket wrapper library. Passes all socket communication over + unix domain sockets if the environment variable SOCKET_WRAPPER_DIR + is set. +*/ + +#include "config.h" + +#include <sys/types.h> +#include <sys/time.h> +#include <sys/stat.h> +#include <sys/socket.h> +#include <sys/ioctl.h> +#ifdef HAVE_SYS_FILIO_H +#include <sys/filio.h> +#endif +#ifdef HAVE_SYS_SIGNALFD_H +#include <sys/signalfd.h> +#endif +#ifdef HAVE_SYS_EVENTFD_H +#include <sys/eventfd.h> +#endif +#ifdef HAVE_SYS_TIMERFD_H +#include <sys/timerfd.h> +#endif +#include <sys/uio.h> +#include <errno.h> +#include <sys/un.h> +#include <netinet/in.h> +#include <netinet/tcp.h> +#include <arpa/inet.h> +#include <fcntl.h> +#include <stdlib.h> +#include <string.h> +#include <stdio.h> +#include <stdint.h> +#include <stdarg.h> +#include <stdbool.h> +#include <unistd.h> +#ifdef HAVE_GNU_LIB_NAMES_H +#include <gnu/lib-names.h> +#endif +#ifdef HAVE_RPC_RPC_H +#include <rpc/rpc.h> +#endif +#include <dirent.h> + +enum swrap_dbglvl_e { + SWRAP_LOG_ERROR = 0, + SWRAP_LOG_WARN, + SWRAP_LOG_DEBUG, + SWRAP_LOG_TRACE +}; + +/* GCC have printf type attribute check. */ +#ifdef HAVE_FUNCTION_ATTRIBUTE_FORMAT +#define PRINTF_ATTRIBUTE(a,b) __attribute__ ((__format__ (__printf__, a, b))) +#else +#define PRINTF_ATTRIBUTE(a,b) +#endif /* HAVE_FUNCTION_ATTRIBUTE_FORMAT */ + +#ifdef HAVE_DESTRUCTOR_ATTRIBUTE +#define DESTRUCTOR_ATTRIBUTE __attribute__ ((destructor)) +#else +#define DESTRUCTOR_ATTRIBUTE +#endif + +#ifdef HAVE_ADDRESS_SANITIZER_ATTRIBUTE +#define DO_NOT_SANITIZE_ADDRESS_ATTRIBUTE __attribute__((no_sanitize_address)) +#else +#define DO_NOT_SANITIZE_ADDRESS_ATTRIBUTE +#endif + +#ifdef HAVE_GCC_THREAD_LOCAL_STORAGE +# define SWRAP_THREAD __thread +#else +# define SWRAP_THREAD +#endif + +#ifndef MIN +#define MIN(a,b) ((a)<(b)?(a):(b)) +#endif + +#ifndef ZERO_STRUCT +#define ZERO_STRUCT(x) memset((char *)&(x), 0, sizeof(x)) +#endif + +#ifndef ZERO_STRUCTP +#define ZERO_STRUCTP(x) do { \ + if ((x) != NULL) \ + memset((char *)(x), 0, sizeof(*(x))); \ + } while(0) +#endif + +#ifndef discard_const +#define discard_const(ptr) ((void *)((uintptr_t)(ptr))) +#endif + +#ifndef discard_const_p +#define discard_const_p(type, ptr) ((type *)discard_const(ptr)) +#endif + +#ifdef IPV6_PKTINFO +# ifndef IPV6_RECVPKTINFO +# define IPV6_RECVPKTINFO IPV6_PKTINFO +# endif /* IPV6_RECVPKTINFO */ +#endif /* IPV6_PKTINFO */ + +/* + * On BSD IP_PKTINFO has a different name because during + * the time when they implemented it, there was no RFC. + * The name for IPv6 is the same as on Linux. + */ +#ifndef IP_PKTINFO +# ifdef IP_RECVDSTADDR +# define IP_PKTINFO IP_RECVDSTADDR +# endif +#endif + + +#define SWRAP_DLIST_ADD(list,item) do { \ + if (!(list)) { \ + (item)->prev = NULL; \ + (item)->next = NULL; \ + (list) = (item); \ + } else { \ + (item)->prev = NULL; \ + (item)->next = (list); \ + (list)->prev = (item); \ + (list) = (item); \ + } \ +} while (0) + +#define SWRAP_DLIST_REMOVE(list,item) do { \ + if ((list) == (item)) { \ + (list) = (item)->next; \ + if (list) { \ + (list)->prev = NULL; \ + } \ + } else { \ + if ((item)->prev) { \ + (item)->prev->next = (item)->next; \ + } \ + if ((item)->next) { \ + (item)->next->prev = (item)->prev; \ + } \ + } \ + (item)->prev = NULL; \ + (item)->next = NULL; \ +} while (0) + +#if defined(HAVE_GETTIMEOFDAY_TZ) || defined(HAVE_GETTIMEOFDAY_TZ_VOID) +#define swrapGetTimeOfDay(tval) gettimeofday(tval,NULL) +#else +#define swrapGetTimeOfDay(tval) gettimeofday(tval) +#endif + +/* we need to use a very terse format here as IRIX 6.4 silently + truncates names to 16 chars, so if we use a longer name then we + can't tell which port a packet came from with recvfrom() + + with this format we have 8 chars left for the directory name +*/ +#define SOCKET_FORMAT "%c%02X%04X" +#define SOCKET_TYPE_CHAR_TCP 'T' +#define SOCKET_TYPE_CHAR_UDP 'U' +#define SOCKET_TYPE_CHAR_TCP_V6 'X' +#define SOCKET_TYPE_CHAR_UDP_V6 'Y' + + +#define SOCKET_FORMAT_LONG "%c%08X%04X" +#define SOCKET_FORMAT_V6_LONG "%c%08X%08X%08X%08X%04X" + +#define SOCKET_TYPE_CHAR_TCP_LONG 'Q' +#define SOCKET_TYPE_CHAR_UDP_LONG 'W' +#define SOCKET_TYPE_CHAR_TCP_V6_LONG 'E' +#define SOCKET_TYPE_CHAR_UDP_V6_LONG 'R' + +/* + * Set the packet MTU to 1500 bytes for stream sockets to make it it easier to + * format PCAP capture files (as the caller will simply continue from here). + */ +#define SOCKET_WRAPPER_MTU_DEFAULT 1500 +#define SOCKET_WRAPPER_MTU_MIN 512 +#define SOCKET_WRAPPER_MTU_MAX 32768 + +#define SOCKET_MAX_SOCKETS 1024 + +/* This limit is to avoid broadcast sendto() needing to stat too many + * files. It may be raised (with a performance cost) to up to 254 + * without changing the format above */ +#define MAX_WRAPPED_INTERFACES 40 + +struct swrap_address { + socklen_t sa_socklen; + union { + struct sockaddr s; + struct sockaddr_in in; +#ifdef HAVE_IPV6 + struct sockaddr_in6 in6; +#endif + struct sockaddr_un un; + struct sockaddr_storage ss; + } sa; +}; + +struct socket_info_fd { + struct socket_info_fd *prev, *next; + int fd; +}; + +struct socket_info +{ + struct socket_info_fd *fds; + + int family; + int type; + int protocol; + int bound; + int bcast; + int is_server; + int connected; + int defer_connect; + int pktinfo; + int tcp_nodelay; + + /* The unix path so we can unlink it on close() */ + struct sockaddr_un un_addr; + + struct swrap_address bindname; + struct swrap_address myname; + struct swrap_address peername; + + struct { + unsigned long pck_snd; + unsigned long pck_rcv; + } io; + + struct socket_info *prev, *next; +}; + +/* + * File descriptors are shared between threads so we should share socket + * information too. + */ +struct socket_info *sockets; + +/* Function prototypes */ + +bool socket_wrapper_enabled(void); +void swrap_destructor(void) DESTRUCTOR_ATTRIBUTE; + +#ifdef NDEBUG +# define SWRAP_LOG(...) +#else + +static void swrap_log(enum swrap_dbglvl_e dbglvl, const char *func, const char *format, ...) PRINTF_ATTRIBUTE(3, 4); +# define SWRAP_LOG(dbglvl, ...) swrap_log((dbglvl), __func__, __VA_ARGS__) + +static void swrap_log(enum swrap_dbglvl_e dbglvl, + const char *func, + const char *format, ...) +{ + char buffer[1024]; + va_list va; + const char *d; + unsigned int lvl = 0; + + d = getenv("SOCKET_WRAPPER_DEBUGLEVEL"); + if (d != NULL) { + lvl = atoi(d); + } + + va_start(va, format); + vsnprintf(buffer, sizeof(buffer), format, va); + va_end(va); + + if (lvl >= dbglvl) { + switch (dbglvl) { + case SWRAP_LOG_ERROR: + fprintf(stderr, + "SWRAP_ERROR(%d) - %s: %s\n", + (int)getpid(), func, buffer); + break; + case SWRAP_LOG_WARN: + fprintf(stderr, + "SWRAP_WARN(%d) - %s: %s\n", + (int)getpid(), func, buffer); + break; + case SWRAP_LOG_DEBUG: + fprintf(stderr, + "SWRAP_DEBUG(%d) - %s: %s\n", + (int)getpid(), func, buffer); + break; + case SWRAP_LOG_TRACE: + fprintf(stderr, + "SWRAP_TRACE(%d) - %s: %s\n", + (int)getpid(), func, buffer); + break; + } + } +} +#endif + +/********************************************************* + * SWRAP LOADING LIBC FUNCTIONS + *********************************************************/ + +#include <dlfcn.h> + +struct swrap_libc_fns { +#ifdef HAVE_ACCEPT4 + int (*libc_accept4)(int sockfd, + struct sockaddr *addr, + socklen_t *addrlen, + int flags); +#else + int (*libc_accept)(int sockfd, + struct sockaddr *addr, + socklen_t *addrlen); +#endif + int (*libc_bind)(int sockfd, + const struct sockaddr *addr, + socklen_t addrlen); + int (*libc_close)(int fd); + int (*libc_connect)(int sockfd, + const struct sockaddr *addr, + socklen_t addrlen); + int (*libc_dup)(int fd); + int (*libc_dup2)(int oldfd, int newfd); + int (*libc_fcntl)(int fd, int cmd, ...); + FILE *(*libc_fopen)(const char *name, const char *mode); +#ifdef HAVE_EVENTFD + int (*libc_eventfd)(int count, int flags); +#endif + int (*libc_getpeername)(int sockfd, + struct sockaddr *addr, + socklen_t *addrlen); + int (*libc_getsockname)(int sockfd, + struct sockaddr *addr, + socklen_t *addrlen); + int (*libc_getsockopt)(int sockfd, + int level, + int optname, + void *optval, + socklen_t *optlen); + int (*libc_ioctl)(int d, unsigned long int request, ...); + int (*libc_listen)(int sockfd, int backlog); + int (*libc_open)(const char *pathname, int flags, mode_t mode); + int (*libc_pipe)(int pipefd[2]); + int (*libc_read)(int fd, void *buf, size_t count); + ssize_t (*libc_readv)(int fd, const struct iovec *iov, int iovcnt); + int (*libc_recv)(int sockfd, void *buf, size_t len, int flags); + int (*libc_recvfrom)(int sockfd, + void *buf, + size_t len, + int flags, + struct sockaddr *src_addr, + socklen_t *addrlen); + int (*libc_recvmsg)(int sockfd, const struct msghdr *msg, int flags); + int (*libc_send)(int sockfd, const void *buf, size_t len, int flags); + int (*libc_sendmsg)(int sockfd, const struct msghdr *msg, int flags); + int (*libc_sendto)(int sockfd, + const void *buf, + size_t len, + int flags, + const struct sockaddr *dst_addr, + socklen_t addrlen); + int (*libc_setsockopt)(int sockfd, + int level, + int optname, + const void *optval, + socklen_t optlen); +#ifdef HAVE_SIGNALFD + int (*libc_signalfd)(int fd, const sigset_t *mask, int flags); +#endif + int (*libc_socket)(int domain, int type, int protocol); + int (*libc_socketpair)(int domain, int type, int protocol, int sv[2]); +#ifdef HAVE_TIMERFD_CREATE + int (*libc_timerfd_create)(int clockid, int flags); +#endif + ssize_t (*libc_write)(int fd, const void *buf, size_t count); + ssize_t (*libc_writev)(int fd, const struct iovec *iov, int iovcnt); +}; + +struct swrap { + void *libc_handle; + void *libsocket_handle; + + bool initialised; + bool enabled; + + char *socket_dir; + + struct swrap_libc_fns fns; +}; + +static struct swrap swrap; + +/* prototypes */ +static const char *socket_wrapper_dir(void); + +#define LIBC_NAME "libc.so" + +enum swrap_lib { + SWRAP_LIBC, + SWRAP_LIBNSL, + SWRAP_LIBSOCKET, +}; + +#ifndef NDEBUG +static const char *swrap_str_lib(enum swrap_lib lib) +{ + switch (lib) { + case SWRAP_LIBC: + return "libc"; + case SWRAP_LIBNSL: + return "libnsl"; + case SWRAP_LIBSOCKET: + return "libsocket"; + } + + /* Compiler would warn us about unhandled enum value if we get here */ + return "unknown"; +} +#endif + +static void *swrap_load_lib_handle(enum swrap_lib lib) +{ + int flags = RTLD_LAZY; + void *handle = NULL; + int i; + +#ifdef RTLD_DEEPBIND + flags |= RTLD_DEEPBIND; +#endif + + switch (lib) { + case SWRAP_LIBNSL: + /* FALL TROUGH */ + case SWRAP_LIBSOCKET: +#ifdef HAVE_LIBSOCKET + handle = swrap.libsocket_handle; + if (handle == NULL) { + for (i = 10; i >= 0; i--) { + char soname[256] = {0}; + + snprintf(soname, sizeof(soname), "libsocket.so.%d", i); + handle = dlopen(soname, flags); + if (handle != NULL) { + break; + } + } + + swrap.libsocket_handle = handle; + } + break; +#endif + /* FALL TROUGH */ + case SWRAP_LIBC: + handle = swrap.libc_handle; +#ifdef LIBC_SO + if (handle == NULL) { + handle = dlopen(LIBC_SO, flags); + + swrap.libc_handle = handle; + } +#endif + if (handle == NULL) { + for (i = 10; i >= 0; i--) { + char soname[256] = {0}; + + snprintf(soname, sizeof(soname), "libc.so.%d", i); + handle = dlopen(soname, flags); + if (handle != NULL) { + break; + } + } + + swrap.libc_handle = handle; + } + break; + } + + if (handle == NULL) { +#ifdef RTLD_NEXT + handle = swrap.libc_handle = swrap.libsocket_handle = RTLD_NEXT; +#else + SWRAP_LOG(SWRAP_LOG_ERROR, + "Failed to dlopen library: %s\n", + dlerror()); + exit(-1); +#endif + } + + return handle; +} + +static void *_swrap_load_lib_function(enum swrap_lib lib, const char *fn_name) +{ + void *handle; + void *func; + + handle = swrap_load_lib_handle(lib); + + func = dlsym(handle, fn_name); + if (func == NULL) { + SWRAP_LOG(SWRAP_LOG_ERROR, + "Failed to find %s: %s\n", + fn_name, dlerror()); + exit(-1); + } + + SWRAP_LOG(SWRAP_LOG_TRACE, + "Loaded %s from %s", + fn_name, swrap_str_lib(lib)); + return func; +} + +#define swrap_load_lib_function(lib, fn_name) \ + if (swrap.fns.libc_##fn_name == NULL) { \ + void *swrap_cast_ptr = _swrap_load_lib_function(lib, #fn_name); \ + *(void **) (&swrap.fns.libc_##fn_name) = \ + swrap_cast_ptr; \ + } + + +/* + * IMPORTANT + * + * Functions especially from libc need to be loaded individually, you can't load + * all at once or gdb will segfault at startup. The same applies to valgrind and + * has probably something todo with with the linker. + * So we need load each function at the point it is called the first time. + */ +#ifdef HAVE_ACCEPT4 +static int libc_accept4(int sockfd, + struct sockaddr *addr, + socklen_t *addrlen, + int flags) +{ + swrap_load_lib_function(SWRAP_LIBSOCKET, accept4); + + return swrap.fns.libc_accept4(sockfd, addr, addrlen, flags); +} + +#else /* HAVE_ACCEPT4 */ + +static int libc_accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen) +{ + swrap_load_lib_function(SWRAP_LIBSOCKET, accept); + + return swrap.fns.libc_accept(sockfd, addr, addrlen); +} +#endif /* HAVE_ACCEPT4 */ + +static int libc_bind(int sockfd, + const struct sockaddr *addr, + socklen_t addrlen) +{ + swrap_load_lib_function(SWRAP_LIBSOCKET, bind); + + return swrap.fns.libc_bind(sockfd, addr, addrlen); +} + +static int libc_close(int fd) +{ + swrap_load_lib_function(SWRAP_LIBC, close); + + return swrap.fns.libc_close(fd); +} + +static int libc_connect(int sockfd, + const struct sockaddr *addr, + socklen_t addrlen) +{ + swrap_load_lib_function(SWRAP_LIBSOCKET, connect); + + return swrap.fns.libc_connect(sockfd, addr, addrlen); +} + +static int libc_dup(int fd) +{ + swrap_load_lib_function(SWRAP_LIBC, dup); + + return swrap.fns.libc_dup(fd); +} + +static int libc_dup2(int oldfd, int newfd) +{ + swrap_load_lib_function(SWRAP_LIBC, dup2); + + return swrap.fns.libc_dup2(oldfd, newfd); +} + +#ifdef HAVE_EVENTFD +static int libc_eventfd(int count, int flags) +{ + swrap_load_lib_function(SWRAP_LIBC, eventfd); + + return swrap.fns.libc_eventfd(count, flags); +} +#endif + +DO_NOT_SANITIZE_ADDRESS_ATTRIBUTE +static int libc_vfcntl(int fd, int cmd, va_list ap) +{ + long int args[4]; + int rc; + int i; + + swrap_load_lib_function(SWRAP_LIBC, fcntl); + + for (i = 0; i < 4; i++) { + args[i] = va_arg(ap, long int); + } + + rc = swrap.fns.libc_fcntl(fd, + cmd, + args[0], + args[1], + args[2], + args[3]); + + return rc; +} + +static int libc_getpeername(int sockfd, + struct sockaddr *addr, + socklen_t *addrlen) +{ + swrap_load_lib_function(SWRAP_LIBSOCKET, getpeername); + + return swrap.fns.libc_getpeername(sockfd, addr, addrlen); +} + +static int libc_getsockname(int sockfd, + struct sockaddr *addr, + socklen_t *addrlen) +{ + swrap_load_lib_function(SWRAP_LIBSOCKET, getsockname); + + return swrap.fns.libc_getsockname(sockfd, addr, addrlen); +} + +static int libc_getsockopt(int sockfd, + int level, + int optname, + void *optval, + socklen_t *optlen) +{ + swrap_load_lib_function(SWRAP_LIBSOCKET, getsockopt); + + return swrap.fns.libc_getsockopt(sockfd, level, optname, optval, optlen); +} + +DO_NOT_SANITIZE_ADDRESS_ATTRIBUTE +static int libc_vioctl(int d, unsigned long int request, va_list ap) +{ + long int args[4]; + int rc; + int i; + + swrap_load_lib_function(SWRAP_LIBC, ioctl); + + for (i = 0; i < 4; i++) { + args[i] = va_arg(ap, long int); + } + + rc = swrap.fns.libc_ioctl(d, + request, + args[0], + args[1], + args[2], + args[3]); + + return rc; +} + +static int libc_listen(int sockfd, int backlog) +{ + swrap_load_lib_function(SWRAP_LIBSOCKET, listen); + + return swrap.fns.libc_listen(sockfd, backlog); +} + +static FILE *libc_fopen(const char *name, const char *mode) +{ + swrap_load_lib_function(SWRAP_LIBC, fopen); + + return swrap.fns.libc_fopen(name, mode); +} + +static int libc_vopen(const char *pathname, int flags, va_list ap) +{ + long int mode = 0; + int fd; + + swrap_load_lib_function(SWRAP_LIBC, open); + + mode = va_arg(ap, long int); + + fd = swrap.fns.libc_open(pathname, flags, (mode_t)mode); + + return fd; +} + +static int libc_open(const char *pathname, int flags, ...) +{ + va_list ap; + int fd; + + va_start(ap, flags); + fd = libc_vopen(pathname, flags, ap); + va_end(ap); + + return fd; +} + +static int libc_pipe(int pipefd[2]) +{ + swrap_load_lib_function(SWRAP_LIBSOCKET, pipe); + + return swrap.fns.libc_pipe(pipefd); +} + +static int libc_read(int fd, void *buf, size_t count) +{ + swrap_load_lib_function(SWRAP_LIBC, read); + + return swrap.fns.libc_read(fd, buf, count); +} + +static ssize_t libc_readv(int fd, const struct iovec *iov, int iovcnt) +{ + swrap_load_lib_function(SWRAP_LIBSOCKET, readv); + + return swrap.fns.libc_readv(fd, iov, iovcnt); +} + +static int libc_recv(int sockfd, void *buf, size_t len, int flags) +{ + swrap_load_lib_function(SWRAP_LIBSOCKET, recv); + + return swrap.fns.libc_recv(sockfd, buf, len, flags); +} + +static int libc_recvfrom(int sockfd, + void *buf, + size_t len, + int flags, + struct sockaddr *src_addr, + socklen_t *addrlen) +{ + swrap_load_lib_function(SWRAP_LIBSOCKET, recvfrom); + + return swrap.fns.libc_recvfrom(sockfd, buf, len, flags, src_addr, addrlen); +} + +static int libc_recvmsg(int sockfd, struct msghdr *msg, int flags) +{ + swrap_load_lib_function(SWRAP_LIBSOCKET, recvmsg); + + return swrap.fns.libc_recvmsg(sockfd, msg, flags); +} + +static int libc_send(int sockfd, const void *buf, size_t len, int flags) +{ + swrap_load_lib_function(SWRAP_LIBSOCKET, send); + + return swrap.fns.libc_send(sockfd, buf, len, flags); +} + +static int libc_sendmsg(int sockfd, const struct msghdr *msg, int flags) +{ + swrap_load_lib_function(SWRAP_LIBSOCKET, sendmsg); + + return swrap.fns.libc_sendmsg(sockfd, msg, flags); +} + +static int libc_sendto(int sockfd, + const void *buf, + size_t len, + int flags, + const struct sockaddr *dst_addr, + socklen_t addrlen) +{ + swrap_load_lib_function(SWRAP_LIBSOCKET, sendto); + + return swrap.fns.libc_sendto(sockfd, buf, len, flags, dst_addr, addrlen); +} + +static int libc_setsockopt(int sockfd, + int level, + int optname, + const void *optval, + socklen_t optlen) +{ + swrap_load_lib_function(SWRAP_LIBSOCKET, setsockopt); + + return swrap.fns.libc_setsockopt(sockfd, level, optname, optval, optlen); +} + +#ifdef HAVE_SIGNALFD +static int libc_signalfd(int fd, const sigset_t *mask, int flags) +{ + swrap_load_lib_function(SWRAP_LIBSOCKET, signalfd); + + return swrap.fns.libc_signalfd(fd, mask, flags); +} +#endif + +static int libc_socket(int domain, int type, int protocol) +{ + swrap_load_lib_function(SWRAP_LIBSOCKET, socket); + + return swrap.fns.libc_socket(domain, type, protocol); +} + +static int libc_socketpair(int domain, int type, int protocol, int sv[2]) +{ + swrap_load_lib_function(SWRAP_LIBSOCKET, socketpair); + + return swrap.fns.libc_socketpair(domain, type, protocol, sv); +} + +#ifdef HAVE_TIMERFD_CREATE +static int libc_timerfd_create(int clockid, int flags) +{ + swrap_load_lib_function(SWRAP_LIBC, timerfd_create); + + return swrap.fns.libc_timerfd_create(clockid, flags); +} +#endif + +static ssize_t libc_write(int fd, const void *buf, size_t count) +{ + swrap_load_lib_function(SWRAP_LIBC, write); + + return swrap.fns.libc_write(fd, buf, count); +} + +static ssize_t libc_writev(int fd, const struct iovec *iov, int iovcnt) +{ + swrap_load_lib_function(SWRAP_LIBSOCKET, writev); + + return swrap.fns.libc_writev(fd, iov, iovcnt); +} + +/********************************************************* + * SWRAP HELPER FUNCTIONS + *********************************************************/ + +#ifdef HAVE_IPV6 +/* + * FD00::5357:5FXX + */ +static const struct in6_addr *swrap_ipv6(void) +{ + static struct in6_addr v; + static int initialized; + int ret; + + if (initialized) { + return &v; + } + initialized = 1; + + ret = inet_pton(AF_INET6, "FD00::5357:5F00", &v); + if (ret <= 0) { + abort(); + } + + return &v; +} +static struct in6_addr swrap_make_ipv6(unsigned int a0, unsigned int a1, + unsigned int a2, unsigned int a3) +{ + struct in6_addr v; + int i; + for (i = 0 ; i < 4; i++) + { + v.s6_addr[ 0 + i] = a0; + v.s6_addr[ 4 + i] = a1; + v.s6_addr[ 8 + i] = a2; + v.s6_addr[12 + i] = a3; + a0 >>= 8; + a1 >>= 8; + a2 >>= 8; + a3 >>= 8; + } + return v; +} +static void swrap_make_ipv6_ints(const unsigned char s[16], unsigned int *a0, unsigned int *a1, + unsigned int *a2, unsigned int *a3) +{ + int i; + + *a0 = 0; *a1 = 0; *a2 = 0; *a3 = 0; + for (i = 3 ; i > 0; i--) + { + *a0 += s[ 0 + i]; + *a1 += s[ 4 + i]; + *a2 += s[ 8 + i]; + *a3 += s[12 + i]; + *a0 <<= 8; + *a1 <<= 8; + *a2 <<= 8; + *a3 <<= 8; + } + *a0 += s[ 0]; + *a1 += s[ 4]; + *a2 += s[ 8]; + *a3 += s[12]; +} + +#endif + +static void set_port(int family, int prt, struct swrap_address *addr) +{ + switch (family) { + case AF_INET: + addr->sa.in.sin_port = htons(prt); + break; +#ifdef HAVE_IPV6 + case AF_INET6: + addr->sa.in6.sin6_port = htons(prt); + break; +#endif + } +} + +static size_t socket_length(int family) +{ + switch (family) { + case AF_INET: + return sizeof(struct sockaddr_in); +#ifdef HAVE_IPV6 + case AF_INET6: + return sizeof(struct sockaddr_in6); +#endif + } + return 0; +} + +static const char *socket_wrapper_dir(void) +{ + const char *s = getenv("SOCKET_WRAPPER_DIR"); + if (s == NULL) { + return NULL; + } + /* TODO use realpath(3) here, when we add support for threads */ + if (strncmp(s, "./", 2) == 0) { + s += 2; + } + + SWRAP_LOG(SWRAP_LOG_TRACE, "socket_wrapper_dir: %s", s); + return s; +} + +static unsigned int socket_wrapper_mtu(void) +{ + static unsigned int max_mtu = 0; + unsigned int tmp; + const char *s; + char *endp; + + if (max_mtu != 0) { + return max_mtu; + } + + max_mtu = SOCKET_WRAPPER_MTU_DEFAULT; + + s = getenv("SOCKET_WRAPPER_MTU"); + if (s == NULL) { + goto done; + } + + tmp = strtol(s, &endp, 10); + if (s == endp) { + goto done; + } + + if (tmp < SOCKET_WRAPPER_MTU_MIN || tmp > SOCKET_WRAPPER_MTU_MAX) { + goto done; + } + max_mtu = tmp; + +done: + return max_mtu; +} + +bool socket_wrapper_enabled(void) +{ + const char *s = socket_wrapper_dir(); + + return s != NULL ? true : false; +} + +static unsigned int socket_wrapper_default_iface(void) +{ + const char *s = getenv("SOCKET_WRAPPER_DEFAULT_IFACE"); + if (s) { + unsigned int iface; + if (sscanf(s, "%u", &iface) == 1) { + if (iface >= 1 && iface <= MAX_WRAPPED_INTERFACES) { + return iface; + } + } + } + + return 1;/* 127.0.0.1 */ +} + +static unsigned int socket_wrapper_default_addr(void) +{ + const char *s = getenv("SOCKET_WRAPPER_DEFAULT_IFACE"); + if (s) { + unsigned int iface; + if (sscanf(s, "%u", &iface) == 1) { + if (iface >= 1 && iface <= MAX_WRAPPED_INTERFACES) { + return (127<<24) | iface; + } + } + } + return (127<<24) | 0x00000001; /* 127.0.0.1 */ +} + +static int convert_un_in(const struct sockaddr_un *un, struct sockaddr *in, socklen_t *len) +{ + unsigned int prt; + const char *p; + char type; + + p = strrchr(un->sun_path, '/'); + if (p) p++; else p = un->sun_path; + + type = p[0]; + + + switch(type) { + case SOCKET_TYPE_CHAR_TCP_LONG: + case SOCKET_TYPE_CHAR_UDP_LONG: { + unsigned int in4_addr; + struct sockaddr_in *in2 = (struct sockaddr_in *)(void *)in; + + if ((*len) < sizeof(*in2)) { + errno = EINVAL; + return -1; + } + + if (sscanf(p, SOCKET_FORMAT_LONG, &type, &in4_addr, &prt) != 3) { + errno = EINVAL; + return -1; + } + + if (prt > 0xFFFF) { + errno = EINVAL; + return -1; + } + + memset(in2, 0, sizeof(*in2)); + in2->sin_family = AF_INET; + in2->sin_addr.s_addr = htonl(in4_addr); + in2->sin_port = htons(prt); + + *len = sizeof(*in2); + break; + } +#ifdef HAVE_IPV6 + case SOCKET_TYPE_CHAR_TCP_V6_LONG: + case SOCKET_TYPE_CHAR_UDP_V6_LONG: { + unsigned int in6_a0, in6_a1, in6_a2, in6_a3; + struct sockaddr_in6 *in2 = (struct sockaddr_in6 *)(void *)in; + + if (sscanf(p, SOCKET_FORMAT_V6_LONG, &type, + &in6_a0, &in6_a1, &in6_a2, &in6_a3, &prt) != 6) { + errno = EINVAL; + return -1; + } + + if ((*len) < sizeof(*in2)) { + errno = EINVAL; + return -1; + } + + memset(in2, 0, sizeof(*in2)); + in2->sin6_family = AF_INET6; + in2->sin6_addr = swrap_make_ipv6(in6_a0,in6_a1,in6_a2,in6_a3); + in2->sin6_port = htons(prt); + + *len = sizeof(*in2); + break; + } +#endif + default: + errno = EINVAL; + return -1; + } + + return 0; +} + +static int convert_in_un_remote(struct socket_info *si, const struct sockaddr *inaddr, struct sockaddr_un *un, + int *bcast) +{ + char type = '\0'; + unsigned int prt; + unsigned int in4_addr, in6_a0, in6_a1, in6_a2, in6_a3; + int is_bcast = 0; + + if (bcast) *bcast = 0; + + switch (inaddr->sa_family) { + case AF_INET: { + const struct sockaddr_in *in = + (const struct sockaddr_in *)(const void *)inaddr; + unsigned int addr = ntohl(in->sin_addr.s_addr); + char u_type = '\0'; + char b_type = '\0'; + char a_type = '\0'; + + switch (si->type) { + case SOCK_STREAM: + u_type = SOCKET_TYPE_CHAR_TCP_LONG; + break; + case SOCK_DGRAM: + u_type = SOCKET_TYPE_CHAR_UDP_LONG; + a_type = SOCKET_TYPE_CHAR_UDP_LONG; + b_type = SOCKET_TYPE_CHAR_UDP_LONG; + break; + default: + SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown socket type!\n"); + errno = ESOCKTNOSUPPORT; + return -1; + } + + prt = ntohs(in->sin_port); + if (a_type && addr == 0xFFFFFFFF) { + /* 255.255.255.255 only udp */ + is_bcast = 2; + type = a_type; + in4_addr = socket_wrapper_default_addr(); + } else if (b_type && addr == 0x7FFFFFFF) { + /* 127.255.255.255 only udp */ + is_bcast = 1; + type = b_type; + in4_addr = socket_wrapper_default_addr(); + } else { + is_bcast = 0; + type = u_type; + in4_addr = addr; + } + if (bcast) *bcast = is_bcast; + break; + } +#ifdef HAVE_IPV6 + case AF_INET6: { + const struct sockaddr_in6 *in = + (const struct sockaddr_in6 *)(const void *)inaddr; + + switch (si->type) { + case SOCK_STREAM: + type = SOCKET_TYPE_CHAR_TCP_V6_LONG; + break; + case SOCK_DGRAM: + type = SOCKET_TYPE_CHAR_UDP_V6_LONG; + break; + default: + SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown socket type!\n"); + errno = ESOCKTNOSUPPORT; + return -1; + } + + /* XXX no multicast/broadcast */ + + prt = ntohs(in->sin6_port); + + /* TODO - More checks */ + + swrap_make_ipv6_ints(in->sin6_addr.s6_addr,&in6_a0,&in6_a1,&in6_a2,&in6_a3); + break; + } +#endif + default: + SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown address family!\n"); + errno = ENETUNREACH; + return -1; + } + + if (prt == 0) { + SWRAP_LOG(SWRAP_LOG_WARN, "Port not set\n"); + errno = EINVAL; + return -1; + } + + if (is_bcast) { + snprintf(un->sun_path, sizeof(un->sun_path), "%s/EINVAL", + socket_wrapper_dir()); + SWRAP_LOG(SWRAP_LOG_DEBUG, "un path [%s]", un->sun_path); + /* the caller need to do more processing */ + return 0; + } + + switch (inaddr->sa_family) { + case AF_INET: + snprintf(un->sun_path, sizeof(un->sun_path), "%s/"SOCKET_FORMAT_LONG, + socket_wrapper_dir(), type, in4_addr, prt); + break; + case AF_INET6: + snprintf(un->sun_path, sizeof(un->sun_path), "%s/"SOCKET_FORMAT_V6_LONG, + socket_wrapper_dir(), type, in6_a0, in6_a1, in6_a2, in6_a3, prt); + break; + } + SWRAP_LOG(SWRAP_LOG_DEBUG, "un path [%s]", un->sun_path); + + return 0; +} + +static int convert_in_un_alloc(struct socket_info *si, const struct sockaddr *inaddr, struct sockaddr_un *un, + int *bcast) +{ + char type = '\0'; + unsigned int prt; + unsigned int in4_addr, in6_a0, in6_a1, in6_a2, in6_a3; + struct stat st; + int is_bcast = 0; + + if (bcast) *bcast = 0; + + switch (si->family) { + case AF_INET: { + const struct sockaddr_in *in = + (const struct sockaddr_in *)(const void *)inaddr; + unsigned int addr = ntohl(in->sin_addr.s_addr); + char u_type = '\0'; + char d_type = '\0'; + char b_type = '\0'; + char a_type = '\0'; + + prt = ntohs(in->sin_port); + + switch (si->type) { + case SOCK_STREAM: + u_type = SOCKET_TYPE_CHAR_TCP_LONG; + d_type = SOCKET_TYPE_CHAR_TCP_LONG; + break; + case SOCK_DGRAM: + u_type = SOCKET_TYPE_CHAR_UDP_LONG; + d_type = SOCKET_TYPE_CHAR_UDP_LONG; + a_type = SOCKET_TYPE_CHAR_UDP_LONG; + b_type = SOCKET_TYPE_CHAR_UDP_LONG; + break; + default: + SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown socket type!\n"); + errno = ESOCKTNOSUPPORT; + return -1; + } + + if (addr == 0) { + /* 0.0.0.0 */ + is_bcast = 0; + type = d_type; + in4_addr = socket_wrapper_default_addr(); + } else if (a_type && addr == 0xFFFFFFFF) { + /* 255.255.255.255 only udp */ + is_bcast = 2; + type = a_type; + in4_addr = socket_wrapper_default_addr(); + } else if (b_type && addr == 0x7FFFFFFF) { + /* 127.255.255.255 only udp */ + is_bcast = 1; + type = b_type; + in4_addr = socket_wrapper_default_addr(); + } else { + /* 127.0.0.X */ + is_bcast = 0; + type = u_type; + in4_addr = addr; + } + + /* Store the bind address for connect() */ + if (si->bindname.sa_socklen == 0) { + struct sockaddr_in bind_in; + socklen_t blen = sizeof(struct sockaddr_in); + + ZERO_STRUCT(bind_in); + bind_in.sin_family = in->sin_family; + bind_in.sin_port = in->sin_port; + bind_in.sin_addr.s_addr = htonl(in4_addr); + + si->bindname.sa_socklen = blen; + memcpy(&si->bindname.sa.in, &bind_in, blen); + } + + break; + } +#ifdef HAVE_IPV6 + case AF_INET6: { + const struct sockaddr_in6 *in = + (const struct sockaddr_in6 *)(const void *)inaddr; + struct sockaddr_in6 in6_addr = *in; + + switch (si->type) { + case SOCK_STREAM: + type = SOCKET_TYPE_CHAR_TCP_V6_LONG; + break; + case SOCK_DGRAM: + type = SOCKET_TYPE_CHAR_UDP_V6_LONG; + break; + default: + SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown socket type!\n"); + errno = ESOCKTNOSUPPORT; + return -1; + } + + /* XXX no multicast/broadcast */ + + prt = ntohs(in->sin6_port); + + /* TODO - More checks */ + + if (IN6_IS_ADDR_UNSPECIFIED(&in->sin6_addr)) { + in6_addr.sin6_addr = *swrap_ipv6(); + in6_addr.sin6_addr.s6_addr[15] = socket_wrapper_default_iface(); + } + + swrap_make_ipv6_ints(in6_addr.sin6_addr.s6_addr,&in6_a0,&in6_a1,&in6_a2,&in6_a3); + + /* Store the bind address for connect() */ + if (si->bindname.sa_socklen == 0) { + struct sockaddr_in6 bind_in; + socklen_t blen = sizeof(struct sockaddr_in6); + + ZERO_STRUCT(bind_in); + bind_in.sin6_family = in6_addr.sin6_family; + bind_in.sin6_port = in6_addr.sin6_port; + + bind_in.sin6_addr = in6_addr.sin6_addr; + + memcpy(&si->bindname.sa.in6, &bind_in, blen); + si->bindname.sa_socklen = blen; + } + + break; + } +#endif + default: + SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown address family\n"); + errno = EADDRNOTAVAIL; + return -1; + } + + + if (bcast) *bcast = is_bcast; + + + if (prt == 0) { + /* handle auto-allocation of ephemeral ports */ + for (prt = 5001; prt < 10000; prt++) { + if (si->family == AF_INET) + snprintf(un->sun_path, sizeof(un->sun_path), "%s/"SOCKET_FORMAT_LONG, + socket_wrapper_dir(), type, in4_addr, prt); + else + snprintf(un->sun_path, sizeof(un->sun_path), "%s/"SOCKET_FORMAT_V6_LONG, + socket_wrapper_dir(), type, in6_a0,in6_a1, in6_a2, in6_a3, prt); + + if (stat(un->sun_path, &st) == 0) continue; + + set_port(si->family, prt, &si->myname); + set_port(si->family, prt, &si->bindname); + + break; + } + if (prt == 10000) { + errno = ENFILE; + return -1; + } + } + + if (si->family == AF_INET) + snprintf(un->sun_path, sizeof(un->sun_path), "%s/"SOCKET_FORMAT_LONG, + socket_wrapper_dir(), type, in4_addr, prt); + else + snprintf(un->sun_path, sizeof(un->sun_path), "%s/"SOCKET_FORMAT_V6_LONG, + socket_wrapper_dir(), type, in6_a0,in6_a1, in6_a2, in6_a3, prt); + SWRAP_LOG(SWRAP_LOG_DEBUG, "un path [%s]", un->sun_path); + return 0; +} + +static struct socket_info *find_socket_info(int fd) +{ + struct socket_info *i; + + for (i = sockets; i; i = i->next) { + struct socket_info_fd *f; + for (f = i->fds; f; f = f->next) { + if (f->fd == fd) { + return i; + } + } + } + + return NULL; +} + +#if 0 /* FIXME */ +static bool check_addr_port_in_use(const struct sockaddr *sa, socklen_t len) +{ + struct socket_info *s; + + /* first catch invalid input */ + switch (sa->sa_family) { + case AF_INET: + if (len < sizeof(struct sockaddr_in)) { + return false; + } + break; +#if HAVE_IPV6 + case AF_INET6: + if (len < sizeof(struct sockaddr_in6)) { + return false; + } + break; +#endif + default: + return false; + break; + } + + for (s = sockets; s != NULL; s = s->next) { + if (s->myname == NULL) { + continue; + } + if (s->myname->sa_family != sa->sa_family) { + continue; + } + switch (s->myname->sa_family) { + case AF_INET: { + struct sockaddr_in *sin1, *sin2; + + sin1 = (struct sockaddr_in *)s->myname; + sin2 = (struct sockaddr_in *)sa; + + if (sin1->sin_addr.s_addr == htonl(INADDR_ANY)) { + continue; + } + if (sin1->sin_port != sin2->sin_port) { + continue; + } + if (sin1->sin_addr.s_addr != sin2->sin_addr.s_addr) { + continue; + } + + /* found */ + return true; + break; + } +#if HAVE_IPV6 + case AF_INET6: { + struct sockaddr_in6 *sin1, *sin2; + + sin1 = (struct sockaddr_in6 *)s->myname; + sin2 = (struct sockaddr_in6 *)sa; + + if (sin1->sin6_port != sin2->sin6_port) { + continue; + } + if (!IN6_ARE_ADDR_EQUAL(&sin1->sin6_addr, + &sin2->sin6_addr)) + { + continue; + } + + /* found */ + return true; + break; + } +#endif + default: + continue; + break; + + } + } + + return false; +} +#endif + +static void swrap_remove_stale(int fd) +{ + struct socket_info *si = find_socket_info(fd); + struct socket_info_fd *fi; + + if (si != NULL) { + for (fi = si->fds; fi; fi = fi->next) { + if (fi->fd == fd) { + SWRAP_LOG(SWRAP_LOG_TRACE, "remove stale wrapper for %d", fd); + SWRAP_DLIST_REMOVE(si->fds, fi); + free(fi); + break; + } + } + + if (si->fds == NULL) { + SWRAP_DLIST_REMOVE(sockets, si); + if (si->un_addr.sun_path[0] != '\0') { + unlink(si->un_addr.sun_path); + } + free(si); + } + } +} + +static int sockaddr_convert_to_un(struct socket_info *si, + const struct sockaddr *in_addr, + socklen_t in_len, + struct sockaddr_un *out_addr, + int alloc_sock, + int *bcast) +{ + struct sockaddr *out = (struct sockaddr *)(void *)out_addr; + + (void) in_len; /* unused */ + + if (out_addr == NULL) { + return 0; + } + + out->sa_family = AF_UNIX; +#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN + out->sa_len = sizeof(*out_addr); +#endif + + switch (in_addr->sa_family) { + case AF_UNSPEC: { + const struct sockaddr_in *sin; + if (si->family != AF_INET) { + break; + } + if (in_len < sizeof(struct sockaddr_in)) { + break; + } + sin = (const struct sockaddr_in *)(const void *)in_addr; + if(sin->sin_addr.s_addr != htonl(INADDR_ANY)) { + break; + } + + /* + * Note: in the special case of AF_UNSPEC and INADDR_ANY, + * AF_UNSPEC is mapped to AF_INET and must be treated here. + */ + + /* FALL THROUGH */ + } + case AF_INET: +#ifdef HAVE_IPV6 + case AF_INET6: +#endif + switch (si->type) { + case SOCK_STREAM: + case SOCK_DGRAM: + break; + default: + SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown socket type!\n"); + errno = ESOCKTNOSUPPORT; + return -1; + } + if (alloc_sock) { + return convert_in_un_alloc(si, in_addr, out_addr, bcast); + } else { + return convert_in_un_remote(si, in_addr, out_addr, bcast); + } + default: + break; + } + + errno = EAFNOSUPPORT; + SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown address family\n"); + return -1; +} + +static int sockaddr_convert_from_un(const struct socket_info *si, + const struct sockaddr_un *in_addr, + socklen_t un_addrlen, + int family, + struct sockaddr *out_addr, + socklen_t *out_addrlen) +{ + int ret; + + if (out_addr == NULL || out_addrlen == NULL) + return 0; + + if (un_addrlen == 0) { + *out_addrlen = 0; + return 0; + } + + switch (family) { + case AF_INET: +#ifdef HAVE_IPV6 + case AF_INET6: +#endif + switch (si->type) { + case SOCK_STREAM: + case SOCK_DGRAM: + break; + default: + SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown socket type!\n"); + errno = ESOCKTNOSUPPORT; + return -1; + } + ret = convert_un_in(in_addr, out_addr, out_addrlen); +#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN + out_addr->sa_len = *out_addrlen; +#endif + return ret; + default: + break; + } + + SWRAP_LOG(SWRAP_LOG_ERROR, "Unknown address family\n"); + errno = EAFNOSUPPORT; + return -1; +} + +enum swrap_packet_type { + SWRAP_CONNECT_SEND, + SWRAP_CONNECT_UNREACH, + SWRAP_CONNECT_RECV, + SWRAP_CONNECT_ACK, + SWRAP_ACCEPT_SEND, + SWRAP_ACCEPT_RECV, + SWRAP_ACCEPT_ACK, + SWRAP_RECVFROM, + SWRAP_SENDTO, + SWRAP_SENDTO_UNREACH, + SWRAP_PENDING_RST, + SWRAP_RECV, + SWRAP_RECV_RST, + SWRAP_SEND, + SWRAP_SEND_RST, + SWRAP_CLOSE_SEND, + SWRAP_CLOSE_RECV, + SWRAP_CLOSE_ACK, +}; + +struct swrap_file_hdr { + uint32_t magic; + uint16_t version_major; + uint16_t version_minor; + int32_t timezone; + uint32_t sigfigs; + uint32_t frame_max_len; +#define SWRAP_FRAME_LENGTH_MAX 0xFFFF + uint32_t link_type; +}; +#define SWRAP_FILE_HDR_SIZE 24 + +struct swrap_packet_frame { + uint32_t seconds; + uint32_t micro_seconds; + uint32_t recorded_length; + uint32_t full_length; +}; +#define SWRAP_PACKET_FRAME_SIZE 16 + +union swrap_packet_ip { + struct { + uint8_t ver_hdrlen; + uint8_t tos; + uint16_t packet_length; + uint16_t identification; + uint8_t flags; + uint8_t fragment; + uint8_t ttl; + uint8_t protocol; + uint16_t hdr_checksum; + uint32_t src_addr; + uint32_t dest_addr; + } v4; +#define SWRAP_PACKET_IP_V4_SIZE 20 + struct { + uint8_t ver_prio; + uint8_t flow_label_high; + uint16_t flow_label_low; + uint16_t payload_length; + uint8_t next_header; + uint8_t hop_limit; + uint8_t src_addr[16]; + uint8_t dest_addr[16]; + } v6; +#define SWRAP_PACKET_IP_V6_SIZE 40 +}; +#define SWRAP_PACKET_IP_SIZE 40 + +union swrap_packet_payload { + struct { + uint16_t source_port; + uint16_t dest_port; + uint32_t seq_num; + uint32_t ack_num; + uint8_t hdr_length; + uint8_t control; + uint16_t window; + uint16_t checksum; + uint16_t urg; + } tcp; +#define SWRAP_PACKET_PAYLOAD_TCP_SIZE 20 + struct { + uint16_t source_port; + uint16_t dest_port; + uint16_t length; + uint16_t checksum; + } udp; +#define SWRAP_PACKET_PAYLOAD_UDP_SIZE 8 + struct { + uint8_t type; + uint8_t code; + uint16_t checksum; + uint32_t unused; + } icmp4; +#define SWRAP_PACKET_PAYLOAD_ICMP4_SIZE 8 + struct { + uint8_t type; + uint8_t code; + uint16_t checksum; + uint32_t unused; + } icmp6; +#define SWRAP_PACKET_PAYLOAD_ICMP6_SIZE 8 +}; +#define SWRAP_PACKET_PAYLOAD_SIZE 20 + +#define SWRAP_PACKET_MIN_ALLOC \ + (SWRAP_PACKET_FRAME_SIZE + \ + SWRAP_PACKET_IP_SIZE + \ + SWRAP_PACKET_PAYLOAD_SIZE) + +static const char *swrap_pcap_init_file(void) +{ + static const char *s = NULL; + static const struct swrap_file_hdr h; + static const struct swrap_packet_frame f; + static const union swrap_packet_ip i; + static const union swrap_packet_payload p; + + // if (initialized == 1) { + // printf("return: 1\n"); + // return s; + // } + // initialized = 1; + + /* + * TODO: don't use the structs use plain buffer offsets + * and PUSH_U8(), PUSH_U16() and PUSH_U32() + * + * for now make sure we disable PCAP support + * if the struct has alignment! + */ + if (sizeof(h) != SWRAP_FILE_HDR_SIZE) { + return NULL; + } + if (sizeof(f) != SWRAP_PACKET_FRAME_SIZE) { + return NULL; + } + if (sizeof(i) != SWRAP_PACKET_IP_SIZE) { + return NULL; + } + if (sizeof(i.v4) != SWRAP_PACKET_IP_V4_SIZE) { + return NULL; + } + if (sizeof(i.v6) != SWRAP_PACKET_IP_V6_SIZE) { + return NULL; + } + if (sizeof(p) != SWRAP_PACKET_PAYLOAD_SIZE) { + return NULL; + } + if (sizeof(p.tcp) != SWRAP_PACKET_PAYLOAD_TCP_SIZE) { + return NULL; + } + if (sizeof(p.udp) != SWRAP_PACKET_PAYLOAD_UDP_SIZE) { + return NULL; + } + if (sizeof(p.icmp4) != SWRAP_PACKET_PAYLOAD_ICMP4_SIZE) { + return NULL; + } + if (sizeof(p.icmp6) != SWRAP_PACKET_PAYLOAD_ICMP6_SIZE) { + return NULL; + } + + s = getenv("SOCKET_WRAPPER_PCAP_FILE"); + if (s == NULL) { + return NULL; + } + if (strncmp(s, "./", 2) == 0) { + s += 2; + } + return s; +} + +static uint8_t *swrap_pcap_packet_init(struct timeval *tval, + const struct sockaddr *src, + const struct sockaddr *dest, + int socket_type, + const uint8_t *payload, + size_t payload_len, + unsigned long tcp_seqno, + unsigned long tcp_ack, + unsigned char tcp_ctl, + int unreachable, + size_t *_packet_len) +{ + uint8_t *base; + uint8_t *buf; + struct swrap_packet_frame *frame; + union swrap_packet_ip *ip; + union swrap_packet_payload *pay; + size_t packet_len; + size_t alloc_len; + size_t nonwire_len = sizeof(*frame); + size_t wire_hdr_len = 0; + size_t wire_len = 0; + size_t ip_hdr_len = 0; + size_t icmp_hdr_len = 0; + size_t icmp_truncate_len = 0; + uint8_t protocol = 0, icmp_protocol = 0; + const struct sockaddr_in *src_in = NULL; + const struct sockaddr_in *dest_in = NULL; +#ifdef HAVE_IPV6 + const struct sockaddr_in6 *src_in6 = NULL; + const struct sockaddr_in6 *dest_in6 = NULL; +#endif + uint16_t src_port; + uint16_t dest_port; + + switch (src->sa_family) { + case AF_INET: + src_in = (const struct sockaddr_in *)(const void *)src; + dest_in = (const struct sockaddr_in *)(const void *)dest; + src_port = src_in->sin_port; + dest_port = dest_in->sin_port; + ip_hdr_len = sizeof(ip->v4); + break; +#ifdef HAVE_IPV6 + case AF_INET6: + src_in6 = (const struct sockaddr_in6 *)(const void *)src; + dest_in6 = (const struct sockaddr_in6 *)(const void *)dest; + src_port = src_in6->sin6_port; + dest_port = dest_in6->sin6_port; + ip_hdr_len = sizeof(ip->v6); + break; +#endif + default: + return NULL; + } + + switch (socket_type) { + case SOCK_STREAM: + protocol = 0x06; /* TCP */ + wire_hdr_len = ip_hdr_len + sizeof(pay->tcp); + wire_len = wire_hdr_len + payload_len; + break; + + case SOCK_DGRAM: + protocol = 0x11; /* UDP */ + wire_hdr_len = ip_hdr_len + sizeof(pay->udp); + wire_len = wire_hdr_len + payload_len; + break; + + default: + return NULL; + } + + if (unreachable) { + icmp_protocol = protocol; + switch (src->sa_family) { + case AF_INET: + protocol = 0x01; /* ICMPv4 */ + icmp_hdr_len = ip_hdr_len + sizeof(pay->icmp4); + break; +#ifdef HAVE_IPV6 + case AF_INET6: + protocol = 0x3A; /* ICMPv6 */ + icmp_hdr_len = ip_hdr_len + sizeof(pay->icmp6); + break; +#endif + } + if (wire_len > 64 ) { + icmp_truncate_len = wire_len - 64; + } + wire_hdr_len += icmp_hdr_len; + wire_len += icmp_hdr_len; + } + + packet_len = nonwire_len + wire_len; + alloc_len = packet_len; + if (alloc_len < SWRAP_PACKET_MIN_ALLOC) { + alloc_len = SWRAP_PACKET_MIN_ALLOC; + } + + base = (uint8_t *)calloc(1, alloc_len); + if (base == NULL) { + return NULL; + } + + buf = base; + + frame = (struct swrap_packet_frame *)(void *)buf; + frame->seconds = tval->tv_sec; + frame->micro_seconds = tval->tv_usec; + frame->recorded_length = wire_len - icmp_truncate_len; + frame->full_length = wire_len - icmp_truncate_len; + buf += SWRAP_PACKET_FRAME_SIZE; + + ip = (union swrap_packet_ip *)(void *)buf; + switch (src->sa_family) { + case AF_INET: + ip->v4.ver_hdrlen = 0x45; /* version 4 and 5 * 32 bit words */ + ip->v4.tos = 0x00; + ip->v4.packet_length = htons(wire_len - icmp_truncate_len); + ip->v4.identification = htons(0xFFFF); + ip->v4.flags = 0x40; /* BIT 1 set - means don't fragment */ + ip->v4.fragment = htons(0x0000); + ip->v4.ttl = 0xFF; + ip->v4.protocol = protocol; + ip->v4.hdr_checksum = htons(0x0000); + ip->v4.src_addr = src_in->sin_addr.s_addr; + ip->v4.dest_addr = dest_in->sin_addr.s_addr; + buf += SWRAP_PACKET_IP_V4_SIZE; + break; +#ifdef HAVE_IPV6 + case AF_INET6: + ip->v6.ver_prio = 0x60; /* version 4 and 5 * 32 bit words */ + ip->v6.flow_label_high = 0x00; + ip->v6.flow_label_low = 0x0000; + ip->v6.payload_length = htons(wire_len - icmp_truncate_len); /* TODO */ + ip->v6.next_header = protocol; + memcpy(ip->v6.src_addr, src_in6->sin6_addr.s6_addr, 16); + memcpy(ip->v6.dest_addr, dest_in6->sin6_addr.s6_addr, 16); + buf += SWRAP_PACKET_IP_V6_SIZE; + break; +#endif + } + + if (unreachable) { + pay = (union swrap_packet_payload *)(void *)buf; + switch (src->sa_family) { + case AF_INET: + pay->icmp4.type = 0x03; /* destination unreachable */ + pay->icmp4.code = 0x01; /* host unreachable */ + pay->icmp4.checksum = htons(0x0000); + pay->icmp4.unused = htonl(0x00000000); + buf += SWRAP_PACKET_PAYLOAD_ICMP4_SIZE; + + /* set the ip header in the ICMP payload */ + ip = (union swrap_packet_ip *)(void *)buf; + ip->v4.ver_hdrlen = 0x45; /* version 4 and 5 * 32 bit words */ + ip->v4.tos = 0x00; + ip->v4.packet_length = htons(wire_len - icmp_hdr_len); + ip->v4.identification = htons(0xFFFF); + ip->v4.flags = 0x40; /* BIT 1 set - means don't fragment */ + ip->v4.fragment = htons(0x0000); + ip->v4.ttl = 0xFF; + ip->v4.protocol = icmp_protocol; + ip->v4.hdr_checksum = htons(0x0000); + ip->v4.src_addr = dest_in->sin_addr.s_addr; + ip->v4.dest_addr = src_in->sin_addr.s_addr; + buf += SWRAP_PACKET_IP_V4_SIZE; + + src_port = dest_in->sin_port; + dest_port = src_in->sin_port; + break; +#ifdef HAVE_IPV6 + case AF_INET6: + pay->icmp6.type = 0x01; /* destination unreachable */ + pay->icmp6.code = 0x03; /* address unreachable */ + pay->icmp6.checksum = htons(0x0000); + pay->icmp6.unused = htonl(0x00000000); + buf += SWRAP_PACKET_PAYLOAD_ICMP6_SIZE; + + /* set the ip header in the ICMP payload */ + ip = (union swrap_packet_ip *)(void *)buf; + ip->v6.ver_prio = 0x60; /* version 4 and 5 * 32 bit words */ + ip->v6.flow_label_high = 0x00; + ip->v6.flow_label_low = 0x0000; + ip->v6.payload_length = htons(wire_len - icmp_truncate_len); /* TODO */ + ip->v6.next_header = protocol; + memcpy(ip->v6.src_addr, dest_in6->sin6_addr.s6_addr, 16); + memcpy(ip->v6.dest_addr, src_in6->sin6_addr.s6_addr, 16); + buf += SWRAP_PACKET_IP_V6_SIZE; + + src_port = dest_in6->sin6_port; + dest_port = src_in6->sin6_port; + break; +#endif + } + } + + pay = (union swrap_packet_payload *)(void *)buf; + + switch (socket_type) { + case SOCK_STREAM: + pay->tcp.source_port = src_port; + pay->tcp.dest_port = dest_port; + pay->tcp.seq_num = htonl(tcp_seqno); + pay->tcp.ack_num = htonl(tcp_ack); + pay->tcp.hdr_length = 0x50; /* 5 * 32 bit words */ + pay->tcp.control = tcp_ctl; + pay->tcp.window = htons(0x7FFF); + pay->tcp.checksum = htons(0x0000); + pay->tcp.urg = htons(0x0000); + buf += SWRAP_PACKET_PAYLOAD_TCP_SIZE; + + break; + + case SOCK_DGRAM: + pay->udp.source_port = src_port; + pay->udp.dest_port = dest_port; + pay->udp.length = htons(8 + payload_len); + pay->udp.checksum = htons(0x0000); + buf += SWRAP_PACKET_PAYLOAD_UDP_SIZE; + + break; + } + + if (payload && payload_len > 0) { + memcpy(buf, payload, payload_len); + } + + *_packet_len = packet_len - icmp_truncate_len; + return base; +} + +static int swrap_pcap_get_fd(const char *fname) +{ + int fd = -1; + + // if (fd != -1) return fd; + + fd = libc_open(fname, O_WRONLY|O_CREAT|O_EXCL|O_APPEND, 0644); + if (fd != -1) { + struct swrap_file_hdr file_hdr; + file_hdr.magic = 0xA1B2C3D4; + file_hdr.version_major = 0x0002; + file_hdr.version_minor = 0x0004; + file_hdr.timezone = 0x00000000; + file_hdr.sigfigs = 0x00000000; + file_hdr.frame_max_len = SWRAP_FRAME_LENGTH_MAX; + file_hdr.link_type = 0x0065; /* 101 RAW IP */ + + if (write(fd, &file_hdr, sizeof(file_hdr)) != sizeof(file_hdr)) { + close(fd); + fd = -1; + } + return fd; + } + + fd = libc_open(fname, O_WRONLY|O_APPEND, 0644); + + return fd; +} + +static uint8_t *swrap_pcap_marshall_packet(struct socket_info *si, + const struct sockaddr *addr, + enum swrap_packet_type type, + const void *buf, size_t len, + size_t *packet_len) +{ + const struct sockaddr *src_addr; + const struct sockaddr *dest_addr; + unsigned long tcp_seqno = 0; + unsigned long tcp_ack = 0; + unsigned char tcp_ctl = 0; + int unreachable = 0; + + struct timeval tv; + + switch (si->family) { + case AF_INET: + break; +#ifdef HAVE_IPV6 + case AF_INET6: + break; +#endif + default: + return NULL; + } + + switch (type) { + case SWRAP_CONNECT_SEND: + if (si->type != SOCK_STREAM) return NULL; + + src_addr = &si->myname.sa.s; + dest_addr = addr; + + tcp_seqno = si->io.pck_snd; + tcp_ack = si->io.pck_rcv; + tcp_ctl = 0x02; /* SYN */ + + si->io.pck_snd += 1; + + break; + + case SWRAP_CONNECT_RECV: + if (si->type != SOCK_STREAM) return NULL; + + dest_addr = &si->myname.sa.s; + src_addr = addr; + + tcp_seqno = si->io.pck_rcv; + tcp_ack = si->io.pck_snd; + tcp_ctl = 0x12; /** SYN,ACK */ + + si->io.pck_rcv += 1; + + break; + + case SWRAP_CONNECT_UNREACH: + if (si->type != SOCK_STREAM) return NULL; + + dest_addr = &si->myname.sa.s; + src_addr = addr; + + /* Unreachable: resend the data of SWRAP_CONNECT_SEND */ + tcp_seqno = si->io.pck_snd - 1; + tcp_ack = si->io.pck_rcv; + tcp_ctl = 0x02; /* SYN */ + unreachable = 1; + + break; + + case SWRAP_CONNECT_ACK: + if (si->type != SOCK_STREAM) return NULL; + + src_addr = &si->myname.sa.s; + dest_addr = addr; + + tcp_seqno = si->io.pck_snd; + tcp_ack = si->io.pck_rcv; + tcp_ctl = 0x10; /* ACK */ + + break; + + case SWRAP_ACCEPT_SEND: + if (si->type != SOCK_STREAM) return NULL; + + dest_addr = &si->myname.sa.s; + src_addr = addr; + + tcp_seqno = si->io.pck_rcv; + tcp_ack = si->io.pck_snd; + tcp_ctl = 0x02; /* SYN */ + + si->io.pck_rcv += 1; + + break; + + case SWRAP_ACCEPT_RECV: + if (si->type != SOCK_STREAM) return NULL; + + src_addr = &si->myname.sa.s; + dest_addr = addr; + + tcp_seqno = si->io.pck_snd; + tcp_ack = si->io.pck_rcv; + tcp_ctl = 0x12; /* SYN,ACK */ + + si->io.pck_snd += 1; + + break; + + case SWRAP_ACCEPT_ACK: + if (si->type != SOCK_STREAM) return NULL; + + dest_addr = &si->myname.sa.s; + src_addr = addr; + + tcp_seqno = si->io.pck_rcv; + tcp_ack = si->io.pck_snd; + tcp_ctl = 0x10; /* ACK */ + + break; + + case SWRAP_SEND: + src_addr = &si->myname.sa.s; + dest_addr = &si->peername.sa.s; + + tcp_seqno = si->io.pck_snd; + tcp_ack = si->io.pck_rcv; + tcp_ctl = 0x18; /* PSH,ACK */ + + si->io.pck_snd += len; + + break; + + case SWRAP_SEND_RST: + dest_addr = &si->myname.sa.s; + src_addr = &si->peername.sa.s; + + if (si->type == SOCK_DGRAM) { + return swrap_pcap_marshall_packet(si, + &si->peername.sa.s, + SWRAP_SENDTO_UNREACH, + buf, + len, + packet_len); + } + + tcp_seqno = si->io.pck_rcv; + tcp_ack = si->io.pck_snd; + tcp_ctl = 0x14; /** RST,ACK */ + + break; + + case SWRAP_PENDING_RST: + dest_addr = &si->myname.sa.s; + src_addr = &si->peername.sa.s; + + if (si->type == SOCK_DGRAM) { + return NULL; + } + + tcp_seqno = si->io.pck_rcv; + tcp_ack = si->io.pck_snd; + tcp_ctl = 0x14; /* RST,ACK */ + + break; + + case SWRAP_RECV: + dest_addr = &si->myname.sa.s; + src_addr = &si->peername.sa.s; + + tcp_seqno = si->io.pck_rcv; + tcp_ack = si->io.pck_snd; + tcp_ctl = 0x18; /* PSH,ACK */ + + si->io.pck_rcv += len; + + break; + + case SWRAP_RECV_RST: + dest_addr = &si->myname.sa.s; + src_addr = &si->peername.sa.s; + + if (si->type == SOCK_DGRAM) { + return NULL; + } + + tcp_seqno = si->io.pck_rcv; + tcp_ack = si->io.pck_snd; + tcp_ctl = 0x14; /* RST,ACK */ + + break; + + case SWRAP_SENDTO: + src_addr = &si->myname.sa.s; + dest_addr = addr; + + si->io.pck_snd += len; + + break; + + case SWRAP_SENDTO_UNREACH: + dest_addr = &si->myname.sa.s; + src_addr = addr; + + unreachable = 1; + + break; + + case SWRAP_RECVFROM: + dest_addr = &si->myname.sa.s; + src_addr = addr; + + si->io.pck_rcv += len; + + break; + + case SWRAP_CLOSE_SEND: + if (si->type != SOCK_STREAM) return NULL; + + src_addr = &si->myname.sa.s; + dest_addr = &si->peername.sa.s; + + tcp_seqno = si->io.pck_snd; + tcp_ack = si->io.pck_rcv; + tcp_ctl = 0x11; /* FIN, ACK */ + + si->io.pck_snd += 1; + + break; + + case SWRAP_CLOSE_RECV: + if (si->type != SOCK_STREAM) return NULL; + + dest_addr = &si->myname.sa.s; + src_addr = &si->peername.sa.s; + + tcp_seqno = si->io.pck_rcv; + tcp_ack = si->io.pck_snd; + tcp_ctl = 0x11; /* FIN,ACK */ + + si->io.pck_rcv += 1; + + break; + + case SWRAP_CLOSE_ACK: + if (si->type != SOCK_STREAM) return NULL; + + src_addr = &si->myname.sa.s; + dest_addr = &si->peername.sa.s; + + tcp_seqno = si->io.pck_snd; + tcp_ack = si->io.pck_rcv; + tcp_ctl = 0x10; /* ACK */ + + break; + default: + return NULL; + } + + swrapGetTimeOfDay(&tv); + + return swrap_pcap_packet_init(&tv, + src_addr, + dest_addr, + si->type, + (const uint8_t *)buf, + len, + tcp_seqno, + tcp_ack, + tcp_ctl, + unreachable, + packet_len); +} + +static void swrap_pcap_dump_packet(struct socket_info *si, + const struct sockaddr *addr, + enum swrap_packet_type type, + const void *buf, size_t len) +{ + const char *file_name; + uint8_t *packet; + size_t packet_len = 0; + int fd; + + file_name = swrap_pcap_init_file(); + if (!file_name) { + return; + } + + packet = swrap_pcap_marshall_packet(si, + addr, + type, + buf, + len, + &packet_len); + if (packet == NULL) { + return; + } + + fd = swrap_pcap_get_fd(file_name); + if (fd != -1) { + if (write(fd, packet, packet_len) != (ssize_t)packet_len) { + close(fd); + free(packet); + return; + } + } + close(fd); + free(packet); +} + +/**************************************************************************** + * SIGNALFD + ***************************************************************************/ + +#ifdef HAVE_SIGNALFD +static int swrap_signalfd(int fd, const sigset_t *mask, int flags) +{ + int rc; + + rc = libc_signalfd(fd, mask, flags); + if (rc != -1) { + swrap_remove_stale(fd); + } + + return rc; +} + +int signalfd(int fd, const sigset_t *mask, int flags) +{ + return swrap_signalfd(fd, mask, flags); +} +#endif + +/**************************************************************************** + * SOCKET + ***************************************************************************/ + +static int swrap_socket(int family, int type, int protocol) +{ + struct socket_info *si; + struct socket_info_fd *fi; + int fd; + int real_type = type; + + /* + * Remove possible addition flags passed to socket() so + * do not fail checking the type. + * See https://lwn.net/Articles/281965/ + */ +#ifdef SOCK_CLOEXEC + real_type &= ~SOCK_CLOEXEC; +#endif +#ifdef SOCK_NONBLOCK + real_type &= ~SOCK_NONBLOCK; +#endif + + if (!socket_wrapper_enabled()) { + return libc_socket(family, type, protocol); + } + + switch (family) { + case AF_INET: +#ifdef HAVE_IPV6 + case AF_INET6: +#endif + break; +#ifdef AF_NETLINK + case AF_NETLINK: +#endif /* AF_NETLINK */ +#ifdef AF_PACKET + case AF_PACKET: +#endif /* AF_PACKET */ + case AF_UNIX: + return libc_socket(family, type, protocol); + default: + errno = EAFNOSUPPORT; + return -1; + } + + switch (real_type) { + case SOCK_STREAM: + break; + case SOCK_DGRAM: + break; + default: + errno = EPROTONOSUPPORT; + return -1; + } + + switch (protocol) { + case 0: + break; + case 6: + if (real_type == SOCK_STREAM) { + break; + } + /*fall through*/ + case 17: + if (real_type == SOCK_DGRAM) { + break; + } + /*fall through*/ + default: + errno = EPROTONOSUPPORT; + return -1; + } + + /* + * We must call libc_socket with type, from the caller, not the version + * we removed SOCK_CLOEXEC and SOCK_NONBLOCK from + */ + fd = libc_socket(AF_UNIX, type, 0); + + if (fd == -1) { + return -1; + } + + /* Check if we have a stale fd and remove it */ + si = find_socket_info(fd); + if (si != NULL) { + swrap_remove_stale(fd); + } + + si = (struct socket_info *)calloc(1, sizeof(struct socket_info)); + if (si == NULL) { + errno = ENOMEM; + return -1; + } + + si->family = family; + + /* however, the rest of the socket_wrapper code expects just + * the type, not the flags */ + si->type = real_type; + si->protocol = protocol; + + /* + * Setup myname so getsockname() can succeed to find out the socket + * type. + */ + switch(si->family) { + case AF_INET: { + struct sockaddr_in sin = { + .sin_family = AF_INET, + }; + + si->myname.sa_socklen = sizeof(struct sockaddr_in); + memcpy(&si->myname.sa.in, &sin, si->myname.sa_socklen); + break; + } + case AF_INET6: { + struct sockaddr_in6 sin6 = { + .sin6_family = AF_INET6, + }; + + si->myname.sa_socklen = sizeof(struct sockaddr_in6); + memcpy(&si->myname.sa.in6, &sin6, si->myname.sa_socklen); + break; + } + default: + free(si); + errno = EINVAL; + return -1; + } + + fi = (struct socket_info_fd *)calloc(1, sizeof(struct socket_info_fd)); + if (fi == NULL) { + free(si); + errno = ENOMEM; + return -1; + } + + fi->fd = fd; + + SWRAP_DLIST_ADD(si->fds, fi); + SWRAP_DLIST_ADD(sockets, si); + + SWRAP_LOG(SWRAP_LOG_TRACE, + "Created %s socket for protocol %s", + si->family == AF_INET ? "IPv4" : "IPv6", + si->type == SOCK_DGRAM ? "UDP" : "TCP"); + + return fd; +} + +int socket(int family, int type, int protocol) +{ + return swrap_socket(family, type, protocol); +} + +/**************************************************************************** + * SOCKETPAIR + ***************************************************************************/ + +static int swrap_socketpair(int family, int type, int protocol, int sv[2]) +{ + int rc; + + rc = libc_socketpair(family, type, protocol, sv); + if (rc != -1) { + swrap_remove_stale(sv[0]); + swrap_remove_stale(sv[1]); + } + + return rc; +} + +int socketpair(int family, int type, int protocol, int sv[2]) +{ + return swrap_socketpair(family, type, protocol, sv); +} + +/**************************************************************************** + * SOCKETPAIR + ***************************************************************************/ + +#ifdef HAVE_TIMERFD_CREATE +static int swrap_timerfd_create(int clockid, int flags) +{ + int fd; + + fd = libc_timerfd_create(clockid, flags); + if (fd != -1) { + swrap_remove_stale(fd); + } + + return fd; +} + +int timerfd_create(int clockid, int flags) +{ + return swrap_timerfd_create(clockid, flags); +} +#endif + +/**************************************************************************** + * PIPE + ***************************************************************************/ + +static int swrap_pipe(int pipefd[2]) +{ + int rc; + + rc = libc_pipe(pipefd); + if (rc != -1) { + swrap_remove_stale(pipefd[0]); + swrap_remove_stale(pipefd[1]); + } + + return rc; +} + +int pipe(int pipefd[2]) +{ + return swrap_pipe(pipefd); +} + +/**************************************************************************** + * ACCEPT + ***************************************************************************/ + +static int swrap_accept(int s, + struct sockaddr *addr, + socklen_t *addrlen, + int flags) +{ + struct socket_info *parent_si, *child_si; + struct socket_info_fd *child_fi; + int fd; + struct swrap_address un_addr = { + .sa_socklen = sizeof(struct sockaddr_un), + }; + struct swrap_address un_my_addr = { + .sa_socklen = sizeof(struct sockaddr_un), + }; + struct swrap_address in_addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + struct swrap_address in_my_addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + int ret; + + parent_si = find_socket_info(s); + if (!parent_si) { +#ifdef HAVE_ACCEPT4 + return libc_accept4(s, addr, addrlen, flags); +#else + return libc_accept(s, addr, addrlen); +#endif + } + + /* + * assume out sockaddr have the same size as the in parent + * socket family + */ + in_addr.sa_socklen = socket_length(parent_si->family); + if (in_addr.sa_socklen <= 0) { + errno = EINVAL; + return -1; + } + +#ifdef HAVE_ACCEPT4 + ret = libc_accept4(s, &un_addr.sa.s, &un_addr.sa_socklen, flags); +#else + ret = libc_accept(s, &un_addr.sa.s, &un_addr.sa_socklen); +#endif + if (ret == -1) { + if (errno == ENOTSOCK) { + /* Remove stale fds */ + swrap_remove_stale(s); + } + return ret; + } + + fd = ret; + + ret = sockaddr_convert_from_un(parent_si, + &un_addr.sa.un, + un_addr.sa_socklen, + parent_si->family, + &in_addr.sa.s, + &in_addr.sa_socklen); + if (ret == -1) { + close(fd); + return ret; + } + + child_si = (struct socket_info *)calloc(1, sizeof(struct socket_info)); + if (child_si == NULL) { + close(fd); + errno = ENOMEM; + return -1; + } + + child_fi = (struct socket_info_fd *)calloc(1, sizeof(struct socket_info_fd)); + if (child_fi == NULL) { + free(child_si); + close(fd); + errno = ENOMEM; + return -1; + } + + child_fi->fd = fd; + + SWRAP_DLIST_ADD(child_si->fds, child_fi); + + child_si->family = parent_si->family; + child_si->type = parent_si->type; + child_si->protocol = parent_si->protocol; + child_si->bound = 1; + child_si->is_server = 1; + child_si->connected = 1; + + child_si->peername = (struct swrap_address) { + .sa_socklen = in_addr.sa_socklen, + }; + memcpy(&child_si->peername.sa.ss, &in_addr.sa.ss, in_addr.sa_socklen); + + if (addr != NULL && addrlen != NULL) { + size_t copy_len = MIN(*addrlen, in_addr.sa_socklen); + if (copy_len > 0) { + memcpy(addr, &in_addr.sa.ss, copy_len); + } + *addrlen = in_addr.sa_socklen; + } + + ret = libc_getsockname(fd, + &un_my_addr.sa.s, + &un_my_addr.sa_socklen); + if (ret == -1) { + free(child_fi); + free(child_si); + close(fd); + return ret; + } + + ret = sockaddr_convert_from_un(child_si, + &un_my_addr.sa.un, + un_my_addr.sa_socklen, + child_si->family, + &in_my_addr.sa.s, + &in_my_addr.sa_socklen); + if (ret == -1) { + free(child_fi); + free(child_si); + close(fd); + return ret; + } + + SWRAP_LOG(SWRAP_LOG_TRACE, + "accept() path=%s, fd=%d", + un_my_addr.sa.un.sun_path, s); + + child_si->myname = (struct swrap_address) { + .sa_socklen = in_my_addr.sa_socklen, + }; + memcpy(&child_si->myname.sa.ss, &in_my_addr.sa.ss, in_my_addr.sa_socklen); + + SWRAP_DLIST_ADD(sockets, child_si); + + if (addr != NULL) { + swrap_pcap_dump_packet(child_si, addr, SWRAP_ACCEPT_SEND, NULL, 0); + swrap_pcap_dump_packet(child_si, addr, SWRAP_ACCEPT_RECV, NULL, 0); + swrap_pcap_dump_packet(child_si, addr, SWRAP_ACCEPT_ACK, NULL, 0); + } + + return fd; +} + +#ifdef HAVE_ACCEPT4 +int accept4(int s, struct sockaddr *addr, socklen_t *addrlen, int flags) +{ + return swrap_accept(s, addr, (socklen_t *)addrlen, flags); +} +#endif + +#ifdef HAVE_ACCEPT_PSOCKLEN_T +int accept(int s, struct sockaddr *addr, Psocklen_t addrlen) +#else +int accept(int s, struct sockaddr *addr, socklen_t *addrlen) +#endif +{ + return swrap_accept(s, addr, (socklen_t *)addrlen, 0); +} + +static int autobind_start_init; +static int autobind_start; + +/* using sendto() or connect() on an unbound socket would give the + recipient no way to reply, as unlike UDP and TCP, a unix domain + socket can't auto-assign ephemeral port numbers, so we need to + assign it here. + Note: this might change the family from ipv6 to ipv4 +*/ +static int swrap_auto_bind(int fd, struct socket_info *si, int family) +{ + struct swrap_address un_addr = { + .sa_socklen = sizeof(struct sockaddr_un), + }; + int i; + char type; + int ret; + int port; + unsigned int in4_addr, in6_a0, in6_a1, in6_a2, in6_a3; + struct stat st; + + if (autobind_start_init != 1) { + autobind_start_init = 1; + autobind_start = getpid(); + autobind_start %= 50000; + autobind_start += 10000; + } + + un_addr.sa.un.sun_family = AF_UNIX; + + switch (family) { + case AF_INET: { + struct sockaddr_in in; + + switch (si->type) { + case SOCK_STREAM: + type = SOCKET_TYPE_CHAR_TCP_LONG; + break; + case SOCK_DGRAM: + type = SOCKET_TYPE_CHAR_UDP_LONG; + break; + default: + errno = ESOCKTNOSUPPORT; + return -1; + } + + memset(&in, 0, sizeof(in)); + in.sin_family = AF_INET; + in4_addr = socket_wrapper_default_addr(); + in.sin_addr.s_addr = htonl(in4_addr); + + si->myname = (struct swrap_address) { + .sa_socklen = sizeof(in), + }; + memcpy(&si->myname.sa.in, &in, si->myname.sa_socklen); + break; + } +#ifdef HAVE_IPV6 + case AF_INET6: { + struct sockaddr_in6 in6; + + if (si->family != family) { + errno = ENETUNREACH; + return -1; + } + + switch (si->type) { + case SOCK_STREAM: + type = SOCKET_TYPE_CHAR_TCP_V6_LONG; + break; + case SOCK_DGRAM: + type = SOCKET_TYPE_CHAR_UDP_V6_LONG; + break; + default: + errno = ESOCKTNOSUPPORT; + return -1; + } + + memset(&in6, 0, sizeof(in6)); + in6.sin6_family = AF_INET6; + in6.sin6_addr = *swrap_ipv6(); + in6.sin6_addr.s6_addr[15] = socket_wrapper_default_iface(); + + si->myname = (struct swrap_address) { + .sa_socklen = sizeof(in6), + }; + memcpy(&si->myname.sa.in6, &in6, si->myname.sa_socklen); + swrap_make_ipv6_ints(in6.sin6_addr.s6_addr,&in6_a0,&in6_a1,&in6_a2,&in6_a3); + break; + } +#endif + default: + errno = ESOCKTNOSUPPORT; + return -1; + } + + if (autobind_start > 60000) { + autobind_start = 10000; + } + + for (i = 0; i < SOCKET_MAX_SOCKETS; i++) { + port = autobind_start + i; + + if (family == AF_INET) + snprintf(un_addr.sa.un.sun_path, sizeof(un_addr.sa.un.sun_path), + "%s/"SOCKET_FORMAT_LONG, socket_wrapper_dir(), + type, in4_addr, port); + else + snprintf(un_addr.sa.un.sun_path, sizeof(un_addr.sa.un.sun_path), + "%s/"SOCKET_FORMAT_V6_LONG, socket_wrapper_dir(), + type, in6_a0,in6_a1, in6_a2, in6_a3, port); + + if (stat(un_addr.sa.un.sun_path, &st) == 0) continue; + + ret = libc_bind(fd, &un_addr.sa.s, un_addr.sa_socklen); + if (ret == -1) return ret; + + si->un_addr = un_addr.sa.un; + + si->bound = 1; + autobind_start = port + 1; + SWRAP_LOG(SWRAP_LOG_TRACE, "bound to: %s", un_addr.sa.un.sun_path); + break; + } + if (i == SOCKET_MAX_SOCKETS) { + SWRAP_LOG(SWRAP_LOG_ERROR, "Too many open unix sockets (%u) for " + "interface "SOCKET_FORMAT, + SOCKET_MAX_SOCKETS, + type, + socket_wrapper_default_addr(), + 0); + errno = ENFILE; + return -1; + } + + si->family = family; + set_port(si->family, port, &si->myname); + + return 0; +} + +/**************************************************************************** + * CONNECT + ***************************************************************************/ + +static int swrap_connect(int s, const struct sockaddr *serv_addr, + socklen_t addrlen) +{ + int ret; + struct swrap_address un_addr = { + .sa_socklen = sizeof(struct sockaddr_un), + }; + struct socket_info *si = find_socket_info(s); + int bcast = 0; + + if (!si) { + return libc_connect(s, serv_addr, addrlen); + } + + if (si->bound == 0) { + ret = swrap_auto_bind(s, si, serv_addr->sa_family); + if (ret == -1) return -1; + } + + if (si->family != serv_addr->sa_family) { + errno = EINVAL; + return -1; + } + + ret = sockaddr_convert_to_un(si, serv_addr, + addrlen, &un_addr.sa.un, 0, &bcast); + if (ret == -1) return -1; + + if (bcast) { + errno = ENETUNREACH; + return -1; + } + + if (si->type == SOCK_DGRAM) { + si->defer_connect = 1; + ret = 0; + } else { + swrap_pcap_dump_packet(si, serv_addr, SWRAP_CONNECT_SEND, NULL, 0); + + ret = libc_connect(s, + &un_addr.sa.s, + un_addr.sa_socklen); + } + + SWRAP_LOG(SWRAP_LOG_TRACE, + "connect() path=%s, fd=%d", + un_addr.sa.un.sun_path, s); + + + /* to give better errors */ + if (ret == -1 && errno == ENOENT) { + errno = EHOSTUNREACH; + } + + if (ret == 0) { + si->peername = (struct swrap_address) { + .sa_socklen = addrlen, + }; + + memcpy(&si->peername.sa.ss, serv_addr, addrlen); + si->connected = 1; + + /* + * When we connect() on a socket than we have to bind the + * outgoing connection on the interface we use for the + * transport. We already bound it on the right interface + * but here we have to update the name so getsockname() + * returns correct information. + */ + if (si->bindname.sa_socklen > 0) { + si->myname = (struct swrap_address) { + .sa_socklen = si->bindname.sa_socklen, + }; + + memcpy(&si->myname.sa.ss, + &si->bindname.sa.ss, + si->bindname.sa_socklen); + + /* Cleanup bindname */ + si->bindname = (struct swrap_address) { + .sa_socklen = 0, + }; + } + + swrap_pcap_dump_packet(si, serv_addr, SWRAP_CONNECT_RECV, NULL, 0); + swrap_pcap_dump_packet(si, serv_addr, SWRAP_CONNECT_ACK, NULL, 0); + } else { + swrap_pcap_dump_packet(si, serv_addr, SWRAP_CONNECT_UNREACH, NULL, 0); + } + + return ret; +} + +int connect(int s, const struct sockaddr *serv_addr, socklen_t addrlen) +{ + return swrap_connect(s, serv_addr, addrlen); +} + +/**************************************************************************** + * BIND + ***************************************************************************/ + +static int swrap_bind(int s, const struct sockaddr *myaddr, socklen_t addrlen) +{ + int ret; + struct swrap_address un_addr = { + .sa_socklen = sizeof(struct sockaddr_un), + }; + struct socket_info *si = find_socket_info(s); + int bind_error = 0; +#if 0 /* FIXME */ + bool in_use; +#endif + + if (!si) { + return libc_bind(s, myaddr, addrlen); + } + + switch (si->family) { + case AF_INET: { + const struct sockaddr_in *sin; + if (addrlen < sizeof(struct sockaddr_in)) { + bind_error = EINVAL; + break; + } + + sin = (const struct sockaddr_in *)(const void *)myaddr; + + if (sin->sin_family != AF_INET) { + bind_error = EAFNOSUPPORT; + } + + /* special case for AF_UNSPEC */ + if (sin->sin_family == AF_UNSPEC && + (sin->sin_addr.s_addr == htonl(INADDR_ANY))) + { + bind_error = 0; + } + + break; + } +#ifdef HAVE_IPV6 + case AF_INET6: { + const struct sockaddr_in6 *sin6; + if (addrlen < sizeof(struct sockaddr_in6)) { + bind_error = EINVAL; + break; + } + + sin6 = (const struct sockaddr_in6 *)(const void *)myaddr; + + if (sin6->sin6_family != AF_INET6) { + bind_error = EAFNOSUPPORT; + } + + break; + } +#endif + default: + bind_error = EINVAL; + break; + } + + if (bind_error != 0) { + errno = bind_error; + return -1; + } + +#if 0 /* FIXME */ + in_use = check_addr_port_in_use(myaddr, addrlen); + if (in_use) { + errno = EADDRINUSE; + return -1; + } +#endif + + si->myname.sa_socklen = addrlen; + memcpy(&si->myname.sa.ss, myaddr, addrlen); + + ret = sockaddr_convert_to_un(si, + myaddr, + addrlen, + &un_addr.sa.un, + 1, + &si->bcast); + if (ret == -1) return -1; + + unlink(un_addr.sa.un.sun_path); + + ret = libc_bind(s, &un_addr.sa.s, un_addr.sa_socklen); + + SWRAP_LOG(SWRAP_LOG_TRACE, + "bind() path=%s, fd=%d", + un_addr.sa.un.sun_path, s); + + if (ret == 0) { + si->bound = 1; + } + + return ret; +} + +int bind(int s, const struct sockaddr *myaddr, socklen_t addrlen) +{ + return swrap_bind(s, myaddr, addrlen); +} + +/**************************************************************************** + * BINDRESVPORT + ***************************************************************************/ + +#ifdef HAVE_BINDRESVPORT +static int swrap_getsockname(int s, struct sockaddr *name, socklen_t *addrlen); + +static int swrap_bindresvport_sa(int sd, struct sockaddr *sa) +{ + struct swrap_address myaddr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + socklen_t salen; + static uint16_t port; + uint16_t i; + int rc = -1; + int af; + +#define SWRAP_STARTPORT 600 +#define SWRAP_ENDPORT (IPPORT_RESERVED - 1) +#define SWRAP_NPORTS (SWRAP_ENDPORT - SWRAP_STARTPORT + 1) + + if (port == 0) { + port = (getpid() % SWRAP_NPORTS) + SWRAP_STARTPORT; + } + + if (sa == NULL) { + salen = myaddr.sa_socklen; + sa = &myaddr.sa.s; + + rc = swrap_getsockname(sd, &myaddr.sa.s, &salen); + if (rc < 0) { + return -1; + } + + af = sa->sa_family; + memset(&myaddr.sa.ss, 0, salen); + } else { + af = sa->sa_family; + } + + for (i = 0; i < SWRAP_NPORTS; i++, port++) { + switch(af) { + case AF_INET: { + struct sockaddr_in *sinp = (struct sockaddr_in *)(void *)sa; + + salen = sizeof(struct sockaddr_in); + sinp->sin_port = htons(port); + break; + } + case AF_INET6: { + struct sockaddr_in6 *sin6p = (struct sockaddr_in6 *)(void *)sa; + + salen = sizeof(struct sockaddr_in6); + sin6p->sin6_port = htons(port); + break; + } + default: + errno = EAFNOSUPPORT; + return -1; + } + sa->sa_family = af; + + if (port > SWRAP_ENDPORT) { + port = SWRAP_STARTPORT; + } + + rc = swrap_bind(sd, (struct sockaddr *)sa, salen); + if (rc == 0 || errno != EADDRINUSE) { + break; + } + } + + return rc; +} + +int bindresvport(int sockfd, struct sockaddr_in *sinp) +{ + return swrap_bindresvport_sa(sockfd, (struct sockaddr *)sinp); +} +#endif + +/**************************************************************************** + * LISTEN + ***************************************************************************/ + +static int swrap_listen(int s, int backlog) +{ + int ret; + struct socket_info *si = find_socket_info(s); + + if (!si) { + return libc_listen(s, backlog); + } + + if (si->bound == 0) { + ret = swrap_auto_bind(s, si, si->family); + if (ret == -1) { + errno = EADDRINUSE; + return ret; + } + } + + ret = libc_listen(s, backlog); + + return ret; +} + +int listen(int s, int backlog) +{ + return swrap_listen(s, backlog); +} + +/**************************************************************************** + * FOPEN + ***************************************************************************/ + +static FILE *swrap_fopen(const char *name, const char *mode) +{ + FILE *fp; + + fp = libc_fopen(name, mode); + if (fp != NULL) { + int fd = fileno(fp); + + swrap_remove_stale(fd); + } + + return fp; +} + +FILE *fopen(const char *name, const char *mode) +{ + return swrap_fopen(name, mode); +} + +/**************************************************************************** + * OPEN + ***************************************************************************/ + +static int swrap_vopen(const char *pathname, int flags, va_list ap) +{ + int ret; + + ret = libc_vopen(pathname, flags, ap); + if (ret != -1) { + /* + * There are methods for closing descriptors (libc-internal code + * paths, direct syscalls) which close descriptors in ways that + * we can't intercept, so try to recover when we notice that + * that's happened + */ + swrap_remove_stale(ret); + } + return ret; +} + +int open(const char *pathname, int flags, ...) +{ + va_list ap; + int fd; + + va_start(ap, flags); + fd = swrap_vopen(pathname, flags, ap); + va_end(ap); + + return fd; +} + +/**************************************************************************** + * GETPEERNAME + ***************************************************************************/ + +static int swrap_getpeername(int s, struct sockaddr *name, socklen_t *addrlen) +{ + struct socket_info *si = find_socket_info(s); + socklen_t len; + + if (!si) { + return libc_getpeername(s, name, addrlen); + } + + if (si->peername.sa_socklen == 0) + { + errno = ENOTCONN; + return -1; + } + + len = MIN(*addrlen, si->peername.sa_socklen); + if (len == 0) { + return 0; + } + + memcpy(name, &si->peername.sa.ss, len); + *addrlen = si->peername.sa_socklen; + + return 0; +} + +#ifdef HAVE_ACCEPT_PSOCKLEN_T +int getpeername(int s, struct sockaddr *name, Psocklen_t addrlen) +#else +int getpeername(int s, struct sockaddr *name, socklen_t *addrlen) +#endif +{ + return swrap_getpeername(s, name, (socklen_t *)addrlen); +} + +/**************************************************************************** + * GETSOCKNAME + ***************************************************************************/ + +static int swrap_getsockname(int s, struct sockaddr *name, socklen_t *addrlen) +{ + struct socket_info *si = find_socket_info(s); + socklen_t len; + + if (!si) { + return libc_getsockname(s, name, addrlen); + } + + len = MIN(*addrlen, si->myname.sa_socklen); + if (len == 0) { + return 0; + } + + memcpy(name, &si->myname.sa.ss, len); + *addrlen = si->myname.sa_socklen; + + return 0; +} + +#ifdef HAVE_ACCEPT_PSOCKLEN_T +int getsockname(int s, struct sockaddr *name, Psocklen_t addrlen) +#else +int getsockname(int s, struct sockaddr *name, socklen_t *addrlen) +#endif +{ + return swrap_getsockname(s, name, (socklen_t *)addrlen); +} + +/**************************************************************************** + * GETSOCKOPT + ***************************************************************************/ + +#ifndef SO_PROTOCOL +# ifdef SO_PROTOTYPE /* The Solaris name */ +# define SO_PROTOCOL SO_PROTOTYPE +# endif /* SO_PROTOTYPE */ +#endif /* SO_PROTOCOL */ + +static int swrap_getsockopt(int s, int level, int optname, + void *optval, socklen_t *optlen) +{ + struct socket_info *si = find_socket_info(s); + + if (!si) { + return libc_getsockopt(s, + level, + optname, + optval, + optlen); + } + + if (level == SOL_SOCKET) { + switch (optname) { +#ifdef SO_DOMAIN + case SO_DOMAIN: + if (optval == NULL || optlen == NULL || + *optlen < (socklen_t)sizeof(int)) { + errno = EINVAL; + return -1; + } + + *optlen = sizeof(int); + *(int *)optval = si->family; + return 0; +#endif /* SO_DOMAIN */ + +#ifdef SO_PROTOCOL + case SO_PROTOCOL: + if (optval == NULL || optlen == NULL || + *optlen < (socklen_t)sizeof(int)) { + errno = EINVAL; + return -1; + } + + *optlen = sizeof(int); + *(int *)optval = si->protocol; + return 0; +#endif /* SO_PROTOCOL */ + case SO_TYPE: + if (optval == NULL || optlen == NULL || + *optlen < (socklen_t)sizeof(int)) { + errno = EINVAL; + return -1; + } + + *optlen = sizeof(int); + *(int *)optval = si->type; + return 0; + default: + return libc_getsockopt(s, + level, + optname, + optval, + optlen); + } + } else if (level == IPPROTO_TCP) { + switch (optname) { +#ifdef TCP_NODELAY + case TCP_NODELAY: + /* + * This enables sending packets directly out over TCP. + * As a unix socket is doing that any way, report it as + * enabled. + */ + if (optval == NULL || optlen == NULL || + *optlen < (socklen_t)sizeof(int)) { + errno = EINVAL; + return -1; + } + + *optlen = sizeof(int); + *(int *)optval = si->tcp_nodelay; + + return 0; +#endif /* TCP_NODELAY */ + default: + break; + } + } + + errno = ENOPROTOOPT; + return -1; +} + +#ifdef HAVE_ACCEPT_PSOCKLEN_T +int getsockopt(int s, int level, int optname, void *optval, Psocklen_t optlen) +#else +int getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen) +#endif +{ + return swrap_getsockopt(s, level, optname, optval, (socklen_t *)optlen); +} + +/**************************************************************************** + * SETSOCKOPT + ***************************************************************************/ + +static int swrap_setsockopt(int s, int level, int optname, + const void *optval, socklen_t optlen) +{ + struct socket_info *si = find_socket_info(s); + + if (!si) { + return libc_setsockopt(s, + level, + optname, + optval, + optlen); + } + + if (level == SOL_SOCKET) { + return libc_setsockopt(s, + level, + optname, + optval, + optlen); + } else if (level == IPPROTO_TCP) { + switch (optname) { +#ifdef TCP_NODELAY + case TCP_NODELAY: { + int i; + + /* + * This enables sending packets directly out over TCP. + * A unix socket is doing that any way. + */ + if (optval == NULL || optlen == 0 || + optlen < (socklen_t)sizeof(int)) { + errno = EINVAL; + return -1; + } + + i = *discard_const_p(int, optval); + if (i != 0 && i != 1) { + errno = EINVAL; + return -1; + } + si->tcp_nodelay = i; + + return 0; + } +#endif /* TCP_NODELAY */ + default: + break; + } + } + + switch (si->family) { + case AF_INET: + if (level == IPPROTO_IP) { +#ifdef IP_PKTINFO + if (optname == IP_PKTINFO) { + si->pktinfo = AF_INET; + } +#endif /* IP_PKTINFO */ + } + return 0; +#ifdef HAVE_IPV6 + case AF_INET6: + if (level == IPPROTO_IPV6) { +#ifdef IPV6_RECVPKTINFO + if (optname == IPV6_RECVPKTINFO) { + si->pktinfo = AF_INET6; + } +#endif /* IPV6_PKTINFO */ + } + return 0; +#endif + default: + errno = ENOPROTOOPT; + return -1; + } +} + +int setsockopt(int s, int level, int optname, + const void *optval, socklen_t optlen) +{ + return swrap_setsockopt(s, level, optname, optval, optlen); +} + +/**************************************************************************** + * IOCTL + ***************************************************************************/ + +static int swrap_vioctl(int s, unsigned long int r, va_list va) +{ + struct socket_info *si = find_socket_info(s); + va_list ap; + int value; + int rc; + + if (!si) { + return libc_vioctl(s, r, va); + } + + va_copy(ap, va); + + rc = libc_vioctl(s, r, va); + + switch (r) { + case FIONREAD: + value = *((int *)va_arg(ap, int *)); + + if (rc == -1 && errno != EAGAIN && errno != ENOBUFS) { + swrap_pcap_dump_packet(si, NULL, SWRAP_PENDING_RST, NULL, 0); + } else if (value == 0) { /* END OF FILE */ + swrap_pcap_dump_packet(si, NULL, SWRAP_PENDING_RST, NULL, 0); + } + break; + } + + va_end(ap); + + return rc; +} + +#ifdef HAVE_IOCTL_INT +int ioctl(int s, int r, ...) +#else +int ioctl(int s, unsigned long int r, ...) +#endif +{ + va_list va; + int rc; + + va_start(va, r); + + rc = swrap_vioctl(s, (unsigned long int) r, va); + + va_end(va); + + return rc; +} + +/***************** + * CMSG + *****************/ + +#ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL + +#ifndef CMSG_ALIGN +# ifdef _ALIGN /* BSD */ +#define CMSG_ALIGN _ALIGN +# else +#define CMSG_ALIGN(len) (((len) + sizeof(size_t) - 1) & ~(sizeof(size_t) - 1)) +# endif /* _ALIGN */ +#endif /* CMSG_ALIGN */ + +/** + * @brief Add a cmsghdr to a msghdr. + * + * This is an function to add any type of cmsghdr. It will operate on the + * msg->msg_control and msg->msg_controllen you pass in by adapting them to + * the buffer position after the added cmsg element. Hence, this function is + * intended to be used with an intermediate msghdr and not on the original + * one handed in by the client. + * + * @param[in] msg The msghdr to which to add the cmsg. + * + * @param[in] level The cmsg level to set. + * + * @param[in] type The cmsg type to set. + * + * @param[in] data The cmsg data to set. + * + * @param[in] len the length of the data to set. + */ +static void swrap_msghdr_add_cmsghdr(struct msghdr *msg, + int level, + int type, + const void *data, + size_t len) +{ + size_t cmlen = CMSG_LEN(len); + size_t cmspace = CMSG_SPACE(len); + uint8_t cmbuf[cmspace]; + void *cast_ptr = (void *)cmbuf; + struct cmsghdr *cm = (struct cmsghdr *)cast_ptr; + uint8_t *p; + + memset(cmbuf, 0, cmspace); + + if (msg->msg_controllen < cmlen) { + cmlen = msg->msg_controllen; + msg->msg_flags |= MSG_CTRUNC; + } + + if (msg->msg_controllen < cmspace) { + cmspace = msg->msg_controllen; + } + + /* + * We copy the full input data into an intermediate cmsghdr first + * in order to more easily cope with truncation. + */ + cm->cmsg_len = cmlen; + cm->cmsg_level = level; + cm->cmsg_type = type; + memcpy(CMSG_DATA(cm), data, len); + + /* + * We now copy the possibly truncated buffer. + * We copy cmlen bytes, but consume cmspace bytes, + * leaving the possible padding uninitialiazed. + */ + p = (uint8_t *)msg->msg_control; + memcpy(p, cm, cmlen); + p += cmspace; + msg->msg_control = p; + msg->msg_controllen -= cmspace; + + return; +} + +static int swrap_msghdr_add_pktinfo(struct socket_info *si, + struct msghdr *msg) +{ + /* Add packet info */ + switch (si->pktinfo) { +#if defined(IP_PKTINFO) && (defined(HAVE_STRUCT_IN_PKTINFO) || defined(IP_RECVDSTADDR)) + case AF_INET: { + struct sockaddr_in *sin; +#if defined(HAVE_STRUCT_IN_PKTINFO) + struct in_pktinfo pkt; +#elif defined(IP_RECVDSTADDR) + struct in_addr pkt; +#endif + + if (si->bindname.sa_socklen == sizeof(struct sockaddr_in)) { + sin = &si->bindname.sa.in; + } else { + if (si->myname.sa_socklen != sizeof(struct sockaddr_in)) { + return 0; + } + sin = &si->myname.sa.in; + } + + ZERO_STRUCT(pkt); + +#if defined(HAVE_STRUCT_IN_PKTINFO) + pkt.ipi_ifindex = socket_wrapper_default_iface(); + pkt.ipi_addr.s_addr = sin->sin_addr.s_addr; +#elif defined(IP_RECVDSTADDR) + pkt = sin->sin_addr; +#endif + + swrap_msghdr_add_cmsghdr(msg, IPPROTO_IP, IP_PKTINFO, + &pkt, sizeof(pkt)); + + break; + } +#endif /* IP_PKTINFO */ +#if defined(HAVE_IPV6) + case AF_INET6: { +#if defined(IPV6_PKTINFO) && defined(HAVE_STRUCT_IN6_PKTINFO) + struct sockaddr_in6 *sin6; + struct in6_pktinfo pkt6; + + if (si->bindname.sa_socklen == sizeof(struct sockaddr_in6)) { + sin6 = &si->bindname.sa.in6; + } else { + if (si->myname.sa_socklen != sizeof(struct sockaddr_in6)) { + return 0; + } + sin6 = &si->myname.sa.in6; + } + + ZERO_STRUCT(pkt6); + + pkt6.ipi6_ifindex = socket_wrapper_default_iface(); + pkt6.ipi6_addr = sin6->sin6_addr; + + swrap_msghdr_add_cmsghdr(msg, IPPROTO_IPV6, IPV6_PKTINFO, + &pkt6, sizeof(pkt6)); +#endif /* HAVE_STRUCT_IN6_PKTINFO */ + + break; + } +#endif /* IPV6_PKTINFO */ + default: + return -1; + } + + return 0; +} + +static int swrap_msghdr_add_socket_info(struct socket_info *si, + struct msghdr *omsg) +{ + int rc = 0; + + if (si->pktinfo > 0) { + rc = swrap_msghdr_add_pktinfo(si, omsg); + } + + return rc; +} + +static int swrap_sendmsg_copy_cmsg(struct cmsghdr *cmsg, + uint8_t **cm_data, + size_t *cm_data_space); +static int swrap_sendmsg_filter_cmsg_socket(struct cmsghdr *cmsg, + uint8_t **cm_data, + size_t *cm_data_space); + +static int swrap_sendmsg_filter_cmsghdr(struct msghdr *msg, + uint8_t **cm_data, + size_t *cm_data_space) { + struct cmsghdr *cmsg; + int rc = -1; + + /* Nothing to do */ + if (msg->msg_controllen == 0 || msg->msg_control == NULL) { + return 0; + } + + for (cmsg = CMSG_FIRSTHDR(msg); + cmsg != NULL; + cmsg = CMSG_NXTHDR(msg, cmsg)) { + switch (cmsg->cmsg_level) { + case IPPROTO_IP: + rc = swrap_sendmsg_filter_cmsg_socket(cmsg, + cm_data, + cm_data_space); + break; + default: + rc = swrap_sendmsg_copy_cmsg(cmsg, + cm_data, + cm_data_space); + break; + } + } + + return rc; +} + +static int swrap_sendmsg_copy_cmsg(struct cmsghdr *cmsg, + uint8_t **cm_data, + size_t *cm_data_space) +{ + size_t cmspace; + uint8_t *p; + + cmspace = *cm_data_space + CMSG_ALIGN(cmsg->cmsg_len); + + p = realloc((*cm_data), cmspace); + if (p == NULL) { + return -1; + } + (*cm_data) = p; + + p = (*cm_data) + (*cm_data_space); + *cm_data_space = cmspace; + + memcpy(p, cmsg, cmsg->cmsg_len); + + return 0; +} + +static int swrap_sendmsg_filter_cmsg_pktinfo(struct cmsghdr *cmsg, + uint8_t **cm_data, + size_t *cm_data_space); + + +static int swrap_sendmsg_filter_cmsg_socket(struct cmsghdr *cmsg, + uint8_t **cm_data, + size_t *cm_data_space) +{ + int rc = -1; + + switch(cmsg->cmsg_type) { +#ifdef IP_PKTINFO + case IP_PKTINFO: + rc = swrap_sendmsg_filter_cmsg_pktinfo(cmsg, + cm_data, + cm_data_space); + break; +#endif +#ifdef IPV6_PKTINFO + case IPV6_PKTINFO: + rc = swrap_sendmsg_filter_cmsg_pktinfo(cmsg, + cm_data, + cm_data_space); + break; +#endif + default: + break; + } + + return rc; +} + +static int swrap_sendmsg_filter_cmsg_pktinfo(struct cmsghdr *cmsg, + uint8_t **cm_data, + size_t *cm_data_space) +{ + (void)cmsg; /* unused */ + (void)cm_data; /* unused */ + (void)cm_data_space; /* unused */ + + /* + * Passing a IP pktinfo to a unix socket might be rejected by the + * Kernel, at least on FreeBSD. So skip this cmsg. + */ + return 0; +} +#endif /* HAVE_STRUCT_MSGHDR_MSG_CONTROL */ + +static ssize_t swrap_sendmsg_before(int fd, + struct socket_info *si, + struct msghdr *msg, + struct iovec *tmp_iov, + struct sockaddr_un *tmp_un, + const struct sockaddr_un **to_un, + const struct sockaddr **to, + int *bcast) +{ + size_t i, len = 0; + ssize_t ret; + + if (to_un) { + *to_un = NULL; + } + if (to) { + *to = NULL; + } + if (bcast) { + *bcast = 0; + } + + switch (si->type) { + case SOCK_STREAM: { + unsigned long mtu; + + if (!si->connected) { + errno = ENOTCONN; + return -1; + } + + if (msg->msg_iovlen == 0) { + break; + } + + mtu = socket_wrapper_mtu(); + for (i = 0; i < (size_t)msg->msg_iovlen; i++) { + size_t nlen; + nlen = len + msg->msg_iov[i].iov_len; + if (nlen > mtu) { + break; + } + } + msg->msg_iovlen = i; + if (msg->msg_iovlen == 0) { + *tmp_iov = msg->msg_iov[0]; + tmp_iov->iov_len = MIN((size_t)tmp_iov->iov_len, + (size_t)mtu); + msg->msg_iov = tmp_iov; + msg->msg_iovlen = 1; + } + break; + } + case SOCK_DGRAM: + if (si->connected) { + if (msg->msg_name != NULL) { + /* + * We are dealing with unix sockets and if we + * are connected, we should only talk to the + * connected unix path. Using the fd to send + * to another server would be hard to achieve. + */ + msg->msg_name = NULL; + msg->msg_namelen = 0; + } + } else { + const struct sockaddr *msg_name; + msg_name = (const struct sockaddr *)msg->msg_name; + + if (msg_name == NULL) { + errno = ENOTCONN; + return -1; + } + + + ret = sockaddr_convert_to_un(si, msg_name, msg->msg_namelen, + tmp_un, 0, bcast); + if (ret == -1) return -1; + + if (to_un) { + *to_un = tmp_un; + } + if (to) { + *to = msg_name; + } + msg->msg_name = tmp_un; + msg->msg_namelen = sizeof(*tmp_un); + } + + if (si->bound == 0) { + ret = swrap_auto_bind(fd, si, si->family); + if (ret == -1) { + if (errno == ENOTSOCK) { + swrap_remove_stale(fd); + return -ENOTSOCK; + } else { + SWRAP_LOG(SWRAP_LOG_ERROR, "swrap_sendmsg_before failed"); + return -1; + } + } + } + + if (!si->defer_connect) { + break; + } + + ret = sockaddr_convert_to_un(si, + &si->peername.sa.s, + si->peername.sa_socklen, + tmp_un, + 0, + NULL); + if (ret == -1) return -1; + + ret = libc_connect(fd, + (struct sockaddr *)(void *)tmp_un, + sizeof(*tmp_un)); + + /* to give better errors */ + if (ret == -1 && errno == ENOENT) { + errno = EHOSTUNREACH; + } + + if (ret == -1) { + return ret; + } + + si->defer_connect = 0; + break; + default: + errno = EHOSTUNREACH; + return -1; + } + +#ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL + if (msg->msg_controllen > 0 && msg->msg_control != NULL) { + uint8_t *cmbuf = NULL; + size_t cmlen = 0; + + ret = swrap_sendmsg_filter_cmsghdr(msg, &cmbuf, &cmlen); + if (ret < 0) { + free(cmbuf); + return -1; + } + + if (cmlen == 0) { + msg->msg_controllen = 0; + msg->msg_control = NULL; + } else if (cmlen < msg->msg_controllen && cmbuf != NULL) { + memcpy(msg->msg_control, cmbuf, cmlen); + msg->msg_controllen = cmlen; + } + free(cmbuf); + } +#endif + + return 0; +} + +static void swrap_sendmsg_after(int fd, + struct socket_info *si, + struct msghdr *msg, + const struct sockaddr *to, + ssize_t ret) +{ + int saved_errno = errno; + size_t i, len = 0; + uint8_t *buf; + off_t ofs = 0; + size_t avail = 0; + size_t remain; + + /* to give better errors */ + if (ret == -1) { + if (saved_errno == ENOENT) { + saved_errno = EHOSTUNREACH; + } else if (saved_errno == ENOTSOCK) { + /* If the fd is not a socket, remove it */ + swrap_remove_stale(fd); + } + } + + for (i = 0; i < (size_t)msg->msg_iovlen; i++) { + avail += msg->msg_iov[i].iov_len; + } + + if (ret == -1) { + remain = MIN(80, avail); + } else { + remain = ret; + } + + /* we capture it as one single packet */ + buf = (uint8_t *)malloc(remain); + if (!buf) { + /* we just not capture the packet */ + errno = saved_errno; + return; + } + + for (i = 0; i < (size_t)msg->msg_iovlen; i++) { + size_t this_time = MIN(remain, (size_t)msg->msg_iov[i].iov_len); + memcpy(buf + ofs, + msg->msg_iov[i].iov_base, + this_time); + ofs += this_time; + remain -= this_time; + } + len = ofs; + + switch (si->type) { + case SOCK_STREAM: + if (ret == -1) { + swrap_pcap_dump_packet(si, NULL, SWRAP_SEND, buf, len); + swrap_pcap_dump_packet(si, NULL, SWRAP_SEND_RST, NULL, 0); + } else { + swrap_pcap_dump_packet(si, NULL, SWRAP_SEND, buf, len); + } + break; + + case SOCK_DGRAM: + if (si->connected) { + to = &si->peername.sa.s; + } + if (ret == -1) { + swrap_pcap_dump_packet(si, to, SWRAP_SENDTO, buf, len); + swrap_pcap_dump_packet(si, to, SWRAP_SENDTO_UNREACH, buf, len); + } else { + swrap_pcap_dump_packet(si, to, SWRAP_SENDTO, buf, len); + } + break; + } + + free(buf); + errno = saved_errno; +} + +static int swrap_recvmsg_before(int fd, + struct socket_info *si, + struct msghdr *msg, + struct iovec *tmp_iov) +{ + size_t i, len = 0; + ssize_t ret; + + (void)fd; /* unused */ + + switch (si->type) { + case SOCK_STREAM: { + unsigned int mtu; + if (!si->connected) { + errno = ENOTCONN; + return -1; + } + + if (msg->msg_iovlen == 0) { + break; + } + + mtu = socket_wrapper_mtu(); + for (i = 0; i < (size_t)msg->msg_iovlen; i++) { + size_t nlen; + nlen = len + msg->msg_iov[i].iov_len; + if (nlen > mtu) { + break; + } + } + msg->msg_iovlen = i; + if (msg->msg_iovlen == 0) { + *tmp_iov = msg->msg_iov[0]; + tmp_iov->iov_len = MIN((size_t)tmp_iov->iov_len, + (size_t)mtu); + msg->msg_iov = tmp_iov; + msg->msg_iovlen = 1; + } + break; + } + case SOCK_DGRAM: + if (msg->msg_name == NULL) { + errno = EINVAL; + return -1; + } + + if (msg->msg_iovlen == 0) { + break; + } + + if (si->bound == 0) { + ret = swrap_auto_bind(fd, si, si->family); + if (ret == -1) { + /* + * When attempting to read or write to a + * descriptor, if an underlying autobind fails + * because it's not a socket, stop intercepting + * uses of that descriptor. + */ + if (errno == ENOTSOCK) { + swrap_remove_stale(fd); + return -ENOTSOCK; + } else { + SWRAP_LOG(SWRAP_LOG_ERROR, + "swrap_recvmsg_before failed"); + return -1; + } + } + } + break; + default: + errno = EHOSTUNREACH; + return -1; + } + + return 0; +} + +static int swrap_recvmsg_after(int fd, + struct socket_info *si, + struct msghdr *msg, + const struct sockaddr_un *un_addr, + socklen_t un_addrlen, + ssize_t ret) +{ + int saved_errno = errno; + size_t i; + uint8_t *buf = NULL; + off_t ofs = 0; + size_t avail = 0; + size_t remain; + int rc; + + /* to give better errors */ + if (ret == -1) { + if (saved_errno == ENOENT) { + saved_errno = EHOSTUNREACH; + } else if (saved_errno == ENOTSOCK) { + /* If the fd is not a socket, remove it */ + swrap_remove_stale(fd); + } + } + + for (i = 0; i < (size_t)msg->msg_iovlen; i++) { + avail += msg->msg_iov[i].iov_len; + } + + /* Convert the socket address before we leave */ + if (si->type == SOCK_DGRAM && un_addr != NULL) { + rc = sockaddr_convert_from_un(si, + un_addr, + un_addrlen, + si->family, + msg->msg_name, + &msg->msg_namelen); + if (rc == -1) { + goto done; + } + } + + if (avail == 0) { + rc = 0; + goto done; + } + + if (ret == -1) { + remain = MIN(80, avail); + } else { + remain = ret; + } + + /* we capture it as one single packet */ + buf = (uint8_t *)malloc(remain); + if (buf == NULL) { + /* we just not capture the packet */ + errno = saved_errno; + return -1; + } + + for (i = 0; i < (size_t)msg->msg_iovlen; i++) { + size_t this_time = MIN(remain, (size_t)msg->msg_iov[i].iov_len); + memcpy(buf + ofs, + msg->msg_iov[i].iov_base, + this_time); + ofs += this_time; + remain -= this_time; + } + + switch (si->type) { + case SOCK_STREAM: + if (ret == -1 && saved_errno != EAGAIN && saved_errno != ENOBUFS) { + swrap_pcap_dump_packet(si, NULL, SWRAP_RECV_RST, NULL, 0); + } else if (ret == 0) { /* END OF FILE */ + swrap_pcap_dump_packet(si, NULL, SWRAP_RECV_RST, NULL, 0); + } else if (ret > 0) { + swrap_pcap_dump_packet(si, NULL, SWRAP_RECV, buf, ret); + } + break; + + case SOCK_DGRAM: + if (ret == -1) { + break; + } + + if (un_addr != NULL) { + swrap_pcap_dump_packet(si, + msg->msg_name, + SWRAP_RECVFROM, + buf, + ret); + } else { + swrap_pcap_dump_packet(si, + msg->msg_name, + SWRAP_RECV, + buf, + ret); + } + + break; + } + + rc = 0; +done: + free(buf); + errno = saved_errno; + +#ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL + if (rc == 0 && + msg->msg_controllen > 0 && + msg->msg_control != NULL) { + rc = swrap_msghdr_add_socket_info(si, msg); + if (rc < 0) { + return -1; + } + } +#endif + + return rc; +} + +/**************************************************************************** + * RECVFROM + ***************************************************************************/ + +static ssize_t swrap_recvfrom(int s, void *buf, size_t len, int flags, + struct sockaddr *from, socklen_t *fromlen) +{ + struct swrap_address from_addr = { + .sa_socklen = sizeof(struct sockaddr_un), + }; + ssize_t ret; + struct socket_info *si = find_socket_info(s); + struct swrap_address saddr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + struct msghdr msg; + struct iovec tmp; + int tret; + + if (!si) { + return libc_recvfrom(s, + buf, + len, + flags, + from, + fromlen); + } + + tmp.iov_base = buf; + tmp.iov_len = len; + + ZERO_STRUCT(msg); + if (from != NULL && fromlen != NULL) { + msg.msg_name = from; /* optional address */ + msg.msg_namelen = *fromlen; /* size of address */ + } else { + msg.msg_name = &saddr.sa.s; /* optional address */ + msg.msg_namelen = saddr.sa_socklen; /* size of address */ + } + msg.msg_iov = &tmp; /* scatter/gather array */ + msg.msg_iovlen = 1; /* # elements in msg_iov */ +#ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL + msg.msg_control = NULL; /* ancillary data, see below */ + msg.msg_controllen = 0; /* ancillary data buffer len */ + msg.msg_flags = 0; /* flags on received message */ +#endif + + tret = swrap_recvmsg_before(s, si, &msg, &tmp); + if (tret < 0) { + return -1; + } + + buf = msg.msg_iov[0].iov_base; + len = msg.msg_iov[0].iov_len; + + ret = libc_recvfrom(s, + buf, + len, + flags, + &from_addr.sa.s, + &from_addr.sa_socklen); + if (ret == -1) { + return ret; + } + + tret = swrap_recvmsg_after(s, + si, + &msg, + &from_addr.sa.un, + from_addr.sa_socklen, + ret); + if (tret != 0) { + return tret; + } + + if (from != NULL && fromlen != NULL) { + *fromlen = msg.msg_namelen; + } + + return ret; +} + +#ifdef HAVE_ACCEPT_PSOCKLEN_T +ssize_t recvfrom(int s, void *buf, size_t len, int flags, + struct sockaddr *from, Psocklen_t fromlen) +#else +ssize_t recvfrom(int s, void *buf, size_t len, int flags, + struct sockaddr *from, socklen_t *fromlen) +#endif +{ + return swrap_recvfrom(s, buf, len, flags, from, (socklen_t *)fromlen); +} + +/**************************************************************************** + * SENDTO + ***************************************************************************/ + +static ssize_t swrap_sendto(int s, const void *buf, size_t len, int flags, + const struct sockaddr *to, socklen_t tolen) +{ + struct msghdr msg; + struct iovec tmp; + struct swrap_address un_addr = { + .sa_socklen = sizeof(struct sockaddr_un), + }; + const struct sockaddr_un *to_un = NULL; + ssize_t ret; + int rc; + struct socket_info *si = find_socket_info(s); + int bcast = 0; + + if (!si) { + return libc_sendto(s, buf, len, flags, to, tolen); + } + + tmp.iov_base = discard_const_p(char, buf); + tmp.iov_len = len; + + ZERO_STRUCT(msg); + msg.msg_name = discard_const_p(struct sockaddr, to); /* optional address */ + msg.msg_namelen = tolen; /* size of address */ + msg.msg_iov = &tmp; /* scatter/gather array */ + msg.msg_iovlen = 1; /* # elements in msg_iov */ +#if HAVE_STRUCT_MSGHDR_MSG_CONTROL + msg.msg_control = NULL; /* ancillary data, see below */ + msg.msg_controllen = 0; /* ancillary data buffer len */ + msg.msg_flags = 0; /* flags on received message */ +#endif + + rc = swrap_sendmsg_before(s, + si, + &msg, + &tmp, + &un_addr.sa.un, + &to_un, + &to, + &bcast); + if (rc < 0) { + return -1; + } + + buf = msg.msg_iov[0].iov_base; + len = msg.msg_iov[0].iov_len; + + if (bcast) { +/* struct stat st; + unsigned int iface; */ + unsigned int prt = ntohs(((const struct sockaddr_in *)(const void *)to)->sin_port); + unsigned int remote_prt; + unsigned int in4_addr; + char type; + DIR *d; + struct dirent *dir; + +/* + type = SOCKET_TYPE_CHAR_UDP; + + for(iface=0; iface <= MAX_WRAPPED_INTERFACES; iface++) { + snprintf(un_addr.sa.un.sun_path, + sizeof(un_addr.sa.un.sun_path), + "%s/"SOCKET_FORMAT, + socket_wrapper_dir(), type, iface, prt); + if (stat(un_addr.sa.un.sun_path, &st) != 0) continue; + + / * ignore the any errors in broadcast sends * / + libc_sendto(s, + buf, + len, + flags, + &un_addr.sa.s, + un_addr.sa_socklen); + } +*/ + + d = opendir(socket_wrapper_dir()); + if (d) { + while ((dir = readdir(d)) != NULL) { + if (dir->d_name[0] == SOCKET_TYPE_CHAR_UDP_LONG) + /* TODO - use S_ISSOCK ? */ + if (sscanf(dir->d_name, SOCKET_FORMAT_LONG, &type, &in4_addr, &remote_prt) == 3) + if (prt == remote_prt) { + snprintf(un_addr.sa.un.sun_path, + sizeof(un_addr.sa.un.sun_path), + "%s/%s", + socket_wrapper_dir(),dir->d_name); + libc_sendto(s, + buf, + len, + flags, + &un_addr.sa.s, + un_addr.sa_socklen); + SWRAP_LOG(SWRAP_LOG_DEBUG,"send bcast packet to %s", dir->d_name); + } + } + closedir(d); + } + + swrap_pcap_dump_packet(si, to, SWRAP_SENDTO, buf, len); + + return len; + } + + /* + * If it is a dgram socket and we are connected, don't include the + * 'to' address. + */ + if (si->type == SOCK_DGRAM && si->connected) { + ret = libc_sendto(s, + buf, + len, + flags, + NULL, + 0); + } else { + ret = libc_sendto(s, + buf, + len, + flags, + (struct sockaddr *)msg.msg_name, + msg.msg_namelen); + } + + swrap_sendmsg_after(s, si, &msg, to, ret); + + return ret; +} + +ssize_t sendto(int s, const void *buf, size_t len, int flags, + const struct sockaddr *to, socklen_t tolen) +{ + return swrap_sendto(s, buf, len, flags, to, tolen); +} + +/**************************************************************************** + * READV + ***************************************************************************/ + +static ssize_t swrap_recv(int s, void *buf, size_t len, int flags) +{ + struct socket_info *si; + struct msghdr msg; + struct swrap_address saddr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + struct iovec tmp; + ssize_t ret; + int tret; + + si = find_socket_info(s); + if (si == NULL) { + return libc_recv(s, buf, len, flags); + } + + tmp.iov_base = buf; + tmp.iov_len = len; + + ZERO_STRUCT(msg); + msg.msg_name = &saddr.sa.s; /* optional address */ + msg.msg_namelen = saddr.sa_socklen; /* size of address */ + msg.msg_iov = &tmp; /* scatter/gather array */ + msg.msg_iovlen = 1; /* # elements in msg_iov */ +#ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL + msg.msg_control = NULL; /* ancillary data, see below */ + msg.msg_controllen = 0; /* ancillary data buffer len */ + msg.msg_flags = 0; /* flags on received message */ +#endif + + tret = swrap_recvmsg_before(s, si, &msg, &tmp); + if (tret < 0) { + return -1; + } + + buf = msg.msg_iov[0].iov_base; + len = msg.msg_iov[0].iov_len; + + ret = libc_recv(s, buf, len, flags); + + tret = swrap_recvmsg_after(s, si, &msg, NULL, 0, ret); + if (tret != 0) { + return tret; + } + + return ret; +} + +ssize_t recv(int s, void *buf, size_t len, int flags) +{ + return swrap_recv(s, buf, len, flags); +} + +/**************************************************************************** + * READ + ***************************************************************************/ + +static ssize_t swrap_read(int s, void *buf, size_t len) +{ + struct socket_info *si; + struct msghdr msg; + struct iovec tmp; + struct swrap_address saddr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + ssize_t ret; + int tret; + + si = find_socket_info(s); + if (si == NULL) { + return libc_read(s, buf, len); + } + + tmp.iov_base = buf; + tmp.iov_len = len; + + ZERO_STRUCT(msg); + msg.msg_name = &saddr.sa.ss; /* optional address */ + msg.msg_namelen = saddr.sa_socklen; /* size of address */ + msg.msg_iov = &tmp; /* scatter/gather array */ + msg.msg_iovlen = 1; /* # elements in msg_iov */ +#ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL + msg.msg_control = NULL; /* ancillary data, see below */ + msg.msg_controllen = 0; /* ancillary data buffer len */ + msg.msg_flags = 0; /* flags on received message */ +#endif + + tret = swrap_recvmsg_before(s, si, &msg, &tmp); + if (tret < 0) { + if (tret == -ENOTSOCK) { + return libc_read(s, buf, len); + } + return -1; + } + + buf = msg.msg_iov[0].iov_base; + len = msg.msg_iov[0].iov_len; + + ret = libc_read(s, buf, len); + + tret = swrap_recvmsg_after(s, si, &msg, NULL, 0, ret); + if (tret != 0) { + return tret; + } + + return ret; +} + +ssize_t read(int s, void *buf, size_t len) +{ + return swrap_read(s, buf, len); +} + +/**************************************************************************** + * WRITE + ***************************************************************************/ + +static ssize_t swrap_write(int s, const void *buf, size_t len) +{ + struct msghdr msg; + struct iovec tmp; + struct sockaddr_un un_addr; + ssize_t ret; + int rc; + struct socket_info *si; + + si = find_socket_info(s); + if (si == NULL) { + return libc_write(s, buf, len); + } + + tmp.iov_base = discard_const_p(char, buf); + tmp.iov_len = len; + + ZERO_STRUCT(msg); + msg.msg_name = NULL; /* optional address */ + msg.msg_namelen = 0; /* size of address */ + msg.msg_iov = &tmp; /* scatter/gather array */ + msg.msg_iovlen = 1; /* # elements in msg_iov */ +#if HAVE_STRUCT_MSGHDR_MSG_CONTROL + msg.msg_control = NULL; /* ancillary data, see below */ + msg.msg_controllen = 0; /* ancillary data buffer len */ + msg.msg_flags = 0; /* flags on received message */ +#endif + + rc = swrap_sendmsg_before(s, si, &msg, &tmp, &un_addr, NULL, NULL, NULL); + if (rc < 0) { + return -1; + } + + buf = msg.msg_iov[0].iov_base; + len = msg.msg_iov[0].iov_len; + + ret = libc_write(s, buf, len); + + swrap_sendmsg_after(s, si, &msg, NULL, ret); + + return ret; +} + +ssize_t write(int s, const void *buf, size_t len) +{ + return swrap_write(s, buf, len); +} + +/**************************************************************************** + * SEND + ***************************************************************************/ + +static ssize_t swrap_send(int s, const void *buf, size_t len, int flags) +{ + struct msghdr msg; + struct iovec tmp; + struct sockaddr_un un_addr; + ssize_t ret; + int rc; + struct socket_info *si = find_socket_info(s); + + if (!si) { + return libc_send(s, buf, len, flags); + } + + tmp.iov_base = discard_const_p(char, buf); + tmp.iov_len = len; + + ZERO_STRUCT(msg); + msg.msg_name = NULL; /* optional address */ + msg.msg_namelen = 0; /* size of address */ + msg.msg_iov = &tmp; /* scatter/gather array */ + msg.msg_iovlen = 1; /* # elements in msg_iov */ +#if HAVE_STRUCT_MSGHDR_MSG_CONTROL + msg.msg_control = NULL; /* ancillary data, see below */ + msg.msg_controllen = 0; /* ancillary data buffer len */ + msg.msg_flags = 0; /* flags on received message */ +#endif + + rc = swrap_sendmsg_before(s, si, &msg, &tmp, &un_addr, NULL, NULL, NULL); + if (rc < 0) { + return -1; + } + + buf = msg.msg_iov[0].iov_base; + len = msg.msg_iov[0].iov_len; + + ret = libc_send(s, buf, len, flags); + + swrap_sendmsg_after(s, si, &msg, NULL, ret); + + return ret; +} + +ssize_t send(int s, const void *buf, size_t len, int flags) +{ + return swrap_send(s, buf, len, flags); +} + +/**************************************************************************** + * RECVMSG + ***************************************************************************/ + +static ssize_t swrap_recvmsg(int s, struct msghdr *omsg, int flags) +{ + struct swrap_address from_addr = { + .sa_socklen = sizeof(struct sockaddr_un), + }; + struct swrap_address convert_addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + struct socket_info *si; + struct msghdr msg; + struct iovec tmp; +#ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL + size_t msg_ctrllen_filled; + size_t msg_ctrllen_left; +#endif + + ssize_t ret; + int rc; + + si = find_socket_info(s); + if (si == NULL) { + return libc_recvmsg(s, omsg, flags); + } + + tmp.iov_base = NULL; + tmp.iov_len = 0; + + ZERO_STRUCT(msg); + msg.msg_name = &from_addr.sa; /* optional address */ + msg.msg_namelen = from_addr.sa_socklen; /* size of address */ + msg.msg_iov = omsg->msg_iov; /* scatter/gather array */ + msg.msg_iovlen = omsg->msg_iovlen; /* # elements in msg_iov */ +#ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL + msg_ctrllen_filled = 0; + msg_ctrllen_left = omsg->msg_controllen; + + msg.msg_control = omsg->msg_control; /* ancillary data, see below */ + msg.msg_controllen = omsg->msg_controllen; /* ancillary data buffer len */ + msg.msg_flags = omsg->msg_flags; /* flags on received message */ +#endif + + rc = swrap_recvmsg_before(s, si, &msg, &tmp); + if (rc < 0) { + return -1; + } + + ret = libc_recvmsg(s, &msg, flags); + +#ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL + msg_ctrllen_filled += msg.msg_controllen; + msg_ctrllen_left -= msg.msg_controllen; + + if (omsg->msg_control != NULL) { + uint8_t *p; + + p = omsg->msg_control; + p += msg_ctrllen_filled; + + msg.msg_control = p; + msg.msg_controllen = msg_ctrllen_left; + } else { + msg.msg_control = NULL; + msg.msg_controllen = 0; + } +#endif + + /* + * We convert the unix address to a IP address so we need a buffer + * which can store the address in case of SOCK_DGRAM, see below. + */ + msg.msg_name = &convert_addr.sa; + msg.msg_namelen = convert_addr.sa_socklen; + + rc = swrap_recvmsg_after(s, + si, + &msg, + &from_addr.sa.un, + from_addr.sa_socklen, + ret); + if (rc != 0) { + return rc; + } + +#ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL + if (omsg->msg_control != NULL) { + /* msg.msg_controllen = space left */ + msg_ctrllen_left = msg.msg_controllen; + msg_ctrllen_filled = omsg->msg_controllen - msg_ctrllen_left; + } + + /* Update the original message length */ + omsg->msg_controllen = msg_ctrllen_filled; + omsg->msg_flags = msg.msg_flags; +#endif + omsg->msg_iovlen = msg.msg_iovlen; + + /* + * From the manpage: + * + * The msg_name field points to a caller-allocated buffer that is + * used to return the source address if the socket is unconnected. The + * caller should set msg_namelen to the size of this buffer before this + * call; upon return from a successful call, msg_name will contain the + * length of the returned address. If the application does not need + * to know the source address, msg_name can be specified as NULL. + */ + if (si->type == SOCK_STREAM) { + omsg->msg_namelen = 0; + } else if (omsg->msg_name != NULL && + omsg->msg_namelen != 0 && + omsg->msg_namelen >= msg.msg_namelen) { + memcpy(omsg->msg_name, msg.msg_name, msg.msg_namelen); + omsg->msg_namelen = msg.msg_namelen; + } + + return ret; +} + +ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags) +{ + return swrap_recvmsg(sockfd, msg, flags); +} + +/**************************************************************************** + * SENDMSG + ***************************************************************************/ + +static ssize_t swrap_sendmsg(int s, const struct msghdr *omsg, int flags) +{ + struct msghdr msg; + struct iovec tmp; + struct sockaddr_un un_addr; + const struct sockaddr_un *to_un = NULL; + const struct sockaddr *to = NULL; + ssize_t ret; + int rc; + struct socket_info *si = find_socket_info(s); + int bcast = 0; + + if (!si) { + return libc_sendmsg(s, omsg, flags); + } + + ZERO_STRUCT(un_addr); + + tmp.iov_base = NULL; + tmp.iov_len = 0; + + ZERO_STRUCT(msg); + + if (si->connected == 0) { + msg.msg_name = omsg->msg_name; /* optional address */ + msg.msg_namelen = omsg->msg_namelen; /* size of address */ + } + msg.msg_iov = omsg->msg_iov; /* scatter/gather array */ + msg.msg_iovlen = omsg->msg_iovlen; /* # elements in msg_iov */ +#ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL + if (msg.msg_controllen > 0 && msg.msg_control != NULL) { + /* omsg is a const so use a local buffer for modifications */ + uint8_t cmbuf[omsg->msg_controllen]; + + memcpy(cmbuf, omsg->msg_control, omsg->msg_controllen); + + msg.msg_control = cmbuf; /* ancillary data, see below */ + msg.msg_controllen = omsg->msg_controllen; /* ancillary data buffer len */ + } + msg.msg_flags = omsg->msg_flags; /* flags on received message */ +#endif + + rc = swrap_sendmsg_before(s, si, &msg, &tmp, &un_addr, &to_un, &to, &bcast); + if (rc < 0) { + return -1; + } + + if (bcast) { +// struct stat st; +// unsigned int iface; + unsigned int prt = ntohs(((const struct sockaddr_in *)(const void *)to)->sin_port); + char type; + size_t i, len = 0; + uint8_t *buf; + off_t ofs = 0; + size_t avail = 0; + size_t remain; + + unsigned int remote_prt; + unsigned int in4_addr; + DIR *d; + struct dirent *dir; + + + for (i = 0; i < (size_t)msg.msg_iovlen; i++) { + avail += msg.msg_iov[i].iov_len; + } + + len = avail; + remain = avail; + + /* we capture it as one single packet */ + buf = (uint8_t *)malloc(remain); + if (!buf) { + return -1; + } + + for (i = 0; i < (size_t)msg.msg_iovlen; i++) { + size_t this_time = MIN(remain, (size_t)msg.msg_iov[i].iov_len); + memcpy(buf + ofs, + msg.msg_iov[i].iov_base, + this_time); + ofs += this_time; + remain -= this_time; + } + + /* + type = SOCKET_TYPE_CHAR_UDP; + + for(iface=0; iface <= MAX_WRAPPED_INTERFACES; iface++) { + snprintf(un_addr.sun_path, sizeof(un_addr.sun_path), "%s/"SOCKET_FORMAT, + socket_wrapper_dir(), type, iface, prt); + if (stat(un_addr.sun_path, &st) != 0) continue; + + msg.msg_name = &un_addr; / * optional address * / + msg.msg_namelen = sizeof(un_addr); / * size of address * / + + / * ignore the any errors in broadcast sends * / + libc_sendmsg(s, &msg, flags); + } + */ + + + d = opendir(socket_wrapper_dir()); + if (d) { + while ((dir = readdir(d)) != NULL) { + if (dir->d_name[0] == SOCKET_TYPE_CHAR_UDP_LONG) + /* TODO - use S_ISSOCK ? */ + if (sscanf(dir->d_name, SOCKET_FORMAT_LONG, &type, &in4_addr, &remote_prt) == 3) + if (prt == remote_prt) { + snprintf(un_addr.sun_path, + sizeof(un_addr.sun_path), + "%s/%s", + socket_wrapper_dir(),dir->d_name); + libc_sendmsg(s, &msg, flags); + SWRAP_LOG(SWRAP_LOG_DEBUG,"send bcast packet to %s", dir->d_name); + } + } + closedir(d); + } + + swrap_pcap_dump_packet(si, to, SWRAP_SENDTO, buf, len); + free(buf); + + return len; + } + + ret = libc_sendmsg(s, &msg, flags); + + swrap_sendmsg_after(s, si, &msg, to, ret); + + return ret; +} + +ssize_t sendmsg(int s, const struct msghdr *omsg, int flags) +{ + return swrap_sendmsg(s, omsg, flags); +} + +/**************************************************************************** + * READV + ***************************************************************************/ + +static ssize_t swrap_readv(int s, const struct iovec *vector, int count) +{ + struct socket_info *si; + struct msghdr msg; + struct iovec tmp; + struct swrap_address saddr = { + .sa_socklen = sizeof(struct sockaddr_storage) + }; + ssize_t ret; + int rc; + + si = find_socket_info(s); + if (si == NULL) { + return libc_readv(s, vector, count); + } + + tmp.iov_base = NULL; + tmp.iov_len = 0; + + ZERO_STRUCT(msg); + msg.msg_name = &saddr.sa.s; /* optional address */ + msg.msg_namelen = saddr.sa_socklen; /* size of address */ + msg.msg_iov = discard_const_p(struct iovec, vector); /* scatter/gather array */ + msg.msg_iovlen = count; /* # elements in msg_iov */ +#ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL + msg.msg_control = NULL; /* ancillary data, see below */ + msg.msg_controllen = 0; /* ancillary data buffer len */ + msg.msg_flags = 0; /* flags on received message */ +#endif + + rc = swrap_recvmsg_before(s, si, &msg, &tmp); + if (rc < 0) { + if (rc == -ENOTSOCK) { + return libc_readv(s, vector, count); + } + return -1; + } + + ret = libc_readv(s, msg.msg_iov, msg.msg_iovlen); + + rc = swrap_recvmsg_after(s, si, &msg, NULL, 0, ret); + if (rc != 0) { + return rc; + } + + return ret; +} + +ssize_t readv(int s, const struct iovec *vector, int count) +{ + return swrap_readv(s, vector, count); +} + +/**************************************************************************** + * WRITEV + ***************************************************************************/ + +static ssize_t swrap_writev(int s, const struct iovec *vector, int count) +{ + struct msghdr msg; + struct iovec tmp; + struct sockaddr_un un_addr; + ssize_t ret; + int rc; + struct socket_info *si = find_socket_info(s); + + if (!si) { + return libc_writev(s, vector, count); + } + + tmp.iov_base = NULL; + tmp.iov_len = 0; + + ZERO_STRUCT(msg); + msg.msg_name = NULL; /* optional address */ + msg.msg_namelen = 0; /* size of address */ + msg.msg_iov = discard_const_p(struct iovec, vector); /* scatter/gather array */ + msg.msg_iovlen = count; /* # elements in msg_iov */ +#if HAVE_STRUCT_MSGHDR_MSG_CONTROL + msg.msg_control = NULL; /* ancillary data, see below */ + msg.msg_controllen = 0; /* ancillary data buffer len */ + msg.msg_flags = 0; /* flags on received message */ +#endif + + rc = swrap_sendmsg_before(s, si, &msg, &tmp, &un_addr, NULL, NULL, NULL); + if (rc < 0) { + if (rc == -ENOTSOCK) { + return libc_readv(s, vector, count); + } + return -1; + } + + ret = libc_writev(s, msg.msg_iov, msg.msg_iovlen); + + swrap_sendmsg_after(s, si, &msg, NULL, ret); + + return ret; +} + +ssize_t writev(int s, const struct iovec *vector, int count) +{ + return swrap_writev(s, vector, count); +} + +/**************************** + * CLOSE + ***************************/ + +static int swrap_close(int fd) +{ + struct socket_info *si = find_socket_info(fd); + struct socket_info_fd *fi; + int ret; + + if (!si) { + return libc_close(fd); + } + + for (fi = si->fds; fi; fi = fi->next) { + if (fi->fd == fd) { + SWRAP_DLIST_REMOVE(si->fds, fi); + free(fi); + break; + } + } + + if (si->fds) { + /* there are still references left */ + return libc_close(fd); + } + + SWRAP_DLIST_REMOVE(sockets, si); + + if (si->myname.sa_socklen > 0 && si->peername.sa_socklen > 0) { + swrap_pcap_dump_packet(si, NULL, SWRAP_CLOSE_SEND, NULL, 0); + } + + ret = libc_close(fd); + + if (si->myname.sa_socklen > 0 && si->peername.sa_socklen > 0) { + swrap_pcap_dump_packet(si, NULL, SWRAP_CLOSE_RECV, NULL, 0); + swrap_pcap_dump_packet(si, NULL, SWRAP_CLOSE_ACK, NULL, 0); + } + + if (si->un_addr.sun_path[0] != '\0') { + unlink(si->un_addr.sun_path); + } + free(si); + + return ret; +} + +int close(int fd) +{ + return swrap_close(fd); +} + +/**************************** + * DUP + ***************************/ + +static int swrap_dup(int fd) +{ + struct socket_info *si; + struct socket_info_fd *fi; + + si = find_socket_info(fd); + + if (!si) { + return libc_dup(fd); + } + + fi = (struct socket_info_fd *)calloc(1, sizeof(struct socket_info_fd)); + if (fi == NULL) { + errno = ENOMEM; + return -1; + } + + fi->fd = libc_dup(fd); + if (fi->fd == -1) { + int saved_errno = errno; + free(fi); + errno = saved_errno; + return -1; + } + + /* Make sure we don't have an entry for the fd */ + swrap_remove_stale(fi->fd); + + SWRAP_DLIST_ADD(si->fds, fi); + return fi->fd; +} + +int dup(int fd) +{ + return swrap_dup(fd); +} + +/**************************** + * DUP2 + ***************************/ + +static int swrap_dup2(int fd, int newfd) +{ + struct socket_info *si; + struct socket_info_fd *fi; + + si = find_socket_info(fd); + + if (!si) { + return libc_dup2(fd, newfd); + } + + if (find_socket_info(newfd)) { + /* dup2() does an implicit close of newfd, which we + * need to emulate */ + swrap_close(newfd); + } + + fi = (struct socket_info_fd *)calloc(1, sizeof(struct socket_info_fd)); + if (fi == NULL) { + errno = ENOMEM; + return -1; + } + + fi->fd = libc_dup2(fd, newfd); + if (fi->fd == -1) { + int saved_errno = errno; + free(fi); + errno = saved_errno; + return -1; + } + + /* Make sure we don't have an entry for the fd */ + swrap_remove_stale(fi->fd); + + SWRAP_DLIST_ADD(si->fds, fi); + return fi->fd; +} + +int dup2(int fd, int newfd) +{ + return swrap_dup2(fd, newfd); +} + +/**************************** + * FCNTL + ***************************/ + +static int swrap_vfcntl(int fd, int cmd, va_list va) +{ + struct socket_info_fd *fi; + struct socket_info *si; + int rc; + + si = find_socket_info(fd); + if (si == NULL) { + rc = libc_vfcntl(fd, cmd, va); + + return rc; + } + + switch (cmd) { + case F_DUPFD: + fi = (struct socket_info_fd *)calloc(1, sizeof(struct socket_info_fd)); + if (fi == NULL) { + errno = ENOMEM; + return -1; + } + + fi->fd = libc_vfcntl(fd, cmd, va); + if (fi->fd == -1) { + int saved_errno = errno; + free(fi); + errno = saved_errno; + return -1; + } + + /* Make sure we don't have an entry for the fd */ + swrap_remove_stale(fi->fd); + + SWRAP_DLIST_ADD(si->fds, fi); + + rc = fi->fd; + break; + default: + rc = libc_vfcntl(fd, cmd, va); + break; + } + + return rc; +} + +int fcntl(int fd, int cmd, ...) +{ + va_list va; + int rc; + + va_start(va, cmd); + + rc = swrap_vfcntl(fd, cmd, va); + + va_end(va); + + return rc; +} + +/**************************** + * EVENTFD + ***************************/ + +#ifdef HAVE_EVENTFD +static int swrap_eventfd(int count, int flags) +{ + int fd; + + fd = libc_eventfd(count, flags); + if (fd != -1) { + swrap_remove_stale(fd); + } + + return fd; +} + +#ifdef HAVE_EVENTFD_UNSIGNED_INT +int eventfd(unsigned int count, int flags) +#else +int eventfd(int count, int flags) +#endif +{ + return swrap_eventfd(count, flags); +} +#endif + +#ifdef HAVE_PLEDGE +int pledge(const char *promises, const char *paths[]) +{ + (void)promises; /* unused */ + (void)paths; /* unused */ + + return 0; +} +#endif /* HAVE_PLEDGE */ + +/**************************** + * DESTRUCTOR + ***************************/ + +/* + * This function is called when the library is unloaded and makes sure that + * sockets get closed and the unix file for the socket are unlinked. + */ +void swrap_destructor(void) +{ + struct socket_info *s = sockets; + + while (s != NULL) { + struct socket_info_fd *f = s->fds; + if (f != NULL) { + swrap_close(f->fd); + } + s = sockets; + } + + if (swrap.libc_handle != NULL) { + dlclose(swrap.libc_handle); + } + if (swrap.libsocket_handle) { + dlclose(swrap.libsocket_handle); + } +} diff --git a/tests/deckard/contrib/libswrap/tests/CMakeLists.txt b/tests/deckard/contrib/libswrap/tests/CMakeLists.txt new file mode 100644 index 0000000..aecf6b8 --- /dev/null +++ b/tests/deckard/contrib/libswrap/tests/CMakeLists.txt @@ -0,0 +1,57 @@ +project(tests C) + +include_directories( + ${CMAKE_BINARY_DIR} + ${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_SOURCE_DIR}/src + ${CMOCKA_INCLUDE_DIR} +) + +set(TORTURE_LIBRARY torture) + +# RFC862 echo server +add_executable(echo_srv echo_srv.c) +target_link_libraries(echo_srv ${SWRAP_REQUIRED_LIBRARIES}) + +add_library(${TORTURE_LIBRARY} STATIC torture.c) +target_link_libraries(${TORTURE_LIBRARY} + ${CMOCKA_LIBRARY} + ${SWRAP_REQUIRED_LIBRARIES}) + +set(SWRAP_TESTS + test_ioctl + test_tcp_listen + test_echo_tcp_socket + test_echo_tcp_connect + test_echo_tcp_bind + test_echo_tcp_socket_options + test_echo_tcp_sendmsg_recvmsg + test_echo_tcp_write_read + test_echo_tcp_writev_readv + test_echo_tcp_get_peer_sock_name + test_echo_udp_sendto_recvfrom + test_echo_udp_send_recv + test_echo_udp_sendmsg_recvmsg + test_swrap_unit) + +if (HAVE_STRUCT_MSGHDR_MSG_CONTROL) + set(SWRAP_TESTS ${SWRAP_TESTS} test_sendmsg_recvmsg_fd) +endif (HAVE_STRUCT_MSGHDR_MSG_CONTROL) + +foreach(_SWRAP_TEST ${SWRAP_TESTS}) + add_cmocka_test(${_SWRAP_TEST} ${_SWRAP_TEST}.c ${TORTURE_LIBRARY}) + + if (OSX) + set_property( + TEST + ${_SWRAP_TEST} + PROPERTY + ENVIRONMENT DYLD_FORCE_FLAT_NAMESPACE=1;DYLD_INSERT_LIBRARIES=${SOCKET_WRAPPER_LOCATION}) + else () + set_property( + TEST + ${_SWRAP_TEST} + PROPERTY + ENVIRONMENT LD_PRELOAD=${SOCKET_WRAPPER_LOCATION}) + endif() +endforeach() diff --git a/tests/deckard/contrib/libswrap/tests/README b/tests/deckard/contrib/libswrap/tests/README new file mode 100644 index 0000000..26bf1fb --- /dev/null +++ b/tests/deckard/contrib/libswrap/tests/README @@ -0,0 +1,9 @@ +In this directory you can find all socket_wrapper tests. All tests can also be +executed outside of the 'make test' environment and without socket_wrapper. + +This can be done with: + +TORTURE_SERVER_ADDRESS_IPV4="127.0.0.1" \ +TORTURE_SERVER_ADDRESS_IPV6="::1" \ +TORTURE_SERVER_PORT=7777 \ +./tests/test_echo_tcp_write_read diff --git a/tests/deckard/contrib/libswrap/tests/echo_srv.c b/tests/deckard/contrib/libswrap/tests/echo_srv.c new file mode 100644 index 0000000..5b784de --- /dev/null +++ b/tests/deckard/contrib/libswrap/tests/echo_srv.c @@ -0,0 +1,925 @@ +#include "config.h" + +#include <errno.h> + +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/stat.h> + +#include <arpa/inet.h> +#include <netinet/in.h> +#include <netdb.h> +#include <resolv.h> + +#include <fcntl.h> +#include <getopt.h> +#include <unistd.h> + +#include <string.h> +#include <stdio.h> +#include <stdlib.h> +#include <stdbool.h> + +#ifndef PIDFILE +#define PIDFILE "echo_srv.pid" +#endif /* PIDFILE */ + +#define ECHO_SRV_IPV4 "127.0.0.10" +/* socket wrapper IPv6 prefix fd00::5357:5fxx */ +#define ECHO_SRV_IPV6 "fd00::5357:5f0a" + +#define DFL_PORT 7 +#define BACKLOG 5 + +#ifndef BUFSIZE +#define BUFSIZE 0x400000 +#endif /* BUFSIZE */ + +#ifndef discard_const +#define discard_const(ptr) ((void *)((uintptr_t)(ptr))) +#endif + +#ifndef discard_const_p +#define discard_const_p(type, ptr) ((type *)discard_const(ptr)) +#endif + +#ifndef ZERO_STRUCT +#define ZERO_STRUCT(x) memset((char *)&(x), 0, sizeof(x)) +#endif + +struct torture_address { + socklen_t sa_socklen; + union { + struct sockaddr s; + struct sockaddr_in in; +#ifdef HAVE_IPV6 + struct sockaddr_in6 in6; +#endif + struct sockaddr_storage ss; + } sa; +}; + +struct echo_srv_opts { + int port; + int socktype; + bool daemon; + char *bind; + const char *pidfile; +}; + +#ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL + +#if defined(IP_PKTINFO) || defined(IP_RECVDSTADDR) || defined(IPV6_PKTINFO) +union pktinfo { +#ifdef HAVE_STRUCT_IN6_PKTINFO + struct in6_pktinfo pkt6; +#endif +#ifdef HAVE_STRUCT_IN_PKTINFO + struct in_pktinfo pkt4; +#elif defined(IP_RECVDSTADDR) + struct in_addr pkt4; +#endif + char c; +}; + +#define HAVE_UNION_PKTINFO 1 +#endif /* IP_PKTINFO || IP_RECVDSTADDR || IPV6_PKTINFO */ + +static const char *echo_server_address(int family) +{ + switch (family) { + case AF_INET: { + const char *ip4 = getenv("TORTURE_SERVER_ADDRESS_IPV4"); + + if (ip4 != NULL && ip4[0] != '\0') { + return ip4; + } + + return ECHO_SRV_IPV4; + } + case AF_INET6: { + const char *ip6 = getenv("TORTURE_SERVER_ADDRESS_IPV6"); + + if (ip6 != NULL && ip6[0] != '\0') { + return ip6; + } + + return ECHO_SRV_IPV6; + } + default: + return NULL; + } + + return NULL; +} +#endif /* HAVE_STRUCT_MSGHDR_MSG_CONTROL */ + +static void _assert_return_code(int rc, + int err, + const char * const file, + const int line) +{ + if (rc < 0) { + fprintf(stderr, "Fatal error: %s\n", strerror(err)); + fprintf(stderr, "%s:%d", file, line); + + abort(); + } +} +#define assert_return_code(rc, err) \ + _assert_return_code(rc, err, __FILE__, __LINE__) + + +static int pidfile(const char *path) +{ + int err; + int fd; + char pid_str[32] = { 0 }; + ssize_t nwritten; + size_t len; + + fd = open(path, O_RDONLY, 0644); + err = errno; + if (fd != -1) { + close(fd); + return EEXIST; + } else if (err != ENOENT) { + return err; + } + + fd = open(path, O_CREAT | O_WRONLY | O_EXCL, 0644); + err = errno; + if (fd == -1) { + return err; + } + + snprintf(pid_str, sizeof(pid_str) -1, "%u\n", (unsigned int) getpid()); + len = strlen(pid_str); + + nwritten = write(fd, pid_str, len); + close(fd); + if (nwritten != (ssize_t)len) { + return EIO; + } + + return 0; +} + +static int become_daemon(void) +{ + int ret; + pid_t child_pid; + int fd; + int i; + + if (getppid() == 1) { + return 0; + } + + child_pid = fork(); + if (child_pid == -1) { + ret = errno; + perror("fork"); + return ret; + } else if (child_pid > 0) { + exit(0); + } + + /* If a working directory was defined, go there */ +#ifdef WORKING_DIR + chdir(WORKING_DIR); +#endif + + ret = setsid(); + if (ret == -1) { + ret = errno; + perror("setsid"); + return ret; + } + + for (fd = getdtablesize(); fd >= 0; --fd) { + close(fd); + } + + for (i = 0; i < 3; i++) { + fd = open("/dev/null", O_RDWR, 0); + if (fd < 0) { + fd = open("/dev/null", O_WRONLY, 0); + } + if (fd < 0) { + ret = errno; + perror("Can't open /dev/null"); + return ret; + } + if (fd != i) { + perror("Didn't get correct fd"); + close(fd); + return EINVAL; + } + } + + umask(0177); + return 0; +} + +static void set_sock_pktinfo(int sock, int family) +{ + int sockopt = 1; + int option = 0; + int proto = 0; + int rc; + + switch(family) { + case AF_INET: + proto = IPPROTO_IP; +#ifdef IP_PKTINFO + option = IP_PKTINFO; +#elif IP_RECVDSTADDR + option = IP_RECVDSTADDR; +#else + return; +#endif /* IP_PKTINFO */ + break; +#ifdef HAVE_IPV6 +#ifdef IPV6_RECVPKTINFO + case AF_INET6: + proto = IPPROTO_IPV6; + option = IPV6_RECVPKTINFO; + break; +#endif /* IPV6_RECVPKTINFO */ +#endif /* HAVE_IPV6 */ + default: + return; + } + + rc = setsockopt(sock, proto, option, &sockopt, sizeof(sockopt)); + assert_return_code(rc, errno); +} + +/* Returns 0 on success, errno on failure. If successful, + * sock is a ready to use socket */ +static int setup_srv(struct echo_srv_opts *opts, int *_sock) +{ + struct addrinfo hints; + struct addrinfo *res, *ri; + char svc[6]; + int ret; + int sock; + + memset(&hints, 0, sizeof(hints)); + hints.ai_family = AF_UNSPEC; + hints.ai_socktype = opts->socktype; + hints.ai_flags = AI_PASSIVE; + + snprintf(svc, sizeof(svc), "%d", opts->port); + + ret = getaddrinfo(opts->bind, svc, &hints, &res); + if (ret != 0) { + return errno; + } + + for (ri = res; ri != NULL; ri = ri->ai_next) { + sock = socket(ri->ai_family, ri->ai_socktype, + ri->ai_protocol); + if (sock == -1) { + ret = errno; + freeaddrinfo(res); + perror("socket"); + return ret; + } + + if (ri->ai_socktype == SOCK_DGRAM) { + set_sock_pktinfo(sock, ri->ai_family); + } + + ret = bind(sock, ri->ai_addr, ri->ai_addrlen); + if (ret == 0) { + break; + } + + close(sock); + } + freeaddrinfo(res); + + if (ri == NULL) { + fprintf(stderr, "Could not bind\n"); + return EFAULT; + } + + if (opts->socktype == SOCK_STREAM) { + ret = listen(sock, BACKLOG); + if (ret == -1) { + ret = errno; + close(sock); + perror("listen"); + return ret; + } + } + + *_sock = sock; + return 0; +} + +static int socket_dup(int s) +{ + struct torture_address cli_addr1 = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + struct torture_address srv_addr1 = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + + struct torture_address cli_addr2 = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + struct torture_address srv_addr2 = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + + struct torture_address cli_addr3 = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + struct torture_address srv_addr3 = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + + int s2; + int rc; + + rc = getsockname(s, &srv_addr1.sa.s, &srv_addr1.sa_socklen); + if (rc == -1) { + perror("getsockname"); + return -1; + } + + rc = getpeername(s, &cli_addr1.sa.s, &cli_addr1.sa_socklen); + if (rc == -1) { + perror("getpeername"); + return -1; + } + + if (cli_addr1.sa.ss.ss_family != srv_addr1.sa.ss.ss_family) { + perror("client/server family mismatch"); + return -1; + } + + /* Test dup */ + s2 = dup(s); + if (s2 == -1) { + perror("dup"); + return -1; + } + close(s); + + rc = getsockname(s2, &srv_addr2.sa.s, &srv_addr2.sa_socklen); + if (rc == -1) { + perror("getsockname"); + close(s2); + return -1; + } + + rc = getpeername(s2, &cli_addr2.sa.s, &cli_addr2.sa_socklen); + if (rc == -1) { + perror("getpeername"); + close(s2); + return -1; + } + + if (cli_addr1.sa_socklen != cli_addr2.sa_socklen || + srv_addr1.sa_socklen != srv_addr2.sa_socklen) { + perror("length mismatch"); + close(s2); + return -1; + } + + switch(cli_addr1.sa.ss.ss_family) { + case AF_INET: { + rc = memcmp(&cli_addr1.sa.in, &cli_addr2.sa.in, sizeof(struct sockaddr_in)); + if (rc != 0) { + perror("client mismatch"); + } + + rc = memcmp(&srv_addr1.sa.in, &srv_addr2.sa.in, sizeof(struct sockaddr_in)); + if (rc != 0) { + perror("server mismatch"); + } + break; + } + case AF_INET6: { + rc = memcmp(&cli_addr1.sa.in6, &cli_addr2.sa.in6, sizeof(struct sockaddr_in6)); + if (rc != 0) { + perror("client mismatch"); + } + + rc = memcmp(&srv_addr1.sa.in6, &srv_addr2.sa.in6, sizeof(struct sockaddr_in6)); + if (rc != 0) { + perror("server mismatch"); + } + break; + } + default: + perror("family mismatch"); + close(s2); + return -1; + } + + /* Test dup2 */ + s = dup2(s2, s); + close(s2); + if (s == -1) { + perror("dup"); + return -1; + } + + rc = getsockname(s, &srv_addr3.sa.s, &srv_addr3.sa_socklen); + if (rc == -1) { + perror("getsockname"); + close(s); + return -1; + } + + rc = getpeername(s, &cli_addr3.sa.s, &cli_addr3.sa_socklen); + if (rc == -1) { + perror("getpeername"); + close(s); + return -1; + } + + if (cli_addr2.sa_socklen != cli_addr3.sa_socklen || + srv_addr2.sa_socklen != srv_addr3.sa_socklen) { + perror("length mismatch"); + close(s); + return -1; + } + + switch(cli_addr2.sa.ss.ss_family) { + case AF_INET: { + rc = memcmp(&cli_addr1.sa.in, &cli_addr2.sa.in, sizeof(struct sockaddr_in)); + if (rc != 0) { + perror("client mismatch"); + } + + rc = memcmp(&srv_addr1.sa.in, &srv_addr2.sa.in, sizeof(struct sockaddr_in)); + if (rc != 0) { + perror("server mismatch"); + } + break; + } + case AF_INET6: { + rc = memcmp(&cli_addr1.sa.in6, &cli_addr2.sa.in6, sizeof(struct sockaddr_in6)); + if (rc != 0) { + perror("client mismatch"); + } + + rc = memcmp(&srv_addr1.sa.in6, &srv_addr2.sa.in6, sizeof(struct sockaddr_in6)); + if (rc != 0) { + perror("server mismatch"); + } + break; + } + default: + perror("family mismatch"); + close(s); + return -1; + } + + return s; +} + +static void echo_tcp(int sock) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + + char buf[BUFSIZE]; + ssize_t bret; + + int client_sock = -1; + int s; + + s = accept(sock, &addr.sa.s, &addr.sa_socklen); + if (s == -1) { + perror("accept"); + goto done; + } + + client_sock = socket_dup(s); + if (client_sock == -1) { + perror("socket_dup"); + goto done; + } + + /* Start ping pong */ + while (1) { + bret = recv(client_sock, buf, BUFSIZE, 0); + if (bret == -1) { + perror("recv"); + goto done; + } else if (bret == 0) { + break; + } + + bret = send(client_sock, buf, bret, 0); + if (bret == -1) { + perror("send"); + goto done; + } + } + +done: + if (client_sock != -1) { + close(client_sock); + } +} + +static ssize_t echo_udp_recv_from_to(int sock, + void *buf, size_t buflen, int flags, + struct sockaddr *from, socklen_t *fromlen, + struct sockaddr *to, socklen_t *tolen) +{ + struct msghdr rmsg; + struct iovec riov; + ssize_t ret; + +#if defined(HAVE_STRUCT_MSGHDR_MSG_CONTROL) && defined(HAVE_UNION_PKTINFO) + size_t cmlen = CMSG_LEN(sizeof(union pktinfo)); + char cmsg[cmlen]; +#else + (void)to; /* unused */ + (void)tolen; /* unused */ +#endif /* HAVE_STRUCT_MSGHDR_MSG_CONTROL */ + + riov.iov_base = buf; + riov.iov_len = buflen; + + ZERO_STRUCT(rmsg); + + rmsg.msg_name = from; + rmsg.msg_namelen = *fromlen; + + rmsg.msg_iov = &riov; + rmsg.msg_iovlen = 1; + +#if defined(HAVE_STRUCT_MSGHDR_MSG_CONTROL) && defined(HAVE_UNION_PKTINFO) + memset(cmsg, 0, cmlen); + + rmsg.msg_control = cmsg; + rmsg.msg_controllen = cmlen; +#endif + + ret = recvmsg(sock, &rmsg, flags); + if (ret < 0) { + return ret; + } + *fromlen = rmsg.msg_namelen; + +#if defined(HAVE_STRUCT_MSGHDR_MSG_CONTROL) && defined(HAVE_UNION_PKTINFO) + if (rmsg.msg_controllen > 0) { + struct cmsghdr *cmsgptr; + + cmsgptr = CMSG_FIRSTHDR(&rmsg); + while (cmsgptr != NULL) { + const char *p; + +#if defined(IP_PKTINFO) && defined(HAVE_STRUCT_IN_PKTINFO) + if (cmsgptr->cmsg_level == IPPROTO_IP && + cmsgptr->cmsg_type == IP_PKTINFO) { + char ip[INET_ADDRSTRLEN] = { 0 }; + struct sockaddr_in *sinp = (struct sockaddr_in *)to; + struct in_pktinfo *pkt; + void *cmsg_cast_ptr = CMSG_DATA(cmsgptr); + + pkt = (struct in_pktinfo *)cmsg_cast_ptr; + + sinp->sin_family = AF_INET; + sinp->sin_addr = pkt->ipi_addr; + *tolen = sizeof(struct sockaddr_in); + + p = inet_ntop(AF_INET, &sinp->sin_addr, ip, sizeof(ip)); + if (p == 0) { + fprintf(stderr, "Failed to convert IP address"); + abort(); + } + + if (strcmp(ip, echo_server_address(AF_INET)) != 0) { + fprintf(stderr, "Wrong IP received"); + abort(); + } + } +#endif /* IP_PKTINFO */ +#ifdef IP_RECVDSTADDR + if (cmsgptr->cmsg_level == IPPROTO_IP && + cmsgptr->cmsg_type == IP_RECVDSTADDR) { + char ip[INET_ADDRSTRLEN] = { 0 }; + struct sockaddr_in *sinp = + (struct sockaddr_in *)(void *)to; + struct in_addr *addr; + void *cmsg_cast_ptr = CMSG_DATA(cmsgptr); + + addr = (struct in_addr *)cmsg_cast_ptr; + + sinp->sin_family = AF_INET; + sinp->sin_addr = *addr; + *tolen = sizeof(struct sockaddr_in); + + p = inet_ntop(AF_INET, &sinp->sin_addr, ip, sizeof(ip)); + if (p == 0) { + fprintf(stderr, "Failed to convert IP address"); + abort(); + } + + if (strcmp(ip, echo_server_address(AF_INET)) != 0) { + fprintf(stderr, "Wrong IP received"); + abort(); + } + } +#endif /* IP_RECVDSTADDR */ +#if defined(IPV6_PKTINFO) && defined(HAVE_STRUCT_IN6_PKTINFO) + if (cmsgptr->cmsg_level == IPPROTO_IPV6 && + cmsgptr->cmsg_type == IPV6_PKTINFO) { + char ip[INET6_ADDRSTRLEN] = { 0 }; + struct in6_pktinfo *pkt6; + struct sockaddr_in6 *sin6p = + (struct sockaddr_in6 *)(void *)to; + void *cmsg_cast_ptr = CMSG_DATA(cmsgptr); + + pkt6 = (struct in6_pktinfo *)cmsg_cast_ptr; + + sin6p->sin6_family = AF_INET6; + sin6p->sin6_addr = pkt6->ipi6_addr; + + p = inet_ntop(AF_INET6, &sin6p->sin6_addr, ip, sizeof(ip)); + if (p == 0) { + fprintf(stderr, "Failed to convert IP address"); + abort(); + } + + if (strcmp(ip, echo_server_address(AF_INET6)) != 0) { + fprintf(stderr, "Wrong IP received"); + abort(); + } + } +#endif /* IPV6_PKTINFO */ + cmsgptr = CMSG_NXTHDR(&rmsg, cmsgptr); + } + } else { + fprintf(stderr, "Failed to receive pktinfo"); + abort(); + } +#endif /* HAVE_STRUCT_MSGHDR_MSG_CONTROL && HAVE_UNION_PKTINFO */ + + return ret; +} + +static ssize_t echo_udp_send_to_from(int sock, + void *buf, size_t buflen, int flags, + struct sockaddr *to, socklen_t tolen, + struct sockaddr *from, socklen_t fromlen) +{ + struct msghdr msg; + struct iovec iov; + ssize_t ret; + +#if defined(HAVE_STRUCT_MSGHDR_MSG_CONTROL) && defined(HAVE_UNION_PKTINFO) + size_t clen = CMSG_SPACE(sizeof(union pktinfo)); + char cbuf[clen]; + struct cmsghdr *cmsgptr; +#else + (void)from; /* unused */ + (void)fromlen; /* unused */ +#endif /* HAVE_STRUCT_MSGHDR_MSG_CONTROL && HAVE_UNION_PKTINFO */ + + iov.iov_base = buf; + iov.iov_len = buflen; + + ZERO_STRUCT(msg); + + msg.msg_name = to; + msg.msg_namelen = tolen; + + msg.msg_iov = &iov; + msg.msg_iovlen = 1; + +#if defined(HAVE_STRUCT_MSGHDR_MSG_CONTROL) && defined(HAVE_UNION_PKTINFO) + memset(cbuf, 0, clen); + + msg.msg_control = cbuf; + msg.msg_controllen = clen; + + cmsgptr = CMSG_FIRSTHDR(&msg); + msg.msg_controllen = 0; + + switch (from->sa_family) { +#if defined(IP_PKTINFO) || defined(IP_SENDSRCADDR) + case AF_INET: { + void *cmsg_cast_ptr = CMSG_DATA(cmsgptr); +#ifdef IP_PKTINFO + struct in_pktinfo *p = (struct in_pktinfo *)cmsg_cast_ptr; +#elif defined(IP_SENDSRCADDR) + struct in_addr *p = (struct in_addr *)cmsg_cast_ptr; +#endif + const struct sockaddr_in *from4 = + (const struct sockaddr_in *)(const void *)from; + + if (fromlen != sizeof(struct sockaddr_in)) { + break; + } + + cmsgptr->cmsg_level = IPPROTO_IP; +#ifdef IP_PKTINFO + cmsgptr->cmsg_type = IP_PKTINFO; + p->ipi_spec_dst = from4->sin_addr; +#elif defined(IP_SENDSRCADDR) + cmsgptr->cmsg_type = IP_SENDSRCADDR; + *p = from4->sin_addr; +#endif + cmsgptr->cmsg_len = CMSG_LEN(sizeof(*p)); + + msg.msg_controllen = CMSG_SPACE(sizeof(*p)); + + break; + } +#endif /* IP_PKTINFO || IP_SENDSRCADDR */ +#ifdef IPV6_PKTINFO + case AF_INET6: { + void *cast_ptr = CMSG_DATA(cmsgptr); + struct in6_pktinfo *p = (struct in6_pktinfo *)cast_ptr; + const struct sockaddr_in6 *from6 = + (const struct sockaddr_in6 *)(const void *)from; + + if (fromlen != sizeof(struct sockaddr_in6)) { + break; + } + + cmsgptr->cmsg_level = IPPROTO_IPV6; + cmsgptr->cmsg_type = IPV6_PKTINFO; + cmsgptr->cmsg_len = CMSG_LEN(sizeof(struct in6_pktinfo)); + + p->ipi6_addr = from6->sin6_addr; + + msg.msg_controllen = CMSG_SPACE(sizeof(struct in6_pktinfo)); + + break; + } +#endif /* IPV6_PKTINFO */ + default: + break; + } +#endif /* HAVE_STRUCT_MSGHDR_MSG_CONTROL && HAVE_UNION_PKTINFO */ + + ret = sendmsg(sock, &msg, flags); + + return ret; +} + +static void echo_udp(int sock) +{ + struct torture_address saddr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + struct torture_address daddr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + ssize_t bret; + char buf[BUFSIZE]; + + while (1) { + bret = echo_udp_recv_from_to(sock, + buf, + BUFSIZE, + 0, + &saddr.sa.s, + &saddr.sa_socklen, + &daddr.sa.s, + &daddr.sa_socklen); + if (bret == -1) { + perror("recvfrom"); + continue; + } + + bret = echo_udp_send_to_from(sock, + buf, + bret, + 0, + &saddr.sa.s, + saddr.sa_socklen, + &daddr.sa.s, + daddr.sa_socklen); + if (bret == -1) { + perror("sendto"); + continue; + } + } +} + +static void echo(int sock, struct echo_srv_opts *opts) +{ + switch (opts->socktype) { + case SOCK_STREAM: + echo_tcp(sock); + return; + case SOCK_DGRAM: + echo_udp(sock); + return; + default: + fprintf(stderr, "Unsupported protocol\n"); + return; + } +} + +int main(int argc, char **argv) +{ + int ret; + int sock = -1; + struct echo_srv_opts opts; + int opt; + int optindex; + static struct option long_options[] = { + { discard_const_p(char, "tcp"), no_argument, 0, 't' }, + { discard_const_p(char, "udp"), no_argument, 0, 'u' }, + { discard_const_p(char, "bind-addr"), required_argument, 0, 'b' }, + { discard_const_p(char, "port"), required_argument, 0, 'p' }, + { discard_const_p(char, "daemon"), no_argument, 0, 'D' }, + { discard_const_p(char, "pid"), required_argument, 0, 0 }, + {0, 0, 0, 0 } + }; + + opts.port = DFL_PORT; + opts.socktype = SOCK_STREAM; + opts.bind = NULL; + opts.pidfile = PIDFILE; + opts.daemon = false; + + while ((opt = getopt_long(argc, argv, "Dutp:b:", + long_options, &optindex)) != -1) { + switch (opt) { + case 0: + if (optindex == 5) { + opts.pidfile = optarg; + } + break; + case 'p': + opts.port = atoi(optarg); + break; + case 'b': + opts.bind = optarg; + break; + case 'u': + opts.socktype = SOCK_DGRAM; + break; + case 't': + opts.socktype = SOCK_STREAM; + break; + case 'D': + opts.daemon = true; + break; + default: /* '?' */ + fprintf(stderr, "Usage: %s [-p port] [-u] [-t] [-b bind_addr] " \ + "[-D] [--pid pidfile]\n" + "-t makes the server listen on TCP\n" + "-u makes the server listen on UDP\n" + "-D tells the server to become a deamon and " \ + "write a PIDfile\n" + "The default port is 7, the default PIDfile is " \ + "echo_srv.pid in the current directory\n", + argv[0]); + ret = 1; + goto done; + } + } + + if (opts.daemon) { + ret = become_daemon(); + if (ret != 0) { + fprintf(stderr, "Cannot become daemon: %s\n", strerror(ret)); + goto done; + } + } + + ret = setup_srv(&opts, &sock); + if (ret != 0) { + fprintf(stderr, "Cannot setup server: %s\n", strerror(ret)); + goto done; + } + + if (opts.daemon && opts.pidfile != NULL) { + ret = pidfile(opts.pidfile); + if (ret != 0) { + fprintf(stderr, "Cannot create pidfile %s: %s\n", + opts.pidfile, strerror(ret)); + goto done; + } + } + + echo(sock, &opts); + close(sock); + + if (opts.daemon) { + unlink(opts.pidfile); + } + + ret = 0; +done: + return ret; +} diff --git a/tests/deckard/contrib/libswrap/tests/test_echo_tcp_bind.c b/tests/deckard/contrib/libswrap/tests/test_echo_tcp_bind.c new file mode 100644 index 0000000..cde7e3f --- /dev/null +++ b/tests/deckard/contrib/libswrap/tests/test_echo_tcp_bind.c @@ -0,0 +1,536 @@ +#include <stdarg.h> +#include <stddef.h> +#include <setjmp.h> +#include <cmocka.h> + +#include "config.h" +#include "torture.h" + +#include <errno.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/un.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> +#ifdef HAVE_RPC_RPC_H +#include <rpc/rpc.h> +#endif + +static int setup_echo_srv_tcp_ipv4(void **state) +{ + torture_setup_echo_srv_tcp_ipv4(state); + + return 0; +} + +static int setup_echo_srv_tcp_ipv6(void **state) +{ + torture_setup_echo_srv_tcp_ipv6(state); + + return 0; +} + +static int teardown(void **state) +{ + torture_teardown_echo_srv(state); + + return 0; +} + +static void test_bind_ipv4(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + struct torture_address addr_in = { + .sa_socklen = sizeof(struct sockaddr_in), + }; + struct torture_address addr_un = { + .sa_socklen = sizeof(struct sockaddr_un), + }; + int rc; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_return_code(s, errno); + + /* + * Test various cases with family AF_UNSPEC + */ + + /* UNSPEC, len == 1: EINVAL */ + + addr_in.sa.in = (struct sockaddr_in) { + .sin_family = AF_UNSPEC, + }; + rc = bind(s, &addr.sa.s, 1); + assert_int_equal(rc, -1); + assert_int_equal(errno, EINVAL); + + /* UNSPEC: EAFNOSUPPORT */ + + addr_in.sa.in = (struct sockaddr_in) { + .sin_family = AF_UNSPEC, + }; + rc = inet_pton(AF_INET, "127.0.0.20", &addr_in.sa.in.sin_addr); + assert_int_equal(rc, 1); + + rc = bind(s, &addr_in.sa.s, addr_in.sa_socklen); + assert_int_equal(rc, -1); + /* FreeBSD uses EADDRNOTAVAIL here ... */ + assert_true(errno == EAFNOSUPPORT || errno == EADDRNOTAVAIL); + + /* special case: AF_UNSPEC with INADDR_ANY: success mapped to AF_INET */ + + addr_in.sa.in = (struct sockaddr_in) { + .sin_family = AF_UNSPEC, + }; + assert_int_equal(addr_in.sa.in.sin_addr.s_addr, htonl(INADDR_ANY)); + + rc = bind(s, &addr_in.sa.s, addr_in.sa_socklen); + assert_return_code(rc, errno); + + close(s); + + s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_return_code(s, errno); + + /* + * Test various cases with family AF_UNIX + * all fail with EAFNOSUPPORT + */ + + addr.sa.ss = (struct sockaddr_storage) { + .ss_family = AF_UNIX, + }; + rc = bind(s, &addr.sa.s, addr.sa_socklen); + assert_int_equal(rc, -1); + assert_int_equal(errno, EAFNOSUPPORT); + + addr_in.sa.in = (struct sockaddr_in) { + .sin_family = AF_UNIX, + }; + rc = bind(s, &addr_in.sa.s, addr_in.sa_socklen); + assert_int_equal(rc, -1); + assert_int_equal(errno, EAFNOSUPPORT); + + addr_un.sa.un = (struct sockaddr_un) { + .sun_family = AF_UNIX, + }; + rc = bind(s, &addr_un.sa.s, addr_un.sa_socklen); + assert_int_equal(rc, -1); + assert_int_equal(errno, EAFNOSUPPORT); + +#ifdef HAVE_IPV6 + /* + * Test with family AF_INET6 - fail + */ + + addr_in.sa.in = (struct sockaddr_in) { + .sin_family = AF_INET6, + }; + rc = bind(s, &addr_in.sa.s, addr_in.sa_socklen); + assert_int_equal(rc, -1); + assert_int_equal(errno, EAFNOSUPPORT); +#endif + + /* + * Finally, success binding a new IPv4 address. + */ + addr_in = (struct torture_address) { + .sa_socklen = sizeof(struct sockaddr_un), + .sa.in = (struct sockaddr_in) { + .sin_family = AF_INET, + }, + }; + + rc = inet_pton(AF_INET, "127.0.0.20", &addr_in.sa.in.sin_addr); + assert_int_equal(rc, 1); + + rc = bind(s, &addr_in.sa.s, addr_in.sa_socklen); + assert_return_code(rc, errno); + + addr_in = (struct torture_address) { + .sa_socklen = sizeof(struct sockaddr_un), + .sa.in = (struct sockaddr_in) { + .sin_family = AF_INET, + .sin_port = htons(torture_server_port()), + }, + }; + + rc = inet_pton(AF_INET, + torture_server_address(AF_INET), + &addr_in.sa.in.sin_addr); + assert_int_equal(rc, 1); + + rc = connect(s, &addr_in.sa.s, addr_in.sa_socklen); + assert_return_code(rc, errno); + + close(s); +} + +#if 0 /* TODO */ +static void test_bind_ipv4_addr_in_use(void **state) +{ + struct sockaddr_in sin, sin2; + socklen_t slen = sizeof(struct sockaddr_in); + int rc; + int s, s2; + + (void) state; /* unused */ + + s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_return_code(s, errno); + + /* + * Try to bind to the same address as already bound by a + * different process. + */ + + /* Without specifying the port - success */ + + ZERO_STRUCT(sin); + sin.sin_family = AF_INET; + rc = inet_pton(AF_INET, torture_server_address(AF_INET), &sin.sin_addr); + assert_int_equal(rc, 1); + rc = bind(s, (struct sockaddr *)&sin, slen); + assert_return_code(rc, errno); + + close(s); + + s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_return_code(s, errno); + +#if 0 + /* specify the same port - fail with EADDRINUSE. */ + + /* Not supported by socket_wrapper yet. ==> TODO! */ + + ZERO_STRUCT(sin); + sin.sin_family = AF_INET, + sin.sin_port = htons(torture_server_port()); + rc = inet_pton(AF_INET, torture_server_address(AF_INET), &sin.sin_addr); + assert_int_equal(rc, 1); + + rc = bind(s, (struct sockaddr *)&sin, slen); + assert_int_equal(rc, -1); + assert_int_equal(errno, EADDRINUSE); +#endif + + /* + * Try double binding when the firs bind is with port == 0 + */ + + ZERO_STRUCT(sin); + sin.sin_family = AF_INET; + + rc = inet_pton(AF_INET, "127.0.0.20", &sin.sin_addr); + assert_int_equal(rc, 1); + + rc = bind(s, (struct sockaddr *)&sin, slen); + assert_return_code(rc, errno); + + /* + * Open a second socket locally and try to bind to the same address. + */ + + /* Succeeds with port == 0 */ + + s2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_return_code(s, errno); + + ZERO_STRUCT(sin2); + sin2.sin_family = AF_INET; + + rc = inet_pton(AF_INET, "127.0.0.20", &sin2.sin_addr); + assert_int_equal(rc, 1); + + rc = bind(s2, (struct sockaddr *)&sin2, slen); + assert_return_code(rc, errno); + + close(s2); + + /* second bind with port != 0 - succeeds */ + + s2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_return_code(s, errno); + + ZERO_STRUCT(sin2); + sin2.sin_family = AF_INET; + sin2.sin_port = htons(12345); + + rc = inet_pton(AF_INET, "127.0.0.20", &sin2.sin_addr); + assert_int_equal(rc, 1); + + rc = bind(s2, (struct sockaddr *)&sin2, slen); + assert_return_code(rc, errno); + + close(s2); + close(s); + + /* + * Try double binding when the first bind is with port != 0 + */ + + s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_return_code(s, errno); + + ZERO_STRUCT(sin); + sin.sin_family = AF_INET; + sin.sin_port = htons(12345); + + rc = inet_pton(AF_INET, "127.0.0.20", &sin.sin_addr); + assert_int_equal(rc, 1); + + rc = bind(s, (struct sockaddr *)&sin, slen); + assert_return_code(rc, errno); + + /* + * Open a second socket locally and try to bind to the same address. + */ + + /* Succeeds with port == 0 */ + + s2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_return_code(s, errno); + + ZERO_STRUCT(sin2); + sin2.sin_family = AF_INET; + + rc = inet_pton(AF_INET, "127.0.0.20", &sin2.sin_addr); + assert_int_equal(rc, 1); + + rc = bind(s2, (struct sockaddr *)&sin2, slen); + assert_return_code(rc, errno); + + close(s2); + + /* with same port as above - fail with EADDRINUSE */ + + s2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_return_code(s, errno); + + ZERO_STRUCT(sin2); + sin2.sin_family = AF_INET; + sin2.sin_port = htons(12345); + + rc = inet_pton(AF_INET, "127.0.0.20", &sin2.sin_addr); + assert_int_equal(rc, 1); + + rc = bind(s2, (struct sockaddr *)&sin2, slen); + assert_int_equal(rc, -1); + assert_int_equal(errno, EADDRINUSE); + + close(s); +} +#endif + +#ifdef HAVE_BINDRESVPORT +static void test_bindresvport_ipv4(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + int rc; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_return_code(s, errno); + + addr.sa.in.sin_family = AF_INET; + + rc = inet_pton(AF_INET, "127.0.0.20", &addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + rc = bindresvport(s, &addr.sa.in); + assert_return_code(rc, errno); + + addr = (struct torture_address) { + .sa_socklen = sizeof(struct sockaddr_storage), + .sa.in = (struct sockaddr_in) { + .sin_family = AF_INET, + .sin_port = htons(torture_server_port()), + }, + }; + + rc = inet_pton(AF_INET, + torture_server_address(AF_INET), + &addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + rc = connect(s, &addr.sa.s, addr.sa_socklen); + assert_return_code(rc, errno); + + close(s); +} + +static void test_bindresvport_ipv4_null(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in), + }; + int rc; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_return_code(s, errno); + + rc = bindresvport(s, NULL); + assert_return_code(rc, errno); + + addr.sa.in.sin_family = AF_INET; + addr.sa.in.sin_port = htons(torture_server_port()); + rc = inet_pton(AF_INET, torture_server_address(AF_INET), &addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + rc = connect(s, &addr.sa.s, addr.sa_socklen); + assert_return_code(rc, errno); + + close(s); +} +#endif /* HAVE_BINDRESVPORT */ + +#ifdef HAVE_IPV6 +static void test_bind_on_ipv6_sock(void **state) +{ + struct torture_address addr_in = { + .sa_socklen = sizeof(struct sockaddr_in), + }; + struct torture_address addr_un = { + .sa_socklen = sizeof(struct sockaddr_un), + }; + int rc; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP); + assert_return_code(s, errno); + + addr_un.sa.un.sun_family = AF_UNIX; + rc = bind(s, &addr_un.sa.s, addr_un.sa_socklen); + assert_int_equal(rc, -1); + /* FreeBSD uses EINVAL here... */ + assert_true(errno == EAFNOSUPPORT || errno == EINVAL); + + addr_in.sa.in.sin_family = AF_INET; + rc = bind(s, &addr_in.sa.s, addr_in.sa_socklen); + assert_int_equal(rc, -1); + assert_int_equal(errno, EINVAL); + + addr_in.sa.in = (struct sockaddr_in) { + .sin_family = AF_INET, + }; + + rc = inet_pton(AF_INET, "127.0.0.20", &addr_in.sa.in.sin_addr); + assert_int_equal(rc, 1); + + rc = bind(s, &addr_in.sa.s, addr_in.sa_socklen); + assert_int_equal(rc, -1); + assert_int_equal(errno, EINVAL); + + addr_in = (struct torture_address) { + .sa_socklen = sizeof(struct sockaddr_in6), + .sa.in = (struct sockaddr_in) { + .sin_family = AF_INET, + }, + }; + + rc = bind(s, &addr_in.sa.s, addr_in.sa_socklen); + assert_int_equal(rc, -1); + assert_int_equal(errno, EAFNOSUPPORT); + + close(s); +} + +#ifdef HAVE_BINDRESVPORT +static void test_bindresvport_on_ipv6_sock(void **state) +{ + struct sockaddr_in sin; + int rc; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP); + assert_return_code(s, errno); + + ZERO_STRUCT(sin); + sin.sin_family = AF_INET; + + rc = inet_pton(AF_INET, "127.0.0.20", &sin.sin_addr); + assert_int_equal(rc, 1); + + rc = bindresvport(s, &sin); + assert_int_equal(rc, -1); + assert_int_equal(errno, EINVAL); + + close(s); +} + +static void test_bindresvport_on_ipv6_sock_null(void **state) +{ + int rc; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP); + assert_return_code(s, errno); + + rc = bindresvport(s, NULL); + assert_return_code(rc, errno); + + close(s); +} +#endif /* HAVE_BINDRESVPORT */ +#endif /* HAVE_IPV6 */ + +int main(void) { + int rc; + + const struct CMUnitTest tcp_bind_tests[] = { + cmocka_unit_test_setup_teardown(test_bind_ipv4, + setup_echo_srv_tcp_ipv4, + teardown), +#if 0 /* TODO */ + cmocka_unit_test_setup_teardown(test_bind_ipv4_addr_in_use, + setup_echo_srv_tcp_ipv4, + teardown), +#endif +#ifdef HAVE_BINDRESVPORT + cmocka_unit_test_setup_teardown(test_bindresvport_ipv4, + setup_echo_srv_tcp_ipv4, + teardown), + cmocka_unit_test_setup_teardown(test_bindresvport_ipv4_null, + setup_echo_srv_tcp_ipv4, + teardown), +#endif /* HAVE_BINDRESVPORT */ +#ifdef HAVE_IPV6 + cmocka_unit_test_setup_teardown(test_bind_on_ipv6_sock, + setup_echo_srv_tcp_ipv6, + teardown), +#ifdef HAVE_BINDRESVPORT + cmocka_unit_test_setup_teardown(test_bindresvport_on_ipv6_sock, + setup_echo_srv_tcp_ipv6, + teardown), + cmocka_unit_test_setup_teardown(test_bindresvport_on_ipv6_sock_null, + setup_echo_srv_tcp_ipv6, + teardown), +#endif /* HAVE_BINDRESVPORT */ +#endif /* HAVE_IPV6 */ + }; + + rc = cmocka_run_group_tests(tcp_bind_tests, NULL, NULL); + + return rc; +} diff --git a/tests/deckard/contrib/libswrap/tests/test_echo_tcp_connect.c b/tests/deckard/contrib/libswrap/tests/test_echo_tcp_connect.c new file mode 100644 index 0000000..d2020c8 --- /dev/null +++ b/tests/deckard/contrib/libswrap/tests/test_echo_tcp_connect.c @@ -0,0 +1,101 @@ +#include <stdarg.h> +#include <stddef.h> +#include <setjmp.h> +#include <cmocka.h> + +#include "config.h" +#include "torture.h" + +#include <errno.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> + +static int setup_echo_srv_tcp_ipv4(void **state) +{ + torture_setup_echo_srv_tcp_ipv4(state); + + return 0; +} + +static int teardown(void **state) +{ + torture_teardown_echo_srv(state); + + return 0; +} + +static void test_connect_broadcast_ipv4(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in), + }; + int rc; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_int_not_equal(s, -1); + + addr.sa.in.sin_family = AF_INET; + addr.sa.in.sin_port = htons(torture_server_port()); + addr.sa.in.sin_addr.s_addr = INADDR_BROADCAST; + + /* We don't allow connect to broadcast addresses */ + rc = connect(s, &addr.sa.s, addr.sa_socklen); + assert_int_equal(rc, -1); + + close(s); +} + +#ifdef HAVE_IPV6 +static void test_connect_downgrade_ipv6(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in), + }; + int rc; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP); + assert_int_not_equal(s, -1); + + addr.sa.in.sin_family = AF_INET; + addr.sa.in.sin_port = htons(torture_server_port()); + + rc = inet_pton(addr.sa.in.sin_family, + torture_server_address(AF_INET), + &addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + /* Connect should downgrade to IPv4 and allow the connect */ + rc = connect(s, &addr.sa.s, addr.sa_socklen); + assert_int_equal(rc, 0); + + close(s); +} +#endif + +int main(void) { + int rc; + + const struct CMUnitTest tcp_connect_tests[] = { + cmocka_unit_test(test_connect_broadcast_ipv4), +#ifdef HAVE_IPV6 + cmocka_unit_test(test_connect_downgrade_ipv6), +#endif + }; + + rc = cmocka_run_group_tests(tcp_connect_tests, + setup_echo_srv_tcp_ipv4, + teardown); + + return rc; +} diff --git a/tests/deckard/contrib/libswrap/tests/test_echo_tcp_get_peer_sock_name.c b/tests/deckard/contrib/libswrap/tests/test_echo_tcp_get_peer_sock_name.c new file mode 100644 index 0000000..ac369dd --- /dev/null +++ b/tests/deckard/contrib/libswrap/tests/test_echo_tcp_get_peer_sock_name.c @@ -0,0 +1,476 @@ +#include <stdarg.h> +#include <stddef.h> +#include <setjmp.h> +#include <cmocka.h> + +#include "config.h" +#include "torture.h" + +#include <errno.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> + +static int setup_echo_srv_tcp_ipv4(void **state) +{ + torture_setup_echo_srv_tcp_ipv4(state); + setenv("SOCKET_WRAPPER_DEFAULT_IFACE", "20", 1); + + return 0; +} + +static int teardown(void **state) +{ + torture_teardown_echo_srv(state); + + return 0; +} + +static void _assert_sockaddr_equal(struct torture_address *addr, const char *a, + const char * const file, const int line) +{ + char ip[INET6_ADDRSTRLEN] = { 0 }; + const char *p; + + p = inet_ntop(addr->sa.ss.ss_family, + addr->sa.ss.ss_family == AF_INET6 ? + (void *)&addr->sa.in6.sin6_addr : + (void *)&addr->sa.in.sin_addr, + ip, + sizeof(ip)); + _assert_true(cast_ptr_to_largest_integral_type(p), + "inet_ntop: Failed to convert IP address", file, line); + + _assert_string_equal(ip, a, file, line); +} + +#define assert_sockaddr_equal(ss, a) \ + _assert_sockaddr_equal(ss, a, __FILE__, __LINE__) + +static void _assert_sockaddr_port_equal(struct torture_address *addr, + const char *a, + uint16_t port, + const char * const file, const int line) +{ + uint16_t n_port; + + _assert_sockaddr_equal(addr, a, file, line); + + switch(addr->sa.ss.ss_family) { + case AF_INET: + n_port = addr->sa.in.sin_port; + break; + case AF_INET6: + n_port = addr->sa.in6.sin6_port; + break; + default: + return; + } + + _assert_int_equal(ntohs(n_port), port, file, line); +} + +#define assert_sockaddr_port_equal(ss, a, prt) \ + _assert_sockaddr_port_equal(ss, a, prt, __FILE__, __LINE__) + +static void _assert_sockaddr_port_range_equal(struct torture_address *addr, + const char *a, + uint16_t min_port, uint16_t max_port, + const char * const file, const int line) +{ + uint16_t n_port; + + _assert_sockaddr_equal(addr, a, file, line); + + switch(addr->sa.ss.ss_family) { + case AF_INET: + n_port = addr->sa.in.sin_port; + break; + case AF_INET6: + n_port = addr->sa.in6.sin6_port; + break; + default: + return; + } + + _assert_in_range(ntohs(n_port), + min_port, + max_port, + file, + line); +} + +#define assert_sockaddr_port_range_equal(ss, a, min_prt, max_prt) \ + _assert_sockaddr_port_range_equal(ss, a, min_prt, max_prt, __FILE__, __LINE__) + +static void test_connect_getsockname_getpeername(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in), + }; + struct torture_address cli_addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + struct torture_address srv_addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + int rc; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_return_code(s, errno); + + /* Bind client address to wildcard address */ + addr.sa.in.sin_family = AF_INET; + + rc = inet_pton(AF_INET, "127.0.0.20", &addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + rc = bind(s, &addr.sa.s, addr.sa_socklen); + assert_return_code(rc, errno); + + rc = getsockname(s, &cli_addr.sa.s, &cli_addr.sa_socklen); + assert_return_code(rc, errno); + assert_sockaddr_port_range_equal(&cli_addr, "127.0.0.20", 1024, 65535); + + rc = getpeername(s, &addr.sa.s, &addr.sa_socklen); + assert_int_equal(rc, -1); + assert_int_equal(errno, ENOTCONN); + + /* connect */ + addr = (struct torture_address) { + .sa_socklen = sizeof(struct sockaddr_in), + .sa.in = (struct sockaddr_in) { + .sin_family = AF_INET, + .sin_port = htons(torture_server_port()), + }, + }; + rc = inet_pton(AF_INET, + torture_server_address(AF_INET), + &addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + /* Connect */ + rc = connect(s, &addr.sa.s, addr.sa_socklen); + assert_return_code(rc, errno); + + cli_addr = (struct torture_address) { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + + rc = getsockname(s, &cli_addr.sa.s, &cli_addr.sa_socklen); + assert_return_code(rc, errno); + assert_sockaddr_port_range_equal(&cli_addr, "127.0.0.20", 1024, 65535); + + srv_addr = (struct torture_address) { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + + rc = getpeername(s, &srv_addr.sa.s, &srv_addr.sa_socklen); + assert_return_code(rc, errno); + assert_sockaddr_port_equal(&srv_addr, "127.0.0.10", 7); + + close(s); +} + +static void test_connect_getsockname_getpeername_port(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in), + }; + struct torture_address cli_addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + struct torture_address srv_addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + int rc; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_return_code(s, errno); + + /* Bind client address to wildcard address */ + addr.sa.in.sin_family = AF_INET; + + rc = inet_pton(AF_INET, "127.0.0.20", &addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + addr.sa.in.sin_port = htons(12345); + + rc = bind(s, &addr.sa.s, addr.sa_socklen); + assert_return_code(rc, errno); + + rc = getsockname(s, &cli_addr.sa.s, &cli_addr.sa_socklen); + assert_return_code(rc, errno); + assert_sockaddr_port_equal(&cli_addr, "127.0.0.20", 12345); + + rc = getpeername(s, &srv_addr.sa.s, &srv_addr.sa_socklen); + assert_int_equal(rc, -1); + assert_int_equal(errno, ENOTCONN); + + /* connect */ + addr = (struct torture_address) { + .sa_socklen = sizeof(struct sockaddr_in), + .sa.in = (struct sockaddr_in) { + .sin_family = AF_INET, + .sin_port = htons(torture_server_port()), + }, + }; + + rc = inet_pton(AF_INET, + torture_server_address(AF_INET), + &addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + /* Connect */ + rc = connect(s, &addr.sa.s, addr.sa_socklen); + assert_return_code(rc, errno); + + cli_addr = (struct torture_address) { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + + rc = getsockname(s, &cli_addr.sa.s, &cli_addr.sa_socklen); + assert_return_code(rc, errno); + assert_sockaddr_port_equal(&cli_addr, "127.0.0.20", 12345); + + srv_addr = (struct torture_address) { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + + rc = getpeername(s, &srv_addr.sa.s, &srv_addr.sa_socklen); + assert_return_code(rc, errno); + assert_sockaddr_port_equal(&srv_addr, "127.0.0.10", 7); + + close(s); +} + +static void test_connect_getsockname_getpeername_any(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in), + }; + struct torture_address cli_addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + struct torture_address srv_addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + int rc; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_return_code(s, errno); + + /* Bind client address to wildcard address */ + addr.sa.in.sin_family = AF_INET; + addr.sa.in.sin_addr.s_addr = htonl(INADDR_ANY); + + rc = bind(s, &addr.sa.s, addr.sa_socklen); + assert_return_code(rc, errno); + + rc = getsockname(s, &cli_addr.sa.s, &cli_addr.sa_socklen); + assert_return_code(rc, errno); + assert_sockaddr_port_range_equal(&cli_addr, "0.0.0.0", 1024, 65535); + + rc = getpeername(s, &srv_addr.sa.s, &srv_addr.sa_socklen); + assert_int_equal(rc, -1); + assert_int_equal(errno, ENOTCONN); + + /* connect */ + addr.sa.in.sin_family = AF_INET; + addr.sa.in.sin_port = htons(torture_server_port()); + rc = inet_pton(AF_INET, + torture_server_address(AF_INET), + &addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + /* Connect */ + rc = connect(s, &addr.sa.s, addr.sa_socklen); + assert_return_code(rc, errno); + + cli_addr = (struct torture_address) { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + + rc = getsockname(s, &cli_addr.sa.s, &cli_addr.sa_socklen); + assert_return_code(rc, errno); + assert_sockaddr_port_range_equal(&cli_addr, "127.0.0.20", 1024, 65535); + + srv_addr = (struct torture_address) { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + + rc = getpeername(s, &srv_addr.sa.s, &srv_addr.sa_socklen); + assert_return_code(rc, errno); + assert_sockaddr_port_equal(&srv_addr, "127.0.0.10", 7); + + close(s); +} + +static void test_connect_getsockname_getpeername_any_port(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in), + }; + struct torture_address cli_addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + struct torture_address srv_addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + int rc; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_return_code(s, errno); + + /* Bind client address to wildcard address */ + addr.sa.in.sin_family = AF_INET; + addr.sa.in.sin_addr.s_addr = htonl(INADDR_ANY); + addr.sa.in.sin_port = htons(12345); + + rc = bind(s, &addr.sa.s, addr.sa_socklen); + assert_return_code(rc, errno); + + rc = getsockname(s, &cli_addr.sa.s, &cli_addr.sa_socklen); + assert_return_code(rc, errno); + assert_sockaddr_port_equal(&cli_addr, "0.0.0.0", 12345); + + rc = getpeername(s, &srv_addr.sa.s, &srv_addr.sa_socklen); + assert_int_equal(rc, -1); + assert_int_equal(errno, ENOTCONN); + + /* connect */ + addr.sa.in.sin_family = AF_INET; + addr.sa.in.sin_port = htons(torture_server_port()); + rc = inet_pton(AF_INET, + torture_server_address(AF_INET), + &addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + /* Connect */ + rc = connect(s, &addr.sa.s, addr.sa_socklen); + assert_return_code(rc, errno); + + cli_addr = (struct torture_address) { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + + rc = getsockname(s, &cli_addr.sa.s, &cli_addr.sa_socklen); + assert_return_code(rc, errno); + assert_sockaddr_port_equal(&cli_addr, "127.0.0.20", 12345); + + srv_addr = (struct torture_address) { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + + rc = getpeername(s, &srv_addr.sa.s, &srv_addr.sa_socklen); + assert_return_code(rc, errno); + assert_sockaddr_port_equal(&srv_addr, "127.0.0.10", 7); + + close(s); +} + +static void test_connect_getsockname_getpeername_len(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in), + }; + struct torture_address cli_addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + struct torture_address srv_addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + socklen_t tmp_len; + int rc; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_return_code(s, errno); + + /* connect */ + addr.sa.in.sin_family = AF_INET; + addr.sa.in.sin_port = htons(torture_server_port()); + rc = inet_pton(AF_INET, + torture_server_address(AF_INET), + &addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + /* Connect */ + rc = connect(s, &addr.sa.s, addr.sa_socklen); + assert_return_code(rc, errno); + + /* Check with len=0 */ + cli_addr.sa_socklen = 0; + rc = getsockname(s, &cli_addr.sa.s, &cli_addr.sa_socklen); + assert_return_code(rc, errno); + + srv_addr.sa_socklen = 0; + rc = getpeername(s, &srv_addr.sa.s, &srv_addr.sa_socklen); + assert_return_code(rc, errno); + + /* Check with len=too small */ + cli_addr = (struct torture_address) { + .sa_socklen = sizeof(struct sockaddr_in) - 2, + }; + + tmp_len = cli_addr.sa_socklen; + rc = getsockname(s, &cli_addr.sa.s, &cli_addr.sa_socklen); + assert_return_code(rc, errno); + assert_int_equal(tmp_len + 2, cli_addr.sa_socklen); + + srv_addr = (struct torture_address) { + .sa_socklen = sizeof(struct sockaddr_in) - 2, + }; + + tmp_len = srv_addr.sa_socklen; + rc = getpeername(s, &srv_addr.sa.s, &srv_addr.sa_socklen); + assert_return_code(rc, errno); + assert_int_equal(tmp_len + 2, srv_addr.sa_socklen); + + close(s); +} + +int main(void) { + int rc; + + const struct CMUnitTest sock_name_tests[] = { + cmocka_unit_test_setup_teardown(test_connect_getsockname_getpeername, + setup_echo_srv_tcp_ipv4, + teardown), + cmocka_unit_test_setup_teardown(test_connect_getsockname_getpeername_port, + setup_echo_srv_tcp_ipv4, + teardown), + cmocka_unit_test_setup_teardown(test_connect_getsockname_getpeername_any, + setup_echo_srv_tcp_ipv4, + teardown), + cmocka_unit_test_setup_teardown(test_connect_getsockname_getpeername_any_port, + setup_echo_srv_tcp_ipv4, + teardown), + cmocka_unit_test_setup_teardown(test_connect_getsockname_getpeername_len, + setup_echo_srv_tcp_ipv4, + teardown), + }; + + rc = cmocka_run_group_tests(sock_name_tests, + NULL, + NULL); + + return rc; +} diff --git a/tests/deckard/contrib/libswrap/tests/test_echo_tcp_sendmsg_recvmsg.c b/tests/deckard/contrib/libswrap/tests/test_echo_tcp_sendmsg_recvmsg.c new file mode 100644 index 0000000..4f7629e --- /dev/null +++ b/tests/deckard/contrib/libswrap/tests/test_echo_tcp_sendmsg_recvmsg.c @@ -0,0 +1,273 @@ +#include <stdarg.h> +#include <stddef.h> +#include <setjmp.h> +#include <cmocka.h> + +#include "config.h" +#include "torture.h" + +#include <errno.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> + +static int setup_echo_srv_tcp_ipv4(void **state) +{ + torture_setup_echo_srv_tcp_ipv4(state); + + return 0; +} + +#ifdef HAVE_IPV6 +static int setup_echo_srv_tcp_ipv6(void **state) +{ + torture_setup_echo_srv_tcp_ipv6(state); + + return 0; +} +#endif + +static int teardown(void **state) +{ + torture_teardown_echo_srv(state); + + return 0; +} + +static void test_sendmsg_recvmsg_ipv4(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + char send_buf[64] = {0}; + char recv_buf[64] = {0}; + ssize_t ret; + int rc; + int i; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_int_not_equal(s, -1); + + addr.sa.in.sin_family = AF_INET; + addr.sa.in.sin_port = htons(torture_server_port()); + + rc = inet_pton(AF_INET, + torture_server_address(AF_INET), + &addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + rc = connect(s, &addr.sa.s, addr.sa_socklen); + + for (i = 0; i < 10; i++) { + struct torture_address reply_addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + struct msghdr s_msg = { + .msg_namelen = 0, + }; + struct msghdr r_msg = { + .msg_namelen = 0, + }; + struct iovec s_iov; + struct iovec r_iov; + + snprintf(send_buf, sizeof(send_buf), "packet.%d", i); + + /* This should be ignored */ + rc = inet_pton(AF_INET, + "127.0.0.1", + &addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + s_msg.msg_name = &addr.sa.s; + s_msg.msg_namelen = addr.sa_socklen; + + s_iov.iov_base = send_buf; + s_iov.iov_len = sizeof(send_buf); + + s_msg.msg_iov = &s_iov; + s_msg.msg_iovlen = 1; + + ret = sendmsg(s, &s_msg, 0); + assert_int_not_equal(ret, -1); + + r_msg.msg_name = &reply_addr.sa.s; + r_msg.msg_namelen = reply_addr.sa_socklen; + + r_iov.iov_base = recv_buf; + r_iov.iov_len = sizeof(recv_buf); + + r_msg.msg_iov = &r_iov; + r_msg.msg_iovlen = 1; + + ret = recvmsg(s, &r_msg, 0); + assert_int_not_equal(ret, -1); + + assert_int_equal(r_msg.msg_namelen, 0); + + assert_memory_equal(send_buf, recv_buf, sizeof(send_buf)); + } + + close(s); +} + +#ifdef HAVE_IPV6 +static void test_sendmsg_recvmsg_ipv6(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + char send_buf[64] = {0}; + char recv_buf[64] = {0}; + ssize_t ret; + int rc; + int i; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP); + assert_int_not_equal(s, -1); + + addr.sa.in.sin_family = AF_INET6; + addr.sa.in.sin_port = htons(torture_server_port()); + + rc = inet_pton(AF_INET6, + torture_server_address(AF_INET6), + &addr.sa.in6.sin6_addr); + assert_int_equal(rc, 1); + + rc = connect(s, &addr.sa.s, addr.sa_socklen); + + for (i = 0; i < 10; i++) { + struct torture_address reply_addr = { + .sa_socklen = sizeof(struct sockaddr_in), + }; + struct msghdr s_msg = { + .msg_namelen = 0, + }; + struct msghdr r_msg = { + .msg_namelen = 0, + }; + struct iovec s_iov; + struct iovec r_iov; + + snprintf(send_buf, sizeof(send_buf), "packet.%d", i); + + s_iov.iov_base = send_buf; + s_iov.iov_len = sizeof(send_buf); + + s_msg.msg_iov = &s_iov; + s_msg.msg_iovlen = 1; + + ret = sendmsg(s, &s_msg, 0); + assert_int_not_equal(ret, -1); + + r_msg.msg_name = &reply_addr.sa.s; + r_msg.msg_namelen = reply_addr.sa_socklen; + + r_iov.iov_base = recv_buf; + r_iov.iov_len = sizeof(recv_buf); + + r_msg.msg_iov = &r_iov; + r_msg.msg_iovlen = 1; + + ret = recvmsg(s, &r_msg, 0); + assert_int_not_equal(ret, -1); + + assert_int_equal(r_msg.msg_namelen, 0); + + assert_memory_equal(send_buf, recv_buf, sizeof(send_buf)); + } + + close(s); +} +#endif + +static void test_sendmsg_recvmsg_ipv4_null(void **state) +{ + struct torture_address send_addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + struct msghdr s_msg = { + .msg_namelen = 0, + }; + struct msghdr r_msg = { + .msg_namelen = 0, + }; + struct iovec iov; + char payload[] = "PACKET"; + ssize_t ret; + int rc; + int s; + + (void)state; /* unused */ + + s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_int_not_equal(s, -1); + + send_addr.sa.in.sin_family = AF_INET; + send_addr.sa.in.sin_port = htons(torture_server_port()); + + rc = inet_pton(AF_INET, + torture_server_address(AF_INET), + &send_addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + rc = connect(s, &send_addr.sa.s, send_addr.sa_socklen); + + /* msg_name = NULL */ + + iov.iov_base = (void *)payload; + iov.iov_len = sizeof(payload); + + s_msg.msg_iov = &iov; + s_msg.msg_iovlen = 1; + + ret = sendmsg(s, &s_msg, 0); + assert_int_not_equal(ret, -1); + + /* msg_name = NULL */ + + memset(payload, 0, sizeof(payload)); + + r_msg.msg_iov = &iov; + r_msg.msg_iovlen = 1; + + ret = recvmsg(s, &r_msg, 0); + assert_int_not_equal(ret, -1); + + assert_int_equal(r_msg.msg_namelen, 0); + assert_null(r_msg.msg_name); + + close(s); +} + +int main(void) { + int rc; + + const struct CMUnitTest sendmsg_tests[] = { + cmocka_unit_test_setup_teardown(test_sendmsg_recvmsg_ipv4, + setup_echo_srv_tcp_ipv4, + teardown), + cmocka_unit_test_setup_teardown(test_sendmsg_recvmsg_ipv4_null, + setup_echo_srv_tcp_ipv4, + teardown), +#ifdef HAVE_IPV6 + cmocka_unit_test_setup_teardown(test_sendmsg_recvmsg_ipv6, + setup_echo_srv_tcp_ipv6, + teardown), +#endif + }; + + rc = cmocka_run_group_tests(sendmsg_tests, NULL, NULL); + + return rc; +} diff --git a/tests/deckard/contrib/libswrap/tests/test_echo_tcp_socket.c b/tests/deckard/contrib/libswrap/tests/test_echo_tcp_socket.c new file mode 100644 index 0000000..57b92de --- /dev/null +++ b/tests/deckard/contrib/libswrap/tests/test_echo_tcp_socket.c @@ -0,0 +1,69 @@ +#include <stdarg.h> +#include <stddef.h> +#include <setjmp.h> +#include <cmocka.h> + +#include "config.h" +#include "torture.h" + +#include <errno.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> + +static void test_socket_getsockname(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in), + }; + int rc; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_int_not_equal(s, -1); + + rc = getsockname(s, &addr.sa.s, &addr.sa_socklen); + assert_return_code(rc, errno); + assert_int_equal(addr.sa.in.sin_family, AF_INET); +} + +#ifdef HAVE_IPV6 +static void test_socket_getsockname6(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in), + }; + int rc; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP); + assert_int_not_equal(s, -1); + + rc = getsockname(s, &addr.sa.s, &addr.sa_socklen); + assert_return_code(rc, errno); + assert_int_equal(addr.sa.in6.sin6_family, AF_INET6); +} +#endif + +int main(void) { + int rc; + + const struct CMUnitTest getsockname_tests[] = { + cmocka_unit_test(test_socket_getsockname), +#ifdef HAVE_IPV6 + cmocka_unit_test(test_socket_getsockname6), +#endif + }; + + rc = cmocka_run_group_tests(getsockname_tests, NULL, NULL); + + return rc; +} diff --git a/tests/deckard/contrib/libswrap/tests/test_echo_tcp_socket_options.c b/tests/deckard/contrib/libswrap/tests/test_echo_tcp_socket_options.c new file mode 100644 index 0000000..dfa46fe --- /dev/null +++ b/tests/deckard/contrib/libswrap/tests/test_echo_tcp_socket_options.c @@ -0,0 +1,368 @@ +#include <stdarg.h> +#include <stddef.h> +#include <setjmp.h> +#include <cmocka.h> + +#include "config.h" +#include "torture.h" + +#include <errno.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <netinet/tcp.h> +#include <arpa/inet.h> +#include <netdb.h> +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> + +#ifndef ZERO_STRUCT +#define ZERO_STRUCT(x) memset((char *)&(x), 0, sizeof(x)) +#endif + +static int setup_echo_srv_tcp_ipv4(void **state) +{ + torture_setup_echo_srv_tcp_ipv4(state); + + return 0; +} + +#ifdef HAVE_IPV6 +static int setup_echo_srv_tcp_ipv6(void **state) +{ + torture_setup_echo_srv_tcp_ipv6(state); + + return 0; +} + +static int setup_ipv6(void **state) +{ + torture_setup_socket_dir(state); + + return 0; +} +#endif + +static int teardown(void **state) +{ + torture_teardown_echo_srv(state); + + return 0; +} + +static void test_sockopt_sndbuf(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in), + }; + int obufsize = 0; + socklen_t olen = sizeof(obufsize); + int gbufsize = 0; + socklen_t glen = sizeof(gbufsize); + int sbufsize = 0; + int rc; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_int_not_equal(s, -1); + + addr.sa.in.sin_family = AF_INET; + addr.sa.in.sin_port = htons(torture_server_port()); + + rc = inet_pton(addr.sa.in.sin_family, + torture_server_address(AF_INET), + &addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + rc = connect(s, &addr.sa.s, addr.sa_socklen); + assert_int_equal(rc, 0); + + rc = getsockopt(s, SOL_SOCKET, SO_SNDBUF, &obufsize, &olen); + assert_int_equal(rc, 0); + + /* request 4k, on Linux the kernel doubles the value */ + sbufsize = 4096; + rc = setsockopt(s, SOL_SOCKET, SO_SNDBUF, &sbufsize, sizeof(sbufsize)); + assert_int_equal(rc, 0); + + rc = getsockopt(s, SOL_SOCKET, SO_SNDBUF, &gbufsize, &glen); + assert_int_equal(rc, 0); + + assert_true(sbufsize == gbufsize || sbufsize == gbufsize/2); + + close(s); +} + +#ifndef SO_PROTOCOL +# ifdef SO_PROTOTYPE /* The Solaris name */ +# define SO_PROTOCOL SO_PROTOTYPE +# endif /* SO_PROTOTYPE */ +#endif /* SO_PROTOCOL */ + +static void test_sockopt_so(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in), + }; + socklen_t so_len; +#ifdef SO_DOMAIN + int so_domain = -1; +#endif /* SO_DOMAIN */ +#ifdef SO_PROTOCOL + int so_protocol = -1; + int so_type = -1; +#endif /* SO_PROTOCOL */ + int rc; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_int_not_equal(s, -1); + + addr.sa.in.sin_family = AF_INET; + addr.sa.in.sin_port = htons(torture_server_port()); + + rc = inet_pton(addr.sa.in.sin_family, + torture_server_address(AF_INET), + &addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + rc = connect(s, &addr.sa.s, addr.sa_socklen); + assert_int_equal(rc, 0); + +#ifdef SO_DOMAIN + so_len = sizeof(so_domain); + rc = getsockopt(s, + SOL_SOCKET, + SO_DOMAIN, + &so_domain, + &so_len); + assert_return_code(rc, errno); + assert_int_equal(so_domain, AF_INET); + assert_int_equal(so_len, sizeof(int)); +#endif /* SO_DOMAIN */ + +#ifdef SO_PROTOCOL + so_len = sizeof(so_protocol); + rc = getsockopt(s, + SOL_SOCKET, + SO_PROTOCOL, + &so_protocol, + &so_len); + assert_return_code(rc, errno); + assert_int_equal(so_protocol, IPPROTO_TCP); + assert_int_equal(so_len, sizeof(int)); + + so_len = sizeof(so_type); + rc = getsockopt(s, + SOL_SOCKET, + SO_TYPE, + &so_type, + &so_len); + assert_return_code(rc, errno); + assert_int_equal(so_type, SOCK_STREAM); + assert_int_equal(so_len, sizeof(int)); +#endif /* SO_PROTOCOL */ + + close(s); +} + +#ifdef HAVE_IPV6 +static void test_sockopt_so6(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in), + }; +#ifdef SO_DOMAIN + int so_domain = -1; +#endif /* SO_DOMAIN */ +#ifdef SO_PROTOCOL + socklen_t so_len; + int so_protocol = -1; + int so_type = -1; +#endif /* SO_PROTOCOL */ + int rc; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP); + assert_int_not_equal(s, -1); + + addr.sa.in6.sin6_family = AF_INET6; + addr.sa.in6.sin6_port = htons(torture_server_port()); + + rc = inet_pton(addr.sa.in6.sin6_family, + torture_server_address(AF_INET6), + &addr.sa.in6.sin6_addr); + assert_int_equal(rc, 1); + + rc = connect(s, &addr.sa.s, addr.sa_socklen); + assert_int_equal(rc, 0); + +#ifdef SO_DOMAIN + so_len = sizeof(so_domain); + rc = getsockopt(s, + SOL_SOCKET, + SO_DOMAIN, + &so_domain, + &so_len); + assert_return_code(rc, errno); + assert_int_equal(so_domain, AF_INET6); + assert_int_equal(so_len, sizeof(int)); +#endif /* SO_DOMAIN */ + +#ifdef SO_PROTOCOL + so_len = sizeof(so_protocol); + rc = getsockopt(s, + SOL_SOCKET, + SO_PROTOCOL, + &so_protocol, + &so_len); + assert_return_code(rc, errno); + assert_int_equal(so_protocol, IPPROTO_TCP); + assert_int_equal(so_len, sizeof(int)); + + so_len = sizeof(so_type); + rc = getsockopt(s, + SOL_SOCKET, + SO_TYPE, + &so_type, + &so_len); + assert_return_code(rc, errno); + assert_int_equal(so_type, SOCK_STREAM); + assert_int_equal(so_len, sizeof(int)); +#endif /* SO_PROTOCOL */ + + close(s); +} + +static void test_bind_ipv6_only(void **state) +{ + struct addrinfo hints; + struct addrinfo *res, *ri; + char svc[] = "7777"; + int rc; + int s; + + (void) state; /* unused */ + + ZERO_STRUCT(hints); + hints.ai_family = AF_UNSPEC; + hints.ai_socktype = SOCK_STREAM; + hints.ai_flags = AI_PASSIVE; + + rc = getaddrinfo(torture_server_address(AF_INET6), svc, &hints, &res); + assert_int_equal(rc, 0); + + for (ri = res; ri != NULL; ri = ri->ai_next) { + int one = 1; + + s = socket(ri->ai_family, + ri->ai_socktype, + ri->ai_protocol); + assert_int_not_equal(rc, -1); + + rc = setsockopt(s, + IPPROTO_IPV6, + IPV6_V6ONLY, + (const void *)&one, + sizeof(one)); + switch(ri->ai_family) { + case AF_INET: + assert_int_equal(rc, -1); + + break; + case AF_INET6: + assert_int_equal(rc, 0); + + rc = bind(s, ri->ai_addr, ri->ai_addrlen); + assert_int_equal(rc, 0); + + break; + default: + break; + } + + close(s); + } + freeaddrinfo(res); +} +#endif + +static void test_sockopt_tcp(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in), + }; + int opt = -1; + socklen_t optlen = sizeof(int); + int rc; + + int s; + + (void) state; /* unused */ + + s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_int_not_equal(s, -1); + + addr.sa.in.sin_family = AF_INET; + addr.sa.in.sin_port = htons(torture_server_port()); + + rc = inet_pton(addr.sa.in.sin_family, + torture_server_address(AF_INET), + &addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + rc = connect(s, &addr.sa.s, addr.sa_socklen); + assert_int_equal(rc, 0); + + rc = getsockopt(s, IPPROTO_TCP, TCP_NODELAY, &opt, &optlen); + assert_return_code(rc, errno); + assert_int_equal(opt, 0); + + opt = 1; /* Turn on TCP_NODELAY */ + optlen = sizeof(int); + rc = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, &opt, optlen); + assert_return_code(rc, errno); + + opt = -1; + optlen = sizeof(int); + rc = getsockopt(s, IPPROTO_TCP, TCP_NODELAY, &opt, &optlen); + assert_return_code(rc, errno); + assert_int_equal(opt, 1); + + close(s); +} + +int main(void) { + int rc; + + const struct CMUnitTest sockopt_tests[] = { + cmocka_unit_test_setup_teardown(test_sockopt_sndbuf, + setup_echo_srv_tcp_ipv4, + teardown), + cmocka_unit_test_setup_teardown(test_sockopt_so, + setup_echo_srv_tcp_ipv4, + teardown), +#ifdef HAVE_IPV6 + cmocka_unit_test_setup_teardown(test_sockopt_so6, + setup_echo_srv_tcp_ipv6, + teardown), + cmocka_unit_test_setup_teardown(test_bind_ipv6_only, + setup_ipv6, + teardown), +#endif + cmocka_unit_test_setup_teardown(test_sockopt_tcp, + setup_echo_srv_tcp_ipv4, + teardown), + }; + + rc = cmocka_run_group_tests(sockopt_tests, NULL, NULL); + + return rc; +} diff --git a/tests/deckard/contrib/libswrap/tests/test_echo_tcp_write_read.c b/tests/deckard/contrib/libswrap/tests/test_echo_tcp_write_read.c new file mode 100644 index 0000000..9129022 --- /dev/null +++ b/tests/deckard/contrib/libswrap/tests/test_echo_tcp_write_read.c @@ -0,0 +1,156 @@ +#include <stdarg.h> +#include <stddef.h> +#include <setjmp.h> +#include <cmocka.h> + +#include "config.h" +#include "torture.h" + +#include <errno.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> + +static int setup_echo_srv_tcp_ipv4(void **state) +{ + torture_setup_echo_srv_tcp_ipv4(state); + + return 0; +} + +#ifdef HAVE_IPV6 +static int setup_echo_srv_tcp_ipv6(void **state) +{ + torture_setup_echo_srv_tcp_ipv6(state); + + return 0; +} +#endif + +static int teardown(void **state) +{ + torture_teardown_echo_srv(state); + + return 0; +} + +static void test_write_read_ipv4(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in), + }; + ssize_t ret; + int rc; + int i; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_int_not_equal(s, -1); + + addr.sa.in.sin_family = AF_INET; + addr.sa.in.sin_port = htons(torture_server_port()); + + rc = inet_pton(addr.sa.in.sin_family, + torture_server_address(AF_INET), + &addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + rc = connect(s, &addr.sa.s, addr.sa_socklen); + assert_int_equal(rc, 0); + + for (i = 0; i < 10; i++) { + char send_buf[64] = {0}; + char recv_buf[64] = {0}; + + snprintf(send_buf, sizeof(send_buf), "packet.%d", i); + + ret = write(s, + send_buf, + sizeof(send_buf)); + assert_int_not_equal(ret, -1); + + ret = read(s, + recv_buf, + sizeof(recv_buf)); + assert_int_not_equal(ret, -1); + + assert_memory_equal(send_buf, recv_buf, sizeof(send_buf)); + } + + close(s); +} + +#ifdef HAVE_IPV6 +static void test_write_read_ipv6(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in6), + }; + ssize_t ret; + int rc; + int i; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP); + assert_int_not_equal(s, -1); + + addr.sa.in6.sin6_family = AF_INET6; + addr.sa.in6.sin6_port = htons(torture_server_port()); + + rc = inet_pton(AF_INET6, + torture_server_address(AF_INET6), + &addr.sa.in6.sin6_addr); + assert_int_equal(rc, 1); + + rc = connect(s, &addr.sa.s, addr.sa_socklen); + assert_int_equal(rc, 0); + + for (i = 0; i < 10; i++) { + char send_buf[64] = {0}; + char recv_buf[64] = {0}; + + snprintf(send_buf, sizeof(send_buf), "packet.%d", i); + + ret = write(s, + send_buf, + sizeof(send_buf)); + assert_int_not_equal(ret, -1); + + ret = read(s, + recv_buf, + sizeof(recv_buf)); + assert_int_not_equal(ret, -1); + + assert_memory_equal(send_buf, recv_buf, sizeof(send_buf)); + } + + close(s); +} +#endif + +int main(void) { + int rc; + + const struct CMUnitTest tcp_write_tests[] = { + cmocka_unit_test_setup_teardown(test_write_read_ipv4, + setup_echo_srv_tcp_ipv4, + teardown), +#ifdef HAVE_IPV6 + cmocka_unit_test_setup_teardown(test_write_read_ipv6, + setup_echo_srv_tcp_ipv6, + teardown), +#endif + }; + + rc = cmocka_run_group_tests(tcp_write_tests, NULL, NULL); + + return rc; +} diff --git a/tests/deckard/contrib/libswrap/tests/test_echo_tcp_writev_readv.c b/tests/deckard/contrib/libswrap/tests/test_echo_tcp_writev_readv.c new file mode 100644 index 0000000..e011236 --- /dev/null +++ b/tests/deckard/contrib/libswrap/tests/test_echo_tcp_writev_readv.c @@ -0,0 +1,189 @@ +#include <stdarg.h> +#include <stddef.h> +#include <setjmp.h> +#include <cmocka.h> + +#include "config.h" +#include "torture.h" + +#include <errno.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/uio.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> + +static int setup_echo_srv_tcp_ipv4(void **state) +{ + torture_setup_echo_srv_tcp_ipv4(state); + + return 0; +} + +#ifdef HAVE_IPV6 +static int setup_echo_srv_tcp_ipv6(void **state) +{ + torture_setup_echo_srv_tcp_ipv6(state); + + return 0; +} +#endif + +static int teardown(void **state) +{ + torture_teardown_echo_srv(state); + + return 0; +} + +static void test_writev_readv_ipv4(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in), + }; + ssize_t ret; + int rc; + int i; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_int_not_equal(s, -1); + + addr.sa.in.sin_family = AF_INET; + addr.sa.in.sin_port = htons(torture_server_port()); + + rc = inet_pton(addr.sa.in.sin_family, + torture_server_address(AF_INET), + &addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + rc = connect(s, &addr.sa.s, addr.sa_socklen); + assert_int_equal(rc, 0); + + for (i = 1; i < 10; i++) { + char send_buf[10][64]; + char recv_buf[10][64]; + struct iovec iov_send[10]; + struct iovec iov_recv[10]; + int j; + + for (j = 0; j < i; j++) { + memset(send_buf[j], 0, 64); + snprintf(send_buf[j], sizeof(send_buf[j]), + "packet.%d", j); + + iov_send[j].iov_base = send_buf[j]; + iov_send[j].iov_len = strlen(send_buf[j]); + + iov_recv[j].iov_base = recv_buf[j]; + iov_recv[j].iov_len = strlen(send_buf[j]); + } + + ret = writev(s, iov_send, j); + assert_int_not_equal(ret, -1); + + ret = readv(s, iov_recv, j); + assert_int_not_equal(ret, -1); + + for (j = 0; j < i; j++) { + assert_int_equal(iov_send[j].iov_len, + iov_recv[j].iov_len); + + assert_memory_equal(iov_send[j].iov_base, + iov_recv[j].iov_base, + iov_send[j].iov_len); + } + } + + close(s); +} + +#ifdef HAVE_IPV6 +static void test_writev_readv_ipv6(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in6), + }; + ssize_t ret; + int rc; + int i; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP); + assert_int_not_equal(s, -1); + + addr.sa.in6.sin6_family = AF_INET6; + addr.sa.in6.sin6_port = htons(torture_server_port()); + + rc = inet_pton(AF_INET6, + torture_server_address(AF_INET6), + &addr.sa.in6.sin6_addr); + assert_int_equal(rc, 1); + + rc = connect(s, &addr.sa.s, addr.sa_socklen); + assert_int_equal(rc, 0); + + for (i = 1; i < 10; i++) { + char send_buf[10][64]; + char recv_buf[10][64]; + struct iovec iov_send[10]; + struct iovec iov_recv[10]; + int j; + + for (j = 0; j < i; j++) { + memset(send_buf[j], 0, 64); + snprintf(send_buf[j], sizeof(send_buf[j]), + "packet.%d", j); + + iov_send[j].iov_base = send_buf[j]; + iov_send[j].iov_len = strlen(send_buf[j]); + + iov_recv[j].iov_base = recv_buf[j]; + iov_recv[j].iov_len = strlen(send_buf[j]); + } + + ret = writev(s, iov_send, j); + assert_int_not_equal(ret, -1); + + ret = readv(s, iov_recv, j); + assert_int_not_equal(ret, -1); + + for (j = 0; j < i; j++) { + assert_int_equal(iov_send[j].iov_len, + iov_recv[j].iov_len); + + assert_memory_equal(iov_send[j].iov_base, + iov_recv[j].iov_base, + iov_send[j].iov_len); + } + } + + close(s); +} +#endif + +int main(void) { + int rc; + + const struct CMUnitTest tcp_writev_tests[] = { + cmocka_unit_test_setup_teardown(test_writev_readv_ipv4, + setup_echo_srv_tcp_ipv4, + teardown), +#ifdef HAVE_IPV6 + cmocka_unit_test_setup_teardown(test_writev_readv_ipv6, + setup_echo_srv_tcp_ipv6, + teardown), +#endif + }; + + rc = cmocka_run_group_tests(tcp_writev_tests, NULL, NULL); + + return rc; +} diff --git a/tests/deckard/contrib/libswrap/tests/test_echo_udp_send_recv.c b/tests/deckard/contrib/libswrap/tests/test_echo_udp_send_recv.c new file mode 100644 index 0000000..cf4e848 --- /dev/null +++ b/tests/deckard/contrib/libswrap/tests/test_echo_udp_send_recv.c @@ -0,0 +1,160 @@ +#include <stdarg.h> +#include <stddef.h> +#include <setjmp.h> +#include <cmocka.h> + +#include "config.h" +#include "torture.h" + +#include <errno.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> + +static int setup_echo_srv_udp_ipv4(void **state) +{ + torture_setup_echo_srv_udp_ipv4(state); + + return 0; +} + +#ifdef HAVE_IPV6 +static int setup_echo_srv_udp_ipv6(void **state) +{ + torture_setup_echo_srv_udp_ipv6(state); + + return 0; +} +#endif + +static int teardown(void **state) +{ + torture_teardown_echo_srv(state); + + return 0; +} + +static void test_send_recv_ipv4(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in), + }; + ssize_t ret; + int rc; + int i; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + assert_int_not_equal(s, -1); + + addr.sa.in.sin_family = AF_INET; + addr.sa.in.sin_port = htons(torture_server_port()); + + rc = inet_pton(AF_INET, + torture_server_address(AF_INET), + &addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + rc = connect(s, &addr.sa.s, addr.sa_socklen); + assert_int_equal(rc, 0); + + for (i = 0; i < 10; i++) { + char send_buf[64] = {0}; + char recv_buf[64] = {0}; + + snprintf(send_buf, sizeof(send_buf), "packet.%d", i); + + ret = send(s, + send_buf, + sizeof(send_buf), + 0); + assert_int_not_equal(ret, -1); + + ret = recv(s, + recv_buf, + sizeof(recv_buf), + 0); + assert_int_not_equal(ret, -1); + + assert_memory_equal(send_buf, recv_buf, sizeof(send_buf)); + } + + close(s); +} + +#ifdef HAVE_IPV6 +static void test_send_recv_ipv6(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in6), + }; + ssize_t ret; + int rc; + int i; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP); + assert_int_not_equal(s, -1); + + addr.sa.in6.sin6_family = AF_INET6; + addr.sa.in6.sin6_port = htons(torture_server_port()); + + rc = inet_pton(AF_INET6, + torture_server_address(AF_INET6), + &addr.sa.in6.sin6_addr); + assert_int_equal(rc, 1); + + rc = connect(s, &addr.sa.s, addr.sa_socklen); + assert_int_equal(rc, 0); + + for (i = 0; i < 10; i++) { + char send_buf[64] = {0}; + char recv_buf[64] = {0}; + + snprintf(send_buf, sizeof(send_buf), "packet.%d", i); + + ret = send(s, + send_buf, + sizeof(send_buf), + 0); + assert_int_not_equal(ret, -1); + + ret = recv(s, + recv_buf, + sizeof(recv_buf), + 0); + assert_int_not_equal(ret, -1); + + assert_memory_equal(send_buf, recv_buf, sizeof(send_buf)); + } + + close(s); +} +#endif + +int main(void) { + int rc; + + const struct CMUnitTest send_tests[] = { + cmocka_unit_test_setup_teardown(test_send_recv_ipv4, + setup_echo_srv_udp_ipv4, + teardown), +#ifdef HAVE_IPV6 + cmocka_unit_test_setup_teardown(test_send_recv_ipv6, + setup_echo_srv_udp_ipv6, + teardown), +#endif + }; + + rc = cmocka_run_group_tests(send_tests, NULL, NULL); + + return rc; +} diff --git a/tests/deckard/contrib/libswrap/tests/test_echo_udp_sendmsg_recvmsg.c b/tests/deckard/contrib/libswrap/tests/test_echo_udp_sendmsg_recvmsg.c new file mode 100644 index 0000000..93450b7 --- /dev/null +++ b/tests/deckard/contrib/libswrap/tests/test_echo_udp_sendmsg_recvmsg.c @@ -0,0 +1,407 @@ +#include <stdarg.h> +#include <stddef.h> +#include <setjmp.h> +#include <cmocka.h> + +#include "config.h" +#include "torture.h" + +#include <errno.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> + +static int setup_echo_srv_udp_ipv4(void **state) +{ + torture_setup_echo_srv_udp_ipv4(state); + + return 0; +} + +#ifdef HAVE_IPV6 +static int setup_echo_srv_udp_ipv6(void **state) +{ + torture_setup_echo_srv_udp_ipv6(state); + + return 0; +} +#endif + +static int teardown(void **state) +{ + torture_teardown_echo_srv(state); + + return 0; +} + +static void test_sendmsg_recvmsg_ipv4(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in), + }; + char send_buf[64] = {0}; + char recv_buf[64] = {0}; + ssize_t ret; + int rc; + int i; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + assert_int_not_equal(s, -1); + + addr.sa.in.sin_family = AF_INET; + addr.sa.in.sin_port = htons(torture_server_port()); + + rc = inet_pton(AF_INET, + torture_server_address(AF_INET), + &addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + for (i = 0; i < 10; i++) { + char ip[INET_ADDRSTRLEN] = {0}; + const char *a; + struct torture_address srv_in = { + .sa_socklen = sizeof(struct sockaddr_in), + }; + struct msghdr s_msg; + struct msghdr r_msg; + struct iovec s_iov; + struct iovec r_iov; + + snprintf(send_buf, sizeof(send_buf), "packet.%d", i); + + ZERO_STRUCT(s_msg); + + s_msg.msg_name = &addr.sa.s; + s_msg.msg_namelen = addr.sa_socklen; + + s_iov.iov_base = send_buf; + s_iov.iov_len = sizeof(send_buf); + + s_msg.msg_iov = &s_iov; + s_msg.msg_iovlen = 1; + + ret = sendmsg(s, &s_msg, 0); + assert_int_not_equal(ret, -1); + + ZERO_STRUCT(r_msg); + + r_msg.msg_name = &srv_in.sa.s; + r_msg.msg_namelen = srv_in.sa_socklen; + + r_iov.iov_base = recv_buf; + r_iov.iov_len = sizeof(recv_buf); + + r_msg.msg_iov = &r_iov; + r_msg.msg_iovlen = 1; + + ret = recvmsg(s, &r_msg, 0); + assert_int_not_equal(ret, -1); + + assert_int_equal(r_msg.msg_namelen, sizeof(struct sockaddr_in)); + + a = inet_ntop(AF_INET, &srv_in.sa.in.sin_addr, ip, sizeof(ip)); + assert_non_null(a); + assert_string_equal(a, torture_server_address(AF_INET)); + + assert_memory_equal(send_buf, recv_buf, sizeof(send_buf)); + } + + close(s); +} + +#ifdef HAVE_IPV6 +static void test_sendmsg_recvmsg_ipv6(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in6), + }; + char send_buf[64] = {0}; + char recv_buf[64] = {0}; + ssize_t ret; + int rc; + int i; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP); + assert_int_not_equal(s, -1); + + addr.sa.in6.sin6_family = AF_INET6; + addr.sa.in6.sin6_port = htons(torture_server_port()); + + rc = inet_pton(AF_INET6, + torture_server_address(AF_INET6), + &addr.sa.in6.sin6_addr); + assert_int_equal(rc, 1); + + for (i = 0; i < 10; i++) { + char ip[INET6_ADDRSTRLEN] = {0}; + const char *a; + struct torture_address srv_in6 = { + .sa_socklen = sizeof(struct sockaddr_in6), + }; + struct msghdr s_msg; + struct msghdr r_msg; + struct iovec s_iov; + struct iovec r_iov; + + snprintf(send_buf, sizeof(send_buf), "packet.%d", i); + + ZERO_STRUCT(s_msg); + + s_msg.msg_name = &addr.sa.s; + s_msg.msg_namelen = addr.sa_socklen; + + s_iov.iov_base = send_buf; + s_iov.iov_len = sizeof(send_buf); + + s_msg.msg_iov = &s_iov; + s_msg.msg_iovlen = 1; + + ret = sendmsg(s, &s_msg, 0); + assert_int_not_equal(ret, -1); + + ZERO_STRUCT(r_msg); + r_msg.msg_name = &srv_in6.sa.s; + r_msg.msg_namelen = srv_in6.sa_socklen; + + r_iov.iov_base = recv_buf; + r_iov.iov_len = sizeof(recv_buf); + + r_msg.msg_iov = &r_iov; + r_msg.msg_iovlen = 1; + + ret = recvmsg(s, &r_msg, 0); + assert_int_not_equal(ret, -1); + + assert_int_equal(r_msg.msg_namelen, sizeof(struct sockaddr_in6)); + + a = inet_ntop(AF_INET6, &srv_in6.sa.in6.sin6_addr, ip, sizeof(ip)); + assert_non_null(a); + assert_string_equal(a, torture_server_address(AF_INET6)); + + assert_memory_equal(send_buf, recv_buf, sizeof(send_buf)); + } + + close(s); +} +#endif + +static void test_sendmsg_recvmsg_ipv4_connected(void **state) +{ + struct torture_address send_addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + struct torture_address r_addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + struct msghdr s_msg = { + .msg_namelen = 0, + }; + struct msghdr r_msg = { + .msg_namelen = 0, + }; + struct iovec iov; + char ip[INET_ADDRSTRLEN] = {0}; + char payload[] = "PACKET"; + const char *a; + ssize_t ret; + int rc; + int s; + + (void)state; /* unused */ + + s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + assert_int_not_equal(s, -1); + + send_addr.sa.in.sin_family = AF_INET; + send_addr.sa.in.sin_port = htons(torture_server_port()); + + rc = inet_pton(AF_INET, + torture_server_address(AF_INET), + &send_addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + rc = connect(s, &send_addr.sa.s, send_addr.sa_socklen); + + iov.iov_base = (void *)payload; + iov.iov_len = sizeof(payload); + + /* msg_name is NULL */ + + s_msg.msg_iov = &iov; + s_msg.msg_iovlen = 1; + + ret = sendmsg(s, &s_msg, 0); + assert_int_not_equal(ret, -1); + + r_msg.msg_name = &r_addr.sa.ss; + r_msg.msg_namelen = r_addr.sa_socklen; + + memset(payload, 0, sizeof(payload)); + + r_msg.msg_iov = &iov; + r_msg.msg_iovlen = 1; + + ret = recvmsg(s, &r_msg, 0); + assert_int_not_equal(ret, -1); + + assert_int_equal(r_msg.msg_namelen, sizeof(struct sockaddr_in)); + + a = inet_ntop(AF_INET, &r_addr.sa.in.sin_addr, ip, sizeof(ip)); + assert_non_null(a); + assert_string_equal(a, torture_server_address(AF_INET)); + + close(s); +} + +static void test_sendmsg_recvmsg_ipv4_connected_null(void **state) +{ + struct torture_address send_addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + struct msghdr s_msg = { + .msg_namelen = 0, + }; + struct msghdr r_msg = { + .msg_namelen = 0, + }; + struct iovec iov; + char payload[] = "PACKET"; + ssize_t ret; + int rc; + int s; + + (void)state; /* unused */ + + s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + assert_int_not_equal(s, -1); + + send_addr.sa.in.sin_family = AF_INET; + send_addr.sa.in.sin_port = htons(torture_server_port()); + + rc = inet_pton(AF_INET, + torture_server_address(AF_INET), + &send_addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + rc = connect(s, &send_addr.sa.s, send_addr.sa_socklen); + + /* msg_name = NULL */ + + iov.iov_base = (void *)payload; + iov.iov_len = sizeof(payload); + + s_msg.msg_iov = &iov; + s_msg.msg_iovlen = 1; + + ret = sendmsg(s, &s_msg, 0); + assert_int_not_equal(ret, -1); + + /* msg_name = NULL */ + + memset(payload, 0, sizeof(payload)); + + r_msg.msg_iov = &iov; + r_msg.msg_iovlen = 1; + + ret = recvmsg(s, &r_msg, 0); + assert_int_not_equal(ret, -1); + + assert_int_equal(r_msg.msg_namelen, 0); + assert_null(r_msg.msg_name); + + close(s); +} + +static void test_sendmsg_recvmsg_ipv4_connected_namelen(void **state) +{ + struct torture_address send_addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + struct msghdr s_msg = { + .msg_namelen = 0, + }; + struct msghdr r_msg = { + .msg_namelen = sizeof(struct sockaddr_storage), + }; + struct iovec iov; + char payload[] = "PACKET"; + ssize_t ret; + int rc; + int s; + + (void)state; /* unused */ + + s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + assert_int_not_equal(s, -1); + + send_addr.sa.in.sin_family = AF_INET; + send_addr.sa.in.sin_port = htons(torture_server_port()); + + rc = inet_pton(AF_INET, + torture_server_address(AF_INET), + &send_addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + rc = connect(s, &send_addr.sa.s, send_addr.sa_socklen); + + /* msg_name = NULL */ + + iov.iov_base = (void *)payload; + iov.iov_len = sizeof(payload); + + s_msg.msg_iov = &iov; + s_msg.msg_iovlen = 1; + + ret = sendmsg(s, &s_msg, 0); + assert_int_not_equal(ret, -1); + + /* msg_name = NULL */ + + memset(payload, 0, sizeof(payload)); + + r_msg.msg_iov = &iov; + r_msg.msg_iovlen = 1; + + ret = recvmsg(s, &r_msg, 0); + assert_int_not_equal(ret, -1); + + close(s); +} + +int main(void) { + int rc; + + const struct CMUnitTest sendmsg_tests[] = { + cmocka_unit_test_setup_teardown(test_sendmsg_recvmsg_ipv4, + setup_echo_srv_udp_ipv4, + teardown), +#ifdef HAVE_IPV6 + cmocka_unit_test_setup_teardown(test_sendmsg_recvmsg_ipv6, + setup_echo_srv_udp_ipv6, + teardown), +#endif + cmocka_unit_test_setup_teardown(test_sendmsg_recvmsg_ipv4_connected, + setup_echo_srv_udp_ipv4, + teardown), + cmocka_unit_test_setup_teardown(test_sendmsg_recvmsg_ipv4_connected_null, + setup_echo_srv_udp_ipv4, + teardown), + cmocka_unit_test_setup_teardown(test_sendmsg_recvmsg_ipv4_connected_namelen, + setup_echo_srv_udp_ipv4, + teardown), + }; + + rc = cmocka_run_group_tests(sendmsg_tests, NULL, NULL); + + return rc; +} diff --git a/tests/deckard/contrib/libswrap/tests/test_echo_udp_sendto_recvfrom.c b/tests/deckard/contrib/libswrap/tests/test_echo_udp_sendto_recvfrom.c new file mode 100644 index 0000000..bb22371 --- /dev/null +++ b/tests/deckard/contrib/libswrap/tests/test_echo_udp_sendto_recvfrom.c @@ -0,0 +1,316 @@ +#include <stdarg.h> +#include <stddef.h> +#include <setjmp.h> +#include <cmocka.h> + +#include "config.h" +#include "torture.h" + +#include <errno.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> + +static int setup_echo_srv_udp_ipv4(void **state) +{ + torture_setup_echo_srv_udp_ipv4(state); + + return 0; +} + +#ifdef HAVE_IPV6 +static int setup_echo_srv_udp_ipv6(void **state) +{ + torture_setup_echo_srv_udp_ipv6(state); + + return 0; +} +#endif + +static int teardown(void **state) +{ + torture_teardown_echo_srv(state); + + return 0; +} + +static void test_sendto_recvfrom_ipv4(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in), + }; + char send_buf[64] = {0}; + char recv_buf[64] = {0}; + ssize_t ret; + int rc; + int i; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + assert_int_not_equal(s, -1); + + addr.sa.in.sin_family = AF_INET; + addr.sa.in.sin_port = htons(torture_server_port()); + + rc = inet_pton(AF_INET, + torture_server_address(AF_INET), + &addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + for (i = 0; i < 10; i++) { + char ip[INET_ADDRSTRLEN] = {0}; + const char *a; + struct torture_address srv_in = { + .sa_socklen = sizeof(struct sockaddr_in), + }; + + snprintf(send_buf, sizeof(send_buf), "packet.%d", i); + + ret = sendto(s, + send_buf, + sizeof(send_buf), + 0, + &addr.sa.s, + addr.sa_socklen); + assert_int_not_equal(ret, -1); + + ret = recvfrom(s, + recv_buf, + sizeof(recv_buf), + 0, + &srv_in.sa.s, + &srv_in.sa_socklen); + assert_int_not_equal(ret, -1); + + a = inet_ntop(AF_INET, &srv_in.sa.in.sin_addr, ip, sizeof(ip)); + assert_non_null(a); + assert_string_equal(a, torture_server_address(AF_INET)); + + assert_memory_equal(send_buf, recv_buf, sizeof(send_buf)); + } + + ret = sendto(s, + send_buf, + sizeof(send_buf), + 0, + &addr.sa.s, + addr.sa_socklen); + assert_int_not_equal(ret, -1); + + ret = recvfrom(s, + recv_buf, + sizeof(recv_buf), + 0, + NULL, + NULL); + assert_int_not_equal(ret, -1); + + close(s); +} + +#ifdef HAVE_IPV6 +static void test_sendto_recvfrom_ipv6(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in6), + }; + char send_buf[64] = {0}; + char recv_buf[64] = {0}; + ssize_t ret; + int rc; + int i; + int s; + + (void) state; /* unused */ + + s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP); + assert_int_not_equal(s, -1); + + addr.sa.in6.sin6_family = AF_INET6; + addr.sa.in6.sin6_port = htons(torture_server_port()); + + rc = inet_pton(AF_INET6, + torture_server_address(AF_INET6), + &addr.sa.in6.sin6_addr); + assert_int_equal(rc, 1); + + for (i = 0; i < 10; i++) { + char ip[INET6_ADDRSTRLEN] = {0}; + const char *a; + struct torture_address srv_in6 = { + .sa_socklen = sizeof(struct sockaddr_in6), + }; + + snprintf(send_buf, sizeof(send_buf), "packet.%d", i); + + ret = sendto(s, + send_buf, + sizeof(send_buf), + 0, + &addr.sa.s, + addr.sa_socklen); + assert_int_not_equal(ret, -1); + + ret = recvfrom(s, + recv_buf, + sizeof(recv_buf), + 0, + &srv_in6.sa.s, + &srv_in6.sa_socklen); + assert_int_not_equal(ret, -1); + + a = inet_ntop(AF_INET6, &srv_in6.sa.in6.sin6_addr, ip, sizeof(ip)); + assert_non_null(a); + assert_string_equal(a, torture_server_address(AF_INET6)); + + assert_memory_equal(send_buf, recv_buf, sizeof(send_buf)); + } + + ret = sendto(s, + send_buf, + sizeof(send_buf), + 0, + &addr.sa.s, + addr.sa_socklen); + assert_int_not_equal(ret, -1); + + ret = recvfrom(s, + recv_buf, + sizeof(recv_buf), + 0, + NULL, + NULL); + assert_int_not_equal(ret, -1); + + close(s); +} +#endif + +static void test_connect_sendto_ipv4(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in), + }; + char send_buf[] = "packet.0"; + char recv_buf[64] = {0}; + ssize_t ret; + int rc; + int s; + + (void) state; /* unused */ + + addr.sa.in.sin_family = AF_INET; + addr.sa.in.sin_port = htons(torture_server_port()); + + rc = inet_pton(AF_INET, + torture_server_address(AF_INET), + &addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + assert_int_not_equal(s, -1); + + /* Now, connect */ + rc = connect(s, &addr.sa.s, addr.sa_socklen); + assert_return_code(rc, errno); + + ret = sendto(s, + send_buf, + sizeof(send_buf), + 0, + &addr.sa.s, + addr.sa_socklen); + assert_return_code(ret, errno); + + ret = recvfrom(s, + recv_buf, + sizeof(recv_buf), + 0, + NULL, + 0); + assert_return_code(ret, errno); + + assert_memory_equal(send_buf, recv_buf, sizeof(send_buf)); + + close(s); +} + +static void test_connect_sendto_null_ipv4(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_in), + }; + char send_buf[] = "packet.0"; + char recv_buf[64] = {0}; + ssize_t ret; + int rc; + int s; + + (void) state; /* unused */ + + addr.sa.in.sin_family = AF_INET; + addr.sa.in.sin_port = htons(torture_server_port()); + + rc = inet_pton(AF_INET, + torture_server_address(AF_INET), + &addr.sa.in.sin_addr); + assert_int_equal(rc, 1); + + s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + assert_int_not_equal(s, -1); + + /* Now, connect */ + rc = connect(s, &addr.sa.s, addr.sa_socklen); + assert_return_code(rc, errno); + + ret = sendto(s, + send_buf, + sizeof(send_buf), + 0, + NULL, + 0); + assert_return_code(ret, errno); + + ret = recvfrom(s, + recv_buf, + sizeof(recv_buf), + 0, + NULL, + 0); + assert_return_code(ret, errno); + + assert_memory_equal(send_buf, recv_buf, sizeof(send_buf)); + + close(s); +} + +int main(void) { + int rc; + + const struct CMUnitTest sendto_tests[] = { + cmocka_unit_test_setup_teardown(test_sendto_recvfrom_ipv4, + setup_echo_srv_udp_ipv4, + teardown), +#ifdef HAVE_IPV6 + cmocka_unit_test_setup_teardown(test_sendto_recvfrom_ipv6, + setup_echo_srv_udp_ipv6, + teardown), +#endif + cmocka_unit_test_setup_teardown(test_connect_sendto_ipv4, + setup_echo_srv_udp_ipv4, + teardown), + cmocka_unit_test_setup_teardown(test_connect_sendto_null_ipv4, + setup_echo_srv_udp_ipv4, + teardown), + }; + + rc = cmocka_run_group_tests(sendto_tests, NULL, NULL); + + return rc; +} diff --git a/tests/deckard/contrib/libswrap/tests/test_ioctl.c b/tests/deckard/contrib/libswrap/tests/test_ioctl.c new file mode 100644 index 0000000..aebff91 --- /dev/null +++ b/tests/deckard/contrib/libswrap/tests/test_ioctl.c @@ -0,0 +1,110 @@ +#include <stdarg.h> +#include <stddef.h> +#include <setjmp.h> +#include <cmocka.h> + +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/ioctl.h> + +#include <errno.h> +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <limits.h> +#include <unistd.h> + +static int setup(void **state) +{ + char test_tmpdir[256]; + const char *p; + + (void) state; /* unused */ + + snprintf(test_tmpdir, sizeof(test_tmpdir), "/tmp/test_socket_wrapper_XXXXXX"); + + p = mkdtemp(test_tmpdir); + assert_non_null(p); + + *state = strdup(p); + setenv("SOCKET_WRAPPER_DIR", p, 1); + setenv("SOCKET_WRAPPER_DEFAULT_IFACE", "11", 1); + + return 0; +} + +static int teardown(void **state) +{ + char remove_cmd[PATH_MAX] = {0}; + char *s = (char *)*state; + int rc; + + if (s == NULL) { + return -1; + } + + snprintf(remove_cmd, sizeof(remove_cmd), "rm -rf %s", s); + free(s); + + rc = system(remove_cmd); + if (rc < 0) { + fprintf(stderr, "%s failed: %s", remove_cmd, strerror(errno)); + } + + return rc; +} + +static void test_swrap_socket(void **state) +{ + int rc; + + (void) state; /* unused */ + + rc = socket(1337, 1337, 0); + assert_int_equal(rc, -1); + assert_int_equal(errno, EAFNOSUPPORT); + + rc = socket(AF_INET, 1337, 0); + assert_int_equal(rc, -1); + assert_int_equal(errno, EPROTONOSUPPORT); + + rc = socket(AF_INET, SOCK_DGRAM, 10); + assert_int_equal(rc, -1); + assert_int_equal(errno, EPROTONOSUPPORT); +} + +static void test_swrap_ioctl_sock(void **state) +{ + int fd; +#ifdef SIOCGPGRP + int rc; + int grp = -127; +#endif + + (void) state; /* unused */ + + fd = socket(AF_INET, SOCK_DGRAM, 0); + assert_int_not_equal(fd, -1); + +#ifdef SIOCGPGRP + rc = ioctl(fd, SIOCGPGRP, &grp); + assert_int_equal(rc, 0); + + assert_int_not_equal(grp, -127); +#endif + + close(fd); +} + +int main(void) { + int rc; + + const struct CMUnitTest ioctl_tests[] = { + cmocka_unit_test_setup_teardown(test_swrap_socket, setup, teardown), + cmocka_unit_test_setup_teardown(test_swrap_ioctl_sock, setup, teardown), + }; + + rc = cmocka_run_group_tests(ioctl_tests, NULL, NULL); + + return rc; +} diff --git a/tests/deckard/contrib/libswrap/tests/test_sendmsg_recvmsg_fd.c b/tests/deckard/contrib/libswrap/tests/test_sendmsg_recvmsg_fd.c new file mode 100644 index 0000000..30c9861 --- /dev/null +++ b/tests/deckard/contrib/libswrap/tests/test_sendmsg_recvmsg_fd.c @@ -0,0 +1,116 @@ +#include <stdarg.h> +#include <stddef.h> +#include <setjmp.h> +#include <cmocka.h> + +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/wait.h> + +#include <errno.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <fcntl.h> +#include <stdio.h> + +static void test_sendmsg_recvmsg_fd(void **state) +{ + int sv[2]; + int child_fd, parent_fd; + int rc; + pid_t pid; + + (void) state; /* unused */ + + rc = socketpair(AF_LOCAL, SOCK_STREAM, 0, sv); + assert_int_not_equal(rc, -1); + + parent_fd = sv[0]; + child_fd = sv[1]; + + pid = fork(); + assert_int_not_equal(pid, -1); + + if (pid == 0) { + /* Child */ + struct msghdr child_msg; + char cmsgbuf[CMSG_SPACE(sizeof(int))]; + struct cmsghdr *cmsg; + int rcv_fd; + char buf[8]; + int i; + + memset(&child_msg, 0, sizeof(child_msg)); + child_msg.msg_control = cmsgbuf; + child_msg.msg_controllen = sizeof(cmsgbuf); + + do { + errno = 0; + rc = recvmsg(child_fd, &child_msg, 0); + } while (errno == EAGAIN || errno == EWOULDBLOCK); + assert_int_not_equal(rc, -1); + + cmsg = CMSG_FIRSTHDR(&child_msg); + assert_non_null(cmsg); + assert_int_equal(cmsg->cmsg_type, SCM_RIGHTS); + + memcpy(&rcv_fd, CMSG_DATA(cmsg), sizeof(rcv_fd)); + assert_int_not_equal(rcv_fd, -1); + + rc = read(rcv_fd, buf, sizeof(buf)); + assert_int_not_equal(rc, -1); + for (i = 0; i < 8; i++) { + assert_int_equal(buf[i], 0); + } + exit(0); + } else { + /* Parent */ + int pass_fd; + struct msghdr parent_msg; + struct cmsghdr *cmsg; + char cmsgbuf[CMSG_SPACE(sizeof(pass_fd))]; + char byte = '!'; + struct iovec iov; + int cs; + + pass_fd = open("/dev/zero", O_RDONLY); + assert_int_not_equal(pass_fd, -1); + + iov.iov_base = &byte; + iov.iov_len = 1; + + memset(&parent_msg, 0, sizeof(parent_msg)); + parent_msg.msg_iov = &iov; + parent_msg.msg_iovlen = 1; + parent_msg.msg_control = cmsgbuf; + parent_msg.msg_controllen = sizeof(cmsgbuf); + + cmsg = CMSG_FIRSTHDR(&parent_msg); + cmsg->cmsg_level = SOL_SOCKET; + cmsg->cmsg_type = SCM_RIGHTS; + cmsg->cmsg_len = CMSG_LEN(sizeof(pass_fd)); + + memcpy(CMSG_DATA(cmsg), &pass_fd, sizeof(pass_fd)); + parent_msg.msg_controllen = cmsg->cmsg_len; + + rc = sendmsg(parent_fd, &parent_msg, 0); + assert_int_not_equal(rc, -1); + + alarm(5); /* 5 seconds timeout for the child */ + rc = waitpid(pid, &cs, 0); + assert_int_not_equal(rc, -1); + } +} + +int main(void) { + int rc; + + const struct CMUnitTest tests[] = { + cmocka_unit_test(test_sendmsg_recvmsg_fd), + }; + + rc = cmocka_run_group_tests(tests, NULL, NULL); + + return rc; +} diff --git a/tests/deckard/contrib/libswrap/tests/test_swrap_unit.c b/tests/deckard/contrib/libswrap/tests/test_swrap_unit.c new file mode 100644 index 0000000..469aa24 --- /dev/null +++ b/tests/deckard/contrib/libswrap/tests/test_swrap_unit.c @@ -0,0 +1,120 @@ +#include <stdarg.h> +#include <stddef.h> +#include <setjmp.h> +#include <cmocka.h> +#include <stdio.h> +#include <string.h> + +#include "config.h" + +#include "socket_wrapper.c" + +#ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL + +/** + * test wrap_sendmsg_filter_cmsghdr() + * + * Prepare a message with two cmsg: + * - the first cmsg is a char buf with the string "Hello World" + * - the second cmsg is a char buf with the string "!\n" + * + * Both cmsgs will be copied without modification by + * wrap_sendmsg_filter_cmsghdr(), so we can check that the msg + * controllen, the cmsg sizes and the payload are the same. + * + * We use an not existing cmsg_type which triggers cmsg copying. + */ +static void test_sendmsg_cmsg(void **state) +{ + int rc = 0; + char byte = '!'; + struct iovec iov; + struct msghdr msg = { 0 }; + struct cmsghdr *cmsg; + char *cmsgbuf; + int cmsgbuf_size; + const char *s1 = "Hello World"; + const int s1_len = strlen(s1); + const char *s2 = "!\n"; + const int s2_len = strlen(s2); + uint8_t *cmbuf = NULL; + size_t cmlen = 0; + + (void)state; /* unused */ + + iov.iov_base = &byte; + iov.iov_len = 1; + + /* + * Prepare cmsgbuf and msg + */ + msg.msg_iov = &iov; + msg.msg_iovlen = 1; + cmsgbuf_size = CMSG_SPACE(s1_len) + CMSG_SPACE(s2_len); + cmsgbuf = calloc(cmsgbuf_size, sizeof(char)); + assert_non_null(cmsgbuf); + msg.msg_control = cmsgbuf; + msg.msg_controllen = cmsgbuf_size; + + /* + * Prepare first cmsg with string "Hello World" + */ + cmsg = CMSG_FIRSTHDR(&msg); + assert_non_null(cmsg); + + cmsg->cmsg_level = SOL_SOCKET; + cmsg->cmsg_type = ~0 - 1; + cmsg->cmsg_len = CMSG_LEN(s1_len); + memcpy(CMSG_DATA(cmsg), s1, s1_len); + + /* + * Prepare second cmsg with string "!\n" + */ + cmsg = CMSG_NXTHDR(&msg, cmsg); + assert_non_null(cmsg); + + cmsg->cmsg_level = SOL_SOCKET; + cmsg->cmsg_type = ~0 - 2; + cmsg->cmsg_len = CMSG_LEN(s2_len); + memcpy(CMSG_DATA(cmsg), s2, s2_len); + + /* + * Now call swrap_sendmsg_filter_cmsghdr() on the msg + */ + rc = swrap_sendmsg_filter_cmsghdr(&msg, &cmbuf, &cmlen); + assert_return_code(rc, errno); + assert_int_equal(cmlen, msg.msg_controllen); + + /* + * Insert filtered cmsgbug into msg and validate cmsgs. + */ + msg.msg_control = cmbuf; + + cmsg = CMSG_FIRSTHDR(&msg); + assert_non_null(cmsg); + assert_int_equal(cmsg->cmsg_len, CMSG_LEN(s1_len)); + assert_memory_equal(CMSG_DATA(cmsg), s1, s1_len); + + cmsg = CMSG_NXTHDR(&msg, cmsg); + assert_non_null(cmsg); + assert_int_equal(cmsg->cmsg_len, CMSG_LEN(s2_len)); + assert_memory_equal(CMSG_DATA(cmsg), s2, s2_len); + + free(cmbuf); + free(cmsgbuf); +} +#endif + +int main(void) { + int rc; + + const struct CMUnitTest unit_tests[] = { +#ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL + cmocka_unit_test(test_sendmsg_cmsg), +#endif + }; + + rc = cmocka_run_group_tests(unit_tests, NULL, NULL); + + return rc; +} diff --git a/tests/deckard/contrib/libswrap/tests/test_tcp_listen.c b/tests/deckard/contrib/libswrap/tests/test_tcp_listen.c new file mode 100644 index 0000000..5641c47 --- /dev/null +++ b/tests/deckard/contrib/libswrap/tests/test_tcp_listen.c @@ -0,0 +1,115 @@ +#include <stdarg.h> +#include <stddef.h> +#include <setjmp.h> +#include <cmocka.h> + +#include "config.h" +#include "torture.h" + +#include <errno.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/un.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> +#ifdef HAVE_RPC_RPC_H +#include <rpc/rpc.h> +#endif + +static int setup(void **state) +{ + torture_setup_socket_dir(state); + + return 0; +} + +static int teardown(void **state) +{ + torture_teardown_socket_dir(state); + + return 0; +} + +static void test_listen_unbound_ipv4(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + int rc; + int s1; + int s2; + + (void) state; /* unused */ + + s1 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_return_code(s1, errno); + + rc = listen(s1, SOMAXCONN); + assert_return_code(rc, errno); + + rc = getsockname(s1, &addr.sa.s, &addr.sa_socklen); + assert_return_code(rc, errno); + assert_int_equal(addr.sa_socklen, sizeof(struct sockaddr_in)); + assert_in_range(ntohs(addr.sa.in.sin_port), 1024, 65535); + + s2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert_return_code(s2, errno); + + rc = connect(s2, &addr.sa.s, addr.sa_socklen); + assert_return_code(rc, errno); + + close(s1); + close(s2); +} + +#ifdef HAVE_IPV6 +static void test_listen_unbound_ipv6(void **state) +{ + struct torture_address addr = { + .sa_socklen = sizeof(struct sockaddr_storage), + }; + int rc; + int s1; + int s2; + + (void) state; /* unused */ + + s1 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP); + assert_return_code(s1, errno); + + rc = listen(s1, SOMAXCONN); + assert_return_code(rc, errno); + + rc = getsockname(s1, &addr.sa.s, &addr.sa_socklen); + assert_return_code(rc, errno); + assert_int_equal(addr.sa_socklen, sizeof(struct sockaddr_in6)); + assert_in_range(ntohs(addr.sa.in6.sin6_port), 1024, 65535); + + s2 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP); + assert_return_code(s2, errno); + + rc = connect(s2, &addr.sa.s, addr.sa_socklen); + assert_return_code(rc, errno); + + close(s1); + close(s2); +} +#endif /* HAVE_IPV6 */ + +int main(void) { + int rc; + + const struct CMUnitTest tcp_listen_tests[] = { + cmocka_unit_test(test_listen_unbound_ipv4), +#ifdef HAVE_IPV6 + cmocka_unit_test(test_listen_unbound_ipv6), +#endif /* HAVE_IPV6 */ + }; + + rc = cmocka_run_group_tests(tcp_listen_tests, setup, teardown); + + return rc; +} diff --git a/tests/deckard/contrib/libswrap/tests/torture.c b/tests/deckard/contrib/libswrap/tests/torture.c new file mode 100644 index 0000000..d3ad84a --- /dev/null +++ b/tests/deckard/contrib/libswrap/tests/torture.c @@ -0,0 +1,318 @@ +/* + * Copyright (C) Andreas Schneider 2013 <asn@samba.org> + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the author nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include "config.h" + +#include "torture.h" + +#include <errno.h> + +#include <sys/types.h> +#include <sys/stat.h> +#include <sys/socket.h> +#include <signal.h> +#include <fcntl.h> + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <time.h> +#include <stdbool.h> + +#define TORTURE_ECHO_SRV_IPV4 "127.0.0.10" +/* socket wrapper IPv6 prefix fd00::5357:5fxx */ +#define TORTURE_ECHO_SRV_IPV6 "fd00::5357:5f0a" +#define TORTURE_ECHO_SRV_PORT 7 + +#define TORTURE_SOCKET_DIR "/tmp/w_XXXXXX" +#define TORTURE_ECHO_SRV_PIDFILE "echo_srv.pid" +#define TORTURE_PCAP_FILE "socket_trace.pcap" + +const char *torture_server_address(int family) +{ + switch (family) { + case AF_INET: { + const char *ip4 = getenv("TORTURE_SERVER_ADDRESS_IPV4"); + + if (ip4 != NULL && ip4[0] != '\0') { + return ip4; + } + + return TORTURE_ECHO_SRV_IPV4; + } +#ifdef HAVE_IPV6 + case AF_INET6: { + const char *ip6 = getenv("TORTURE_SERVER_ADDRESS_IPV6"); + + if (ip6 != NULL && ip6[0] != '\0') { + return ip6; + } + + return TORTURE_ECHO_SRV_IPV6; + } +#endif + default: + return NULL; + } + + return NULL; +} + +int torture_server_port(void) +{ + char *env = getenv("TORTURE_SERVER_PORT"); + + if (env != NULL && env[0] != '\0' && strlen(env) < 6) { + int port = atoi(env); + + if (port > 0 && port < 65536) { + return port; + } + } + + return TORTURE_ECHO_SRV_PORT; +} + +void torture_setup_socket_dir(void **state) +{ + struct torture_state *s; + const char *p; + size_t len; + + s = malloc(sizeof(struct torture_state)); + assert_non_null(s); + + s->socket_dir = strdup(TORTURE_SOCKET_DIR); + assert_non_null(s->socket_dir); + + p = mkdtemp(s->socket_dir); + assert_non_null(p); + + /* pcap file */ + len = strlen(p) + 1 + strlen(TORTURE_PCAP_FILE) + 1; + + s->pcap_file = malloc(len); + assert_non_null(s->pcap_file); + + snprintf(s->pcap_file, len, "%s/%s", p, TORTURE_PCAP_FILE); + + /* pid file */ + len = strlen(p) + 1 + strlen(TORTURE_ECHO_SRV_PIDFILE) + 1; + + s->srv_pidfile = malloc(len); + assert_non_null(s->srv_pidfile); + + snprintf(s->srv_pidfile, len, "%s/%s", p, TORTURE_ECHO_SRV_PIDFILE); + + setenv("SOCKET_WRAPPER_DIR", p, 1); + setenv("SOCKET_WRAPPER_DEFAULT_IFACE", "170", 1); + setenv("SOCKET_WRAPPER_PCAP_FILE", s->pcap_file, 1); + + *state = s; +} + +static void torture_setup_echo_srv_ip(void **state, + const char *ip, + int port, + int type) +{ + struct torture_state *s; + char start_echo_srv[1024] = {0}; + const char *t; + int count = 0; + int rc; + + torture_setup_socket_dir(state); + + s = *state; + + switch (type) { + case SOCK_STREAM: + t = "-t"; + break; + case SOCK_DGRAM: + t = "-u"; + break; + default: + t = ""; + break; + } + + /* set default iface for the server */ + setenv("SOCKET_WRAPPER_DEFAULT_IFACE", "10", 1); + + snprintf(start_echo_srv, sizeof(start_echo_srv), + "%s/tests/echo_srv -b %s -p %d -D %s --pid %s", + BINARYDIR, ip, port, t, s->srv_pidfile); + + rc = system(start_echo_srv); + assert_int_equal(rc, 0); + + do { + struct stat sb; + + count++; + if (count > 100) { + break; + } + + rc = stat(s->srv_pidfile, &sb); + usleep(200); + } while (rc != 0); + assert_int_equal(rc, 0); + + /* set default iface for the client */ + setenv("SOCKET_WRAPPER_DEFAULT_IFACE", "170", 1); +} + +void torture_setup_echo_srv_udp_ipv4(void **state) +{ + torture_setup_echo_srv_ip(state, + "0.0.0.0", + torture_server_port(), + SOCK_DGRAM); +} + +void torture_setup_echo_srv_udp_ipv6(void **state) +{ + torture_setup_echo_srv_ip(state, + "::", + torture_server_port(), + SOCK_DGRAM); +} + +void torture_setup_echo_srv_tcp_ipv4(void **state) +{ + torture_setup_echo_srv_ip(state, + "0.0.0.0", + torture_server_port(), + SOCK_STREAM); +} + +void torture_setup_echo_srv_tcp_ipv6(void **state) +{ + torture_setup_echo_srv_ip(state, + "::", + torture_server_port(), + SOCK_STREAM); +} + +void torture_teardown_socket_dir(void **state) +{ + struct torture_state *s = *state; + char *env = getenv("TORTURE_SKIP_CLEANUP"); + char remove_cmd[1024] = {0}; + int rc; + + if (env != NULL && env[0] == '1') { + fprintf(stderr, ">>> Skipping cleanup of %s", s->socket_dir); + } else { + snprintf(remove_cmd, sizeof(remove_cmd), "rm -rf %s", s->socket_dir); + + rc = system(remove_cmd); + if (rc < 0) { + fprintf(stderr, "%s failed: %s", remove_cmd, strerror(errno)); + } + } + + free(s->socket_dir); + free(s->pcap_file); + free(s->srv_pidfile); + free(s); +} + +void torture_teardown_echo_srv(void **state) +{ + struct torture_state *s = *state; + char buf[8] = {0}; + long int tmp; + ssize_t rc; + pid_t pid; + int fd; + bool is_running = true; + int count; + + /* read the pidfile */ + fd = open(s->srv_pidfile, O_RDONLY); + if (fd < 0) { + goto done; + } + + rc = read(fd, buf, sizeof(buf)); + close(fd); + if (rc <= 0) { + goto done; + } + + buf[sizeof(buf) - 1] = '\0'; + + tmp = strtol(buf, NULL, 10); + if (tmp == 0 || tmp > 0xFFFF || errno == ERANGE) { + goto done; + } + + pid = (pid_t)(tmp & 0xFFFF); + + for (count = 0; count < 10; count++) { + /* Make sure the daemon goes away! */ + kill(pid, SIGTERM); + + usleep(200); + + rc = kill(pid, 0); + if (rc != 0) { + is_running = false; + break; + } + } + + if (is_running) { + fprintf(stderr, + "WARNING the echo server is still running!\n"); + } + +done: + torture_teardown_socket_dir(state); +} + +void torture_generate_random_buffer(uint8_t *out, int len) +{ + int i; + + srand(time(NULL)); + + for (i = 0; i < len; i++) { + out[i] = (uint8_t)rand(); + } +} diff --git a/tests/deckard/contrib/libswrap/tests/torture.h b/tests/deckard/contrib/libswrap/tests/torture.h new file mode 100644 index 0000000..921195d --- /dev/null +++ b/tests/deckard/contrib/libswrap/tests/torture.h @@ -0,0 +1,88 @@ +/* + * Copyright (C) Andreas Schneider 2013 <asn@samba.org> + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the author nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _TORTURE_H +#define _TORTURE_H + +#include "config.h" + +#include <sys/socket.h> +#include <sys/un.h> +#include <netinet/in.h> + +#include <stdarg.h> +#include <stddef.h> +#include <setjmp.h> +#include <cmocka.h> + +#include <stdint.h> +#include <string.h> + +struct torture_address { + socklen_t sa_socklen; + union { + struct sockaddr s; + struct sockaddr_in in; +#ifdef HAVE_IPV6 + struct sockaddr_in6 in6; +#endif + struct sockaddr_un un; + struct sockaddr_storage ss; + } sa; +}; + +struct torture_state { + char *socket_dir; + char *pcap_file; + char *srv_pidfile; +}; + +#ifndef ZERO_STRUCT +#define ZERO_STRUCT(x) memset((char *)&(x), 0, sizeof(x)) +#endif + +const char *torture_server_address(int domain); +int torture_server_port(void); + +void torture_setup_socket_dir(void **state); +void torture_setup_echo_srv_udp_ipv4(void **state); +void torture_setup_echo_srv_udp_ipv6(void **state); + +void torture_setup_echo_srv_tcp_ipv4(void **state); +void torture_setup_echo_srv_tcp_ipv6(void **state); + +void torture_teardown_socket_dir(void **state); +void torture_teardown_echo_srv(void **state); + +void torture_generate_random_buffer(uint8_t *out, int len); +#endif /* _TORTURE_H */ diff --git a/tests/deckard/contrib/libswrap/tests/valgrind.supp b/tests/deckard/contrib/libswrap/tests/valgrind.supp new file mode 100644 index 0000000..9857825 --- /dev/null +++ b/tests/deckard/contrib/libswrap/tests/valgrind.supp @@ -0,0 +1,16 @@ +### GLIBC +{ + glibc_dlopen_alloc + Memcheck:Leak + fun:calloc + fun:_dlerror_run + fun:dlopen@@GLIBC_2.2.5 +} + +{ + glibc_dlclose_alloc + Memcheck:Leak + fun:calloc + fun:_dlerror_run + fun:dlclose +} |