/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2002 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdio.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/file.h>
#include <sys/time.h>
#include <time.h>
#include <errno.h>
#include <unistd.h>

#define	isleap(y) (((y) % 4) == 0 && ((y) % 100) != 0 || ((y) % 400) == 0)

struct	stat	stbuf;
int	status;
#ifdef S5EMUL
int dmsize[12]={31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
#endif /* S5EMUL */

static char usage[] =
#ifdef S5EMUL
		"[-amc] [mmddhhmm[yy]]";
#else /*!S5EMUL*/
		"[-amcf]";
int	force = 0;
int	nowrite;
#endif /*!S5EMUL*/

int	mflg=1, aflg=1, cflg=0, nflg=0;
char	*prog;

#ifdef S5EMUL
char	*cbp;
#endif /* S5EMUL */
time_t	time();
off_t	lseek();
time_t	timelocal(), timegm();
struct timeval timbuf;
static void timestruc_to_timeval(timestruc_t *, struct timeval *);

#ifdef S5EMUL
struct tm *
gtime()
{
	static struct tm newtime;
	long nt;

	newtime.tm_mon = gpair() - 1;
	newtime.tm_mday = gpair();
	newtime.tm_hour = gpair();
	if (newtime.tm_hour == 24) {
		newtime.tm_hour = 0;
		newtime.tm_mday++;
	}
	newtime.tm_min = gpair();
	newtime.tm_sec = 0;
	newtime.tm_year = gpair();
	if (newtime.tm_year < 0) {
		(void) time(&nt);
		newtime.tm_year = localtime(&nt)->tm_year;
	}
	return (&newtime);
}

gpair()
{
	int c, d;
	char *cp;

	cp = cbp;
	if (*cp == 0)
		return (-1);
	c = (*cp++ - '0') * 10;
	if (c<0 || c>100)
		return (-1);
	if (*cp == 0)
		return (-1);
	if ((d = *cp++ - '0') < 0 || d > 9)
		return (-1);
	cbp = cp;
	return (c+d);
}
#endif /*S5EMUL*/

int
main(int argc, char *argv[])
{
	int c;
#ifdef S5EMUL
	int days_in_month;
	struct tm *tp;
#endif /* S5EMUL */

	int errflg=0, optc;
	extern char *optarg;
	extern int optind;
	extern int opterr;

	prog = argv[0];
	opterr = 0;			/* disable getopt() error msgs */
	while ((optc=getopt(argc, argv, "amcf")) != EOF)
		switch (optc) {
		case 'm':
			mflg++;
			aflg--;
			break;
		case 'a':
			aflg++;
			mflg--;
			break;
		case 'c':
			cflg++;
			break;
#ifndef S5EMUL
		case 'f':
			force++;	/* SysV version ignores -f */
			break;
#endif /*!S5EMUL*/
		case '?':
			errflg++;
		}

	if (((argc-optind) < 1) || errflg) {
		(void) fprintf(stderr, "usage: %s %s file ...\n", prog, usage);
		exit(2);
	}
	status = 0;

#ifdef S5EMUL
	if (!isnumber(argv[optind])) {	/* BSD version only sets Present */
#endif /*S5EMUL*/
		if ((aflg <= 0) || (mflg <= 0))
			(void) gettimeofday(&timbuf, NULL);
		else
			nflg++;		/* no -a, -m, or date seen */
#ifdef S5EMUL
	} else {			/* SysV version sets arbitrary date */
		cbp = (char *)argv[optind++];
		if ((tp = gtime()) == NULL) {
			(void) fprintf(stderr, "%s: bad date conversion\n",
			    prog);
			exit(2);
		}
		days_in_month = dmsize[tp->tm_mon];
		if (tp->tm_mon == 1 && isleap(tp->tm_year + 1900))
			days_in_month = 29;	/* February in leap year */
		if (tp->tm_mon < 0 || tp->tm_mon > 11 ||
		    tp->tm_mday < 1 || tp->tm_mday > days_in_month ||
		    tp->tm_hour < 0 || tp->tm_hour > 23 ||
		    tp->tm_min < 0 || tp->tm_min > 59 ||
		    tp->tm_sec < 0 || tp->tm_sec > 59) {
			(void) fprintf(stderr, "%s: bad date conversion\n",
			    prog);
			exit(2);
		}
		timbuf = timelocal(tp);
	}
#endif /*S5EMUL*/

	for (c = optind; c < argc; c++) {
		if (touch(argv[c]) < 0)
			status++;
	}
	return (status);
}

int
touch(filename)
	char *filename;
{
	struct timeval times[2];
	int fd;

	if (stat(filename, &stbuf)) {
		/*
		 * if stat failed for reasons other than ENOENT,
		 * the file should not be created, since this
		 * can clobber the contents of an existing file
		 * (for example, a large file that results in overflow).
		 */
		if (errno != ENOENT) {
			(void) fprintf(stderr,"%s: cannot stat ", prog);
			perror(filename);
			return (-1);
		} else if (cflg) {
			return (-1);
		}
		else if ((fd = creat(filename, 0666)) < 0) {
			(void) fprintf(stderr, "%s: cannot create ", prog);
			perror(filename);
			return (-1);
		}
		else {
			(void) close(fd);
			if (stat(filename, &stbuf)) {
				(void) fprintf(stderr,"%s: cannot stat ", prog);
				perror(filename);
				return (-1);
			}
		}
		if (nflg)
			return (0);
	}

	times[0] = times[1] = timbuf;
	if (mflg <= 0)
		timestruc_to_timeval(&stbuf.st_mtim, times + 1);
	if (aflg <= 0)
		timestruc_to_timeval(&stbuf.st_atim, times);

#ifndef S5EMUL
	/*
	 * Since utime() allows the owner to change file times without
	 * regard to access permission, enforce BSD semantics here
	 * (cannot touch if read-only and not -f).
	 */
	nowrite = access(filename, R_OK|W_OK);
	if (nowrite && !force) {
		(void) fprintf(stderr,
		    "%s: cannot touch %s: no write permission\n",
		    prog, filename);
		return (-1);
	}
#endif /*!S5EMUL*/

	if (utimes(filename, nflg ? NULL : times)) {
		if (nflg && (errno != EROFS) && (errno != EACCES)) {
			/*
			 * If utime() failed to set the Present, it
			 * could be a BSD server that is complaining.
			 * If that's the case, try the old read/write trick.
			 */
			return (oldtouch(filename, &stbuf));
		}
		(void) fprintf(stderr,"%s: cannot change times on ", prog);
		perror(filename);
		return (-1);
	}
	return (0);
}

int
oldtouch(filename, statp)
	char *filename;
	struct stat *statp;
{
	int rwstatus;

	if ((statp->st_mode & S_IFMT) != S_IFREG) {
		(void) fprintf(stderr,
		    "%s: %s: only owner may touch special files on this filesystem\n",
		    prog, filename);
		return (-1);
	}

#ifndef S5EMUL
	if (nowrite && force) {
		if (chmod(filename, 0666)) {
			fprintf(stderr, "%s: could not chmod ", prog);
			perror(filename);
			return (-1);
		}
		rwstatus = readwrite(filename, statp->st_size);
		if (chmod(filename, (int)statp->st_mode)) {
			fprintf(stderr, "%s: could not chmod back ", prog);
			perror(filename);
			return (-1);
		}
		return (rwstatus);
	} else
#endif /*!S5EMUL*/
		return (readwrite(filename, statp->st_size));
}

int
readwrite(filename, size)
	char	*filename;
	off_t	size;
{
	int fd;
	char first;

	if (size) {
		if ((fd = open(filename, 2)) < 0)
			goto error;
		if (read(fd, &first, 1) != 1)
			goto closeerror;
		if (lseek(fd, 0L, 0) == -1)
			goto closeerror;
		if (write(fd, &first, 1) != 1)
			goto closeerror;
	} else {
		if ((fd = creat(filename, 0666)) < 0)
			goto error;
	}
	if (close(fd) < 0)
		goto error;
	return (0);

closeerror:
	(void) close(fd);
error:
	(void) fprintf(stderr, "%s: could not touch ", prog);
	perror(filename);
	return (-1);
}

#ifdef S5EMUL
isnumber(s)
	char *s;
{
	char c;

	while (c = *s++)
		if (!isdigit(c))
			return (0);
	return (1);
}
#endif /* S5EMUL */

/*
 * nanoseconds are rounded off to microseconds by flooring.
 */
static void
timestruc_to_timeval(timestruc_t *ts, struct timeval *tv)
{
	tv->tv_sec = ts->tv_sec;
	tv->tv_usec = ts->tv_nsec / 1000;
}