help.c

/*
 * help - display help for calc
 *
 * Copyright (C) 1999-2007,2014,2018,2021  Landon Curt Noll
 *
 * Calc is open software; you can redistribute it and/or modify it under
 * the terms of the version 2.1 of the GNU Lesser General Public License
 * as published by the Free Software Foundation.
 *
 * Calc is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 * Public License for more details.
 *
 * A copy of version 2.1 of the GNU Lesser General Public License is
 * distributed with calc under the filename COPYING-LGPL.  You should have
 * received a copy with calc; if not, write to Free Software Foundation, Inc.
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 * Under source code control:   1997/09/14 10:58:30
 * File existed as early as:    1997
 *
 * chongo <was here> /\oo/\     http://www.isthe.com/chongo/
 * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
 */


#include <stdio.h>
#include <ctype.h>
#include <sys/types.h>
#include <signal.h>
#include <sys/errno.h>

#include "calc.h"
#include "conf.h"
#include "lib_calc.h"

#include "have_unistd.h"
#if defined(HAVE_UNISTD_H)
#include <unistd.h>
#endif

#if defined(_WIN32) || defined(_WIN64)
# define popen _popen
# define pclose _pclose
#endif


#include "banned.h"     /* include after system header <> includes */


/*
 * some help topics are symbols, so we alias them to nice filenames
 */
STATIC struct help_alias {
        char *topic;
        char *filename;
} halias[] = {
        /* We sort the list below via: sort -d -u */
        {"=", "address"},
        {"->", "arrow"},
        {"=", "assign"},
        {"*", "dereference"},
        {"%", "mod"},
        {".", "oldvalue"},
        {"#", "pound"},
        {"//", "quo"},
        {"COPYING_LGPL", "COPYING-LGPL"},
        {"COPYLEFT", "copyright"},
        {"COPYRIGHT", "copyright"},
        {"Copyleft", "copyright"},
        {"Copyright", "copyright"},
        {"abort", "command"},
        {"cd", "command"},
        {"copy", "blkcpy"},
        {"copying", "COPYING"},
        {"copying-lgpl", "COPYING-LGPL"},
        {"define", "command"},
        {"dm2d", "dms2d"},
        {"exit", "command"},
        {"gm2g", "gms2g"},
        {"hm2d", "hms2d"},
        {"man", "calc"},
        {"question", "questions"},
        {"quit", "command"},
        {"read", "command"},
        {"release", "releases"},
        {"show", "command"},
        {"stdlib", "resource"},
        {"usage", "calc"},
        {"write", "command"},

        /* MUST BE LAST! */
        {NULL, NULL}
};


/*
 * external values
 */
EXTERN char *pager;             /* $PAGER or default */


/*
 * page_file - output an open file thru a pager
 *
 * The popen() below is fairly safe.  The $PAGER environment variable
 * (supplied by the user) is the command we need to run without args.
 * True, the user could set $PAGER is a bogus prog ... but if -m is
 * 5 or 7 (read and exec allowed), then the calc is given ``permission''
 * to open the help file for reading as well as to exec the pager!
 *
 * given:
 *      stream  open file stream of the file to send to the pager
 */
S_FUNC void
page_file(FILE *stream)
{
        FILE *cmd;              /* pager command */
        char buf[BUFSIZ+1];     /* I/O buffer */
        char *fgets_ret;        /* fgets() return value */

        /*
         * flush any pending I/O
         */
        fflush(stderr);
        fflush(stdout);
        fflush(stdin);

        /*
         * form a write pipe to a pager
         */
        if (pager == NULL || pager[0] == '\0') {
            cmd = stdout;
        } else {
            cmd = popen(pager, "w");
        }
        if (cmd == NULL) {
                fprintf(stderr, "unable form pipe to pager: %s", pager);
                return;
        }

        /*
         * read the help file and send non-## lines to the pager
         * until EOF or error
         */
        buf[BUFSIZ] = '\0';
        do {

                /*
                 * read the next line that does not begin with ##
                 */
                buf[0] = '\0';
                while ((fgets_ret = fgets(buf, BUFSIZ, stream)) != NULL &&
                       buf[0] == '#' && buf[1] == '#') {
                }

                /*
                 * stop reading when we reach EOF (or error) on help file
                 */
                if (fgets_ret == NULL) {
                        fflush(cmd);
                        break;
                }

                /*
                 * write the line to pager, if possible
                 *
                 * We have to use fprintf() instead of fputs() because
                 * on NetBSD, fputs() function returns 0 on success and
                 # EOF on error.  *sigh*
                 */
        }  while (fprintf(cmd, "%s", buf) > 0);

        /*
         * all done, EOF or error, so just clean up
         */
        (void) pclose(cmd);
        fflush(stderr);
        fflush(stdout);
        fflush(stdin);
        return;
}


/*
 * givehelp - display a help file
 *
 * given:
 *      type            the type of help to give, NULL => index
 */
void
givehelp(char *type)
{
        struct help_alias *p;   /* help alias being considered */
        FILE *stream;           /* help file stream */
        char *helppath;         /* path to the help file */
        char *c;
        size_t snprintf_len;    /* malloced snprintf buffer length */

        /*
         * check permissions to see if we are allowed to help
         */
        if (!allow_exec || !allow_read) {
                fprintf(stderr,
                    "sorry, help is only allowed with -m mode 5 or 7\n");
                return;
        }

        /* catch the case where we just print the index */
        if (type == NULL) {
                type = DEFAULTCALCHELP;         /* the help index file */
        }

        /* alias the type of help, if needed */
        for (p=halias; p->topic; ++p) {
                if (strcmp(type, p->topic) == 0) {
                        type = p->filename;
                        break;
                }
        }

        /*
         * sanity check on name
         */
        /* look for /. or a leading . */
        if (strstr(type, "/.") != NULL || type[0] == '.') {
                fprintf(stderr, "bad help name\n");
                return;
        }
        /* look for chars that could be shell meta chars */
        for (c = type; *c; ++c) {
                switch ((int)*c) {
                case '+':
                case ',':
                case '-':
                case '.':
                case '/':
                case '_':
                        break;
                default:
                        if (!isascii((int)*c) || !isalnum((int)*c)) {
                                fprintf(stderr, "bogus char in help name\n");
                                return;
                        }
                        break;
                }
        }

        /*
         * special case for Copyright and Copyleft
         */
        if (strcmp(type, "copyright") == 0) {
                fputs(Copyright, stdout);
                fflush(stdout);
                return;
        }

        /*
         * open the helpfile (looking in HELPDIR first)
         */
        snprintf_len = strlen(calc_helpdir)+1+strlen(type) + 1;
        helppath = (char *)malloc(snprintf_len+1);
        if (helppath == NULL) {
                fprintf(stderr, "malloc failure in givehelp #0\n");
                return;
        }
        snprintf(helppath, snprintf_len, "%s/%s", calc_helpdir, type);
        helppath[snprintf_len] = '\0';  /* paranoia */
        errno = 0;
        stream = fopen(helppath, "r");
        if (stream != NULL) {

                /*
                 * we have the help file open, now display it
                 */
                page_file(stream);
                (void) fclose(stream);

#if defined(CUSTOM)
        /*
         * open the helpfile (looking in CUSTOMHELPDIR last)
         */
        } else {
                char *cust_helppath;      /* path to the custom help file */
                size_t cust_snprintf_len; /* malloced custom snprintf buf len */

                cust_snprintf_len =
                  strlen(calc_customhelpdir)+1+strlen(type) + 1;
                cust_helppath = (char *)malloc(cust_snprintf_len+1);
                if (cust_helppath == NULL) {
                        fprintf(stderr, "malloc failure for givehelp #1\n");
                        return;
                }
                snprintf(cust_helppath, cust_snprintf_len,
                         "%s/%s", calc_customhelpdir, type);
                cust_helppath[cust_snprintf_len] = '\0';        /* paranoia */
                errno = 0;
                stream = fopen(cust_helppath, "r");
                if (stream != NULL) {

                        /*
                         * we have the help file open, now display it
                         */
                        page_file(stream);
                        (void) fclose(stream);

                /* unable to open help file */
                } else {
                        fprintf(stderr, "unable to open help file: %s - %s\n",
                                        type, strerror(errno));
                }
                free(cust_helppath);
                cust_helppath = NULL;

#else /* CUSTOM */
        /* unable to open help file */
        } else {
                fprintf(stderr, "unable to open help file: %s - %s\n",
                                type, strerror(errno));
#endif /* CUSTOM */
        }

        /*
         * cleanup
         */
        free(helppath);
        helppath = NULL;
        return;
}