/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
 */

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



/*
 * 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)strtoul(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);
}