cmd/ipcrm/ipcrm.c

	ipcrm.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*  Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*    All Rights Reserved   */


#pragma ident   "%Z%%M% %I% %E% SMI"

/*
 * ipcrm - IPC remove
 *
 * Remove specified message queues,
 * semaphore sets and shared memory ids.
 */

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <errno.h>
#include <sys/ipc_impl.h>
#include <zone.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <locale.h>

#define NULL_MSG    ((struct msqid_ds *)NULL)
#define NULL_SEM    ((struct semid_ds *)NULL)
#define NULL_SHM    ((struct shmid_ds *)NULL)

#define USAGE   "usage: ipcrm [-z zone] [ [-q msqid] [-m shmid] " \
"[-s semid]\n\t [-Q msgkey] [-M shmkey] [-S semkey] ... ]\n"

#define IPC_KEYMATCH(perm, zoneid, key) \
    ((perm).ipcx_key == (key) && (perm).ipcx_zoneid == (zoneid))

static char opts[] = "z:q:m:s:Q:M:S:";  /* allowable options for getopt */
extern char *optarg;    /* arg pointer for getopt */
extern int  optind;     /* option index for getopt */

static zoneid_t zoneid;
static int zflg;

static int *idlist, nids;

static void
oops(char *thing, char *arg)
{
    char *e;

    switch (errno) {
    case ENOENT:    /* key not found */
    case EINVAL:    /* id not found */
        e = "not found";
        break;

    case EPERM:
        e = "permission denied";
        break;
    default:
        e = "unknown error";
    }

    (void) fprintf(stderr, gettext("ipcrm: %s(%s): %s\n"), thing, arg, e);
}

/* convert string to numeric key */
static key_t
getkey(char *kp)
{
    key_t k;
    char *tp;   /* will point to char that terminates strtol scan */

    if ((k = (key_t)strtol(kp, &tp, 0)) == IPC_PRIVATE || *tp != '\0') {
        (void) fprintf(stderr, gettext("ipcrm: illegal key: %s\n"),
            kp);
        return (0);
    }
    return (k);
}

/*
 * Gets list of all IPC ids (of a particular type) visible in the
 * caller's zone.  Returns number of ids retrieved.  On return, idlist
 * is set to point to an array of ids at least as large as the number
 * retrieved.
 */
static uint_t
getids(int (*idsfunc)(int *, uint_t, uint_t *))
{
    uint_t n;

    for (;;) {
        if (idsfunc(idlist, nids, &n) != 0)
            goto err;   /* should never happen */
        if (n <= nids)
            break;
        idlist = realloc(idlist, (nids = n) * sizeof (int));
        if (idlist == NULL)
            goto err;
    }
    return (n);

err:
    perror("ipcrm");
    exit(1);
    /* NOTREACHED */
}

static int
msggetid(char *arg)
{
    int id = atol(arg);
    struct msqid_ds64 qds;

    if (!zflg)
        return (id);

    if (msgctl64(id, IPC_STAT64, &qds) < 0) {
        oops("msgctl", arg);
        return (-1);
    }
    if (qds.msgx_perm.ipcx_zoneid != zoneid) {
        /*
         * Not in right zone, pretend the call failed.
         * Message should be the same as that returned if
         * msggetid succeeds but the subsequent IPC_RMID fails
         * with EINVAL.
         */
        errno = EINVAL;
        oops("msgctl", arg);
        return (-1);
    }
    return (id);
}

static int
msggetkey(char *kp)
{
    key_t k;
    int id, i;
    uint_t n;
    struct msqid_ds64 qds;

    if ((k = getkey(kp)) == 0)
        return (-1);

    if (!zflg) {
        /* lookup in local zone is simple */
        if ((id = msgget(k, 0)) == -1)
            oops("msgget", kp);
        return (id);
    }

    n = getids(msgids);

    /* search for right key and zone combination */
    for (i = 0; i < n; i++) {
        id = idlist[i];
        if (msgctl64(id, IPC_STAT64, &qds) < 0)
            continue;
        if (IPC_KEYMATCH(qds.msgx_perm, zoneid, k))
            return (id);    /* found it, no need to look further */
    }
    (void) fprintf(stderr, gettext("ipcrm: unknown key: %s\n"), kp);
    return (-1);
}

static int
semgetid(char *arg)
{
    int id = atol(arg);
    struct semid_ds64 sds;
    union semun {
        int val;
        struct semid_ds64 *buf;
        ushort_t *array;
    } semarg;

    if (!zflg)
        return (id);

    semarg.buf = &sds;
    if (semctl64(id, 0, IPC_STAT64, semarg) < 0) {
        oops("semctl", arg);
        return (-1);
    }
    if (sds.semx_perm.ipcx_zoneid != zoneid) {
        /*
         * Not in right zone, pretend the call failed.
         * Message should be the same as that returned if
         * semgetid succeeds but the subsequent IPC_RMID fails
         * with EINVAL.
         */
        errno = EINVAL;
        oops("semctl", arg);
        return (-1);
    }
    return (id);
}

static int
semgetkey(char *kp)
{
    key_t k;
    int id, i;
    uint_t n;
    struct semid_ds64 sds;
    union semun {
        int val;
        struct semid_ds64 *buf;
        ushort_t *array;
    } semarg;

    if ((k = getkey(kp)) == 0)
        return (-1);

    if (!zflg) {
        /* lookup in local zone is simple */
        if ((id = semget(k, 0, 0)) == -1)
            oops("semget", kp);
        return (id);
    }

    n = getids(semids);

    semarg.buf = &sds;
    /* search for right key and zone combination */
    for (i = 0; i < n; i++) {
        int id;
        id = idlist[i];
        if (semctl64(id, 0, IPC_STAT64, semarg) < 0)
            continue;
        if (IPC_KEYMATCH(sds.semx_perm, zoneid, k))
            return (id);    /* found it, no need to look further */
    }

    (void) fprintf(stderr, gettext("ipcrm: unknown key: %s\n"), kp);
    return (-1);
}

static int
shmgetid(char *arg)
{
    int id = atol(arg);
    struct shmid_ds64 mds;

    if (!zflg)
        return (id);

    if (shmctl64(id, IPC_STAT64, &mds) < 0) {
        oops("shmctl", arg);
        return (-1);
    }
    if (mds.shmx_perm.ipcx_zoneid != zoneid) {
        /*
         * Not in right zone, pretend the call failed.
         * Message should be the same as that returned if
         * shmgetid succeeds but the subsequent IPC_RMID fails
         * with EINVAL.
         */
        errno = EINVAL;
        oops("shmctl", arg);
        return (-1);
    }
    return (id);
}

static int
shmgetkey(char *kp)
{
    key_t k;
    int id, i;
    uint_t n;
    struct shmid_ds64 mds;

    if ((k = getkey(kp)) == 0)
        return (-1);

    if (!zflg) {
        /* lookup in local zone is simple */
        if ((id = shmget(k, 0, 0)) == -1)
            oops("shmget", kp);
        return (id);
    }

    n = getids(shmids);

    /* search for right key and zone combination */
    for (i = 0; i < n; i++) {
        int id;
        id = idlist[i];
        if (shmctl64(id, IPC_STAT64, &mds) < 0)
            continue;
        if (IPC_KEYMATCH(mds.shmx_perm, zoneid, k))
            return (id);    /* found it, no need to look further */
    }
    (void) fprintf(stderr, gettext("ipcrm: unknown key: %s\n"), kp);
    return (-1);
}


/* convert string containing zone name or id to a numeric id */
static zoneid_t
getzone(char *arg)
{
    zoneid_t zoneid;

    if (zone_get_id(arg, &zoneid) != 0) {
        (void) fprintf(stderr, gettext("ipcrm: unknown zone: %s\n"),
            arg);
        exit(1);
    }
    return (zoneid);
}

int
main(int argc, char **argv)
{
    int o;      /* option flag */
    int err;        /* error count */
    int ipc_id;     /* id to remove */

    (void) setlocale(LC_ALL, "");
    (void) textdomain(TEXT_DOMAIN);
    /*
     * If one or more of the IPC modules is not
     * included in the kernel, the corresponding
     * system calls will incur SIGSYS.  Ignoring
     * that signal makes the system call appear
     * to fail with errno == EINVAL, which can be
     * interpreted appropriately in oops().
     */

    (void) signal(SIGSYS, SIG_IGN);

    /*
     * If no -z argument is specified, only objects in the current
     * zone can be removed with keys.
     */
    zoneid = getzoneid();

    /*
     * Go through the options.  The first pass looks only for -z
     * since this option can affect the processing of keys.  The
     * second pass looks for the other options and ignores -z.
     */
    err = 0;
    while ((o = getopt(argc, argv, opts)) != EOF) {
        switch (o) {
        case 'z':
            zflg++;
            zoneid = getzone(optarg);
            break;

        case 'q':   /* skip the rest of the flags */
        case 'm':
        case 's':
        case 'Q':
        case 'M':
        case 'S':
            break;

        case '?':   /* anything else is an error */
        default:
            err++;
            break;
        }
    }

    if (err || (optind < argc)) {
        (void) fprintf(stderr, gettext(USAGE));
        return (err);
    }

    if (zflg > 1) {
        (void) fprintf(stderr,
            gettext("multiple -z options not allowed\n"));
        (void) fprintf(stderr, gettext(USAGE));
        return (1);
    }

    optind = 1; /* rewind for pass 2 */
    while ((o = getopt(argc, argv, opts)) != EOF) {
        switch (o) {
        case 'z':   /* zone identifier */
            break;

        case 'q':   /* message queue */
            if ((ipc_id = msggetid(optarg)) < 0) {
                err++;
            } else if (msgctl(ipc_id, IPC_RMID, NULL_MSG) == -1) {
                oops("msgctl", optarg);
                err++;
            }
            break;

        case 'm':   /* shared memory */
            if ((ipc_id = shmgetid(optarg)) < 0) {
                err++;
            } else if (shmctl(ipc_id, IPC_RMID, NULL_SHM) == -1) {
                oops("shmctl", optarg);
                err++;
            }
            break;

        case 's':   /* semaphores */
            if ((ipc_id = semgetid(optarg)) < 0) {
                err++;
            } else if (semctl(ipc_id, 0, IPC_RMID, NULL_SEM) ==
                -1) {
                oops("semctl", optarg);
                err++;
            }
            break;

        case 'Q':   /* message queue (by key) */
            if ((ipc_id = msggetkey(optarg)) == -1) {
                err++;
                break;
            }
            if (msgctl(ipc_id, IPC_RMID, NULL_MSG) == -1) {
                oops("msgctl", optarg);
                err++;
            }
            break;

        case 'M':   /* shared memory (by key) */
            if ((ipc_id = shmgetkey(optarg)) == -1) {
                err++;
                break;
            }
            if (shmctl(ipc_id, IPC_RMID, NULL_SHM) == -1) {
                oops("shmctl", optarg);
                err++;
            }
            break;

        case 'S':   /* semaphores (by key) */
            if ((ipc_id = semgetkey(optarg)) == -1) {
                err++;
                break;
            }
            if (semctl(ipc_id, 0, IPC_RMID, NULL_SEM) == -1) {
                oops("semctl", optarg);
                err++;
            }
            break;
        }
    }
    return (err);
}