xinetd-2.3.15.tar.gz

/* * (c) Copyright 1992 by Panagiotis Tsirigotis * (c) Sections Copyright 1998-2001 by Rob Braun * All rights reserved. The file named COPYRIGHT specifies the terms * and conditions for redistribution. */ #include "config.h" #include <ctype.h> #include <sys/file.h> #include <syslog.h> #include <netdb.h> #include <pwd.h> #include <grp.h> #include <sys/types.h> #include <sys/stat.h> #include <netinet/in.h> #include <arpa/inet.h> #include <unistd.h> #include <stdlib.h> #include <limits.h> /* For LONG_MIN and LONG_MAX */ #include <errno.h> #ifdef HAVE_LOADAVG #include <stdio.h> #endif #if defined(hpux) && !defined(X_OK) #define X_OK 1 #endif #include "str.h" #include "parsers.h" #include "msg.h" #include "nvlists.h" #include "env.h" #include "xconfig.h" #include "addr.h" #include "libportable.h" #include "timex.h" #include "addr.h" /* check_hostname() */ #define NEW_SET( set, v1, v2 ) \ if ( (set) == NULL && \ ( (set) = pset_create( (v1), (v2) ) ) == NULL ) \ { \ out_of_memory( func ) ; \ return( FAILED ) ; \ } static void missing_attr_msg(const char *par, const char *item) { parsemsg( LOG_WARNING, par, "attribute %s expects at least 1 value and none were given.", item ); } /* * Find the flags corresponding to strings in "values" and apply * them to "*maskp" (apply means add or remove depending on "op") * "description" describes the type of flags. */ static status_e parse_value_list( pset_h values, mask_t *maskp, const struct name_value list[], enum assign_op op, const char *description ) { unsigned u ; const struct name_value *nvp ; const char *func = "parse_value_list" ; for ( u=0; u<pset_count( values ); u++ ) { const char *name = (char *) pset_pointer( values, u ) ; nvp = nv_find_value( list, name ) ; if ( nvp != NULL ) { if ( op == PLUS_EQ ) M_SET( *maskp, nvp->value ) ; else M_CLEAR( *maskp, nvp->value ) ; } else { parsemsg( LOG_WARNING, func, "Bad %s: %s", description, name ) ; return( FAILED ); } } return( OK ) ; } status_e type_parser( pset_h values, struct service_config *scp, enum assign_op op ) { if ( pset_count( values ) >= 1 ) { return( parse_value_list( values, &SC_TYPE(scp), service_types, PLUS_EQ, "service type" ) ) ; } else { missing_attr_msg("type_parser", "type"); return FAILED ; } } status_e flags_parser( pset_h values, struct service_config *scp, enum assign_op op ) { if ( pset_count( values ) >= 1 ) { return( parse_value_list( values, &SC_XFLAGS(scp), service_flags, PLUS_EQ, "service flag" ) ) ; } else { missing_attr_msg("flags_parser", "flags"); return FAILED ; } } status_e socket_type_parser( const pset_h values, struct service_config *scp, enum assign_op op ) { const struct name_value *nvp ; const char *type = (char *) pset_pointer( values, 0 ) ; const char *func = "socket_type_parser" ; nvp = nv_find_value( socket_types, type ) ; if ( nvp != NULL ) { SC_SOCKET_TYPE(scp) = nvp->value ; return( OK ) ; } else { parsemsg( LOG_ERR, func, "Bad socket type: %s", type ) ; return( FAILED ) ; } } status_e rpc_version_parser( pset_h values, struct service_config *scp, enum assign_op op ) { struct rpc_data *rdp = SC_RPCDATA( scp ) ; char *version = (char *) pset_pointer( values, 0 ) ; int min_version=0, max_version=0; char *p = strchr( version, '-' ) ; const char *func = "rpc_version_parser" ; if ( p == NULL ) { if ( parse_base10(version, &min_version) ) max_version = min_version - 1; else max_version = min_version; } else { *p = NUL ; if ( parse_base10(version, &min_version) || parse_base10(p+1, &max_version) ) max_version = min_version - 1; } if ( min_version > max_version ) { parsemsg( LOG_ERR, func, "bad version range: %s", version ) ; return( FAILED ) ; } rdp->rd_min_version = min_version; rdp->rd_max_version = max_version; return( OK ) ; } status_e rpc_number_parser( pset_h values, struct service_config *scp, enum assign_op op ) { int num; if ( parse_base10((char *) pset_pointer( values, 0 ), &num) ) { parsemsg(LOG_ERR, "rpc_number_parser", "Error parsing: %s", (char *)pset_pointer( values, 0 )); return( FAILED ); } SC_RPCDATA( scp )->rd_program_number = num; return( OK ) ; } status_e protocol_parser( pset_h values, struct service_config *scp, enum assign_op op ) { char *proto_name = (char *) pset_pointer( values, 0 ) ; struct protoent *pep ; const char *func = "protocol_parser" ; if( proto_name == NULL ) { parsemsg( LOG_ERR, func, "Protocol name is null in %s", SC_NAME(scp) ); return( FAILED ); } if ( ( pep = getprotobyname( proto_name ) ) == NULL ) { parsemsg( LOG_ERR, func, "Protocol %s not in /etc/protocols", proto_name ) ; return( FAILED ) ; } SC_PROTONAME(scp) = new_string( proto_name ) ; if ( SC_PROTONAME(scp) == NULL ) { out_of_memory( func ) ; return( FAILED ) ; } SC_PROTOVAL(scp) = pep->p_proto ; return( OK ) ; } status_e wait_parser( pset_h values, struct service_config *scp, enum assign_op op ) { char *val = (char *) pset_pointer( values, 0 ) ; const char *func = "wait_parser" ; if ( EQ( val, "yes" ) ) SC_WAIT(scp) = YES ; else if ( EQ( val, "no" ) ) SC_WAIT(scp) = NO ; else { parsemsg( LOG_ERR, func, "Bad value for wait: %s", val ) ; return( FAILED ); } return( OK ) ; } #ifdef HAVE_MDNS status_e mdns_parser( pset_h values, struct service_config *scp, enum assign_op op ) { char *val = (char *) pset_pointer( values, 0 ) ; const char *func = "mdns_parser" ; if ( EQ( val, "yes" ) ) SC_MDNS(scp) = YES ; else if ( EQ( val, "no" ) ) SC_MDNS(scp) = NO ; else { parsemsg( LOG_ERR, func, "Bad value for mdns: %s", val ) ; return( FAILED ); } return( OK ) ; } #endif status_e user_parser( pset_h values, struct service_config *scp, enum assign_op op ) { char *user = (char *) pset_pointer( values, 0 ) ; const char *func = "user_parser" ; if (parse_all_digits(user) == TRUE) { /* We will assume the number is a valid user. This is a workaround for some Solaris systems that have problems doing getgr*. */ if (parse_ubase10(user, (unsigned int *)&SC_UID(scp))) { parsemsg( LOG_ERR, func, "Error parsing user as a number: %s", user ) ; return( FAILED ) ; } SC_USER_GID(scp) = SC_UID(scp) ; } else { struct passwd *pw ; pw = getpwnam( user ) ; if ( pw == NULL ) { parsemsg( LOG_ERR, func, "Unknown user: %s", user ) ; return( FAILED ) ; } str_fill( pw->pw_passwd, ' ' ); SC_UID(scp) = pw->pw_uid ; SC_USER_GID(scp) = pw->pw_gid ; } return( OK ) ; } status_e group_parser( pset_h values, struct service_config *scp, enum assign_op op ) { const char *func = "group_parser" ; char *gro