xref: /illumos-gate/usr/src/lib/libc/port/gen/str2sig.c (revision 19d32b9a)
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 (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  * Copyright (c) 2014, Joyent, Inc.  All rights reserved.
26  */
27 
28 /*	Copyright (c) 1988 AT&T	*/
29 /*	  All Rights Reserved  	*/
30 
31 #include "lint.h"
32 #include <string.h>
33 #include <stdlib.h>
34 #include <signal.h>
35 #include <sys/types.h>
36 #include <errno.h>
37 
38 typedef struct signame {
39 	const char *sigstr;
40 	const int   signum;
41 } signame_t;
42 
43 static signame_t signames[] = {
44 	{ "EXIT",	0 },
45 	{ "HUP",	SIGHUP },
46 	{ "INT",	SIGINT },
47 	{ "QUIT",	SIGQUIT },
48 	{ "ILL",	SIGILL },
49 	{ "TRAP",	SIGTRAP },
50 	{ "ABRT",	SIGABRT },
51 	{ "IOT",	SIGIOT },
52 	{ "EMT",	SIGEMT },
53 	{ "FPE",	SIGFPE },
54 	{ "KILL",	SIGKILL },
55 	{ "BUS",	SIGBUS },
56 	{ "SEGV",	SIGSEGV },
57 	{ "SYS",	SIGSYS },
58 	{ "PIPE",	SIGPIPE },
59 	{ "ALRM",	SIGALRM },
60 	{ "TERM",	SIGTERM },
61 	{ "USR1",	SIGUSR1 },
62 	{ "USR2",	SIGUSR2 },
63 	{ "CLD",	SIGCLD },
64 	{ "CHLD",	SIGCHLD },
65 	{ "PWR",	SIGPWR },
66 	{ "WINCH",	SIGWINCH },
67 	{ "URG",	SIGURG },
68 	{ "POLL",	SIGPOLL },
69 	{ "IO",		SIGPOLL },
70 	{ "STOP",	SIGSTOP },
71 	{ "TSTP",	SIGTSTP },
72 	{ "CONT",	SIGCONT },
73 	{ "TTIN",	SIGTTIN },
74 	{ "TTOU",	SIGTTOU },
75 	{ "VTALRM",	SIGVTALRM },
76 	{ "PROF",	SIGPROF },
77 	{ "XCPU",	SIGXCPU },
78 	{ "XFSZ",	SIGXFSZ },
79 	{ "WAITING",	SIGWAITING },
80 	{ "LWP",	SIGLWP },
81 	{ "FREEZE",	SIGFREEZE },
82 	{ "THAW",	SIGTHAW },
83 	{ "CANCEL",	SIGCANCEL },
84 	{ "LOST",	SIGLOST },
85 	{ "XRES", 	SIGXRES },
86 	{ "JVM1",	SIGJVM1 },
87 	{ "JVM2",	SIGJVM2 },
88 	{ "INFO",	SIGINFO },
89 	{ "RTMIN",	_SIGRTMIN },
90 	{ "RTMIN+1",	_SIGRTMIN+1 },
91 	{ "RTMIN+2",	_SIGRTMIN+2 },
92 	{ "RTMIN+3",	_SIGRTMIN+3 },
93 	{ "RTMIN+4",	_SIGRTMIN+4 },
94 	{ "RTMIN+5",	_SIGRTMIN+5 },
95 	{ "RTMIN+6",	_SIGRTMIN+6 },
96 	{ "RTMIN+7",	_SIGRTMIN+7 },
97 	{ "RTMIN+8",	_SIGRTMIN+8 },
98 	{ "RTMIN+9",	_SIGRTMIN+9 },
99 	{ "RTMIN+10",	_SIGRTMIN+10 },
100 	{ "RTMIN+11",	_SIGRTMIN+11 },
101 	{ "RTMIN+12",	_SIGRTMIN+12 },
102 	{ "RTMIN+13",	_SIGRTMIN+13 },
103 	{ "RTMIN+14",	_SIGRTMIN+14 },
104 	{ "RTMIN+15",	_SIGRTMIN+15 },
105 	{ "RTMAX-15",	_SIGRTMAX-15 },
106 	{ "RTMAX-14",	_SIGRTMAX-14 },
107 	{ "RTMAX-13",	_SIGRTMAX-13 },
108 	{ "RTMAX-12",	_SIGRTMAX-12 },
109 	{ "RTMAX-11",	_SIGRTMAX-11 },
110 	{ "RTMAX-10",	_SIGRTMAX-10 },
111 	{ "RTMAX-9",	_SIGRTMAX-9 },
112 	{ "RTMAX-8",	_SIGRTMAX-8 },
113 	{ "RTMAX-7",	_SIGRTMAX-7 },
114 	{ "RTMAX-6",	_SIGRTMAX-6 },
115 	{ "RTMAX-5",	_SIGRTMAX-5 },
116 	{ "RTMAX-4",	_SIGRTMAX-4 },
117 	{ "RTMAX-3",	_SIGRTMAX-3 },
118 	{ "RTMAX-2",	_SIGRTMAX-2 },
119 	{ "RTMAX-1",	_SIGRTMAX-1 },
120 	{ "RTMAX",	_SIGRTMAX },
121 };
122 
123 #define	SIGCNT	(sizeof (signames) / sizeof (struct signame))
124 
125 static int	str2long(const char *, long *);
126 
127 static int
str2long(const char * p,long * val)128 str2long(const char *p, long *val)
129 {
130 	char *q;
131 	int error;
132 	int saved_errno = errno;
133 
134 	errno = 0;
135 	*val = strtol(p, &q, 10);
136 
137 	error = ((errno != 0 || q == p || *q != '\0') ? -1 : 0);
138 	errno = saved_errno;
139 
140 	return (error);
141 }
142 
143 int
str2sig(const char * s,int * sigp)144 str2sig(const char *s, int *sigp)
145 {
146 	const struct signame *sp;
147 
148 	if (*s >= '0' && *s <= '9') {
149 		long val;
150 
151 		if (str2long(s, &val) == -1)
152 			return (-1);
153 
154 		for (sp = signames; sp < &signames[SIGCNT]; sp++) {
155 			if (sp->signum == val) {
156 				*sigp = sp->signum;
157 				return (0);
158 			}
159 		}
160 		return (-1);
161 	} else {
162 		for (sp = signames; sp < &signames[SIGCNT]; sp++) {
163 			if (strcmp(sp->sigstr, s) == 0) {
164 				*sigp = sp->signum;
165 				return (0);
166 			}
167 		}
168 		return (-1);
169 	}
170 }
171 
172 int
sig2str(int i,char * s)173 sig2str(int i, char *s)
174 {
175 	const struct signame *sp;
176 
177 	for (sp = signames; sp < &signames[SIGCNT]; sp++) {
178 		if (sp->signum == i) {
179 			(void) strcpy(s, sp->sigstr);
180 			return (0);
181 		}
182 	}
183 	return (-1);
184 }
185