home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / security / xinetd / misc.1.2.2 / env.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-11-08  |  4.7 KB  |  286 lines
  1. /*
  2.  * (c) Copyright 1992 by Panagiotis Tsirigotis
  3.  * All rights reserved.  The file named COPYRIGHT specifies the terms 
  4.  * and conditions for redistribution.
  5.  */
  6.  
  7. static char RCSid[] = "$Id: env.c,v 1.4 1992/11/03 00:07:50 panos Exp $" ;
  8.  
  9. #include <memory.h>
  10. #include <string.h>
  11.  
  12. #include "misc.h"
  13. #include "env.h"
  14.  
  15. typedef struct __env env_s ;
  16.  
  17. #define PRIVATE                    static
  18. #define INITIAL_VARS                20
  19. #define INCREASE                    10
  20.  
  21. #ifndef NULL
  22. #define NULL                        0
  23. #endif
  24.  
  25. char *malloc() ;
  26. char *realloc() ;
  27.  
  28. int env_errno ;
  29.  
  30.  
  31.  
  32. PRIVATE env_s *alloc_env( max_vars )
  33.     unsigned max_vars ;
  34. {
  35.     env_s *ep ;
  36.     unsigned size ;
  37.     char **pointers ;
  38.  
  39.     ep = (env_s *) malloc( sizeof( env_s ) ) ;
  40.     if ( ep == ENV_NULL )
  41.     {
  42.         env_errno = ENV_ENOMEM ;
  43.         return( ENV_NULL ) ;
  44.     }
  45.  
  46.     size = ( max_vars + 1 ) * sizeof( char * ) ;
  47.     pointers = (char **) malloc( size ) ;
  48.     if ( pointers == NULL )
  49.     {
  50.         free( (char *)ep ) ;
  51.         env_errno = ENV_ENOMEM ;
  52.         return( ENV_NULL ) ;
  53.     }
  54.     (void) memset( (char *)pointers, 0, (int) size ) ;
  55.  
  56.     ep->vars = pointers ;
  57.     ep->max_vars = max_vars ;
  58.     ep->n_vars = 0 ;
  59.     return( ep ) ;
  60. }
  61.  
  62.  
  63. env_h env_create( init_env )
  64.     env_h init_env ;
  65. {
  66.     unsigned u ;
  67.     env_s *ep ;
  68.     unsigned max_vars ;
  69.  
  70.     if ( init_env == ENV_NULL )
  71.         max_vars = INITIAL_VARS ;
  72.     else
  73.         max_vars = init_env->n_vars + 5 ;
  74.     
  75.     ep = alloc_env( max_vars ) ;
  76.     if ( ep == NULL )
  77.     {
  78.         env_errno = ENV_ENOMEM ;
  79.         return( ENV_NULL ) ;
  80.     }
  81.  
  82.     if ( init_env == ENV_NULL )
  83.         return( ep ) ;
  84.  
  85.     for ( u = 0, ep->n_vars = 0 ; u < init_env->n_vars ; u++, ep->n_vars++ )
  86.     {
  87.         ep->vars[ ep->n_vars ] = make_string( 1, init_env->vars[ u ] ) ;
  88.         if ( ep->vars[ ep->n_vars ] == NULL )
  89.         {
  90.             env_destroy( ep ) ;
  91.             env_errno = ENV_ENOMEM ;
  92.             return( ENV_NULL ) ;
  93.         }
  94.     }
  95.     return( ep ) ;
  96. }
  97.  
  98.  
  99. void env_destroy( env )
  100.     env_h env ;
  101. {
  102.     unsigned u ;
  103.  
  104.     for ( u = 0 ; u < env->n_vars ; u++ )
  105.         free( env->vars[ u ] ) ;
  106.     free( (char *)env->vars ) ;
  107.     free( (char *)env ) ;
  108. }
  109.  
  110.  
  111. env_h env_make( env_strings )
  112.     char **env_strings ;
  113. {
  114.     env_s *ep ;
  115.     char **pp ;
  116.  
  117.     for ( pp = env_strings ; *pp ; pp++ ) ;
  118.  
  119.     ep = alloc_env( (unsigned) (pp-env_strings) ) ;
  120.     if ( ep == NULL )
  121.     {
  122.         env_errno = ENV_ENOMEM ;
  123.         return( ENV_NULL ) ;
  124.     }
  125.  
  126.     for ( pp = env_strings ; *pp ; pp++ )
  127.     {
  128.         char *p = make_string( 1, *pp ) ;
  129.  
  130.         if ( p == NULL )
  131.         {
  132.             env_destroy( ep ) ;
  133.             env_errno = ENV_ENOMEM ;
  134.             return( ENV_NULL ) ;
  135.         }
  136.         ep->vars[ ep->n_vars++ ] = p ;
  137.     }
  138.     return( ep ) ;
  139. }
  140.  
  141.  
  142. char *env_lookup( env, var )
  143.     env_h env ;
  144.     char *var ;
  145. {
  146.     char **lookup() ;
  147.     char **pp = lookup( env, var, strlen( var ) ) ;
  148.  
  149.     return( ( pp == NULL ) ? NULL : *pp ) ;
  150. }
  151.  
  152.  
  153. PRIVATE char **lookup( env, var, len )
  154.     env_h env ;
  155.     char *var ;
  156.     register int len ;
  157. {
  158.     register char **pp ;
  159.  
  160.     for ( pp = env->vars ; *pp ; pp++ )
  161.         if ( strncmp( *pp, var, len ) == 0 && (*pp)[ len ] == '=' )
  162.             return( pp ) ;
  163.     return( NULL ) ;
  164. }
  165.  
  166.  
  167. PRIVATE int grow( ep )
  168.     env_s *ep ;
  169. {
  170.     char **new_vars ;
  171.     unsigned new_max_vars ;
  172.     unsigned new_size ;
  173.  
  174.     new_max_vars = ep->max_vars + INCREASE ;
  175.     new_size = ( new_max_vars+1 ) * sizeof( char * ) ;
  176.     new_vars = (char **) realloc( (char *)ep->vars, new_size ) ;
  177.     if ( new_vars == NULL )
  178.         return( ENV_ERR ) ;
  179.     
  180.     ep->vars = new_vars ;
  181.     ep->max_vars = new_max_vars ;
  182.     return( ENV_OK ) ;
  183. }
  184.  
  185.  
  186. /*
  187.  * Add the variable string to the given environment.
  188.  */
  189. PRIVATE int addstring( ep, var_string, len )
  190.     env_s *ep ;
  191.     char *var_string ;
  192.     int len ;
  193. {
  194.     char **pp ;
  195.     char *p ;
  196.  
  197.     p = make_string( 1, var_string ) ;
  198.     if ( p == NULL )
  199.         return( ENV_ERR ) ;
  200.         
  201.     pp = lookup( ep, var_string, len ) ;
  202.     if ( pp == NULL )
  203.     {
  204.         if ( ep->n_vars >= ep->max_vars && grow( ep ) == ENV_ERR )
  205.         {
  206.             free( p ) ;
  207.             env_errno = ENV_ENOMEM ;
  208.             return( ENV_ERR ) ;
  209.         }
  210.         ep->vars[ ep->n_vars++ ] = p ;
  211.     }
  212.     else
  213.     {
  214.         free( *pp ) ;
  215.         *pp = p ;
  216.     }
  217.     return( ENV_OK ) ;
  218. }
  219.  
  220.  
  221. int env_addvar( env, from_env, var_name )
  222.     env_h env ;
  223.     env_h from_env ;
  224.     char *var_name ;
  225. {
  226.     char *var_string = env_lookup( from_env, var_name ) ;
  227.  
  228.     if ( var_string == NULL )
  229.     {
  230.         env_errno = ENV_EBADVAR ;
  231.         return( ENV_ERR ) ;
  232.     }
  233.  
  234.     return( addstring( env, var_string, strlen( var_name ) ) ) ;
  235. }
  236.  
  237.  
  238. int env_addstr( env, var_string )
  239.     env_h env ;
  240.     char *var_string ;
  241. {
  242.     char *p = strchr( var_string, '=' ) ;
  243.  
  244.     if ( p == NULL )
  245.     {
  246.         env_errno = ENV_EBADSTRING ;
  247.         return( ENV_ERR ) ;
  248.     }
  249.     
  250.     return( addstring( env, var_string, p-var_string ) ) ;
  251. }
  252.  
  253.  
  254. int env_remvar( env, var )
  255.     env_h env ;
  256.     char *var ;
  257. {
  258.     char **pp = lookup( env, var, strlen( var ) ) ;
  259.  
  260.     if ( pp == NULL )
  261.     {
  262.         env_errno = ENV_EBADVAR ;
  263.         return( ENV_ERR ) ;
  264.     }
  265.     
  266.     free( *pp ) ;
  267.     *pp = env->vars[ --env->n_vars ] ;
  268.     return( ENV_OK ) ;
  269. }
  270.  
  271.  
  272. #ifdef notdef
  273. PRIVATE int comparator( p1, p2 )
  274.     char **p1, **p2 ;
  275. {
  276.     return( strcmp( *p1, *p2 ) ) ;
  277. }
  278.  
  279.  
  280. void env_sort( env )
  281.     env_h env ;
  282. {
  283.     qsort( (char *)env->vars, env->n_vars, sizeof( char * ), comparator ) ;
  284. }
  285. #endif
  286.