1 /* @(#)signames.c 1.26 20/10/25 Copyright 1998-2020 J. Schilling */
2 #include <schily/mconfig.h>
3 #ifndef lint
4 static UConst char sccsid[] =
5 "@(#)signames.c 1.26 20/10/25 Copyright 1998-2020 J. Schilling";
6 #endif
7 /*
8 * Handle signal names for systems that don't have
9 * strsignal()/str2sig()/sig2str()
10 *
11 * Copyright (c) 1998-2020 J. Schilling
12 */
13 /*
14 * The contents of this file are subject to the terms of the
15 * Common Development and Distribution License, Version 1.0 only
16 * (the "License"). You may not use this file except in compliance
17 * with the License.
18 *
19 * See the file CDDL.Schily.txt in this distribution for details.
20 * A copy of the CDDL is also available via the Internet at
21 * http://www.opensource.org/licenses/cddl1.txt
22 *
23 * When distributing Covered Code, include this CDDL HEADER in each
24 * file and include the License file CDDL.Schily.txt from this distribution.
25 */
26
27 #include <schily/stdio.h>
28 #include <schily/stdlib.h>
29 #include <schily/string.h>
30 #ifdef USE_JS_BOOL /* #define USE_JS_BOOL if there is a */
31 #define BOOL JS_BOOL /* different (incompatible) BOOL in */
32 #endif /* the using code, e.g. Boune Shell */
33 #include <schily/standard.h>
34 #include <schily/signal.h>
35 #include <schily/schily.h>
36 #ifdef USE_JS_BOOL /* If in workaround mode, */
37 #undef BOOL /* revert to default BOOL */
38 #endif
39
40 #ifdef FORCE_SIGNAMES
41 #undef HAVE_STRSIGNAL
42 #undef HAVE_STR2SIG
43 #undef HAVE_SIG2STR
44 #endif
45
46 #if !(defined(HAVE_STRSIGNAL) && defined(HAVE_STR2SIG) && \
47 defined(HAVE_SIG2STR))
48
49 /*
50 * Linux uses __SIGRTMIN instead of _SIGRTMIN.
51 */
52 #ifndef _SIGRTMIN
53 #ifdef __SIGRTMIN
54 #define _SIGRTMIN __SIGRTMIN
55 #endif
56 #endif
57 #ifndef _SIGRTMAX
58 #ifdef __SIGRTMAX
59 #define _SIGRTMAX __SIGRTMAX
60 #endif
61 #endif
62
63 #if defined(__FreeBSD__) || defined(__NetBSD__)
64 #ifndef _SIGRTMIN
65 #ifdef SIGRTMIN
66 #define _SIGRTMIN SIGRTMIN
67 #endif
68 #endif
69 #ifndef _SIGRTMAX
70 #ifdef SIGRTMAX
71 #define _SIGRTMAX SIGRTMAX
72 #endif
73 #endif
74 #endif
75
76 #ifndef HAVE_STRSIGNAL
77 EXPORT char *strsignal __PR((int sig));
78 #endif
79 #ifndef HAVE_STR2SIG
80 LOCAL int stol __PR((const char *s, long *valp));
81 EXPORT int str2sig __PR((const char *s, int *sigp));
82 #endif
83 #ifndef HAVE_SIG2STR
84 EXPORT int sig2str __PR((int sig, char *s));
85 #endif
86 #ifdef _SIGRTMIN
87 LOCAL void _rtsiginit __PR((void));
88 #endif
89
90 #ifdef MAIN
main()91 main()
92 {
93 int i;
94 char *t;
95 char n[32];
96 int s;
97
98 for (i = 0; i < NSIG+6; i++) {
99 if ((t = strsignal(i)) == 0)
100 t = "NULL";
101 if (sig2str(i, n) < 0)
102 strcpy(n, "XXX");
103 if (str2sig(n, &s) < 0)
104 s = -2;
105
106 printf("SIG: %d %s (%d) %s\n", i, n, s, t);
107 }
108 }
109 #endif
110
111 /*
112 * Let "EXIT" be first, to make the shell trap(1) command work as expected.
113 */
114 LOCAL struct signames {
115 int signo;
116 char *signame;
117 char *sigtext;
118 } signames[] = {
119 { 0, "EXIT", "Unknown Signal", },
120 { 0, "NULL", "Null Signal", },
121 #ifdef SIGNULL
122 { SIGNULL, "NULL", "Null Signal", },
123 #endif
124 #ifdef SIGHUP
125 { SIGHUP, "HUP", "Hangup", },
126 #endif
127 #ifdef SIGINT
128 { SIGINT, "INT", "Interrupt", },
129 #endif
130 #ifdef SIGQUIT
131 { SIGQUIT, "QUIT", "Quit", },
132 #endif
133 #ifdef SIGILL
134 { SIGILL, "ILL", "Illegal Instruction", },
135 #endif
136 #ifdef SIGTRAP
137 { SIGTRAP, "TRAP", "Trace/Breakpoint Trap", },
138 #endif
139 #ifdef SIGABRT
140 { SIGABRT, "ABRT", "IOT trap/Abort", },
141 #endif
142 #ifdef SIGIOT
143 { SIGIOT, "IOT", "IOT trap/Abort", },
144 #endif
145 #ifdef SIGEMT
146 { SIGEMT, "EMT", "Emulation Trap", },
147 #endif
148 #ifdef SIGFPE
149 { SIGFPE, "FPE", "Arithmetic Exception", },
150 #endif
151 #ifdef SIGKILL
152 { SIGKILL, "KILL", "Killed", },
153 #endif
154 #ifdef SIGBUS
155 { SIGBUS, "BUS", "Bus Error", },
156 #endif
157 #ifdef SIGSEGV
158 { SIGSEGV, "SEGV", "Segmentation Fault", },
159 #endif
160 #ifdef SIGSYS
161 { SIGSYS, "SYS", "Bad System Call", },
162 #endif
163 #ifdef SIGPIPE
164 { SIGPIPE, "PIPE", "Broken Pipe", },
165 #endif
166 #ifdef SIGALRM
167 { SIGALRM, "ALRM", "Alarm Clock", },
168 #endif
169 #ifdef SIGTERM
170 { SIGTERM, "TERM", "Terminated", },
171 #endif
172 #ifdef SIGUSR1
173 { SIGUSR1, "USR1", "User defined Signal 1", },
174 #endif
175 #ifdef SIGUSR2
176 { SIGUSR2, "USR2", "User defined Signal 2", },
177 #endif
178 #ifdef SIGSTKFLT
179 { SIGSTKFLT, "STKFLT", "Stack Fault", },
180 #endif
181 #ifdef SIGCHLD /* POSIX name should appear first */
182 { SIGCHLD, "CHLD", "Child Status Changed", },
183 #endif
184 #ifdef SIGCLD
185 { SIGCLD, "CLD", "Child Status Changed", },
186 #endif
187 #ifdef SIGPWR
188 { SIGPWR, "PWR", "Power-Fail/Restart", },
189 #endif
190 #ifdef SIGWINCH
191 { SIGWINCH, "WINCH", "Window Size Change", },
192 #endif
193 #ifdef SIGURG
194 { SIGURG, "URG", "Urgent Socket Condition", },
195 #endif
196 #ifdef SIGPOLL
197 { SIGPOLL, "POLL", "Pollable Event", },
198 #endif
199 #ifdef SIGIO
200 { SIGIO, "IO", "Possible I/O", },
201 #endif
202 #ifdef SIGLOST
203 { SIGLOST, "LOST", "Resource Lost", },
204 #endif
205 #ifdef SIGSTOP
206 { SIGSTOP, "STOP", "Stopped (signal)", },
207 #endif
208 #ifdef SIGTSTP
209 { SIGTSTP, "TSTP", "Stopped (user)", },
210 #endif
211 #ifdef SIGCONT
212 { SIGCONT, "CONT", "Continued", },
213 #endif
214 #ifdef SIGTTIN
215 { SIGTTIN, "TTIN", "Stopped (tty input)", },
216 #endif
217 #ifdef SIGTTOU
218 { SIGTTOU, "TTOU", "Stopped (tty output)", },
219 #endif
220 #ifdef SIGVTALRM
221 { SIGVTALRM, "VTALRM", "Virtual Timer Expired", },
222 #endif
223 #ifdef SIGPROF
224 { SIGPROF, "PROF", "Profiling Timer Expired", },
225 #endif
226 #ifdef SIGXCPU
227 { SIGXCPU, "XCPU", "Cpu Time Limit Exceeded", },
228 #endif
229 #ifdef SIGXFSZ
230 { SIGXFSZ, "XFSZ", "File Size Limit Exceeded", },
231 #endif
232 #ifdef SIGWAITING
233 { SIGWAITING, "WAITING", "No runnable lwp", },
234 #endif
235 #ifdef SIGLWP
236 { SIGLWP, "LWP", "Inter-lwp signal", },
237 #endif
238 #ifdef SIGFREEZE
239 { SIGFREEZE, "FREEZE", "Checkpoint Freeze", },
240 #endif
241 #ifdef SIGTHAW
242 { SIGTHAW, "THAW", "Checkpoint Thaw", },
243 #endif
244 #ifdef SIGCANCEL
245 { SIGCANCEL, "CANCEL", "Thread Cancellation", },
246 #endif
247 #ifdef SIGXRES
248 { SIGXRES, "XRES", "Resource Control Exceeded", },
249 #endif
250 #ifdef SIGJVM1
251 { SIGJVM1, "JVM1", "Reserved for JVM 1", },
252 #endif
253 #ifdef SIGJVM2
254 { SIGJVM2, "JVM2", "Reserved for JVM 2", },
255 #endif
256 #ifdef SIGUNUSED
257 { SIGUNUSED, "UNUSED", "Unused Signal", },
258 #endif
259 #ifdef SIGDGTIMER1
260 { SIGDGTIMER1, "DGTIMER1", "DG Timer 1", },
261 #endif
262 #ifdef SIGDGTIMER2
263 { SIGDGTIMER2, "DGTIMER2", "DG Timer 2", },
264 #endif
265 #ifdef SIGDGTIMER3
266 { SIGDGTIMER3, "DGTIMER3", "DG Timer 3", },
267 #endif
268 #ifdef SIGDGTIMER4
269 { SIGDGTIMER4, "DGTIMER4", "DG Timer 4", },
270 #endif
271 #ifdef SIGDGNOTIFY
272 { SIGDGNOTIFY, "DGNOTIFY", "DG Notify", },
273 #endif
274 #ifdef SIGINFO
275 { SIGINFO, "INFO", "Information Request", },
276 #endif
277 #ifdef SIGDIL /* HP-UX */
278 { SIGDIL, "DIL", "DIL Signal", },
279 #endif
280 #ifdef SIGAIO
281 { SIGAIO, "AIO", "Asynchronous I/O", },
282 #endif
283 #ifdef SIGALRM1
284 { SIGALRM1, "ALRM1", "Scheduling - reserved", },
285 #endif
286 #ifdef SIGAPOLLO
287 { SIGAPOLLO, "APOLLO", "SIGAPOLLO", },
288 #endif
289 #ifdef SIGCPUFAIL
290 { SIGCPUFAIL, "CPUFAIL",
291 "Predictive processor deconfiguration", },
292 #endif
293 #ifdef SIGDANGER
294 { SIGDANGER, "DANGER", "System crash soon", },
295 #endif
296 #ifdef SIGERR
297 { SIGERR, "ERR", "", },
298 #endif
299 #ifdef SIGGRANT
300 { SIGGRANT, "GRANT", "Grant monitor mode", },
301 #endif
302 #ifdef SIGLAB
303 { SIGLAB, "LAB", "Security label changed", },
304 #endif
305 #ifdef SIGMIGRATE
306 { SIGMIGRATE, "MIGRATE", "Migrate process", },
307 #endif
308 #ifdef SIGMSG
309 { SIGMSG, "MSG", "Ring buffer input data", },
310 #endif
311 #ifdef SIGPHONE
312 { SIGPHONE, "PHONE", "Phone interrupt", },
313 #endif
314 #ifdef SIGPRE
315 { SIGPRE, "PRE", "Programming exception", },
316 #endif
317 #ifdef SIGRETRACT
318 { SIGRETRACT, "RETRACT", "Relinquish monitor mode", },
319 #endif
320 #ifdef SIGSAK
321 { SIGSAK, "SAK", "Secure attention key", },
322 #endif
323 #ifdef SIGSOUND
324 { SIGSOUND, "SOUND", "Sound completed", },
325 #endif
326 #ifdef SIGTINT
327 { SIGTINT, "TINT", "Interrupt", },
328 #endif
329 #ifdef SIGVIRT
330 { SIGVIRT, "VIRT", "Virtual timer alarm", },
331 #endif
332 { 0, 0, 0, },
333 };
334
335 #ifdef _SIGRTMIN
336 LOCAL struct signames rtsignames[] = {
337 #ifdef _SIGRTMIN
338 { _SIGRTMIN, "RTMIN", "First Realtime Signal", },
339 { _SIGRTMIN+1, "RTMIN+1", "Second Realtime Signal", },
340 { _SIGRTMIN+2, "RTMIN+2", "Third Realtime Signal", },
341 { _SIGRTMIN+3, "RTMIN+3", "Fourth Realtime Signal", },
342 #endif
343 #if (_SIGRTMAX - _SIGRTMIN) >= 8
344 { _SIGRTMIN+4, "RTMIN+4", "Fifth Realtime Signal", },
345 #endif
346 #if (_SIGRTMAX - _SIGRTMIN) >= 10
347 { _SIGRTMIN+5, "RTMIN+5", "Sixth Realtime Signal", },
348 #endif
349 #if (_SIGRTMAX - _SIGRTMIN) >= 12
350 { _SIGRTMIN+6, "RTMIN+6", "Seventh Realtime Signal", },
351 #endif
352 #if (_SIGRTMAX - _SIGRTMIN) >= 14
353 { _SIGRTMIN+7, "RTMIN+7", "Eighth Realtime Signal", },
354 #endif
355 #if (_SIGRTMAX - _SIGRTMIN) >= 16
356 { _SIGRTMIN+8, "RTMIN+8", "Nint Realtime Signal", },
357 #endif
358 #if (_SIGRTMAX - _SIGRTMIN) >= 18
359 { _SIGRTMIN+9, "RTMIN+9", "Tenth Realtime Signal", },
360 #endif
361 #if (_SIGRTMAX - _SIGRTMIN) >= 20
362 { _SIGRTMIN+10, "RTMIN+10", "Eleventh Realtime Signal", },
363 #endif
364 #if (_SIGRTMAX - _SIGRTMIN) >= 22
365 { _SIGRTMIN+11, "RTMIN+11", "Twelfth Realtime Signal", },
366 #endif
367 #if (_SIGRTMAX - _SIGRTMIN) >= 24
368 { _SIGRTMIN+12, "RTMIN+12", "Thirteenth Realtime Signal", },
369 #endif
370 #if (_SIGRTMAX - _SIGRTMIN) >= 26
371 { _SIGRTMIN+13, "RTMIN+13", "Fourteenth Realtime Signal", },
372 #endif
373 #if (_SIGRTMAX - _SIGRTMIN) >= 28
374 { _SIGRTMIN+14, "RTMIN+14", "Fifteenth Realtime Signal", },
375 #endif
376 #if (_SIGRTMAX - _SIGRTMIN) >= 30
377 { _SIGRTMIN+15, "RTMIN+15", "Sixteenth Realtime Signal", },
378 #endif
379 #if (_SIGRTMAX - _SIGRTMIN) >= 32
380 { _SIGRTMIN+16, "RTMIN+16", "Seventeenth Realtime Signal", },
381 #endif
382 #if (_SIGRTMAX - _SIGRTMIN) >= 34
383 { _SIGRTMIN+17, "RTMIN+17", "Eighteenth Realtime Signal", },
384 #endif
385 #if (_SIGRTMAX - _SIGRTMIN) >= 36
386 { _SIGRTMIN+18, "RTMIN+18", "Nineteenth Realtime Signal", },
387 #endif
388 #if (_SIGRTMAX - _SIGRTMIN) >= 38
389 { _SIGRTMIN+19, "RTMIN+19", "Twentieth Realtime Signal", },
390 #endif
391 #if (_SIGRTMAX - _SIGRTMIN) >= 40
392 { _SIGRTMIN+20, "RTMIN+20", "Twenty-first Realtime Signal", },
393 #endif
394 #if (_SIGRTMAX - _SIGRTMIN) >= 42
395 { _SIGRTMIN+21, "RTMIN+21", "Twenty-second Realtime Signal", },
396 #endif
397 #if (_SIGRTMAX - _SIGRTMIN) >= 44
398 { _SIGRTMIN+22, "RTMIN+22", "Twenty-third Realtime Signal", },
399 #endif
400 #if (_SIGRTMAX - _SIGRTMIN) >= 46
401 { _SIGRTMIN+23, "RTMIN+23", "Twenty-fourth Realtime Signal", },
402 #endif
403 #if (_SIGRTMAX - _SIGRTMIN) >= 48
404 { _SIGRTMIN+24, "RTMIN+24", "Twenty-fifth Realtime Signal", },
405 #endif
406 #if (_SIGRTMAX - _SIGRTMIN) >= 50
407 { _SIGRTMIN+25, "RTMIN+25", "Twenty-sixth Realtime Signal", },
408 #endif
409 #if (_SIGRTMAX - _SIGRTMIN) >= 52
410 { _SIGRTMIN+26, "RTMIN+26", "Twenty-seventh Realtime Signal", },
411 #endif
412 #if (_SIGRTMAX - _SIGRTMIN) >= 54
413 { _SIGRTMIN+27, "RTMIN+27", "Twenty-eighth Realtime Signal", },
414 #endif
415 #if (_SIGRTMAX - _SIGRTMIN) >= 56
416 { _SIGRTMIN+28, "RTMIN+28", "Twenty-ninth Realtime Signal", },
417 #endif
418 #if (_SIGRTMAX - _SIGRTMIN) >= 58
419 { _SIGRTMIN+29, "RTMIN+29", "Thirtieth Realtime Signal", },
420 #endif
421 #if (_SIGRTMAX - _SIGRTMIN) >= 60
422 { _SIGRTMIN+30, "RTMIN+30", "Thirty-firsth Realtime Signal", },
423 #endif
424 #if (_SIGRTMAX - _SIGRTMIN) >= 62
425 { _SIGRTMIN+31, "RTMIN+31", "Thirty-second Realtime Signal", },
426 #endif
427 #if (_SIGRTMAX - _SIGRTMIN) >= 63
428 { _SIGRTMAX-31, "RTMAX-31", "Thirty-second Last Realtime Signal", },
429 #endif
430 #if (_SIGRTMAX - _SIGRTMIN) >= 61
431 { _SIGRTMAX-30, "RTMAX-30", "Thirty-firsth Last Realtime Signal", },
432 #endif
433 #if (_SIGRTMAX - _SIGRTMIN) >= 59
434 { _SIGRTMAX-29, "RTMAX-29", "Thirtieth Last Realtime Signal", },
435 #endif
436 #if (_SIGRTMAX - _SIGRTMIN) >= 57
437 { _SIGRTMAX-28, "RTMAX-28", "Twenty-ninth Last Realtime Signal", },
438 #endif
439 #if (_SIGRTMAX - _SIGRTMIN) >= 55
440 { _SIGRTMAX-27, "RTMAX-27", "Twenty-eighth Last Realtime Signal", },
441 #endif
442 #if (_SIGRTMAX - _SIGRTMIN) >= 53
443 { _SIGRTMAX-26, "RTMAX-26",
444 "Twenty-seventh Last Realtime Signal", },
445 #endif
446 #if (_SIGRTMAX - _SIGRTMIN) >= 51
447 { _SIGRTMAX-25, "RTMAX-25", "Twenty-sixth Last Realtime Signal", },
448 #endif
449 #if (_SIGRTMAX - _SIGRTMIN) >= 49
450 { _SIGRTMAX-24, "RTMAX-24", "Twenty-fifth Last Realtime Signal", },
451 #endif
452 #if (_SIGRTMAX - _SIGRTMIN) >= 47
453 { _SIGRTMAX-23, "RTMAX-23", "Twenty-fourth Last Realtime Signal", },
454 #endif
455 #if (_SIGRTMAX - _SIGRTMIN) >= 45
456 { _SIGRTMAX-22, "RTMAX-22", "Twenty-third Last Realtime Signal", },
457 #endif
458 #if (_SIGRTMAX - _SIGRTMIN) >= 43
459 { _SIGRTMAX-21, "RTMAX-21", "Twenty-second Last Realtime Signal", },
460 #endif
461 #if (_SIGRTMAX - _SIGRTMIN) >= 41
462 { _SIGRTMAX-20, "RTMAX-20", "Twenty-first Last Realtime Signal", },
463 #endif
464 #if (_SIGRTMAX - _SIGRTMIN) >= 39
465 { _SIGRTMAX-19, "RTMAX-19", "Twentieth Last Realtime Signal", },
466 #endif
467 #if (_SIGRTMAX - _SIGRTMIN) >= 37
468 { _SIGRTMAX-18, "RTMAX-18", "Nineteenth Last Realtime Signal", },
469 #endif
470 #if (_SIGRTMAX - _SIGRTMIN) >= 35
471 { _SIGRTMAX-17, "RTMAX-17", "Eighteenth Last Realtime Signal", },
472 #endif
473 #if (_SIGRTMAX - _SIGRTMIN) >= 33
474 { _SIGRTMAX-16, "RTMAX-16", "Seventeenth Last Realtime Signal", },
475 #endif
476 #if (_SIGRTMAX - _SIGRTMIN) >= 31
477 { _SIGRTMAX-15, "RTMAX-15", "Sixteenth Last Realtime Signal", },
478 #endif
479 #if (_SIGRTMAX - _SIGRTMIN) >= 29
480 { _SIGRTMAX-14, "RTMAX-14", "Fifteenth Last Realtime Signal", },
481 #endif
482 #if (_SIGRTMAX - _SIGRTMIN) >= 27
483 { _SIGRTMAX-13, "RTMAX-13", "Fourteenth Last Realtime Signal", },
484 #endif
485 #if (_SIGRTMAX - _SIGRTMIN) >= 25
486 { _SIGRTMAX-12, "RTMAX-12", "Thirteenth Last Realtime Signal", },
487 #endif
488 #if (_SIGRTMAX - _SIGRTMIN) >= 23
489 { _SIGRTMAX-11, "RTMAX-11", "Twelfth Last Realtime Signal", },
490 #endif
491 #if (_SIGRTMAX - _SIGRTMIN) >= 21
492 { _SIGRTMAX-10, "RTMAX-10", "Eleventh Last Realtime Signal", },
493 #endif
494 #if (_SIGRTMAX - _SIGRTMIN) >= 19
495 { _SIGRTMAX-9, "RTMAX-9", "Tenth Last Realtime Signal", },
496 #endif
497 #if (_SIGRTMAX - _SIGRTMIN) >= 17
498 { _SIGRTMAX-8, "RTMAX-8", "Nint Last Realtime Signal", },
499 #endif
500 #if (_SIGRTMAX - _SIGRTMIN) >= 15
501 { _SIGRTMAX-7, "RTMAX-7", "Eighth Last Realtime Signal", },
502 #endif
503 #if (_SIGRTMAX - _SIGRTMIN) >= 13
504 { _SIGRTMAX-6, "RTMAX-6", "Seventh Last Realtime Signal", },
505 #endif
506 #if (_SIGRTMAX - _SIGRTMIN) >= 11
507 { _SIGRTMAX-5, "RTMAX-5", "Sixth Last Realtime Signal", },
508 #endif
509 #if (_SIGRTMAX - _SIGRTMIN) >= 9
510 { _SIGRTMAX-4, "RTMAX-4", "Fifth Last Realtime Signal", },
511 #endif
512 #ifdef _SIGRTMAX
513 { _SIGRTMAX-3, "RTMAX-3", "Fourth Last Realtime Signal", },
514 { _SIGRTMAX-2, "RTMAX-2", "Third Last Realtime Signal", },
515 { _SIGRTMAX-1, "RTMAX-1", "Second Last Realtime Signal", },
516 { _SIGRTMAX, "RTMAX", "Last Realtime Signal", },
517 #endif
518 { 0, 0, 0, },
519 };
520
521 LOCAL int rtmin;
522 LOCAL int rtmax;
523
524 /*
525 * Make the numbers in rtsignames match the current numbers.
526 * This is needed as SIGRTMIN and SIGRTMAX are macros that call
527 * an interface that may not return the same numbers as
528 * _SIGRTMIN and _SIGRTMAX.
529 */
530 LOCAL void
_rtsiginit()531 _rtsiginit()
532 {
533 register int i;
534 int nmed;
535 int max;
536
537 rtmin = SIGRTMIN;
538 rtmax = SIGRTMAX;
539 nmed = (rtmin + rtmax) / 2;
540
541 for (i = 0; rtsignames[i].signame; i++)
542 ;
543 max = i-1;
544
545 for (i = 0; rtsignames[i].signame; i++) {
546 rtsignames[i].signo = 0;
547 if ((rtmin + i) <= nmed) {
548 rtsignames[i].signo = rtmin + i;
549 } else if ((rtmax - max + i) > nmed) {
550 rtsignames[i].signo = (rtmax - max) + i;
551 }
552 }
553 }
554 #endif /* _SIGRTMIN */
555
556 #ifndef HAVE_STRSIGNAL
557 /*
558 * Convert the signal number into the signal description text.
559 */
560 EXPORT char *
strsignal(sig)561 strsignal(sig)
562 int sig;
563 {
564 register int i;
565 struct signames *sn = signames;
566
567 #ifdef _SIGRTMIN
568 if (rtmin == 0)
569 _rtsiginit();
570
571 if (sig >= rtmin && sig <= rtmax)
572 sn = rtsignames;
573 #endif
574 for (i = 0; sn[i].signame; i++) {
575 if (sn[i].signo == sig)
576 return (sn[i].sigtext);
577 }
578 return (NULL);
579 }
580
581 #endif
582
583 #ifndef HAVE_STR2SIG
584 LOCAL int
stol(s,valp)585 stol(s, valp)
586 const char *s;
587 long *valp;
588 {
589 long val;
590 #ifdef HAVE_STRTOL
591 char *p;
592
593 val = strtol(s, &p, 10);
594 if (*p != '\0')
595 return (-1);
596 #else
597 if (*astolb(s, &val, 10) != '\0')
598 return (-1);
599 #endif
600 *valp = val;
601 return (0);
602 }
603
604 /*
605 * Convert "HUP" or 1 into SIGHUP and similar for other signals.
606 */
607 EXPORT int
str2sig(s,sigp)608 str2sig(s, sigp)
609 const char *s;
610 int *sigp;
611 {
612 register int i;
613 long val;
614 struct signames *sn = signames;
615
616 #ifdef _SIGRTMIN
617 if (rtmin == 0)
618 _rtsiginit();
619 #endif
620 if (*s >= '0' && *s <= '9') {
621 if (stol(s, &val) != 0)
622 return (-1);
623
624 #ifdef _SIGRTMIN
625 if (val >= rtmin && val <= rtmax)
626 sn = rtsignames;
627 #endif
628 for (i = 0; sn[i].signame; i++) {
629 if (sn[i].signo == val) {
630 *sigp = val;
631 return (0);
632 }
633 }
634 return (-1);
635 }
636 do {
637 for (i = 0; sn[i].signame; i++) {
638 if (strcmp(s, sn[i].signame) == 0) {
639 *sigp = sn[i].signo;
640 return (0);
641 }
642 }
643 #ifdef _SIGRTMIN
644 } while (sn == signames && (sn = rtsignames));
645 #else
646 } while (0);
647 #endif
648 #ifdef _SIGRTMIN
649 if (strncmp(s, "RTMIN+", 6) == 0) {
650 if (stol(s+5, &val) != 0)
651 return (-1);
652 val += SIGRTMIN;
653 } else if (strncmp(s, "RTMAX-", 6) == 0) {
654 if (stol(s+5, &val) != 0)
655 return (-1);
656 val += SIGRTMAX;
657 } else {
658 return (-1);
659 }
660 sn = rtsignames;
661 for (i = 0; sn[i].signame; i++) {
662 if (sn[i].signo == val) {
663 *sigp = val;
664 return (0);
665 }
666 }
667 #endif
668
669 return (-1);
670 }
671 #endif
672
673 #ifndef HAVE_SIG2STR
674 /*
675 * Convert signal numbers into the signal names (e.g. 1 -> "HUP").
676 */
677 EXPORT int
sig2str(sig,s)678 sig2str(sig, s)
679 int sig;
680 char *s;
681 {
682 register int i;
683 struct signames *sn = signames;
684
685 #ifdef _SIGRTMIN
686 if (rtmin == 0)
687 _rtsiginit();
688
689 if (sig >= rtmin && sig <= rtmax)
690 sn = rtsignames;
691 #endif
692 for (i = 0; sn[i].signame; i++) {
693 if (sn[i].signo == sig) {
694 strcpy(s, sn[i].signame);
695 return (0);
696 }
697 }
698 return (-1);
699 }
700 #endif
701
702 #endif /* ! (HAVE_STRSIGNAL && HAVE_STR2SIG && HAVE_SIG2STR) */
703