InfoMagic Source Code 1993 July/THE_SOURCE_CODE_CD_ROM.iso/X/mit/clients/xdm/verify.c

C/C++ Source or Header | 1991-07-18 | 5.0 KB | 237 lines

/*
 * xdm - display manager daemon
 *
 * $XConsortium: verify.c,v 1.24 91/07/18 22:22:45 rws Exp $
 *
 * Copyright 1988 Massachusetts Institute of Technology
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose and without fee is hereby granted, provided
 * that the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of M.I.T. not be used in advertising or
 * publicity pertaining to distribution of the software without specific,
 * written prior permission.  M.I.T. makes no representations about the
 * suitability of this software for any purpose.  It is provided "as is"
 * without express or implied warranty.
 *
 * Author:  Keith Packard, MIT X Consortium
 */

/*
 * verify.c
 *
 * typical unix verification routine.
 */

# include    "dm.h"
# include    <pwd.h>
# ifdef NGROUPS_MAX
# include    <grp.h>
# endif
#ifdef USESHADOW
# include    <shadow.h>
#endif
#ifdef X_NOT_STDC_ENV
char *getenv();
#endif

struct passwd joeblow = {
    "Nobody", "***************"
};

#ifdef USESHADOW
struct spwd spjoeblow = {
    "Nobody", "**************"
};
#endif

static char *envvars[] = {
#if defined(sony) && !defined(SYSTYPE_SYSV)
    "bootdev",
    "boothowto",
    "cputype",
    "ioptype",
    "machine",
    "model",
    "CONSDEVTYPE",
    "SYS_LANGUAGE",
    "SYS_CODE",
    "TZ",
#endif
    NULL
};

Verify (d, greet, verify)
struct display        *d;
struct greet_info    *greet;
struct verify_info    *verify;
{
    struct passwd    *p;
#ifdef USESHADOW
    struct spwd    *sp;
#endif
    char        *crypt ();
    char        **userEnv (), **systemEnv (), **parseArgs ();
    char        *shell, *home;
    char        **argv;

    Debug ("Verify %s ...\n", greet->name);
    p = getpwnam (greet->name);
    if (!p || strlen (greet->name) == 0)
        p = &joeblow;
#ifdef USESHADOW
    sp = getspnam(greet->name);
    if (sp == NULL) {
        sp = &spjoeblow;
        Debug ("getspnam() failed.  Are you root?\n");
    }
    endspent();

    if (strcmp (crypt (greet->password, sp->sp_pwdp), sp->sp_pwdp))
#else
    if (strcmp (crypt (greet->password, p->pw_passwd), p->pw_passwd))
#endif
    {
        Debug ("verify failed\n");
        bzero(greet->password, strlen(greet->password));
        return 0;
    }
    Debug ("verify succeeded\n");
/*    bzero(greet->password, strlen(greet->password)); */
    verify->uid = p->pw_uid;
#ifdef NGROUPS_MAX
    getGroups (greet->name, verify, p->pw_gid);
#else
    verify->gid = p->pw_gid;
#endif
    home = p->pw_dir;
    shell = p->pw_shell;
    argv = 0;
    if (d->session)
        argv = parseArgs (argv, d->session);
    if (greet->string)
        argv = parseArgs (argv, greet->string);
    if (!argv)
        argv = parseArgs (argv, "xsession");
    verify->argv = argv;
    verify->userEnviron = userEnv (d, p->pw_uid == 0,
                       greet->name, home, shell);
    Debug ("user environment:\n");
    printEnv (verify->userEnviron);
    verify->systemEnviron = systemEnv (d, greet->name, home);
    Debug ("system environment:\n");
    printEnv (verify->systemEnviron);
    Debug ("end of environments\n");
    return 1;
}

extern char **setEnv ();

char **
defaultEnv ()
{
    char    **env, **exp, *value;

    env = 0;
    for (exp = exportList; exp && *exp; ++exp)
    {
    value = getenv (*exp);
    if (value)
        env = setEnv (env, *exp, value);
    }
    return env;
}

char **
userEnv (d, useSystemPath, user, home, shell)
struct display    *d;
int    useSystemPath;
char    *user, *home, *shell;
{
    char    **env;
    char    **envvar;
    char    *str;

    env = defaultEnv ();
    env = setEnv (env, "DISPLAY", d->name);
    env = setEnv (env, "HOME", home);
    env = setEnv (env, "USER", user);
    env = setEnv (env, "PATH", useSystemPath ? d->systemPath : d->userPath);
    env = setEnv (env, "SHELL", shell);
    for (envvar = envvars; *envvar; envvar++)
    {
    if (str = getenv(*envvar))
        env = setEnv (env, *envvar, str);
    }
    return env;
}

char **
systemEnv (d, user, home)
struct display    *d;
char    *user, *home;
{
    char    **env;

    env = defaultEnv ();
    env = setEnv (env, "DISPLAY", d->name);
    if (home)
    env = setEnv (env, "HOME", home);
    if (user)
    env = setEnv (env, "USER", user);
    env = setEnv (env, "PATH", d->systemPath);
    env = setEnv (env, "SHELL", d->systemShell);
    if (d->authFile)
        env = setEnv (env, "XAUTHORITY", d->authFile);
    return env;
}

#ifdef NGROUPS_MAX
groupMember (name, members)
char    *name;
char    **members;
{
    while (*members) {
        if (!strcmp (name, *members))
            return 1;
        ++members;
    }
    return 0;
}

getGroups (name, verify, gid)
char            *name;
struct verify_info    *verify;
int            gid;
{
    int        ngroups;
    struct group    *g;
    int        i;

    ngroups = 0;
    verify->groups[ngroups++] = gid;
    setgrent ();
    /* SUPPRESS 560 */
    while (g = getgrent()) {
        /*
         * make the list unique
         */
        for (i = 0; i < ngroups; i++)
            if (verify->groups[i] == g->gr_gid)
                break;
        if (i != ngroups)
            continue;
        if (groupMember (name, g->gr_mem)) {
            if (ngroups >= NGROUPS_MAX)
                LogError ("%s belongs to more than %d groups, %s ignored\n",
                    name, NGROUPS_MAX, g->gr_name);
            else
                verify->groups[ngroups++] = g->gr_gid;
        }
    }
    verify->ngroups = ngroups;
    endgrent ();
}
#endif