/*
 * 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 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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


#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <limits.h>
#include <pkgstrct.h>
#include <pkginfo.h>
#include <locale.h>
#include <libintl.h>
#include <unistd.h>
#include <stdlib.h>
#include <pkglib.h>
#include <install.h>
#include <libadm.h>
#include <libinst.h>

extern char     *basedir, *root, *rootlist[], **environ;

/*
 * IMPORTANT NOTE: PLEASE SEE THE DEFINITION OF temp[] BELOW BEFORE
 * CHANGING THE DEFINITION OF PATH_LGTH!!!!
 */

#define PATH_LGTH 4096

#define MAXPARAMS 256
#define NRECURS 20

#define MSG_BPARAMC     "parametric class specification for <%s> not allowed"
#define MSG_SRCHLOC     "no object for <%s> found in local path"
#define MSG_SRCHSRCH    "no object for <%s> found in search path"
#define MSG_SRCHROOT    "no object for <%s> found in root directory"
#define MSG_CONTENTS    "unable to process contents of object <%s>"
#define MSG_WRITE       "write of entry failed, errno=%d"
#define MSG_GARBDEFLT   "garbled default settings: %s"
#define MSG_BANG        "unknown directive: %s"
#define MSG_CHDIR       "unable to change directory to <%s>"
#define MSG_INCOMPLETE  "processing of <%s> may be incomplete"
#define MSG_NRECURS     "too many levels of include (limit is %d)"
#define MSG_RDINCLUDE   "unable to process include file <%s>, errno=%d"
#define MSG_IGNINCLUDE  "ignoring include file <%s>"
#define MSG_NODEVICE    "device numbers cannot be determined for <%s>"

#define WRN_BADATTR     "WARNING: attributes set to %04o %s %s for <%s>"
#define WRN_BADATTRM    "WARNING: attributes set to %s %s %s for <%s>"
#define WRN_FAKEBD      "WARNING: parametric paths may ignore BASEDIR"

#define ERR_TEMP        "unable to obtain temporary file resources, errno=%d"
#define ERR_ENVBUILD    "unable to build parameter environment, errno=%d"
#define ERR_MAXPARAMS   "too many parameter definitions (limit is %d)"
#define ERR_GETCWD      "unable to get current directory, errno=%d"
#define ERR_PATHVAR     "cannot resolve all build parameters associated with " \
                            "path <%s>."

static struct cfent entry;
static FILE     *fp,
                *sfp[20];
static char     *dname[NRECURS],
                *params[256],
                *proto[NRECURS],
                *rootp[NRECURS][16],
                *srchp[NRECURS][16],
                *d_own[NRECURS],
                *d_grp[NRECURS],
                *rdonly[256];
static mode_t   d_mod[NRECURS];
static int      nfp = (-1);
static int      nrdonly = 0;
static int      errflg = 0;
static char     *separ = " \t\n, ";

/* libpkg/gpkgmap.c */
extern void     attrpreset(int mode, char *owner, char *group);
extern void     attrdefault();
static char     *findfile(char *path, char *local);
static char     *srchroot(char *path, char *copy);

static int      popenv(void);

static int      doattrib(void);
static void     doinclude(void);
static void     dorsearch(void);
static void     dosearch(void);
static void     error(int flag);
static void     lputenv(char *s);
static void     pushenv(char *file);
static void     translate(register char *pt, register char *copy);

int
mkpkgmap(char *outfile, char *protofile, char **envparam)
{
        FILE    *tmpfp;
        char    *pt, *path, mybuff[PATH_LGTH];
        char    **envsave;
        int     c, fakebasedir;
        int     i, n;

        /*
         * NOTE: THE SIZE OF temp IS HARD CODED INTO CALLS TO fscanf.
         * YOU *MUST* MAKE SURE TO CHANGE THOSE CALLS IF THE SIZE OF temp
         * IS EVER CHANGED!!!!!!
         */
        char    temp[PATH_LGTH];

        if ((tmpfp = fopen(outfile, "w")) == NULL) {
                progerr(gettext(ERR_TEMP), errno);
                quit(99);
        }
        envsave = environ;
        environ = params; /* use only local environ */
        attrdefault();  /* assume no default attributes */

        /*
         * Environment parameters are optional, so variable
         * (envparam[i]) could be NULL.
         */
        for (i = 0; (envparam[i] != NULL) &&
            (pt = strchr(envparam[i], '=')); i++) {
                *pt = '\0';
                rdonly[nrdonly++] = qstrdup(envparam[i]);
                *pt = '=';
                if (putenv(qstrdup(envparam[i]))) { /* bugid 1090920 */
                        progerr(gettext(ERR_ENVBUILD), errno);
                        quit(99);
                }
                if (nrdonly >= MAXPARAMS) {
                        progerr(gettext(ERR_MAXPARAMS), MAXPARAMS);
                        quit(1);
                }
        }

        pushenv(protofile);
        errflg = 0;
again:
        fakebasedir = 0;
        while (!feof(fp)) {
                c = getc(fp);
                while (isspace(c))
                        c = getc(fp);

                if (c == '#') {
                        do c = getc(fp); while ((c != EOF) && (c != '\n'));
                        continue;
                }
                if (c == EOF)
                        break;

                if (c == '!') {
                        /*
                         * IMPORTANT NOTE: THE SIZE OF temp IS HARD CODED INTO
                         * the FOLLOWING CALL TO fscanf -- YOU MUST CHANGE THIS
                         * LINE IF THE SIZE OF fscanf IS EVER CHANGED!!!
                         */
                        (void) fscanf(fp, "%4096s", temp);

                        if (strcmp(temp, "include") == 0)
                                doinclude();
                        else if (strcmp(temp, "rsearch") == 0)
                                dorsearch();
                        else if (strcmp(temp, "search") == 0)
                                dosearch();
                        else if (strcmp(temp, "default") == 0) {
                                if (doattrib())
                                        break;
                        } else if (strchr(temp, '=')) {
                                translate(temp, mybuff);
                                /* put this into the local environment */
                                lputenv(mybuff);
                                (void) fscanf(fp, "%*[^\n]"); /* rest of line */
                                (void) fscanf(fp, "\n"); /* rest of line */
                        } else {
                                error(1);
                                logerr(gettext(MSG_BANG), temp);
                                (void) fscanf(fp, "%*[^\n]"); /* read of line */
                                (void) fscanf(fp, "\n"); /* read of line */
                        }
                        continue;
                }
                (void) ungetc(c, fp);

                if ((n = gpkgmap(&entry, fp)) < 0) {
                        char    *errstr;

                        error(1);
                        errstr = getErrstr();
                        logerr(gettext("garbled entry"));
                        logerr(gettext("- pathname: %s"),
                            (entry.path && *entry.path) ? entry.path :
                            "Unknown");
                        logerr(gettext("- problem: %s"),
                            (errstr && *errstr) ? errstr : "Unknown");
                        break;
                }
                if (n == 0)
                        break; /* done with file */

                /* don't allow classname to be parametric */
                if (entry.ftype != 'i') {
                        if (entry.pkg_class[0] == '$') {
                                error(1);
                                logerr(gettext(MSG_BPARAMC), entry.path);
                        }
                }

                if (strchr("dxlscbp", entry.ftype)) {
                        /*
                         * We don't need to search for things without any
                         * contents in them.
                         */
                        if (strchr("cb", entry.ftype)) {
                                if (entry.ainfo.major == BADMAJOR ||
                                    entry.ainfo.minor == BADMINOR) {
                                        error(1);
                                        logerr(gettext(MSG_NODEVICE),
                                            entry.path);
                                }
                        }
                        path = NULL;
                } else {
                        path = findfile(entry.path, entry.ainfo.local);
                        if (!path)
                                continue;

                        entry.ainfo.local = path;
                        if (strchr("fevin?", entry.ftype)) {
                                if (cverify(0, &entry.ftype, path,
                                    &entry.cinfo, 1)) {
                                        error(1);
                                        logerr(gettext(MSG_CONTENTS), path);
                                }
                        }
                }

                /* Warn if attributes are not set correctly. */
                if (!strchr("isl", entry.ftype)) {
                        int dowarning = 0;
                        int hasbadmode = 0;

                        if (entry.ainfo.mode == NOMODE) {
                                entry.ainfo.mode = CURMODE;
                                dowarning = 1;
                                hasbadmode = 1;
                        }

                        if (strcmp(entry.ainfo.owner, NOOWNER) == 0) {
                                (void) strlcpy(entry.ainfo.owner, CUROWNER,
                                                sizeof (entry.ainfo.owner));
                                dowarning = 1;
                        }

                        if (strcmp(entry.ainfo.group, NOGROUP) == 0) {
                                (void) strlcpy(entry.ainfo.group, CURGROUP,
                                                sizeof (entry.ainfo.group));
                                dowarning = 1;
                        }


                        if (dowarning) {
                                if (hasbadmode)
                                        logerr(gettext(WRN_BADATTRM),
                                                "?",
                                            entry.ainfo.owner,
                                            entry.ainfo.group,
                                            entry.path);
                                else
                                        logerr(gettext(WRN_BADATTR),
                                                (int)entry.ainfo.mode,
                                                entry.ainfo.owner,
                                                entry.ainfo.group,
                                                entry.path);
                        }
                }

                /*
                 * Resolve build parameters (initial lower case) in
                 * the link and target paths.
                 */
                if (strchr("ls", entry.ftype)) {
                        if (!RELATIVE(entry.ainfo.local) ||
                                        PARAMETRIC(entry.ainfo.local)) {
                                if (mappath(1, entry.ainfo.local)) {
                                        error(1);
                                        logerr(gettext(ERR_PATHVAR),
                                            entry.ainfo.local);
                                        break;
                                }

                                canonize(entry.ainfo.local);
                        }
                }

                /*
                 * Warn if top level file or directory is an install
                 * parameter
                 */
                if (entry.ftype != 'i') {
                        if (entry.path[0] == '$' && isupper(entry.path[1]))
                                fakebasedir = 1;
                }

                if (mappath(1, entry.path)) {
                        error(1);
                        logerr(gettext(ERR_PATHVAR), entry.path);
                        break;
                }

                canonize(entry.path);
                if (ppkgmap(&entry, tmpfp)) {
                        error(1);
                        logerr(gettext(MSG_WRITE), errno);
                        break;
                }
        }

        if (fakebasedir) {
                logerr(gettext(WRN_FAKEBD));
                fakebasedir = 0;
        }

        if (popenv())
                goto again;

        (void) fclose(tmpfp);
        environ = envsave; /* restore environment */

        return (errflg ? 1 : 0);
}

static char *
findfile(char *path, char *local)
{
        struct stat statbuf;
        static char host[PATH_MAX];
        register char *pt;
        char    temp[PATH_MAX], *basename;
        int     i;

        /*
         * map any parameters specified in path to their corresponding values
         * and make sure the path is in its canonical form; any parmeters for
         * which a value is not defined will be left unexpanded. Since this
         * is an actual search for a real file (which will not end up in the
         * package) - we map ALL variables (both build and Install).
         */
        (void) strlcpy(temp, (local && local[0] ? local : path), sizeof (temp));
        mappath(0, temp);
        canonize(temp);

        *host = '\0';
        if (rootlist[0] || (basedir && (*temp != '/'))) {
                /*
                 * search for path in the pseudo-root/basedir directory; note
                 * that package information files should NOT be included in
                 * this list
                 */
                if (entry.ftype != 'i')
                        return (srchroot(temp, host));
        }

        /* looking for local object file  */
        if (local && *local) {
                basepath(temp, dname[nfp], NULL);
                /*
                 * If it equals "/dev/null", that just means it's an empty
                 * file. Otherwise, we'll really be writing stuff, so we need
                 * to verify the source.
                 */
                if (strcmp(temp, "/dev/null") != 0) {
                        if (stat(temp, &statbuf) ||
                            !(statbuf.st_mode & S_IFREG)) {
                                error(1);
                                logerr(gettext(MSG_SRCHLOC), path);
                                return (NULL);
                        }
                }
                (void) strlcpy(host, temp, sizeof (host));
                return (host);
        }

        for (i = 0; rootp[nfp][i]; i++) {
                (void) snprintf(host, sizeof (host), "%s/%s", rootp[nfp][i],
                    temp + (*temp == '/' ? 1 : 0));
                if ((stat(host, &statbuf) == 0) &&
                    (statbuf.st_mode & S_IFREG)) {
                        return (host);
                }
        }

        pt = strrchr(temp, '/');
        if (!pt++)
                pt = temp;

        basename = pt;

        for (i = 0; srchp[nfp][i]; i++) {
                (void) snprintf(host, sizeof (host), "%s/%s",
                        srchp[nfp][i], basename);
                if ((stat(host, &statbuf) == 0) &&
                    (statbuf.st_mode & S_IFREG)) {
                        return (host);
                }
        }

        /* check current directory as a last resort */
        (void) snprintf(host, sizeof (host), "%s/%s", dname[nfp], basename);
        if ((stat(host, &statbuf) == 0) && (statbuf.st_mode & S_IFREG))
                return (host);

        error(1);
        logerr(gettext(MSG_SRCHSRCH), path);
        return (NULL);
}

static void
dosearch(void)
{
        char temp[PATH_MAX], lookpath[PATH_MAX], *pt;
        int n;

        (void) fgets(temp, PATH_MAX, fp);
        translate(temp, lookpath);

        for (n = 0; srchp[nfp][n]; n++)
                free(srchp[nfp][n]);

        n = 0;
        pt = strtok(lookpath, separ);
        if (pt && *pt) {
                do {
                        if (*pt != '/') {
                                /* make relative path an absolute directory */
                                (void) snprintf(temp, sizeof (temp),
                                                "%s/%s", dname[nfp], pt);
                                pt = temp;
                        }
                        canonize(pt);
                        srchp[nfp][n++] = qstrdup(pt);
                } while (pt = strtok(NULL, separ));
                srchp[nfp][n] = NULL;
        }
}

static void
dorsearch(void)
{
        char temp[PATH_MAX], lookpath[PATH_MAX], *pt;
        int n;

        (void) fgets(temp, PATH_MAX, fp);
        translate(temp, lookpath);

        for (n = 0; rootp[nfp][n]; n++)
                free(rootp[nfp][n]);

        n = 0;
        pt = strtok(lookpath, separ);
        do {
                if (*pt != '/') {
                        /* make relative path an absolute directory */
                        (void) snprintf(temp, sizeof (temp),
                                        "%s/%s", dname[nfp], pt);
                        pt = temp;
                }
                canonize(pt);
                rootp[nfp][n++] = qstrdup(pt);
        } while (pt = strtok(NULL, separ));
        rootp[nfp][n] = NULL;
}

/*
 * This function reads the default mode, owner and group from the prototype
 * file and makes that available.
 */
static int
doattrib(void)
{
        char *pt, attrib[PATH_MAX], *mode_ptr, *owner_ptr, *group_ptr, *eol;
        int mode;
        char owner[ATRSIZ+1], group[ATRSIZ+1], attrib_save[(4*ATRSIZ)];

        (void) fgets(attrib, PATH_MAX, fp);

        (void) strlcpy(attrib_save, attrib, sizeof (attrib_save));

        /*
         * Now resolve any variables that may be present. Start on group and
         * move backward since that keeps the resolved string from
         * overwriting any of the other entries. This is required since
         * mapvar() writes the resolved string over the string provided.
         */
        mode_ptr = strtok(attrib, " \t");
        owner_ptr = strtok(NULL, " \t");
        group_ptr = strtok(NULL, " \t\n");
        eol = strtok(NULL, " \t\n");
        if (strtok(NULL, " \t\n")) {
                /* extra tokens on the line */
                error(1);
                logerr(gettext(MSG_GARBDEFLT), (eol) ? eol :
                    gettext("unreadable at end of line"));
                return (1);
        }

        if (group_ptr && mapvar(1, group_ptr) == 0)
                (void) strncpy(group, group_ptr, ATRSIZ);
        else {
                error(1);
                logerr(gettext(MSG_GARBDEFLT), (attrib_save) ?
                    ((attrib_save[0]) ? attrib_save : gettext("none")) :
                    gettext("unreadable at group"));
                return (1);
        }

        if (owner_ptr && mapvar(1, owner_ptr) == 0)
                (void) strncpy(owner, owner_ptr, ATRSIZ);
        else {
                error(1);
                logerr(gettext(MSG_GARBDEFLT), (attrib_save) ?
                    ((attrib_save[0]) ? attrib_save : gettext("none")) :
                    gettext("unreadable at owner"));
                return (1);
        }

        /*
         * For mode, don't use scanf, since we want to force an octal
         * interpretation and need to limit the length of the owner and group
         * specifications.
         */
        if (mode_ptr && mapvar(1, mode_ptr) == 0)
                mode = strtol(mode_ptr, &pt, 8);
        else {
                error(1);
                logerr(gettext(MSG_GARBDEFLT), (attrib_save) ?
                    ((attrib_save[0]) ? attrib_save : gettext("none")) :
                    gettext("unreadable at mode"));
                return (1);
        }

        /* free any previous memory from qstrdup */
        if (d_own[nfp])
                free(d_own[nfp]);
        if (d_grp[nfp])
                free(d_grp[nfp]);

        d_mod[nfp] = mode;
        d_own[nfp] = qstrdup(owner);
        d_grp[nfp] = qstrdup(group);

        attrpreset(d_mod[nfp], d_own[nfp], d_grp[nfp]);

        return (0);
}

static void
doinclude(void)
{
        char    file[PATH_MAX];
        char    temp[PATH_MAX];

        (void) fgets(temp, PATH_MAX, fp);

        /*
         * IMPORTANT NOTE: THE SIZE OF temp IS HARD CODED INTO THE
         * FOLLOWING CALL TO fscanf -- YOU MUST CHANGE THIS LINE IF
         * THE SIZE OF fscanf IS EVER CHANGED!!!
         */
        (void) sscanf(temp, "%1024s", file);

        translate(file, temp);
        canonize(temp);

        if (*temp == '\0')
                return;
        else if (*temp != '/')
                (void) snprintf(file, sizeof (file), "%s/%s", dname[nfp], temp);
        else
                (void) strlcpy(file, temp, sizeof (file));

        canonize(file);
        pushenv(file);
}

/*
 * This does what mappath() does except that it does it for ALL variables
 * using whitespace as a token separator. This is used to resolve search
 * paths and assignment statements. It doesn't effect the build versus
 * install decision made for pkgmap variables.
 */
static void
translate(register char *pt, register char *copy)
{
        char *pt2, varname[MAX_PKG_PARAM_LENGTH];

token:
        /* eat white space */
        while (isspace(*pt))
                pt++;
        while (*pt && !isspace(*pt)) {
                if (*pt == '$') {
                        pt2 = varname;
                        while (*++pt && !strchr("/= \t\n\r", *pt))
                                *pt2++ = *pt;
                        *pt2 = '\0';
                        if (pt2 = getenv(varname)) {
                                while (*pt2)
                                        *copy++ = *pt2++;
                        }
                } else
                        *copy++ = *pt++;
        }
        if (*pt) {
                *copy++ = ' ';
                goto token;
        }
        *copy = '\0';
}

static void
error(int flag)
{
        static char *lasterr = NULL;

        if (lasterr != proto[nfp]) {
                lasterr = proto[nfp];
                (void) fprintf(stderr, gettext("ERROR in %s:\n"), lasterr);
        }
        if (flag)
                errflg++;
}

/* Set up defaults and change to the build directory. */
static void
pushenv(char *file)
{
        register char *pt;
        static char     topdir[PATH_MAX];

        if ((nfp+1) >= NRECURS) {
                error(1);
                logerr(gettext(MSG_NRECURS), NRECURS);
                logerr(gettext(MSG_IGNINCLUDE), file);
                return;
        }

        if (strcmp(file, "-") == 0) {
                fp = stdin;
        } else if ((fp = fopen(file, "r")) == NULL) {
                error(1);
                logerr(gettext(MSG_RDINCLUDE), file, errno);
                if (nfp >= 0) {
                        logerr(gettext(MSG_IGNINCLUDE), file);
                        fp = sfp[nfp];
                        return;
                } else
                        quit(1);
        }
        sfp[++nfp] = fp;
        srchp[nfp][0] = NULL;
        rootp[nfp][0] = NULL;
        d_mod[nfp] = (mode_t)(-1);
        d_own[nfp] = NULL;
        d_grp[nfp] = NULL;

        if (!nfp) {
                /* upper level proto file */
                proto[nfp] = file;
                if (file[0] == '/')
                        pt = strcpy(topdir, file);
                else {
                        /* path is relative to the prototype file specified */
                        pt = getcwd(NULL, PATH_MAX);
                        if (pt == NULL) {
                                progerr(gettext(ERR_GETCWD), errno);
                                quit(99);
                        }
                        (void) snprintf(topdir, sizeof (topdir),
                                                "%s/%s", pt, file);
                }
                if (pt = strrchr(topdir, '/'))
                        *pt = '\0'; /* should always happen */
                if (topdir[0] == '\0')
                        (void) strlcpy(topdir, "/", sizeof (topdir));
                dname[nfp] = topdir;
        } else {
                proto[nfp] = qstrdup(file);
                dname[nfp] = qstrdup(file);
                if (pt = strrchr(dname[nfp], '/'))
                        *pt = '\0';
                else {
                        /* same directory as the last prototype */
                        free(dname[nfp]);
                        dname[nfp] = qstrdup(dname[nfp-1]);
                        return; /* no need to canonize() or chdir() */
                }
        }

        canonize(dname[nfp]);

        if (chdir(dname[nfp])) {
                error(1);
                logerr(gettext(MSG_CHDIR), dname[nfp]);
                if (!nfp)
                        quit(1); /* must be able to cd to upper level */
                logerr(gettext(MSG_IGNINCLUDE), proto[nfp]);
                (void) popenv();
        }
}

/* Restore defaults and return to the prior directory. */
static int
popenv(void)
{
        int i;

        (void) fclose(fp);
        if (nfp) {
                if (proto[nfp])
                        free(proto[nfp]);
                if (dname[nfp])
                        free(dname[nfp]);
                for (i = 0; srchp[nfp][i]; i++)
                        free(srchp[nfp][i]);
                for (i = 0; rootp[nfp][i]; i++)
                        free(rootp[nfp][i]);
                if (d_own[nfp])
                        free(d_own[nfp]);
                if (d_grp[nfp])
                        free(d_grp[nfp]);

                fp = sfp[--nfp];

                if (chdir(dname[nfp])) {
                        error(1);
                        logerr(gettext(MSG_CHDIR), dname[nfp]);
                        logerr(gettext(MSG_INCOMPLETE), proto[nfp]);
                        return (popenv());
                }
                return (1);
        }
        return (0);
}

/*
 * If this parameter isn't already in place, put it into the local
 * environment. This means that command line directives override prototype
 * file directives.
 */
static void
lputenv(char *s)
{
        char *pt;
        int i;

        pt = strchr(s, '=');
        if (!pt)
                return;

        *pt = '\0';
        for (i = 0; i < nrdonly; i++) {
                if (strcmp(rdonly[i], s) == 0) {
                        *pt = '=';
                        return;
                }
        }
        *pt = '=';

        if (putenv(qstrdup(s))) {
                progerr(gettext(ERR_ENVBUILD), errno);
                quit(99);
        }
}

static char *
srchroot(char *path, char *copy)
{
        struct stat statbuf;
        int i;

        i = 0;
        root = rootlist[i++];
        do {
                /* convert with root & basedir info */
                cvtpath(path, copy);
                /* make it pretty again */
                canonize(copy);

                if (stat(copy, &statbuf) || !(statbuf.st_mode & S_IFREG)) {
                        root = rootlist[i++];
                        continue; /* host source must be a regular file */
                }
                return (copy);
        } while (root != NULL);
        error(1);
        logerr(gettext(MSG_SRCHROOT), path);
        return (NULL);
}