Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/bin/sleep/sleep.c

246 lines
7.0 KiB
C
Raw Normal View History

Deal with overflow when the sleep duration given is a simple integer (previously it was just clamped at the max possible value). This would have caused sleep 10000000000000000000 (or anything bigger) to have only actually slept for 9223372036854775807 secs. Someone would have noticed that happen, one day, in some other universe. This is now an error, as it was previously if this had been entered as sleep 1e19 Also detect an attempt to sleep for so long that a time_t will no longer be able to represent the current time when the sleep is done. Undo the attempts to work around a broken kernel nanosleep() implementation (by only ever issuing shortish sleep requests, and looping). That code was broken (idiot botch of mine) though you would have had to wait a month to observe it happen. I was going to just fix it, but sanity prevailed, and the kernel got fixed instead. That allows this to be much simplified, only looping as needed to handle dealing with SIGINFO. Switch to using clock_nanosleep() to implement the delay, as while our nanosleep() uses CLOCK_MONOTONIC the standards say it should use CLOCK_REALTIME, and if that we ever changed that, the old way would alter "sleep 5" from "sleep for 5 seconds" to "sleep until now + 5 secs", which is subtly different. Always use %g format to print the original sleep duration in reports of how much time remains - this works best for both long and short durations. A couple of other minor (frill) mods to the SIGINFO report message as well.
2019-03-10 18:18:45 +03:00
/* $NetBSD: sleep.c,v 1.30 2019/03/10 15:18:45 kre Exp $ */
convert to new RCS id conventions.
1995-03-21 12:01:59 +03:00
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
/*
Merge 4.4-Lite version.
1994-09-22 13:24:46 +04:00
* Copyright (c) 1988, 1993, 1994
* The Regents of the University of California. All rights reserved.
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
Move UCB-licensed code from 4-clause to 3-clause licence. Patches provided by Joel Baker in PR 22249, verified by myself.
2003-08-07 13:05:01 +04:00
* 3. Neither the name of the University nor the names of its contributors
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
Fix compiler warnings. Add WARNS=1
1997-07-21 01:28:26 +04:00
#include <sys/cdefs.h>
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
#ifndef lint
Remove the \n and tabs from the __COPYRIGHT() strings.
2008-07-20 04:52:39 +04:00
__COPYRIGHT("@(#) Copyright (c) 1988, 1993, 1994\
The Regents of the University of California. All rights reserved.");
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
#endif /* not lint */
#ifndef lint
convert to new RCS id conventions.
1995-03-21 12:01:59 +03:00
#if 0
static char sccsid[] = "@(#)sleep.c 8.3 (Berkeley) 4/2/94";
#else
Deal with overflow when the sleep duration given is a simple integer (previously it was just clamped at the max possible value). This would have caused sleep 10000000000000000000 (or anything bigger) to have only actually slept for 9223372036854775807 secs. Someone would have noticed that happen, one day, in some other universe. This is now an error, as it was previously if this had been entered as sleep 1e19 Also detect an attempt to sleep for so long that a time_t will no longer be able to represent the current time when the sleep is done. Undo the attempts to work around a broken kernel nanosleep() implementation (by only ever issuing shortish sleep requests, and looping). That code was broken (idiot botch of mine) though you would have had to wait a month to observe it happen. I was going to just fix it, but sanity prevailed, and the kernel got fixed instead. That allows this to be much simplified, only looping as needed to handle dealing with SIGINFO. Switch to using clock_nanosleep() to implement the delay, as while our nanosleep() uses CLOCK_MONOTONIC the standards say it should use CLOCK_REALTIME, and if that we ever changed that, the old way would alter "sleep 5" from "sleep for 5 seconds" to "sleep until now + 5 secs", which is subtly different. Always use %g format to print the original sleep duration in reports of how much time remains - this works best for both long and short durations. A couple of other minor (frill) mods to the SIGINFO report message as well.
2019-03-10 18:18:45 +03:00
__RCSID("$NetBSD: sleep.c,v 1.30 2019/03/10 15:18:45 kre Exp $");
convert to new RCS id conventions.
1995-03-21 12:01:59 +03:00
#endif
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
#endif /* not lint */
Make sleep handle non-integer values. Document the same, noting that the extension is grotesquely non-portable. As requested by Denny Gentry in pr-3914. He supplied some code, but I used all my own code in the change, and wrote documentation for the man page. This is creeping featurism at its worst. I added it only because I can't see a good reason for refusing. However, I'm disgusted with myself for doing it anyway.
1997-08-04 05:13:07 +04:00
#include <ctype.h>
PR/14558: Tero Kivinen: Check the return value of nanosleep and don't fail silently.
2001-11-12 17:55:53 +03:00
#include <err.h>
Deal with overflow when the sleep duration given is a simple integer (previously it was just clamped at the max possible value). This would have caused sleep 10000000000000000000 (or anything bigger) to have only actually slept for 9223372036854775807 secs. Someone would have noticed that happen, one day, in some other universe. This is now an error, as it was previously if this had been entered as sleep 1e19 Also detect an attempt to sleep for so long that a time_t will no longer be able to represent the current time when the sleep is done. Undo the attempts to work around a broken kernel nanosleep() implementation (by only ever issuing shortish sleep requests, and looping). That code was broken (idiot botch of mine) though you would have had to wait a month to observe it happen. I was going to just fix it, but sanity prevailed, and the kernel got fixed instead. That allows this to be much simplified, only looping as needed to handle dealing with SIGINFO. Switch to using clock_nanosleep() to implement the delay, as while our nanosleep() uses CLOCK_MONOTONIC the standards say it should use CLOCK_REALTIME, and if that we ever changed that, the old way would alter "sleep 5" from "sleep for 5 seconds" to "sleep until now + 5 secs", which is subtly different. Always use %g format to print the original sleep duration in reports of how much time remains - this works best for both long and short durations. A couple of other minor (frill) mods to the SIGINFO report message as well.
2019-03-10 18:18:45 +03:00
#include <errno.h>
ANSIfy and KNF by Petri Koistinen.
2001-09-17 01:18:33 +04:00
#include <locale.h>
Make sleep handle non-integer values. Document the same, noting that the extension is grotesquely non-portable. As requested by Denny Gentry in pr-3914. He supplied some code, but I used all my own code in the change, and wrote documentation for the man page. This is creeping featurism at its worst. I added it only because I can't see a good reason for refusing. However, I'm disgusted with myself for doing it anyway.
1997-08-04 05:13:07 +04:00
#include <math.h>
#include <signal.h>
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
#include <stdio.h>
#include <stdlib.h>
Deal with overflow when the sleep duration given is a simple integer (previously it was just clamped at the max possible value). This would have caused sleep 10000000000000000000 (or anything bigger) to have only actually slept for 9223372036854775807 secs. Someone would have noticed that happen, one day, in some other universe. This is now an error, as it was previously if this had been entered as sleep 1e19 Also detect an attempt to sleep for so long that a time_t will no longer be able to represent the current time when the sleep is done. Undo the attempts to work around a broken kernel nanosleep() implementation (by only ever issuing shortish sleep requests, and looping). That code was broken (idiot botch of mine) though you would have had to wait a month to observe it happen. I was going to just fix it, but sanity prevailed, and the kernel got fixed instead. That allows this to be much simplified, only looping as needed to handle dealing with SIGINFO. Switch to using clock_nanosleep() to implement the delay, as while our nanosleep() uses CLOCK_MONOTONIC the standards say it should use CLOCK_REALTIME, and if that we ever changed that, the old way would alter "sleep 5" from "sleep for 5 seconds" to "sleep until now + 5 secs", which is subtly different. Always use %g format to print the original sleep duration in reports of how much time remains - this works best for both long and short durations. A couple of other minor (frill) mods to the SIGINFO report message as well.
2019-03-10 18:18:45 +03:00
#include <string.h>
ANSIfy and KNF by Petri Koistinen.
2001-09-17 01:18:33 +04:00
#include <time.h>
Merge 4.4-Lite version.
1994-09-22 13:24:46 +04:00
#include <unistd.h>
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
Use __dead
2011-08-29 18:51:17 +04:00
__dead static void alarmhandle(int);
__dead static void usage(void);
Merge 4.4-Lite version.
1994-09-22 13:24:46 +04:00
Adjust the way the arg string is parsed in the "not entirely integer" case, so we avoid adjusting the locale of sleep, and generally be more reliable and simpler. In addition, deal with weirdness in nanosleep() when the interval gets long, by avoiding using it. In this version when the sleep interval < 10000 seconds, we use nanosleep() as before, for delays longer than that we use sleep() instead, and ignore any fractional seconds. We avoid overflow problems here by not bothering to sleep at all for delays longer than 135 years (approx) and simply pause() instead. That sleep never terminates in such a case is unlikely to ever be observed. This commit makes no decision on the question of whether the arg should be interpreted in the locale of the user, or always in the C locale. That is for another day.
2019-01-26 18:19:08 +03:00
static void report(const time_t, const time_t, const char *const);
add SIGINFO support; from freebsd: when a SIGINFO is delivered, display the approximate remaining seconds.
2010-10-09 08:57:30 +04:00
static volatile sig_atomic_t report_requested;
static void
report_request(int signo __unused)
{
report_requested = 1;
}
Quiet compiler warnings by explicitly declaring return value of main().
1993-09-10 22:52:27 +04:00
int
ANSIfy and KNF by Petri Koistinen.
2001-09-17 01:18:33 +04:00
main(int argc, char *argv[])
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
{
Make sleep handle non-integer values. Document the same, noting that the extension is grotesquely non-portable. As requested by Denny Gentry in pr-3914. He supplied some code, but I used all my own code in the change, and wrote documentation for the man page. This is creeping featurism at its worst. I added it only because I can't see a good reason for refusing. However, I'm disgusted with myself for doing it anyway.
1997-08-04 05:13:07 +04:00
char *arg, *temp;
Allow the decimal radix character '.' to work, regardless of what the current locale's radix character happens to be, while still allowing locale specific entry of fractional seconds (ie: if you're in locale where the radix character is ',' you san use "sleep 2.5" or "sleep 2,5" and they accomplish the same thing). This avoids issues with the "sleep 0.05" in rc.subr which generated usage messages when a locale that does not use '.' as its radix character was in use. Reported on netbsd-users by Dima Veselov, with the problem diagnosed by Martin Husemann While here, tighten the arg validity checking (3+4 is no longer permitted as a synonym of 3) and allow 0.0 to mean the same thing as 0 rather than being an error. Also, make the SIGINFO reports a little nicer (IMO). The ATF tests for sleep all pass (not that that means a lot).
2019-01-19 16:27:12 +03:00
const char *msg;
ANSIfy and KNF by Petri Koistinen.
2001-09-17 01:18:33 +04:00
double fval, ival, val;
Make sleep handle non-integer values. Document the same, noting that the extension is grotesquely non-portable. As requested by Denny Gentry in pr-3914. He supplied some code, but I used all my own code in the change, and wrote documentation for the man page. This is creeping featurism at its worst. I added it only because I can't see a good reason for refusing. However, I'm disgusted with myself for doing it anyway.
1997-08-04 05:13:07 +04:00
struct timespec ntime;
Deal with overflow when the sleep duration given is a simple integer (previously it was just clamped at the max possible value). This would have caused sleep 10000000000000000000 (or anything bigger) to have only actually slept for 9223372036854775807 secs. Someone would have noticed that happen, one day, in some other universe. This is now an error, as it was previously if this had been entered as sleep 1e19 Also detect an attempt to sleep for so long that a time_t will no longer be able to represent the current time when the sleep is done. Undo the attempts to work around a broken kernel nanosleep() implementation (by only ever issuing shortish sleep requests, and looping). That code was broken (idiot botch of mine) though you would have had to wait a month to observe it happen. I was going to just fix it, but sanity prevailed, and the kernel got fixed instead. That allows this to be much simplified, only looping as needed to handle dealing with SIGINFO. Switch to using clock_nanosleep() to implement the delay, as while our nanosleep() uses CLOCK_MONOTONIC the standards say it should use CLOCK_REALTIME, and if that we ever changed that, the old way would alter "sleep 5" from "sleep for 5 seconds" to "sleep until now + 5 secs", which is subtly different. Always use %g format to print the original sleep duration in reports of how much time remains - this works best for both long and short durations. A couple of other minor (frill) mods to the SIGINFO report message as well.
2019-03-10 18:18:45 +03:00
struct timespec endtime;
struct timespec now;
add SIGINFO support; from freebsd: when a SIGINFO is delivered, display the approximate remaining seconds.
2010-10-09 08:57:30 +04:00
time_t original;
Adjust the way the arg string is parsed in the "not entirely integer" case, so we avoid adjusting the locale of sleep, and generally be more reliable and simpler. In addition, deal with weirdness in nanosleep() when the interval gets long, by avoiding using it. In this version when the sleep interval < 10000 seconds, we use nanosleep() as before, for delays longer than that we use sleep() instead, and ignore any fractional seconds. We avoid overflow problems here by not bothering to sleep at all for delays longer than 135 years (approx) and simply pause() instead. That sleep never terminates in such a case is unlikely to ever be observed. This commit makes no decision on the question of whether the arg should be interpreted in the locale of the user, or always in the C locale. That is for another day.
2019-01-26 18:19:08 +03:00
int ch, fracflag;
Merge 4.4-Lite version.
1994-09-22 13:24:46 +04:00
ANSIfy and KNF by Petri Koistinen.
2001-09-17 01:18:33 +04:00
setprogname(argv[0]);
lint
1997-11-06 00:17:14 +03:00
(void)setlocale(LC_ALL, "");
Merge 4.4-Lite version.
1994-09-22 13:24:46 +04:00
Make sleep handle non-integer values. Document the same, noting that the extension is grotesquely non-portable. As requested by Denny Gentry in pr-3914. He supplied some code, but I used all my own code in the change, and wrote documentation for the man page. This is creeping featurism at its worst. I added it only because I can't see a good reason for refusing. However, I'm disgusted with myself for doing it anyway.
1997-08-04 05:13:07 +04:00
(void)signal(SIGALRM, alarmhandle);
- getopt returns -1 not EOF - use .Nm appropriately
1997-09-14 11:31:56 +04:00
while ((ch = getopt(argc, argv, "")) != -1)
Merge 4.4-Lite version.
1994-09-22 13:24:46 +04:00
switch(ch) {
default:
usage();
}
argc -= optind;
argv += optind;
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
Merge 4.4-Lite version.
1994-09-22 13:24:46 +04:00
if (argc != 1)
usage();
localization & manpage update.
1993-12-31 22:30:00 +03:00
Make sleep handle non-integer values. Document the same, noting that the extension is grotesquely non-portable. As requested by Denny Gentry in pr-3914. He supplied some code, but I used all my own code in the change, and wrote documentation for the man page. This is creeping featurism at its worst. I added it only because I can't see a good reason for refusing. However, I'm disgusted with myself for doing it anyway.
1997-08-04 05:13:07 +04:00
/*
* Okay, why not just use atof for everything? Why bother
* checking if there is a fraction in use? Because the old
* sleep handled the full range of integers, that's why, and a
* double can't handle a large long. This is fairly useless
* given how large a number a double can hold on most
* machines, but now we won't ever have trouble. If you want
* 1000000000.9 seconds of sleep, well, that's your
* problem. Why use an isdigit() check instead of checking for
* a period? Because doing it this way means locales will be
* handled transparently by the atof code.
Allow the decimal radix character '.' to work, regardless of what the current locale's radix character happens to be, while still allowing locale specific entry of fractional seconds (ie: if you're in locale where the radix character is ',' you san use "sleep 2.5" or "sleep 2,5" and they accomplish the same thing). This avoids issues with the "sleep 0.05" in rc.subr which generated usage messages when a locale that does not use '.' as its radix character was in use. Reported on netbsd-users by Dima Veselov, with the problem diagnosed by Martin Husemann While here, tighten the arg validity checking (3+4 is no longer permitted as a synonym of 3) and allow 0.0 to mean the same thing as 0 rather than being an error. Also, make the SIGINFO reports a little nicer (IMO). The ATF tests for sleep all pass (not that that means a lot).
2019-01-19 16:27:12 +03:00
*
* Since fracflag is set for any non-digit, we also fall
* into the floating point conversion path if the input
* is hex (the 'x' in 0xA is not a digit). Then if
* strtod() handles hex (on NetBSD it does) so will we.
While cute, the previous version is not really safe. After all, a system might want to sleep for several thousand years on a spaceship headed to a distant solar system... So, remove the pause() code, deal with limits on the range (it is just an int) that can be passed to sleep() by looping, and do a much better job of checking for out of range input values. With this change sleep(1) should work for durations up to something more than 250 billion years. It fails (at startup, with an error) if the requested duration is beyond what can be handled. Here no changes at all related to locales and arg parsing. Still for another day.
2019-01-26 18:20:50 +03:00
* That path is also taken for scientific notation (1.2e+3)
* and when the input is simply nonsense.
Make sleep handle non-integer values. Document the same, noting that the extension is grotesquely non-portable. As requested by Denny Gentry in pr-3914. He supplied some code, but I used all my own code in the change, and wrote documentation for the man page. This is creeping featurism at its worst. I added it only because I can't see a good reason for refusing. However, I'm disgusted with myself for doing it anyway.
1997-08-04 05:13:07 +04:00
*/
fracflag = 0;
arg = *argv;
for (temp = arg; *temp != '\0'; temp++)
Allow the decimal radix character '.' to work, regardless of what the current locale's radix character happens to be, while still allowing locale specific entry of fractional seconds (ie: if you're in locale where the radix character is ',' you san use "sleep 2.5" or "sleep 2,5" and they accomplish the same thing). This avoids issues with the "sleep 0.05" in rc.subr which generated usage messages when a locale that does not use '.' as its radix character was in use. Reported on netbsd-users by Dima Veselov, with the problem diagnosed by Martin Husemann While here, tighten the arg validity checking (3+4 is no longer permitted as a synonym of 3) and allow 0.0 to mean the same thing as 0 rather than being an error. Also, make the SIGINFO reports a little nicer (IMO). The ATF tests for sleep all pass (not that that means a lot).
2019-01-19 16:27:12 +03:00
if (!isdigit((unsigned char)*temp)) {
ch = *temp;
Make sleep handle non-integer values. Document the same, noting that the extension is grotesquely non-portable. As requested by Denny Gentry in pr-3914. He supplied some code, but I used all my own code in the change, and wrote documentation for the man page. This is creeping featurism at its worst. I added it only because I can't see a good reason for refusing. However, I'm disgusted with myself for doing it anyway.
1997-08-04 05:13:07 +04:00
fracflag++;
Allow the decimal radix character '.' to work, regardless of what the current locale's radix character happens to be, while still allowing locale specific entry of fractional seconds (ie: if you're in locale where the radix character is ',' you san use "sleep 2.5" or "sleep 2,5" and they accomplish the same thing). This avoids issues with the "sleep 0.05" in rc.subr which generated usage messages when a locale that does not use '.' as its radix character was in use. Reported on netbsd-users by Dima Veselov, with the problem diagnosed by Martin Husemann While here, tighten the arg validity checking (3+4 is no longer permitted as a synonym of 3) and allow 0.0 to mean the same thing as 0 rather than being an error. Also, make the SIGINFO reports a little nicer (IMO). The ATF tests for sleep all pass (not that that means a lot).
2019-01-19 16:27:12 +03:00
}
Make sleep handle non-integer values. Document the same, noting that the extension is grotesquely non-portable. As requested by Denny Gentry in pr-3914. He supplied some code, but I used all my own code in the change, and wrote documentation for the man page. This is creeping featurism at its worst. I added it only because I can't see a good reason for refusing. However, I'm disgusted with myself for doing it anyway.
1997-08-04 05:13:07 +04:00
if (fracflag) {
Allow the decimal radix character '.' to work, regardless of what the current locale's radix character happens to be, while still allowing locale specific entry of fractional seconds (ie: if you're in locale where the radix character is ',' you san use "sleep 2.5" or "sleep 2,5" and they accomplish the same thing). This avoids issues with the "sleep 0.05" in rc.subr which generated usage messages when a locale that does not use '.' as its radix character was in use. Reported on netbsd-users by Dima Veselov, with the problem diagnosed by Martin Husemann While here, tighten the arg validity checking (3+4 is no longer permitted as a synonym of 3) and allow 0.0 to mean the same thing as 0 rather than being an error. Also, make the SIGINFO reports a little nicer (IMO). The ATF tests for sleep all pass (not that that means a lot).
2019-01-19 16:27:12 +03:00
/*
Adjust the way the arg string is parsed in the "not entirely integer" case, so we avoid adjusting the locale of sleep, and generally be more reliable and simpler. In addition, deal with weirdness in nanosleep() when the interval gets long, by avoiding using it. In this version when the sleep interval < 10000 seconds, we use nanosleep() as before, for delays longer than that we use sleep() instead, and ignore any fractional seconds. We avoid overflow problems here by not bothering to sleep at all for delays longer than 135 years (approx) and simply pause() instead. That sleep never terminates in such a case is unlikely to ever be observed. This commit makes no decision on the question of whether the arg should be interpreted in the locale of the user, or always in the C locale. That is for another day.
2019-01-26 18:19:08 +03:00
* If we cannot convert the value using the user's locale
* then try again using the C locale, so strtod() can always
* parse values like 2.5, even if the user's locale uses
* a different decimal radix character (like ',')
*
* (but only if that is the potential problem)
Allow the decimal radix character '.' to work, regardless of what the current locale's radix character happens to be, while still allowing locale specific entry of fractional seconds (ie: if you're in locale where the radix character is ',' you san use "sleep 2.5" or "sleep 2,5" and they accomplish the same thing). This avoids issues with the "sleep 0.05" in rc.subr which generated usage messages when a locale that does not use '.' as its radix character was in use. Reported on netbsd-users by Dima Veselov, with the problem diagnosed by Martin Husemann While here, tighten the arg validity checking (3+4 is no longer permitted as a synonym of 3) and allow 0.0 to mean the same thing as 0 rather than being an error. Also, make the SIGINFO reports a little nicer (IMO). The ATF tests for sleep all pass (not that that means a lot).
2019-01-19 16:27:12 +03:00
*/
val = strtod(arg, &temp);
Adjust the way the arg string is parsed in the "not entirely integer" case, so we avoid adjusting the locale of sleep, and generally be more reliable and simpler. In addition, deal with weirdness in nanosleep() when the interval gets long, by avoiding using it. In this version when the sleep interval < 10000 seconds, we use nanosleep() as before, for delays longer than that we use sleep() instead, and ignore any fractional seconds. We avoid overflow problems here by not bothering to sleep at all for delays longer than 135 years (approx) and simply pause() instead. That sleep never terminates in such a case is unlikely to ever be observed. This commit makes no decision on the question of whether the arg should be interpreted in the locale of the user, or always in the C locale. That is for another day.
2019-01-26 18:19:08 +03:00
if (*temp != '\0')
val = strtod_l(arg, &temp, LC_C_LOCALE);
Allow the decimal radix character '.' to work, regardless of what the current locale's radix character happens to be, while still allowing locale specific entry of fractional seconds (ie: if you're in locale where the radix character is ',' you san use "sleep 2.5" or "sleep 2,5" and they accomplish the same thing). This avoids issues with the "sleep 0.05" in rc.subr which generated usage messages when a locale that does not use '.' as its radix character was in use. Reported on netbsd-users by Dima Veselov, with the problem diagnosed by Martin Husemann While here, tighten the arg validity checking (3+4 is no longer permitted as a synonym of 3) and allow 0.0 to mean the same thing as 0 rather than being an error. Also, make the SIGINFO reports a little nicer (IMO). The ATF tests for sleep all pass (not that that means a lot).
2019-01-19 16:27:12 +03:00
if (val < 0 || temp == arg || *temp != '\0')
PR/27140: "sleep time" doesn't error out. Apply fix from Dheeraj Reddy.
2005-10-17 14:11:46 +04:00
usage();
While cute, the previous version is not really safe. After all, a system might want to sleep for several thousand years on a spaceship headed to a distant solar system... So, remove the pause() code, deal with limits on the range (it is just an int) that can be passed to sleep() by looping, and do a much better job of checking for out of range input values. With this change sleep(1) should work for durations up to something more than 250 billion years. It fails (at startup, with an error) if the requested duration is beyond what can be handled. Here no changes at all related to locales and arg parsing. Still for another day.
2019-01-26 18:20:50 +03:00
Make sleep handle non-integer values. Document the same, noting that the extension is grotesquely non-portable. As requested by Denny Gentry in pr-3914. He supplied some code, but I used all my own code in the change, and wrote documentation for the man page. This is creeping featurism at its worst. I added it only because I can't see a good reason for refusing. However, I'm disgusted with myself for doing it anyway.
1997-08-04 05:13:07 +04:00
ival = floor(val);
fval = (1000000000 * (val-ival));
While cute, the previous version is not really safe. After all, a system might want to sleep for several thousand years on a spaceship headed to a distant solar system... So, remove the pause() code, deal with limits on the range (it is just an int) that can be passed to sleep() by looping, and do a much better job of checking for out of range input values. With this change sleep(1) should work for durations up to something more than 250 billion years. It fails (at startup, with an error) if the requested duration is beyond what can be handled. Here no changes at all related to locales and arg parsing. Still for another day.
2019-01-26 18:20:50 +03:00
ntime.tv_sec = ival;
if ((double)ntime.tv_sec != ival)
errx(1, "requested delay (%s) out of range", arg);
Make sleep handle non-integer values. Document the same, noting that the extension is grotesquely non-portable. As requested by Denny Gentry in pr-3914. He supplied some code, but I used all my own code in the change, and wrote documentation for the man page. This is creeping featurism at its worst. I added it only because I can't see a good reason for refusing. However, I'm disgusted with myself for doing it anyway.
1997-08-04 05:13:07 +04:00
ntime.tv_nsec = fval;
While cute, the previous version is not really safe. After all, a system might want to sleep for several thousand years on a spaceship headed to a distant solar system... So, remove the pause() code, deal with limits on the range (it is just an int) that can be passed to sleep() by looping, and do a much better job of checking for out of range input values. With this change sleep(1) should work for durations up to something more than 250 billion years. It fails (at startup, with an error) if the requested duration is beyond what can be handled. Here no changes at all related to locales and arg parsing. Still for another day.
2019-01-26 18:20:50 +03:00
Allow the decimal radix character '.' to work, regardless of what the current locale's radix character happens to be, while still allowing locale specific entry of fractional seconds (ie: if you're in locale where the radix character is ',' you san use "sleep 2.5" or "sleep 2,5" and they accomplish the same thing). This avoids issues with the "sleep 0.05" in rc.subr which generated usage messages when a locale that does not use '.' as its radix character was in use. Reported on netbsd-users by Dima Veselov, with the problem diagnosed by Martin Husemann While here, tighten the arg validity checking (3+4 is no longer permitted as a synonym of 3) and allow 0.0 to mean the same thing as 0 rather than being an error. Also, make the SIGINFO reports a little nicer (IMO). The ATF tests for sleep all pass (not that that means a lot).
2019-01-19 16:27:12 +03:00
if (ntime.tv_sec == 0 && ntime.tv_nsec == 0)
return EXIT_SUCCESS; /* was 0.0 or underflowed */
} else {
Deal with overflow when the sleep duration given is a simple integer (previously it was just clamped at the max possible value). This would have caused sleep 10000000000000000000 (or anything bigger) to have only actually slept for 9223372036854775807 secs. Someone would have noticed that happen, one day, in some other universe. This is now an error, as it was previously if this had been entered as sleep 1e19 Also detect an attempt to sleep for so long that a time_t will no longer be able to represent the current time when the sleep is done. Undo the attempts to work around a broken kernel nanosleep() implementation (by only ever issuing shortish sleep requests, and looping). That code was broken (idiot botch of mine) though you would have had to wait a month to observe it happen. I was going to just fix it, but sanity prevailed, and the kernel got fixed instead. That allows this to be much simplified, only looping as needed to handle dealing with SIGINFO. Switch to using clock_nanosleep() to implement the delay, as while our nanosleep() uses CLOCK_MONOTONIC the standards say it should use CLOCK_REALTIME, and if that we ever changed that, the old way would alter "sleep 5" from "sleep for 5 seconds" to "sleep until now + 5 secs", which is subtly different. Always use %g format to print the original sleep duration in reports of how much time remains - this works best for both long and short durations. A couple of other minor (frill) mods to the SIGINFO report message as well.
2019-03-10 18:18:45 +03:00
errno = 0;
Allow the decimal radix character '.' to work, regardless of what the current locale's radix character happens to be, while still allowing locale specific entry of fractional seconds (ie: if you're in locale where the radix character is ',' you san use "sleep 2.5" or "sleep 2,5" and they accomplish the same thing). This avoids issues with the "sleep 0.05" in rc.subr which generated usage messages when a locale that does not use '.' as its radix character was in use. Reported on netbsd-users by Dima Veselov, with the problem diagnosed by Martin Husemann While here, tighten the arg validity checking (3+4 is no longer permitted as a synonym of 3) and allow 0.0 to mean the same thing as 0 rather than being an error. Also, make the SIGINFO reports a little nicer (IMO). The ATF tests for sleep all pass (not that that means a lot).
2019-01-19 16:27:12 +03:00
ntime.tv_sec = strtol(arg, &temp, 10);
if (ntime.tv_sec < 0 || temp == arg || *temp != '\0')
usage();
Deal with overflow when the sleep duration given is a simple integer (previously it was just clamped at the max possible value). This would have caused sleep 10000000000000000000 (or anything bigger) to have only actually slept for 9223372036854775807 secs. Someone would have noticed that happen, one day, in some other universe. This is now an error, as it was previously if this had been entered as sleep 1e19 Also detect an attempt to sleep for so long that a time_t will no longer be able to represent the current time when the sleep is done. Undo the attempts to work around a broken kernel nanosleep() implementation (by only ever issuing shortish sleep requests, and looping). That code was broken (idiot botch of mine) though you would have had to wait a month to observe it happen. I was going to just fix it, but sanity prevailed, and the kernel got fixed instead. That allows this to be much simplified, only looping as needed to handle dealing with SIGINFO. Switch to using clock_nanosleep() to implement the delay, as while our nanosleep() uses CLOCK_MONOTONIC the standards say it should use CLOCK_REALTIME, and if that we ever changed that, the old way would alter "sleep 5" from "sleep for 5 seconds" to "sleep until now + 5 secs", which is subtly different. Always use %g format to print the original sleep duration in reports of how much time remains - this works best for both long and short durations. A couple of other minor (frill) mods to the SIGINFO report message as well.
2019-03-10 18:18:45 +03:00
if (errno == ERANGE)
errx(EXIT_FAILURE, "Requested delay (%s) out of range",
arg);
else if (errno != 0)
err(EXIT_FAILURE, "Requested delay (%s)", arg);
While cute, the previous version is not really safe. After all, a system might want to sleep for several thousand years on a spaceship headed to a distant solar system... So, remove the pause() code, deal with limits on the range (it is just an int) that can be passed to sleep() by looping, and do a much better job of checking for out of range input values. With this change sleep(1) should work for durations up to something more than 250 billion years. It fails (at startup, with an error) if the requested duration is beyond what can be handled. Here no changes at all related to locales and arg parsing. Still for another day.
2019-01-26 18:20:50 +03:00
Allow the decimal radix character '.' to work, regardless of what the current locale's radix character happens to be, while still allowing locale specific entry of fractional seconds (ie: if you're in locale where the radix character is ',' you san use "sleep 2.5" or "sleep 2,5" and they accomplish the same thing). This avoids issues with the "sleep 0.05" in rc.subr which generated usage messages when a locale that does not use '.' as its radix character was in use. Reported on netbsd-users by Dima Veselov, with the problem diagnosed by Martin Husemann While here, tighten the arg validity checking (3+4 is no longer permitted as a synonym of 3) and allow 0.0 to mean the same thing as 0 rather than being an error. Also, make the SIGINFO reports a little nicer (IMO). The ATF tests for sleep all pass (not that that means a lot).
2019-01-19 16:27:12 +03:00
if (ntime.tv_sec == 0)
- Cleanup for sleep.c: + mark two functions as static + remove case '?' in switch() before default + use return instead of exit() in main() function + use constants EXIT_SUCCESS/EXIT_FAILURE instead of 0/1 - In man sleep(1): + cleanup example Patch submitted by Slava Semushin <php-coder@altlinux.ru> in private email.
2007-08-18 04:41:52 +04:00
return EXIT_SUCCESS;
Make sleep handle non-integer values. Document the same, noting that the extension is grotesquely non-portable. As requested by Denny Gentry in pr-3914. He supplied some code, but I used all my own code in the change, and wrote documentation for the man page. This is creeping featurism at its worst. I added it only because I can't see a good reason for refusing. However, I'm disgusted with myself for doing it anyway.
1997-08-04 05:13:07 +04:00
ntime.tv_nsec = 0;
}
add SIGINFO support; from freebsd: when a SIGINFO is delivered, display the approximate remaining seconds.
2010-10-09 08:57:30 +04:00
original = ntime.tv_sec;
Deal with overflow when the sleep duration given is a simple integer (previously it was just clamped at the max possible value). This would have caused sleep 10000000000000000000 (or anything bigger) to have only actually slept for 9223372036854775807 secs. Someone would have noticed that happen, one day, in some other universe. This is now an error, as it was previously if this had been entered as sleep 1e19 Also detect an attempt to sleep for so long that a time_t will no longer be able to represent the current time when the sleep is done. Undo the attempts to work around a broken kernel nanosleep() implementation (by only ever issuing shortish sleep requests, and looping). That code was broken (idiot botch of mine) though you would have had to wait a month to observe it happen. I was going to just fix it, but sanity prevailed, and the kernel got fixed instead. That allows this to be much simplified, only looping as needed to handle dealing with SIGINFO. Switch to using clock_nanosleep() to implement the delay, as while our nanosleep() uses CLOCK_MONOTONIC the standards say it should use CLOCK_REALTIME, and if that we ever changed that, the old way would alter "sleep 5" from "sleep for 5 seconds" to "sleep until now + 5 secs", which is subtly different. Always use %g format to print the original sleep duration in reports of how much time remains - this works best for both long and short durations. A couple of other minor (frill) mods to the SIGINFO report message as well.
2019-03-10 18:18:45 +03:00
if (original < 86400) {
if (ntime.tv_nsec > 1000000000 * 2 / 3) {
original++;
msg = " less a bit";
} else if (ntime.tv_nsec != 0)
msg = " and a bit";
else
msg = "";
} else
Allow the decimal radix character '.' to work, regardless of what the current locale's radix character happens to be, while still allowing locale specific entry of fractional seconds (ie: if you're in locale where the radix character is ',' you san use "sleep 2.5" or "sleep 2,5" and they accomplish the same thing). This avoids issues with the "sleep 0.05" in rc.subr which generated usage messages when a locale that does not use '.' as its radix character was in use. Reported on netbsd-users by Dima Veselov, with the problem diagnosed by Martin Husemann While here, tighten the arg validity checking (3+4 is no longer permitted as a synonym of 3) and allow 0.0 to mean the same thing as 0 rather than being an error. Also, make the SIGINFO reports a little nicer (IMO). The ATF tests for sleep all pass (not that that means a lot).
2019-01-19 16:27:12 +03:00
msg = "";
Deal with overflow when the sleep duration given is a simple integer (previously it was just clamped at the max possible value). This would have caused sleep 10000000000000000000 (or anything bigger) to have only actually slept for 9223372036854775807 secs. Someone would have noticed that happen, one day, in some other universe. This is now an error, as it was previously if this had been entered as sleep 1e19 Also detect an attempt to sleep for so long that a time_t will no longer be able to represent the current time when the sleep is done. Undo the attempts to work around a broken kernel nanosleep() implementation (by only ever issuing shortish sleep requests, and looping). That code was broken (idiot botch of mine) though you would have had to wait a month to observe it happen. I was going to just fix it, but sanity prevailed, and the kernel got fixed instead. That allows this to be much simplified, only looping as needed to handle dealing with SIGINFO. Switch to using clock_nanosleep() to implement the delay, as while our nanosleep() uses CLOCK_MONOTONIC the standards say it should use CLOCK_REALTIME, and if that we ever changed that, the old way would alter "sleep 5" from "sleep for 5 seconds" to "sleep until now + 5 secs", which is subtly different. Always use %g format to print the original sleep duration in reports of how much time remains - this works best for both long and short durations. A couple of other minor (frill) mods to the SIGINFO report message as well.
2019-03-10 18:18:45 +03:00
if (clock_gettime(CLOCK_MONOTONIC, &now) != 0)
err(EXIT_FAILURE, "clock_gettime");
timespecadd(&now, &ntime, &endtime);
if (endtime.tv_sec < now.tv_sec || (endtime.tv_sec == now.tv_sec &&
endtime.tv_nsec <= now.tv_nsec))
errx(EXIT_FAILURE, "cannot sleep beyond the end of time");
add SIGINFO support; from freebsd: when a SIGINFO is delivered, display the approximate remaining seconds.
2010-10-09 08:57:30 +04:00
signal(SIGINFO, report_request);
Deal with overflow when the sleep duration given is a simple integer (previously it was just clamped at the max possible value). This would have caused sleep 10000000000000000000 (or anything bigger) to have only actually slept for 9223372036854775807 secs. Someone would have noticed that happen, one day, in some other universe. This is now an error, as it was previously if this had been entered as sleep 1e19 Also detect an attempt to sleep for so long that a time_t will no longer be able to represent the current time when the sleep is done. Undo the attempts to work around a broken kernel nanosleep() implementation (by only ever issuing shortish sleep requests, and looping). That code was broken (idiot botch of mine) though you would have had to wait a month to observe it happen. I was going to just fix it, but sanity prevailed, and the kernel got fixed instead. That allows this to be much simplified, only looping as needed to handle dealing with SIGINFO. Switch to using clock_nanosleep() to implement the delay, as while our nanosleep() uses CLOCK_MONOTONIC the standards say it should use CLOCK_REALTIME, and if that we ever changed that, the old way would alter "sleep 5" from "sleep for 5 seconds" to "sleep until now + 5 secs", which is subtly different. Always use %g format to print the original sleep duration in reports of how much time remains - this works best for both long and short durations. A couple of other minor (frill) mods to the SIGINFO report message as well.
2019-03-10 18:18:45 +03:00
for (;;) {
int e;
add SIGINFO support; from freebsd: when a SIGINFO is delivered, display the approximate remaining seconds.
2010-10-09 08:57:30 +04:00
Deal with overflow when the sleep duration given is a simple integer (previously it was just clamped at the max possible value). This would have caused sleep 10000000000000000000 (or anything bigger) to have only actually slept for 9223372036854775807 secs. Someone would have noticed that happen, one day, in some other universe. This is now an error, as it was previously if this had been entered as sleep 1e19 Also detect an attempt to sleep for so long that a time_t will no longer be able to represent the current time when the sleep is done. Undo the attempts to work around a broken kernel nanosleep() implementation (by only ever issuing shortish sleep requests, and looping). That code was broken (idiot botch of mine) though you would have had to wait a month to observe it happen. I was going to just fix it, but sanity prevailed, and the kernel got fixed instead. That allows this to be much simplified, only looping as needed to handle dealing with SIGINFO. Switch to using clock_nanosleep() to implement the delay, as while our nanosleep() uses CLOCK_MONOTONIC the standards say it should use CLOCK_REALTIME, and if that we ever changed that, the old way would alter "sleep 5" from "sleep for 5 seconds" to "sleep until now + 5 secs", which is subtly different. Always use %g format to print the original sleep duration in reports of how much time remains - this works best for both long and short durations. A couple of other minor (frill) mods to the SIGINFO report message as well.
2019-03-10 18:18:45 +03:00
if ((e = clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME,
&endtime, NULL)) == 0)
return EXIT_SUCCESS;
While cute, the previous version is not really safe. After all, a system might want to sleep for several thousand years on a spaceship headed to a distant solar system... So, remove the pause() code, deal with limits on the range (it is just an int) that can be passed to sleep() by looping, and do a much better job of checking for out of range input values. With this change sleep(1) should work for durations up to something more than 250 billion years. It fails (at startup, with an error) if the requested duration is beyond what can be handled. Here no changes at all related to locales and arg parsing. Still for another day.
2019-01-26 18:20:50 +03:00
Deal with overflow when the sleep duration given is a simple integer (previously it was just clamped at the max possible value). This would have caused sleep 10000000000000000000 (or anything bigger) to have only actually slept for 9223372036854775807 secs. Someone would have noticed that happen, one day, in some other universe. This is now an error, as it was previously if this had been entered as sleep 1e19 Also detect an attempt to sleep for so long that a time_t will no longer be able to represent the current time when the sleep is done. Undo the attempts to work around a broken kernel nanosleep() implementation (by only ever issuing shortish sleep requests, and looping). That code was broken (idiot botch of mine) though you would have had to wait a month to observe it happen. I was going to just fix it, but sanity prevailed, and the kernel got fixed instead. That allows this to be much simplified, only looping as needed to handle dealing with SIGINFO. Switch to using clock_nanosleep() to implement the delay, as while our nanosleep() uses CLOCK_MONOTONIC the standards say it should use CLOCK_REALTIME, and if that we ever changed that, the old way would alter "sleep 5" from "sleep for 5 seconds" to "sleep until now + 5 secs", which is subtly different. Always use %g format to print the original sleep duration in reports of how much time remains - this works best for both long and short durations. A couple of other minor (frill) mods to the SIGINFO report message as well.
2019-03-10 18:18:45 +03:00
if (!report_requested || e != EINTR) {
errno = e;
err(EXIT_FAILURE, "clock_nanotime");
}
While cute, the previous version is not really safe. After all, a system might want to sleep for several thousand years on a spaceship headed to a distant solar system... So, remove the pause() code, deal with limits on the range (it is just an int) that can be passed to sleep() by looping, and do a much better job of checking for out of range input values. With this change sleep(1) should work for durations up to something more than 250 billion years. It fails (at startup, with an error) if the requested duration is beyond what can be handled. Here no changes at all related to locales and arg parsing. Still for another day.
2019-01-26 18:20:50 +03:00
Deal with overflow when the sleep duration given is a simple integer (previously it was just clamped at the max possible value). This would have caused sleep 10000000000000000000 (or anything bigger) to have only actually slept for 9223372036854775807 secs. Someone would have noticed that happen, one day, in some other universe. This is now an error, as it was previously if this had been entered as sleep 1e19 Also detect an attempt to sleep for so long that a time_t will no longer be able to represent the current time when the sleep is done. Undo the attempts to work around a broken kernel nanosleep() implementation (by only ever issuing shortish sleep requests, and looping). That code was broken (idiot botch of mine) though you would have had to wait a month to observe it happen. I was going to just fix it, but sanity prevailed, and the kernel got fixed instead. That allows this to be much simplified, only looping as needed to handle dealing with SIGINFO. Switch to using clock_nanosleep() to implement the delay, as while our nanosleep() uses CLOCK_MONOTONIC the standards say it should use CLOCK_REALTIME, and if that we ever changed that, the old way would alter "sleep 5" from "sleep for 5 seconds" to "sleep until now + 5 secs", which is subtly different. Always use %g format to print the original sleep duration in reports of how much time remains - this works best for both long and short durations. A couple of other minor (frill) mods to the SIGINFO report message as well.
2019-03-10 18:18:45 +03:00
report_requested = 0;
if (clock_gettime(CLOCK_MONOTONIC, &now) != 0) /* Huh? */
continue;
While cute, the previous version is not really safe. After all, a system might want to sleep for several thousand years on a spaceship headed to a distant solar system... So, remove the pause() code, deal with limits on the range (it is just an int) that can be passed to sleep() by looping, and do a much better job of checking for out of range input values. With this change sleep(1) should work for durations up to something more than 250 billion years. It fails (at startup, with an error) if the requested duration is beyond what can be handled. Here no changes at all related to locales and arg parsing. Still for another day.
2019-01-26 18:20:50 +03:00
Deal with overflow when the sleep duration given is a simple integer (previously it was just clamped at the max possible value). This would have caused sleep 10000000000000000000 (or anything bigger) to have only actually slept for 9223372036854775807 secs. Someone would have noticed that happen, one day, in some other universe. This is now an error, as it was previously if this had been entered as sleep 1e19 Also detect an attempt to sleep for so long that a time_t will no longer be able to represent the current time when the sleep is done. Undo the attempts to work around a broken kernel nanosleep() implementation (by only ever issuing shortish sleep requests, and looping). That code was broken (idiot botch of mine) though you would have had to wait a month to observe it happen. I was going to just fix it, but sanity prevailed, and the kernel got fixed instead. That allows this to be much simplified, only looping as needed to handle dealing with SIGINFO. Switch to using clock_nanosleep() to implement the delay, as while our nanosleep() uses CLOCK_MONOTONIC the standards say it should use CLOCK_REALTIME, and if that we ever changed that, the old way would alter "sleep 5" from "sleep for 5 seconds" to "sleep until now + 5 secs", which is subtly different. Always use %g format to print the original sleep duration in reports of how much time remains - this works best for both long and short durations. A couple of other minor (frill) mods to the SIGINFO report message as well.
2019-03-10 18:18:45 +03:00
timespecsub(&endtime, &now, &ntime);
report(ntime.tv_sec, original, msg);
Adjust the way the arg string is parsed in the "not entirely integer" case, so we avoid adjusting the locale of sleep, and generally be more reliable and simpler. In addition, deal with weirdness in nanosleep() when the interval gets long, by avoiding using it. In this version when the sleep interval < 10000 seconds, we use nanosleep() as before, for delays longer than that we use sleep() instead, and ignore any fractional seconds. We avoid overflow problems here by not bothering to sleep at all for delays longer than 135 years (approx) and simply pause() instead. That sleep never terminates in such a case is unlikely to ever be observed. This commit makes no decision on the question of whether the arg should be interpreted in the locale of the user, or always in the C locale. That is for another day.
2019-01-26 18:19:08 +03:00
}
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
}
Merge 4.4-Lite version.
1994-09-22 13:24:46 +04:00
Adjust the way the arg string is parsed in the "not entirely integer" case, so we avoid adjusting the locale of sleep, and generally be more reliable and simpler. In addition, deal with weirdness in nanosleep() when the interval gets long, by avoiding using it. In this version when the sleep interval < 10000 seconds, we use nanosleep() as before, for delays longer than that we use sleep() instead, and ignore any fractional seconds. We avoid overflow problems here by not bothering to sleep at all for delays longer than 135 years (approx) and simply pause() instead. That sleep never terminates in such a case is unlikely to ever be observed. This commit makes no decision on the question of whether the arg should be interpreted in the locale of the user, or always in the C locale. That is for another day.
2019-01-26 18:19:08 +03:00
/* Reporting does not bother with nanoseconds. */
static void
report(const time_t remain, const time_t original, const char * const msg)
{
if (remain == 0)
warnx("In the final moments of the original"
Deal with overflow when the sleep duration given is a simple integer (previously it was just clamped at the max possible value). This would have caused sleep 10000000000000000000 (or anything bigger) to have only actually slept for 9223372036854775807 secs. Someone would have noticed that happen, one day, in some other universe. This is now an error, as it was previously if this had been entered as sleep 1e19 Also detect an attempt to sleep for so long that a time_t will no longer be able to represent the current time when the sleep is done. Undo the attempts to work around a broken kernel nanosleep() implementation (by only ever issuing shortish sleep requests, and looping). That code was broken (idiot botch of mine) though you would have had to wait a month to observe it happen. I was going to just fix it, but sanity prevailed, and the kernel got fixed instead. That allows this to be much simplified, only looping as needed to handle dealing with SIGINFO. Switch to using clock_nanosleep() to implement the delay, as while our nanosleep() uses CLOCK_MONOTONIC the standards say it should use CLOCK_REALTIME, and if that we ever changed that, the old way would alter "sleep 5" from "sleep for 5 seconds" to "sleep until now + 5 secs", which is subtly different. Always use %g format to print the original sleep duration in reports of how much time remains - this works best for both long and short durations. A couple of other minor (frill) mods to the SIGINFO report message as well.
2019-03-10 18:18:45 +03:00
" %g%s second%s", (double)original, msg,
Adjust the way the arg string is parsed in the "not entirely integer" case, so we avoid adjusting the locale of sleep, and generally be more reliable and simpler. In addition, deal with weirdness in nanosleep() when the interval gets long, by avoiding using it. In this version when the sleep interval < 10000 seconds, we use nanosleep() as before, for delays longer than that we use sleep() instead, and ignore any fractional seconds. We avoid overflow problems here by not bothering to sleep at all for delays longer than 135 years (approx) and simply pause() instead. That sleep never terminates in such a case is unlikely to ever be observed. This commit makes no decision on the question of whether the arg should be interpreted in the locale of the user, or always in the C locale. That is for another day.
2019-01-26 18:19:08 +03:00
original == 1 && *msg == '\0' ? "" : "s");
While cute, the previous version is not really safe. After all, a system might want to sleep for several thousand years on a spaceship headed to a distant solar system... So, remove the pause() code, deal with limits on the range (it is just an int) that can be passed to sleep() by looping, and do a much better job of checking for out of range input values. With this change sleep(1) should work for durations up to something more than 250 billion years. It fails (at startup, with an error) if the requested duration is beyond what can be handled. Here no changes at all related to locales and arg parsing. Still for another day.
2019-01-26 18:20:50 +03:00
else if (remain < 2000)
cast to intmax_t instead of long, since time_t is "long long"
2019-01-27 05:00:45 +03:00
warnx("Between %jd and %jd seconds left"
While cute, the previous version is not really safe. After all, a system might want to sleep for several thousand years on a spaceship headed to a distant solar system... So, remove the pause() code, deal with limits on the range (it is just an int) that can be passed to sleep() by looping, and do a much better job of checking for out of range input values. With this change sleep(1) should work for durations up to something more than 250 billion years. It fails (at startup, with an error) if the requested duration is beyond what can be handled. Here no changes at all related to locales and arg parsing. Still for another day.
2019-01-26 18:20:50 +03:00
" out of the original %g%s",
cast to intmax_t instead of long, since time_t is "long long"
2019-01-27 05:00:45 +03:00
(intmax_t)remain, (intmax_t)remain + 1, (double)original,
Explicitly cast time_t to match format string - should fix the build on some 32bit architectures.
2019-01-26 21:14:22 +03:00
msg);
While cute, the previous version is not really safe. After all, a system might want to sleep for several thousand years on a spaceship headed to a distant solar system... So, remove the pause() code, deal with limits on the range (it is just an int) that can be passed to sleep() by looping, and do a much better job of checking for out of range input values. With this change sleep(1) should work for durations up to something more than 250 billion years. It fails (at startup, with an error) if the requested duration is beyond what can be handled. Here no changes at all related to locales and arg parsing. Still for another day.
2019-01-26 18:20:50 +03:00
else if ((original - remain) < 100000 && (original-remain) < original/8)
Deal with overflow when the sleep duration given is a simple integer (previously it was just clamped at the max possible value). This would have caused sleep 10000000000000000000 (or anything bigger) to have only actually slept for 9223372036854775807 secs. Someone would have noticed that happen, one day, in some other universe. This is now an error, as it was previously if this had been entered as sleep 1e19 Also detect an attempt to sleep for so long that a time_t will no longer be able to represent the current time when the sleep is done. Undo the attempts to work around a broken kernel nanosleep() implementation (by only ever issuing shortish sleep requests, and looping). That code was broken (idiot botch of mine) though you would have had to wait a month to observe it happen. I was going to just fix it, but sanity prevailed, and the kernel got fixed instead. That allows this to be much simplified, only looping as needed to handle dealing with SIGINFO. Switch to using clock_nanosleep() to implement the delay, as while our nanosleep() uses CLOCK_MONOTONIC the standards say it should use CLOCK_REALTIME, and if that we ever changed that, the old way would alter "sleep 5" from "sleep for 5 seconds" to "sleep until now + 5 secs", which is subtly different. Always use %g format to print the original sleep duration in reports of how much time remains - this works best for both long and short durations. A couple of other minor (frill) mods to the SIGINFO report message as well.
2019-03-10 18:18:45 +03:00
warnx("Have waited only %jd second%s of the original %g%s",
(intmax_t)(original - remain),
(original - remain) == 1 ? "" : "s",
(double)original, msg);
While cute, the previous version is not really safe. After all, a system might want to sleep for several thousand years on a spaceship headed to a distant solar system... So, remove the pause() code, deal with limits on the range (it is just an int) that can be passed to sleep() by looping, and do a much better job of checking for out of range input values. With this change sleep(1) should work for durations up to something more than 250 billion years. It fails (at startup, with an error) if the requested duration is beyond what can be handled. Here no changes at all related to locales and arg parsing. Still for another day.
2019-01-26 18:20:50 +03:00
else
Deal with overflow when the sleep duration given is a simple integer (previously it was just clamped at the max possible value). This would have caused sleep 10000000000000000000 (or anything bigger) to have only actually slept for 9223372036854775807 secs. Someone would have noticed that happen, one day, in some other universe. This is now an error, as it was previously if this had been entered as sleep 1e19 Also detect an attempt to sleep for so long that a time_t will no longer be able to represent the current time when the sleep is done. Undo the attempts to work around a broken kernel nanosleep() implementation (by only ever issuing shortish sleep requests, and looping). That code was broken (idiot botch of mine) though you would have had to wait a month to observe it happen. I was going to just fix it, but sanity prevailed, and the kernel got fixed instead. That allows this to be much simplified, only looping as needed to handle dealing with SIGINFO. Switch to using clock_nanosleep() to implement the delay, as while our nanosleep() uses CLOCK_MONOTONIC the standards say it should use CLOCK_REALTIME, and if that we ever changed that, the old way would alter "sleep 5" from "sleep for 5 seconds" to "sleep until now + 5 secs", which is subtly different. Always use %g format to print the original sleep duration in reports of how much time remains - this works best for both long and short durations. A couple of other minor (frill) mods to the SIGINFO report message as well.
2019-03-10 18:18:45 +03:00
warnx("Approximately %g seconds left out of the original %g%s",
(double)remain, (double)original, msg);
Adjust the way the arg string is parsed in the "not entirely integer" case, so we avoid adjusting the locale of sleep, and generally be more reliable and simpler. In addition, deal with weirdness in nanosleep() when the interval gets long, by avoiding using it. In this version when the sleep interval < 10000 seconds, we use nanosleep() as before, for delays longer than that we use sleep() instead, and ignore any fractional seconds. We avoid overflow problems here by not bothering to sleep at all for delays longer than 135 years (approx) and simply pause() instead. That sleep never terminates in such a case is unlikely to ever be observed. This commit makes no decision on the question of whether the arg should be interpreted in the locale of the user, or always in the C locale. That is for another day.
2019-01-26 18:19:08 +03:00
}
Use __dead
2011-08-29 18:51:17 +04:00
static void
ANSIfy and KNF by Petri Koistinen.
2001-09-17 01:18:33 +04:00
usage(void)
Merge 4.4-Lite version.
1994-09-22 13:24:46 +04:00
{
ANSIfy and KNF by Petri Koistinen.
2001-09-17 01:18:33 +04:00
(void)fprintf(stderr, "usage: %s seconds\n", getprogname());
- Cleanup for sleep.c: + mark two functions as static + remove case '?' in switch() before default + use return instead of exit() in main() function + use constants EXIT_SUCCESS/EXIT_FAILURE instead of 0/1 - In man sleep(1): + cleanup example Patch submitted by Slava Semushin <php-coder@altlinux.ru> in private email.
2007-08-18 04:41:52 +04:00
exit(EXIT_FAILURE);
Delint.
1998-07-28 09:31:22 +04:00
/* NOTREACHED */
Merge 4.4-Lite version.
1994-09-22 13:24:46 +04:00
}
Make sleep handle non-integer values. Document the same, noting that the extension is grotesquely non-portable. As requested by Denny Gentry in pr-3914. He supplied some code, but I used all my own code in the change, and wrote documentation for the man page. This is creeping featurism at its worst. I added it only because I can't see a good reason for refusing. However, I'm disgusted with myself for doing it anyway.
1997-08-04 05:13:07 +04:00
lint
1997-11-06 00:17:14 +03:00
/* ARGSUSED */
Use __dead
2011-08-29 18:51:17 +04:00
static void
ANSIfy and KNF by Petri Koistinen.
2001-09-17 01:18:33 +04:00
alarmhandle(int i)
Make sleep handle non-integer values. Document the same, noting that the extension is grotesquely non-portable. As requested by Denny Gentry in pr-3914. He supplied some code, but I used all my own code in the change, and wrote documentation for the man page. This is creeping featurism at its worst. I added it only because I can't see a good reason for refusing. However, I'm disgusted with myself for doing it anyway.
1997-08-04 05:13:07 +04:00
{
- Cleanup for sleep.c: + mark two functions as static + remove case '?' in switch() before default + use return instead of exit() in main() function + use constants EXIT_SUCCESS/EXIT_FAILURE instead of 0/1 - In man sleep(1): + cleanup example Patch submitted by Slava Semushin <php-coder@altlinux.ru> in private email.
2007-08-18 04:41:52 +04:00
_exit(EXIT_SUCCESS);
Delint.
1998-07-28 09:31:22 +04:00
/* NOTREACHED */
Make sleep handle non-integer values. Document the same, noting that the extension is grotesquely non-portable. As requested by Denny Gentry in pr-3914. He supplied some code, but I used all my own code in the change, and wrote documentation for the man page. This is creeping featurism at its worst. I added it only because I can't see a good reason for refusing. However, I'm disgusted with myself for doing it anyway.
1997-08-04 05:13:07 +04:00
}