/*      $NetBSD: pcnfsd_v2.c,v 1.14 2018/01/23 21:06:25 sevan Exp $     */

/* RE_SID: @(%)/usr/dosnfs/shades_SCCS/unix/pcnfsd/v2/src/SCCS/s.pcnfsd_v2.c 1.2 91/12/18 13:26:13 SMI */
/*
**=====================================================================
** Copyright (c) 1986,1987,1988,1989,1990,1991 by Sun Microsystems, Inc.
**      @(#)pcnfsd_v2.c 1.2     12/18/91
**=====================================================================
*/
/*
**=====================================================================
**             I N C L U D E   F I L E   S E C T I O N                *
**                                                                    *
** If your port requires different include files, add a suitable      *
** #define in the customization section, and make the inclusion or    *
** exclusion of the files conditional on this.                        *
**=====================================================================
*/

#include <sys/file.h>
#include <sys/ioctl.h>
#include <sys/stat.h>

#include <grp.h>
#include <netdb.h>
#include <pwd.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#ifdef USE_YP
#include <rpcsvc/ypclnt.h>
#endif

#ifndef SYSV
#include <sys/wait.h>
#endif

#ifdef ISC_2_0
#include <sys/fcntl.h>
#endif

#ifdef SHADOW_SUPPORT
#include <shadow.h>
#endif

#include "common.h"
#include "pcnfsd.h"
#include "extern.h"

/*
**=====================================================================
**                      C O D E   S E C T I O N                       *
**=====================================================================
*/


static char no_comment[] = "No comment";
static char not_supported[] = "Not supported";
static char pcnfsd_version[] = "@(#)pcnfsd_v2.c 1.2 - rpc.pcnfsd V2.0 (c) 1991 Sun Technology Enterprises, Inc.";

/*ARGSUSED*/
void   *
pcnfsd2_null_2_svc(void *arg, struct svc_req *req)
{
       static char dummy;
       return ((void *) &dummy);
}

v2_auth_results *
pcnfsd2_auth_2_svc(v2_auth_args *arg, struct svc_req *req)
{
       static v2_auth_results r;

       char    uname[32];
       char    pw[64];
       int     c1, c2;
       struct passwd *p;
       static u_int extra_gids[EXTRAGIDLEN];
       static char home[256];
#ifdef USE_YP
       char   *yphome;
       char   *cp;
#endif                          /* USE_YP */


       r.stat = AUTH_RES_FAIL; /* assume failure */
       r.uid = (int) -2;
       r.gid = (int) -2;
       r.cm = &no_comment[0];
       r.gids.gids_len = 0;
       r.gids.gids_val = &extra_gids[0];
       home[0] = '\0';
       r.home = &home[0];
       r.def_umask = umask(0);
       (void) umask(r.def_umask);      /* or use 022 */

       scramble(arg->id, uname);
       scramble(arg->pw, pw);

#ifdef USER_CACHE
       if (check_cache(uname, pw, &r.uid, &r.gid)) {
               r.stat = AUTH_RES_OK;
#ifdef WTMP
               wlogin(uname, req);
#endif
               fillin_extra_groups
                   (uname, r.gid, &r.gids.gids_len, extra_gids);
#ifdef USE_YP
               yphome = find_entry(uname, "auto.home");
               if (yphome) {
                       strlcpy(home, yphome, sizeof(home));
                       free(yphome);
                       cp = strchr(home, ':');
                       cp++;
                       cp = strchr(cp, ':');
                       if (cp)
                               *cp = '/';
               }
#endif
               return (&r);
       }
#endif

       p = get_password(uname);
       if (p == NULL)
               return (&r);

       c1 = strlen(pw);
       c2 = strlen(p->pw_passwd);
       if ((c1 && !c2) || (c2 && !c1) ||
           (strcmp(p->pw_passwd, crypt(pw, p->pw_passwd)))) {
               return (&r);
       }
       r.stat = AUTH_RES_OK;
       r.uid = p->pw_uid;
       r.gid = p->pw_gid;
#ifdef WTMP
       wlogin(uname, req);
#endif
       fillin_extra_groups(uname, r.gid, &r.gids.gids_len, extra_gids);

#ifdef USE_YP
       yphome = find_entry(uname, "auto.home");
       if (yphome) {
               strlcpy(home, yphome, sizeof(home));
               free(yphome);
               cp = strchr(home, ':');
               cp++;
               cp = strchr(cp, ':');
               if (cp)
                       *cp = '/';
       }
#endif

#ifdef USER_CACHE
       add_cache_entry(p);
#endif

       return (&r);

}

v2_pr_init_results *
pcnfsd2_pr_init_2_svc(v2_pr_init_args *arg, struct svc_req *req)
{
       static v2_pr_init_results res;

       res.stat =
           (pirstat) pr_init(arg->system, arg->pn, &res.dir);
       res.cm = &no_comment[0];


       return (&res);
}

v2_pr_start_results *
pcnfsd2_pr_start_2_svc(v2_pr_start_args *arg, struct svc_req *req)
{
       static v2_pr_start_results res;

       res.stat =
           (psrstat) pr_start2(arg->system, arg->pn, arg->user,
           arg->file, arg->opts, &res.id);
       res.cm = &no_comment[0];

       return (&res);
}
/*ARGSUSED*/
v2_pr_list_results *
pcnfsd2_pr_list_2_svc(void *arg, struct svc_req *req)
{
       static v2_pr_list_results res;

       if (printers == NULL)
               (void) build_pr_list();
       res.cm = &no_comment[0];
       res.printers = printers;

       return (&res);
}

v2_pr_queue_results *
pcnfsd2_pr_queue_2_svc(v2_pr_queue_args *arg, struct svc_req *req)
{
       static v2_pr_queue_results res;

       res.stat = build_pr_queue(arg->pn, arg->user,
           arg->just_mine, &res.qlen, &res.qshown);
       res.cm = &no_comment[0];
       res.just_yours = arg->just_mine;
       res.jobs = queue;


       return (&res);
}

v2_pr_status_results *
pcnfsd2_pr_status_2_svc(v2_pr_status_args *arg, struct svc_req *req)
{
       static v2_pr_status_results res;
       static char status[128];

       res.stat = get_pr_status(arg->pn, &res.avail, &res.printing,
           &res.qlen, &res.needs_operator, &status[0], sizeof(status));
       res.status = &status[0];
       res.cm = &no_comment[0];

       return (&res);
}

v2_pr_cancel_results *
pcnfsd2_pr_cancel_2_svc(v2_pr_cancel_args *arg, struct svc_req *req)
{
       static v2_pr_cancel_results res;

       res.stat = pr_cancel(arg->pn, arg->user, arg->id);
       res.cm = &no_comment[0];

       return (&res);
}
/*ARGSUSED*/
v2_pr_requeue_results *
pcnfsd2_pr_requeue_2_svc(v2_pr_requeue_args *arg, struct svc_req *req)
{
       static v2_pr_requeue_results res;
       res.stat = PC_RES_FAIL;
       res.cm = &not_supported[0];

       return (&res);
}
/*ARGSUSED*/
v2_pr_hold_results *
pcnfsd2_pr_hold_2_svc(v2_pr_hold_args *arg, struct svc_req *req)
{
       static v2_pr_hold_results res;

       res.stat = PC_RES_FAIL;
       res.cm = &not_supported[0];

       return (&res);
}
/*ARGSUSED*/
v2_pr_release_results *
pcnfsd2_pr_release_2_svc(v2_pr_release_args *arg, struct svc_req *req)
{
       static v2_pr_release_results res;

       res.stat = PC_RES_FAIL;
       res.cm = &not_supported[0];

       return (&res);
}
/*ARGSUSED*/
v2_pr_admin_results *
pcnfsd2_pr_admin_2_svc(v2_pr_admin_args *arg, struct svc_req *req)
{
       static v2_pr_admin_results res;
/*
** The default action for admin is to fail.
** If someone wishes to implement an administration
** mechanism, and isn't worried about the security
** holes, go right ahead.
*/

       res.cm = &not_supported[0];
       res.stat = PI_RES_FAIL;

       return (&res);
}

void
free_mapreq_results(mapreq_res p)
{
       if (p->mapreq_next)
               free_mapreq_results(p->mapreq_next);    /* recurse */
       if (p->name)
               (void) free(p->name);
       (void) free(p);
       return;
}

static char *my_strdup(const char *);

static char *
my_strdup(const char *s)
{
       size_t len;
       char   *r;
       len = strlen(s);
       r = (char *) grab(len + 1);
       memcpy(r, s, len + 1);
       return (r);
}

v2_mapid_results *
pcnfsd2_mapid_2_svc(v2_mapid_args *arg, struct svc_req *req)
{
       static v2_mapid_results res;
       struct passwd *p_passwd;
       struct group *p_group;

       mapreq_arg a;
       mapreq_res next_r;
       mapreq_res last_r = NULL;


       if (res.res_list) {
               free_mapreq_results(res.res_list);
               res.res_list = NULL;
       }
       a = arg->req_list;
       while (a) {
               next_r = (struct mapreq_res_item *)
                   grab(sizeof(struct mapreq_res_item));
               next_r->stat = MAP_RES_UNKNOWN;
               next_r->req = a->req;
               next_r->id = a->id;
               next_r->name = NULL;
               next_r->mapreq_next = NULL;

               if (last_r == NULL)
                       res.res_list = next_r;
               else
                       last_r->mapreq_next = next_r;
               last_r = next_r;
               switch (a->req) {
               case MAP_REQ_UID:
                       p_passwd = getpwuid((uid_t) a->id);
                       if (p_passwd) {
                               next_r->name = my_strdup(p_passwd->pw_name);
                               next_r->stat = MAP_RES_OK;
                       }
                       break;
               case MAP_REQ_GID:
                       p_group = getgrgid((gid_t) a->id);
                       if (p_group) {
                               next_r->name = my_strdup(p_group->gr_name);
                               next_r->stat = MAP_RES_OK;
                       }
                       break;
               case MAP_REQ_UNAME:
                       next_r->name = my_strdup(a->name);
                       p_passwd = getpwnam(a->name);
                       if (p_passwd) {
                               next_r->id = p_passwd->pw_uid;
                               next_r->stat = MAP_RES_OK;
                       }
                       break;
               case MAP_REQ_GNAME:
                       next_r->name = my_strdup(a->name);
                       p_group = getgrnam(a->name);
                       if (p_group) {
                               next_r->id = p_group->gr_gid;
                               next_r->stat = MAP_RES_OK;
                       }
                       break;
               }
               if (next_r->name == NULL)
                       next_r->name = my_strdup("");
               a = a->mapreq_next;
       }

       res.cm = &no_comment[0];

       return (&res);
}


/*ARGSUSED*/
v2_alert_results *
pcnfsd2_alert_2_svc(v2_alert_args *arg, struct svc_req *req)
{
       static v2_alert_results res;

       res.stat = ALERT_RES_FAIL;
       res.cm = &not_supported[0];

       return (&res);
}
/*ARGSUSED*/
v2_info_results *
pcnfsd2_info_2_svc(v2_info_args *arg, struct svc_req *req)
{
       static v2_info_results res;
       static int facilities[FACILITIESMAX];
       static int onetime = 1;

#define UNSUPPORTED -1
#define QUICK 100
#define SLOW 2000

       if (onetime) {
               onetime = 0;
               facilities[PCNFSD2_NULL] = QUICK;
               facilities[PCNFSD2_INFO] = QUICK;
               facilities[PCNFSD2_PR_INIT] = QUICK;
               facilities[PCNFSD2_PR_START] = SLOW;
               facilities[PCNFSD2_PR_LIST] = QUICK;    /* except first time */
               facilities[PCNFSD2_PR_QUEUE] = SLOW;
               facilities[PCNFSD2_PR_STATUS] = SLOW;
               facilities[PCNFSD2_PR_CANCEL] = SLOW;
               facilities[PCNFSD2_PR_ADMIN] = UNSUPPORTED;
               facilities[PCNFSD2_PR_REQUEUE] = UNSUPPORTED;
               facilities[PCNFSD2_PR_HOLD] = UNSUPPORTED;
               facilities[PCNFSD2_PR_RELEASE] = UNSUPPORTED;
               facilities[PCNFSD2_MAPID] = QUICK;
               facilities[PCNFSD2_AUTH] = QUICK;
               facilities[PCNFSD2_ALERT] = QUICK;
       }
       res.facilities.facilities_len = PCNFSD2_ALERT + 1;
       res.facilities.facilities_val = facilities;

       res.vers = &pcnfsd_version[0];
       res.cm = &no_comment[0];

       return (&res);
}



void
fillin_extra_groups(char *uname, gid_t main_gid, int *len, gid_t extra_gids[EXTRAGIDLEN])
{
       struct group *grp;
       __aconst char *__aconst *members;
       int     n = 0;

       setgrent();

       while (n < EXTRAGIDLEN) {
               grp = getgrent();
               if (grp == NULL)
                       break;
               if (grp->gr_gid == main_gid)
                       continue;
               for (members = grp->gr_mem; members && *members; members++) {
                       if (!strcmp(*members, uname)) {
                               extra_gids[n++] = grp->gr_gid;
                               break;
                       }
               }
       }
       endgrent();
       *len = n;
}

#ifdef USE_YP
/* the following is from rpcsvc/yp_prot.h */
#define YPMAXDOMAIN 64

/*
* find_entry returns NULL on any error (printing a message) and
* otherwise returns a pointer to the malloc'd result. The caller
* is responsible for free()ing the result string.
*/
char   *
find_entry(const char *key, const char *map)
{
       int     err;
       char   *val = NULL;
       char   *cp;
       int     len = 0;
       static char domain[YPMAXDOMAIN + 1];

       if (getdomainname(domain, YPMAXDOMAIN)) {
               msg_out("rpc.pcnfsd: getdomainname failed");
               return (NULL);
       }
       if ((err = yp_bind(domain)) != 0) {
#ifdef  DEBUG
               msg_out("rpc.pcnfsd: yp_bind failed");
#endif
               return (NULL);
       }
       err = yp_match(domain, map, key, strlen(key), &val, &len);

       if (err) {
               msg_out("rpc.pcnfsd: yp_match failed");
               if (val)
                       free(val);
               return (NULL);
       }
       if ((cp = strchr(val, '\n')) != NULL)
               *cp = '\0';     /* in case we get an extra NL at the end */
       return (val);
}
#endif

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.