path: root/usr/src/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);
}