/*      $NetBSD: lcl_ng.c,v 1.1.1.2 2012/09/09 16:07:54 christos Exp $  */

/*
* Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
* Copyright (c) 1996-1999 by Internet Software Consortium.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

#if !defined(LINT) && !defined(CODECENTER)
static const char rcsid[] = "Id: lcl_ng.c,v 1.3 2005/04/27 04:56:31 sra Exp ";
#endif

/* Imports */

#include "port_before.h"

#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/nameser.h>
#include <resolv.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <irs.h>
#include <isc/memcluster.h>

#include "port_after.h"

#include "irs_p.h"
#include "lcl_p.h"

/* Definitions */

#define NG_HOST         0       /*%< Host name */
#define NG_USER         1       /*%< User name */
#define NG_DOM          2       /*%< and Domain name */
#define LINSIZ          1024    /*%< Length of netgroup file line */
/*
* XXX Warning XXX
* This code is a hack-and-slash special.  It realy needs to be
* rewritten with things like strdup, and realloc in mind.
* More reasonable data structures would not be a bad thing.
*/

/*%
* Static Variables and functions used by setnetgrent(), getnetgrent() and
* endnetgrent().
*
* There are two linked lists:
* \li linelist is just used by setnetgrent() to parse the net group file via.
*   parse_netgrp()
* \li netgrp is the list of entries for the current netgroup
*/
struct linelist {
       struct linelist *l_next;        /*%< Chain ptr. */
       int             l_parsed;       /*%< Flag for cycles */
       char *          l_groupname;    /*%< Name of netgroup */
       char *          l_line;         /*%< Netgroup entrie(s) to be parsed */
};

struct ng_old_struct {
       struct ng_old_struct *ng_next;  /*%< Chain ptr */
       char *          ng_str[3];      /*%< Field pointers, see below */
};

struct pvt {
       FILE                    *fp;
       struct linelist         *linehead;
       struct ng_old_struct    *nextgrp;
       struct {
               struct ng_old_struct    *gr;
               char                    *grname;
       } grouphead;
};

/* Forward */

static void             ng_rewind(struct irs_ng *, const char*);
static void             ng_close(struct irs_ng *);
static int              ng_next(struct irs_ng *, const char **,
                               const char **, const char **);
static int              ng_test(struct irs_ng *, const char *,
                               const char *, const char *,
                               const char *);
static void             ng_minimize(struct irs_ng *);

static int              parse_netgrp(struct irs_ng *, const char*);
static struct linelist *read_for_group(struct irs_ng *, const char *);
static void             freelists(struct irs_ng *);

/* Public */

struct irs_ng *
irs_lcl_ng(struct irs_acc *this) {
       struct irs_ng *ng;
       struct pvt *pvt;

       UNUSED(this);

       if (!(ng = memget(sizeof *ng))) {
               errno = ENOMEM;
               return (NULL);
       }
       memset(ng, 0x5e, sizeof *ng);
       if (!(pvt = memget(sizeof *pvt))) {
               memput(ng, sizeof *ng);
               errno = ENOMEM;
               return (NULL);
       }
       memset(pvt, 0, sizeof *pvt);
       ng->private = pvt;
       ng->close = ng_close;
       ng->next = ng_next;
       ng->test = ng_test;
       ng->rewind = ng_rewind;
       ng->minimize = ng_minimize;
       return (ng);
}

/* Methods */

static void
ng_close(struct irs_ng *this) {
       struct pvt *pvt = (struct pvt *)this->private;

       if (pvt->fp != NULL)
               fclose(pvt->fp);
       freelists(this);
       memput(pvt, sizeof *pvt);
       memput(this, sizeof *this);
}

/*%
* Parse the netgroup file looking for the netgroup and build the list
* of netgrp structures. Let parse_netgrp() and read_for_group() do
* most of the work.
*/
static void
ng_rewind(struct irs_ng *this, const char *group) {
       struct pvt *pvt = (struct pvt *)this->private;

       if (pvt->fp != NULL && fseek(pvt->fp, SEEK_CUR, 0L) == -1) {
               fclose(pvt->fp);
               pvt->fp = NULL;
       }

       if (pvt->fp == NULL || pvt->grouphead.gr == NULL ||
           strcmp(group, pvt->grouphead.grname)) {
               freelists(this);
               if (pvt->fp != NULL)
                       fclose(pvt->fp);
               pvt->fp = fopen(_PATH_NETGROUP, "r");
               if (pvt->fp != NULL) {
                       if (parse_netgrp(this, group))
                               freelists(this);
                       if (!(pvt->grouphead.grname = strdup(group)))
                               freelists(this);
                       fclose(pvt->fp);
                       pvt->fp = NULL;
               }
       }
       pvt->nextgrp = pvt->grouphead.gr;
}

/*%
* Get the next netgroup off the list.
*/
static int
ng_next(struct irs_ng *this, const char **host, const char **user,
       const char **domain)
{
       struct pvt *pvt = (struct pvt *)this->private;

       if (pvt->nextgrp) {
               *host = pvt->nextgrp->ng_str[NG_HOST];
               *user = pvt->nextgrp->ng_str[NG_USER];
               *domain = pvt->nextgrp->ng_str[NG_DOM];
               pvt->nextgrp = pvt->nextgrp->ng_next;
               return (1);
       }
       return (0);
}

/*%
* Search for a match in a netgroup.
*/
static int
ng_test(struct irs_ng *this, const char *name,
       const char *host, const char *user, const char *domain)
{
       const char *ng_host, *ng_user, *ng_domain;

       ng_rewind(this, name);
       while (ng_next(this, &ng_host, &ng_user, &ng_domain))
               if ((host == NULL || ng_host == NULL ||
                    !strcmp(host, ng_host)) &&
                   (user ==  NULL || ng_user == NULL ||
                    !strcmp(user, ng_user)) &&
                   (domain == NULL || ng_domain == NULL ||
                    !strcmp(domain, ng_domain))) {
                       freelists(this);
                       return (1);
               }
       freelists(this);
       return (0);
}

static void
ng_minimize(struct irs_ng *this) {
       struct pvt *pvt = (struct pvt *)this->private;

       if (pvt->fp != NULL) {
               (void)fclose(pvt->fp);
               pvt->fp = NULL;
       }
}

/* Private */

/*%
* endnetgrent() - cleanup
*/
static void
freelists(struct irs_ng *this) {
       struct pvt *pvt = (struct pvt *)this->private;
       struct linelist *lp, *olp;
       struct ng_old_struct *gp, *ogp;

       lp = pvt->linehead;
       while (lp) {
               olp = lp;
               lp = lp->l_next;
               free(olp->l_groupname);
               free(olp->l_line);
               free((char *)olp);
       }
       pvt->linehead = NULL;
       if (pvt->grouphead.grname) {
               free(pvt->grouphead.grname);
               pvt->grouphead.grname = NULL;
       }
       gp = pvt->grouphead.gr;
       while (gp) {
               ogp = gp;
               gp = gp->ng_next;
               if (ogp->ng_str[NG_HOST])
                       free(ogp->ng_str[NG_HOST]);
               if (ogp->ng_str[NG_USER])
                       free(ogp->ng_str[NG_USER]);
               if (ogp->ng_str[NG_DOM])
                       free(ogp->ng_str[NG_DOM]);
               free((char *)ogp);
       }
       pvt->grouphead.gr = NULL;
}

/*%
* Parse the netgroup file setting up the linked lists.
*/
static int
parse_netgrp(struct irs_ng *this, const char *group) {
       struct pvt *pvt = (struct pvt *)this->private;
       char *spos, *epos;
       int len, strpos;
       char *pos, *gpos;
       struct ng_old_struct *grp;
       struct linelist *lp = pvt->linehead;

       /*
        * First, see if the line has already been read in.
        */
       while (lp) {
               if (!strcmp(group, lp->l_groupname))
                       break;
               lp = lp->l_next;
       }
       if (lp == NULL &&
           (lp = read_for_group(this, group)) == NULL)
               return (1);
       if (lp->l_parsed) {
               /*fprintf(stderr, "Cycle in netgroup %s\n", lp->l_groupname);*/
               return (1);
       } else
               lp->l_parsed = 1;
       pos = lp->l_line;
       while (*pos != '\0') {
               if (*pos == '(') {
                       if (!(grp = malloc(sizeof (struct ng_old_struct)))) {
                               freelists(this);
                               errno = ENOMEM;
                               return (1);
                       }
                       memset(grp, 0, sizeof (struct ng_old_struct));
                       grp->ng_next = pvt->grouphead.gr;
                       pvt->grouphead.gr = grp;
                       pos++;
                       gpos = strsep(&pos, ")");
                       for (strpos = 0; strpos < 3; strpos++) {
                               if ((spos = strsep(&gpos, ","))) {
                                       while (*spos == ' ' || *spos == '\t')
                                               spos++;
                                       if ((epos = strpbrk(spos, " \t"))) {
                                               *epos = '\0';
                                               len = epos - spos;
                                       } else
                                               len = strlen(spos);
                                       if (len > 0) {
                                               if(!(grp->ng_str[strpos]
                                                  =  (char *)
                                                  malloc(len + 1))) {
                                                       freelists(this);
                                                       return (1);
                                               }
                                               memcpy(grp->ng_str[strpos],
                                                      spos,
                                                      len + 1);
                                       }
                               } else
                                       goto errout;
                       }
               } else {
                       spos = strsep(&pos, ", \t");
                       if (spos != NULL && parse_netgrp(this, spos)) {
                               freelists(this);
                               return (1);
                       }
               }
               if (pos == NULL)
                       break;
               while (*pos == ' ' || *pos == ',' || *pos == '\t')
                       pos++;
       }
       return (0);
errout:
       /*fprintf(stderr, "Bad netgroup %s at ..%s\n", lp->l_groupname,
                 spos);*/
       return (1);
}

/*%
* Read the netgroup file and save lines until the line for the netgroup
* is found. Return 1 if eof is encountered.
*/
static struct linelist *
read_for_group(struct irs_ng *this, const char *group) {
       struct pvt *pvt = (struct pvt *)this->private;
       char *pos, *spos, *linep = NULL, *olinep;
       int len, olen, cont;
       struct linelist *lp;
       char line[LINSIZ + 1];

       while (fgets(line, LINSIZ, pvt->fp) != NULL) {
               pos = line;
               if (*pos == '#')
                       continue;
               while (*pos == ' ' || *pos == '\t')
                       pos++;
               spos = pos;
               while (*pos != ' ' && *pos != '\t' && *pos != '\n' &&
                       *pos != '\0')
                       pos++;
               len = pos - spos;
               while (*pos == ' ' || *pos == '\t')
                       pos++;
               if (*pos != '\n' && *pos != '\0') {
                       if (!(lp = malloc(sizeof (*lp)))) {
                               freelists(this);
                               return (NULL);
                       }
                       lp->l_parsed = 0;
                       if (!(lp->l_groupname = malloc(len + 1))) {
                               free(lp);
                               freelists(this);
                               return (NULL);
                       }
                       memcpy(lp->l_groupname, spos,  len);
                       *(lp->l_groupname + len) = '\0';
                       len = strlen(pos);
                       olen = 0;
                       olinep = NULL;

                       /*
                        * Loop around handling line continuations.
                        */
                       do {
                               if (*(pos + len - 1) == '\n')
                                       len--;
                               if (*(pos + len - 1) == '\\') {
                                       len--;
                                       cont = 1;
                               } else
                                       cont = 0;
                               if (len > 0) {
                                       if (!(linep = malloc(olen + len + 1))){
                                               if (olen > 0)
                                                       free(olinep);
                                               free(lp->l_groupname);
                                               free(lp);
                                               freelists(this);
                                               errno = ENOMEM;
                                               return (NULL);
                                       }
                                       if (olen > 0) {
                                               memcpy(linep, olinep, olen);
                                               free(olinep);
                                       }
                                       memcpy(linep + olen, pos, len);
                                       olen += len;
                                       *(linep + olen) = '\0';
                                       olinep = linep;
                               }
                               if (cont) {
                                       if (fgets(line, LINSIZ, pvt->fp)) {
                                               pos = line;
                                               len = strlen(pos);
                                       } else
                                               cont = 0;
                               }
                       } while (cont);
                       lp->l_line = linep;
                       lp->l_next = pvt->linehead;
                       pvt->linehead = lp;

                       /*
                        * If this is the one we wanted, we are done.
                        */
                       if (!strcmp(lp->l_groupname, group))
                               return (lp);
               }
       }
       return (NULL);
}

/*! \file */

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.