21#endif
22
23/* vix 26jan87 [RCS has the rest of the log]
24 * vix 30dec86 [written]
25 */
26
27
28#include "cron.h"
29#if SYS_TIME_H
30# include <sys/time.h>
31#else
32# include <time.h>
33#endif
34#include <sys/file.h>
35#include <sys/stat.h>
36#include <err.h>
37#include <errno.h>
38#include <string.h>
39#include <fcntl.h>
40#if defined(SYSLOG)
41# include <syslog.h>
42#endif
43
44
45#if defined(LOG_DAEMON) && !defined(LOG_CRON)
46#define LOG_CRON LOG_DAEMON
47#endif
48
49
50static int LogFD = ERR;
51
52
53int
54strcmp_until(left, right, until)
55 char *left;
56 char *right;
57 int until;
58{
59 register int diff;
60
61 while (*left && *left != until && *left == *right) {
62 left++;
63 right++;
64 }
65
66 if ((*left=='\0' || *left == until) &&
67 (*right=='\0' || *right == until)) {
68 diff = 0;
69 } else {
70 diff = *left - *right;
71 }
72
73 return diff;
74}
75
76
77/* strdtb(s) - delete trailing blanks in string 's' and return new length
78 */
79int
80strdtb(s)
81 char *s;
82{
83 char *x = s;
84
85 /* scan forward to the null
86 */
87 while (*x)
88 x++;
89
90 /* scan backward to either the first character before the string,
91 * or the last non-blank in the string, whichever comes first.
92 */
93 do {x--;}
94 while (x >= s && isspace(*x));
95
96 /* one character beyond where we stopped above is where the null
97 * goes.
98 */
99 *++x = '\0';
100
101 /* the difference between the position of the null character and
102 * the position of the first character of the string is the length.
103 */
104 return x - s;
105}
106
107
108int
109set_debug_flags(flags)
110 char *flags;
111{
112 /* debug flags are of the form flag[,flag ...]
113 *
114 * if an error occurs, print a message to stdout and return FALSE.
115 * otherwise return TRUE after setting ERROR_FLAGS.
116 */
117
118#if !DEBUGGING
119
120 printf("this program was compiled without debugging enabled\n");
121 return FALSE;
122
123#else /* DEBUGGING */
124
125 char *pc = flags;
126
127 DebugFlags = 0;
128
129 while (*pc) {
130 char **test;
131 int mask;
132
133 /* try to find debug flag name in our list.
134 */
135 for ( test = DebugFlagNames, mask = 1;
136 *test && strcmp_until(*test, pc, ',');
137 test++, mask <<= 1
138 )
139 ;
140
141 if (!*test) {
142 fprintf(stderr,
143 "unrecognized debug flag <%s> <%s>\n",
144 flags, pc);
145 return FALSE;
146 }
147
148 DebugFlags |= mask;
149
150 /* skip to the next flag
151 */
152 while (*pc && *pc != ',')
153 pc++;
154 if (*pc == ',')
155 pc++;
156 }
157
158 if (DebugFlags) {
159 int flag;
160
161 fprintf(stderr, "debug flags enabled:");
162
163 for (flag = 0; DebugFlagNames[flag]; flag++)
164 if (DebugFlags & (1 << flag))
165 fprintf(stderr, " %s", DebugFlagNames[flag]);
166 fprintf(stderr, "\n");
167 }
168
169 return TRUE;
170
171#endif /* DEBUGGING */
172}
173
174
175void
176set_cron_uid()
177{
178#if defined(BSD) || defined(POSIX)
179 if (seteuid(ROOT_UID) < OK)
180 err(ERROR_EXIT, "seteuid");
181#else
182 if (setuid(ROOT_UID) < OK)
183 err(ERROR_EXIT, "setuid");
184#endif
185}
186
187
188void
189set_cron_cwd()
190{
191 struct stat sb;
192
193 /* first check for CRONDIR ("/var/cron" or some such)
194 */
195 if (stat(CRONDIR, &sb) < OK && errno == ENOENT) {
196 warn("%s", CRONDIR);
197 if (OK == mkdir(CRONDIR, 0700)) {
198 warnx("%s: created", CRONDIR);
199 stat(CRONDIR, &sb);
200 } else {
201 err(ERROR_EXIT, "%s: mkdir", CRONDIR);
202 }
203 }
204 if (!(sb.st_mode & S_IFDIR))
205 err(ERROR_EXIT, "'%s' is not a directory, bailing out", CRONDIR);
206 if (chdir(CRONDIR) < OK)
207 err(ERROR_EXIT, "cannot chdir(%s), bailing out", CRONDIR);
208
209 /* CRONDIR okay (now==CWD), now look at SPOOL_DIR ("tabs" or some such)
210 */
211 if (stat(SPOOL_DIR, &sb) < OK && errno == ENOENT) {
212 warn("%s", SPOOL_DIR);
213 if (OK == mkdir(SPOOL_DIR, 0700)) {
214 warnx("%s: created", SPOOL_DIR);
215 stat(SPOOL_DIR, &sb);
216 } else {
217 err(ERROR_EXIT, "%s: mkdir", SPOOL_DIR);
218 }
219 }
220 if (!(sb.st_mode & S_IFDIR))
221 err(ERROR_EXIT, "'%s' is not a directory, bailing out", SPOOL_DIR);
222}
223
224
225/* acquire_daemonlock() - write our PID into /etc/cron.pid, unless
226 * another daemon is already running, which we detect here.
227 *
228 * note: main() calls us twice; once before forking, once after.
229 * we maintain static storage of the file pointer so that we
230 * can rewrite our PID into the PIDFILE after the fork.
231 *
232 * it would be great if fflush() disassociated the file buffer.
233 */
234void
235acquire_daemonlock(closeflag)
236 int closeflag;
237{
238 static FILE *fp = NULL;
239
240 if (closeflag && fp) {
241 fclose(fp);
242 fp = NULL;
243 return;
244 }
245
246 if (!fp) {
247 char pidfile[MAX_FNAME];
248 char buf[MAX_TEMPSTR];
249 int fd, otherpid;
250
251 (void) sprintf(pidfile, PIDFILE, PIDDIR);
252 if ((-1 == (fd = open(pidfile, O_RDWR|O_CREAT, 0644)))
253 || (NULL == (fp = fdopen(fd, "r+")))
254 ) {
255 sprintf(buf, "can't open or create %s: %s",
256 pidfile, strerror(errno));
257 log_it("CRON", getpid(), "DEATH", buf);
258 errx(ERROR_EXIT, "%s", buf);
259 }
260
261 if (flock(fd, LOCK_EX|LOCK_NB) < OK) {
262 int save_errno = errno;
263
264 fscanf(fp, "%d", &otherpid);
265 sprintf(buf, "can't lock %s, otherpid may be %d: %s",
266 pidfile, otherpid, strerror(save_errno));
267 log_it("CRON", getpid(), "DEATH", buf);
268 errx(ERROR_EXIT, "%s", buf);
269 }
270
271 (void) fcntl(fd, F_SETFD, 1);
272 }
273
274 rewind(fp);
275 fprintf(fp, "%d\n", getpid());
276 fflush(fp);
277 (void) ftruncate(fileno(fp), ftell(fp));
278
279 /* abandon fd and fp even though the file is open. we need to
280 * keep it open and locked, but we don't need the handles elsewhere.
281 */
282}
283
284/* get_char(file) : like getc() but increment LineNumber on newlines
285 */
286int
287get_char(file)
288 FILE *file;
289{
290 int ch;
291
292 ch = getc(file);
293 if (ch == '\n')
294 Set_LineNum(LineNumber + 1)
295 return ch;
296}
297
298
299/* unget_char(ch, file) : like ungetc but do LineNumber processing
300 */
301void
302unget_char(ch, file)
303 int ch;
304 FILE *file;
305{
306 ungetc(ch, file);
307 if (ch == '\n')
308 Set_LineNum(LineNumber - 1)
309}
310
311
312/* get_string(str, max, file, termstr) : like fgets() but
313 * (1) has terminator string which should include \n
314 * (2) will always leave room for the null
315 * (3) uses get_char() so LineNumber will be accurate
316 * (4) returns EOF or terminating character, whichever
317 */
318int
319get_string(string, size, file, terms)
320 char *string;
321 int size;
322 FILE *file;
323 char *terms;
324{
325 int ch;
326
327 while (EOF != (ch = get_char(file)) && !strchr(terms, ch)) {
328 if (size > 1) {
329 *string++ = (char) ch;
330 size--;
331 }
332 }
333
334 if (size > 0)
335 *string = '\0';
336
337 return ch;
338}
339
340
341/* skip_comments(file) : read past comment (if any)
342 */
343void
344skip_comments(file)
345 FILE *file;
346{
347 int ch;
348
349 while (EOF != (ch = get_char(file))) {
350 /* ch is now the first character of a line.
351 */
352
353 while (ch == ' ' || ch == '\t')
354 ch = get_char(file);
355
356 if (ch == EOF)
357 break;
358
359 /* ch is now the first non-blank character of a line.
360 */
361
362 if (ch != '\n' && ch != '#')
363 break;
364
365 /* ch must be a newline or comment as first non-blank
366 * character on a line.
367 */
368
369 while (ch != '\n' && ch != EOF)
370 ch = get_char(file);
371
372 /* ch is now the newline of a line which we're going to
373 * ignore.
374 */
375 }
376 if (ch != EOF)
377 unget_char(ch, file);
378}
379
380
381/* int in_file(char *string, FILE *file)
382 * return TRUE if one of the lines in file matches string exactly,
383 * FALSE otherwise.
384 */
385static int
386in_file(string, file)
387 char *string;
388 FILE *file;
389{
390 char line[MAX_TEMPSTR];
391
392 rewind(file);
393 while (fgets(line, MAX_TEMPSTR, file)) {
394 if (line[0] != '\0')
395 line[strlen(line)-1] = '\0';
396 if (0 == strcmp(line, string))
397 return TRUE;
398 }
399 return FALSE;
400}
401
402
403/* int allowed(char *username)
404 * returns TRUE if (ALLOW_FILE exists and user is listed)
405 * or (DENY_FILE exists and user is NOT listed)
406 * or (neither file exists but user=="root" so it's okay)
407 */
408int
409allowed(username)
410 char *username;
411{
412 static int init = FALSE;
413 static FILE *allow, *deny;
414
415 if (!init) {
416 init = TRUE;
417#if defined(ALLOW_FILE) && defined(DENY_FILE)
418 allow = fopen(ALLOW_FILE, "r");
419 deny = fopen(DENY_FILE, "r");
420 Debug(DMISC, ("allow/deny enabled, %d/%d\n", !!allow, !!deny))
421#else
422 allow = NULL;
423 deny = NULL;
424#endif
425 }
426
427 if (allow)
428 return (in_file(username, allow));
429 if (deny)
430 return (!in_file(username, deny));
431
432#if defined(ALLOW_ONLY_ROOT)
433 return (strcmp(username, ROOT_USER) == 0);
434#else
435 return TRUE;
436#endif
437}
438
439
440void
441log_it(username, xpid, event, detail)
442 char *username;
443 int xpid;
444 char *event;
445 char *detail;
446{
447 PID_T pid = xpid;
448#if defined(LOG_FILE)
449 char *msg;
450 TIME_T now = time((TIME_T) 0);
451 register struct tm *t = localtime(&now);
452#endif /*LOG_FILE*/
453
454#if defined(SYSLOG)
455 static int syslog_open = 0;
456#endif
457
458#if defined(LOG_FILE)
459 /* we assume that MAX_TEMPSTR will hold the date, time, &punctuation.
460 */
461 msg = malloc(strlen(username)
462 + strlen(event)
463 + strlen(detail)
464 + MAX_TEMPSTR);
465
466 if (LogFD < OK) {
467 LogFD = open(LOG_FILE, O_WRONLY|O_APPEND|O_CREAT, 0600);
468 if (LogFD < OK) {
469 warn("can't open log file %s", LOG_FILE);
470 } else {
471 (void) fcntl(LogFD, F_SETFD, 1);
472 }
473 }
474
475 /* we have to sprintf() it because fprintf() doesn't always write
476 * everything out in one chunk and this has to be atomically appended
477 * to the log file.
478 */
479 sprintf(msg, "%s (%02d/%02d-%02d:%02d:%02d-%d) %s (%s)\n",
480 username,
481 t->tm_mon+1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, pid,
482 event, detail);
483
484 /* we have to run strlen() because sprintf() returns (char*) on old BSD
485 */
486 if (LogFD < OK || write(LogFD, msg, strlen(msg)) < OK) {
487 if (LogFD >= OK)
488 warn("%s", LOG_FILE);
489 warnx("can't write to log file");
490 write(STDERR, msg, strlen(msg));
491 }
492
493 free(msg);
494#endif /*LOG_FILE*/
495
496#if defined(SYSLOG)
497 if (!syslog_open) {
498 /* we don't use LOG_PID since the pid passed to us by
499 * our client may not be our own. therefore we want to
500 * print the pid ourselves.
501 */
502# ifdef LOG_DAEMON
503 openlog(ProgramName, LOG_PID, LOG_CRON);
504# else
505 openlog(ProgramName, LOG_PID);
506# endif
507 syslog_open = TRUE; /* assume openlog success */
508 }
509
510 syslog(LOG_INFO, "(%s) %s (%s)\n", username, event, detail);
511
512#endif /*SYSLOG*/
513
514#if DEBUGGING
515 if (DebugFlags) {
516 fprintf(stderr, "log_it: (%s %d) %s (%s)\n",
517 username, pid, event, detail);
518 }
519#endif
520}
521
522
523void
524log_close() {
525 if (LogFD != ERR) {
526 close(LogFD);
527 LogFD = ERR;
528 }
529}
530
531
532/* two warnings:
533 * (1) this routine is fairly slow
534 * (2) it returns a pointer to static storage
535 */
536char *
537first_word(s, t)
538 register char *s; /* string we want the first word of */
539 register char *t; /* terminators, implicitly including \0 */
540{
541 static char retbuf[2][MAX_TEMPSTR + 1]; /* sure wish C had GC */
542 static int retsel = 0;
543 register char *rb, *rp;
544
545 /* select a return buffer */
546 retsel = 1-retsel;
547 rb = &retbuf[retsel][0];
548 rp = rb;
549
550 /* skip any leading terminators */
551 while (*s && (NULL != strchr(t, *s))) {
552 s++;
553 }
554
555 /* copy until next terminator or full buffer */
556 while (*s && (NULL == strchr(t, *s)) && (rp < &rb[MAX_TEMPSTR])) {
557 *rp++ = *s++;
558 }
559
560 /* finish the return-string and return it */
561 *rp = '\0';
562 return rb;
563}
564
565
566/* warning:
567 * heavily ascii-dependent.
568 */
569void
570mkprint(dst, src, len)
571 register char *dst;
572 register unsigned char *src;
573 register int len;
574{
575 while (len-- > 0)
576 {
577 register unsigned char ch = *src++;
578
579 if (ch < ' ') { /* control character */
580 *dst++ = '^';
581 *dst++ = ch + '@';
582 } else if (ch < 0177) { /* printable */
583 *dst++ = ch;
584 } else if (ch == 0177) { /* delete/rubout */
585 *dst++ = '^';
586 *dst++ = '?';
587 } else { /* parity character */
588 sprintf(dst, "\\%03o", ch);
589 dst += 4;
590 }
591 }
592 *dst = '\0';
593}
594
595
596/* warning:
597 * returns a pointer to malloc'd storage, you must call free yourself.
598 */
599char *
600mkprints(src, len)
601 register unsigned char *src;
602 register unsigned int len;
603{
604 register char *dst = malloc(len*4 + 1);
605
606 mkprint(dst, src, len);
607
608 return dst;
609}
610
611
612#ifdef MAIL_DATE
613/* Sat, 27 Feb 93 11:44:51 CST
614 * 123456789012345678901234567
615 */
616char *
617arpadate(clock)
618 time_t *clock;
619{
620 time_t t = clock ?*clock :time(0L);
621 struct tm *tm = localtime(&t);
| 21#endif
22
23/* vix 26jan87 [RCS has the rest of the log]
24 * vix 30dec86 [written]
25 */
26
27
28#include "cron.h"
29#if SYS_TIME_H
30# include <sys/time.h>
31#else
32# include <time.h>
33#endif
34#include <sys/file.h>
35#include <sys/stat.h>
36#include <err.h>
37#include <errno.h>
38#include <string.h>
39#include <fcntl.h>
40#if defined(SYSLOG)
41# include <syslog.h>
42#endif
43
44
45#if defined(LOG_DAEMON) && !defined(LOG_CRON)
46#define LOG_CRON LOG_DAEMON
47#endif
48
49
50static int LogFD = ERR;
51
52
53int
54strcmp_until(left, right, until)
55 char *left;
56 char *right;
57 int until;
58{
59 register int diff;
60
61 while (*left && *left != until && *left == *right) {
62 left++;
63 right++;
64 }
65
66 if ((*left=='\0' || *left == until) &&
67 (*right=='\0' || *right == until)) {
68 diff = 0;
69 } else {
70 diff = *left - *right;
71 }
72
73 return diff;
74}
75
76
77/* strdtb(s) - delete trailing blanks in string 's' and return new length
78 */
79int
80strdtb(s)
81 char *s;
82{
83 char *x = s;
84
85 /* scan forward to the null
86 */
87 while (*x)
88 x++;
89
90 /* scan backward to either the first character before the string,
91 * or the last non-blank in the string, whichever comes first.
92 */
93 do {x--;}
94 while (x >= s && isspace(*x));
95
96 /* one character beyond where we stopped above is where the null
97 * goes.
98 */
99 *++x = '\0';
100
101 /* the difference between the position of the null character and
102 * the position of the first character of the string is the length.
103 */
104 return x - s;
105}
106
107
108int
109set_debug_flags(flags)
110 char *flags;
111{
112 /* debug flags are of the form flag[,flag ...]
113 *
114 * if an error occurs, print a message to stdout and return FALSE.
115 * otherwise return TRUE after setting ERROR_FLAGS.
116 */
117
118#if !DEBUGGING
119
120 printf("this program was compiled without debugging enabled\n");
121 return FALSE;
122
123#else /* DEBUGGING */
124
125 char *pc = flags;
126
127 DebugFlags = 0;
128
129 while (*pc) {
130 char **test;
131 int mask;
132
133 /* try to find debug flag name in our list.
134 */
135 for ( test = DebugFlagNames, mask = 1;
136 *test && strcmp_until(*test, pc, ',');
137 test++, mask <<= 1
138 )
139 ;
140
141 if (!*test) {
142 fprintf(stderr,
143 "unrecognized debug flag <%s> <%s>\n",
144 flags, pc);
145 return FALSE;
146 }
147
148 DebugFlags |= mask;
149
150 /* skip to the next flag
151 */
152 while (*pc && *pc != ',')
153 pc++;
154 if (*pc == ',')
155 pc++;
156 }
157
158 if (DebugFlags) {
159 int flag;
160
161 fprintf(stderr, "debug flags enabled:");
162
163 for (flag = 0; DebugFlagNames[flag]; flag++)
164 if (DebugFlags & (1 << flag))
165 fprintf(stderr, " %s", DebugFlagNames[flag]);
166 fprintf(stderr, "\n");
167 }
168
169 return TRUE;
170
171#endif /* DEBUGGING */
172}
173
174
175void
176set_cron_uid()
177{
178#if defined(BSD) || defined(POSIX)
179 if (seteuid(ROOT_UID) < OK)
180 err(ERROR_EXIT, "seteuid");
181#else
182 if (setuid(ROOT_UID) < OK)
183 err(ERROR_EXIT, "setuid");
184#endif
185}
186
187
188void
189set_cron_cwd()
190{
191 struct stat sb;
192
193 /* first check for CRONDIR ("/var/cron" or some such)
194 */
195 if (stat(CRONDIR, &sb) < OK && errno == ENOENT) {
196 warn("%s", CRONDIR);
197 if (OK == mkdir(CRONDIR, 0700)) {
198 warnx("%s: created", CRONDIR);
199 stat(CRONDIR, &sb);
200 } else {
201 err(ERROR_EXIT, "%s: mkdir", CRONDIR);
202 }
203 }
204 if (!(sb.st_mode & S_IFDIR))
205 err(ERROR_EXIT, "'%s' is not a directory, bailing out", CRONDIR);
206 if (chdir(CRONDIR) < OK)
207 err(ERROR_EXIT, "cannot chdir(%s), bailing out", CRONDIR);
208
209 /* CRONDIR okay (now==CWD), now look at SPOOL_DIR ("tabs" or some such)
210 */
211 if (stat(SPOOL_DIR, &sb) < OK && errno == ENOENT) {
212 warn("%s", SPOOL_DIR);
213 if (OK == mkdir(SPOOL_DIR, 0700)) {
214 warnx("%s: created", SPOOL_DIR);
215 stat(SPOOL_DIR, &sb);
216 } else {
217 err(ERROR_EXIT, "%s: mkdir", SPOOL_DIR);
218 }
219 }
220 if (!(sb.st_mode & S_IFDIR))
221 err(ERROR_EXIT, "'%s' is not a directory, bailing out", SPOOL_DIR);
222}
223
224
225/* acquire_daemonlock() - write our PID into /etc/cron.pid, unless
226 * another daemon is already running, which we detect here.
227 *
228 * note: main() calls us twice; once before forking, once after.
229 * we maintain static storage of the file pointer so that we
230 * can rewrite our PID into the PIDFILE after the fork.
231 *
232 * it would be great if fflush() disassociated the file buffer.
233 */
234void
235acquire_daemonlock(closeflag)
236 int closeflag;
237{
238 static FILE *fp = NULL;
239
240 if (closeflag && fp) {
241 fclose(fp);
242 fp = NULL;
243 return;
244 }
245
246 if (!fp) {
247 char pidfile[MAX_FNAME];
248 char buf[MAX_TEMPSTR];
249 int fd, otherpid;
250
251 (void) sprintf(pidfile, PIDFILE, PIDDIR);
252 if ((-1 == (fd = open(pidfile, O_RDWR|O_CREAT, 0644)))
253 || (NULL == (fp = fdopen(fd, "r+")))
254 ) {
255 sprintf(buf, "can't open or create %s: %s",
256 pidfile, strerror(errno));
257 log_it("CRON", getpid(), "DEATH", buf);
258 errx(ERROR_EXIT, "%s", buf);
259 }
260
261 if (flock(fd, LOCK_EX|LOCK_NB) < OK) {
262 int save_errno = errno;
263
264 fscanf(fp, "%d", &otherpid);
265 sprintf(buf, "can't lock %s, otherpid may be %d: %s",
266 pidfile, otherpid, strerror(save_errno));
267 log_it("CRON", getpid(), "DEATH", buf);
268 errx(ERROR_EXIT, "%s", buf);
269 }
270
271 (void) fcntl(fd, F_SETFD, 1);
272 }
273
274 rewind(fp);
275 fprintf(fp, "%d\n", getpid());
276 fflush(fp);
277 (void) ftruncate(fileno(fp), ftell(fp));
278
279 /* abandon fd and fp even though the file is open. we need to
280 * keep it open and locked, but we don't need the handles elsewhere.
281 */
282}
283
284/* get_char(file) : like getc() but increment LineNumber on newlines
285 */
286int
287get_char(file)
288 FILE *file;
289{
290 int ch;
291
292 ch = getc(file);
293 if (ch == '\n')
294 Set_LineNum(LineNumber + 1)
295 return ch;
296}
297
298
299/* unget_char(ch, file) : like ungetc but do LineNumber processing
300 */
301void
302unget_char(ch, file)
303 int ch;
304 FILE *file;
305{
306 ungetc(ch, file);
307 if (ch == '\n')
308 Set_LineNum(LineNumber - 1)
309}
310
311
312/* get_string(str, max, file, termstr) : like fgets() but
313 * (1) has terminator string which should include \n
314 * (2) will always leave room for the null
315 * (3) uses get_char() so LineNumber will be accurate
316 * (4) returns EOF or terminating character, whichever
317 */
318int
319get_string(string, size, file, terms)
320 char *string;
321 int size;
322 FILE *file;
323 char *terms;
324{
325 int ch;
326
327 while (EOF != (ch = get_char(file)) && !strchr(terms, ch)) {
328 if (size > 1) {
329 *string++ = (char) ch;
330 size--;
331 }
332 }
333
334 if (size > 0)
335 *string = '\0';
336
337 return ch;
338}
339
340
341/* skip_comments(file) : read past comment (if any)
342 */
343void
344skip_comments(file)
345 FILE *file;
346{
347 int ch;
348
349 while (EOF != (ch = get_char(file))) {
350 /* ch is now the first character of a line.
351 */
352
353 while (ch == ' ' || ch == '\t')
354 ch = get_char(file);
355
356 if (ch == EOF)
357 break;
358
359 /* ch is now the first non-blank character of a line.
360 */
361
362 if (ch != '\n' && ch != '#')
363 break;
364
365 /* ch must be a newline or comment as first non-blank
366 * character on a line.
367 */
368
369 while (ch != '\n' && ch != EOF)
370 ch = get_char(file);
371
372 /* ch is now the newline of a line which we're going to
373 * ignore.
374 */
375 }
376 if (ch != EOF)
377 unget_char(ch, file);
378}
379
380
381/* int in_file(char *string, FILE *file)
382 * return TRUE if one of the lines in file matches string exactly,
383 * FALSE otherwise.
384 */
385static int
386in_file(string, file)
387 char *string;
388 FILE *file;
389{
390 char line[MAX_TEMPSTR];
391
392 rewind(file);
393 while (fgets(line, MAX_TEMPSTR, file)) {
394 if (line[0] != '\0')
395 line[strlen(line)-1] = '\0';
396 if (0 == strcmp(line, string))
397 return TRUE;
398 }
399 return FALSE;
400}
401
402
403/* int allowed(char *username)
404 * returns TRUE if (ALLOW_FILE exists and user is listed)
405 * or (DENY_FILE exists and user is NOT listed)
406 * or (neither file exists but user=="root" so it's okay)
407 */
408int
409allowed(username)
410 char *username;
411{
412 static int init = FALSE;
413 static FILE *allow, *deny;
414
415 if (!init) {
416 init = TRUE;
417#if defined(ALLOW_FILE) && defined(DENY_FILE)
418 allow = fopen(ALLOW_FILE, "r");
419 deny = fopen(DENY_FILE, "r");
420 Debug(DMISC, ("allow/deny enabled, %d/%d\n", !!allow, !!deny))
421#else
422 allow = NULL;
423 deny = NULL;
424#endif
425 }
426
427 if (allow)
428 return (in_file(username, allow));
429 if (deny)
430 return (!in_file(username, deny));
431
432#if defined(ALLOW_ONLY_ROOT)
433 return (strcmp(username, ROOT_USER) == 0);
434#else
435 return TRUE;
436#endif
437}
438
439
440void
441log_it(username, xpid, event, detail)
442 char *username;
443 int xpid;
444 char *event;
445 char *detail;
446{
447 PID_T pid = xpid;
448#if defined(LOG_FILE)
449 char *msg;
450 TIME_T now = time((TIME_T) 0);
451 register struct tm *t = localtime(&now);
452#endif /*LOG_FILE*/
453
454#if defined(SYSLOG)
455 static int syslog_open = 0;
456#endif
457
458#if defined(LOG_FILE)
459 /* we assume that MAX_TEMPSTR will hold the date, time, &punctuation.
460 */
461 msg = malloc(strlen(username)
462 + strlen(event)
463 + strlen(detail)
464 + MAX_TEMPSTR);
465
466 if (LogFD < OK) {
467 LogFD = open(LOG_FILE, O_WRONLY|O_APPEND|O_CREAT, 0600);
468 if (LogFD < OK) {
469 warn("can't open log file %s", LOG_FILE);
470 } else {
471 (void) fcntl(LogFD, F_SETFD, 1);
472 }
473 }
474
475 /* we have to sprintf() it because fprintf() doesn't always write
476 * everything out in one chunk and this has to be atomically appended
477 * to the log file.
478 */
479 sprintf(msg, "%s (%02d/%02d-%02d:%02d:%02d-%d) %s (%s)\n",
480 username,
481 t->tm_mon+1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, pid,
482 event, detail);
483
484 /* we have to run strlen() because sprintf() returns (char*) on old BSD
485 */
486 if (LogFD < OK || write(LogFD, msg, strlen(msg)) < OK) {
487 if (LogFD >= OK)
488 warn("%s", LOG_FILE);
489 warnx("can't write to log file");
490 write(STDERR, msg, strlen(msg));
491 }
492
493 free(msg);
494#endif /*LOG_FILE*/
495
496#if defined(SYSLOG)
497 if (!syslog_open) {
498 /* we don't use LOG_PID since the pid passed to us by
499 * our client may not be our own. therefore we want to
500 * print the pid ourselves.
501 */
502# ifdef LOG_DAEMON
503 openlog(ProgramName, LOG_PID, LOG_CRON);
504# else
505 openlog(ProgramName, LOG_PID);
506# endif
507 syslog_open = TRUE; /* assume openlog success */
508 }
509
510 syslog(LOG_INFO, "(%s) %s (%s)\n", username, event, detail);
511
512#endif /*SYSLOG*/
513
514#if DEBUGGING
515 if (DebugFlags) {
516 fprintf(stderr, "log_it: (%s %d) %s (%s)\n",
517 username, pid, event, detail);
518 }
519#endif
520}
521
522
523void
524log_close() {
525 if (LogFD != ERR) {
526 close(LogFD);
527 LogFD = ERR;
528 }
529}
530
531
532/* two warnings:
533 * (1) this routine is fairly slow
534 * (2) it returns a pointer to static storage
535 */
536char *
537first_word(s, t)
538 register char *s; /* string we want the first word of */
539 register char *t; /* terminators, implicitly including \0 */
540{
541 static char retbuf[2][MAX_TEMPSTR + 1]; /* sure wish C had GC */
542 static int retsel = 0;
543 register char *rb, *rp;
544
545 /* select a return buffer */
546 retsel = 1-retsel;
547 rb = &retbuf[retsel][0];
548 rp = rb;
549
550 /* skip any leading terminators */
551 while (*s && (NULL != strchr(t, *s))) {
552 s++;
553 }
554
555 /* copy until next terminator or full buffer */
556 while (*s && (NULL == strchr(t, *s)) && (rp < &rb[MAX_TEMPSTR])) {
557 *rp++ = *s++;
558 }
559
560 /* finish the return-string and return it */
561 *rp = '\0';
562 return rb;
563}
564
565
566/* warning:
567 * heavily ascii-dependent.
568 */
569void
570mkprint(dst, src, len)
571 register char *dst;
572 register unsigned char *src;
573 register int len;
574{
575 while (len-- > 0)
576 {
577 register unsigned char ch = *src++;
578
579 if (ch < ' ') { /* control character */
580 *dst++ = '^';
581 *dst++ = ch + '@';
582 } else if (ch < 0177) { /* printable */
583 *dst++ = ch;
584 } else if (ch == 0177) { /* delete/rubout */
585 *dst++ = '^';
586 *dst++ = '?';
587 } else { /* parity character */
588 sprintf(dst, "\\%03o", ch);
589 dst += 4;
590 }
591 }
592 *dst = '\0';
593}
594
595
596/* warning:
597 * returns a pointer to malloc'd storage, you must call free yourself.
598 */
599char *
600mkprints(src, len)
601 register unsigned char *src;
602 register unsigned int len;
603{
604 register char *dst = malloc(len*4 + 1);
605
606 mkprint(dst, src, len);
607
608 return dst;
609}
610
611
612#ifdef MAIL_DATE
613/* Sat, 27 Feb 93 11:44:51 CST
614 * 123456789012345678901234567
615 */
616char *
617arpadate(clock)
618 time_t *clock;
619{
620 time_t t = clock ?*clock :time(0L);
621 struct tm *tm = localtime(&t);
|