OpenSolaris_b135/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;
}