![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to misc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / notes / src|
Return to misc.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / notes / src |
1.1 root 1: #include <errno.h>
2: #include <sys/param.h>
3: #include "parms.h"
4: #include "structs.h"
5: #include <signal.h> /* signal processing */
6: #include <ctype.h>
7: #ifdef SIGCHLD
8: #include <sys/wait.h> /* for child status */
9: #endif SIGCHLD
10:
11: #ifdef RCSIDENT
12: static char rcsid[] = "$Header: misc.c,v 1.7.0.5 85/10/06 01:41:01 notes Rel $";
13: #endif RCSIDENT
14:
15: #define LOCKTRY 10 /* number of shots at grabbing */
16: #define FORKTRY 10 /* tries at forking */
17:
18: /*
19: * dounix(charstring, flag) will execute that character string as a shell command
20: * stolen from shell, though this one catches more signals.
21: *
22: * Depending on the RUNSUID flag the routine sets things back to
23: * the users group or uid. Early versions were setuid and newer
24: * versions only run setgid. Don't get confused by the "hisuid"
25: * argument: it really means "reset to his permissions".
26: * R. Kolstad -- 11/2/80
27: * modified: R. Essick January 1982, to clean up some signal processing
28: *
29: */
30:
31: #if defined(SIGCHLD)
32: static int kidpid; /* passed by kidwatch() */
33: static union wait kidstatus;
34: #endif defined(SIGCHLD)
35:
36:
37: #ifndef FASTFORK
38: dounix (linebuf, hisuid, ttymode)
39: char linebuf[];
40: #else
41: dounix (hisuid, ttymode, arg0, arg1, arg2, arg3, arg4)
42: char *arg0,
43: *arg1,
44: *arg2,
45: *arg3,
46: *arg4;
47: #endif
48: {
49: register pid,
50: forktry,
51: rpid;
52: int (*p) (),
53: (*q) (),
54: (*r) ();
55: #if defined(SIGTSTP)
56: int (*s) ();
57: #endif defined(SIGTSTP)
58: #if defined(SIGCHLD)
59: int (*t) ();
60: extern int watchkid (); /* catch stopped kids */
61: #endif defined(SIGCHLD)
62: int retcode;
63:
64:
65: if (ttymode)
66: ttystop (); /* give back to normal mode */
67: pid = 0; /* satisfy init conditions */
68: forktry = 0; /* init the counter */
69: while (pid <= 0 && ++forktry < FORKTRY)
70: {
71: if ((pid = fork ()) == 0)
72: {
73: uncatchem (); /* reset this process signals */
74: /* if user can get his hands on it */
75: if (hisuid) /* only set uid if giving shell */
76: #ifdef RUNSUID
77: setuid (globuid); /* give him his uid */
78: #else
79: setgid (getgid ()); /* his group */
80: #endif RUNSUID
81: for (rpid = 3; rpid < NOFILE; rpid++) /* close extra files */
82: close (rpid);
83:
84: #ifndef FASTFORK
85: if (linebuf == 0)
86: execl (hisshell, hisshell, 0);
87: else
88: execl (DFLTSH, "sh", "-c", linebuf, 0);
89: printf ("Rats -- Couldn't load %s\n", DFLTSH);
90: #else
91: if (arg0 == 0)
92: execlp (hisshell, hisshell, 0);
93: else
94: execlp (arg0, arg0, arg1, arg2, arg3, arg4);
95: printf ("Rats - Couldn't load %s\n", arg0);
96: #endif
97:
98: _exit (BAD); /* if exec fails .. */
99: }
100: if (pid <= 0) /* if fork failed */
101: sleep (2); /* wait a bit */
102: }
103: if (pid > 0) /* only if have son */
104: {
105: p = signal (SIGHUP, SIG_IGN);
106: q = signal (SIGINT, SIG_IGN);
107: r = signal (SIGQUIT, SIG_IGN);
108: #if defined(SIGTSTP)
109: s = signal (SIGTSTP, SIG_DFL);
110: #endif defined(SIGTSTP)
111: #if defined(SIGCHLD)
112: t = signal (SIGCHLD, watchkid); /* if he signals */
113: #endif defined(SIGCHLD)
114: while ((rpid = wait (&retcode)) != pid && rpid != -1);
115: if (rpid == -1)
116: {
117: #if defined(SIGCHLD)
118: /*
119: * watchkid() might have sucked down the status of the terminated
120: * child, so we load whatever value it left for us in kidstatus
121: * (provided that kidpid was ok)
122: */
123: if (pid == kidpid) /* the one we wanted */
124: retcode = kidstatus.w_status; /* from watchkid() */
125: else
126: retcode = 1 << 8; /* make an error */
127: #else
128: /*
129: * normal case, if the wait() failed for some reason we say that it
130: * is an error.
131: */
132: retcode = 1 << 8; /* indicates error */
133: #endif defined(SIGCHLD)
134: }
135: signal (SIGHUP, p);
136: signal (SIGINT, q);
137: signal (SIGQUIT, r);
138: #if defined(SIGTSTP)
139: signal (SIGTSTP, s);
140: #endif defined(SIGTSTP)
141: #if defined(SIGCHLD)
142: signal (SIGCHLD, t);
143: #endif defined(SIGCHLD)
144: }
145: else
146: retcode = -1; /* some sort of error */
147: if (ttymode)
148: ttystrt (); /* back into raw mode */
149: return retcode >> 8; /* hand him the completion code */
150: }
151:
152: #if defined(SIGCHLD)
153: /*
154: * watchkid()
155: *
156: * called when we receive a SIGCHLD signal, indicating that a child's
157: * status has changed. This routine looks via wait3() to see if
158: * the children have merely been suspended. If so, it stops itself
159: * so that it's parent can decide what to do.
160: *
161: * This catches problems with programs like vi which run in raw mode
162: * and catch ^z as a character. They later try to signal the entire
163: * process group but are unable to signal the notes process since it
164: * has a different effective uid. By watching the SIGCHLD signal, we
165: * get notification when the vi process has stopped and we can stop
166: * ourselves.
167: * Ray Essick, Augst 22, 1984
168: */
169: static int watchkid (sig)
170: int sig;
171: {
172:
173: kidpid = wait3 (&kidstatus, WUNTRACED | WNOHANG, 0);/* get status */
174: if (kidpid == 0) /* nothing to report */
175: return 0; /* get out */
176: if (kidpid == (-1)) /* no children at all */
177: return 0; /* get out */
178: if (WIFSTOPPED (kidstatus)) /* stopped himself */
179: {
180: kill (getpid (), SIGTSTP); /* stop myself */
181: }
182: }
183: #endif defined(SIGCHLD)
184:
185: /*
186: * If the condition is TRUE (non-zero) abort the program.
187: *
188: * Print the supplied message and halt.
189: * Leave an optional core dump for debugging later.
190: *
191: * Ray Essick 10/23/80
192: */
193:
194: x (cond, p) char *p;
195: {
196: if (cond == 0)
197: return; /* didnt fail */
198:
199: perror ("notes");
200: fprintf (stderr, "Fatal Internal Notesfile Error: %s\n", p);
201: ttystop (); /* back to normal */
202:
203:
204: #ifdef DUMPCORE
205: if (chdir (Mstdir) < 0) /* go to known place */
206: exit (BAD); /* drop out */
207: if (chdir (UTILITY) < 0)
208: exit (BAD); /* drop out */
209: if (chdir (DUMPCORE) < 0) /* writeable to all */
210: exit (BAD); /* drop out */
211: #ifdef RUNSUID
212: setuid (globuid); /* won't dump if euid != uid */
213: #else
214: setgid (getgid ()); /* no gift groups */
215: #endif RUNSUID
216: #endif DUMPCORE
217:
218: #ifdef NFMAINT
219: /*
220: * This code is kind of risky. If the NFMAINT notesfile ever
221: * gets trashed and starts calling this routine, look out because
222: * it will recursively fail. This is the unfortunate byproduct
223: * of the fact that the "x" routine doesn't know what the
224: * current notesfile is.
225: */
226: {
227: char pbuf[512]; /* hold message */
228: char pbuf2[128]; /* and title */
229: char pbuf3[256]; /* core image */
230: char *tail; /* end of invocation */
231:
232: sprintf (pbuf2, "%s: aborted", Invokedas);
233: sprintf (pbuf, "Program:\t%s\nMessage:\t%s\n\nerrno:\t\t%d (%s)\n",
234: Invokedas, p, errno,
235: errno >= sys_nerr ? "Unknown error code" : sys_errlist[errno]);
236: #ifdef DUMPCORE
237: if ((tail = rindex (Invokedas, '/')) == NULL) /* pathname? */
238: tail = Invokedas; /* simple invocation */
239: else
240: tail++; /* strip the slash */
241: sprintf (pbuf3, "%s/%s/%s/%s", Mstdir, UTILITY, DUMPCORE, tail);
242: nfabort (NFMAINT, pbuf, pbuf2, pbuf3, BAD); /* log & abort */
243: #else ! DUMPCORE
244: nfcomment (NFMAINT, pbuf, pbuf2, 0, 0); /* actual insertion */
245: #endif DUMPCORE
246: }
247: #endif NFMAINT
248:
249: /*
250: * Handle the exit if NFMAINT is undefined.
251: */
252:
253: #ifdef DUMPCORE
254: abort (); /* dump in "core" */
255: #else
256: exit (BAD); /* for production */
257: #endif DUMPCORE
258: }
259:
260: /*
261: * lock creates a lock file, or waits until it can create the lock.
262: * lock files are of the form lock# where # is a character passed
263: * to the routine.
264: *
265: * Rob Kolstad 10/20/80
266: * modified: rbe December 1981 to add full path name for lock file
267: */
268:
269: locknf (io, c)
270: struct io_f *io;
271: char c;
272: {
273: register int i,
274: holderr,
275: trys;
276: char p[WDLEN];
277:
278: sprintf (p, "%s/%s/%c%s", Mstdir, LOCKS, c, io -> nf);
279: /* generate file name */
280: trys = LOCKTRY; /* set him up */
281: while ((i = creat (p, 0)) < 0)
282: {
283: if (trys-- == 0)
284: {
285: holderr = errno; /* before it's abused */
286: fprintf (stderr, "lock %c (%s) permanently locked - consult a guru\n",
287: c, io -> nf);
288: #ifdef NFMAINT
289: if (strcmp (NFMAINT, io -> nf)) /* avoid loops */
290: {
291: char pbuf[256]; /* for error logging */
292: char tbuf[256]; /* title */
293: sprintf (pbuf,
294: "lock %c failed for %s,\nerrno = %d (%s)\nProgram = %s\n",
295: c, io -> fullname, holderr, sys_errlist[holderr],
296: Invokedas);
297: sprintf (tbuf, "%s: locked (%c)", io -> nf, c);
298: nfcomment (NFMAINT, pbuf, tbuf, 0, 0);
299: }
300: #endif NFMAINT
301: ttystop ();
302: exit (BAD);
303: }
304: sleep (2); /* guarantee at least 1 */
305: }
306: ignoresigs++; /* critical section */
307: /*
308: * could be above getting the lock, but wanted to be able to suspend
309: * while getting the lock. The interuptable window is very small
310: */
311: close (i);
312: }
313:
314: /*
315: * unlock takes the same arguements as the lock routine, and it
316: * will remove the corresponding lock file
317: *
318: * Rob Kolstad 10/20/80
319: * modified: rbe December 1981 to add full path name for lock name
320: */
321:
322: unlocknf (io, c)
323: struct io_f *io;
324: char c;
325: {
326: char p[WDLEN];
327:
328: sprintf (p, "%s/%s/%c%s", Mstdir, LOCKS, c, io -> nf);
329: /* generate file name */
330: x (unlink (p) < 0, "unlock: unlink lock");
331: ignoresigs--; /* no longer critical */
332: }
333:
334: /*
335: * glock creates a lock file, or waits until it can create the lock.
336: * lock files are of the form lock# where # is a character passed
337: * to the routine.
338: * This lock file is a GLOBAL lock - across all notefiles
339: *
340: * taken from lock routine above by R. Essick December 1981
341: */
342:
343: glocknf (io, c)
344: struct io_f *io; /* unused in this routine */
345: char c;
346: {
347: register int i,
348: holderr,
349: trys;
350: char p[WDLEN];
351:
352: sprintf (p, "%s/%s/%c", Mstdir, LOCKS, c); /* generate file name */
353: trys = LOCKTRY;
354: while ((i = creat (p, 0)) < 0)
355: {
356: if (trys-- == 0)
357: {
358: holderr = errno; /* before it's abused */
359: fprintf (stderr, "lock%c combo lost - consult your local guru\n", c);
360: #ifdef NFMAINT
361: if (strcmp (NFMAINT, io -> nf)) /* don't loop on self */
362: {
363: char pbuf[256]; /* for error logging */
364: char pbuf2[256];
365: sprintf (pbuf,
366: "glock %c failed for %s, errno = %d (%s)\nProgram = %s\n",
367: c, io -> fullname, holderr, sys_errlist[holderr],
368: Invokedas);
369: sprintf (pbuf2, "Frozen Global Lock (%c)", c);
370: nfcomment (NFMAINT, pbuf, pbuf2, 0, 0);
371: }
372: #endif NFMAINT
373: ttystop ();
374: exit (BAD);
375: }
376: sleep (2); /* is there a smaller time interval */
377: }
378: close (i);
379: }
380:
381: /*
382: * gunlock takes the same arguements as the lock routine, and it
383: * will remove the corresponding lock file
384: * This is GLOBAL locking - across all notefiles
385: *
386: * copy of code from unlock, with minor changes
387: * Ray Essick December 1981
388: */
389:
390: gunlocknf (io, c)
391: struct io_f *io; /* not used by this routine */
392: char c;
393: {
394: char p[WDLEN];
395:
396: sprintf (p, "%s/%s/%c", Mstdir, LOCKS, c); /* make the file name */
397: x (unlink (p) < 0, "gunlock: unlink lock");
398: }
399:
400: /*
401: * length tells us max(length of string, 1)
402: */
403: len (p, n) char *p;
404: {
405: int i;
406: i = n;
407: p += n;
408: while (*--p == ' ' && --i)
409: if (i == 0)
410: i = 1;
411: return i;
412: }
413:
414: /*
415: * shell - give the user a shell
416: * this includes:
417: * 1) changing to the directory where he came in from
418: * 2) giving him a shell
419: * 3) return to the notefile directory
420: *
421: * original author: Ray Essick may 29, 1981
422: *
423: */
424:
425: gshell ()
426: {
427: printf ("\n");
428: #ifndef FASTFORK
429: dounix (0, 1, 1); /* give him his shell */
430: #else
431: dounix (1, 1, 0, 0, 0, 0, 0);
432: #endif
433: return 0;
434: }
435:
436: /* copydate merely moves a when_f structure from 'from' to 'to' */
437: /* ray essick - 20-nov-1981 */
438:
439: copydate (from, to)
440: struct when_f *from,
441: *to;
442: {
443: *to = *from; /* use block move */
444: }
445:
446: /* strmove - copy a null terminated string to another */
447: /* returns the count of characters moved, this count includes the */
448: /* null terminator.. */
449: /* r. essick 20-nov-81 */
450:
451: strmove (p, q)
452: char *p,
453: *q; /* from p to q */
454: {
455: int count;
456: register char *pp,
457: *qq;
458:
459: count = 0; /* start with no characters moved */
460: pp = p;
461: qq = q; /* use registers for speed */
462: while (*qq++ = *pp++)
463: count++;
464: return count; /* return count of characters moved */
465: /* don't include the terminator */
466: }
467:
468: /* copyauth(from, to) struct auth_f *from,*auth
469: * copys author from from to to
470: * Ray Essick December 1981
471: *
472: * SHOULD USE STRUCTURE ASSIGNMENT IN ALL PLACES THAT CALL THIS
473: */
474: copyauth (from, to)
475: struct auth_f *from,
476: *to;
477: {
478:
479: strncpy (to -> aname, from -> aname, NAMESZ); /* author name */
480: strncpy (to -> asystem, from -> asystem, HOMESYSSZ);/* home machine */
481: to -> aid = from -> aid; /* and user id */
482: }
483:
484: /* listget, listconv - parse a list of numbers.
485: * this is all taken ( sort of ) from Rob Kolstad's getpg
486: * program
487: */
488:
489: listget (buf, ptr, start, finish)
490: char buf[];
491: int *ptr,
492: *start,
493: *finish;
494: {
495: if ((buf[*ptr] < '0' || buf[*ptr] > '9') && buf[*ptr] != ' ')
496: {
497: return 0; /* end of this list */
498: }
499: *start = listconv (buf, ptr); /* get the first */
500: *finish = *start; /* default to single */
501: if (buf[*ptr] == '-')
502: {
503: ++(*ptr); /* trash that separator */
504: *finish = listconv (buf, ptr); /* grab second */
505: ++(*ptr); /* bump past delimiter */
506: return 2; /* parsed 2 arguements */
507: }
508: else
509: {
510: if (buf[*ptr] != '\0')
511: ++(*ptr); /* dump delimiter */
512: return 1;
513: }
514: }
515:
516: listconv (buf, ptr)
517: char buf[];
518: int *ptr;
519: {
520: int i;
521: i = 0;
522: while (buf[*ptr] == ' ')
523: ++(*ptr);
524: while (buf[*ptr] >= '0' && buf[*ptr] <= '9')
525: {
526: i = 10 * i + buf[*ptr] - '0';
527: ++(*ptr); /* bump him */
528: }
529: return (i);
530: }
531:
532: /* tolcase - check to see if upper case, and convert to lcase */
533: /* R. Essick Feb 1982 */
534: tolcase (c)
535: char c;
536: {
537: if (isascii (c) && isupper (c))
538: return (tolower (c)); /* to lower case */
539: return (c); /* leave as is */
540: }
541:
542: /*
543: * Date printing stuff.
544: *
545: * CHANGE TO CTIME(III) FORMAT EVENTUALLY
546: */
547:
548: char *mnames[13] = /* so indexes work right */
549: {
550: "???", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug",
551: "Sep", "Oct", "Nov", "Dec"
552: };
553:
554: sprdate (w, str) struct when_f *w;
555: char *str;
556: {
557: char *m;
558: int h,
559: i,
560: j; /* temps to print 0's or funny strings */
561: m = "am";
562: h = w -> w_hours;
563: if (h >= 12)
564: m = "pm";
565: if (h == 0)
566: h = 12;
567: if (h > 12)
568: h -= 12;
569: i = w -> w_mins / 10;
570: j = w -> w_mins % 10; /* get those leading zeroes */
571: sprintf (str, "%2d:%d%d %2s %3s %2d, %4d", h, i, j, m, mnames[w -> w_month], w -> w_day, w -> w_year);
572: /* sprintf puts it into a string */
573: }
574:
575: prdate (zdate) struct when_f *zdate;
576: {
577: char line[DATELEN];
578:
579: sprdate (zdate, line); /* format it */
580: printf ("%s", line); /* and print it */
581: }
582:
583: /*
584: * Saves a string with malloc() and returns a pointer
585: * to where it wound up. Useful for building lists of
586: * stuff.
587: *
588: * Courtesy of Lou Salkind & Rick Spickelmier.
589: */
590:
591:
592: char *strsave (s)
593: char *s;
594: {
595: char *p;
596: extern char *malloc ();
597:
598: p = malloc (strlen (s) + 1);
599: strcpy (p, s);
600: return (p);
601: }
602:
603: /*
604: * substr(a,b) see if A is a substring of B
605: *
606: * uses: strlen.
607: */
608:
609: substr (a, b)
610: char *a;
611: char *b;
612: {
613: register char first;
614: register int length; /* length of a */
615: register int count; /* max checks */
616:
617: first = *a; /* get first */
618: length = strlen (a); /* for strncmp */
619: count = strlen (b) - length + 1; /* max checks */
620: while (count-- > 0) /* can try */
621: {
622: if (*b == first && !strncmp (a, b, length))
623: return (1); /* is a substring */
624: b++; /* on to next */
625: }
626: return (0); /* not a substring */
627: }
628:
629: /*
630: * routine to process a string and remove any
631: * nasties like control characters and escape codes.
632: */
633:
634: int strclean (p)
635: char *p;
636: {
637: if (p == (char *) NULL)
638: return 0;
639: if (*p == '\0')
640: return 0;
641: do
642: {
643: if (!isascii (*p) || iscntrl (*p))
644: *p = '_'; /* kill controls */
645: } while (*++p != '\0');
646: return (0);
647: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.