libadm/common/ckitem.c

	ckitem.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 (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*    All Rights Reserved   */


/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"    /* SVr4.0 1.4 */
/*LINTLIBRARY*/

#include <stdio.h>
#include <ctype.h>
#include <limits.h>
#include "valtools.h"
#include <sys/types.h>
#include <stdlib.h>
#include <strings.h>
#include "libadm.h"

static int  insert(struct _choice_ *, CKMENU *);
static char *strtoki(char *, char *);
static char **match(CKMENU *, char *, int);
static int  getstr(char *, char *, char *, char *, char *);
static int  getnum(char *, int, int *, int *);
static struct _choice_ *next(struct _choice_ *);

static char *deferr;
static char *errmsg;
static char *defhlp;

#define PROMPT  "Enter selection"
#define MESG0   "Entry does not match available menu selection. "
#define MESG1   "the number of the menu item you wish to select, or "
#define MESG2   "the token which is associated with the menu item,\
        or a partial string which uniquely identifies the \
        token for the menu item. Enter ?? to reprint the menu."

#define TOOMANY "Too many items selected from menu"
#define NOTUNIQ "The entered text does not uniquely identify a menu choice."
#define BADNUM  "Bad numeric choice specification"

static char *
setmsg(CKMENU *menup, short flag)
{
    int n;
    char    *msg;

    n = (int)(6 + sizeof (MESG2));
    if (flag)
        n += (int)(sizeof (MESG0));

    if (menup->attr & CKUNNUM) {
        msg = calloc((size_t)n, sizeof (char));
        if (flag)
            (void) strcpy(msg, MESG0);
        else
            msg[0] = '\0';
        (void) strcat(msg, "Enter ");
        (void) strcat(msg, MESG2);
    } else {
        msg = calloc(n+sizeof (MESG1), sizeof (char));
        if (flag)
            (void) strcpy(msg, MESG0);
        else
            msg[0] = '\0';
        (void) strcat(msg, "Enter ");
        (void) strcat(msg, MESG1);
        (void) strcat(msg, MESG2);
    }
    return (msg);
}

CKMENU *
allocmenu(char *label, int attr)
{
    CKMENU *pt;

    if (pt = calloc(1, sizeof (CKMENU))) {
        pt->attr = attr;
        pt->label = label;
    }
    return (pt);
}

void
ckitem_err(CKMENU *menup, char *error)
{
    deferr = setmsg(menup, 1);
    puterror(stdout, deferr, error);
    free(deferr);
}

void
ckitem_hlp(CKMENU *menup, char *help)
{
    defhlp = setmsg(menup, 0);
    puthelp(stdout, defhlp, help);
    free(defhlp);
}

int
ckitem(CKMENU *menup, char *item[], short max, char *defstr, char *error,
    char *help, char *prompt)
{
    int n, i;
    char    strval[MAX_INPUT];
    char    **list;

    if ((menup->nchoices <= 0) && !menup->invis)
        return (4); /* nothing to choose from */

    if (menup->attr & CKONEFLAG) {
        if (((n = menup->nchoices) <= 1) && menup->invis) {
            for (i = 0; menup->invis[i]; ++i)
                n++;
        }
        if (n <= 1) {
            if (menup->choice)
                item[0] = menup->choice->token;
            else if (menup->invis)
                item[0] = menup->invis[0];
            item[1] = NULL;
            return (0);
        }
    }

    if (max < 1)
        max = menup->nchoices;

    if (!prompt)
        prompt = PROMPT;
    defhlp = setmsg(menup, 0);
    deferr = setmsg(menup, 1);

reprint:
    printmenu(menup);

start:
    if (n = getstr(strval, defstr, error, help, prompt)) {
        free(defhlp);
        free(deferr);
        return (n);
    }
    if (strcmp(strval, "??") == 0) {
        goto reprint;
    }
    if ((defstr) && (strcmp(strval, defstr) == 0)) {
        item[0] = defstr;
        item[1] = NULL;
    } else {
        list = match(menup, strval, (int)max);
        if (!list) {
            puterror(stderr, deferr, (errmsg ? errmsg : error));
            goto start;
        }
        for (i = 0; (i < max); i++)
            item[i] = list[i];
        free(list);
    }
    free(defhlp);
    free(deferr);
    return (0);
}

static int
getnum(char *strval, int max, int *begin, int *end)
{
    int n;
    char *pt;

    *begin = *end = 0;
    pt = strval;
    for (;;) {
        if (*pt == '$') {
            n = max;
            pt++;
        } else {
            n = (int)strtol(pt, &pt, 10);
            if ((n <= 0) || (n > max))
                return (1);
        }
        while (isspace((unsigned char)*pt))
            pt++;

        if (!*begin && (*pt == '-')) {
            *begin = n;
            pt++;
            while (isspace((unsigned char)*pt))
                pt++;
            continue;
        } else if (*pt) {
            return (1); /* wasn't a number, or an invalid one */
        } else if (*begin) {
            *end = n;
            break;
        } else {
            *begin = n;
            break;
        }
    }
    if (!*end)
        *end = *begin;
    return ((*begin <= *end) ? 0 : 1);
}

static char **
match(CKMENU *menup, char *strval, int max)
{
    struct _choice_ *chp;
    char **choice;
    int begin, end;
    char *pt, *found;
    int i, len, nchoice;

    nchoice = 0;
    choice = calloc((size_t)max, sizeof (char *));

    do {
        if (pt = strpbrk(strval, " \t,")) {
            do {
                *pt++ = '\0';
            } while (strchr(" \t,", *pt));
        }

        if (nchoice >= max) {
            errmsg = TOOMANY;
            return (NULL);
        }
        if (!(menup->attr & CKUNNUM) &&
            isdigit((unsigned char)*strval)) {
            if (getnum(strval, (int)menup->nchoices, &begin,
                &end)) {
                errmsg = BADNUM;
                return (NULL);
            }
            chp = menup->choice;
            for (i = 1; chp; i++) {
                if ((i >= begin) && (i <= end)) {
                    if (nchoice >= max) {
                        errmsg = TOOMANY;
                        return (NULL);
                    }
                    choice[nchoice++] = chp->token;
                }
                chp = chp->next;
            }
            continue;
        }

        found = NULL;
        chp = menup->choice;
        for (i = 0; chp; i++) {
            len = (int)strlen(strval);
            if (strncmp(chp->token, strval, (size_t)len) == 0) {
                if (chp->token[len] == '\0') {
                    found = chp->token;
                    break;
                } else if (found) {
                    errmsg = NOTUNIQ;
                    return (NULL); /* not unique */
                }
                found = chp->token;
            }
            chp = chp->next;
        }

        if (menup->invis) {
            for (i = 0; menup->invis[i]; ++i) {
                len = (int)strlen(strval);
                if (strncmp(menup->invis[i], strval,
                    (size_t)len) == 0) {
#if _3b2
                    if (chp->token[len] == '\0') {
#else
                    if (menup->invis[i][len] == '\0') {
#endif
                        found = menup->invis[i];
                        break;
                    } else if (found) {
                        errmsg = NOTUNIQ;
                        return (NULL);
                    }
                    found = menup->invis[i];
                }
            }
        }
        if (found) {
            choice[nchoice++] = found;
            continue;
        }
        errmsg = NULL;
        return (NULL);
    } while (((strval = pt) != NULL) && *pt);
    return (choice);
}

int
setitem(CKMENU *menup, char *choice)
{
    struct _choice_ *chp;
    int n;
    char *pt;

    if (choice == NULL) {
        /* request to clear memory usage */
        chp = menup->choice;
        while (chp) {
            struct _choice_ *_chp = chp;

            chp = chp->next;
            menup->longest = menup->nchoices = 0;

            (void) free(_chp->token); /* free token and text */
            (void) free(_chp);
        }
        return (1);
    }

    if ((chp = calloc(1, sizeof (struct _choice_))) == NULL)
        return (1);

    if ((pt = strdup(choice)) == NULL) {
        free(chp);
        return (1);
    }
    if (!*pt || isspace((unsigned char)*pt)) {
        free(chp);
        return (2);
    }

    chp->token = strtoki(pt, " \t\n");
    chp->text = strtoki(NULL, "");

    if (chp->text) {
        while (isspace((unsigned char)*chp->text))
        chp->text++;
    }
    n = (int)strlen(chp->token);
    if (n > menup->longest)
        menup->longest = (short)n;

    if (insert(chp, menup))
        menup->nchoices++;
    else
        free(chp); /* duplicate entry */
    return (0);
}

int
setinvis(CKMENU *menup, char *choice)
{
    int index;

    index = 0;
    if (choice == NULL) {
        if (menup->invis == NULL)
            return (0);
        while (menup->invis[index])
            free(menup->invis[index]);
        free(menup->invis);
        return (0);
    }

    if (menup->invis == NULL)
        menup->invis = calloc(2, sizeof (char *));
    else {
        while (menup->invis[index])
            index++; /* count invisible choices */
        menup->invis = realloc(menup->invis,
            (index+2)* sizeof (char *));
        menup->invis[index+1] = NULL;
    }
    if (!menup->invis)
        return (-1);
    menup->invis[index] = strdup(choice);
    return (0);
}

static int
insert(struct _choice_ *chp, CKMENU *menup)
{
    struct _choice_ *last, *base;
    int n;

    base = menup->choice;
    last = NULL;

    if (!(menup->attr & CKALPHA)) {
        while (base) {
            if (strcmp(base->token, chp->token) == 0)
                return (0);
            last = base;
            base = base->next;
        }
        if (last)
            last->next = chp;
        else
            menup->choice = chp;
        return (1);
    }

    while (base) {
        if ((n = strcmp(base->token, chp->token)) == 0)
            return (0);
        if (n > 0) {
            /* should come before this one */
            break;
        }
        last = base;
        base = base->next;
    }
    if (last) {
        chp->next = last->next;
        last->next = chp;
    } else {
        chp->next = menup->choice;
        menup->choice = chp;
    }
    return (1);
}

void
printmenu(CKMENU *menup)
{
    int i;
    struct _choice_ *chp;
    char *pt;
    char format[16];
    int c;

    (void) fputc('\n', stderr);
    if (menup->label) {
        (void) puttext(stderr, menup->label, 0, 0);
        (void) fputc('\n', stderr);
    }
    (void) sprintf(format, "%%-%ds", menup->longest+5);

    (void) next(NULL);
    chp = ((menup->attr & CKALPHA) ? next(menup->choice) : menup->choice);
    for (i = 1; chp; ++i) {
        if (!(menup->attr & CKUNNUM))
            (void) fprintf(stderr, "%3d  ", i);
        (void) fprintf(stderr, format, chp->token);
        if (chp->text) {
            /* there is text associated with the token */
            pt = chp->text;
            while (*pt) {
                (void) fputc(*pt, stderr);
                if (*pt++ == '\n') {
                    if (!(menup->attr & CKUNNUM))
                        (void) fprintf(stderr,
                            "%5s", "");
                    (void) fprintf(stderr, format, "");
                    while (isspace((unsigned char)*pt))
                        ++pt;
                }
            }
        }
        (void) fputc('\n', stderr);
        chp = ((menup->attr & CKALPHA) ?
            next(menup->choice) : chp->next);
        if (chp && ((i % 10) == 0)) {
            /* page the choices */
            (void) fprintf(stderr,
                "\n... %d more menu choices to follow;",
                menup->nchoices - i);
            (void) fprintf(stderr,
                /* CSTYLED */
                "\n<RETURN> for more choices, <CTRL-D> to stop \
display:");
            /* ignore other chars */
            while (((c = getc(stdin)) != EOF) && (c != '\n'))
                ;
            (void) fputc('\n', stderr);
            if (c == EOF)
                break; /* stop printing menu */
        }
    }
}

static int
getstr(char *strval, char *defstr, char *error, char *help, char *prompt)
{
    char input[MAX_INPUT];
    char *ept, end[MAX_INPUT];

    *(ept = end) = '\0';
    if (defstr) {
        (void) sprintf(ept, "(default: %s) ", defstr);
        ept += strlen(ept);
    }
    if (ckquit) {
        (void) strcat(ept, "[?,??,q]");
    } else {
        (void) strcat(ept, "[?,??]");
    }

start:
    (void) fputc('\n', stderr);
    (void) puttext(stderr, prompt, 0, 0);
    (void) fprintf(stderr, " %s: ", end);

    if (getinput(input))
        return (1);

    if (strlen(input) == 0) {
        if (defstr) {
            (void) strcpy(strval, defstr);
            return (0);
        }
        puterror(stderr, deferr, (errmsg ? errmsg : error));
        goto start;
    } else if (strcmp(input, "?") == 0) {
        puthelp(stderr, defhlp, help);
        goto start;
    } else if (ckquit && (strcmp(input, "q") == 0)) {
        /* (void) strcpy(strval, input); */
        return (3);
    }
    (void) strcpy(strval, input);
    return (0);
}

static struct _choice_ *
next(struct _choice_ *chp)
{
    static char *last;
    static char *first;
    struct _choice_ *found;

    if (!chp) {
        last = NULL;
        return (NULL);
    }

    found = NULL;
    for (first = NULL; chp; chp = chp->next) {
        if (last && strcmp(last, chp->token) >= 0)
            continue; /* lower than the last one we found */

        if (!first || strcmp(first, chp->token) > 0) {
            first = chp->token;
            found = chp;
        }
    }
    last = first;
    return (found);
}

static char *
strtoki(char *string, char *sepset)
{
    char    *p, *q, *r;
    static char *savept;

    /* first or subsequent call */
    p = (string == NULL)? savept: string;

    if (p == NULL)      /* return if no tokens remaining */
        return (NULL);

    q = p + strspn(p, sepset);  /* skip leading separators */

    if (*q == '\0')     /* return if no tokens remaining */
        return (NULL);

    if ((r = strpbrk(q, sepset)) == NULL)   /* move past token */
        savept = 0; /* indicate this is last token */
    else {
        *r = '\0';
        savept = ++r;
    }
    return (q);
}