Home | History | Annotate | Download | only in bnu
      1 /*
      2  * CDDL HEADER START
      3  *
      4  * The contents of this file are subject to the terms of the
      5  * Common Development and Distribution License, Version 1.0 only
      6  * (the "License").  You may not use this file except in compliance
      7  * with the License.
      8  *
      9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
     10  * or http://www.opensolaris.org/os/licensing.
     11  * See the License for the specific language governing permissions
     12  * and limitations under the License.
     13  *
     14  * When distributing Covered Code, include this CDDL HEADER in each
     15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
     16  * If applicable, add the following below this CDDL HEADER, with the
     17  * fields enclosed by brackets "[]" replaced with your own identifying
     18  * information: Portions Copyright [yyyy] [name of copyright owner]
     19  *
     20  * CDDL HEADER END
     21  */
     22 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
     23 /*	  All Rights Reserved  	*/
     24 
     25 
     26 #ident	"%Z%%M%	%I%	%E% SMI"	/* from SVR4 bnu:utility.c 2.9 */
     27 
     28 #include "uucp.h"
     29 
     30 
     31 static void logError();
     32 extern int cuantos(), gnamef();
     33 
     34 #define TY_ASSERT	1
     35 #define TY_ERROR	2
     36 
     37 /*
     38  *	produce an assert error message
     39  * input:
     40  *	s1 - string 1
     41  *	s2 - string 2
     42  *	i1 - integer 1 (usually errno)
     43  *	file - __FILE of calling module
     44  *	line - __LINE__ of calling module
     45  */
     46 void
     47 assert(s1, s2, i1, file, line)
     48 char *s1, *s2, *file;
     49 {
     50 	logError(s1, s2, i1, TY_ASSERT, file, line);
     51 	return;
     52 }
     53 
     54 
     55 /*
     56  *	produce an assert error message
     57  * input: -- same as assert
     58  */
     59 void
     60 errent(s1, s2, i1, file, line)
     61 char *s1, *s2, *file;
     62 {
     63 	logError(s1, s2, i1, TY_ERROR, file, line);
     64 	return;
     65 }
     66 
     67 #define EFORMAT	"%sERROR (%.9s)  pid: %ld (%s) %s %s (%d) [FILE: %s, LINE: %d]\n"
     68 
     69 static void
     70 logError(s1, s2, i1, type, file, line)
     71 char *s1, *s2, *file;
     72 {
     73 	register FILE *errlog;
     74 	char text[BUFSIZ];
     75 	pid_t pid;
     76 
     77 	if (Debug)
     78 		errlog = stderr;
     79 	else {
     80 		errlog = fopen(ERRLOG, "a");
     81 		(void) chmod(ERRLOG, PUB_FILEMODE);
     82 	}
     83 	if (errlog == NULL)
     84 		return;
     85 
     86 	pid = getpid();
     87 
     88 	(void) fprintf(errlog, EFORMAT, type == TY_ASSERT ? "ASSERT " : " ",
     89 	    Progname, (long) pid, timeStamp(), s1, s2, i1, file, line);
     90 
     91 	if (!Debug)
     92 		(void) fclose(errlog);
     93 
     94 	(void) sprintf(text, " %sERROR %.100s %.100s (%.9s)",
     95 	    type == TY_ASSERT ? "ASSERT " : " ",
     96 	    s1, s2, Progname);
     97 	if (type == TY_ASSERT)
     98 	    systat(Rmtname, SS_ASSERT_ERROR, text, Retrytime);
     99 	return;
    100 }
    101 
    102 
    103 /* timeStamp - create standard time string
    104  * return
    105  *	pointer to time string
    106  */
    107 
    108 char *
    109 timeStamp()
    110 {
    111 	register struct tm *tp;
    112 	time_t clock;
    113 	static char str[20];
    114 
    115 	(void) time(&clock);
    116 	tp = localtime(&clock);
    117 	(void) sprintf(str, "%d/%d-%d:%2.2d:%2.2d", tp->tm_mon + 1,
    118 	    tp->tm_mday, tp->tm_hour, tp->tm_min, tp->tm_sec);
    119 	return(str);
    120 }
    121 
    122 
    123 /*
    124 * Function:	countProcs - Count Process to Stay Within Limits
    125 *
    126 * There are a number of cases in BNU when we want to limit the number
    127 * of processes of a certain type that are running at a given time.  This
    128 * process is used to check the number of existing processes, to determine
    129 * if a new one is allowed.
    130 *
    131 * The strategy is that all processes of a given type will place a lock
    132 * file with a specific prefix in a single directory, usually
    133 * /var/spool/locks.  The caller of this function must provide a full
    134 * path prefix, and countProcs will count the number of files that begin
    135 * with the prefix and compare the count to the allowable maximum.
    136 *
    137 * Parameters:
    138 *
    139 *	prefix -	A full path prefix for lock files that identify
    140 *			processes that are to be counted.
    141 *	maxCount -	Maximum number of allowable processes.
    142 *
    143 * Returns:
    144 *
    145 *	TRUE is returned if this process is allowed to continue, and
    146 *	FALSE is returned if the maximum is exceeded.
    147 */
    148 
    149 int
    150 countProcs (prefix, maxCount)
    151 
    152 char *	prefix;
    153 int	maxCount;
    154 
    155 {
    156 	register char *	namePrefix;		/* Points to file name part */
    157 
    158 	char		directory[MAXNAMESIZE];
    159 	register int	processes;		/* Count of processes. */
    160 
    161 	/* Separate prefix into directory part and file name part. */
    162 
    163 	strncpy(directory, prefix, MAXNAMESIZE);
    164 	directory[MAXNAMESIZE-1] = NULLCHAR;
    165 	namePrefix = strrchr(directory, '/');
    166 	ASSERT(namePrefix  != NULL, "No file name in", prefix, 0);
    167 	*namePrefix++ = NULLCHAR;		/* Terminate directory part */
    168 
    169 	/* Check to see if we can continue. */
    170 
    171 	processes = cuantos(namePrefix, directory);
    172 	if (processes <= maxCount)
    173 		return TRUE;
    174 	else
    175 		return FALSE;
    176 }
    177 
    178 
    179 /*
    180  * return the number of files in directory <dir> who's names
    181  * begin with <prefix>
    182  * This is used to count the number of processes of a certain
    183  * type that are currently running.
    184  *
    185  */
    186 int
    187 cuantos(prefix, dir)
    188 char *prefix, *dir;
    189 {
    190 	int i = 0;
    191 	DIR	*pdir;
    192 	char fullname[MAXNAMESIZE], file[MAXNAMESIZE];
    193 
    194 	pdir = opendir(dir);
    195 	ASSERT(pdir != NULL, Ct_OPEN, dir, errno);
    196 
    197 	while (gnamef(pdir, file) == TRUE)
    198 		if (PREFIX(prefix, file)) {
    199 		    (void) sprintf(fullname, "%s/%s", dir, file);
    200 		    if (cklock(fullname))
    201 			i++;
    202 		}
    203 	closedir(pdir);
    204 	return(i);
    205 }
    206