/*
 * 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 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include "lpsched.h"
#include <syslog.h>
#include <strings.h>

static char time_buf[50];
#ifdef LP_USE_PAPI_ATTR
static char *extractReqno(char *req_file);
#endif

/**
 ** chfiles() - CHANGE OWNERSHIP OF FILES, RETURN TOTAL SIZE
 **/

off_t chfiles ( char * * list, uid_t uid, gid_t gid )	/* funcdef */
{
    size_t	total;
    struct stat	stbuf;
    char	*file;
    
    total = 0;

    while(file = *list++)
    {
	if (STRNEQU(Lp_Temp, file, strlen(Lp_Temp)) ||
	    STRNEQU(Lp_Tmp, file, strlen(Lp_Tmp)))
	{
	    /*
	     * Once this routine (chfiles) is called for a request,
	     * any temporary files are ``ours'', i.e. they are on our
	     * machine. A user running on an RFS-connected remote machine
	     * can't necessarily know our machine name, so can't put
	     * the files where they belong (Lp_Tmp/machine). But now we
	     * can. Of course, this is all done with mirrors, as Lp_Temp
	     * and Lp_Tmp/local-machine are symbolicly linked. So we just
	     * change the name. This saves on wear and tear later.
	     */
	    if (STRNEQU(Lp_Temp, file, strlen(Lp_Temp)))
	    {
		char *newfile = makepath(Lp_Tmp, Local_System,
				file + strlen(Lp_Temp) + 1, NULL);

		Free(file);
		list[-1] = file = newfile;
	    }
	    
	    (void) chownmod(file, uid, gid, 0600);
	}

	if (Stat(file, &stbuf) == -1)
	    return(-1);

	switch (stbuf.st_mode & S_IFMT) {
	case 0:
	case S_IFREG:
	    break;

	case S_IFIFO:
	    if (!isadmin(uid))
		return(-1);
	    /*
	     * If any of the files is a FIFO, the size indicator
	     * becomes meaningless. On the other hand, returning
	     * a total of zero causes the request to be rejected,
	     * so we return something > 0.
	     */
	    stbuf.st_size = 1;
	    break;

	case S_IFDIR:
	case S_IFCHR:
	case S_IFBLK:
	default:
	    return(-1);
	}

	total += stbuf.st_size;
    }
    return(total);
}

/**
 ** rmfiles() - DELETE/LOG FILES FOR DEFUNCT REQUEST
 **/

void rmfiles ( RSTATUS * rp, int log_it )	/* funcdef */
{
    char	**file	= rp->request->file_list;
    char	*path;
    char	num[STRSIZE(MOST_FILES) + 1];
    static int	fd	= -1;
    int		reqfd;
    int		count	= 0;
#ifdef LP_USE_PAPI_ATTR
    struct stat	tmpBuf;
    char	*idno = NULL;
    char 	tmpName[BUFSIZ];
#endif


    if (rp->req_file) {
	    char *p, *q;

	   /*
	    * The secure request file is removed first to prevent
	    * reloading should the system crash while in rmfiles().
	    */
	    path = makepath(Lp_Requests, rp->req_file, (char *)0);
	    (void) Unlink(path);
	    Free(path);

	    /*
	     * Copy the request file to the log file, if asked,
	     * or simply remove it.
	     */
	    path = makepath(Lp_Tmp, rp->req_file, (char *)0);
	    if (log_it && rp->secure && rp->secure->req_id) {
		if (fd == -1)
		    fd = open_locked(Lp_ReqLog, "a", MODE_NOREAD);
		if ((fd  >= 0) && (reqfd = Open(path, O_RDONLY, 0)) != -1) {
		    register int	n;
		    char		buf[BUFSIZ];

		    (void) strftime(time_buf, sizeof (time_buf),
			NULL, localtime(&(rp->secure->date)));
		    fdprintf(fd, "= %s, uid %u, gid %u, size %ld, %s\n",
			rp->secure->req_id, rp->secure->uid, rp->secure->gid,
			rp->secure->size, time_buf);
		    if (rp->slow)
			fdprintf(fd, "x %s\n", rp->slow);
		    if (rp->fast)
			fdprintf(fd, "y %s\n", rp->fast);
		    if (rp->printer && rp->printer->printer)
			fdprintf(fd, "z %s\n", rp->printer->printer->name);
		    while ((n = Read(reqfd, buf, BUFSIZ)) > 0)
			write (fd, buf, n);
		    Close (reqfd);
		}
	    }
	    (void)Unlink (path);		/* remove request file */
	    Free (path);

	    p = strdup(rp->req_file);		/* remove host/id file */
	    if (q = strrchr(p, '-')) {
		    *q = NULL;
		    path = makepath(Lp_Tmp, p, NULL);
		    (void) Unlink(path);
		    Free(path);
	    }
	    Free(p);

#ifdef LP_USE_PAPI_ATTR
	/* Look for a PAPI job attribute file, if it exists remove it */
	idno = extractReqno(rp->req_file);
	snprintf(tmpName, sizeof (tmpName), "%s-%s", idno, LP_PAPIATTRNAME);
	path = makepath(Lp_Temp, tmpName, (char *)0);

	if (((path != NULL) && (idno != NULL)) && (stat(path, &tmpBuf) == 0))
	{
	    /* PAPI job attribute file exists for this job so remove it */
	    (void) Unlink(path);
	}

	Free(idno);
	Free(path);
#endif
    }

    if (file)					/* remove file in filelist */
	while(*file)
	{
		/*
		 * The copies of user files.
		 */
		if ((STRNEQU(Lp_Temp, *file, strlen(Lp_Temp)) ||
		    STRNEQU(Lp_Tmp, *file, strlen(Lp_Tmp))) &&
		    (! strstr(*file, "../")))

		    (void) Unlink(*file);

		count++;
		file++;
	}

    if (rp->secure && rp->secure->req_id) {
	char *p;
	p = getreqno(rp->secure->req_id);

	/*
	 * The filtered files. We can't rely on just the RS_FILTERED
	 * flag, since the request may have been cancelled while
	 * filtering. On the other hand, just checking "rp->slow"
	 * doesn't mean that the files exist, because the request
	 * may have been canceled BEFORE filtering started. Oh well.
	 */
	if (rp->slow)
	    while(count > 0)
	    {
		sprintf(num, "%d", count--);
		path = makestr(Lp_Temp, "/F", p, "-", num, (char *)0);
		Unlink(path);
		Free(path);
	    }

	/*
	 * The notify/error file.
	 */
	path = makepath(Lp_Temp, p, (char *)0);
	(void) Unlink(path);
	Free(path);
    }
}

/**
 ** _alloc_req_id(void) - ALLOCATE NEXT REQUEST ID
 **/

#define	SEQF_DEF_START	1
#define	SEQF_DEF_END	59999
#define	SEQF_DEF_INCR	1
#define	SEQF		".SEQF"


long
_alloc_req_id ( void )
{
	static short		started	= 0;

	static int		fd;

	static long		start;
	static long		end;
	static long		incr;
	static long		curr;
	static long		wrap;

	static char		fmt[
				STRSIZE(BIGGEST_REQID_S)/* start   */
			      + 1			/* :       */
			      + STRSIZE(BIGGEST_REQID_S)/* end     */
			      + 1			/* :       */
			      + STRSIZE(BIGGEST_REQID_S)/* incr    */
			      + 1			/* :       */
			      + 4			/* %ld\n   */
			      + 1			/* (nul)   */
				];

	char 			buf[256];
	int len;

	long			ret;


	if (!started) {
		snprintf(buf, sizeof (buf), "%s/%s", Lp_Temp, SEQF);
		if (((fd = open_locked(buf, "r+", 0644)) < 0) &&
		    ((fd = open_locked(buf, "w", 0644)) < 0))
			fail ("Can't open file %s (%s).\n", buf, PERROR);

		lseek(fd, 0, SEEK_SET);

		read(fd, buf, sizeof (buf));
		if (sscanf(buf, "%ld:%ld:%ld:%ld\n", &start, &end, &incr, &curr) != 4) {
			start = SEQF_DEF_START;
			end = SEQF_DEF_END;
			curr = start;
			incr = SEQF_DEF_INCR;
		}

		if (start < 0)
			start = SEQF_DEF_START;
		if (end > SEQF_DEF_END)
			end = SEQF_DEF_END;
		if (curr < start || curr > end)
			curr = start;

		sprintf (fmt, "%ld:%ld:%ld:%%ld\n", start, end, incr);
		started = 1;
	}

	wrap = curr;
	do {	
		ret = curr;
		if ((curr += incr) > end)
	    	curr = start;

	} while ( wrap != curr && ((RSTATUS *)request_by_id_num(ret)) ) ; 

	/* write the new id file */
	lseek(fd, 0, SEEK_SET);
	len = sprintf(buf, fmt, curr);
	write(fd, buf, len);
	ftruncate(fd, len);

	if (curr == wrap) {
		note("alloc_req_id(): out of ids\n");
		errno = EEXIST;
		return(SEQF_DEF_START-1);
	} else
		return (ret);
}

/**
 ** _alloc_file() - ALLOCATE FILES FOR A REQUEST
 **/

char *
_alloc_files (
	int			num,
	char *			prefix,
	uid_t			uid,
	gid_t			gid
)
{
	static char		base[
				1			/* F       */
			      + STRSIZE(BIGGEST_REQID_S)/* req-id  */
			      + 1			/* -       */
			      + STRSIZE(MOST_FILES_S)	/* file-no */
			      + 1			/* (nul)   */
				];

	char *			file;
	char *			cp;

	int			fd;
	int			plus;


	if (num > BIGGEST_REQID)
		return (0);

	if (!prefix) {
		int id;

		if ((id = _alloc_req_id()) < SEQF_DEF_START )
			return(NULL); /* Out of request IDs (errno = EEXIST) */
		snprintf (base, sizeof (base), "%d-%d", id, MOST_FILES);
		plus = 0;
	} else {
		if (strlen(prefix) > (size_t) 6)
			return (0);
		snprintf (base, sizeof (base), "F%s-%d", prefix, MOST_FILES);
		plus = 1;
	}

	file = makepath(Lp_Temp, base, (char *)0);
        
	cp = strrchr(file, '-') + 1;
	while (num--) {
		sprintf (cp, "%d", num + plus);
		if ((fd = Open(file, O_CREAT|O_TRUNC, 0600)) == -1) {
			Free (file);
			return (0);
		} else {
			Close (fd);
			(void) chownmod(file, uid, gid, 0600);
		}
	}

#ifdef LP_USE_PAPI_ATTR
	if (prefix == NULL)
	{
		/*
		 * Initial job request (s_alloc_files) so create an empty PAPI
		 * Attribute file; note, this file will only be used if the
		 * print job has been submitted via the PAPI interface.
		 */

		file = (char *)Realloc(file, strlen(file) +
					strlen(LP_PAPIATTRNAME) + 1);
		if (file != NULL)
		{
			cp = strrchr(file, '-') + 1;
			sprintf(cp, "%s", LP_PAPIATTRNAME);

			if ((fd = Open(file, O_CREAT|O_TRUNC, 0600)) == -1)
			{
				Free(file);
				return (0);
			}
			else
			{
				Close(fd);
				(void) chownmod(file, uid, gid, 0600);
			}

			Free(file);
		}
	}
#endif


	if ((cp = strrchr(base, '-')))
		*cp = 0;

	return (base);
}


#ifdef LP_USE_PAPI_ATTR
static char *extractReqno(char *req_file)

{
	char *start = NULL;
	char *end = NULL;
	char *result = NULL;

	start = strrchr(req_file, '/');
	end = strrchr(req_file, '-');

	if ((start != NULL) && (end != NULL))
	{
		start++;
		if (end > start)
		{
			int n = end - start;
			result = (char *)Malloc(n+1);
			strncpy(result, start, n);
			result[n] = '\0';
		}
	}

	return (result);
} /* extractReqno() */
#endif