![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kill.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin|
Return to kill.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin |
1.1 root 1: static char _version[]="kill version 2.0";
2: /*
3: * kill -- send a signal to a process
4: */
5: #include <signal.h>
6: #include <ctype.h>
7: #include <errno.h>
8: #include <stdio.h>
9:
10: #define NOTREACHED return
11:
12: int err = 0;
13:
14: main( argc, argv)
15: register char **argv;
16: {
17: register pid;
18: char **getsignal( );
19: extern char *sys_errlist[];
20: extern errno;
21: static int sig = SIGTERM;
22:
23: /*
24: * Fetch the signal we are going to send, from the command line.
25: */
26: argv = getsignal(argv, &sig);
27:
28:
29: if (*argv == NULL) {
30: fprintf(stderr, "Usage: kill [ signal ] pid ...\n");
31: exit(1);
32: }
33:
34: /*
35: * If we are sending this signal to our own process group
36: * leader, we don't want to receive this signal here.
37: */
38: signal(sig, SIG_IGN);
39:
40:
41: do {
42: if (isdigit(**argv)==0 && **argv!='-') {
43: error("\"%s\" is not a process id", *argv);
44: continue;
45: }
46: pid = atoi(*argv);
47: if (kill(pid, sig)) {
48: if (errno == EINVAL)
49: fatal("signal %d is invalid", sig);
50: error("process %d: %s", pid, sys_errlist[errno]);
51: continue;
52: }
53: } while (*++argv);
54: exit(err);
55: }
56:
57:
58: /*
59: * Attempt to extract a signal number from argv[].
60: * Puts any signal number it finds in *sigp, and then returns
61: * the next argument in argv[].
62: */
63: char **
64: getsignal( av, sigp)
65: register char **av;
66: int *sigp;
67: {
68: if ((++av)[0] == NULL)
69: return (av);
70: if (isdigit( av[0][0]))
71: return (av);
72: /*
73: * Do we have an explicit signal number?
74: */
75: if (av[0][0] == '-') {
76: ++av[0]; /* Skip the '-'. */
77: if (isdigit( av[0][0])) {
78: /*
79: * Convert the signal number to an integer and return.
80: */
81: *sigp = atoi( &av[0][0]);
82: return (++av);
83: }
84: }
85:
86: /*
87: * The signal must be symbolic.
88: */
89: uppercase( av[0]);
90: /*
91: * Strip off an optional leading "SIG".
92: */
93: if (strncmp( av[0], "SIG", 3) == 0)
94: *av += 3;
95: /*
96: * Walk through the signal names looking for a match.
97: */
98: for (*sigp = 1; notsame( *sigp, av[0]); ++*sigp) {
99: /* Do nothing. */
100: }
101:
102: /*
103: * Bump argv to next argument.
104: */
105: return (++av);
106: }
107:
108:
109: /*
110: * Returns 0 only if 'sig' has symbolic name 'name'.
111: */
112: notsame(sig, name)
113: char *name;
114: {
115: static char *names[] = {
116: #ifdef _I386
117: 0,
118: "HUP", "INT", "QUIT", "ILL",
119: "TRAP", "IOT", "EMT", "FPE",
120: "KILL", "BUS", "SEGV", "SYS",
121: "PIPE", "ALRM", "TERM", "USR1",
122: "USR2", "CHLD", "PWR", "WINCH",
123: "", "POLL",
124: NULL
125: #else /* _I386 */
126: 0,
127: "HUP", "INT", "QUIT", "ALRM",
128: "TERM", "REST", "SYS", "PIPE",
129: "KILL", "TRAP", "SEGV", "ILL",
130: "IOT", "EMT", "FPE", "BUS",
131: NULL
132: #endif /* _I386 */
133: };
134:
135: if (sig>NSIG || names[sig]==NULL) {
136: fatal( "no such signal SIG%s", name);
137: }
138:
139: #ifdef _I386
140: /*
141: * SIGABRT and SIGCLD share numbers with other signals.
142: */
143: if ( SIGABRT == sig ) {
144: if ( 0 == strcmp( "ABRT", name ) ) {
145: return (0); /* Match! */
146: }
147: }
148: if ( SIGCLD == sig ) {
149: if ( 0 == strcmp( "CLD", name ) ) {
150: return (0); /* Match! */
151: }
152: }
153: #endif /* _I386 */
154:
155: return (strcmp( names[sig], name));
156: }
157:
158:
159: uppercase(s)
160: register char *s;
161: {
162: for (; *s; ++s)
163: if (islower( *s))
164: *s &= ~040;
165: }
166:
167:
168: error(arg0)
169: char *arg0;
170: {
171: fprintf( stderr, "kill: %r\n", &arg0);
172: err = 1;
173: }
174:
175:
176: fatal(arg0)
177: char *arg0;
178: {
179: fprintf( stderr, "kill: %r\n", &arg0);
180: exit(1);
181: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.