Merge branch '2017wk11' of git://github.com/kerolasa/lelux-utiliteetit
* '2017wk11' of git://github.com/kerolasa/lelux-utiliteetit:
blkid: add control struct
blkid: simplify version option handling
tests: add static keyword where needed [smatch scan]
tests: do not use plain 0 as NULL [smatch scan]
libsmartcols: fix test variable shadowing
diff --git a/.gitignore b/.gitignore
index 8630fea..f325d5c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -55,6 +55,7 @@
tests/run.sh.log
tests/run.sh.trs
update.log
+ylwrap
#
# binaries
@@ -83,6 +84,7 @@
/fallocate
/fdformat
/fdisk
+/fincore
/findfs
/findmnt
/flock
diff --git a/Documentation/parse-date.txt b/Documentation/parse-date.txt
new file mode 100644
index 0000000..cb06a47
--- /dev/null
+++ b/Documentation/parse-date.txt
@@ -0,0 +1,468 @@
+
+NAME
+ parse_date - parses a date string into a timespec struct.
+
+SYNOPSIS
+ #include "timeutils.h"
+
+ int parse_date(struct timespec *result, char const *p,
+ struct timespec const *now)
+
+ LDADD libcommon.la
+
+DESCRIPTION
+ Parse a date/time string, storing the resulting time value into *result.
+ The string itself is pointed to by *p. Return 1 if successful.
+ *p can be an incomplete or relative time specification; if so, use
+ *now as the basis for the returned time.
+
+
+This function is based upon gnulib's parse-datetime.y-dd7a871.
+
+Below is a plain text version of the gnulib parse-datetime.texi-dd7a871 manual
+describing the input strings that are recognized.
+
+Any future modifications to the util-linux parser that affect input strings
+should be noted below.
+
+
+1 Date input formats
+********************
+
+First, a quote:
+
+ Our units of temporal measurement, from seconds on up to months,
+ are so complicated, asymmetrical and disjunctive so as to make
+ coherent mental reckoning in time all but impossible. Indeed, had
+ some tyrannical god contrived to enslave our minds to time, to
+ make it all but impossible for us to escape subjection to sodden
+ routines and unpleasant surprises, he could hardly have done
+ better than handing down our present system. It is like a set of
+ trapezoidal building blocks, with no vertical or horizontal
+ surfaces, like a language in which the simplest thought demands
+ ornate constructions, useless particles and lengthy
+ circumlocutions. Unlike the more successful patterns of language
+ and science, which enable us to face experience boldly or at least
+ level-headedly, our system of temporal calculation silently and
+ persistently encourages our terror of time.
+
+ ... It is as though architects had to measure length in feet,
+ width in meters and height in ells; as though basic instruction
+ manuals demanded a knowledge of five different languages. It is
+ no wonder then that we often look into our own immediate past or
+ future, last Tuesday or a week from Sunday, with feelings of
+ helpless confusion. ...
+
+ --Robert Grudin, `Time and the Art of Living'.
+
+ This section describes the textual date representations that GNU
+programs accept. These are the strings you, as a user, can supply as
+arguments to the various programs. The C interface (via the
+`parse_datetime' function) is not described here.
+
+1.1 General date syntax
+=======================
+
+A "date" is a string, possibly empty, containing many items separated
+by whitespace. The whitespace may be omitted when no ambiguity arises.
+The empty string means the beginning of today (i.e., midnight). Order
+of the items is immaterial. A date string may contain many flavors of
+items:
+
+ * calendar date items
+
+ * time of day items
+
+ * time zone items
+
+ * combined date and time of day items
+
+ * day of the week items
+
+ * relative items
+
+ * pure numbers.
+
+We describe each of these item types in turn, below.
+
+ A few ordinal numbers may be written out in words in some contexts.
+This is most useful for specifying day of the week items or relative
+items (see below). Among the most commonly used ordinal numbers, the
+word `last' stands for -1, `this' stands for 0, and `first' and `next'
+both stand for 1. Because the word `second' stands for the unit of
+time there is no way to write the ordinal number 2, but for convenience
+`third' stands for 3, `fourth' for 4, `fifth' for 5, `sixth' for 6,
+`seventh' for 7, `eighth' for 8, `ninth' for 9, `tenth' for 10,
+`eleventh' for 11 and `twelfth' for 12.
+
+ When a month is written this way, it is still considered to be
+written numerically, instead of being "spelled in full"; this changes
+the allowed strings.
+
+ In the current implementation, only English is supported for words
+and abbreviations like `AM', `DST', `EST', `first', `January',
+`Sunday', `tomorrow', and `year'.
+
+ The output of the `date' command is not always acceptable as a date
+string, not only because of the language problem, but also because
+there is no standard meaning for time zone items like `IST'. When using
+`date' to generate a date string intended to be parsed later, specify a
+date format that is independent of language and that does not use time
+zone items other than `UTC' and `Z'. Here are some ways to do this:
+
+ $ LC_ALL=C TZ=UTC0 date
+ Mon Mar 1 00:21:42 UTC 2004
+ $ TZ=UTC0 date +'%Y-%m-%d %H:%M:%SZ'
+ 2004-03-01 00:21:42Z
+ $ date --rfc-3339=ns # --rfc-3339 is a GNU extension.
+ 2004-02-29 16:21:42.692722128-08:00
+ $ date --rfc-2822 # a GNU extension
+ Sun, 29 Feb 2004 16:21:42 -0800
+ $ date +'%Y-%m-%d %H:%M:%S %z' # %z is a GNU extension.
+ 2004-02-29 16:21:42 -0800
+ $ date +'@%s.%N' # %s and %N are GNU extensions.
+ @1078100502.692722128
+
+ Alphabetic case is completely ignored in dates. Comments may be
+introduced between round parentheses, as long as included parentheses
+are properly nested. Hyphens not followed by a digit are currently
+ignored. Leading zeros on numbers are ignored.
+
+ Invalid dates like `2005-02-29' or times like `24:00' are rejected.
+In the typical case of a host that does not support leap seconds, a
+time like `23:59:60' is rejected even if it corresponds to a valid leap
+second.
+
+1.2 Calendar date items
+=======================
+
+A "calendar date item" specifies a day of the year. It is specified
+differently, depending on whether the month is specified numerically or
+literally. All these strings specify the same calendar date:
+
+ 1972-09-24 # ISO 8601.
+ 72-9-24 # Assume 19xx for 69 through 99,
+ # 20xx for 00 through 68.
+ 72-09-24 # Leading zeros are ignored.
+ 9/24/72 # Common U.S. writing.
+ 24 September 1972
+ 24 Sept 72 # September has a special abbreviation.
+ 24 Sep 72 # Three-letter abbreviations always allowed.
+ Sep 24, 1972
+ 24-sep-72
+ 24sep72
+
+ The year can also be omitted. In this case, the last specified year
+is used, or the current year if none. For example:
+
+ 9/24
+ sep 24
+
+ Here are the rules.
+
+ For numeric months, the ISO 8601 format `YEAR-MONTH-DAY' is allowed,
+where YEAR is any positive number, MONTH is a number between 01 and 12,
+and DAY is a number between 01 and 31. A leading zero must be present
+if a number is less than ten. If YEAR is 68 or smaller, then 2000 is
+added to it; otherwise, if YEAR is less than 100, then 1900 is added to
+it. The construct `MONTH/DAY/YEAR', popular in the United States, is
+accepted. Also `MONTH/DAY', omitting the year.
+
+ Literal months may be spelled out in full: `January', `February',
+`March', `April', `May', `June', `July', `August', `September',
+`October', `November' or `December'. Literal months may be abbreviated
+to their first three letters, possibly followed by an abbreviating dot.
+It is also permitted to write `Sept' instead of `September'.
+
+ When months are written literally, the calendar date may be given as
+any of the following:
+
+ DAY MONTH YEAR
+ DAY MONTH
+ MONTH DAY YEAR
+ DAY-MONTH-YEAR
+
+ Or, omitting the year:
+
+ MONTH DAY
+
+1.3 Time of day items
+=====================
+
+A "time of day item" in date strings specifies the time on a given day.
+Here are some examples, all of which represent the same time:
+
+ 20:02:00.000000
+ 20:02
+ 8:02pm
+ 20:02-0500 # In EST (U.S. Eastern Standard Time).
+
+ More generally, the time of day may be given as
+`HOUR:MINUTE:SECOND', where HOUR is a number between 0 and 23, MINUTE
+is a number between 0 and 59, and SECOND is a number between 0 and 59
+possibly followed by `.' or `,' and a fraction containing one or more
+digits. Alternatively, `:SECOND' can be omitted, in which case it is
+taken to be zero. On the rare hosts that support leap seconds, SECOND
+may be 60.
+
+ If the time is followed by `am' or `pm' (or `a.m.' or `p.m.'), HOUR
+is restricted to run from 1 to 12, and `:MINUTE' may be omitted (taken
+to be zero). `am' indicates the first half of the day, `pm' indicates
+the second half of the day. In this notation, 12 is the predecessor of
+1: midnight is `12am' while noon is `12pm'. (This is the zero-oriented
+interpretation of `12am' and `12pm', as opposed to the old tradition
+derived from Latin which uses `12m' for noon and `12pm' for midnight.)
+
+ The time may alternatively be followed by a time zone correction,
+expressed as `SHHMM', where S is `+' or `-', HH is a number of zone
+hours and MM is a number of zone minutes. The zone minutes term, MM,
+may be omitted, in which case the one- or two-digit correction is
+interpreted as a number of hours. You can also separate HH from MM
+with a colon. When a time zone correction is given this way, it forces
+interpretation of the time relative to Coordinated Universal Time
+(UTC), overriding any previous specification for the time zone or the
+local time zone. For example, `+0530' and `+05:30' both stand for the
+time zone 5.5 hours ahead of UTC (e.g., India). This is the best way to
+specify a time zone correction by fractional parts of an hour. The
+maximum zone correction is 24 hours.
+
+ Either `am'/`pm' or a time zone correction may be specified, but not
+both.
+
+1.4 Time zone items
+===================
+
+A "time zone item" specifies an international time zone, indicated by a
+small set of letters, e.g., `UTC' or `Z' for Coordinated Universal
+Time. Any included periods are ignored. By following a
+non-daylight-saving time zone by the string `DST' in a separate word
+(that is, separated by some white space), the corresponding daylight
+saving time zone may be specified. Alternatively, a
+non-daylight-saving time zone can be followed by a time zone
+correction, to add the two values. This is normally done only for
+`UTC'; for example, `UTC+05:30' is equivalent to `+05:30'.
+
+ Time zone items other than `UTC' and `Z' are obsolescent and are not
+recommended, because they are ambiguous; for example, `EST' has a
+different meaning in Australia than in the United States. Instead,
+it's better to use unambiguous numeric time zone corrections like
+`-0500', as described in the previous section.
+
+ If neither a time zone item nor a time zone correction is supplied,
+timestamps are interpreted using the rules of the default time zone
+(*note Specifying time zone rules::).
+
+1.5 Combined date and time of day items
+=======================================
+
+The ISO 8601 date and time of day extended format consists of an ISO
+8601 date, a `T' character separator, and an ISO 8601 time of day.
+This format is also recognized if the `T' is replaced by a space.
+
+ In this format, the time of day should use 24-hour notation.
+Fractional seconds are allowed, with either comma or period preceding
+the fraction. ISO 8601 fractional minutes and hours are not supported.
+Typically, hosts support nanosecond timestamp resolution; excess
+precision is silently discarded.
+
+ Here are some examples:
+
+ 2012-09-24T20:02:00.052-05:00
+ 2012-12-31T23:59:59,999999999+11:00
+ 1970-01-01 00:00Z
+
+1.6 Day of week items
+=====================
+
+The explicit mention of a day of the week will forward the date (only
+if necessary) to reach that day of the week in the future.
+
+ Days of the week may be spelled out in full: `Sunday', `Monday',
+`Tuesday', `Wednesday', `Thursday', `Friday' or `Saturday'. Days may
+be abbreviated to their first three letters, optionally followed by a
+period. The special abbreviations `Tues' for `Tuesday', `Wednes' for
+`Wednesday' and `Thur' or `Thurs' for `Thursday' are also allowed.
+
+ A number may precede a day of the week item to move forward
+supplementary weeks. It is best used in expression like `third
+monday'. In this context, `last DAY' or `next DAY' is also acceptable;
+they move one week before or after the day that DAY by itself would
+represent.
+
+ A comma following a day of the week item is ignored.
+
+1.7 Relative items in date strings
+==================================
+
+"Relative items" adjust a date (or the current date if none) forward or
+backward. The effects of relative items accumulate. Here are some
+examples:
+
+ 1 year
+ 1 year ago
+ 3 years
+ 2 days
+
+ The unit of time displacement may be selected by the string `year'
+or `month' for moving by whole years or months. These are fuzzy units,
+as years and months are not all of equal duration. More precise units
+are `fortnight' which is worth 14 days, `week' worth 7 days, `day'
+worth 24 hours, `hour' worth 60 minutes, `minute' or `min' worth 60
+seconds, and `second' or `sec' worth one second. An `s' suffix on
+these units is accepted and ignored.
+
+ The unit of time may be preceded by a multiplier, given as an
+optionally signed number. Unsigned numbers are taken as positively
+signed. No number at all implies 1 for a multiplier. Following a
+relative item by the string `ago' is equivalent to preceding the unit
+by a multiplier with value -1.
+
+ The string `tomorrow' is worth one day in the future (equivalent to
+`day'), the string `yesterday' is worth one day in the past (equivalent
+to `day ago').
+
+ The strings `now' or `today' are relative items corresponding to
+zero-valued time displacement, these strings come from the fact a
+zero-valued time displacement represents the current time when not
+otherwise changed by previous items. They may be used to stress other
+items, like in `12:00 today'. The string `this' also has the meaning
+of a zero-valued time displacement, but is preferred in date strings
+like `this thursday'.
+
+ When a relative item causes the resulting date to cross a boundary
+where the clocks were adjusted, typically for daylight saving time, the
+resulting date and time are adjusted accordingly.
+
+ The fuzz in units can cause problems with relative items. For
+example, `2003-07-31 -1 month' might evaluate to 2003-07-01, because
+2003-06-31 is an invalid date. To determine the previous month more
+reliably, you can ask for the month before the 15th of the current
+month. For example:
+
+ $ date -R
+ Thu, 31 Jul 2003 13:02:39 -0700
+ $ date --date='-1 month' +'Last month was %B?'
+ Last month was July?
+ $ date --date="$(date +%Y-%m-15) -1 month" +'Last month was %B!'
+ Last month was June!
+
+ Also, take care when manipulating dates around clock changes such as
+daylight saving leaps. In a few cases these have added or subtracted
+as much as 24 hours from the clock, so it is often wise to adopt
+universal time by setting the `TZ' environment variable to `UTC0'
+before embarking on calendrical calculations.
+
+1.8 Pure numbers in date strings
+================================
+
+The precise interpretation of a pure decimal number depends on the
+context in the date string.
+
+ If the decimal number is of the form YYYYMMDD and no other calendar
+date item (*note Calendar date items::) appears before it in the date
+string, then YYYY is read as the year, MM as the month number and DD as
+the day of the month, for the specified calendar date.
+
+ If the decimal number is of the form HHMM and no other time of day
+item appears before it in the date string, then HH is read as the hour
+of the day and MM as the minute of the hour, for the specified time of
+day. MM can also be omitted.
+
+ If both a calendar date and a time of day appear to the left of a
+number in the date string, but no relative item, then the number
+overrides the year.
+
+1.9 Seconds since the Epoch
+===========================
+
+If you precede a number with `@', it represents an internal timestamp
+as a count of seconds. The number can contain an internal decimal
+point (either `.' or `,'); any excess precision not supported by the
+internal representation is truncated toward minus infinity. Such a
+number cannot be combined with any other date item, as it specifies a
+complete timestamp.
+
+ Internally, computer times are represented as a count of seconds
+since an epoch--a well-defined point of time. On GNU and POSIX
+systems, the epoch is 1970-01-01 00:00:00 UTC, so `@0' represents this
+time, `@1' represents 1970-01-01 00:00:01 UTC, and so forth. GNU and
+most other POSIX-compliant systems support such times as an extension
+to POSIX, using negative counts, so that `@-1' represents 1969-12-31
+23:59:59 UTC.
+
+ Traditional Unix systems count seconds with 32-bit two's-complement
+integers and can represent times from 1901-12-13 20:45:52 through
+2038-01-19 03:14:07 UTC. More modern systems use 64-bit counts of
+seconds with nanosecond subcounts, and can represent all the times in
+the known lifetime of the universe to a resolution of 1 nanosecond.
+
+ On most hosts, these counts ignore the presence of leap seconds.
+For example, on most hosts `@915148799' represents 1998-12-31 23:59:59
+UTC, `@915148800' represents 1999-01-01 00:00:00 UTC, and there is no
+way to represent the intervening leap second 1998-12-31 23:59:60 UTC.
+
+1.10 Specifying time zone rules
+===============================
+
+Normally, dates are interpreted using the rules of the current time
+zone, which in turn are specified by the `TZ' environment variable, or
+by a system default if `TZ' is not set. To specify a different set of
+default time zone rules that apply just to one date, start the date
+with a string of the form `TZ="RULE"'. The two quote characters (`"')
+must be present in the date, and any quotes or backslashes within RULE
+must be escaped by a backslash.
+
+ For example, with the GNU `date' command you can answer the question
+"What time is it in New York when a Paris clock shows 6:30am on October
+31, 2004?" by using a date beginning with `TZ="Europe/Paris"' as shown
+in the following shell transcript:
+
+ $ export TZ="America/New_York"
+ $ date --date='TZ="Europe/Paris" 2004-10-31 06:30'
+ Sun Oct 31 01:30:00 EDT 2004
+
+ In this example, the `--date' operand begins with its own `TZ'
+setting, so the rest of that operand is processed according to
+`Europe/Paris' rules, treating the string `2004-10-31 06:30' as if it
+were in Paris. However, since the output of the `date' command is
+processed according to the overall time zone rules, it uses New York
+time. (Paris was normally six hours ahead of New York in 2004, but
+this example refers to a brief Halloween period when the gap was five
+hours.)
+
+ A `TZ' value is a rule that typically names a location in the `tz'
+database (http://www.twinsun.com/tz/tz-link.htm). A recent catalog of
+location names appears in the TWiki Date and Time Gateway
+(http://twiki.org/cgi-bin/xtra/tzdate). A few non-GNU hosts require a
+colon before a location name in a `TZ' setting, e.g.,
+`TZ=":America/New_York"'.
+
+ The `tz' database includes a wide variety of locations ranging from
+`Arctic/Longyearbyen' to `Antarctica/South_Pole', but if you are at sea
+and have your own private time zone, or if you are using a non-GNU host
+that does not support the `tz' database, you may need to use a POSIX
+rule instead. Simple POSIX rules like `UTC0' specify a time zone
+without daylight saving time; other rules can specify simple daylight
+saving regimes. *Note Specifying the Time Zone with `TZ': (libc)TZ
+Variable.
+
+1.11 Authors of `parse_datetime'
+================================
+
+`parse_datetime' started life as `getdate', as originally implemented
+by Steven M. Bellovin (<smb@research.att.com>) while at the University
+of North Carolina at Chapel Hill. The code was later tweaked by a
+couple of people on Usenet, then completely overhauled by Rich $alz
+(<rsalz@bbn.com>) and Jim Berets (<jberets@bbn.com>) in August, 1990.
+Various revisions for the GNU system were made by David MacKenzie, Jim
+Meyering, Paul Eggert and others, including renaming it to `get_date' to
+avoid a conflict with the alternative Posix function `getdate', and a
+later rename to `parse_datetime'. The Posix function `getdate' can
+parse more locale-specific dates using `strptime', but relies on an
+environment variable and external file, and lacks the thread-safety of
+`parse_datetime'.
+
+ This chapter was originally produced by Franc,ois Pinard
+(<pinard@iro.umontreal.ca>) from the `parse_datetime.y' source code,
+and then edited by K. Berry (<kb@cs.umb.edu>).
+
diff --git a/autogen.sh b/autogen.sh
index 116885b..04b6cb4 100755
--- a/autogen.sh
+++ b/autogen.sh
@@ -67,6 +67,25 @@
DIE=1
}
+if ! (bison --version) < /dev/null > /dev/null 2>&1; then
+ echo
+ echo "You must have bison installed to build the util-linux."
+ echo
+ DIE=1
+else
+ lexver=$(bison --version | awk '/bison \(GNU Bison\)/ { print $4 }')
+ case "$lexver" in
+ [2-9].*)
+ ;;
+ *)
+ echo
+ echo "You must have bison version >= 2.x, but you have $lexver."
+ echo
+ DIE=1
+ ;;
+ esac
+fi
+
LIBTOOLIZE=libtoolize
case `uname` in Darwin*) LIBTOOLIZE=glibtoolize ;; esac
if ! ($LIBTOOLIZE --version) < /dev/null > /dev/null 2>&1; then
@@ -104,6 +123,7 @@
echo " autoheader: $(autoheader --version | head -1)"
echo " automake: $(automake --version | head -1)"
echo " libtoolize: $($LIBTOOLIZE --version | head -1)"
+echo " bison: $(bison --version | head -1)"
rm -rf autom4te.cache
diff --git a/bash-completion/Makemodule.am b/bash-completion/Makemodule.am
index 3ffd124..ff7b052 100644
--- a/bash-completion/Makemodule.am
+++ b/bash-completion/Makemodule.am
@@ -18,6 +18,9 @@
if BUILD_COLUMN
dist_bashcompletion_DATA += bash-completion/column
endif
+if BUILD_FINCORE
+dist_bashcompletion_DATA += bash-completion/fincore
+endif
if BUILD_FINDMNT
dist_bashcompletion_DATA += bash-completion/findmnt
endif
diff --git a/bash-completion/fincore b/bash-completion/fincore
new file mode 100644
index 0000000..9b1aed8
--- /dev/null
+++ b/bash-completion/fincore
@@ -0,0 +1,46 @@
+_fincore_module()
+{
+ local cur prev OPTS
+ COMPREPLY=()
+ cur="${COMP_WORDS[COMP_CWORD]}"
+ prev="${COMP_WORDS[COMP_CWORD-1]}"
+ case $prev in
+ '-o'|'--output')
+ local prefix realcur OUTPUT_ALL OUTPUT
+ realcur="${cur##*,}"
+ prefix="${cur%$realcur}"
+ OUTPUT_ALL='PAGES SIZE FILE'
+ for WORD in $OUTPUT_ALL; do
+ if ! [[ $prefix == *"$WORD"* ]]; then
+ OUTPUT="$WORD $OUTPUT"
+ fi
+ done
+ compopt -o nospace
+ COMPREPLY=( $(compgen -P "$prefix" -W "$OUTPUT" -S ',' -- "$realcur") )
+ return 0
+ ;;
+ '-h'|'--help'|'-V'|'--version')
+ return 0
+ ;;
+ esac
+ case $cur in
+ -*)
+ OPTS="
+ --json
+ --bytes
+ --noheadings
+ --output
+ --raw
+ --help
+ --version
+ "
+ COMPREPLY=( $(compgen -W "${OPTS[*]}" -- $cur) )
+ return 0
+ ;;
+ esac
+ local IFS=$'\n'
+ compopt -o filenames
+ COMPREPLY=( $(compgen -f -- ${cur:-"/"}) )
+ return 0
+}
+complete -F _fincore_module fincore
diff --git a/configure.ac b/configure.ac
index 8933afa..1acd2b0 100644
--- a/configure.ac
+++ b/configure.ac
@@ -99,6 +99,7 @@
AM_PROG_CC_C_O
AC_PROG_MKDIR_P
AC_PROG_CC_STDC
+AC_PROG_YACC
AC_CANONICAL_HOST
AC_C_CONST
AC_C_VOLATILE
@@ -153,7 +154,6 @@
GTK_DOC_CHECK([1.10])
AC_PATH_PROG([XSLTPROC], [xsltproc])
-
linux_os=no
bsd_os=no
AS_CASE([${host_os}],
@@ -1589,6 +1589,11 @@
UL_REQUIRES_HAVE([ctrlaltdel], [reboot], [reboot function])
AM_CONDITIONAL([BUILD_CTRLALTDEL], [test "x$build_ctrlaltdel" = xyes])
+UL_BUILD_INIT([fincore], [check])
+UL_REQUIRES_LINUX([fincore])
+UL_REQUIRES_BUILD([fincore], [libsmartcols])
+AM_CONDITIONAL([BUILD_FINCORE], [test "x$build_fincore" = xyes])
+
UL_BUILD_INIT([fsfreeze], [check])
UL_REQUIRES_LINUX([fsfreeze])
AM_CONDITIONAL([BUILD_FSFREEZE], [test "x$build_fsfreeze" = xyes])
diff --git a/disk-utils/cfdisk.c b/disk-utils/cfdisk.c
index cb9f342..cc4a867 100644
--- a/disk-utils/cfdisk.c
+++ b/disk-utils/cfdisk.c
@@ -1530,14 +1530,14 @@
return 0;
}
- DBG(MENU, ul_debug(" no memu move key"));
+ DBG(MENU, ul_debug(" no menu move key"));
return 1;
}
/* but don't call me from ui_run(), this is for pop-up menus only */
static void ui_menu_resize(struct cfdisk *cf)
{
- DBG(MENU, ul_debug("memu resize/refresh"));
+ DBG(MENU, ul_debug("menu resize/refresh"));
resize();
ui_clean_menu(cf);
menu_refresh_size(cf);
diff --git a/include/Makemodule.am b/include/Makemodule.am
index d43c597..7ea1a48 100644
--- a/include/Makemodule.am
+++ b/include/Makemodule.am
@@ -5,6 +5,7 @@
include/blkdev.h \
include/canonicalize.h \
include/carefulputc.h \
+ include/cctype.h \
include/c.h \
include/closestream.h \
include/colors.h \
diff --git a/include/cctype.h b/include/cctype.h
new file mode 100644
index 0000000..6ab644c
--- /dev/null
+++ b/include/cctype.h
@@ -0,0 +1,325 @@
+/**
+ * Character handling in C locale.
+ *
+ * This file is based on gnulib c-ctype.h-dd7a871 with the
+ * other gnulib dependencies removed for use in util-linux.
+ *
+ * These functions work like the corresponding functions in <ctype.h>,
+ * except that they have the C (POSIX) locale hardwired, whereas the
+ * <ctype.h> functions' behaviour depends on the current locale set via
+ * setlocale.
+ *
+ * Copyright (C) 2000-2003, 2006, 2008-2017 Free Software Foundation, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UTIL_LINUX_CCTYPE_H
+#define UTIL_LINUX_CCTYPE_H
+
+/**
+ * The functions defined in this file assume the "C" locale and a character
+ * set without diacritics (ASCII-US or EBCDIC-US or something like that).
+ * Even if the "C" locale on a particular system is an extension of the ASCII
+ * character set (like on BeOS, where it is UTF-8, or on AmigaOS, where it
+ * is ISO-8859-1), the functions in this file recognize only the ASCII
+ * characters.
+ */
+
+#if (' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \
+ && ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \
+ && (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \
+ && ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \
+ && ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \
+ && ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \
+ && ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \
+ && ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \
+ && ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \
+ && ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \
+ && ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \
+ && ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \
+ && ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \
+ && ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \
+ && ('Z' == 90) && ('[' == 91) && ('\\' == 92) && (']' == 93) \
+ && ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \
+ && ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \
+ && ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \
+ && ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \
+ && ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \
+ && ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \
+ && ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \
+ && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126)
+
+/*
+ * The character set is ASCII or one of its variants or extensions, not EBCDIC.
+ * Testing the value of '\n' and '\r' is not relevant.
+ */
+# define C_CTYPE_ASCII 1
+#elif ! (' ' == '\x40' && '0' == '\xf0' \
+ && 'A' == '\xc1' && 'J' == '\xd1' && 'S' == '\xe2' \
+ && 'a' == '\x81' && 'j' == '\x91' && 's' == '\xa2')
+# error "Only ASCII and EBCDIC are supported"
+#endif
+
+#if 'A' < 0
+# error "EBCDIC and char is signed -- not supported"
+#endif
+
+/* Cases for control characters. */
+#define _C_CTYPE_CNTRL \
+ case '\a': case '\b': case '\f': case '\n': \
+ case '\r': case '\t': case '\v': \
+ _C_CTYPE_OTHER_CNTRL
+
+/* ASCII control characters other than those with \-letter escapes. */
+#if C_CTYPE_ASCII
+# define _C_CTYPE_OTHER_CNTRL \
+ case '\x00': case '\x01': case '\x02': case '\x03': \
+ case '\x04': case '\x05': case '\x06': case '\x0e': \
+ case '\x0f': case '\x10': case '\x11': case '\x12': \
+ case '\x13': case '\x14': case '\x15': case '\x16': \
+ case '\x17': case '\x18': case '\x19': case '\x1a': \
+ case '\x1b': case '\x1c': case '\x1d': case '\x1e': \
+ case '\x1f': case '\x7f'
+#else
+
+/*
+ * Use EBCDIC code page 1047's assignments for ASCII control chars;
+ * assume all EBCDIC code pages agree about these assignments.
+ */
+# define _C_CTYPE_OTHER_CNTRL \
+ case '\x00': case '\x01': case '\x02': case '\x03': \
+ case '\x07': case '\x0e': case '\x0f': case '\x10': \
+ case '\x11': case '\x12': case '\x13': case '\x18': \
+ case '\x19': case '\x1c': case '\x1d': case '\x1e': \
+ case '\x1f': case '\x26': case '\x27': case '\x2d': \
+ case '\x2e': case '\x32': case '\x37': case '\x3c': \
+ case '\x3d': case '\x3f'
+#endif
+
+/* Cases for lowercase hex letters, and lowercase letters, all offset by N. */
+#define _C_CTYPE_LOWER_A_THRU_F_N(N) \
+ case 'a' + (N): case 'b' + (N): case 'c' + (N): case 'd' + (N): \
+ case 'e' + (N): case 'f' + (N)
+#define _C_CTYPE_LOWER_N(N) \
+ _C_CTYPE_LOWER_A_THRU_F_N(N): \
+ case 'g' + (N): case 'h' + (N): case 'i' + (N): case 'j' + (N): \
+ case 'k' + (N): case 'l' + (N): case 'm' + (N): case 'n' + (N): \
+ case 'o' + (N): case 'p' + (N): case 'q' + (N): case 'r' + (N): \
+ case 's' + (N): case 't' + (N): case 'u' + (N): case 'v' + (N): \
+ case 'w' + (N): case 'x' + (N): case 'y' + (N): case 'z' + (N)
+
+/* Cases for hex letters, digits, lower, punct, and upper. */
+#define _C_CTYPE_A_THRU_F \
+ _C_CTYPE_LOWER_A_THRU_F_N (0): \
+ _C_CTYPE_LOWER_A_THRU_F_N ('A' - 'a')
+#define _C_CTYPE_DIGIT \
+ case '0': case '1': case '2': case '3': \
+ case '4': case '5': case '6': case '7': \
+ case '8': case '9'
+#define _C_CTYPE_LOWER _C_CTYPE_LOWER_N (0)
+#define _C_CTYPE_PUNCT \
+ case '!': case '"': case '#': case '$': \
+ case '%': case '&': case '\'': case '(': \
+ case ')': case '*': case '+': case ',': \
+ case '-': case '.': case '/': case ':': \
+ case ';': case '<': case '=': case '>': \
+ case '?': case '@': case '[': case '\\': \
+ case ']': case '^': case '_': case '`': \
+ case '{': case '|': case '}': case '~'
+#define _C_CTYPE_UPPER _C_CTYPE_LOWER_N ('A' - 'a')
+
+/**
+ * Function definitions.
+ *
+ * Unlike the functions in <ctype.h>, which require an argument in the range
+ * of the 'unsigned char' type, the functions here operate on values that are
+ * in the 'unsigned char' range or in the 'char' range. In other words,
+ * when you have a 'char' value, you need to cast it before using it as
+ * argument to a <ctype.h> function:
+ *
+ * const char *s = ...;
+ * if (isalpha ((unsigned char) *s)) ...
+ *
+ * but you don't need to cast it for the functions defined in this file:
+ *
+ * const char *s = ...;
+ * if (c_isalpha (*s)) ...
+ */
+
+static inline int c_isalnum (int c)
+{
+ switch (c) {
+ _C_CTYPE_DIGIT:
+ _C_CTYPE_LOWER:
+ _C_CTYPE_UPPER:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+static inline int c_isalpha (int c)
+{
+ switch (c) {
+ _C_CTYPE_LOWER:
+ _C_CTYPE_UPPER:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+/* The function isascii is not locale dependent.
+ * Its use in EBCDIC is questionable.
+ */
+static inline int c_isascii (int c)
+{
+ switch (c) {
+ case ' ':
+ _C_CTYPE_CNTRL:
+ _C_CTYPE_DIGIT:
+ _C_CTYPE_LOWER:
+ _C_CTYPE_PUNCT:
+ _C_CTYPE_UPPER:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+static inline int c_isblank (int c)
+{
+ return c == ' ' || c == '\t';
+}
+
+static inline int c_iscntrl (int c)
+{
+ switch (c) {
+ _C_CTYPE_CNTRL:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+static inline int c_isdigit (int c)
+{
+ switch (c) {
+ _C_CTYPE_DIGIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+static inline int c_isgraph (int c)
+{
+ switch (c) {
+ _C_CTYPE_DIGIT:
+ _C_CTYPE_LOWER:
+ _C_CTYPE_PUNCT:
+ _C_CTYPE_UPPER:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+static inline int c_islower (int c)
+{
+ switch (c) {
+ _C_CTYPE_LOWER:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+static inline int c_isprint (int c)
+{
+ switch (c) {
+ case ' ':
+ _C_CTYPE_DIGIT:
+ _C_CTYPE_LOWER:
+ _C_CTYPE_PUNCT:
+ _C_CTYPE_UPPER:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+static inline int c_ispunct (int c)
+{
+ switch (c) {
+ _C_CTYPE_PUNCT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+static inline int c_isspace (int c)
+{
+ switch (c) {
+ case ' ': case '\t': case '\n': case '\v': case '\f': case '\r':
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+static inline int c_isupper (int c)
+{
+ switch (c) {
+ _C_CTYPE_UPPER:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+static inline int c_isxdigit (int c)
+{
+ switch (c) {
+ _C_CTYPE_DIGIT:
+ _C_CTYPE_A_THRU_F:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+static inline int c_tolower (int c)
+{
+ switch (c) {
+ _C_CTYPE_UPPER:
+ return c - 'A' + 'a';
+ default:
+ return c;
+ }
+}
+
+static inline int c_toupper (int c)
+{
+ switch (c) {
+ _C_CTYPE_LOWER:
+ return c - 'a' + 'A';
+ default:
+ return c;
+ }
+}
+
+#endif /* UTIL_LINUX_CCTYPE_H */
diff --git a/include/timeutils.h b/include/timeutils.h
index 85fc228..874f853 100644
--- a/include/timeutils.h
+++ b/include/timeutils.h
@@ -82,4 +82,6 @@
extern time_t timegm(struct tm *tm);
#endif
+int parse_date(struct timespec *, char const *, struct timespec const *);
+
#endif /* UTIL_LINUX_TIME_UTIL_H */
diff --git a/lib/.gitignore b/lib/.gitignore
new file mode 100644
index 0000000..070c244
--- /dev/null
+++ b/lib/.gitignore
@@ -0,0 +1 @@
+parse-date.c
diff --git a/lib/Makemodule.am b/lib/Makemodule.am
index d20a9ac..358b85a 100644
--- a/lib/Makemodule.am
+++ b/lib/Makemodule.am
@@ -16,6 +16,7 @@
lib/mbsedit.c\
lib/md5.c \
lib/pager.c \
+ lib/parse-date.y \
lib/path.c \
lib/randutils.c \
lib/setproctitle.c \
diff --git a/lib/parse-date.y b/lib/parse-date.y
new file mode 100644
index 0000000..7bfdb36
--- /dev/null
+++ b/lib/parse-date.y
@@ -0,0 +1,1645 @@
+%{
+/**
+ * Parse a string into an internal timestamp.
+ *
+ * This file is based on gnulib parse-datetime.y-dd7a871 with
+ * the other gnulib dependencies removed for use in util-linux.
+ *
+ * Copyright (C) 1999-2000, 2002-2017 Free Software Foundation, Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Originally written by Steven M. Bellovin <smb@research.att.com> while
+ * at the University of North Carolina at Chapel Hill. Later tweaked by
+ * a couple of people on Usenet. Completely overhauled by Rich $alz
+ * <rsalz@bbn.com> and Jim Berets <jberets@bbn.com> in August, 1990.
+ *
+ * Modified by Paul Eggert <eggert@twinsun.com> in August 1999 to do
+ * the right thing about local DST. Also modified by Paul Eggert
+ * <eggert@cs.ucla.edu> in February 2004 to support
+ * nanosecond-resolution timestamps, and in October 2004 to support
+ * TZ strings in dates.
+ */
+
+/**
+ * FIXME: Check for arithmetic overflow in all cases, not just
+ * some of them.
+ */
+
+#include <sys/time.h>
+#include <time.h>
+
+#include "c.h"
+#include "timeutils.h"
+
+/**
+ * There's no need to extend the stack, so there's no need to involve
+ * alloca.
+ */
+#define YYSTACK_USE_ALLOCA 0
+
+/**
+ * Tell Bison how much stack space is needed. 20 should be plenty for
+ * this grammar, which is not right recursive. Beware setting it too
+ * high, since that might cause problems on machines whose
+ * implementations have lame stack-overflow checking.
+ */
+#define YYMAXDEPTH 20
+#define YYINITDEPTH YYMAXDEPTH
+
+/**
+ * Since the code of parse-datetime.y is not included in the Emacs executable
+ * itself, there is no need to #define static in this file. Even if
+ * the code were included in the Emacs executable, it probably
+ * wouldn't do any harm to #undef it here; this will only cause
+ * problems if we try to write to a static variable, which I don't
+ * think this code needs to do.
+ */
+#ifdef emacs
+# undef static
+#endif
+
+#include <inttypes.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+#include <stdarg.h>
+#include "cctype.h"
+#include "nls.h"
+#include "xalloc.h"
+
+/**
+ * Bison's skeleton tests _STDLIB_H, while some stdlib.h headers
+ * use _STDLIB_H_ as witness. Map the latter to the one bison uses.
+ * FIXME: this is temporary. Remove when we have a mechanism to ensure
+ * that the version we're using is fixed, too.
+ */
+#ifdef _STDLIB_H_
+# undef _STDLIB_H
+# define _STDLIB_H 1
+#endif
+
+/**
+ * ISDIGIT differs from isdigit, as follows:
+ * - Its arg may be any int or unsigned int; it need not be an unsigned char
+ * or EOF.
+ * - It's typically faster.
+ * POSIX says that only '0' through '9' are digits. Prefer ISDIGIT to
+ * isdigit unless it's important to use the locale's definition
+ * of "digit" even when the host does not conform to POSIX.
+ */
+#define ISDIGIT(c) ((unsigned int) (c) - '0' <= 9)
+
+/**
+ * Shift A right by B bits portably, by dividing A by 2**B and
+ * truncating towards minus infinity. A and B should be free of side
+ * effects, and B should be in the range 0 <= B <= INT_BITS - 2, where
+ * INT_BITS is the number of useful bits in an int. GNU code can
+ * assume that INT_BITS is at least 32.
+ *
+ * ISO C99 says that A >> B is implementation-defined if A < 0. Some
+ * implementations (e.g., UNICOS 9.0 on a Cray Y-MP EL) don't shift
+ * right in the usual way when A < 0, so SHR falls back on division if
+ * ordinary A >> B doesn't seem to be the usual signed shift.
+ */
+#define SHR(a, b) \
+ (-1 >> 1 == -1 \
+ ? (a) >> (b) \
+ : (a) / (1 << (b)) - ((a) % (1 << (b)) < 0))
+
+#define EPOCH_YEAR 1970
+#define TM_YEAR_BASE 1900
+
+#define HOUR(x) ((x) * 60)
+
+#define STREQ(a, b) (strcmp (a, b) == 0)
+
+/**
+ * Convert a possibly-signed character to an unsigned character. This is
+ * a bit safer than casting to unsigned char, since it catches some type
+ * errors that the cast doesn't.
+ */
+static unsigned char to_uchar (char ch) { return ch; }
+
+/**
+ * FIXME: It also assumes that signed integer overflow silently wraps around,
+ * but this is not true any more with recent versions of GCC 4.
+ */
+
+/**
+ * An integer value, and the number of digits in its textual
+ * representation.
+ */
+typedef struct {
+ int negative;
+ long int value;
+ size_t digits;
+} textint;
+
+/* An entry in the lexical lookup table. */
+typedef struct {
+ char const *name;
+ int type;
+ int value;
+} table;
+
+/* Meridian: am, pm, or 24-hour style. */
+enum { MERam, MERpm, MER24 };
+
+enum { BILLION = 1000000000, LOG10_BILLION = 9 };
+
+/* Relative year, month, day, hour, minutes, seconds, and nanoseconds. */
+typedef struct {
+ long int year;
+ long int month;
+ long int day;
+ long int hour;
+ long int minutes;
+ time_t seconds;
+ long int ns;
+} relative_time;
+
+#if HAVE_COMPOUND_LITERALS
+# define RELATIVE_TIME_0 ((relative_time) { 0, 0, 0, 0, 0, 0, 0 })
+#else
+static relative_time const RELATIVE_TIME_0;
+#endif
+
+/* Information passed to and from the parser. */
+typedef struct {
+ /* The input string remaining to be parsed. */
+ const char *input;
+
+ /* N, if this is the Nth Tuesday. */
+ long int day_ordinal;
+
+ /* Day of week; Sunday is 0. */
+ int day_number;
+
+ /* tm_isdst flag for the local zone. */
+ int local_isdst;
+
+ /* Time zone, in minutes east of UTC. */
+ long int time_zone;
+
+ /* Style used for time. */
+ int meridian;
+
+ /* Gregorian year, month, day, hour, minutes, seconds, and ns. */
+ textint year;
+ long int month;
+ long int day;
+ long int hour;
+ long int minutes;
+ struct timespec seconds; /* includes nanoseconds */
+
+ /* Relative year, month, day, hour, minutes, seconds, and ns. */
+ relative_time rel;
+
+ /* Presence or counts of some nonterminals parsed so far. */
+ int timespec_seen;
+ int rels_seen;
+ size_t dates_seen;
+ size_t days_seen;
+ size_t local_zones_seen;
+ size_t dsts_seen;
+ size_t times_seen;
+ size_t zones_seen;
+ size_t year_seen;
+
+ /* 1 if the user specified explicit ordinal day value, */
+ int ordinal_day_seen;
+
+ /* Table of local time zone abbreviations, null terminated. */
+ table local_time_zone_table[3];
+} parser_control;
+
+union YYSTYPE;
+static int yylex (union YYSTYPE *, parser_control *);
+static int yyerror (parser_control const *, char const *);
+static long int time_zone_hhmm (parser_control *, textint, long int);
+
+/**
+ * Extract into *PC any date and time info from a string of digits
+ * of the form e.g., YYYYMMDD, YYMMDD, HHMM, HH (and sometimes YYY,
+ * YYYY, ...).
+ */
+static void digits_to_date_time(parser_control *pc, textint text_int)
+{
+ if (pc->dates_seen && ! pc->year.digits
+ && ! pc->rels_seen && (pc->times_seen || 2 < text_int.digits)) {
+ pc->year_seen++;
+ pc->year = text_int;
+ } else {
+ if (4 < text_int.digits) {
+ pc->dates_seen++;
+ pc->day = text_int.value % 100;
+ pc->month = (text_int.value / 100) % 100;
+ pc->year.value = text_int.value / 10000;
+ pc->year.digits = text_int.digits - 4;
+ } else {
+ pc->times_seen++;
+ if (text_int.digits <= 2) {
+ pc->hour = text_int.value;
+ pc->minutes = 0;
+ }
+ else {
+ pc->hour = text_int.value / 100;
+ pc->minutes = text_int.value % 100;
+ }
+ pc->seconds.tv_sec = 0;
+ pc->seconds.tv_nsec = 0;
+ pc->meridian = MER24;
+ }
+ }
+}
+
+/* Increment PC->rel by FACTOR * REL (FACTOR is 1 or -1). */
+static void apply_relative_time(parser_control *pc, relative_time rel,
+ int factor)
+{
+ pc->rel.ns += factor * rel.ns;
+ pc->rel.seconds += factor * rel.seconds;
+ pc->rel.minutes += factor * rel.minutes;
+ pc->rel.hour += factor * rel.hour;
+ pc->rel.day += factor * rel.day;
+ pc->rel.month += factor * rel.month;
+ pc->rel.year += factor * rel.year;
+ pc->rels_seen = 1;
+}
+
+/* Set PC-> hour, minutes, seconds and nanoseconds members from arguments. */
+static void
+set_hhmmss(parser_control *pc, long int hour, long int minutes,
+ time_t sec, long int nsec)
+{
+ pc->hour = hour;
+ pc->minutes = minutes;
+ pc->seconds.tv_sec = sec;
+ pc->seconds.tv_nsec = nsec;
+}
+
+%}
+
+/**
+ * We want a reentrant parser, even if the TZ manipulation and the calls to
+ * localtime and gmtime are not reentrant.
+ */
+%pure-parser
+%parse-param { parser_control *pc }
+%lex-param { parser_control *pc }
+
+/* This grammar has 31 shift/reduce conflicts. */
+%expect 31
+
+%union {
+ long int intval;
+ textint textintval;
+ struct timespec timespec;
+ relative_time rel;
+}
+
+%token <intval> tAGO
+%token tDST
+
+%token tYEAR_UNIT tMONTH_UNIT tHOUR_UNIT tMINUTE_UNIT tSEC_UNIT
+%token <intval> tDAY_UNIT tDAY_SHIFT
+
+%token <intval> tDAY tDAYZONE tLOCAL_ZONE tMERIDIAN
+%token <intval> tMONTH tORDINAL tZONE
+
+%token <textintval> tSNUMBER tUNUMBER
+%token <timespec> tSDECIMAL_NUMBER tUDECIMAL_NUMBER
+
+%type <intval> o_colon_minutes
+%type <timespec> seconds signed_seconds unsigned_seconds
+
+%type <rel> relunit relunit_snumber dayshift
+
+%%
+
+spec:
+ timespec
+ | items
+;
+
+timespec:
+ '@' seconds {
+ pc->seconds = $2;
+ pc->timespec_seen = 1;
+ }
+;
+
+items:
+ /* empty */
+ | items item
+;
+
+item:
+ datetime {
+ pc->times_seen++; pc->dates_seen++;
+ }
+ | time {
+ pc->times_seen++;
+ }
+ | local_zone {
+ pc->local_zones_seen++;
+ }
+ | zone {
+ pc->zones_seen++;
+ }
+ | date {
+ pc->dates_seen++;
+ }
+ | day {
+ pc->days_seen++;
+ }
+ | rel
+ | number
+ | hybrid
+;
+
+datetime:
+ iso_8601_datetime
+;
+
+iso_8601_datetime:
+ iso_8601_date 'T' iso_8601_time
+;
+
+time:
+ tUNUMBER tMERIDIAN {
+ set_hhmmss (pc, $1.value, 0, 0, 0);
+ pc->meridian = $2;
+ }
+ | tUNUMBER ':' tUNUMBER tMERIDIAN {
+ set_hhmmss (pc, $1.value, $3.value, 0, 0);
+ pc->meridian = $4;
+ }
+ | tUNUMBER ':' tUNUMBER ':' unsigned_seconds tMERIDIAN {
+ set_hhmmss (pc, $1.value, $3.value, $5.tv_sec, $5.tv_nsec);
+ pc->meridian = $6;
+ }
+ | iso_8601_time
+;
+
+iso_8601_time:
+ tUNUMBER zone_offset {
+ set_hhmmss (pc, $1.value, 0, 0, 0);
+ pc->meridian = MER24;
+ }
+ | tUNUMBER ':' tUNUMBER o_zone_offset {
+ set_hhmmss (pc, $1.value, $3.value, 0, 0);
+ pc->meridian = MER24;
+ }
+ | tUNUMBER ':' tUNUMBER ':' unsigned_seconds o_zone_offset {
+ set_hhmmss (pc, $1.value, $3.value, $5.tv_sec, $5.tv_nsec);
+ pc->meridian = MER24;
+ }
+;
+
+o_zone_offset:
+ /* empty */
+ | zone_offset
+;
+
+zone_offset:
+ tSNUMBER o_colon_minutes {
+ pc->zones_seen++;
+ pc->time_zone = time_zone_hhmm (pc, $1, $2);
+ }
+;
+
+/**
+ * Local zone strings only affect DST setting,
+ * and only take affect if the current TZ setting is relevant.
+ *
+ * Example 1:
+ * 'EEST' is parsed as tLOCAL_ZONE, as it relates to the effective TZ:
+ * TZ=Europe/Helsinki date -d '2016-12-30 EEST'
+ *
+ * Example 2:
+ * 'EEST' is parsed as 'zone' (TZ=+03:00):
+ * TZ=Asia/Tokyo ./src/date --debug -d '2011-06-11 EEST'
+ *
+ * This is implemented by probing the next three calendar quarters
+ * of the effective timezone and looking for DST changes -
+ * if found, the timezone name (EEST) is inserted into
+ * the lexical lookup table with type tLOCAL_ZONE.
+ * (Search for 'quarter' comment in 'parse_date').
+ */
+local_zone:
+ tLOCAL_ZONE {
+ pc->local_isdst = $1;
+ pc->dsts_seen += (0 < $1);
+ }
+ | tLOCAL_ZONE tDST {
+ pc->local_isdst = 1;
+ pc->dsts_seen += (0 < $1) + 1;
+ }
+;
+
+/**
+ * Note 'T' is a special case, as it is used as the separator in ISO
+ * 8601 date and time of day representation.
+ */
+zone:
+ tZONE {
+ pc->time_zone = $1;
+ }
+ | 'T' {
+ pc->time_zone = HOUR(7);
+ }
+ | tZONE relunit_snumber {
+ pc->time_zone = $1;
+ apply_relative_time (pc, $2, 1);
+ }
+ | 'T' relunit_snumber {
+ pc->time_zone = HOUR(7);
+ apply_relative_time (pc, $2, 1);
+ }
+ | tZONE tSNUMBER o_colon_minutes {
+ pc->time_zone = $1 + time_zone_hhmm (pc, $2, $3);
+ }
+ | tDAYZONE {
+ pc->time_zone = $1 + 60;
+ }
+ | tZONE tDST {
+ pc->time_zone = $1 + 60;
+ }
+;
+
+day:
+ tDAY {
+ pc->day_ordinal = 0;
+ pc->day_number = $1;
+ }
+ | tDAY ',' {
+ pc->day_ordinal = 0;
+ pc->day_number = $1;
+ }
+ | tORDINAL tDAY {
+ pc->day_ordinal = $1;
+ pc->day_number = $2;
+ pc->ordinal_day_seen = 1;
+ }
+ | tUNUMBER tDAY {
+ pc->day_ordinal = $1.value;
+ pc->day_number = $2;
+ pc->ordinal_day_seen = 1;
+ }
+;
+
+date:
+ tUNUMBER '/' tUNUMBER {
+ pc->month = $1.value;
+ pc->day = $3.value;
+ }
+ | tUNUMBER '/' tUNUMBER '/' tUNUMBER {
+ /**
+ * Interpret as YYYY/MM/DD if the first value has 4 or more digits,
+ * otherwise as MM/DD/YY.
+ * The goal in recognizing YYYY/MM/DD is solely to support legacy
+ * machine-generated dates like those in an RCS log listing. If
+ * you want portability, use the ISO 8601 format.
+ */
+ if (4 <= $1.digits) {
+ pc->year = $1;
+ pc->month = $3.value;
+ pc->day = $5.value;
+ } else {
+ pc->month = $1.value;
+ pc->day = $3.value;
+ pc->year = $5;
+ }
+ }
+ | tUNUMBER tMONTH tSNUMBER {
+ /* e.g. 17-JUN-1992. */
+ pc->day = $1.value;
+ pc->month = $2;
+ pc->year.value = -$3.value;
+ pc->year.digits = $3.digits;
+ }
+ | tMONTH tSNUMBER tSNUMBER {
+ /* e.g. JUN-17-1992. */
+ pc->month = $1;
+ pc->day = -$2.value;
+ pc->year.value = -$3.value;
+ pc->year.digits = $3.digits;
+ }
+ | tMONTH tUNUMBER {
+ pc->month = $1;
+ pc->day = $2.value;
+ }
+ | tMONTH tUNUMBER ',' tUNUMBER {
+ pc->month = $1;
+ pc->day = $2.value;
+ pc->year = $4;
+ }
+ | tUNUMBER tMONTH {
+ pc->day = $1.value;
+ pc->month = $2;
+ }
+ | tUNUMBER tMONTH tUNUMBER {
+ pc->day = $1.value;
+ pc->month = $2;
+ pc->year = $3;
+ }
+ | iso_8601_date
+;
+
+iso_8601_date:
+ tUNUMBER tSNUMBER tSNUMBER {
+ /* ISO 8601 format.YYYY-MM-DD. */
+ pc->year = $1;
+ pc->month = -$2.value;
+ pc->day = -$3.value;
+ }
+;
+
+rel:
+ relunit tAGO
+ { apply_relative_time (pc, $1, $2); }
+ | relunit
+ { apply_relative_time (pc, $1, 1); }
+ | dayshift
+ { apply_relative_time (pc, $1, 1); }
+;
+
+relunit:
+ tORDINAL tYEAR_UNIT
+ { $$ = RELATIVE_TIME_0; $$.year = $1; }
+ | tUNUMBER tYEAR_UNIT
+ { $$ = RELATIVE_TIME_0; $$.year = $1.value; }
+ | tYEAR_UNIT
+ { $$ = RELATIVE_TIME_0; $$.year = 1; }
+ | tORDINAL tMONTH_UNIT
+ { $$ = RELATIVE_TIME_0; $$.month = $1; }
+ | tUNUMBER tMONTH_UNIT
+ { $$ = RELATIVE_TIME_0; $$.month = $1.value; }
+ | tMONTH_UNIT
+ { $$ = RELATIVE_TIME_0; $$.month = 1; }
+ | tORDINAL tDAY_UNIT
+ { $$ = RELATIVE_TIME_0; $$.day = $1 * $2; }
+ | tUNUMBER tDAY_UNIT
+ { $$ = RELATIVE_TIME_0; $$.day = $1.value * $2; }
+ | tDAY_UNIT
+ { $$ = RELATIVE_TIME_0; $$.day = $1; }
+ | tORDINAL tHOUR_UNIT
+ { $$ = RELATIVE_TIME_0; $$.hour = $1; }
+ | tUNUMBER tHOUR_UNIT
+ { $$ = RELATIVE_TIME_0; $$.hour = $1.value; }
+ | tHOUR_UNIT
+ { $$ = RELATIVE_TIME_0; $$.hour = 1; }
+ | tORDINAL tMINUTE_UNIT
+ { $$ = RELATIVE_TIME_0; $$.minutes = $1; }
+ | tUNUMBER tMINUTE_UNIT
+ { $$ = RELATIVE_TIME_0; $$.minutes = $1.value; }
+ | tMINUTE_UNIT
+ { $$ = RELATIVE_TIME_0; $$.minutes = 1; }
+ | tORDINAL tSEC_UNIT
+ { $$ = RELATIVE_TIME_0; $$.seconds = $1; }
+ | tUNUMBER tSEC_UNIT
+ { $$ = RELATIVE_TIME_0; $$.seconds = $1.value; }
+ | tSDECIMAL_NUMBER tSEC_UNIT {
+ $$ = RELATIVE_TIME_0;
+ $$.seconds = $1.tv_sec;
+ $$.ns = $1.tv_nsec;
+ }
+ | tUDECIMAL_NUMBER tSEC_UNIT {
+ $$ = RELATIVE_TIME_0;
+ $$.seconds = $1.tv_sec;
+ $$.ns = $1.tv_nsec;
+ }
+ | tSEC_UNIT
+ { $$ = RELATIVE_TIME_0; $$.seconds = 1; }
+ | relunit_snumber
+;
+
+relunit_snumber:
+ tSNUMBER tYEAR_UNIT
+ { $$ = RELATIVE_TIME_0; $$.year = $1.value; }
+ | tSNUMBER tMONTH_UNIT
+ { $$ = RELATIVE_TIME_0; $$.month = $1.value; }
+ | tSNUMBER tDAY_UNIT
+ { $$ = RELATIVE_TIME_0; $$.day = $1.value * $2; }
+ | tSNUMBER tHOUR_UNIT
+ { $$ = RELATIVE_TIME_0; $$.hour = $1.value; }
+ | tSNUMBER tMINUTE_UNIT
+ { $$ = RELATIVE_TIME_0; $$.minutes = $1.value; }
+ | tSNUMBER tSEC_UNIT
+ { $$ = RELATIVE_TIME_0; $$.seconds = $1.value; }
+;
+
+dayshift:
+ tDAY_SHIFT
+ { $$ = RELATIVE_TIME_0; $$.day = $1; }
+;
+
+seconds: signed_seconds | unsigned_seconds;
+
+signed_seconds:
+ tSDECIMAL_NUMBER
+ | tSNUMBER
+ { $$.tv_sec = $1.value; $$.tv_nsec = 0; }
+;
+
+unsigned_seconds:
+ tUDECIMAL_NUMBER
+ | tUNUMBER
+ { $$.tv_sec = $1.value; $$.tv_nsec = 0; }
+;
+
+number:
+ tUNUMBER
+ { digits_to_date_time (pc, $1); }
+;
+
+hybrid:
+ tUNUMBER relunit_snumber {
+ /**
+ * Hybrid all-digit and relative offset, so that we accept e.g.,
+ * "YYYYMMDD +N days" as well as "YYYYMMDD N days".
+ */
+ digits_to_date_time (pc, $1);
+ apply_relative_time (pc, $2, 1);
+ }
+;
+
+o_colon_minutes:
+ /* empty */
+ { $$ = -1; }
+ | ':' tUNUMBER
+ { $$ = $2.value; }
+;
+
+%%
+
+static table const meridian_table[] = {
+ { "AM", tMERIDIAN, MERam },
+ { "A.M.", tMERIDIAN, MERam },
+ { "PM", tMERIDIAN, MERpm },
+ { "P.M.", tMERIDIAN, MERpm },
+ { NULL, 0, 0 }
+};
+
+static table const dst_table[] = {
+ { "DST", tDST, 0 }
+};
+
+static table const month_and_day_table[] = {
+ { "JANUARY", tMONTH, 1 },
+ { "FEBRUARY", tMONTH, 2 },
+ { "MARCH", tMONTH, 3 },
+ { "APRIL", tMONTH, 4 },
+ { "MAY", tMONTH, 5 },
+ { "JUNE", tMONTH, 6 },
+ { "JULY", tMONTH, 7 },
+ { "AUGUST", tMONTH, 8 },
+ { "SEPTEMBER",tMONTH, 9 },
+ { "SEPT", tMONTH, 9 },
+ { "OCTOBER", tMONTH, 10 },
+ { "NOVEMBER", tMONTH, 11 },
+ { "DECEMBER", tMONTH, 12 },
+ { "SUNDAY", tDAY, 0 },
+ { "MONDAY", tDAY, 1 },
+ { "TUESDAY", tDAY, 2 },
+ { "TUES", tDAY, 2 },
+ { "WEDNESDAY",tDAY, 3 },
+ { "WEDNES", tDAY, 3 },
+ { "THURSDAY", tDAY, 4 },
+ { "THUR", tDAY, 4 },
+ { "THURS", tDAY, 4 },
+ { "FRIDAY", tDAY, 5 },
+ { "SATURDAY", tDAY, 6 },
+ { NULL, 0, 0 }
+};
+
+static table const time_units_table[] = {
+ { "YEAR", tYEAR_UNIT, 1 },
+ { "MONTH", tMONTH_UNIT, 1 },
+ { "FORTNIGHT",tDAY_UNIT, 14 },
+ { "WEEK", tDAY_UNIT, 7 },
+ { "DAY", tDAY_UNIT, 1 },
+ { "HOUR", tHOUR_UNIT, 1 },
+ { "MINUTE", tMINUTE_UNIT, 1 },
+ { "MIN", tMINUTE_UNIT, 1 },
+ { "SECOND", tSEC_UNIT, 1 },
+ { "SEC", tSEC_UNIT, 1 },
+ { NULL, 0, 0 }
+};
+
+/* Assorted relative-time words. */
+static table const relative_time_table[] = {
+ { "TOMORROW", tDAY_SHIFT, 1 },
+ { "YESTERDAY",tDAY_SHIFT, -1 },
+ { "TODAY", tDAY_SHIFT, 0 },
+ { "NOW", tDAY_SHIFT, 0 },
+ { "LAST", tORDINAL, -1 },
+ { "THIS", tORDINAL, 0 },
+ { "NEXT", tORDINAL, 1 },
+ { "FIRST", tORDINAL, 1 },
+ /*{ "SECOND", tORDINAL, 2 }, */
+ { "THIRD", tORDINAL, 3 },
+ { "FOURTH", tORDINAL, 4 },
+ { "FIFTH", tORDINAL, 5 },
+ { "SIXTH", tORDINAL, 6 },
+ { "SEVENTH", tORDINAL, 7 },
+ { "EIGHTH", tORDINAL, 8 },
+ { "NINTH", tORDINAL, 9 },
+ { "TENTH", tORDINAL, 10 },
+ { "ELEVENTH", tORDINAL, 11 },
+ { "TWELFTH", tORDINAL, 12 },
+ { "AGO", tAGO, -1 },
+ { "HENCE", tAGO, 1 },
+ { NULL, 0, 0 }
+};
+
+/**
+ * The universal time zone table. These labels can be used even for
+ * timestamps that would not otherwise be valid, e.g., GMT timestamps
+ * in London during summer.
+ */
+static table const universal_time_zone_table[] = {
+ { "GMT", tZONE, HOUR ( 0) }, /* Greenwich Mean */
+ { "UT", tZONE, HOUR ( 0) }, /* Universal (Coordinated) */
+ { "UTC", tZONE, HOUR ( 0) },
+ { NULL, 0, 0 }
+};
+
+/**
+ * The time zone table. This table is necessarily incomplete, as time
+ * zone abbreviations are ambiguous; e.g. Australians interpret "EST"
+ * as Eastern time in Australia, not as US Eastern Standard Time.
+ * You cannot rely on parse_date to handle arbitrary time zone
+ * abbreviations; use numeric abbreviations like "-0500" instead.
+ */
+static table const time_zone_table[] = {
+ { "WET", tZONE, HOUR ( 0) }, /* Western European */
+ { "WEST", tDAYZONE, HOUR ( 0) }, /* Western European Summer */
+ { "BST", tDAYZONE, HOUR ( 0) }, /* British Summer */
+ { "ART", tZONE, -HOUR ( 3) }, /* Argentina */
+ { "BRT", tZONE, -HOUR ( 3) }, /* Brazil */
+ { "BRST", tDAYZONE, -HOUR ( 3) }, /* Brazil Summer */
+ { "NST", tZONE, -(HOUR ( 3) + 30) }, /* Newfoundland Standard */
+ { "NDT", tDAYZONE,-(HOUR ( 3) + 30) }, /* Newfoundland Daylight */
+ { "AST", tZONE, -HOUR ( 4) }, /* Atlantic Standard */
+ { "ADT", tDAYZONE, -HOUR ( 4) }, /* Atlantic Daylight */
+ { "CLT", tZONE, -HOUR ( 4) }, /* Chile */
+ { "CLST", tDAYZONE, -HOUR ( 4) }, /* Chile Summer */
+ { "EST", tZONE, -HOUR ( 5) }, /* Eastern Standard */
+ { "EDT", tDAYZONE, -HOUR ( 5) }, /* Eastern Daylight */
+ { "CST", tZONE, -HOUR ( 6) }, /* Central Standard */
+ { "CDT", tDAYZONE, -HOUR ( 6) }, /* Central Daylight */
+ { "MST", tZONE, -HOUR ( 7) }, /* Mountain Standard */
+ { "MDT", tDAYZONE, -HOUR ( 7) }, /* Mountain Daylight */
+ { "PST", tZONE, -HOUR ( 8) }, /* Pacific Standard */
+ { "PDT", tDAYZONE, -HOUR ( 8) }, /* Pacific Daylight */
+ { "AKST", tZONE, -HOUR ( 9) }, /* Alaska Standard */
+ { "AKDT", tDAYZONE, -HOUR ( 9) }, /* Alaska Daylight */
+ { "HST", tZONE, -HOUR (10) }, /* Hawaii Standard */
+ { "HAST", tZONE, -HOUR (10) }, /* Hawaii-Aleutian Standard */
+ { "HADT", tDAYZONE, -HOUR (10) }, /* Hawaii-Aleutian Daylight */
+ { "SST", tZONE, -HOUR (12) }, /* Samoa Standard */
+ { "WAT", tZONE, HOUR ( 1) }, /* West Africa */
+ { "CET", tZONE, HOUR ( 1) }, /* Central European */
+ { "CEST", tDAYZONE, HOUR ( 1) }, /* Central European Summer */
+ { "MET", tZONE, HOUR ( 1) }, /* Middle European */
+ { "MEZ", tZONE, HOUR ( 1) }, /* Middle European */
+ { "MEST", tDAYZONE, HOUR ( 1) }, /* Middle European Summer */
+ { "MESZ", tDAYZONE, HOUR ( 1) }, /* Middle European Summer */
+ { "EET", tZONE, HOUR ( 2) }, /* Eastern European */
+ { "EEST", tDAYZONE, HOUR ( 2) }, /* Eastern European Summer */
+ { "CAT", tZONE, HOUR ( 2) }, /* Central Africa */
+ { "SAST", tZONE, HOUR ( 2) }, /* South Africa Standard */
+ { "EAT", tZONE, HOUR ( 3) }, /* East Africa */
+ { "MSK", tZONE, HOUR ( 3) }, /* Moscow */
+ { "MSD", tDAYZONE, HOUR ( 3) }, /* Moscow Daylight */
+ { "IST", tZONE, (HOUR ( 5) + 30) }, /* India Standard */
+ { "SGT", tZONE, HOUR ( 8) }, /* Singapore */
+ { "KST", tZONE, HOUR ( 9) }, /* Korea Standard */
+ { "JST", tZONE, HOUR ( 9) }, /* Japan Standard */
+ { "GST", tZONE, HOUR (10) }, /* Guam Standard */
+ { "NZST", tZONE, HOUR (12) }, /* New Zealand Standard */
+ { "NZDT", tDAYZONE, HOUR (12) }, /* New Zealand Daylight */
+ { NULL, 0, 0 }
+};
+
+/**
+ * Military time zone table.
+ *
+ * Note 'T' is a special case, as it is used as the separator in ISO
+ * 8601 date and time of day representation.
+ */
+static table const military_table[] = {
+ { "A", tZONE, -HOUR ( 1) },
+ { "B", tZONE, -HOUR ( 2) },
+ { "C", tZONE, -HOUR ( 3) },
+ { "D", tZONE, -HOUR ( 4) },
+ { "E", tZONE, -HOUR ( 5) },
+ { "F", tZONE, -HOUR ( 6) },
+ { "G", tZONE, -HOUR ( 7) },
+ { "H", tZONE, -HOUR ( 8) },
+ { "I", tZONE, -HOUR ( 9) },
+ { "K", tZONE, -HOUR (10) },
+ { "L", tZONE, -HOUR (11) },
+ { "M", tZONE, -HOUR (12) },
+ { "N", tZONE, HOUR ( 1) },
+ { "O", tZONE, HOUR ( 2) },
+ { "P", tZONE, HOUR ( 3) },
+ { "Q", tZONE, HOUR ( 4) },
+ { "R", tZONE, HOUR ( 5) },
+ { "S", tZONE, HOUR ( 6) },
+ { "T", 'T', 0 },
+ { "U", tZONE, HOUR ( 8) },
+ { "V", tZONE, HOUR ( 9) },
+ { "W", tZONE, HOUR (10) },
+ { "X", tZONE, HOUR (11) },
+ { "Y", tZONE, HOUR (12) },
+ { "Z", tZONE, HOUR ( 0) },
+ { NULL, 0, 0 }
+};
+
+
+
+/**
+ * Convert a time zone expressed as HH:MM into an integer count of
+ * minutes. If MM is negative, then S is of the form HHMM and needs
+ * to be picked apart; otherwise, S is of the form HH. As specified in
+ * http://www.opengroup.org/susv3xbd/xbd_chap08.html#tag_08_03, allow
+ * only valid TZ range, and consider first two digits as hours, if no
+ * minutes specified.
+ */
+
+static long int time_zone_hhmm(parser_control *pc, textint s, long int mm)
+{
+ long int n_minutes;
+
+ /**
+ * If the length of S is 1 or 2 and no minutes are specified,
+ * interpret it as a number of hours.
+ */
+ if (s.digits <= 2 && mm < 0)
+ s.value *= 100;
+
+ if (mm < 0)
+ n_minutes = (s.value / 100) * 60 + s.value % 100;
+ else
+ n_minutes = s.value * 60 + (s.negative ? -mm : mm);
+
+ /**
+ * If the absolute number of minutes is larger than 24 hours,
+ * arrange to reject it by incrementing pc->zones_seen. Thus,
+ * we allow only values in the range UTC-24:00 to UTC+24:00.
+ */
+ if (24 * 60 < abs (n_minutes))
+ pc->zones_seen++;
+
+ return n_minutes;
+}
+
+static int to_hour(long int hours, int meridian)
+{
+ switch (meridian) {
+ default: /* Pacify GCC. */
+ case MER24:
+ return 0 <= hours && hours < 24 ? hours : -1;
+ case MERam:
+ return 0 < hours && hours < 12 ? hours : hours == 12 ? 0 : -1;
+ case MERpm:
+ return 0 < hours && hours < 12 ? hours + 12 : hours == 12 ? 12 : -1;
+ }
+}
+
+static long int to_year(textint textyear)
+{
+ long int year = textyear.value;
+
+ if (year < 0)
+ year = -year;
+
+ /**
+ * XPG4 suggests that years 00-68 map to 2000-2068, and
+ * years 69-99 map to 1969-1999.
+ */
+ else if (textyear.digits == 2)
+ year += year < 69 ? 2000 : 1900;
+
+ return year;
+}
+
+static table const * lookup_zone(parser_control const *pc, char const *name)
+{
+ table const *tp;
+
+ for (tp = universal_time_zone_table; tp->name; tp++)
+ if (strcmp (name, tp->name) == 0)
+ return tp;
+
+ /**
+ * Try local zone abbreviations before those in time_zone_table, as
+ * the local ones are more likely to be right.
+ */
+ for (tp = pc->local_time_zone_table; tp->name; tp++)
+ if (strcmp (name, tp->name) == 0)
+ return tp;
+
+ for (tp = time_zone_table; tp->name; tp++)
+ if (strcmp (name, tp->name) == 0)
+ return tp;
+
+ return NULL;
+}
+
+#if ! HAVE_TM_GMTOFF
+/**
+ * Yield the difference between *A and *B,
+ * measured in seconds, ignoring leap seconds.
+ * The body of this function is taken directly from the GNU C Library;
+ * see src/strftime.c.
+ */
+static long int tm_diff(struct tm const *a, struct tm const *b)
+{
+ /**
+ * Compute intervening leap days correctly even if year is negative.
+ * Take care to avoid int overflow in leap day calculations.
+ */
+ int a4 = SHR (a->tm_year, 2) + SHR (TM_YEAR_BASE, 2) - ! (a->tm_year & 3);
+ int b4 = SHR (b->tm_year, 2) + SHR (TM_YEAR_BASE, 2) - ! (b->tm_year & 3);
+ int a100 = a4 / 25 - (a4 % 25 < 0);
+ int b100 = b4 / 25 - (b4 % 25 < 0);
+ int a400 = SHR (a100, 2);
+ int b400 = SHR (b100, 2);
+ int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
+ long int ayear = a->tm_year;
+ long int years = ayear - b->tm_year;
+ long int days = (365 * years + intervening_leap_days
+ + (a->tm_yday - b->tm_yday));
+ return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour))
+ + (a->tm_min - b->tm_min))
+ + (a->tm_sec - b->tm_sec));
+}
+#endif /* ! HAVE_TM_GMTOFF */
+
+static table const * lookup_word(parser_control const *pc, char *word)
+{
+ char *p;
+ char *q;
+ size_t wordlen;
+ table const *tp;
+ int period_found;
+ int abbrev;
+
+ /* Make it uppercase. */
+ for (p = word; *p; p++) {
+ unsigned char ch = *p;
+ *p = c_toupper (ch);
+ }
+
+ for (tp = meridian_table; tp->name; tp++)
+ if (strcmp (word, tp->name) == 0)
+ return tp;
+
+ /* See if we have an abbreviation for a month. */
+ wordlen = strlen (word);
+ abbrev = wordlen == 3 || (wordlen == 4 && word[3] == '.');
+
+ for (tp = month_and_day_table; tp->name; tp++)
+ if ((abbrev ? strncmp (word, tp->name, 3) :
+ strcmp (word, tp->name)) == 0)
+ return tp;
+
+ if ((tp = lookup_zone (pc, word)))
+ return tp;
+
+ if (strcmp (word, dst_table[0].name) == 0)
+ return dst_table;
+
+ for (tp = time_units_table; tp->name; tp++)
+ if (strcmp (word, tp->name) == 0)
+ return tp;
+
+ /* Strip off any plural and try the units table again. */
+ if (word[wordlen - 1] == 'S') {
+ word[wordlen - 1] = '\0';
+ for (tp = time_units_table; tp->name; tp++)
+ if (strcmp (word, tp->name) == 0)
+ return tp;
+ word[wordlen - 1] = 'S'; /* For "this" in relative_time_table. */
+ }
+
+ for (tp = relative_time_table; tp->name; tp++)
+ if (strcmp (word, tp->name) == 0)
+ return tp;
+
+ /* Military time zones. */
+ if (wordlen == 1)
+ for (tp = military_table; tp->name; tp++)
+ if (word[0] == tp->name[0])
+ return tp;
+
+ /* Drop out any periods and try the time zone table again. */
+ for (period_found = 0, p = q = word; (*p = *q); q++)
+ if (*q == '.')
+ period_found = 1;
+ else
+ p++;
+ if (period_found && (tp = lookup_zone (pc, word)))
+ return tp;
+
+ return NULL;
+}
+
+static int yylex (union YYSTYPE *lvalp, parser_control *pc)
+{
+ unsigned char c;
+ size_t count;
+
+ for (;;) {
+ while (c = *pc->input, c_isspace (c))
+ pc->input++;
+
+ if (ISDIGIT (c) || c == '-' || c == '+') {
+ char const *p;
+ int sign;
+ unsigned long int value;
+ if (c == '-' || c == '+') {
+ sign = c == '-' ? -1 : 1;
+ while (c = *++pc->input, c_isspace (c))
+ continue;
+ if (! ISDIGIT (c))
+ /* skip the '-' sign */
+ continue;
+ } else
+ sign = 0;
+ p = pc->input;
+ for (value = 0; ; value *= 10) {
+ unsigned long int value1 = value + (c - '0');
+ if (value1 < value)
+ return '?';
+ value = value1;
+ c = *++p;
+ if (! ISDIGIT (c))
+ break;
+ if (ULONG_MAX / 10 < value)
+ return '?';
+ }
+ if ((c == '.' || c == ',') && ISDIGIT (p[1])) {
+ time_t s;
+ int ns;
+ int digits;
+ unsigned long int value1;
+
+ /* Check for overflow when converting value to
+ * time_t.
+ */
+ if (sign < 0) {
+ s = - value;
+ if (0 < s)
+ return '?';
+ value1 = -s;
+ } else {
+ s = value;
+ if (s < 0)
+ return '?';
+ value1 = s;
+ }
+ if (value != value1)
+ return '?';
+
+ /* Accumulate fraction, to ns precision. */
+ p++;
+ ns = *p++ - '0';
+ for (digits = 2;
+ digits <= LOG10_BILLION; digits++) {
+ ns *= 10;
+ if (ISDIGIT (*p))
+ ns += *p++ - '0';
+ }
+
+ /* Skip excess digits, truncating toward
+ * -Infinity.
+ */
+ if (sign < 0)
+ for (; ISDIGIT (*p); p++)
+ if (*p != '0') {
+ ns++;
+ break;
+ }
+ while (ISDIGIT (*p))
+ p++;
+
+ /* Adjust to the timespec convention, which is
+ * that tv_nsec is always a positive offset even
+ * if tv_sec is negative.
+ */
+ if (sign < 0 && ns) {
+ s--;
+ if (! (s < 0))
+ return '?';
+ ns = BILLION - ns;
+ }
+
+ lvalp->timespec.tv_sec = s;
+ lvalp->timespec.tv_nsec = ns;
+ pc->input = p;
+ return
+ sign ? tSDECIMAL_NUMBER : tUDECIMAL_NUMBER;
+ } else {
+ lvalp->textintval.negative = sign < 0;
+ if (sign < 0) {
+ lvalp->textintval.value = - value;
+ if (0 < lvalp->textintval.value)
+ return '?';
+ } else {
+ lvalp->textintval.value = value;
+ if (lvalp->textintval.value < 0)
+ return '?';
+ }
+ lvalp->textintval.digits = p - pc->input;
+ pc->input = p;
+ return sign ? tSNUMBER : tUNUMBER;
+ }
+ }
+
+ if (c_isalpha (c)) {
+ char buff[20];
+ char *p = buff;
+ table const *tp;
+
+ do {
+ if (p < buff + sizeof buff - 1)
+ *p++ = c;
+ c = *++pc->input;
+ }
+ while (c_isalpha (c) || c == '.');
+
+ *p = '\0';
+ tp = lookup_word (pc, buff);
+ if (! tp) {
+ return '?';
+ }
+ lvalp->intval = tp->value;
+ return tp->type;
+ }
+
+ if (c != '(')
+ return to_uchar (*pc->input++);
+
+ count = 0;
+ do {
+ c = *pc->input++;
+ if (c == '\0')
+ return c;
+ if (c == '(')
+ count++;
+ else if (c == ')')
+ count--;
+ }
+ while (count != 0);
+ }
+}
+
+/* Do nothing if the parser reports an error. */
+static int yyerror(parser_control const *pc __attribute__((__unused__)),
+ char const *s __attribute__((__unused__)))
+{
+ return 0;
+}
+
+/**
+ * If *TM0 is the old and *TM1 is the new value of a struct tm after
+ * passing it to mktime, return 1 if it's OK that mktime returned T.
+ * It's not OK if *TM0 has out-of-range members.
+ */
+
+static int mktime_ok(struct tm const *tm0, struct tm const *tm1, time_t t)
+{
+ if (t == (time_t) -1) {
+ /**
+ * Guard against falsely reporting an error when parsing a
+ * timestamp that happens to equal (time_t) -1, on a host that
+ * supports such a timestamp.
+ */
+ tm1 = localtime (&t);
+ if (!tm1)
+ return 0;
+ }
+
+ return ! ((tm0->tm_sec ^ tm1->tm_sec)
+ | (tm0->tm_min ^ tm1->tm_min)
+ | (tm0->tm_hour ^ tm1->tm_hour)
+ | (tm0->tm_mday ^ tm1->tm_mday)
+ | (tm0->tm_mon ^ tm1->tm_mon)
+ | (tm0->tm_year ^ tm1->tm_year));
+}
+
+/**
+ * A reasonable upper bound for the size of ordinary TZ strings.
+ * Use heap allocation if TZ's length exceeds this.
+ */
+enum { TZBUFSIZE = 100 };
+
+/**
+ * Return a copy of TZ, stored in TZBUF if it fits, and heap-allocated
+ * otherwise.
+ */
+static char * get_tz(char tzbuf[TZBUFSIZE])
+{
+ char *tz = getenv ("TZ");
+ if (tz) {
+ size_t tzsize = strlen (tz) + 1;
+ tz = (tzsize <= TZBUFSIZE
+ ? memcpy (tzbuf, tz, tzsize)
+ : xstrdup (tz));
+ }
+ return tz;
+}
+
+/**
+ * Parse a date/time string, storing the resulting time value into *result.
+ * The string itself is pointed to by *p. Return 1 if successful.
+ * *p can be an incomplete or relative time specification; if so, use
+ * *now as the basis for the returned time.
+ */
+int parse_date(struct timespec *result, char const *p,
+ struct timespec const *now)
+{
+ time_t Start;
+ long int Start_ns;
+ struct tm const *tmp;
+ struct tm tm;
+ struct tm tm0;
+ parser_control pc;
+ struct timespec gettime_buffer;
+ unsigned char c;
+ int tz_was_altered = 0;
+ char *tz0 = NULL;
+ char tz0buf[TZBUFSIZE];
+ int ok = 1;
+ struct timeval tv;
+
+ if (! now) {
+ gettimeofday (&tv, NULL);
+ gettime_buffer.tv_sec = tv.tv_sec;
+ gettime_buffer.tv_nsec = tv.tv_usec * 1000;
+ now = &gettime_buffer;
+ }
+
+ Start = now->tv_sec;
+ Start_ns = now->tv_nsec;
+
+ tmp = localtime (&now->tv_sec);
+ if (! tmp)
+ return 0;
+
+ while (c = *p, c_isspace (c))
+ p++;
+
+ if (strncmp (p, "TZ=\"", 4) == 0) {
+ char const *tzbase = p + 4;
+ size_t tzsize = 1;
+ char const *s;
+
+ for (s = tzbase; *s; s++, tzsize++)
+ if (*s == '\\') {
+ s++;
+ if (! (*s == '\\' || *s == '"'))
+ break;
+ } else if (*s == '"') {
+ char *z;
+ char *tz1;
+ char tz1buf[TZBUFSIZE];
+ int large_tz = TZBUFSIZE < tzsize;
+ int setenv_ok;
+ tz0 = get_tz (tz0buf);
+ z = tz1 = large_tz ? malloc (tzsize) : tz1buf;
+ for (s = tzbase; *s != '"'; s++)
+ *z++ = *(s += *s == '\\');
+ *z = '\0';
+ setenv_ok = setenv ("TZ", tz1, 1) == 0;
+ if (large_tz)
+ free (tz1);
+ if (!setenv_ok)
+ goto fail;
+ tz_was_altered = 1;
+
+ p = s + 1;
+ while (c = *p, c_isspace (c))
+ p++;
+
+ break;
+ }
+ }
+
+ /**
+ * As documented, be careful to treat the empty string just like
+ * a date string of "0". Without this, an empty string would be
+ * declared invalid when parsed during a DST transition.
+ */
+ if (*p == '\0')
+ p = "0";
+
+ pc.input = p;
+ pc.year.value = tmp->tm_year;
+ pc.year.value += TM_YEAR_BASE;
+ pc.year.digits = 0;
+ pc.month = tmp->tm_mon + 1;
+ pc.day = tmp->tm_mday;
+ pc.hour = tmp->tm_hour;
+ pc.minutes = tmp->tm_min;
+ pc.seconds.tv_sec = tmp->tm_sec;
+ pc.seconds.tv_nsec = Start_ns;
+ tm.tm_isdst = tmp->tm_isdst;
+
+ pc.meridian = MER24;
+ pc.rel = RELATIVE_TIME_0;
+ pc.timespec_seen = 0;
+ pc.rels_seen = 0;
+ pc.dates_seen = 0;
+ pc.days_seen = 0;
+ pc.times_seen = 0;
+ pc.local_zones_seen = 0;
+ pc.dsts_seen = 0;
+ pc.zones_seen = 0;
+ pc.year_seen = 0;
+ pc.ordinal_day_seen = 0;
+
+#if HAVE_STRUCT_TM_TM_ZONE
+ pc.local_time_zone_table[0].name = tmp->tm_zone;
+ pc.local_time_zone_table[0].type = tLOCAL_ZONE;
+ pc.local_time_zone_table[0].value = tmp->tm_isdst;
+ pc.local_time_zone_table[1].name = NULL;
+
+ /**
+ * Probe the names used in the next three calendar quarters, looking
+ * for a tm_isdst different from the one we already have.
+ */
+ {
+ int quarter;
+ for (quarter = 1; quarter <= 3; quarter++) {
+ time_t probe = Start + quarter * (90 * 24 * 60 * 60);
+ struct tm const *probe_tm = localtime (&probe);
+ if (probe_tm && probe_tm->tm_zone
+ && probe_tm->tm_isdst
+ != pc.local_time_zone_table[0].value) {
+ {
+ pc.local_time_zone_table[1].name
+ = probe_tm->tm_zone;
+ pc.local_time_zone_table[1].type
+ = tLOCAL_ZONE;
+ pc.local_time_zone_table[1].value
+ = probe_tm->tm_isdst;
+ pc.local_time_zone_table[2].name
+ = NULL;
+ }
+ break;
+ }
+ }
+ }
+#else
+#if HAVE_TZNAME
+ {
+# if !HAVE_DECL_TZNAME
+ extern char *tzname[];
+# endif
+ int i;
+ for (i = 0; i < 2; i++) {
+ pc.local_time_zone_table[i].name = tzname[i];
+ pc.local_time_zone_table[i].type = tLOCAL_ZONE;
+ pc.local_time_zone_table[i].value = i;
+ }
+ pc.local_time_zone_table[i].name = NULL;
+ }
+#else
+ pc.local_time_zone_table[0].name = NULL;
+#endif
+#endif
+
+ if (pc.local_time_zone_table[0].name && pc.local_time_zone_table[1].name
+ && ! strcmp (pc.local_time_zone_table[0].name,
+ pc.local_time_zone_table[1].name)) {
+ /**
+ * This locale uses the same abbreviation for standard and
+ * daylight times. So if we see that abbreviation, we don't
+ * know whether it's daylight time.
+ */
+ pc.local_time_zone_table[0].value = -1;
+ pc.local_time_zone_table[1].name = NULL;
+ }
+
+ if (yyparse (&pc) != 0) {
+ goto fail;
+ }
+
+ if (pc.timespec_seen)
+ *result = pc.seconds;
+ else {
+ if (1 < (pc.times_seen | pc.dates_seen | pc.days_seen
+ | pc.dsts_seen
+ | (pc.local_zones_seen + pc.zones_seen))) {
+ goto fail;
+ }
+
+ tm.tm_year = to_year (pc.year) - TM_YEAR_BASE;
+ tm.tm_mon = pc.month - 1;
+ tm.tm_mday = pc.day;
+ if (pc.times_seen || (pc.rels_seen &&
+ ! pc.dates_seen && ! pc.days_seen)) {
+ tm.tm_hour = to_hour (pc.hour, pc.meridian);
+ if (tm.tm_hour < 0) {
+ goto fail;
+ }
+ tm.tm_min = pc.minutes;
+ tm.tm_sec = pc.seconds.tv_sec;
+ } else {
+ tm.tm_hour = tm.tm_min = tm.tm_sec = 0;
+ pc.seconds.tv_nsec = 0;
+ }
+
+ /**
+ * Let mktime deduce tm_isdst if we have an absolute timestamp.
+ */
+ if (pc.dates_seen | pc.days_seen | pc.times_seen)
+ tm.tm_isdst = -1;
+
+ /**
+ * But if the input explicitly specifies local time with or
+ * without DST, give mktime that information.
+ */
+ if (pc.local_zones_seen)
+ tm.tm_isdst = pc.local_isdst;
+
+ tm0 = tm;
+
+ Start = mktime (&tm);
+
+ if (! mktime_ok (&tm0, &tm, Start)) {
+ if (! pc.zones_seen) {
+ goto fail;
+ } else {
+ /** Guard against falsely reporting errors near
+ * the time_t boundaries when parsing times in
+ * other time zones. For example, suppose the
+ * input string "1969-12-31 23:00:00 -0100", the
+ * current time zone is 8 hours ahead of UTC,
+ * and the min time_t value is 1970-01-01
+ * 00:00:00 UTC. Then the min localtime value
+ * is 1970-01-01 08:00:00, and mktime will
+ * therefore fail on 1969-12-31 23:00:00. To
+ * work around the problem, set the time zone to
+ * 1 hour behind UTC temporarily by setting
+ * TZ="XXX1:00" and try mktime again.
+ */
+
+ long int time_zone = pc.time_zone;
+
+ long int abs_time_zone = time_zone < 0
+ ? - time_zone : time_zone;
+
+ long int abs_time_zone_hour
+ = abs_time_zone / 60;
+
+ int abs_time_zone_min = abs_time_zone % 60;
+
+ char tz1buf[sizeof "XXX+0:00"
+ + sizeof pc.time_zone
+ * CHAR_BIT / 3];
+
+ if (!tz_was_altered)
+ tz0 = get_tz (tz0buf);
+ sprintf (tz1buf, "XXX%s%ld:%02d",
+ &"-"[time_zone < 0],
+ abs_time_zone_hour,
+ abs_time_zone_min);
+ if (setenv ("TZ", tz1buf, 1) != 0) {
+ goto fail;
+ }
+ tz_was_altered = 1;
+ tm = tm0;
+ Start = mktime (&tm);
+ if (! mktime_ok (&tm0, &tm, Start)) {
+ goto fail;
+ }
+ }
+ }
+
+ if (pc.days_seen && ! pc.dates_seen) {
+ tm.tm_mday += ((pc.day_number - tm.tm_wday + 7) % 7 + 7
+ * (pc.day_ordinal
+ - (0 < pc.day_ordinal
+ && tm.tm_wday != pc.day_number)));
+ tm.tm_isdst = -1;
+ Start = mktime (&tm);
+ if (Start == (time_t) -1) {
+ goto fail;
+ }
+ }
+ /* Add relative date. */
+ if (pc.rel.year | pc.rel.month | pc.rel.day) {
+ int year = tm.tm_year + pc.rel.year;
+ int month = tm.tm_mon + pc.rel.month;
+ int day = tm.tm_mday + pc.rel.day;
+ if (((year < tm.tm_year) ^ (pc.rel.year < 0))
+ | ((month < tm.tm_mon) ^ (pc.rel.month < 0))
+ | ((day < tm.tm_mday) ^ (pc.rel.day < 0))) {
+ goto fail;
+ }
+ tm.tm_year = year;
+ tm.tm_mon = month;
+ tm.tm_mday = day;
+ tm.tm_hour = tm0.tm_hour;
+ tm.tm_min = tm0.tm_min;
+ tm.tm_sec = tm0.tm_sec;
+ tm.tm_isdst = tm0.tm_isdst;
+ Start = mktime (&tm);
+ if (Start == (time_t) -1) {
+ goto fail;
+ }
+ }
+
+ /**
+ * The only "output" of this if-block is an updated Start value,
+ * so this block must follow others that clobber Start.
+ */
+ if (pc.zones_seen) {
+ long int delta = pc.time_zone * 60;
+ time_t t1;
+#ifdef HAVE_TM_GMTOFF
+ delta -= tm.tm_gmtoff;
+#else
+ time_t t = Start;
+ struct tm const *gmt = gmtime (&t);
+ if (! gmt) {
+ goto fail;
+ }
+ delta -= tm_diff (&tm, gmt);
+#endif
+ t1 = Start - delta;
+ if ((Start < t1) != (delta < 0)) {
+ goto fail; /* time_t overflow */
+ }
+ Start = t1;
+ }
+
+ /**
+ * Add relative hours, minutes, and seconds. On hosts that
+ * support leap seconds, ignore the possibility of leap seconds;
+ * e.g., "+ 10 minutes" adds 600 seconds, even if one of them is
+ * a leap second. Typically this is not what the user wants,
+ * but it's too hard to do it the other way, because the time
+ * zone indicator must be applied before relative times, and if
+ * mktime is applied again the time zone will be lost.
+ */
+ long int sum_ns = pc.seconds.tv_nsec + pc.rel.ns;
+ long int normalized_ns = (sum_ns % BILLION + BILLION) % BILLION;
+ time_t t0 = Start;
+ long int d1 = 60 * 60 * pc.rel.hour;
+ time_t t1 = t0 + d1;
+ long int d2 = 60 * pc.rel.minutes;
+ time_t t2 = t1 + d2;
+ time_t d3 = pc.rel.seconds;
+ time_t t3 = t2 + d3;
+ long int d4 = (sum_ns - normalized_ns) / BILLION;
+ time_t t4 = t3 + d4;
+ time_t t5 = t4;
+
+ if ((d1 / (60 * 60) ^ pc.rel.hour)
+ | (d2 / 60 ^ pc.rel.minutes)
+ | ((t1 < t0) ^ (d1 < 0))
+ | ((t2 < t1) ^ (d2 < 0))
+ | ((t3 < t2) ^ (d3 < 0))
+ | ((t4 < t3) ^ (d4 < 0))
+ | (t5 != t4)) {
+ goto fail;
+ }
+ result->tv_sec = t5;
+ result->tv_nsec = normalized_ns;
+ }
+
+ goto done;
+
+ fail:
+ ok = 0;
+ done:
+ if (tz_was_altered)
+ ok &= (tz0 ? setenv ("TZ", tz0, 1)
+ : unsetenv ("TZ")) == 0;
+ if (tz0 != tz0buf)
+ free (tz0);
+ return ok;
+}
diff --git a/libblkid/src/superblocks/hfs.c b/libblkid/src/superblocks/hfs.c
index ee502cf..c234411 100644
--- a/libblkid/src/superblocks/hfs.c
+++ b/libblkid/src/superblocks/hfs.c
@@ -244,7 +244,9 @@
leaf_node_head = be32_to_cpu(bnode->leaf_head);
leaf_node_size = be16_to_cpu(bnode->node_size);
leaf_node_count = be32_to_cpu(bnode->leaf_count);
- if (leaf_node_count == 0)
+
+ if (leaf_node_size < sizeof(struct hfsplus_bnode_descriptor) +
+ sizeof(struct hfsplus_catalog_key) || leaf_node_count == 0)
return 0;
leaf_block = (leaf_node_head * leaf_node_size) / blocksize;
@@ -284,7 +286,8 @@
key = (struct hfsplus_catalog_key *)
&buf[sizeof(struct hfsplus_bnode_descriptor)];
- if (be32_to_cpu(key->parent_id) != HFSPLUS_POR_CNID)
+ if (be32_to_cpu(key->parent_id) != HFSPLUS_POR_CNID ||
+ be16_to_cpu(key->unicode_len) > 255)
return 0;
blkid_probe_set_utf8label(pr, key->unicode,
diff --git a/libfdisk/src/gpt.c b/libfdisk/src/gpt.c
index 6962e77..c99b16f 100644
--- a/libfdisk/src/gpt.c
+++ b/libfdisk/src/gpt.c
@@ -830,7 +830,7 @@
sz = (ssize_t) le32_to_cpu(header->npartition_entries) *
le32_to_cpu(header->sizeof_partition_entry);
- if (sz == 0 || sz >= UINT32_MAX ||
+ if (sz == 0 || sz >= (ssize_t) UINT32_MAX ||
le32_to_cpu(header->sizeof_partition_entry) != sizeof(struct gpt_entry)) {
DBG(LABEL, ul_debug("GPT entreis array size check failed"));
return NULL;
diff --git a/misc-utils/Makemodule.am b/misc-utils/Makemodule.am
index ce9df2c..2a159aa 100644
--- a/misc-utils/Makemodule.am
+++ b/misc-utils/Makemodule.am
@@ -180,3 +180,11 @@
misc-utils/getopt-parse.bash \
misc-utils/getopt-parse.tcsh
endif
+
+if BUILD_FINCORE
+usrbin_exec_PROGRAMS += fincore
+dist_man_MANS += misc-utils/fincore.1
+fincore_SOURCES = misc-utils/fincore.c
+fincore_LDADD = $(LDADD) libsmartcols.la libcommon.la
+fincore_CFLAGS = $(AM_CFLAGS) -I$(ul_libsmartcols_incdir)
+endif
diff --git a/misc-utils/fincore.1 b/misc-utils/fincore.1
new file mode 100644
index 0000000..942dd70
--- /dev/null
+++ b/misc-utils/fincore.1
@@ -0,0 +1,63 @@
+.\" Copyright 2017 Red Hat, Inc.
+.\"
+.\" This file may be copied under the terms of the GNU Public License.
+.TH FINCORE 1 "March 2017" "util-linux" "User Commands"
+.SH NAME
+fincore \- count pages of file contents in core
+.SH SYNOPSIS
+.B fincore
+[options]
+.I file ...
+.SH DESCRIPTION
+.B fincore
+counts pages of file contents being resident in memory(in core), and
+reports the numbers. An output line has 3 columns: the number of
+pages in core, a file size, and a file name. If an error
+occurs during counting, then an error message is printed to the stderr and
+.B fincore
+continues processing the rest of files listed in a command line.
+
+The default output is subject to change. So whenever possible, you should
+avoid using default outputs in your scripts. Always explicitly define expected
+columns by using
+.B \-\-output
+.I columns-list
+in environments where a stable output is required.
+.SH OPTIONS
+.TP
+.BR \-n , " \-\-noheadings"
+Do not print a header line in status output.
+.TP
+.BR \-b , " \-\-bytes"
+Print the SIZE column in bytes rather than in a human-readable format.
+.TP
+.BR \-o , " \-\-output \fIlist\fP"
+Define output columns. See the \fB\-\-help\fP output to get a list of the
+currently supported columns. The default list of columns may be extended if \fIlist\fP is
+specified in the format \fI+list\fP.
+.TP
+.BR \-r , " \-\-raw"
+Produce output in raw format. All potentially unsafe characters are hex-escaped
+(\\x<code>).
+.TP
+.BR \-J , " \-\-json"
+Use JSON output format.
+.TP
+\fB\-V\fR, \fB\-\-version\fR
+Display version information and exit.
+.TP
+\fB\-h\fR, \fB\-\-help\fR
+Display help text and exit.
+.SH AUTHORS
+.MT yamato@\:redhat.com
+Masatake YAMATO
+.ME
+.SH "SEE ALSO"
+.BR mincore (2),
+.BR getpagesize (2),
+.BR getconf (1)
+.SH AVAILABILITY
+The example command is part of the util-linux package and is available from
+.UR https://\:www.kernel.org\:/pub\:/linux\:/utils\:/util-linux/
+Linux Kernel Archive
+.UE .
diff --git a/misc-utils/fincore.c b/misc-utils/fincore.c
new file mode 100644
index 0000000..a2fc1d1
--- /dev/null
+++ b/misc-utils/fincore.c
@@ -0,0 +1,378 @@
+/*
+ * fincore - count pages of file contents in core
+ *
+ * Copyright (C) 2017 Red Hat, Inc. All rights reserved.
+ * Written by Masatake YAMATO <yamato@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it would be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "c.h"
+#include "nls.h"
+#include "closestream.h"
+#include "xalloc.h"
+#include "strutils.h"
+
+#include "libsmartcols.h"
+
+/* For large files, mmap is called in iterative way.
+ Window is the unit of vma prepared in each mmap
+ calling.
+
+ Window size depends on page size.
+ e.g. 128MB on x86_64. ( = N_PAGES_IN_WINDOW * 4096 ). */
+#define N_PAGES_IN_WINDOW (32 * 1024)
+
+
+struct colinfo {
+ const char *name;
+ double whint;
+ int flags;
+ const char *help;
+};
+
+enum {
+ COL_PAGES,
+ COL_SIZE,
+ COL_FILE
+};
+
+static struct colinfo infos[] = {
+ [COL_PAGES] = { "PAGES", 1, SCOLS_FL_RIGHT, N_("number of memory page")},
+ [COL_SIZE] = { "SIZE", 5, SCOLS_FL_RIGHT, N_("size of the file")},
+ [COL_FILE] = { "FILE", 4, 0, N_("file name")},
+};
+
+static int columns[ARRAY_SIZE(infos) * 2] = {-1};
+static size_t ncolumns;
+
+struct fincore_control {
+ const int pagesize;
+
+ struct libscols_table *tb; /* output */
+
+ unsigned int bytes : 1,
+ noheadings : 1,
+ raw : 1,
+ json : 1;
+};
+
+
+static int column_name_to_id(const char *name, size_t namesz)
+{
+ size_t i;
+
+ for (i = 0; i < ARRAY_SIZE(infos); i++) {
+ const char *cn = infos[i].name;
+
+ if (!strncasecmp(name, cn, namesz) && !*(cn + namesz))
+ return i;
+ }
+ warnx(_("unknown column: %s"), name);
+ return -1;
+}
+
+static int get_column_id(int num)
+{
+ assert(num >= 0);
+ assert((size_t) num < ncolumns);
+ assert(columns[num] < (int) ARRAY_SIZE(infos));
+ return columns[num];
+}
+
+static const struct colinfo *get_column_info(int num)
+{
+ return &infos[ get_column_id(num) ];
+}
+
+static int add_output_data(struct fincore_control *ctl,
+ const char *name,
+ off_t file_size,
+ off_t count_incore)
+{
+ size_t i;
+ char *tmp;
+ struct libscols_line *ln;
+
+ assert(ctl);
+ assert(ctl->tb);
+
+ ln = scols_table_new_line(ctl->tb, NULL);
+ if (!ln)
+ err(EXIT_FAILURE, _("failed to initialize output line"));
+
+ for (i = 0; i < ncolumns; i++) {
+ switch(get_column_id(i)) {
+ case COL_FILE:
+ scols_line_set_data(ln, i, name);
+ break;
+ case COL_PAGES:
+ xasprintf(&tmp, "%jd", (intmax_t) count_incore);
+ scols_line_refer_data(ln, i, tmp);
+ break;
+ case COL_SIZE:
+ if (ctl->bytes)
+ xasprintf(&tmp, "%jd", (intmax_t) file_size);
+ else
+ tmp = size_to_human_string(SIZE_SUFFIX_1LETTER, file_size);
+ scols_line_refer_data(ln, i, tmp);
+ break;
+ default:
+ return -EINVAL;
+ }
+ }
+
+ return 0;
+}
+
+static int do_mincore(struct fincore_control *ctl,
+ void *window, const size_t len,
+ const char *name,
+ off_t *count_incore)
+{
+ static unsigned char vec[N_PAGES_IN_WINDOW];
+ int n = (len / ctl->pagesize) + ((len % ctl->pagesize)? 1: 0);
+
+ if (mincore (window, len, vec) < 0) {
+ warn(_("failed to do mincore: %s"), name);
+ return -errno;
+ }
+
+ while (n > 0)
+ {
+ if (vec[--n] & 0x1)
+ {
+ vec[n] = 0;
+ (*count_incore)++;
+ }
+ }
+
+ return 0;
+}
+
+static int fincore_fd (struct fincore_control *ctl,
+ int fd,
+ const char *name,
+ off_t file_size,
+ off_t *count_incore)
+{
+ size_t window_size = N_PAGES_IN_WINDOW * ctl->pagesize;
+ off_t file_offset;
+ void *window = NULL;
+ int rc = 0;
+ int warned_once = 0;
+
+ for (file_offset = 0; file_offset < file_size; file_offset += window_size) {
+ size_t len;
+
+ len = file_size - file_offset;
+ if (len >= window_size)
+ len = window_size;
+
+ window = mmap(window, len, PROT_NONE, MAP_PRIVATE, fd, file_offset);
+ if (window == MAP_FAILED) {
+ if (!warned_once) {
+ rc = -EINVAL;
+ warn(_("failed to do mmap: %s"), name);
+ warned_once = 1;
+ }
+ break;
+ }
+
+ rc = do_mincore(ctl, window, len, name, count_incore);
+ if (rc)
+ break;
+
+ munmap (window, len);
+ }
+
+ return rc;
+}
+
+/*
+ * Returns: <0 on error, 0 success, 1 ignore.
+ */
+static int fincore_name(struct fincore_control *ctl,
+ const char *name,
+ struct stat *sb,
+ off_t *count_incore)
+{
+ int fd;
+ int rc = 0;
+
+ if ((fd = open (name, O_RDONLY)) < 0) {
+ warn(_("failed to open: %s"), name);
+ return -errno;
+ }
+
+ if (fstat (fd, sb) < 0) {
+ warn(_("failed to do fstat: %s"), name);
+ return -errno;
+ }
+
+ if (S_ISDIR(sb->st_mode))
+ rc = 1; /* ignore */
+
+ else if (sb->st_size)
+ rc = fincore_fd(ctl, fd, name, sb->st_size, count_incore);
+
+ close (fd);
+ return rc;
+}
+
+static void __attribute__((__noreturn__)) usage(FILE *out)
+{
+ size_t i;
+
+ fputs(USAGE_HEADER, out);
+ fprintf(out, _(" %s [options] file...\n"), program_invocation_short_name);
+
+ fputs(USAGE_OPTIONS, out);
+ fputs(_(" -J, --json use JSON output format\n"), out);
+ fputs(_(" -b, --bytes print sizes in bytes rather than in human readable format\n"), out);
+ fputs(_(" -n, --noheadings don't print headings\n"), out);
+ fputs(_(" -o, --output <list> output columns\n"), out);
+ fputs(_(" -r, --raw use raw output format\n"), out);
+
+ fputs(USAGE_SEPARATOR, out);
+ fputs(USAGE_HELP, out);
+ fputs(USAGE_VERSION, out);
+
+ fprintf(out, _("\nAvailable columns (for --output):\n"));
+
+ for (i = 0; i < ARRAY_SIZE(infos); i++)
+ fprintf(out, " %11s %s\n", infos[i].name, _(infos[i].help));
+
+ fprintf(out, USAGE_MAN_TAIL("fincore(1)"));
+
+ exit(out == stderr ? EXIT_FAILURE : EXIT_SUCCESS);
+}
+
+int main(int argc, char ** argv)
+{
+ int c;
+ size_t i;
+ int rc = EXIT_SUCCESS;
+ char *outarg = NULL;
+
+ struct fincore_control ctl = {
+ .pagesize = getpagesize()
+ };
+
+ static const struct option longopts[] = {
+ { "bytes", no_argument, NULL, 'b' },
+ { "noheadings", no_argument, NULL, 'n' },
+ { "output", required_argument, NULL, 'o' },
+ { "version", no_argument, NULL, 'V' },
+ { "help", no_argument, NULL, 'h' },
+ { "json", no_argument, NULL, 'J' },
+ { "raw", no_argument, NULL, 'r' },
+ { NULL, 0, NULL, 0 },
+ };
+
+ setlocale(LC_ALL, "");
+ bindtextdomain(PACKAGE, LOCALEDIR);
+ textdomain(PACKAGE);
+ atexit(close_stdout);
+
+ while ((c = getopt_long (argc, argv, "bno:JrVh", longopts, NULL)) != -1) {
+ switch (c) {
+ case 'b':
+ ctl.bytes = 1;
+ break;
+ case 'n':
+ ctl.noheadings = 1;
+ break;
+ case 'o':
+ outarg = optarg;
+ break;
+ case 'J':
+ ctl.json = 1;
+ break;
+ case 'r':
+ ctl.raw = 1;
+ break;
+ case 'V':
+ printf(UTIL_LINUX_VERSION);
+ return EXIT_SUCCESS;
+ case 'h':
+ usage(stdout);
+ default:
+ errtryhelp(EXIT_FAILURE);
+ }
+ }
+
+ if (optind == argc) {
+ warnx(_("no file specified"));
+ errtryhelp(EXIT_FAILURE);
+ }
+
+ if (!ncolumns) {
+ columns[ncolumns++] = COL_PAGES;
+ columns[ncolumns++] = COL_SIZE;
+ columns[ncolumns++] = COL_FILE;
+ }
+
+ if (outarg && string_add_to_idarray(outarg, columns, ARRAY_SIZE(columns),
+ &ncolumns, column_name_to_id) < 0)
+ return EXIT_FAILURE;
+
+ scols_init_debug(0);
+ ctl.tb = scols_new_table();
+ if (!ctl.tb)
+ err(EXIT_FAILURE, _("failed to create output table"));
+
+ scols_table_enable_noheadings(ctl.tb, ctl.noheadings);
+ scols_table_enable_raw(ctl.tb, ctl.raw);
+ scols_table_enable_json(ctl.tb, ctl.json);
+ if (ctl.json)
+ scols_table_set_name(ctl.tb, "fincore");
+
+ for (i = 0; i < ncolumns; i++) {
+ const struct colinfo *col = get_column_info(i);
+
+ if (!scols_table_new_column(ctl.tb, col->name, col->whint, col->flags))
+ err(EXIT_FAILURE, _("failed to initialize output column"));
+ }
+
+ for(; optind < argc; optind++) {
+ char *name = argv[optind];
+ struct stat sb;
+ off_t count_incore = 0;
+
+ switch (fincore_name(&ctl, name, &sb, &count_incore)) {
+ case 0:
+ add_output_data(&ctl, name, sb.st_size, count_incore);
+ break;
+ case 1:
+ break; /* ignore */
+ default:
+ rc = EXIT_FAILURE;
+ break;
+ }
+ }
+
+ scols_print_table(ctl.tb);
+ scols_unref_table(ctl.tb);
+
+ return rc;
+}
diff --git a/sys-utils/hwclock-rtc.c b/sys-utils/hwclock-rtc.c
index 411ec43..077db73 100644
--- a/sys-utils/hwclock-rtc.c
+++ b/sys-utils/hwclock-rtc.c
@@ -110,8 +110,8 @@
"/dev/efirtc",
"/dev/misc/efirtc",
#endif
- "/dev/rtc",
"/dev/rtc0",
+ "/dev/rtc",
"/dev/misc/rtc"
};
size_t i;
diff --git a/sys-utils/hwclock.8.in b/sys-utils/hwclock.8.in
index 2dec782..45ff73f 100644
--- a/sys-utils/hwclock.8.in
+++ b/sys-utils/hwclock.8.in
@@ -282,27 +282,27 @@
.
.TP
.BI \%\-\-date= date_string
-You need this option if you specify the
+This option must be used with the
.B \-\-set
or
.B \%\-\-predict
functions, otherwise it is ignored.
-It specifies the time to which to set the Hardware Clock, or the
-time for which to predict the Hardware Clock reading.
-The value of this option is used as an argument to the
-.BR date "(1) program's " \-\-date
-option. For example:
.RS
.IP "" 4
-.B "hwclock\ \-\-set\ \-\-date='2011-08-14\ 16:45:05'"
+.B "hwclock\ \-\-set\ \-\-date='16:45'"
+.IP "" 4
+.B "hwclock\ \-\-predict\ \-\-date='2525-08-14\ 07:11:05'"
.PP
The argument must be in local time, even if you keep your Hardware Clock in
-UTC. See the
+UTC. See the
.B \%\-\-localtime
-option. The argument must not be a relative time like "+5 minutes", because
+option. Therefore, the argument should not include any timezone information.
+It also should not be a relative time like "+5 minutes", because
.BR \%hwclock 's
-precision depends upon correlation between the argument's value and when
-the enter key is pressed.
+precision depends upon correlation between the argument's value and when the
+enter key is pressed. Fractional seconds are silently dropped. This option is
+capable of understanding many time and date formats, but the previous
+parameters should be observed.
.RE
.
.TP
@@ -337,10 +337,10 @@
use the first one found in this order:
.in +4
.br
-.I /dev/rtc
-.br
.I /dev/rtc0
.br
+.I /dev/rtc
+.br
.I /dev/misc/rtc
.br
.in
@@ -1010,10 +1010,10 @@
.B hwclock
may try for Hardware Clock access:
.br
-.I /dev/rtc
-.br
.I /dev/rtc0
.br
+.I /dev/rtc
+.br
.I /dev/misc/rtc
.br
.I /dev/efirtc
diff --git a/sys-utils/hwclock.c b/sys-utils/hwclock.c
index 21d1304..21559cf 100644
--- a/sys-utils/hwclock.c
+++ b/sys-utils/hwclock.c
@@ -639,100 +639,6 @@
}
/*
- * Interpret the value of the --date option, which is something like
- * "13:05:01". In fact, it can be any of the myriad ASCII strings that
- * specify a time which the "date" program can understand. The date option
- * value in question is our "dateopt" argument.
- *
- * The specified time is in the local time zone.
- *
- * Our output, "*time_p", is a seconds-into-epoch time.
- *
- * We use the "date" program to interpret the date string. "date" must be
- * runnable by issuing the command "date" to the /bin/sh shell. That means
- * in must be in the current PATH.
- *
- * If anything goes wrong (and many things can), we return code 10
- * and arbitrary *time_p. Otherwise, return code is 0 and *time_p is valid.
- */
-static int interpret_date_string(const struct hwclock_control *ctl,
- time_t *const time_p)
-{
- FILE *date_child_fp = NULL;
- char *date_command = NULL;
- char *date_resp = NULL;
- size_t len = 0;
- const char magic[] = "seconds-into-epoch=";
- int retcode = 1;
- long seconds_since_epoch;
-
- if (!ctl->date_opt) {
- warnx(_("No --date option specified."));
- return retcode;
- }
-
- /* Quotes in date_opt would ruin the date command we construct. */
- if (strchr(ctl->date_opt, '"') != NULL ||
- strchr(ctl->date_opt, '`') != NULL ||
- strchr(ctl->date_opt, '$') != NULL) {
- warnx(_
- ("The value of the --date option is not a valid date.\n"
- "In particular, it contains illegal character(s)."));
- return retcode;
- }
-
- xasprintf(&date_command, "date --date=\"%s\" +%s%%s",
- ctl->date_opt, magic);
- if (ctl->debug)
- printf(_("Issuing date command: %s\n"), date_command);
-
- date_child_fp = popen(date_command, "r");
- if (date_child_fp == NULL) {
- warn(_("Unable to run 'date' program in /bin/sh shell. "
- "popen() failed"));
- goto out;
- }
-
- if (getline(&date_resp, &len, date_child_fp) < 0) {
- warn(_("getline() failed"));
- goto out;
- }
- if (ctl->debug)
- printf(_("response from date command = %s\n"), date_resp);
- if (strncmp(date_resp, magic, sizeof(magic) - 1) != 0) {
- warnx(_("The date command issued by %s returned "
- "unexpected results.\n"
- "The command was:\n %s\n"
- "The response was:\n %s"),
- program_invocation_short_name, date_command, date_resp);
- goto out;
- }
-
- if (sscanf(date_resp + sizeof(magic) - 1, "%ld", &seconds_since_epoch) < 1) {
- warnx(_("The date command issued by %s returned "
- "something other than an integer where the "
- "converted time value was expected.\n"
- "The command was:\n %s\n"
- "The response was:\n %s\n"),
- program_invocation_short_name, date_command, date_resp);
- } else {
- retcode = 0;
- *time_p = seconds_since_epoch;
- if (ctl->debug)
- printf(_("date string %s equates to "
- "%ld seconds since 1969.\n"),
- ctl->date_opt, *time_p);
- }
- out:
- free(date_command);
- free(date_resp);
- if (date_child_fp)
- pclose(date_child_fp);
-
- return retcode;
-}
-
-/*
* Set the System Clock to time 'newtime'.
*
* Also set the kernel time zone value to the value indicated by the TZ
@@ -1460,6 +1366,7 @@
struct hwclock_control ctl = { NULL };
struct timeval startup_time;
struct adjtime adjtime = { 0 };
+ struct timespec when = { 0 };
/*
* The time we started up, in seconds into the epoch, including
* fractions.
@@ -1699,11 +1606,10 @@
#endif
if (ctl.set || ctl.predict) {
- rc = interpret_date_string(&ctl, &set_time);
- /* (time-consuming) */
- if (rc != 0) {
- warnx(_("No usable set-to time. "
- "Cannot set clock."));
+ if (parse_date(&when, ctl.date_opt, NULL))
+ set_time = when.tv_sec;
+ else {
+ warnx(_("invalid date '%s'"), ctl.date_opt);
hwclock_exit(&ctl, EX_USAGE);
}
}
diff --git a/tests/commands.sh b/tests/commands.sh
index 2e3a276..2e5c11d 100644
--- a/tests/commands.sh
+++ b/tests/commands.sh
@@ -50,6 +50,7 @@
TS_CMD_FDISK=${TS_CMD_FDISK-"$top_builddir/fdisk"}
TS_CMD_FLOCK=${TS_CMD_FLOCK-"$top_builddir/flock"}
TS_CMD_SFDISK=${TS_CMD_SFDISK-"$top_builddir/sfdisk"}
+TS_CMD_FINCORE=${TS_CMD_FINCORE-"$top_builddir/fincore"}
TS_CMD_FINDMNT=${TS_CMD_FINDMNT-"$top_builddir/findmnt"}
TS_CMD_FSCKCRAMFS=${TS_CMD_FSCKCRAMFS:-"$top_builddir/fsck.cramfs"}
TS_CMD_FSCKMINIX=${TS_CMD_FSCKMINIX:-"$top_builddir/fsck.minix"}
diff --git a/tests/expected/fincore/count b/tests/expected/fincore/count
new file mode 100644
index 0000000..d5ce062
--- /dev/null
+++ b/tests/expected/fincore/count
@@ -0,0 +1,61 @@
+[ NO EXCITING FILE ]
+fincore: failed to open: no_such_file: No such file or directory
+return value: 1
+ 0 0 i_EMPTY_FILE
+return value: 0
+ 1 2048 i_SMALLER_THAN_PAGESIZE__incore_
+return value: 0
+ 1 4095 i_PAGESIZE_-1__incore_
+return value: 0
+ 1 4096 i_JUST_PAGESIZE_incore_
+return value: 0
+ 0 4096 i_JUST_PAGESIZE_directio_
+return value: 0
+ 2 4097 i_PAGESIZE_+_1__incore_
+return value: 0
+ 2 8192 i_TWO_PAGES_incore_
+return value: 0
+ 0 8192 i_TWO_PAGES_directio_
+return value: 0
+ 1 8192 i_TWO_PAGES_mixed_directio_incore_
+return value: 0
+ 1 8192 i_TWO_PAGES_mixed_incore_directio_
+return value: 0
+ 2 134213632 i_WINDOW_SIZE_incore-sparse-incore_
+return value: 0
+ 0 134213632 i_WINDOW_SIZE_directio-sparse-directio_
+return value: 0
+ 1 134213632 i_WINDOW_SIZE_incore-sparse-directio_
+return value: 0
+ 1 134213632 i_WINDOW_SIZE_directio-sparse-incore_
+return value: 0
+ 2 134217728 i_WINDOW_SIZE_+_1_page_incore-sparse-incore_
+return value: 0
+ 0 134217728 i_WINDOW_SIZE_+_1_page_directio-sparse-directio_
+return value: 0
+ 1 134217728 i_WINDOW_SIZE_+_1_page_incore-sparse-directio_
+return value: 0
+ 1 134217728 i_WINDOW_SIZE_+_1_page_directio-sparse-incore_
+return value: 0
+[ MULTIPLE FILES ]
+fincore: failed to open: no_such_file: No such file or directory
+PAGES SIZE FILE
+ 0 0 i_EMPTY_FILE
+ 1 2048 i_SMALLER_THAN_PAGESIZE__incore_
+ 1 4095 i_PAGESIZE_-1__incore_
+ 1 4096 i_JUST_PAGESIZE_incore_
+ 0 4096 i_JUST_PAGESIZE_directio_
+ 2 4097 i_PAGESIZE_+_1__incore_
+ 2 8192 i_TWO_PAGES_incore_
+ 0 8192 i_TWO_PAGES_directio_
+ 1 8192 i_TWO_PAGES_mixed_directio_incore_
+ 1 8192 i_TWO_PAGES_mixed_incore_directio_
+ 2 134213632 i_WINDOW_SIZE_incore-sparse-incore_
+ 0 134213632 i_WINDOW_SIZE_directio-sparse-directio_
+ 1 134213632 i_WINDOW_SIZE_incore-sparse-directio_
+ 1 134213632 i_WINDOW_SIZE_directio-sparse-incore_
+ 2 134217728 i_WINDOW_SIZE_+_1_page_incore-sparse-incore_
+ 0 134217728 i_WINDOW_SIZE_+_1_page_directio-sparse-directio_
+ 1 134217728 i_WINDOW_SIZE_+_1_page_incore-sparse-directio_
+ 1 134217728 i_WINDOW_SIZE_+_1_page_directio-sparse-incore_
+return value: 1
diff --git a/tests/ts/fincore/count b/tests/ts/fincore/count
new file mode 100755
index 0000000..a3638ac
--- /dev/null
+++ b/tests/ts/fincore/count
@@ -0,0 +1,194 @@
+#!/bin/bash
+
+function header
+{
+ echo "[" "$1" "]"
+}
+
+function footer
+{
+ echo "return value: $1"
+}
+
+function make_input_name
+{
+ header=$1
+ prefix=i_
+ echo ${prefix}$(sed -e "s/[^-+a-zA-Z0-9_]/_/g"<<<"$header")
+}
+
+function run_dd_test
+{
+ header=$1
+ bs=$2
+ flags=$3
+
+ input=$(make_input_name "$header")
+ INPUT="${INPUT} ${input}"
+
+ if [ "$bs" = 0 ]; then
+ touch $input
+ else
+ $DD if=/dev/zero of=$input count=1 bs=$bs $flags
+ fi
+
+ $TS_CMD_FINCORE --bytes --noheadings $input
+
+ footer "$?"
+}
+
+function run_dd_dd_test
+{
+ header=$1
+ flags0=$2
+ flags1=$3
+
+ bs=$PAGE_SIZE
+
+ input=$(make_input_name "$header")
+ INPUT="${INPUT} ${input}"
+
+ $DD if=/dev/zero of=$input count=1 bs=$bs $flags0
+ $DD if=/dev/zero of=$input count=1 bs=$bs $flags1
+
+ $TS_CMD_FINCORE --bytes --noheadings $input
+
+ footer "$?"
+}
+
+TS_TOPDIR="${0%/*}/../.."
+TS_DESC="count file contents in core"
+
+. $TS_TOPDIR/functions.sh
+ts_init "$*"
+
+PAGE_SIZE=$($TS_HELPER_SYSINFO pagesize)
+WINDOW_SIZE=$(( 32 * 1024 * PAGE_SIZE ))
+
+DD_FLAGS="status=none"
+DD="dd $DD_FLAGS"
+
+
+ts_check_test_command "$TS_CMD_FINCORE"
+ts_cd "$TS_OUTDIR"
+
+INPUT=
+input=
+
+{
+ input=no_such_file
+ INPUT="${INPUT} ${input}"
+
+ header "NO EXCITING FILE"
+ $TS_CMD_FINCORE --bytes --noheadings $input
+ footer "$?"
+} >> $TS_OUTPUT 2>&1
+
+{
+ run_dd_test "EMPTY FILE" 0
+} >> $TS_OUTPUT 2>&1
+
+{
+ run_dd_test "SMALLER THAN PAGESIZE (incore)" $(( PAGE_SIZE / 2 ))
+} >> $TS_OUTPUT 2>&1
+
+{
+ run_dd_test "PAGESIZE -1 (incore)" $(( PAGE_SIZE - 1 ))
+} >> $TS_OUTPUT 2>&1
+
+{
+ run_dd_test "JUST PAGESIZE(incore)" $(( PAGE_SIZE ))
+} >> $TS_OUTPUT 2>&1
+
+{
+ run_dd_test "JUST PAGESIZE(directio)" $(( PAGE_SIZE )) "oflag=direct"
+} >> $TS_OUTPUT 2>&1
+
+{
+ run_dd_test "PAGESIZE + 1 (incore)" $(( PAGE_SIZE + 1 ))
+} >> $TS_OUTPUT 2>&1
+
+{
+ run_dd_test "TWO PAGES(incore)" $(( 2 * PAGE_SIZE ))
+} >> $TS_OUTPUT 2>&1
+
+{
+ run_dd_test "TWO PAGES(directio)" $(( 2 * PAGE_SIZE )) "oflag=direct"
+} >> $TS_OUTPUT 2>&1
+
+{
+ run_dd_dd_test "TWO PAGES(mixed directio/incore)" \
+ oflag=direct \
+ "oflag=append seek=1"
+} >> $TS_OUTPUT 2>&1
+
+{
+ run_dd_dd_test "TWO PAGES(mixed incore/directio)" \
+ "" \
+ "oflag=direct,append seek=1"
+} >> $TS_OUTPUT 2>&1
+
+{
+ hole_count=$(( WINDOW_SIZE / PAGE_SIZE - 2 ))
+ run_dd_dd_test "WINDOW SIZE(incore-sparse-incore)" \
+ "" \
+ "oflag=append seek=$hole_count"
+} >> $TS_OUTPUT 2>&1
+
+{
+ hole_count=$(( WINDOW_SIZE / PAGE_SIZE - 2 ))
+ run_dd_dd_test "WINDOW SIZE(directio-sparse-directio)" \
+ "oflag=direct" \
+ "oflag=append,direct seek=$hole_count"
+} >> $TS_OUTPUT 2>&1
+
+{
+ hole_count=$(( WINDOW_SIZE / PAGE_SIZE - 2 ))
+ run_dd_dd_test "WINDOW SIZE(incore-sparse-directio)" \
+ "" \
+ "oflag=append,direct seek=$hole_count"
+} >> $TS_OUTPUT 2>&1
+
+{
+ hole_count=$(( WINDOW_SIZE / PAGE_SIZE - 2 ))
+ run_dd_dd_test "WINDOW SIZE(directio-sparse-incore)" \
+ "oflag=direct" \
+ "oflag=append seek=$hole_count"
+} >> $TS_OUTPUT 2>&1
+
+{
+ hole_count=$(( WINDOW_SIZE / PAGE_SIZE - 1 ))
+ run_dd_dd_test "WINDOW SIZE + 1 page(incore-sparse-incore)" \
+ "" \
+ "oflag=append seek=$hole_count"
+} >> $TS_OUTPUT 2>&1
+
+{
+ hole_count=$(( WINDOW_SIZE / PAGE_SIZE - 1 ))
+ run_dd_dd_test "WINDOW SIZE + 1 page(directio-sparse-directio)" \
+ "oflag=direct" \
+ "oflag=append,direct seek=$hole_count"
+} >> $TS_OUTPUT 2>&1
+
+{
+ hole_count=$(( WINDOW_SIZE / PAGE_SIZE - 1 ))
+ run_dd_dd_test "WINDOW SIZE + 1 page(incore-sparse-directio)" \
+ "" \
+ "oflag=append,direct seek=$hole_count"
+} >> $TS_OUTPUT 2>&1
+
+{
+ hole_count=$(( WINDOW_SIZE / PAGE_SIZE - 1 ))
+ run_dd_dd_test "WINDOW SIZE + 1 page(directio-sparse-incore)" \
+ "oflag=direct" \
+ "oflag=append seek=$hole_count"
+} >> $TS_OUTPUT 2>&1
+
+{
+ header "MULTIPLE FILES"
+ $TS_CMD_FINCORE --bytes $INPUT
+ footer "$?"
+} >> $TS_OUTPUT 2>&1
+
+rm -f $INPUT
+ts_finalize
