extern int
operand2sig (char const *operand, char *signame)
{
int signum;
if (ISDIGIT (*operand))
{
/* Note we don't put a limit on the maximum value passed,
because we're checking shell $? values here, and ksh for
example will add 256 to the signal value, thus being wider
than the number of WEXITSTATUS bits.
We could validate that values were not above say
((WEXITSTATUS (~0) << 1) + 1), which would cater for ksh.
But some shells may use other adjustments in future to be
(forward) compatible with systems that support
wider exit status values as discussed at
http://austingroupbugs.net/view.php?id=947 */
char *endp;
long int l = (errno = 0, strtol (operand, &endp, 10));
int i = l;
signum = (operand == endp || *endp || errno || i != l ? -1 : i);
if (signum != -1)
{
/* Note AIX uses a different bit pattern for status returned
from shell and wait(), so we can't use WTERMSIG etc. here.
Also ksh returns 0xFF + signal number. */
signum &= signum >= 0xFF ? 0xFF : 0x7F;
}
}
else
{
/* Convert signal to upper case in the C locale, not in the
current locale. Don't assume ASCII; it might be EBCDIC. */
char *upcased = xstrdup (operand);
char *p;
for (p = upcased; *p; p++)
if (strchr ("abcdefghijklmnopqrstuvwxyz", *p))
*p += 'A' - 'a';
/* Look for the signal name, possibly prefixed by "SIG",
and possibly lowercased. */
if (!(str2sig (upcased, &signum) == 0
|| (upcased[0] == 'S' && upcased[1] == 'I' && upcased[2] == 'G'
&& str2sig (upcased + 3, &signum) == 0)))
signum = -1;
free (upcased);
}
if (signum < 0 || sig2str (signum, signame) != 0)
{
error (0, 0, _("%s: invalid signal"), quote (operand));
return -1;
}
return signum;
}
static int
ret_mask(sigset_t *mask, int arg_number)
{
// TODO;
NODE *tmp, *array, *elm, *value;
int i;
int sig;
array = (NODE *) get_array_argument(arg_number, FALSE);
if ( array != NULL ) {
#if 0
for (i = 0; i < array->array_size; i++) {
for (elm = array->var_array[i]; elm != NULL; elm = elm->ahnext) {
name = elm->hname;
force_string(name);
sig = str2sig(name->stptr);
if (sig) {
value = elm->hvalue;
force_string(value);
if (value->stptr[0] != '0' && value->stptr[0] != '\0') {
sigaddset(mask, sig);
}
}
}
}
#endif
} else {
tmp = (NODE *) get_scalar_argument(arg_number, FALSE);
}
return 0;
}
extern int
operand2sig (char const *operand, char *signame)
{
int signum;
if (ISDIGIT (*operand))
{
char *endp;
long int l = (errno = 0, strtol (operand, &endp, 10));
int i = l;
signum = (operand == endp || *endp || errno || i != l ? -1
: WIFSIGNALED (i) ? WTERMSIG (i) : i);
}
else
{
/* Convert signal to upper case in the C locale, not in the
current locale. Don't assume ASCII; it might be EBCDIC. */
char *upcased = xstrdup (operand);
char *p;
for (p = upcased; *p; p++)
if (strchr ("abcdefghijklmnopqrstuvwxyz", *p))
*p += 'A' - 'a';
/* Look for the signal name, possibly prefixed by "SIG",
and possibly lowercased. */
if (!(str2sig (upcased, &signum) == 0
|| (upcased[0] == 'S' && upcased[1] == 'I' && upcased[2] == 'G'
&& str2sig (upcased + 3, &signum) == 0)))
signum = -1;
free (upcased);
}
if (signum < 0 || sig2str (signum, signame) != 0)
{
error (0, 0, _("%s: invalid signal"), operand);
return -1;
}
return signum;
}
static int
get_signo(NODE *tmp)
{
int sig;
force_string(tmp);
sig = str2sig(tmp->stptr);
if (sig == 0) {
sig = num2sig((int) force_number(tmp));
}
if (sig == 0) {
force_string(tmp);
fatal(_("Signal `%s' is not defined"), tmp->stptr);
}
return sig;
}
int main(int argc, char** argv)
{
int pid = -1;
int i;
if (argc <= 1)
return -1;
for (i = 1; i < argc; ++i) {
if (i == 1) {
pid = atoi(argv[i]);
continue;
}
int sig = str2sig(argv[i]);
send_sig(pid, sig);
}
return 0;
}
static int
ana_mask(sigset_t *mask, int arg_number)
{
NODE *tmp, *array, *elm, *name, *value;
int i;
int sig;
sigemptyset(mask);
array = (NODE *) get_array_argument(arg_number, FALSE);
if ( array != NULL ) {
for (i = 0; i < array->array_size; i++) {
for (elm = array->var_array[i]; elm != NULL; elm = elm->ahnext) {
sig = str2sig(elm->hname);
if (sig) {
value = elm->hvalue;
force_string(value);
if (value->stptr[0] != '0' && value->stptr[0] != '\0') {
sigaddset(mask, sig);
}
}
}
}
} else {
tmp = (NODE *) get_scalar_argument(arg_number, FALSE);
if (strcmp(tmp->stptr, "@all") == 0) { // toupper TODO @FILL
sigfillset(mask);
} else if (strcmp(tmp->stptr, "@empty") == 0) { // TODO
sigemptyset(mask);
} else {
}
}
return 0;
}
int main (int argc, char **argv)
{
int c;
int sig;
int s_flag;
int l_flag;
int err_flag;
char buf [SIG2STR_MAX];
pid_t pid;
s_flag= 0;
l_flag =0;
err_flag = 0;
opterr = 0;
while ((c = getopt (argc, argv, "ls:")) != EOF) {
switch (c) {
case 'l':
if (s_flag)
err_flag++;
l_flag++;
break;
case 's':
if ((l_flag) || (s_flag))
err_flag++;
s_flag++;
snprintf (buf, SIG2STR_MAX - 1, "%s", optarg);
break;
default:
err_flag++;
break;
}
}
if ((!l_flag) && (!s_flag))
err_flag++;
if (((s_flag) && (optind == argc)) || ((l_flag) && (optind != argc)))
err_flag++;
if (err_flag) {
log_msg ("Usage: ssp_kill -l");
log_msg (" ssp_kill -s signal PID");
exit (1);
}
if (l_flag) {
for (sig = 0; sig <= MAXSIG; sig++) {
sig2str (sig, buf);
printf ("%s ", buf);
}
printf ("\n");
}
else {
if (str2sig (buf, &sig) == -1)
err_quit ("ssp_kill: %s: No such signal", buf);
for (; optind < argc; optind++) {
pid = atoi (argv [optind]);
if (kill (pid, sig) == -1)
err_ret ("Can't kill PID %d", pid);
}
}
return (0);
}
int
main(int argc, char *argv[])
{
int c;
int lflag, dflag, sflag, pflag;
int tflag, rflag, eflag, iflag, qflag;
pri_t rtpri;
long tqntm;
long res;
int tqsig;
char *idtypnm;
idtype_t idtype;
int idargc;
uint_t cflags;
(void) strlcpy(cmdpath, argv[0], MAXPATHLEN);
(void) strlcpy(basenm, basename(argv[0]), BASENMSZ);
lflag = dflag = sflag = pflag = 0;
tflag = rflag = eflag = iflag = qflag = 0;
while ((c = getopt(argc, argv, "ldsp:t:r:q:ec:i:")) != -1) {
switch (c) {
case 'l':
lflag++;
break;
case 'd':
dflag++;
break;
case 's':
sflag++;
break;
case 'p':
pflag++;
rtpri = (pri_t)str2num(optarg, SHRT_MIN, SHRT_MAX);
if (errno)
fatalerr("%s: Specified real time priority %s"
" out of configured range\n",
basenm, optarg);
break;
case 't':
tflag++;
tqntm = str2num(optarg, 1, INT_MAX);
if (errno)
fatalerr("%s: Invalid time quantum specified;"
" time quantum must be positive\n", basenm);
break;
case 'r':
rflag++;
res = str2num(optarg, 1, 1000000000);
if (errno)
fatalerr("%s: Invalid resolution specified;"
" resolution must be between"
" 1 and 1,000,000,000\n", basenm);
break;
case 'q':
qflag++;
if (str2sig(optarg, &tqsig) != 0)
fatalerr("%s: Invalid real time quantum signal"
" specified\n", basenm);
break;
case 'e':
eflag++;
break;
case 'c':
if (strcmp(optarg, "RT") != 0)
fatalerr("error: %s executed for %s class, %s"
" is actually sub-command for RT class\n",
cmdpath, optarg, cmdpath);
break;
case 'i':
iflag++;
idtypnm = optarg;
break;
case '?':
fatalerr(usage);
default:
break;
}
}
if (lflag) {
if (dflag || sflag || pflag || tflag || rflag || eflag ||
iflag || qflag)
fatalerr(usage);
print_rtinfo();
} else if (dflag) {
if (lflag || sflag || pflag || tflag || rflag || eflag || qflag)
fatalerr(usage);
return (print_rtprocs());
} else if (sflag) {
if (lflag || dflag || eflag)
fatalerr(usage);
if (iflag) {
if (str2idtyp(idtypnm, &idtype) == -1)
fatalerr("%s: Bad idtype %s\n", basenm,
idtypnm);
} else {
idtype = P_PID;
}
cflags = (pflag ? RT_DOPRI : 0);
if (tflag)
cflags |= RT_DOTQ;
if (rflag == 0)
res = 1000;
if (optind < argc)
idargc = argc - optind;
else
idargc = 0;
if (qflag)
cflags |= RT_DOSIG;
return (set_rtprocs(idtype, idargc, &argv[optind], cflags,
rtpri, tqntm, res, tqsig));
} else if (eflag) {
if (lflag || dflag || sflag || iflag)
fatalerr(usage);
cflags = (pflag ? RT_DOPRI : 0);
if (tflag)
cflags |= RT_DOTQ;
if (rflag == 0)
res = 1000;
if (qflag)
cflags |= RT_DOSIG;
exec_rtcmd(&argv[optind], cflags, rtpri, tqntm, res, tqsig);
} else {
fatalerr(usage);
}
return (0);
}
