* Copyright (c) 1992 Keith Muller.
* Copyright (c) 1992 The Regents of the University of California.
* This code is derived from software contributed to Berkeley by
* Keith Muller of the University of California, San Diego.
* %sccs.include.redist.c%
static char sccsid
[] = "@(#)sel_subs.c 1.3 (Berkeley) %G%";
static int str_sec
__P((register char *, time_t *));
static int usr_match
__P((register ARCHD
*));
static int grp_match
__P((register ARCHD
*));
static int trng_match
__P((register ARCHD
*));
static TIME_RNG
*trhead
= NULL
; /* time range list head */
static TIME_RNG
*trtail
= NULL
; /* time range list tail */
static USRT
**usrtb
= NULL
; /* user selection table */
static GRPT
**grptb
= NULL
; /* group selection table */
* Routines for selection of archive members
* check if this file matches a specfied uid, gid or time range
* 0 if this archive member should be processed, 1 if it should be skipped
sel_chk(register ARCHD
*arcn
)
if (((usrtb
!= NULL
) && usr_match(arcn
)) ||
((grptb
!= NULL
) && grp_match(arcn
)) ||
((trhead
!= NULL
) && trng_match(arcn
)))
* User/group selection routines
* Routines to handle user selection of files based on the file uid/gid. To
* add an entry, the user supplies either then name or the uid/gid starting with
* a # on the command line. A \# will eascape the #.
* add a user match to the user match hash table
* 0 if added ok, -1 otherwise;
usr_add(register char *str
)
register struct passwd
*pw
;
* create the table if it doesn't exist
if ((str
== NULL
) || (*str
== '\0'))
((usrtb
= (USRT
**)calloc(USR_TB_SZ
, sizeof(USRT
*))) == NULL
)) {
warn(1, "Unable to allocate memory for user selection table");
* it is a user name, \# escapes # as first char in user name
if ((str
[0] == '\\') && (str
[1] == '#'))
if ((pw
= getpwnam(str
)) == NULL
) {
warn(1, "Unable to find uid for user: %s", str
);
uid
= (uid_t
)atoi(str
+1);
uid
= (uid_t
)strtoul(str
+1, (char **)NULL
, 10);
* hash it and go down the hash chain (if any) looking for it
indx
= ((unsigned)uid
) % USR_TB_SZ
;
if ((pt
= usrtb
[indx
]) != NULL
) {
* uid is not yet in the table, add it to the front of the chain
if ((pt
= (USRT
*)malloc(sizeof(USRT
))) != NULL
) {
warn(1, "User selection table out of memory");
* check if this files uid matches a selected uid.
* 0 if this archive member should be processed, 1 if it should be skipped
usr_match(register ARCHD
*arcn
)
* hash and look for it in the table
pt
= usrtb
[((unsigned)arcn
->sb
.st_uid
) % USR_TB_SZ
];
if (pt
->uid
== arcn
->sb
.st_uid
)
* add a group match to the group match hash table
* 0 if added ok, -1 otherwise;
grp_add(register char *str
)
register struct group
*gr
;
* create the table if it doesn't exist
if ((str
== NULL
) || (*str
== '\0'))
((grptb
= (GRPT
**)calloc(GRP_TB_SZ
, sizeof(GRPT
*))) == NULL
)) {
warn(1, "Unable to allocate memory fo group selection table");
* it is a group name, \# escapes # as first char in group name
if ((str
[0] == '\\') && (str
[1] == '#'))
if ((gr
= getgrnam(str
)) == NULL
) {
warn(1,"Cannot determine gid for group name: %s", str
);
gid
= (gid_t
)atoi(str
+1);
gid
= (gid_t
)strtoul(str
+1, (char **)NULL
, 10);
* hash it and go down the hash chain (if any) looking for it
indx
= ((unsigned)gid
) % GRP_TB_SZ
;
if ((pt
= grptb
[indx
]) != NULL
) {
* gid not in the table, add it to the front of the chain
if ((pt
= (GRPT
*)malloc(sizeof(GRPT
))) != NULL
) {
warn(1, "Group selection table out of memory");
* check if this files gid matches a selected gid.
* 0 if this archive member should be processed, 1 if it should be skipped
grp_match(register ARCHD
*arcn
)
* hash and look for it in the table
pt
= grptb
[((unsigned)arcn
->sb
.st_gid
) % GRP_TB_SZ
];
if (pt
->gid
== arcn
->sb
.st_gid
)
* Time range selection routines
* Routines to handle user selection of files based on the modification and/or
* inode change time falling within a specified time range (the non-standard
* -T flag). The user may specify any number of different file time ranges.
* Time ranges are checked one at a time until a match is found (if at all).
* If the file has a mtime (and/or ctime) which lies within one of the time
* ranges, the file is selected. Time ranges may have a lower and/or a upper
* value. These ranges are inclusive. When no time ranges are supplied to pax
* with the -T option, all members in the archive will be selected by the time
* range routines. When only a lower range is supplied, only files with a
* mtime (and/or ctime) equal to or younger are selected. When only a upper
* range is supplied, only files with a mtime (and/or ctime) equal to or older
* are selected. When the lower time range is equal to the upper time range,
* only files with a mtime (or ctime) of exactly that time are selected.
* add a time range match to the time range list.
* This is a non-standard pax option. Lower and upper ranges are in the
* format: [yy[mm[dd[hh]]]]mm[.ss] and are comma separated.
* Time ranges are based on current time, so 1234 would specify a time of
* 0 if the time range was added to the list, -1 otherwise
trng_add(register char *str
)
register char *up_pt
= NULL
;
* throw out the badly formed time ranges
if ((str
== NULL
) || (*str
== '\0')) {
warn(1, "Empty time range string");
* locate optional flags suffix /{cm}.
if ((flgpt
= rindex(str
, '/')) != NULL
)
for (stpt
= str
; *stpt
!= '\0'; ++stpt
) {
if ((*stpt
>= '0') && (*stpt
<= '9'))
if ((*stpt
== ',') && (up_pt
== NULL
)) {
* allow only one dot per range (secs)
if ((*stpt
== '.') && (!dot
)) {
warn(1, "Improperly specified time range: %s", str
);
* allocate space for the time range and store the limits
if ((pt
= (TIME_RNG
*)malloc(sizeof(TIME_RNG
))) == NULL
) {
warn(1, "Unable to allocate memory for time range");
* by default we only will check file mtime, but usee can specify
* mtime, ctime (inode change time) or both.
if ((flgpt
== NULL
) || (*flgpt
== '\0'))
warn(1, "Bad option %c with time range %s",
* start off with the current time
pt
->low_time
= pt
->high_time
= time((time_t *)NULL
);
if (str_sec(str
, &(pt
->low_time
)) < 0) {
warn(1, "Illegal lower time range %s", str
);
if ((up_pt
!= NULL
) && (*up_pt
!= '\0')) {
if (str_sec(up_pt
, &(pt
->high_time
)) < 0) {
warn(1, "Illegal upper time range %s", up_pt
);
* check that the upper and lower do not overlap
if (pt
->low_time
> pt
->high_time
) {
warn(1, "Upper %s and lower %s time overlap",
warn(1, "Time range format is: [yy[mm[dd[hh]]]]mm[.ss][/[c][m]]");
* check if this files mtime/ctime falls within any supplied time range.
* 0 if this archive member should be processed, 1 if it should be skipped
trng_match(register ARCHD
*arcn
)
* have to search down the list one at a time looking for a match.
* remember time range limits are inclusive.
switch(pt
->flgs
& CMPBOTH
) {
* user wants both mtime and ctime checked for this
if (((pt
->flgs
& HASLOW
) &&
(arcn
->sb
.st_mtime
< pt
->low_time
) &&
(arcn
->sb
.st_ctime
< pt
->low_time
)) ||
(arcn
->sb
.st_mtime
> pt
->high_time
) &&
(arcn
->sb
.st_ctime
> pt
->high_time
))) {
* user wants only ctime checked for this time range
if (((pt
->flgs
& HASLOW
) &&
(arcn
->sb
.st_ctime
< pt
->low_time
)) ||
(arcn
->sb
.st_ctime
> pt
->high_time
))) {
* user wants only mtime checked for this time range
if (((pt
->flgs
& HASLOW
) &&
(arcn
->sb
.st_mtime
< pt
->low_time
)) ||
(arcn
->sb
.st_mtime
> pt
->high_time
))) {
* Convert a time string in the format of [yy[mm[dd[hh]]]]mm[.ss] to gmt
* seconds. Tval already has current time loaded into it at entry.
* 0 if converted ok, -1 otherwise
str_sec(register char *str
, time_t *tval
)
register char *dot
= NULL
;
if ((dot
= index(str
, '.')) != NULL
) {
if ((lt
->tm_sec
= ATOI2(dot
)) > 61)
* watch out for year 2000
if ((lt
->tm_year
= ATOI2(str
)) < 69)
* watch out months are from 0 - 11 internally
if ((lt
->tm_mon
= ATOI2(str
)) > 12)
if ((lt
->tm_mday
= ATOI2(str
)) > 31)
if ((lt
->tm_hour
= ATOI2(str
)) > 23)
if ((lt
->tm_min
= ATOI2(str
)) > 59)
* convert broken-down time to GMT clock time seconds
if ((*tval
= mktime(lt
)) == -1)