7600 zfs rollback should pass target snapshot to kernel

[unleashed.git] / usr / src / cmd / bnu / grades.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 (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*        All Rights Reserved   */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include "uucp.h"
#include <grp.h>

#define G_EXT   0
#define G_INT   1
#define G_RES   2
#define G_ACT   3
#define G_IDF   4
#define G_MAX   512     /* max number of fields in the Grades file line */
#define SMBUF   128

#define TYPE    0
#define FILE1   1
#define FILE2   2
#define USER    3
#define OPTS    4
#define FILE3   5

extern int rdfulline(), jsize(), gdirf(), gnamef();
extern void wfcommit();

static void     mailAdmin();            /* Send mail to administrator. */

/*
 * chkgrp - checks to see the group has permission
 *              to use a service grade queue.
 *
 * returns
 *
 *      SUCCESS - if the group has permissions
 *      FAIL - if group does not
 *
 */

static int
chkgrp(carray,na)
char **carray;
int na;
{
        struct group *grp;
        int i;
        gid_t gid;

        gid = getgid();
        grp = getgrgid(gid);

        for (i = G_IDF; i < na; i++)
                        if (EQUALS(carray[i], grp->gr_name))
                                return(SUCCESS);

        return(FAIL);
}

/*
 * chkusr - checks the permission fields of the Grades file
 *          to determine if the user can queue to a particular service grade.
 *
 * returns
 *
 *      SUCCESS - if the user can queue to the service grade.
 *      FAIL - if the user can not queue to this service grade.
 *
 */

static int
chkusr(carray, na)
char **carray;
int na;
{
        int i;

        /*
         * start at the point where the users are supposed to be in the
         * Grades file. Loop thru until the end of the user list is
         * found or the user name is found. If the user name is found then
         * return TRUE. If the end of the list is found, return FAIL.
         */

        DEBUG(9, "User (%s)\n", User);

        /* check for any user and return if so */

        if (EQUALS(carray[G_IDF], "Any"))
                return(SUCCESS);

        DEBUG(9, "Members of administrator defined service grade (%s)\n", carray[G_EXT]);

        for (i = G_IDF; i < na; i++) {
                DEBUG(9, "%s\n", carray[i]);
                if (EQUALS(User, carray[i]))
                        return(SUCCESS);
        }

        return(FAIL);
}

/*
 *      fgrade - finds the appropiate queue to queue a job into
 *
 *      returns
 *              SUCCESS -> found a queue
 *              FAIL    -> can't find a queue
 */

int
fgrade(scfile)
struct cs_struct *scfile;
{
        char fdgrade();
        FILE *cfd;
        char line[BUFSIZ];
        char *carray[G_MAX];
        long climit;

        /* Check for the default service grade first */

        if (strcmp(scfile->sgrade, "default") == 0) {
                scfile->grade = fdgrade();
                return(SUCCESS);
        }

        /* open grades file to begin a linear for the grade requested */

        cfd = fopen(GRADES, "r");

        /* loop until the file is empty or we find the grade we want */

        while (rdfulline(cfd, line, BUFSIZ) != 0) {
                (void) getargs(line, carray, G_MAX);

                /* check to see if this is the grade we want */

                if (!EQUALS(scfile->sgrade, carray[G_EXT]))
                        continue;

                if (jsize(scfile, carray[G_RES], &climit) != FAIL) {
                        (void) fclose(cfd);
                        scfile->grade = *carray[G_INT];
                        return(SUCCESS);
                }
        }

        (void) fclose(cfd);

        (void) fprintf(stderr, gettext("Job size (%ld bytes)"
            " exceeds maximum number of bytes (%ld bytes)"
            " allowed into this service grade (%s).\n"
            "Job queued to default grade.\n"),
            scfile->jsize, climit, scfile->sgrade);

        scfile->grade = fdgrade();
        return(SUCCESS);
}

/*
 *      fdgrade - finds the default queue for this system
 *
 *      returns
 *              a one char name for the default queue
 *
 */

char
fdgrade()
{
        FILE *cfd;
        char line[BUFSIZ];
        char *carray[G_MAX];

        /* Check for the default grade first */

                cfd = fopen(GRADES, "r");

                /* loop until the end of the file is read */

                for (; rdfulline(cfd, line, BUFSIZ) != 0;) {

                        /* parse the fields of this line */

                        (void) getargs(line, carray, G_MAX);

                        /* check to see if the administrator has defined
                         * a default grade for the machine.
                         */

                        if (strcmp(carray[G_EXT], "default") != 0)
                                continue;

                        /* default must be defined in the file
                         *  close the file, get the queue name, and return.
                         */

                        (void) fclose(cfd);
                        return(*carray[G_INT]);
                }

                /* no default defined in this file. close file.
                 * get our default queue and return.
                 */

                (void) fclose(cfd);
                return(D_QUEUE);
}

/*
 * job_size - determines the size of a job
 *
 * returns
 *
 *      SUCCESS - if the size of the job can be determined
 *      FAIL    - otherwise
 */

int
job_size(scfile)
struct cs_struct *scfile;
{
        extern int Dfileused;
        struct stat s;
        FILE *fp;
        char line[BUFSIZ];
        char *carray[G_MAX];
        int na;
        int nodfile = FALSE;
        int ret;

        scfile->jsize = 0;

        fp = fopen(scfile->file, "r");

        if (fp == NULL) {
                toCorrupt(scfile->file);
                errent(Ct_OPEN, scfile->file, errno, __FILE__,  __LINE__);
        }

        while (fgets(line, BUFSIZ, fp) != NULL) {
                na = getargs(line, carray, G_MAX);

                if (na < 6) {
                        (void) fclose(fp);
                        toCorrupt(scfile->file);
                        errent("BAD NUMBER OF ARGUMENTS", scfile->file, 0,
                                __FILE__, __LINE__);
                }

                /* if the type of a transfer is not a push
                 * then don't try to determine the size of
                 * the data file, because you can't.
                 */

                if (*carray[TYPE] == 'R')
                        continue;

                /* find the data dile that is to be transferred */

                if ((ret = stat(carray[FILE3], &s)) != 0) {
                        if (errno == ENOENT) {
                                nodfile = TRUE;
                                ret = stat(carray[FILE1], &s);
                        }
                }
                else
                        Dfileused = TRUE;

                /*
                 * check to see if the return code from stat was 0
                 * if return code was not 0, write message to error
                 * log and quit. Otherwise, add size of file to job
                 * size and continue looping.
                 */

                if (ret != 0) {
                        (void) fclose(fp);
                        errent(Ct_STAT, nodfile ?
                                carray[FILE1] : carray[FILE3], errno,
                                __FILE__, __LINE__);
                }

                nodfile = FALSE;
                scfile->jsize += s.st_size;
        }
        (void) fclose(fp);
        return(SUCCESS);
}

static void lcase();

/*
 * jsize - determines whether if a job is small enough to
 *         be placed in the appropiate queue.
 *
 * returns
 *
 *      SUCCESS - if the size of the job is less than or
 *                equal to the number of bytes in the restriction
 *                of the GRADES file.
 *
 *      FAIL    - otherwise
 */

int
jsize(scfile, climit, nlimit)
struct cs_struct *scfile;
char *climit;
long *nlimit;
{
#define ONE_K (1024)
#define ONE_MEG ((1024)*(1024))

        char rest[SMBUF];
        char msg[BUFSIZ], *p;

        if (EQUALS(climit, "Any"))
                return(SUCCESS);

        lcase(climit, rest, SMBUF);

        if (!(p = strchr(rest, 'k')) && (!(p = strchr(rest, 'm')))) {

                for(p = climit; *p; ++p) {
                        if (isdigit(*p))
                                continue;

                        /* corrupt restriction field in the Grades file.
                         * report it to the uucp administrator.
                         */

                        snprintf(msg, sizeof (msg),
                            gettext("Error encountered in the"
                            " restrictions field of the Grades file."
                            "  Field contents (%s)."), climit);
                        mailAdmin(msg);
                        return(SUCCESS);
                }

                *nlimit = atol(climit);
        }
        else if (*p == 'k') {
                *p = '\0';
                *nlimit = (long) (atof(rest) * ONE_K);
        }
        else {
                *p = '\0';
                *nlimit = (long) (atof(rest) * ONE_MEG);
        }

        if (scfile->jsize <= *nlimit)
                return(SUCCESS);
        else
                return(FAIL);
}

static void
lcase(s, t, lim)
char s[], t[];
int lim;
{
        char *p;
        int i;


        p = s;

        for (i = 0; i < lim-1 && *p; i++)
                if (isupper(*p))
                        t[i] = tolower(*p++);
                else
                        t[i] = *p++;

        t[i] = '\0';
        return;
}

/*
 * mailAdmin - mail a message to the uucp administrator.
 *
 * returns:
 *
 *      nothing
 */

static void
mailAdmin (msg)

char *  msg;

{
        char    cmd[BUFSIZ];            /* Place to build mail command. */
        FILE *  mail;                   /* Channel to write mail on. */

        (void) sprintf(cmd, "%s %s %s", PATH, MAIL, "uucp");
        if ((mail = popen(cmd, "w")) != (FILE *) NULL)
        {
                (void) fprintf(mail, "To: uucp\nSubject: %s\n\n%s\n",
                    gettext("Grades file problem"), msg);
                (void) pclose(mail);
        }

        /*
         * Ignore popen failure.  There is not much that we can do if
         * it fails, since we are already trying to notify the administrator
         * of a problem.
         */
        return;
}

/*
 * putdfiles - moves any and all of the D. to the spool directory for
 *             a C. file.
 *
 * returns
 *
 *      nothing
 */

void
putdfiles(scfile)
struct cs_struct scfile;
{
        FILE *fp;
        char line[BUFSIZ];
        char *carray[G_MAX];
        int na;
        struct stat s;

        fp = fopen(scfile.file, "r");

        if (fp == NULL) {
                toCorrupt(scfile.file);
                errent(Ct_OPEN, scfile.file, errno, __FILE__, __LINE__);
        }

        while (fgets(line, BUFSIZ, fp) != NULL) {

                na = getargs(line, carray, G_MAX);
                if (na < 6) {
                        (void) fclose(fp);
                        toCorrupt(scfile.file);
                        errent("BAD NUMBER OF ARGUMENTS", scfile.file, 0,
                                __FILE__, __LINE__);
                }

                if (*carray[TYPE] == 'R')
                        continue;

                /* move D. file to the spool area */

                if (stat(carray[FILE3], &s) != -1)
                        wfcommit(carray[FILE3], carray[FILE3], scfile.sys);
        }

        (void) fclose(fp);
        return;
}

/*
 * reads a line from a file and takes care of comment lines
 * and continuations (\) in last column.
 *
 * return:
 *      the number of chars that are placed in line.
 */

int
rdfulline(fd, line, lim)
FILE *fd;
char *line;
int lim;
{
        register char *p, *c;
        char buf[BUFSIZ];
        size_t blr, btox;

        p = line;
        for (;fgets(buf, BUFSIZ, fd) != NULL;) {
                /* check to see if it is a comment */

                if (buf[0] == '#')
                        continue;

                /* remove trailing white space */
                c = &buf[strlen(buf)-1];
                while (c>=buf && (*c == '\n' || *c == '\t' || *c == ' ') )
                        *c-- = NULLCHAR;

                if (buf[0] == '\n' || buf[0] == NULLCHAR)
                        continue;

                blr = lim - 1 - (p - line);
                btox = blr < strlen(buf) ? blr : strlen(buf);

                if (btox <= 0)
                        break;

                (void) strncpy(p, buf, btox);
                p += btox - 1;

                if ( *(p-1) == '\\')
                        p--;
                else
                        break;
        }

        *++p = '\0';
        return(p-line-1);
}

/*      upermit - checks to determine if the user has permissions
 *      to use administrator defined service grade.
 *
 *      returns
 *              SUCCESS -> if the user can queue to this service grade.
 *              FAIL -> if the user cannot queue to this service grade.
 */

int
upermit(carray, na)
char **carray;
int na;
{
#define G_USR "user"
#define G_NUSR "non-user"
#define G_GRP "group"
#define G_NGRP "non-group"

        char actn[SMBUF];
        char ufld[SMBUF];
        char msg[BUFSIZ];

        (void) strcpy(actn, carray[G_ACT]);

        lcase(actn, ufld, SMBUF);

        if (EQUALS(ufld, G_USR))
                return(chkusr(carray,na));

        if (EQUALS(ufld, G_NUSR))
                return((chkusr(carray, na) != SUCCESS) ? SUCCESS : FAIL);

        if (EQUALS(ufld, G_GRP))
                return(chkgrp(carray, na));

        if (EQUALS(ufld, G_NGRP))
                return((chkgrp(carray, na) != SUCCESS) ? SUCCESS : FAIL);

        (void) snprintf(msg, sizeof (msg),
            gettext("Error encountered in action field of"
            " the Grades file. Field contents (%s)."), carray[G_ACT]);
        mailAdmin(msg);
        return(FAIL);
}

/*
 *      vergrd - verify if the grade name is a valid administrator
 *               defined service grade name and if the user has the
 *               appropiate permission to use this grade.
 *
 *      returns
 *              SUCCESS -> grade is valid and user is
 *                         permitted to use this grade.
 *              FAIL    -> otherwise
 *
 */

int
vergrd(grade)
char *grade;
{
        FILE *cfd;
        char line[BUFSIZ];
        char *carray[G_MAX];
        int na;

        /* Check for the default grade first */

        if (EQUALS(grade, "default"))
                return(SUCCESS);

        /* open grades file to begin a linear for the grade requested */

        cfd = fopen(GRADES, "r");

        /* loop until the file is empty or we find the grade we want */

        while (rdfulline(cfd, line, BUFSIZ) != 0) {
                na = getargs(line, carray, G_MAX);

                /* check to see if this is the grade we want */

                if (!EQUALS(grade, carray[G_EXT]))
                        continue;

                /* check for the permission on this grade */

                if (upermit(carray, na) != FAIL) {
                        (void) fclose(cfd);
                        return(SUCCESS);
                }
                else {
                        (void) fclose(cfd);
                        (void) fprintf(stderr, gettext("User does not have"
                            " permission to use this service grade (%s).\n"
                            "Job has not been queued.\n"
                            "Use (uuglist) to find which service grades"
                            " you can queue to.\n"), grade);
                        return(FAIL);
                }
        }

        (void) fclose(cfd);

        (void) fprintf(stderr, gettext(
            "Service grade (%s) does not exist on this machine."
            "  Job not queued.\n"
            "Use (uuglist) to find which service grades are available on"
            " this machine.\n"), grade);
        return(FAIL);
}

/*
 * wfremove - removes a C. file from the Workspace directory and all of its
 * D. files.
 */

void
wfremove(file)
char *file;
{
        FILE *fp;
        char line[BUFSIZ];
        char *carray[G_MAX];
        int na;
        struct stat s;

        fp = fopen(file, "r");

        if (fp == NULL) {
                toCorrupt(file);
                errent(Ct_OPEN, file, errno, __FILE__, __LINE__);
        }

        while (fgets(line, BUFSIZ, fp) != NULL) {
                na = getargs(line, carray, G_MAX);

                if (na < 6) {
                        (void) fclose(fp);
                        toCorrupt(file);
                        errent("BAD NUMBER OF ARGUMENTS", file, 0,
                                __FILE__, __LINE__);
                }

                if (*carray[TYPE] == 'R')
                        continue;

                /* remove D. file */

                DEBUG(4, "Removing data file (%s)\n", carray[FILE3]);

                if ((stat(carray[FILE3], &s) != -1) && (unlink(carray[FILE3]) != 0)) {
                        (void) fclose(fp);
                        toCorrupt(file);
                        toCorrupt(carray[FILE3]);
                        errent(Ct_UNLINK, carray[FILE3], errno, __FILE__,
                                __LINE__);
                }
        }

        (void) fclose(fp);

        DEBUG(4, "Removing work file (%s)\n", file);

        if (unlink(file) != 0) {
                toCorrupt(file);
                errent(Ct_UNLINK, file, errno, __FILE__, __LINE__);
        }
        return;
}

/*
 * findgrade - finds the highest priority job grade that is not locked
 * and that has jobs.
 *
 * job grade name is null, if no job grade is found.
 */

void
findgrade(dir, jobgrade)
char *dir, *jobgrade;
{
        char prevgrade[MAXBASENAME+1], curgrade[MAXBASENAME+1],
             gradedir[MAXBASENAME+1];
        char lockname[MAXFULLNAME];
        char Cfile[MAXBASENAME+1];
        DIR *p, *q;

        *prevgrade = NULLCHAR;
        p = opendir(dir);
        ASSERT(p != NULL, Ct_OPEN, dir, errno);

        while (gdirf(p, gradedir, dir) == TRUE) {
                (void) sprintf(lockname, "%s.%.*s.%s", LOCKPRE, SYSNSIZE,
                    Rmtname, gradedir);
                if (cklock(lockname) == FAIL)
                        continue;
                q = opendir(gradedir);
                ASSERT(q != NULL, Ct_OPEN, gradedir, errno);
                while (gnamef(q, Cfile) == TRUE) {
                        if (Cfile[0] == CMDPRE) {
                                if (*prevgrade == NULLCHAR) {
                                        (void) strcpy(prevgrade, gradedir);
                                        break;
                                }
                                (void) strcpy(curgrade, gradedir);
                                if (strcmp(curgrade, prevgrade) < 0)
                                        (void) strcpy(prevgrade, curgrade);
                        }
                }
                closedir(q);
        }
        closedir(p);
        (void) strncpy(jobgrade, prevgrade, MAXBASENAME);
        jobgrade[MAXBASENAME] = NULLCHAR;
        return;
}