Merge pull request #244 from sdettmer/dev/sde/faketime_link_flags

Added support for FAKETIME_LINK_FLAGS for #243.

.github/workflows/make-test.yml

@@ -0,0 +1,23 @@
+name: Run make test
+
+on:
+  push:
+    branches: 
+      - master
+      - develop
+  schedule:
+    - cron:  '30 9 * * *'
+      
+jobs:
+  build:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macOS-latest]
+    runs-on: ${{ matrix.os }}
+   
+    steps:
+    - uses: actions/checkout@v1
+    - name: make
+      run: make
+    - name: make test
+      run: make test

.travis.yml

@@ -0,0 +1,13 @@
+language: c
+
+matrix:
+  include:
+    - os: linux
+      compiler: gcc
+    - os: osx
+      osx_image: xcode11
+
+script:
+  - cd ${TRAVIS_BUILD_DIR}
+  - FAKETIME_COMPILE_CFLAGS="-DFORCE_MONOTONIC_FIX" make
+  - make test

Makefile

@@ -7,6 +7,7 @@ all:
 	$(MAKE) $(SELECTOR) -C src all
 
 test:
+	$(MAKE) $(SELECTOR) -C src all
 	$(MAKE) $(SELECTOR) -C test all
 
 install:

NEWS

@@ -1,3 +1,51 @@
+    - Additional link-time LDFLAGS can be passed via the
+      environment variable FAKETIME_LINK_FLAGS when
+      running 'make'.
+
+Since 0.9.8:
+    - Compile-time CFLAG FAKE_SETTIME can be enabled to
+      intercept calls to clock_settime(), settimeofday(), and
+      adjtime(). (suggested and prototyped by @ojura)
+    - Additional compile-time CFLAGs can be passed via the
+      environment variable FAKETIME_COMPILE_CFLAGS when
+      running 'make'.
+    - src/Makefile CFLAG FORCE_PTHREAD_NONVER should be set on
+      systems that hang on CLOCK_REALTIME, or that hang on
+      CLOCK_MONOTONIC where FORCE_MONOTONIC_FIX is not sufficient.
+
+Since 0.9.7:
+    - Passthrough for unknown clock ids to avoid error messages
+    - Fixes for multithreaded operations (mliertzer, qnox)
+    - glibc-related fixes (jprjr) and gcc8 support (tpetazzoni)
+    - Improved error message output on parsing errors
+    - fix file stat() faking when 'i' modifier is used for determinism
+    - Use FAKETIME="%" to take FAKETIME setting from a file as
+      specified in FAKETIME_FOLLOW_FILE
+    - Added FAKETIME_DONT_RESET environment variable to avoid
+      faketime resets when subprocesses are started (similar to
+      the old v0.9.6 behavior)
+    - Added FAKETIME_XRESET to avoid large clock jumps when
+      the 'x' modifier is used and changed during run-time
+    - Do not fake time during libfaketime initialization to
+      improve compatibility with memory allocation libraries that
+      use time-related functions themselves
+    - Fixes for shared memory related issues, especially when
+      not using the faketime wrapper
+    - Updated glibc compatibility settings for various platforms
+    - Support for clock_nanosleep() with realtime and monotonic clocks
+    - Support for epoll_wait(), epoll_pwait(), and pselect()
+    - src/Makefile CFLAG FORCE_MONOTONIC_FIX should be set (only) on
+      platforms where the test program hangs forever at the
+      CLOCK_MONOTONIC test.
+
+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
@@ -49,7 +97,7 @@ Since 0.8.2:
 
 Since 0.8.1:
     - Added a MacOS port.
-      Thanks to Derrick Brashear!
+      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!

README

@@ -1,7 +1,5 @@
-      =======================================================
-             libfaketime, version 0.9.6 (June 2014)
-        (previously also know as FakeTime Preload Library)
-      =======================================================
+libfaketime, version 0.9.8 (August 2019)
+========================================
 
 
 Content of this file:
@@ -26,82 +24,99 @@ Content of this file:
 6. Contact
 
 
-
 1. Introduction
 ---------------
 
-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.
+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
 
-- running legacy software with y2k bugs
-- testing software for year-2038 compliance
+- deterministic build processes
 - debugging time-related issues, such as expired SSL certificates
-- running software which ceases to run outside a certain timeframe
-- using different system-wide date and time settings, e.g., on OpenVZ-
-  based virtual machines running on the same host.
+- 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 has been designed on and for Linux, but is supposed and has been
-  reported to work on other *NIXes as well, including Mac OS X.
+- 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 and thus cannot work with
+- 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 (man ld).
+  manpage for further details.
 
-* As of version 0.7, support has been added for use in a 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 . Thanks to David North, TDI!
+- 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.
 
-* If and only if you want to run Java programs with faked times in the future
-  (not in the past) on Linux, you also should set the environment variable
-  LD_ASSUME_KERNEL=2.4.19 before running the appropriate "java" command. This
-  fixes an occasional bug where Java locks up at exiting. Again, this is only
-  required for Java with faked times in the future. Thanks to Jamie Cameron for
-  reporting this issue and finding a workaround!
+  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
+  (FAKETIME_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.
 
+  This apparently happens a lot in complex run-time environments, e.g., for
+  programs written in golang, for some Java Virtual Machine implementations,
+  etc. Since libfaketime is effectively bypassed in such situations, there's
+  nothing we can do about it. Please consider asking the appropriate developers
+  and vendors to implement their runtime environment in a way that supports
+  intercepting selected system calls through LD_PRELOAD.
+
 * 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.
 
+* CLOCK_MONOTONIC test: Running "make test" performs a series of tests after
+  successful compilation of the libfaketime library. On some platforms, the
+  "CLOCK_MONOTONIC test" will apparently hang forever. If and only if this
+  happens on your platform, add the CFLAG -DFORCE_MONOTONIC_FIX to
+  src/Makefile and recompile libfaketime. Do not set FORCE_MONOTONIC_FIX on
+  platforms where the test does not hang.
+
+  If you observe hangs on the CLOCK_REALTIME test, add the CFLAG
+  -DFORCE_PTHREAD_NONVER. Also set this FORCE_PTHREAD_NONVER flag in case
+  FORCE_MONOTONIC_FIX alone does not solve the hang on the MONOTONIC_CLOCK
+  test.
 
 
 3. Installation
 ---------------
 
-Running "make" should compile both library versions and a test program, which
-it then also executes.
+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
+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.
+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,
@@ -115,16 +130,15 @@ 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 OS X, it is necessary to compile differently, due to the different
-behavior dyld has. Use the Makefile provided to compile
+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). Mac OS X users should read README.OSX for additional
+set (to anything). macOS users should read README.OSX for additional
 details.
 
 
-
 4. Usage
 --------
 
@@ -136,26 +150,29 @@ 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 2007
+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 2007
+Mon Nov  8 12:01:12 CEST 2016
 
+user@host> LD_PRELOAD=/usr/local/lib/libfaketime.so.1 FAKETIME="-15d"
+FAKETIME_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 full path and
+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
@@ -163,28 +180,34 @@ 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:
+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 .faketimerc in your home directory.
-c) By using the file /etc/faketimerc for a system-wide default.
+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) or c), $HOME/.faketimerc or /etc/faketimerc consist of
+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 the FAKETIME environment variable always
-has priority over the files.
+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 which _must_ be used for _absolute_ dates is "YYYY-MM-DD hh:mm:ss".
-For example, the 24th of December, 2002, 8:30 PM would have to be specified as
-FAKETIME="2002-12-24 20:30:00".
+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
@@ -192,15 +215,31 @@ FAKETIME="2002-12-24 20:30:00".
 
 (Thanks to a major contribution by David North, TDI in version 0.7)
 
-The format which _must_ be used for _start_at_ dates is "@YYYY-MM-DD hh:mm:ss".
-For example, the 24th of December, 2002, 8:30 PM would have to be specified as
-FAKETIME="@2002-12-24 20:30:00".
+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
+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
+operation as described below in section 4d), but using a 'start at' time
 instead of an offset time.
 
+If the started process itself starts other (child) processes, they by default
+will start with the specified start-at-date again. If this is not what you need,
+set the environment variable FAKETIME_DONT_RESET=1. Try these examples to see
+the difference:
+
+LD_PRELOAD=src/libfaketime.so.1 FAKETIME="@2000-01-01 11:12:13" \
+  FAKETIME_DONT_RESET=1 \
+  /bin/bash -c 'while [ $SECONDS -lt 5 ]; do date; sleep 1; done'
+
+LD_PRELOAD=src/libfaketime.so.1 FAKETIME="@2000-01-01 11:12:13" \
+  /bin/bash -c 'while [ $SECONDS -lt 5 ]; do date; sleep 1; done'
+
+In the second example, the "date" command will always print the same time,
+while in the first example, with FAKETIME_DONT_RESET set, time will increment
+even though all the "date" commands are new processes.
+
 
 4d) Using offsets for relative dates
 ------------------------------------
@@ -209,27 +248,31 @@ 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:
+- 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
+- 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.
 
+  Please note that if you need other multipliers (weeks, months etc.) or higher
+  precision (e.g., correct leap year handling), you should use either the
+  faketime wrapper or the GNU date command as shown in the first of the three
+  examples below.
 
 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 FTPL gets loaded and sets the faked time to
+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 to optionally set the strptime() format:
+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
@@ -253,7 +296,7 @@ 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
+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.
 
@@ -269,14 +312,19 @@ 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.
+delimiter depends on your locale. Furthermore,
 
 FAKETIME="+1y i2,0"
 
-will make the clock step two seconds per each time(), etc. call, running
+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 restaring it at the start of each process.
+the same global clock without restarting it at the start of each process.
+
+Please note that using "x" or "i" in FAKETIME still requires giving an offset
+(see section 4d). This means that "+1y x2" will work, but "x2" only will not.
+If you do not want to fake the time, but just modify clock speed, use something
+like "+0 x2", i.e., use an explizit zero offset as a prefix in your FAKETIME.
 
 For testing, your should run a command like
 
@@ -288,10 +336,9 @@ 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 FTPL will be re-initialized. It will show
-the correct offset (1.5 years in the future), but no speed-ups or
-slow-downs.)
+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
@@ -305,8 +352,8 @@ 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
+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).
 
@@ -314,12 +361,109 @@ 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 specification of the fake time is cached for 10
-seconds in order to enhance the library's performance. Thus, if you change the
+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 disable caching at compile time by adding the
-command line option -DNO_CACHING to this library's Makefile.
+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.
+
+
+Setting FAKETIME by means of a file timestamp
+---------------------------------------------
+
+Based on a proposal by Hitoshi Harada (umitanuki), the "start at" time can now be
+set through any file in the file system by setting the FAKETIME environment variable
+to "%" (a percent sign) and FAKETIME_FOLLOW_FILE to the name of the file whose
+modification timestamp shall be used as source for the "start at" time.
+
+Usage example:
+
+# create any file with December 24th, 2009, 12:34:56 as timestamp
+touch -t 0912241234.56 /tmp/my-demo-file.tmp
+
+# run a bash shell with an endless loop printing the current time
+LD_PRELOAD=/path/to/libfaketime.so.1 \
+  FAKETIME='%' FAKETIME_FOLLOW_FILE=/tmp/my-demo-file.tmp \
+  FAKETIME_DONT_RESET=1 \
+  bash -c 'while true ; do date ; sleep 1 ; done'
+
+# now, while the above is running, change the file's timestamp
+# (in a different terminal window or whatever)
+touch -t 2002290123.45 /tmp/my-demo-file.tmp
+
+
+Changing the 'x' modifier during run-time
+-----------------------------------------
+
+Using FAKETIME_TIMESTAMP_FILE allows for easily changing the FAKETIME setting
+while a program is running:
+
+echo "+0 x1" > /tmp/my-faketime.rc
+LD_PRELOAD=libfaketime.so.1 FAKETIME_TIMESTAMP_FILE="/tmp/my-faketime.rc" \
+  FAKETIME_NO_CACHE=1 ./some-program &
+sleep 10 ; echo "+0 x10" > /tmp/my-faketime.rc
+
+Changing the speed of the wall clock time, i.e., using a different 'x' modifier
+during run-time, by default can lead to greater jumps that may confuse the
+program. For example, if the program has been running for 10 seconds on 'x1',
+and then the setting is changed to 'x10', the faked time will look to the
+program as if it has been running for more than 100 instead of just more than
+10 seconds.
+
+By setting the environment variable FAKETIME_XRESET to any value, transitions
+between different 'x' modifier values will be significantly smoothed:
+
+LD_PRELOAD=libfaketime.so.1 FAKETIME_TIMESTAMP_FILE="/tmp/my-faketime.rc" \
+  FAKETIME_NO_CACHE=1 FAKETIME_XRESET=1 ./some-program &
+
+Setting FAKETIME_XRESET ensures that wall clock time begins to run faster
+only after the 'x' modifier has been changed (when increasing it) and also
+ensures that the reported faked time does not jump back to past values
+(when decreasing it).
+
+Please note that FAKETIME_XRESET internally works by resetting libfaketime's
+internal time-keeping data structures, which may have side effects on reported
+file timestamps. Using FAKETIME_XRESET should be considered experimental at
+the moment.
+
+
+Cleaning up shared memory
+-------------------------
+
+libfaketime uses semaphores and shared memory on platforms that support it in
+order to sync faketime settings across parent-child processes. It will clean
+up when it exits properly. However, when processes are terminated (e.g., by
+Ctrl-C on command line), shared memory cannot be cleaned up properly. In such
+cases, you should occasionally delete
+
+  /dev/shm/faketime_shm_* and
+  /dev/shm/sem.faketime_sem_*
+
+manually (or properly automated). Leftover files there from processes that
+already have been terminated are not a problem in general, but result in a
+libfaketime error the next time a process is started with a process id for
+which such a stale semaphore/shared memory exists. Thus, if you run across
+the following error message
+
+  libfaketime: In ft_shm_create(), shm_open failed: File exists
+
+please cleanup /dev/shm as described above. This is especially relevant
+for long-running systems (servers with high uptime) and systems on which
+a lot of processes are started (e.g., servers handling many containers
+or similar virtualization mechanisms).
+
+
+Intercepting time-setting calls
+-------------------------------
+
+libfaketime can be compiled with the CFLAG "-DFAKE_SETTIME" in order
+to also intercept time-setting functions, i.e., clock_settime(),
+settimeofday(), and adjtime(). Instead of passing the timestamp a
+program sets through to the system, only the FAKETIME environment
+variable will be adjusted accordingly.
 
 
 4f) Faking the date and time system-wide
@@ -358,7 +502,7 @@ faketime 'last Friday 5 pm' /your/command/here
 
 Of course, also absolute dates can be used, such as in
 
-faketime '2008-12-24 08:15:42' /bin/date
+faketime '2018-12-24 08:15:42' /bin/date
 
 Thanks to Daniel Kahn Gillmor for providing these suggestions!
 
@@ -367,7 +511,7 @@ 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.
@@ -381,12 +525,12 @@ 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
-  penalities.
+  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 (see Makefile), but comes at a
-  performance cost because this file has to be read and evaluated each time.
+- 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,
 
@@ -434,7 +578,7 @@ doing.
 4i) "Limiting" libfaketime per process
 --------------------------------------
 
-Faketime can be instructed to fake time related calls only for selected
+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.
 
@@ -454,16 +598,17 @@ 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
+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 an
-arbitrary number of seconds or number of time-related system calls of the
-program started. This has two limitations one needs to be aware of:
+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
@@ -494,7 +639,7 @@ seconds.
 4k) Saving timestamps to file, loading them from file
 -----------------------------------------------------
 
-Faketime can save faked timestamps to a file specified by FAKETIME_SAVE_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
@@ -509,15 +654,15 @@ struct saved_timestamp {
   uint64_t nsec;
 };
 
-Faketime needs to be run using the faketime wrapper to use these files. This
+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 Public License, GPL. Please see the
-included COPYING file.
+libfaketime has been released under the GNU General Public License, GPL.
+Please see the included COPYING file.
 
 
 6. Contact
@@ -527,4 +672,3 @@ Bug reports, feature suggestions, success reports, and patches/pull
 requests are highly appreciated:
 
             https://github.com/wolfcw/libfaketime
-

README.OSX

@@ -1,24 +1,22 @@
-README file for libfaketime on Mac OS X
-=======================================
+README file for libfaketime on macOS
+====================================
 
-Support for Mac OS X has meanwhile matured and many command line and
+Support for macOS has meanwhile matured and many command line and
 GUI applications will run stable.
 
-Developments and tests are done on OSX 10.8+ currently, although the
-current version will also work with OSX 10.7.
+Developments and tests are done on Mojave currently.
 
-Version 0.9.5 and higher no longer works with OSX <= 10.6 due to
+Version 0.9.5 and higher no longer work 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
+Installing and using libfaketime on macOS 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.
+setup and usage, and refer to this file only about macOS specifics.
 
 
-1) Installing libfaketime on OS X
----------------------------------
+1) Installing libfaketime on macOS
+----------------------------------
 
 If you use MacPorts, libfaketime can be installed on the command line
 as follows:
@@ -33,6 +31,10 @@ Or, if you use Homebrew, install using:
 
     brew install libfaketime
 
+Please inform the respective package maintainers if the latest release
+is not yet available this way. With homebrew, you can typically use
+"brew install --HEAD" to install from the latest source automatically.
+
 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.
@@ -51,11 +53,11 @@ output is correct:
     make -f Makefile.OSX
 
 
-2) Using libfaketime from the command line on OS X
---------------------------------------------------
+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:
+or any other CLI session, the following commands can be used:
 
 export DYLD_FORCE_FLAT_NAMESPACE=1
 export DYLD_INSERT_LIBRARIES=/path/to/libfaketime.1.dylib
@@ -65,7 +67,7 @@ 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 OS X;
+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
@@ -76,7 +78,7 @@ for help and use "man faketime" for details.
 --------------------------------------------
 
 Given the limited number of system calls libfaketime intercepts,
-it may not work too well with specific GUI applications on OS X.
+it may not work too well with specific GUI applications on macOS.
 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.
@@ -123,14 +125,30 @@ 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 OS X.
+time-related system calls that need to be intercepted on macOS.
 
     https://github.com/wolfcw/libfaketime/issues
 
+However, there are two important aspects:
 
-4) Notes for developers of OS X applications
---------------------------------------------
+- 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.
+
+- We cannot and will not help with using libfaketime for proprietary or
+  commercial software unless you are its developer trying to integrate
+  libfaketime. Please contact the developers or the vendor directly if
+  you have problems using libfaketime with non-free / not open sourced
+  macOS applications.
+
+
+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.
+be re-set to 0 (zero) to work around potential incompatibilities or if
+you do not want libfaketime applied to your software.

README.developers

@@ -4,19 +4,26 @@ 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: 
+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.
+- Official releases are tagged.
 
-Code contributions are highly welcome, preferrably via pull requests on Github.
+- Code contributions and bugfixes should be submitted to and then 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 macOS systems.
+
+Code contributions are highly welcome, preferably via pull requests on Github.
+
+Please have a look at issues labelled as "help wanted" in the Github issue
+tracker. If you are interested in contributing to libfaketime, helping with
+these issues is not only much appreciated, but also a good way to familiarize
+yourself with the overall codebase.
 
 
 CODE STYLE
@@ -43,16 +50,16 @@ void do_nothing(int how_often)
   }
 }
 
-- 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.  
+- 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 "libfaketime" 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. 
+  in the commit message.
 
 
 DEVELOPMENT, BUILDING, AND TESTING
@@ -62,19 +69,19 @@ DEVELOPMENT, BUILDING, AND TESTING
   the modification fixes bugs :-)).
 
 - Add tests for new features. Extend test/timetest.c appropriately and
-  try to use the functional testing framework wherever possible. 
+  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. 
+- If you cannot test the code on both Linux and macOS 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 
+For anything more than small bugfixes, please update the user documentation
 and credits appropriately:
 
 - The NEWS file should mention the change and your credits.
@@ -83,8 +90,8 @@ and credits appropriately:
 - 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. 
+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
@@ -97,7 +104,7 @@ 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
+official release per 1-2 years. 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

README.packagers

@@ -0,0 +1,63 @@
+README for packagers of libfaketime
+
+First, thank you for your efforts to make libfaketime packages available
+on your platform / distribution!
+
+libfaketime has tagged releases about once every 1-2 years, made available
+through github.com/wolfcw/libfaketime, but usually it is also safe (i.e.,
+stable) to use the latest HEAD of the master branch, which contains bug
+fixes since the last tagged release.
+
+You may want to familiarize yourself with the options you can set into
+src/Makefile, but sane defaults for stable operations have been chosen.
+
+Currently, libfaketime does not use autotools yet, so there is
+_no_ ./configure step, but "make" and "make test" will work as expected.
+
+
+However, one problem makes it somewhat difficult to get libfaketime
+working on different platforms:
+
+libfaketime currently has the challenge that depending on the version
+of glibc and the platform (e.g., x86_64 or aarch64) certain compiler
+CFLAGS have to be set manually, as we have not yet found a way to
+safely determine behavior at run-time automatically.
+
+Please proceed as follows:
+
+- run "make test". If everything runs through smoothly and you do not
+  encounter any hangs or test failure reports, use the binaries as
+  they are.
+
+- If you encounter endless hangs during the CLOCK_REALTIME test,
+  add -DFORCE_PTHREAD_NONVER to the CFLAGS.
+
+- If you encounter endless hangs during the CLOCK_MONOTONIC test,
+  add -DFORCE_MONOTONIC_FIX to the CFLAGS. If it works with that,
+  it's fine, otherwise additionally use -DFORCE_PTHREAD_NONVER.
+
+CFLAGS can also be passed through the FAKETIME_COMPILE_CFLAGS environment
+variable, so for example
+
+  FAKETIME_COMPILE_CFLAGS="-DFORCE_PTHREAD_NONVER" make test
+
+would create the libfaketime binaries and run the tests with the
+FORCE_PTHREAD_NONVER flag set in a single step. Likewise there is
+FAKETIME_LINK_FLAGS.
+
+Please do not use FORCE_MONOTONIC_FIX by default, as it would result
+in incorrect operations on platforms that do not need it.
+
+Our observations with a limited number of Linux distributions is that
+libfaketime may require different compile flags per platform even
+if the same distribution and glibc version is used across these
+platforms.
+
+As soon as we have found a reliable way to automatically choose the
+correct compile-time flags, we will remove this burden from you as
+packager for obvious reasons. Until then, please feel free to report
+your experiences with different platforms and distribution versions
+through the issue tracker on Github.
+
+Again, thanks for your time and effort to make libfaketime available
+easily for everyone else!

TODO

@@ -1,11 +1,15 @@
-Open issues / next steps for libfaketime development
+Open issues / next steps for libfaketime development:
+
+Please see the issue tracker on Github - https://github.com/wolfcw/libfaketime
+
+- New features, such as additional system calls to intercept, are labelled
+  "feature request" when they are considered for implementation
+
+- Issues labelled "help wanted" should be your starting point if you are
+  interested in contributing to libfaketime
+
+Besides the open issues, two major changes are planned for the next release:
+
+- integrate manchicken's autoconf/automake support to get rid of separate Makefile.OSX
 
-- add more functional tests that check more than the basic functionality
 - use the testing framework to also implement unit tests
-- make the new "limiting" and "spawning" features more flexible to use
-  and available through the wrapper shell script
-- fake timer_create and friends
-- handle CLOCK_REALTIME_COARSE and CLOCK_MONOTONIC_COARSE
-- work around thread local storage issue, e.g., by using pthreads
-- add autoconf/automake support to get rid of separate Makefile.OSX
-

man/faketime.1

@@ -1,4 +1,4 @@
-.TH FAKETIME "1" "June 2014" "faketime 0.9.6" wolfcw
+.TH FAKETIME "1" "August 2019" "faketime 0.9.8" wolfcw
 .SH NAME
 faketime \- manipulate the system time for a given command
 .SH SYNOPSIS
@@ -7,11 +7,11 @@ faketime \- manipulate the system time for a given command
 .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. 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
+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
@@ -25,6 +25,9 @@ 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
@@ -33,7 +36,7 @@ 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 restaring it at the start of each process.
+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
@@ -51,12 +54,14 @@ This is the most often used format and specifies the faked time relatively to th
 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 
+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 contributers.
+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

packaging/Linux/Arch/PKGBUILD-32bit.txt

@@ -1,25 +0,0 @@
-# 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
-}

packaging/Linux/Debian/avoid-spurious-lrt.patch

@@ -1,30 +0,0 @@
-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

packaging/Linux/Debian/control

@@ -1,40 +0,0 @@
-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).
-

packaging/Linux/Debian/fix-infinite-recursion-on-real_clock_gettime.patch

@@ -1,29 +0,0 @@
-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");

packaging/Linux/Debian/libfaketime.install

@@ -1,3 +0,0 @@
-#!/usr/bin/dh-exec
-src/libfaketime.so.1 usr/lib/${DEB_HOST_MULTIARCH}/faketime/
-src/libfaketimeMT.so.1 usr/lib/${DEB_HOST_MULTIARCH}/faketime/

packaging/Linux/Debian/rules

@@ -1,17 +0,0 @@
-#!/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 $@

packaging/Linux/Redhat/libfaketime-fix-infinite-recursion-on-real_clock_gettime.patch

@@ -1,13 +0,0 @@
-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");

packaging/Linux/Redhat/libfaketime.spec.txt

@@ -1,55 +0,0 @@
-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

packaging/OSX/Fink/libfaketime.info

@@ -1,54 +0,0 @@
-Package: libfaketime
-Version: 0.9.5
-Revision: 1
-
-Source: http://www.code-wizards.com/projects/%n/%n-%v.tar.gz
-Source-MD5: 89b5c71e6c6a93b1c6feba374ac37719
-
-Maintainer: Wolfgang Hommel <wolf@fink.code-wizards.com>
-HomePage: http://www.code-wizards.com/projects/%n
-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
-
-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
-<<
-

packaging/OSX/Homebrew/libfaketime.rb

@@ -1,22 +0,0 @@
-require 'formula'
-
-class Libfaketime < Formula
-  homepage 'http://www.code-wizards.com/projects/libfaketime'
-  url 'http://code-wizards.com/projects/libfaketime/libfaketime-0.9.5.tar.gz'
-  sha1 '12199af854004f231892ab6976c2e99b937e2d61'
-
-  depends_on :macos => :lion
-
-  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
-

packaging/OSX/MacPorts/Portfile

@@ -1,45 +0,0 @@
-# -*- 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.5rc3 v
-
-checksums           rmd160  8d10140a181e0d5ce93bd7b0e7eeaa380eb7a9c6 \
-                    sha256  ee2234335b3d730fdf6898d8dba9195d9ab3068c29af25270be03682d24a424f
-
-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}

packaging/OSX/MacPorts/patch-test-Makefile.OSX.diff

@@ -1,12 +0,0 @@
---- 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}

packaging/OSX/README

@@ -1,67 +0,0 @@
-# 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
-    (0.9.5rc3 is code-identical to 0.9.5 release except for Makefile patches)
-- Non-clang-compilers need to be blacklisted (for libfaketime =0.9.5)
-- 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/
-

packaging/README

@@ -1,14 +0,0 @@
-# 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".
-

src/Makefile

@@ -9,12 +9,9 @@
 #     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
-#           possibile caching side-effects in a multithreaded environment
+#           possible caching side-effects in a multithreaded environment
 #           without this, but the performance impact may require you to
 #           try it unsynchronized.
 #
@@ -24,23 +21,30 @@
 #           that make use of low-level system calls, such as Java Virtual
 #           Machines.
 #
-# 	  FAKE_SLEEP
-# 	      - Also intercept sleep(), nanosleep(), usleep(), alarm(), [p]poll()
+#     FAKE_SLEEP
+#         - Also intercept sleep(), nanosleep(), usleep(), alarm(), [p]poll()
 #
-#	  FAKE_TIMERS
-#	      - Also intercept timer_settime() and timer_gettime()
+#     FAKE_TIMERS
+#         - Also intercept timer_settime() and timer_gettime()
 #
-#     NO_CACHING
-#         - Disables the caching of the fake time offset. Only disable caching
-#           if you change the fake time offset during program runtime very
-#           frequently. Disabling the cache may negatively influence the
-#           performance.
+#     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!
+#     FAKE_SETTIME
+#         - Intercept clock_settime(), settimeofday(), and adjtime()
+#
+#     FORCE_MONOTONIC_FIX
+#         - If the test program hangs forever on
+#                  " pthread_cond_timedwait: CLOCK_MONOTONIC test
+#                    (Intentionally sleeping 1 second...)          "
+#           then add -DFORCE_MONOTONIC_FIX to CFLAGS and recompile.
+#           (This is a platform-specific issue we cannot handle at run-time.)
+#
+#     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
@@ -56,8 +60,8 @@
 # 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. 
+# 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='.'
 
@@ -66,10 +70,20 @@ 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)'"' $(FAKETIME_COMPILE_CFLAGS)
+ifeq ($(PLATFORM),SunOS)
+CFLAGS += -D__EXTENSIONS__ -D_XOPEN_SOURCE=600
+endif
 
-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 -lpthread
+
+LDFLAGS += $(FAKETIME_LINK_FLAGS) -lpthread
+ifneq ($(PLATFORM),SunOS)
+LDFLAGS += -Wl,--version-script=libfaketime.map
+endif
+
 LDADD += -ldl -lm -lrt
 BIN_LDFLAGS += -lrt
 
@@ -82,16 +96,16 @@ LIBS = libfaketime.so.${SONAME} libfaketimeMT.so.${SONAME}
 
 all: ${LIBS} ${BINS}
 
-faketimeMT.o: EXTRA_FLAGS := -DPTHREAD -DPTHREAD_SINGLETHREADED_TIME
+libfaketimeMT.o: EXTRA_FLAGS := -DPTHREAD_SINGLETHREADED_TIME
 
 ${LIBS_OBJ}: libfaketime.c
-	${CC} -o $@ -c ${CFLAGS} ${EXTRA_FLAGS} $<
+	${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} ${EXTRA_FLAGS} $< ${LDFLAGS} ${BIN_LDFLAGS}
+	${CC} -o $@ ${CFLAGS} ${CPPFLAGS} ${EXTRA_FLAGS} $< ${LDFLAGS} ${BIN_LDFLAGS}
 
 clean:
 	@rm -f ${LIBS_OBJ} ${LIBS} ${BINS}

src/Makefile.OSX

@@ -14,19 +14,13 @@
 #
 #     PTHREAD_SINGLETHREADED_TIME
 #         - Define this if you want to single-thread time() ... there ARE
-#           possibile caching side-effects in a multithreaded environment
+#           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()
 #
-#     NO_CACHING
-#         - Disables the caching of the fake time offset. Only disable caching
-#           if you change the fake time offset during program runtime very
-#           frequently. Disabling the cache may negatively influence the
-#           performance.
-#
 #   * Compilation addition: second libMT target added for building the pthread-
 #     enabled library as a separate library
 #
@@ -44,8 +38,8 @@ INSTALL ?= install
 
 PREFIX ?= /usr/local
 
-CFLAGS += -DFAKE_SLEEP -DFAKE_INTERNAL_CALLS -DPREFIX='"'${PREFIX}'"'
-LIB_LDFLAGS += -dynamiclib -current_version 0.9.6 -compatibility_version 0.7
+CFLAGS += -DFAKE_SLEEP -DFAKE_INTERNAL_CALLS -DPREFIX='"'${PREFIX}'"' $(FAKETIME_COMPILE_CFLAGS)
+LIB_LDFLAGS += -dynamiclib -current_version 0.9.8 -compatibility_version 0.7
 
 SONAME = 1
 LIBS = libfaketime.${SONAME}.dylib

src/faketime.c

@@ -1,7 +1,7 @@
 /*
  *  libfaketime wrapper command
  *
- *  This file is part of libfaketime, version 0.9.6
+ *  This file is part of libfaketime, version 0.9.8
  *
  *  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
@@ -48,7 +48,7 @@
 
 #include "faketime_common.h"
 
-const char version[] = "0.9.6";
+const char version[] = "0.9.7";
 
 #ifdef __APPLE__
 static const char *date_cmd = "gdate";
@@ -63,28 +63,29 @@ char sem_name[PATH_BUFSIZE] = {0}, shm_name[PATH_BUFSIZE] = {0};
 
 void usage(const char *name)
 {
-  printf("\n");
-  printf("Usage: %s [switches] <timestamp> <program with arguments>\n", name);
-  printf("\n");
-  printf("This will run the specified 'program' with the given 'arguments'.\n");
-  printf("The program will be tricked into seeing the given 'timestamp' as its starting date and time.\n");
-  printf("The clock will continue to run from this timestamp. Please see the manpage (man faketime)\n");
-  printf("for advanced options, such as stopping the wall clock and make it run faster or slower.\n");
-  printf("\n");
-  printf("The optional switches are:\n");
-  printf("  -m        : Use the multi-threaded version of libfaketime\n");
-  printf("  -f        : Use the advanced timestamp specification format (see manpage)\n");
-  printf("\n");
-  printf("Examples:\n");
-  printf("%s 'last friday 5 pm' /bin/date\n", name);
-  printf("%s '2008-12-24 08:15:42' /bin/date\n", name);
-  printf("%s -f '+2,5y x10,0' /bin/bash -c 'date; while true; do echo $SECONDS ; sleep 1 ; done'\n", name);
-  printf("%s -f '+2,5y x0,50' /bin/bash -c 'date; while true; do echo $SECONDS ; sleep 1 ; done'\n", name);
-  printf("%s -f '+2,5y i2,0' /bin/bash -c 'date; while true; do date; sleep 1 ; done'\n", name);
-  printf("In this single case all spawned processes will use the same global clock\n");
-  printf("without restaring it at the start of each process.\n\n");
-  printf("(Please note that it depends on your locale settings whether . or , has to be used for fractions)\n");
-  printf("\n");
+  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 */
@@ -105,7 +106,6 @@ int main (int argc, char **argv)
   pid_t child_pid;
   int curr_opt = 1;
   bool use_mt = false, use_direct = false;
-  int pfds[2];
   long offset;
 
   while(curr_opt < argc)
@@ -122,6 +122,12 @@ int main (int argc, char **argv)
       curr_opt++;
       continue;
     }
+    else if (0 == strcmp(argv[curr_opt], "--exclude-monotonic"))
+    {
+      setenv("FAKETIME_DONT_FAKE_MONOTONIC", "1", true);
+      curr_opt++;
+      continue;
+    }
     else if ((0 == strcmp(argv[curr_opt], "-v")) ||
              (0 == strcmp(argv[curr_opt], "--version")))
     {
@@ -154,6 +160,7 @@ int main (int argc, char **argv)
   if (!use_direct)
   {
     // TODO get seconds
+    int pfds[2];
     (void) (pipe(pfds) + 1);
     int ret = EXIT_SUCCESS;
 
@@ -183,6 +190,7 @@ int main (int argc, char **argv)
       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
@@ -190,6 +198,8 @@ int main (int argc, char **argv)
     /* 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++;
@@ -199,14 +209,22 @@ int main (int argc, char **argv)
     int shm_fd;
     sem_t *sem;
     struct ft_shared_s *ft_shared;
-    char shared_objs[PATH_BUFSIZE];
+    char shared_objs[PATH_BUFSIZE * 2 + 1];
 
-    snprintf(sem_name, PATH_BUFSIZE -1 ,"/faketime_sem_%d", getpid());
-    snprintf(shm_name, PATH_BUFSIZE -1 ,"/faketime_shm_%d", getpid());
+    /*
+     * 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");
+      fprintf(stderr, "The faketime wrapper only works on platforms that support the sem_open()\nsystem call. However, you may LD_PRELOAD libfaketime without using this wrapper.\n");
       exit(EXIT_FAILURE);
     }
 
@@ -269,7 +287,7 @@ int main (int argc, char **argv)
       exit(EXIT_FAILURE);
     }
 
-    snprintf(shared_objs, PATH_BUFSIZE, "%s %s", sem_name, shm_name);
+    snprintf(shared_objs, sizeof(shared_objs), "%s %s", sem_name, shm_name);
     setenv("FAKETIME_SHARED", shared_objs, true);
     sem_close(sem);
   }
@@ -326,6 +344,7 @@ int main (int argc, char **argv)
   /* 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");
@@ -335,7 +354,10 @@ int main (int argc, char **argv)
   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))
     {
@@ -344,6 +366,8 @@ int main (int argc, char **argv)
     }
     exit(WEXITSTATUS(ret));
   }
+
+  return EXIT_SUCCESS;
 }
 
 /*

src/faketime_common.h

@@ -32,6 +32,10 @@ struct system_time_s
   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 */
@@ -47,4 +51,11 @@ struct ft_shared_s
   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

src/libfaketime.map

@@ -4,7 +4,18 @@ GLIBC_2.2 {
   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;
+

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 */

src/time_ops.h

@@ -60,9 +60,9 @@
 #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);                            \
+    int64_t tmp_time;                                             \
+    tmp_time = (c) * (int64_t) ((tvp)->tv_sec * SEC_TO_##prefix##SEC +        \
+               (int64_t) (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;                                         \
@@ -89,16 +89,28 @@
 #ifndef timersub
 #define timersub(a, b, result) timersub2(a, b, result, u)
 #endif
-#ifndef timersub
+#ifndef timermul
 #define timermul(a, c, result) timermul2(a, c, result, u)
 #endif
 
 /* ops for nanosecs */
+#ifndef timespecisset
 #define timespecisset(tvp) timerisset2(tvp,n)
+#endif
+#ifndef timespecclear
 #define timespecclear(tvp) timerclear2(tvp, n)
+#endif
+#ifndef timespeccmp
 #define timespeccmp(a, b, CMP) timercmp2(a, b, CMP, n)
+#endif
+#ifndef timespecadd
 #define timespecadd(a, b, result) timeradd2(a, b, result, n)
+#endif
+#ifndef timespecsub
 #define timespecsub(a, b, result) timersub2(a, b, result, n)
+#endif
+#ifndef timespecmul
 #define timespecmul(a, c, result) timermul2(a, c, result, n)
+#endif
 
 #endif

test/Makefile

@@ -1,7 +1,7 @@
 CC = gcc
 
-CFLAGS = -std=gnu99 -Wall -DFAKE_STAT -Werror -Wextra
-LDFLAGS = -lrt
+CFLAGS = -std=gnu99 -Wall -DFAKE_STAT -Werror -Wextra $(FAKETIME_COMPILE_CFLAGS)
+LDFLAGS = -lrt -lpthread
 
 SRC = timetest.c
 OBJ = ${SRC:.c=.o}

test/Makefile.OSX

@@ -1,6 +1,6 @@
 CC ?= clang
 
-CFLAGS += -std=gnu99 -Wall -DFAKE_STAT 
+CFLAGS += -std=gnu99 -Wall -DFAKE_STAT $(FAKETIME_COMPILE_CFLAGS)
 
 SRC = timetest.c
 OBJ = ${SRC:.c=.o}

test/README-testframe.txt

@@ -35,5 +35,5 @@
 # 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 funtion, call assertneq or asserteq, or do
+# 6. within each testcase function, call assertneq or asserteq, or do
 #    the equivalent.

test/functests/common.inc

@@ -9,6 +9,7 @@ platform()
 	*Darwin*) echo "mac" ;;
 	*Linux*) echo "linuxlike" ;;
     GNU|GNU/kFreeBSD) echo "linuxlike" ;;
+        *SunOS*) echo "sunos" ;;
 	*) echo 1>&2 unsupported platform, uname=\"$out\" ;;
 	esac
 }
@@ -25,6 +26,15 @@ mac_fakecmd()
 	"$@"
 }
 
+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()
 {

test/functests/test_exclude_mono.sh

@@ -0,0 +1,88 @@
+# Checks that setting FAKETIME_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 FAKETIME_DONT_FAKE_MONOTONIC to 1, calling
+# clock_gettime(CLOCK_MONOTONIC) returns two different values.
+#
+# We also make sure that if we don't set FAKETIME_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;
+    FAKETIME_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}"
+}

test/functests/test_true.sh

@@ -1,4 +1,4 @@
-# test suite that always succeds - for testing framework
+# test suite that always succeeds - for testing framework
 
 run()
 {

test/functests/test_walkone.sh

@@ -37,7 +37,15 @@ fakedate()
 	#
 	typeset fmt='%s'
 	export FAKETIME_FMT=$fmt
-	fakecmd "$1" date +$fmt
+	if [ "mac" == "$PLATFORM" ]; then
+    if [ -x /usr/local/bin/gdate ] ; then
+      	fakecmd "$1" gdate +$fmt
+      else
+        echo "<skip>"
+      fi
+  else
+  	fakecmd "$1" date +$fmt
+  fi
 }
 
 #
@@ -63,5 +71,14 @@ test_with_i()
 	typeset i="$1"
 	typeset t=$(pow 2 $i)
 
-	asserteq $(fakedate $t) $t "(secs since Epoch)"
+  if [ "mac" == "$PLATFORM" ]; then
+    if [ -x /usr/local/bin/gdate ] ; then
+	    asserteq $(fakedate $t) $t "(secs since Epoch)"
+    else
+      asserteq $t $t "(skipping test, install gdate)"
+    fi
+
+  else
+	  asserteq $(fakedate $t) $t "(secs since Epoch)"
+  fi
 }

test/test.sh

@@ -47,9 +47,9 @@ echo
 echo "============================================================================="
 echo
 
-echo "Running the test program with 10 days postive 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 "Running the test program with 10 days positive offset specified, and speed-up factor"
+echo "\$ LD_PRELOAD=../src/libfaketime.so.1 FAKETIME=\"+10d x1\" ./timetest"
+LD_PRELOAD=../src/libfaketime.so.1 FAKETIME="+10d x1" NO_FAKE_STAT=1 ./timetest
 echo
 
 echo "============================================================================="

test/test_OSX.sh

@@ -28,19 +28,25 @@ 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
+# FAKE_STAT is disabled on macOS by default, so testing NO_FAKE_STAT is not useful
+#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 postive offset specified, and sped up 2 times"
+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
+# On more recent macOS versions, the following won't work without copying gdate
+# to a different folder beforehand. We don't do that here, and since the output
+# of these tests must be reviewed manually anyway, the timetest binary should be
+# sufficient to determine whether everything works as planned.
+
+#echo "Running the 'date' command with 15 days negative offset specified"
+#echo "FAKETIME=\"-15d\" date"
+#FAKETIME="-15d" date
+#echo
 
 exit 0

test/timetest.c

@@ -18,19 +18,26 @@
  *  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>
 
+#ifndef __APPLE__
 #ifdef FAKE_STAT
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #endif
+#else
+#include <unistd.h>
+#endif
 
 #ifndef __APPLE__
+#include <pthread.h>
+#include <errno.h>
 #include <signal.h>
 
 #define VERBOSE 0
@@ -49,6 +56,64 @@ handler(int sig, siginfo_t *si, void *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..., see docs about CLOCK_MONOTONIC test)\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)
@@ -64,11 +129,22 @@ int main (int argc, char **argv)
     sigset_t mask;
     struct sigaction sa;
 #endif
+#ifndef __APPLE__
 #ifdef FAKE_STAT
     struct stat buf;
 #endif
+#endif
+
+/* silence compiler warnings */
+printf("%s", 0 == 1 ? argv[0] : "");
 
 #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);
@@ -174,8 +250,8 @@ int main (int argc, char **argv)
     if (VERBOSE == 1)
     {
         printf("timer_gettime(timerid1, &its); its = {{%ld, %ld}, {%ld, %ld}}}\n",
-                its.it_interval.tv_sec, its.it_interval.tv_nsec,
-                its.it_value.tv_sec, its.it_value.tv_nsec);
+                (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);
@@ -188,14 +264,16 @@ int main (int argc, char **argv)
     if (VERBOSE == 1)
     {
         printf("timer_gettime(timerid2, &its); its = {{%ld, %ld}, {%ld, %ld}}}\n",
-            its.it_interval.tv_sec, its.it_interval.tv_nsec,
-            its.it_value.tv_sec, its.it_value.tv_nsec);
+            (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
 
+#ifndef __APPLE__
 #ifdef FAKE_STAT
     lstat(argv[0], &buf);
     printf("stat(): mod. time of file '%s': %s", argv[0], ctime(&buf.st_mtime));
+#endif
 #endif
 
     return 0;