Return to putenv.c CVS log

Up to [MW Coherent from dump] / coherent / b / lib / libc / gen

Annotation of coherent/b/lib/libc/gen/putenv.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Change or add value to environment.
        !             3:  *
        !             4:  * $Log:       putenv.c,v $
        !             5:  * Revision 1.3  93/02/10  16:53:40  bin
        !             6:  * *** empty log message ***
        !             7:  * 
        !             8:  * 87/02/05    Allan Cornish
        !             9:  * Initial revision.
        !            10:  */
        !            11: #include <stdio.h>
        !            12: #include <errno.h>
        !            13: 
        !            14: /**
        !            15:  *
        !            16:  * int
        !            17:  * putenv( s )         - change or add value to environment
        !            18:  * char * s;
        !            19:  *
        !            20:  *     Input:  s = pointer to string of the form 'NAME=value'
        !            21:  *
        !            22:  *     Action: The function putenv makes the value of the environment
        !            23:  *             variable 'name' equal to 'value' by altering an existing
        !            24:  *             variable or creating a new one.  In either case, the string
        !            25:  *             created by 'string' becomes part of the environment,
        !            26:  *             so altering the string will change the environment.
        !            27:  *             The space used by string is no longer used once a new
        !            28:  *             string-defining name is passed to the function putenv.
        !            29:  *
        !            30:  *     Return: 0 = environment updated.
        !            31:  *             * = insufficient memory, or invalid argument.
        !            32:  *
        !            33:  *     Notes:  The third argument to main [envp] is not changed.
        !            34:  */
        !            35: 
        !            36: int
        !            37: putenv( string )
        !            38: char * string;
        !            39: {
        !            40:        register char **epp;
        !            41:        register int    len;
        !            42:        static char ** lastenv;
        !            43:        extern char ** environ;
        !            44: 
        !            45:        /*
        !            46:         * Paranoia.
        !            47:         */
        !            48:        if ( string == NULL ) {
        !            49:                errno = EFAULT;
        !            50:                return -1;
        !            51:        }
        !            52: 
        !            53:        /*
        !            54:         * Validate string, which must be of form NAME=value.
        !            55:         */
        !            56:        for ( len = 0; string[len] != '='; len++ ) {
        !            57:                if ( string[len] == '\0' ) {
        !            58:                        errno = EINVAL;
        !            59:                        return -1;
        !            60:                }
        !            61:        }
        !            62: 
        !            63:        /*
        !            64:         * Update len to include the '='.
        !            65:         */
        !            66:        len++;
        !            67: 
        !            68:        /*
        !            69:         * Search for existing value.
        !            70:         */
        !            71:        for ( epp = environ; *epp != NULL; epp++ ) {
        !            72: 
        !            73:                /*
        !            74:                 * Variable already in environment.
        !            75:                 */
        !            76:                if ( strncmp( string, *epp, len ) == 0 ) {
        !            77: 
        !            78:                        /*
        !            79:                         * Update environment.
        !            80:                         * NOTE: should release previous value if malloc'ed.
        !            81:                         */
        !            82:                        *epp = string;
        !            83:                        return 0;
        !            84:                }
        !            85:        }
        !            86: 
        !            87:        /*
        !            88:         * Allocate new environment array.
        !            89:         */
        !            90:        len = (epp - environ + 2) * sizeof(*epp);
        !            91:        if ( (epp = malloc(len)) == NULL ) {
        !            92:                errno = ENOMEM;
        !            93:                return -1;
        !            94:        }
        !            95: 
        !            96:        /*
        !            97:         * Copy old environment to new environment.
        !            98:         */
        !            99:        len = 0;
        !           100:        while ( epp[len] = environ[len] )
        !           101:                len++;
        !           102: 
        !           103:        /*
        !           104:         * Append new variable and NULL terminator.
        !           105:         */
        !           106:        epp[len++] = string;
        !           107:        epp[len++] = NULL;
        !           108: 
        !           109:        /*
        !           110:         * Release last malloc'ed environment array.
        !           111:         */
        !           112:        if ( lastenv != NULL )
        !           113:                free( lastenv );
        !           114: 
        !           115:        /*
        !           116:         * Install new environment.
        !           117:         */
        !           118:        environ = epp;
        !           119:        lastenv = epp;
        !           120: 
        !           121:        return 0;
        !           122: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.