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 #include "uucp.h"
26
27 static void logError();
28 extern int cuantos(), gnamef();
29
30 #define TY_ASSERT 1
31 #define TY_ERROR 2
32
33 /*
34 * produce an assert error message
35 * input:
36 * s1 - string 1
37 * s2 - string 2
38 * i1 - integer 1 (usually errno)
39 * file - __FILE of calling module
40 * line - __LINE__ of calling module
41 */
42 void
assert(char * s1,char * s2,int i1,char * file,int line)43 assert(char *s1, char *s2, int i1, char *file, int line)
44 {
45 logError(s1, s2, i1, TY_ASSERT, file, line);
46 return;
47 }
48
49
50 /*
51 * produce an assert error message
52 * input: -- same as assert
53 */
54 void
errent(char * s1,char * s2,int i1,char * file,int line)55 errent(char *s1, char *s2, int i1, char *file, int line)
56 {
57 logError(s1, s2, i1, TY_ERROR, file, line);
58 return;
59 }
60
61 #define EFORMAT "%sERROR (%.9s) pid: %ld (%s) %s %s (%d) [FILE: %s, LINE: %d]\n"
62
63 static void
logError(char * s1,char * s2,int i1,int type,char * file,int line)64 logError(char *s1, char *s2, int i1, int type, char *file, int line)
65 {
66 FILE *errlog;
67 char text[BUFSIZ];
68 pid_t pid;
69
70 if (Debug)
71 errlog = stderr;
72 else {
73 errlog = fopen(ERRLOG, "a");
74 (void) chmod(ERRLOG, PUB_FILEMODE);
75 }
76 if (errlog == NULL)
77 return;
78
79 pid = getpid();
80
81 (void) fprintf(errlog, EFORMAT, type == TY_ASSERT ? "ASSERT " : " ",
82 Progname, (long) pid, timeStamp(), s1, s2, i1, file, line);
83
84 if (!Debug)
85 (void) fclose(errlog);
86
87 (void) sprintf(text, " %sERROR %.100s %.100s (%.9s)",
88 type == TY_ASSERT ? "ASSERT " : " ",
89 s1, s2, Progname);
90 if (type == TY_ASSERT)
91 systat(Rmtname, SS_ASSERT_ERROR, text, Retrytime);
92 return;
93 }
94
95
96 /* timeStamp - create standard time string
97 * return
98 * pointer to time string
99 */
100
101 char *
timeStamp()102 timeStamp()
103 {
104 register struct tm *tp;
105 time_t clock;
106 static char str[20];
107
108 (void) time(&clock);
109 tp = localtime(&clock);
110 (void) sprintf(str, "%d/%d-%d:%2.2d:%2.2d", tp->tm_mon + 1,
111 tp->tm_mday, tp->tm_hour, tp->tm_min, tp->tm_sec);
112 return(str);
113 }
114
115
116 /*
117 * Function: countProcs - Count Process to Stay Within Limits
118 *
119 * There are a number of cases in BNU when we want to limit the number
120 * of processes of a certain type that are running at a given time. This
121 * process is used to check the number of existing processes, to determine
122 * if a new one is allowed.
123 *
124 * The strategy is that all processes of a given type will place a lock
125 * file with a specific prefix in a single directory, usually
126 * /var/spool/locks. The caller of this function must provide a full
127 * path prefix, and countProcs will count the number of files that begin
128 * with the prefix and compare the count to the allowable maximum.
129 *
130 * Parameters:
131 *
132 * prefix - A full path prefix for lock files that identify
133 * processes that are to be counted.
134 * maxCount - Maximum number of allowable processes.
135 *
136 * Returns:
137 *
138 * TRUE is returned if this process is allowed to continue, and
139 * FALSE is returned if the maximum is exceeded.
140 */
141
142 int
countProcs(prefix,maxCount)143 countProcs (prefix, maxCount)
144
145 char * prefix;
146 int maxCount;
147
148 {
149 register char * namePrefix; /* Points to file name part */
150
151 char directory[MAXNAMESIZE];
152 register int processes; /* Count of processes. */
153
154 /* Separate prefix into directory part and file name part. */
155
156 strncpy(directory, prefix, MAXNAMESIZE);
157 directory[MAXNAMESIZE-1] = NULLCHAR;
158 namePrefix = strrchr(directory, '/');
159 ASSERT(namePrefix != NULL, "No file name in", prefix, 0);
160 *namePrefix++ = NULLCHAR; /* Terminate directory part */
161
162 /* Check to see if we can continue. */
163
164 processes = cuantos(namePrefix, directory);
165 if (processes <= maxCount)
166 return TRUE;
167 else
168 return FALSE;
169 }
170
171
172 /*
173 * return the number of files in directory <dir> who's names
174 * begin with <prefix>
175 * This is used to count the number of processes of a certain
176 * type that are currently running.
177 *
178 */
179 int
cuantos(prefix,dir)180 cuantos(prefix, dir)
181 char *prefix, *dir;
182 {
183 int i = 0;
184 DIR *pdir;
185 char fullname[MAXNAMESIZE], file[MAXNAMESIZE];
186
187 pdir = opendir(dir);
188 ASSERT(pdir != NULL, Ct_OPEN, dir, errno);
189
190 while (gnamef(pdir, file) == TRUE)
191 if (PREFIX(prefix, file)) {
192 (void) sprintf(fullname, "%s/%s", dir, file);
193 if (cklock(fullname))
194 i++;
195 }
196 closedir(pdir);
197 return(i);
198 }
199