OpenSolaris_b135/cmd/acct/lib/pnpsplit.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
/*
* pnpsplit splits interval into prime & nonprime portions
* ONLY ROUTINE THAT KNOWS ABOUT HOLIDAYS AND DEFN OF PRIME/NONPRIME
*/
#include <stdio.h>
#include <sys/types.h>
#include <sys/param.h>
#include "acctdef.h"
#include <time.h>
#include <ctype.h>
/*
* validate that hours and minutes of prime/non-prime read in
* from holidays file fall within proper boundaries.
* Time is expected in the form and range of 0000-2400.
*/
static int thisyear = 1970; /* this is changed by holidays file */
static int holidays[NHOLIDAYS]; /* holidays file day-of-year table */
static int day_tab[2][13] = {
{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
{0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
};
/*
* prime(0) and nonprime(1) times during a day
* for BTL, prime time is 9AM to 5PM
*/
static struct hours {
int h_sec; /* normally always zero */
int h_min; /* initialized from holidays file (time%100) */
int h_hour; /* initialized from holidays file (time/100) */
long h_type; /* prime/nonprime of previous period */
} h[4];
int daysend[] = {0, 60, 23}; /* the sec, min, hr of the day's end */
struct tm *localtime();
long tmsecs();
/*
* split interval of length etime, starting at start into prime/nonprime
* values, return as result
* input values in seconds
*/
int
pnpsplit(start, etime, result)
long start, result[2];
ulong_t etime;
{
struct tm cur, end;
time_t tcur, tend;
long tmp;
int sameday;
register struct hours *hp;
char *memcpy();
/* once holidays file is read, this is zero */
if(thisyear && (checkhol() == 0)) {
return(0);
}
tcur = start;
tend = start + etime;
memcpy(&end, localtime(&tend), sizeof(end));
result[PRIME] = 0;
result[NONPRIME] = 0;
while ( tcur < tend ) { /* one iteration per day or part thereof */
memcpy(&cur, localtime(&tcur), sizeof(cur));
sameday = cur.tm_yday == end.tm_yday;
if (ssh(&cur)) { /* ssh:only NONPRIME */
if (sameday) {
result[NONPRIME] += tend-tcur;
break;
} else {
tmp = tmsecs(&cur, daysend);
result[NONPRIME] += tmp;
tcur += tmp;
}
} else { /* working day, PRIME or NONPRIME */
for (hp = h; tmless(hp, &cur); hp++);
for (; hp->h_sec >= 0; hp++) {
if (sameday && tmless(&end, hp)) {
/* WHCC mod, change from = to += 3/6/86 Paul */
result[hp->h_type] += tend-tcur;
tcur = tend;
break; /* all done */
} else { /* time to next PRIME /NONPRIME change */
tmp = tmsecs(&cur, hp);
result[hp->h_type] += tmp;
tcur += tmp;
cur.tm_sec = hp->h_sec;
cur.tm_min = hp->h_min;
cur.tm_hour = hp->h_hour;
}
}
}
}
return(1);
}
/*
* Starting day after Christmas, complain if holidays not yet updated.
* This code is only executed once per program invocation.
*/
int
checkhol()
{
register struct tm *tp;
time_t t;
if(inithol() == 0) {
fprintf(stderr, "pnpsplit: holidays table setup failed\n");
thisyear = 0;
holidays[0] = -1;
return(0);
}
time(&t);
tp = localtime(&t);
tp->tm_year += 1900;
if ((tp->tm_year == thisyear && tp->tm_yday > 359)
|| tp->tm_year > thisyear)
fprintf(stderr,
"***UPDATE %s WITH NEW HOLIDAYS***\n", HOLFILE);
thisyear = 0; /* checkhol() will not be called again */
return(1);
}
/*
* ssh returns 1 if Sat, Sun, or Holiday
*/
int
ssh(ltp)
register struct tm *ltp;
{
int i;
if (ltp->tm_wday == 0 || ltp->tm_wday == 6)
return(1);
for (i = 0; holidays[i] >= 0; i++)
if (ltp->tm_yday == holidays[i])
return(1);
return(0);
}
/*
* inithol - read from an ascii file and initialize the "thisyear"
* variable, the times that prime and non-prime start, and the
* holidays array.
*/
int
inithol()
{
FILE *fopen(), *holptr;
char *fgets(), holbuf[128];
register int line = 0,
holindx = 0,
errflag = 0;
int pstart, npstart;
int doy; /* day of the year */
int month, day;
char *c;
if((holptr=fopen(HOLFILE, "r")) == NULL) {
perror(HOLFILE);
fclose(holptr);
return(0);
}
while(fgets(holbuf, sizeof(holbuf), holptr) != NULL) {
/* skip over blank lines and comments */
if (holbuf[0] == '*')
continue;
for (c = holbuf; isspace(*c); c++)
/* is a space */;
if (*c == '\0')
continue;
else if(++line == 1) { /* format: year p-start np-start */
if(sscanf(holbuf, "%4d %4d %4d",
&thisyear, &pstart, &npstart) != 3) {
fprintf(stderr,
"%s: bad {yr ptime nptime} conversion\n",
HOLFILE);
errflag++;
break;
}
/* validate year */
if(thisyear < 1970 || thisyear > 2037) {
fprintf(stderr, "pnpsplit: invalid year: %d\n",
thisyear);
errflag++;
break;
}
/* validate prime/nonprime hours */
if((! okay(pstart)) || (! okay(npstart))) {
fprintf(stderr,
"pnpsplit: invalid p/np hours\n");
errflag++;
break;
}
/* Set up start of prime time; 2400 == 0000 */
h[0].h_sec = 0;
h[0].h_min = pstart%100;
h[0].h_hour = (pstart/100==24) ? 0 : pstart/100;
h[0].h_type = NONPRIME;
/* Set up start of non-prime time; 2400 == 2360 */
if ((npstart/100) == 24) {
h[1].h_sec = 0;
h[1].h_min = 60;
h[1].h_hour = 23;
} else {
h[1].h_sec = 0;
h[1].h_min = npstart % 100;
h[1].h_hour = npstart / 100;
}
h[1].h_type = PRIME;
/* This is the end of the day */
h[2].h_sec = 0;
h[2].h_min = 60;
h[2].h_hour = 23;
h[2].h_type = NONPRIME;
/* The end of the array */
h[3].h_sec = -1;
continue;
}
else if(holindx >= NHOLIDAYS) {
fprintf(stderr, "pnpsplit: too many holidays, ");
fprintf(stderr, "recompile with larger NHOLIDAYS\n");
errflag++;
break;
}
/* Fill up holidays array from holidays file */
sscanf(holbuf, "%d/%d %*s %*s %*[^\n]\n", &month, &day);
if (month < 0 || month > 12) {
fprintf(stderr, "pnpsplit: invalid month %d\n", month);
errflag++;
break;
}
if (day < 0 || day > 31) {
fprintf(stderr, "pnpsplit: invalid day %d\n", day);
errflag++;
break;
}
doy = day_of_year(thisyear, month, day);
holidays[holindx++] = (doy - 1);
}
fclose(holptr);
if(!errflag && holindx < NHOLIDAYS) {
holidays[holindx] = -1;
return(1);
}
else
return(0);
}
/*
* tmsecs returns number of seconds from t1 to t2,
* times expressed in localtime format.
* assumed that t1 <= t2, and are in same day.
*/
long
tmsecs(t1, t2)
register struct tm *t1, *t2;
{
return((t2->tm_sec - t1->tm_sec) +
60*(t2->tm_min - t1->tm_min) +
3600L*(t2->tm_hour - t1->tm_hour));
}
/*
* return 1 if t1 earlier than t2 (times in localtime format)
* assumed that t1 and t2 are in same day
*/
int
tmless(t1, t2)
register struct tm *t1, *t2;
{
if (t1->tm_hour != t2->tm_hour)
return(t1->tm_hour < t2->tm_hour);
if (t1->tm_min != t2->tm_min)
return(t1->tm_min < t2->tm_min);
return(t1->tm_sec < t2->tm_sec);
}
/* set day of year from month and day */
int
day_of_year(year, month, day)
{
int i, leap;
leap = year%4 == 0 && year%100 || year%400 == 0;
for (i = 1; i < month; i++)
day += day_tab[leap][i];
return(day);
}