usr/src/lib/libc/port/gen/str2sig.c

   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
 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
 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
 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 }