Source Code 1994 March/Source_Code_CD-ROM_Walnut_Creek_March_1994.iso/compsrcs/unix/volume26/xinetd21/part28

Text File | 1993-06-26 | 19.6 KB | 879 lines

Newsgroups: comp.sources.unix
From: [e-mail] (Panos Tsirigotis)
Subject: v26i272: xinetd-2.1.1 - inetd replacement with access control and logging, Part28/31
Sender: [e-mail]
Approved: [e-mail]

Submitted-By: [e-mail] (Panos Tsirigotis)
Posting-Number: Volume 26, Issue 272
Archive-Name: xinetd-2.1.1/part28

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#        "End of archive 28 (of 31)."
# Contents:  xinetd/parsers.c
# Wrapped by panos@mystique on Mon Jun 21 14:51:28 1993
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'xinetd/parsers.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'xinetd/parsers.c'\"
else
echo shar: Extracting \"'xinetd/parsers.c'\" \(17457 characters\)
sed "s/^X//" >'xinetd/parsers.c' <<'END_OF_FILE'
X/*
X * (c) Copyright 1992 by Panagiotis Tsirigotis
X * All rights reserved.  The file named COPYRIGHT specifies the terms
X * and conditions for redistribution.
X */
X
Xstatic char RCSid[] = "$Id: parsers.c,v 6.4 1993/06/06 00:14:38 panos Exp $" ;
X
X#include <sys/file.h>
X#include <syslog.h>
X#include <string.h>
X#include <netdb.h>
X#include <pwd.h>
X#include <grp.h>
X
Xint free() ;
X
X#include "pset.h"
X#include "misc.h"
X
X#include "defs.h"
X#include "parse.h"
X#include "sconf.h"
X#include "config.h"
X#include "addr.h"
X
X#define NEW_SET( set, v1, v2 )                                                            \
X                if ( (set) == NULL &&                                                         \
X                        ( (set) = pset_create( (set), (v1), (v2) ) ) == NULL )    \
X                {                                                                                    \
X                    out_of_memory( func ) ;                                                    \
X                    return( FAILED ) ;                                                        \
X                }
X
X
Xvoid msg() ;
Xvoid parsemsg() ;
Xvoid out_of_memory() ;
Xchar **argv_alloc() ;
X
Xextern struct name_value success_log_options[] ;
Xextern struct name_value failure_log_options[] ;
Xextern struct name_value service_types[] ;
Xextern struct name_value socket_types[] ;
Xextern struct name_value service_flags[] ;
Xextern struct name_value syslog_facilities[] ;
Xextern struct name_value syslog_levels[] ;
X
Xextern env_h std_env ;
X
X
X/*
X * Find the flags corresponding to strings in "values" and apply
X * them to "*maskp" (apply means add or remove depending on "op")
X * "description" describes the type of flags.
X */
XPRIVATE status_e parse_value_list( values, maskp, list, op, description )
X    pset_h                    values ;
X    mask_t                    *maskp ;
X    struct name_value        list[] ;
X    enum assign_op            op ;
X    char                        *description ;
X{
X    register unsigned                u ;
X    register struct name_value *nvp ;
X    char                                *func = "parse_value_list" ;
X
X    for ( u = 0 ; u < pset_count( values ) ; u++ )
X    {
X        char *name = (char *) pset_pointer( values, u ) ;
X
X        nvp = nv_find_value( list, name ) ;
X        if ( nvp != NULL )
X            if ( op == PLUS_EQ )
X                M_SET( *maskp, nvp->value ) ;
X            else
X                M_CLEAR( *maskp, nvp->value ) ;
X        else
X            parsemsg( LOG_WARNING, func, "Bad %s: %s", description, name ) ;
X    }
X    return( OK ) ;
X}
X
X
Xstatus_e type_parser( values, scp, op )
X    pset_h values ;
X    struct service_config *scp ;
X    enum assign_op op ;
X{
X    return( parse_value_list( values,
X                        &scp->sc_type, service_types, PLUS_EQ, "service type" ) ) ;
X}
X
X
Xstatus_e flags_parser( values, scp, op )
X    pset_h values ;
X    struct service_config *scp ;
X    enum assign_op op ;
X{
X    return( parse_value_list( values,
X                        &scp->sc_flags, service_flags, PLUS_EQ, "service flag" ) ) ;
X}
X
X
Xstatus_e socket_type_parser( values, scp, op )
X    pset_h values ;
X    struct service_config *scp ;
X    enum assign_op op ;
X{
X    register struct name_value *nvp ;
X    register char *type = (char *) pset_pointer( values, 0 ) ;
X    char *func = "socket_type_parser" ;
X
X    nvp = nv_find_value( socket_types, type ) ;
X    if ( nvp != NULL )
X    {
X        scp->sc_socket_type = nvp->value ;
X        return( OK ) ;
X    }
X    else
X    {
X        parsemsg( LOG_ERR, func, "Bad socket type: %s", type ) ;
X        return( FAILED ) ;
X    }
X}
X
X
Xstatus_e rpc_version_parser( values, scp, op )
X    pset_h values ;
X    struct service_config *scp ;
X    enum assign_op op ;
X{
X    struct rpc_data *rdp = SC_RPCDATA( scp ) ;
X    char *version = (char *) pset_pointer( values, 0 ) ;
X    char *p = strchr( version, '-' ) ;
X    char *func = "rpc_version_parser" ;
X
X    if ( p == NULL )
X        rdp->rd_min_version = rdp->rd_max_version = atoi( version ) ;
X    else
X    {
X        *p = NUL ;
X        rdp->rd_min_version = atoi( version ) ;
X        rdp->rd_max_version = atoi( p+1 ) ;
X        if ( rdp->rd_min_version > rdp->rd_max_version )
X        {
X            parsemsg( LOG_ERR, func, "bad version range: %s", version ) ;
X            return( FAILED ) ;
X        }
X    }
X    return( OK ) ;
X}
X
X
Xstatus_e rpc_number_parser( values, scp, op )
X    pset_h values ;
X    struct service_config *scp ;
X    enum assign_op op ;
X{
X    SC_RPCDATA( scp )->rd_program_number =
X                                    atoi( (char *) pset_pointer( values, 0 ) ) ;
X    return( OK ) ;
X}
X
X
Xstatus_e protocol_parser( values, scp, op )
X    pset_h values ;
X    struct service_config *scp ;
X    enum assign_op op ;
X{
X    char *proto_name = (char *) pset_pointer( values, 0 ) ;
X    struct protoent *pep ;
X    char *func = "protocol_parser" ;
X
X    if ( ( pep = getprotobyname( proto_name ) ) == NULL )
X    {
X        parsemsg( LOG_ERR, func,
X                    "Protocol %s not in /etc/protocols", proto_name ) ;
X        return( FAILED ) ;
X    }
X
X    scp->sc_protocol.name = make_string( 1, proto_name ) ;
X    if ( scp->sc_protocol.name == NULL )
X    {
X        out_of_memory( func ) ;
X        return( FAILED ) ;
X    }
X    scp->sc_protocol.value = pep->p_proto ;
X    return( OK ) ;
X}
X
X
Xstatus_e wait_parser( values, scp, op )
X    pset_h values ;
X    struct service_config *scp ;
X    enum assign_op op ;
X{
X    char *val = (char *) pset_pointer( values, 0 ) ;
X    char *func = "wait_parser" ;
X
X    if ( EQ( val, "yes" ) )
X        scp->sc_wait = YES ;
X    else if ( EQ( val, "no" ) )
X        scp->sc_wait = NO ;
X    else
X        parsemsg( LOG_ERR, func, "Bad value for wait: %s", val ) ;
X    return( OK ) ;
X}
X
X
Xstatus_e user_parser( values, scp, op )
X    pset_h values ;
X    struct service_config *scp ;
X    enum assign_op op ;
X{
X    char *user = (char *) pset_pointer( values, 0 ) ;
X    struct passwd *pw ;
X    char *func = "user_parser" ;
X
X    pw = getpwnam( user ) ;
X    if ( pw == NULL )
X    {
X        parsemsg( LOG_ERR, func, "Unknown user: %s", user ) ;
X        return( FAILED ) ;
X    }
X
X    scp->sc_uid = pw->pw_uid ;
X    scp->sc_user_gid = pw->pw_gid ;
X    return( OK ) ;
X}
X
X
X
Xstatus_e group_parser( values, scp, op )
X    pset_h values ;
X    struct service_config *scp ;
X    enum assign_op op ;
X{
X    char *group = (char *) pset_pointer( values, 0 ) ;
X    struct group *grp ;
X    char *func = "group_parser" ;
X
X    grp = getgrnam( group ) ;
X    if ( grp == NULL )
X    {
X        parsemsg( LOG_ERR, func, "Unknown group: %s", group ) ;
X        return( FAILED ) ;
X    }
X
X    scp->sc_gid = grp->gr_gid ;
X    return( OK ) ;
X}
X
X
X
Xstatus_e server_parser( values, scp, op )
X    pset_h values ;
X    struct service_config *scp ;
X    enum assign_op op ;
X{
X    char *server = (char *) pset_pointer( values, 0 ) ;
X    char *func = "server_parser" ;
X
X    if ( access( server, X_OK ) == -1 )
X    {
X        parsemsg( LOG_ERR, func, "Server %s is not executable", server ) ;
X        return( FAILED ) ;
X    }
X
X    scp->sc_server = make_string( 1, server ) ;
X    if ( scp->sc_server == NULL )
X    {
X        out_of_memory( func ) ;
X        return( FAILED ) ;
X    }
X    return( OK ) ;
X}
X
X
X
Xstatus_e server_args_parser( values, scp, op )
X    pset_h values ;
X    struct service_config *scp ;
X    enum assign_op op ;
X{
X    register char **argv ;
X    register unsigned u ;
X    unsigned i ;
X    register unsigned argv_index ;
X    register unsigned n_args = pset_count( values ) ;
X    char *func = "server_args_parser" ;
X
X    /*
X     * Create the argv for a future exec call
X     * Reserve space for the server. We cannot use scp->sc_server
X     * since it may not have a value yet.
X     */
X    argv = argv_alloc( n_args+1 ) ;
X
X    for ( u = 0, argv_index = 1 ; u < pset_count( values ) ; u++, argv_index++ )
X    {
X        register char *s = make_string( 1, (char *) pset_pointer( values, u ) ) ;
X
X        if ( s == NULL )
X        {
X            for ( i = 1 ; i < argv_index ; i++ )
X                free( argv[ i ] ) ;
X            free( (char *) argv ) ;
X            out_of_memory( func ) ;
X            return( FAILED ) ;
X        }
X        argv[ argv_index ] = s ;
X    }
X
X    argv[ argv_index ] = argv[ 0 ] = NULL ;
X    scp->sc_server_argv = argv ;
X    return( OK ) ;
X}
X
X
Xstatus_e instances_parser( values, scp, op )
X    pset_h values ;
X    struct service_config *scp ;
X    enum assign_op op ;
X{
X    char *instances = (char *) pset_pointer( values, 0 ) ;
X    char *func = "instances_parser" ;
X
X    if ( EQ( instances, "UNLIMITED" ) )
X        scp->sc_instances = UNLIMITED ;
X    else
X    {
X        scp->sc_instances = atoi( instances ) ;
X        if ( scp->sc_instances < 0 )
X        {
X            parsemsg( LOG_ERR, func,
X                "Number of instances is negative: %s", instances ) ;
X            return( FAILED ) ;
X        }
X    }
X    return( OK ) ;
X}
X
X
Xstatus_e id_parser( values, scp, op )
X    pset_h values ;
X    struct service_config *scp ;
X    enum assign_op op ;
X{
X    char *func = "id_parser" ;
X
X    scp->sc_id = make_string( 1, (char *) pset_pointer( values, 0 ) ) ;
X    if ( scp->sc_id != NULL )
X        return( OK ) ;
X    out_of_memory( func ) ;
X    return( FAILED ) ;
X}
X
X
X
X#define PORT_BITS                16
X#define PORT_MAX                ( 1 << PORT_BITS )
X
Xstatus_e port_parser( values, scp, op )
X    pset_h values ;
X    struct service_config *scp ;
X    enum assign_op op ;
X{
X    unsigned long port = atoi( (char *) pset_pointer( values, 0 ) ) ;
X    char *func = "port_parser" ;
X
X    if ( port >= PORT_MAX )
X    {
X        parsemsg( LOG_ERR, func, "port number exceeds %d", PORT_MAX-1 ) ;
X        return( FAILED ) ;
X    }
X    scp->sc_port = port ;
X    return( OK ) ;
X}
X
X
XPRIVATE status_e add_new_string( set, str )
X    pset_h set ;
X    char *str ;
X{
X    char *p = make_string( 1, str ) ;
X    char *func = "add_new_string" ;
X
X    if ( p == NULL )
X    {
X        parsemsg( LOG_CRIT, func, ES_NOMEM ) ;
X        return( FAILED ) ;
X    }
X    if ( pset_add( set, p ) == NULL )
X    {
X        free( p ) ;
X        parsemsg( LOG_CRIT, func, ES_NOMEM ) ;
X        return( FAILED ) ;
X    }
X    return( OK ) ;
X}
X
X
Xstatus_e env_parser( values, scp, op )
X    pset_h values ;
X    struct service_config *scp ;
X    enum assign_op op ;
X{
X    unsigned u ;
X    char *func = "env_parser" ;
X
X    if ( op == MINUS_EQ )
X    {
X        parsemsg( LOG_WARNING, func,
X            "operator '-=' not supported for env atribute" ) ;
X        return( FAILED ) ;
X    }
X
X    NEW_SET( scp->sc_env_var_defs, 5, 5 ) ;
X
X    if ( op == SET_EQ && pset_count( scp->sc_env_var_defs ) > 0 )
X    {
X        pset_apply( scp->sc_env_var_defs, free, NULL ) ;
X        pset_clear( scp->sc_env_var_defs ) ;
X    }
X
X    for ( u = 0 ; u < pset_count( values ) ; u++ )
X    {
X        char *str = (char *) pset_pointer( values, u ) ;
X
X        /*
X         * Check if the string contains an '='
X         */
X        if ( strchr( str, '=' ) == NULL )
X        {
X            parsemsg( LOG_ERR, func, "%s has no '='", str ) ;
X            continue ;
X        }
X
X        if ( add_new_string( scp->sc_env_var_defs, str ) == FAILED )
X            break ;
X    }
X    return( OK ) ;
X}
X
X
Xstatus_e passenv_parser( values, scp, op )
X    pset_h values ;
X    struct service_config *scp ;
X    enum assign_op op ;
X{
X    pset_h var_set ;
X    unsigned u ;
X    char *func = "passenv_parser" ;
X
X    NEW_SET( scp->sc_pass_env_vars, 0, 0 ) ;
X
X    var_set = scp->sc_pass_env_vars ;
X
X    if ( op == SET_EQ )
X    {
X        pset_apply( var_set, free, NULL ) ;
X        pset_clear( var_set ) ;
X        op = PLUS_EQ ;
X    }
X
X    for ( u = 0 ; u < pset_count( values ) ; u++ )
X    {
X        char *env_var = (char *) pset_pointer( values, u ) ;
X        unsigned v ;
X        boolean_e found ;
X
X        /*
X         * Check if it is already there
X         */
X        for ( found = NO, v = 0 ; v < pset_count( var_set ) ; v++ )
X            if ( EQ( env_var, (char *) pset_pointer( var_set, v ) ) )
X            {
X                found = YES ;
X                break ;
X            }
X
X        if ( op == MINUS_EQ && found == NO || op != MINUS_EQ && found == YES )
X            continue ;
X
X        if ( op == MINUS_EQ )
X        {
X            free( (char *) pset_pointer( var_set, v ) ) ;
X            pset_remove_index( var_set, v ) ;
X        }
X        else
X        {
X            if ( env_lookup( std_env, env_var ) == CHAR_NULL )
X            {
X                parsemsg( LOG_WARNING, func,
X                    "undefined environment variable: %s", env_var ) ;
X                continue ;
X            }
X
X            if ( add_new_string( var_set, env_var ) == FAILED )
X                return( FAILED ) ;
X        }
X    }
X    return( OK ) ;
X}
X
X
X
Xstatus_e disabled_parser( values, scp, op )
X    pset_h values ;
X    struct service_config *scp ;
X    enum assign_op op ;
X{
X    register unsigned u ;
X    char *func = "disabled_parser" ;
X
X    NEW_SET( scp->sc_disabled, pset_count( values ), 0 ) ;
X
X    for ( u = 0 ; u < pset_count( values ) ; u++ )
X    {
X        char *name = (char *) pset_pointer( values, u ) ;
X
X        if ( add_new_string( scp->sc_disabled, name ) == FAILED )
X            return( OK ) ;
X    }
X    return( OK ) ;
X}
X
X
X/*
X * Interpret a number of the form: <num>[m|M|k|K]
X * m and M mean megabytes, k and K mean kilobytes, nothing means bytes
X */
XPRIVATE unsigned get_limit( limitstr )
X    char *limitstr ;
X{
X    int multiplier ;
X
X    switch ( limitstr[ strlen( limitstr ) - 1 ] )
X    {
X        case 'k':
X        case 'K':
X            multiplier = 1024 ;
X            break ;
X
X        case 'm':
X        case 'M':
X            multiplier = 1024 * 1024 ;
X            break ;
X
X        default:
X            multiplier = 1 ;
X    }
X    return( (unsigned) atoi( limitstr ) * multiplier ) ;
X}
X
X
XPRIVATE status_e parse_filelog( flp, values )
X    struct filelog        *flp ;
X    pset_h                values ;
X{
X    unsigned        soft_limit ;
X    unsigned        hard_limit ;
X    char            *file ;
X    unsigned        count = pset_count( values ) ;
X    char            *func = "parse_filelog" ;
X
X    if ( count < 2 || count > 4 )
X    {
X        parsemsg( LOG_ERR, func, "wrong number of arguments" ) ;
X        return( FAILED ) ;
X    }
X
X    file = make_string( 1, (char *) pset_pointer( values, 1 ) ) ;
X    if ( file == NULL )
X    {
X        out_of_memory( func ) ;
X        return( FAILED ) ;
X    }
X
X    /*
X     * Get the limits, if any
X     */
X    if ( count > 2 )
X    {
X        soft_limit = get_limit( (char *) pset_pointer( values, 2 ) ) ;
X        if ( soft_limit == 0 )
X        {
X            parsemsg( LOG_ERR, func, "soft limit is 0" ) ;
X            free( file ) ;
X            return( FAILED ) ;
X        }
X
X        /*
X         * If a hard limit was specified check that it is at least equal
X         * to the soft limit. If no hard limit was specified, determine
X         * it from the formula:
X         *        hard = soft + x
X         * where
X         *        min( 1%soft,LOG_EXTRA_MIN ) <= x <= max( 1%soft,LOG_EXTRA_MAX )
X         */
X        if ( count == 4 )
X        {
X            hard_limit = get_limit( (char *) pset_pointer( values, 3 ) ) ;
X            if ( hard_limit < soft_limit )
X            {
X                parsemsg( LOG_ERR, func,
X                    "hard limit (%d) is less than soft limit (%d)",
X                            hard_limit, soft_limit ) ;
X                free( file ) ;
X                return( FAILED ) ;
X            }
X        }
X        else
X        {
X            unsigned extra = soft_limit / 100 ;        /* 1% of soft limit */
X
X            if ( extra < LOG_EXTRA_MIN )
X                extra = LOG_EXTRA_MIN ;
X            else if ( extra > LOG_EXTRA_MAX )
X                extra = LOG_EXTRA_MAX ;
X            hard_limit = soft_limit + extra ;
X        }
X        flp->fl_soft_limit = soft_limit ;
X        flp->fl_hard_limit = hard_limit ;
X    }
X    flp->fl_filename = file ;
X    return( OK ) ;
X}
X
X
XPRIVATE status_e parse_syslog( slp, values )
X    struct syslog    *slp ;
X    pset_h            values ;
X{
X    char                    *facility ;
X    char                    *level ;
X    struct name_value *nvp ;
X    unsigned                count = pset_count( values ) ;
X    char                    *func = "parse_syslog" ;
X
X    if ( count < 2 || count > 3 )
X    {
X        parsemsg( LOG_ERR, func, "wrong number of arguments" ) ;
X        return( FAILED ) ;
X    }
X
X    facility = (char *) pset_pointer( values, 1 ) ;
X    if ( ( nvp = nv_find_value( syslog_facilities, facility ) ) == NULL )
X    {
X        parsemsg( LOG_ERR, func, "Unknown syslog facility: %s", facility ) ;
X        return( FAILED ) ;
X    }
X    slp->sl_facility = nvp->value ;
X
X    if ( count == 3 )
X    {
X        level = (char *) pset_pointer( values, 2 ) ;
X        if ( ( nvp = nv_find_value( syslog_levels, level ) ) == NULL )
X        {
X            parsemsg( LOG_ERR, func, "Unknown syslog level: %s", level ) ;
X            return( FAILED ) ;
X        }
X        slp->sl_level = nvp->value ;
X    }
X    else
X        slp->sl_level = DEFAULT_SERVICE_SYSLOG_LEVEL ;
X
X    return( OK ) ;
X}
X
X
Xstatus_e log_type_parser( values, scp, op )
X    pset_h values ;
X    struct service_config *scp ;
X    enum assign_op op ;
X{
X    struct log *lp = SC_LOG( scp ) ;
X    char *type ;
X    char *func = "parse_log_type" ;
X
X    type = (char *) pset_pointer( values, 0 ) ;
X
X    if ( EQ( type, "FILE" ) )
X    {
X        if ( parse_filelog( log_filelog( lp ), values ) == FAILED )
X            return( FAILED ) ;
X        lp->l_type = L_FILE ;
X    }
X    else if ( EQ( type, "SYSLOG" ) )
X    {
X        if ( parse_syslog( log_syslog( lp ), values ) == FAILED )
X            return( FAILED ) ;
X        lp->l_type = L_SYSLOG ;
X    }
X    else
X    {
X        parsemsg( LOG_ERR, func, "Unknown log type: %s", type ) ;
X        return( FAILED ) ;
X    }
X    return( OK ) ;
X}
X
X
X
XPRIVATE status_e parse_log_flags( values, op, maskp, options, name )
X    pset_h                values ;
X    enum assign_op        op ;
X    mask_t                *maskp ;
X    struct name_value options[] ;
X    char                    *name ;
X{
X    if ( op == SET_EQ )
X    {
X        M_CLEAR_ALL( *maskp ) ;
X        op = PLUS_EQ ;
X    }
X
X    return( parse_value_list( values, maskp, options, op, name ) ) ;
X}
X
X
Xstatus_e log_on_success_parser( values, scp, op )
X    pset_h values ;
X    struct service_config *scp ;
X    enum assign_op op ;
X{
X    return( parse_log_flags( values, op,
X        &scp->sc_log_on_success, success_log_options, "log-on-success flag" ) ) ;
X}
X
X
Xstatus_e log_on_failure_parser( values, scp, op )
X    pset_h values ;
X    struct service_config *scp ;
X    enum assign_op op ;
X{
X    return( parse_log_flags( values, op,
X        &scp->sc_log_on_failure, failure_log_options, "log-on_failure flag" ) ) ;
X}
X
X
X
XPRIVATE status_e parse_inet_addresses( values, op, addr_list )
X    pset_h            values ;
X    enum assign_op op ;
X    pset_h            *addr_list ;
X{
X    register unsigned        u ;
X    pset_h                    addr_set ;
X    statfunc                    addrlist_func ;
X    char                        *func = "parse_inet_addresses" ;
X
X    NEW_SET( *addr_list, 0, 0 ) ;
X
X    addr_set = *addr_list ;
X
X    /*
X     * If the op was '=' clear the existing list of addresses
X     */
X    if ( op == SET_EQ )
X    {
X        op = PLUS_EQ ;
X        addrlist_free( addr_set ) ;
X        pset_clear( addr_set ) ;
X    }
X
X    addrlist_func = ( op == PLUS_EQ ) ? addrlist_add : addrlist_remove ;
X
X    for ( u = 0 ; u < pset_count( values ) ; u++ )
X    {
X        register char *str_addr = (char *) pset_pointer( values, u ) ;
X
X        if ( (*addrlist_func)( addr_set, str_addr ) == FAILED )
X            break ;
X    }
X    return( OK ) ;
X}
X
X
X
Xstatus_e only_from_parser( values, scp, op )
X    pset_h values ;
X    struct service_config *scp ;
X    enum assign_op op ;
X{
X    return( parse_inet_addresses( values, op, &scp->sc_only_from ) ) ;
X}
X
X
Xstatus_e no_access_parser( values, scp, op )
X    pset_h values ;
X    struct service_config *scp ;
X    enum assign_op op ;
X{
X    return( parse_inet_addresses( values, op, &scp->sc_no_access ) ) ;
X}
X
X
Xstatus_e access_times_parser( values, scp, op )
X    pset_h values ;
X    struct service_config *scp ;
X    enum assign_op op ;
X{
X    register unsigned u ;
X    char *func = "access_times_parser" ;
X    status_e ti_add() ;
X
X    NEW_SET( scp->sc_access_times, 0, 0 ) ;
X
X    for ( u = 0 ; u < pset_count( values ) ; u++ )
X    {
X        register char *interval = (char *) pset_pointer( values, u ) ;
X
X        if ( ti_add( scp->sc_access_times, interval ) == FAILED )
X            break ;
X    }
X    return( OK ) ;
X}
X
X
Xstatus_e nice_parser( values, scp, op )
X    pset_h values ;
X    struct service_config *scp ;
X    enum assign_op op ;
X{
X    scp->sc_nice = atoi( (char *) pset_pointer( values, 0 ) ) ;
X    return( OK ) ;
X}
X
END_OF_FILE
if test 17457 -ne `wc -c <'xinetd/parsers.c'`; then
    echo shar: \"'xinetd/parsers.c'\" unpacked with wrong size!
fi
# end of 'xinetd/parsers.c'
fi
echo shar: End of archive 28 \(of 31\).
cp /dev/null ark28isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 31 archives.
    rm -f ark[1-9]isdone ark[1-9][0-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0