[BACK]Return to vars.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / mail

Annotation of src/usr.bin/mail/vars.c, Revision 1.8

1.8     ! millert     1: /*     $OpenBSD: vars.c,v 1.7 2001/11/21 15:26:39 millert Exp $        */
1.2       deraadt     2: /*     $NetBSD: vars.c,v 1.4 1996/06/08 19:48:45 christos Exp $        */
                      3:
1.1       deraadt     4: /*
                      5:  * Copyright (c) 1980, 1993
                      6:  *     The Regents of the University of California.  All rights reserved.
                      7:  *
                      8:  * Redistribution and use in source and binary forms, with or without
                      9:  * modification, are permitted provided that the following conditions
                     10:  * are met:
                     11:  * 1. Redistributions of source code must retain the above copyright
                     12:  *    notice, this list of conditions and the following disclaimer.
                     13:  * 2. Redistributions in binary form must reproduce the above copyright
                     14:  *    notice, this list of conditions and the following disclaimer in the
                     15:  *    documentation and/or other materials provided with the distribution.
                     16:  * 3. All advertising materials mentioning features or use of this software
                     17:  *    must display the following acknowledgement:
                     18:  *     This product includes software developed by the University of
                     19:  *     California, Berkeley and its contributors.
                     20:  * 4. Neither the name of the University nor the names of its contributors
                     21:  *    may be used to endorse or promote products derived from this software
                     22:  *    without specific prior written permission.
                     23:  *
                     24:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
                     25:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                     26:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                     27:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
                     28:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     29:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     30:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     31:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     32:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     33:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     34:  * SUCH DAMAGE.
                     35:  */
                     36:
                     37: #ifndef lint
1.2       deraadt    38: #if 0
1.7       millert    39: static const char sccsid[] = "@(#)vars.c       8.1 (Berkeley) 6/6/93";
1.2       deraadt    40: #else
1.8     ! millert    41: static const char rcsid[] = "$OpenBSD: vars.c,v 1.7 2001/11/21 15:26:39 millert Exp $";
1.2       deraadt    42: #endif
1.1       deraadt    43: #endif /* not lint */
                     44:
                     45: #include "rcv.h"
                     46: #include "extern.h"
                     47:
                     48: /*
                     49:  * Mail -- a mail program
                     50:  *
                     51:  * Variable handling stuff.
                     52:  */
                     53:
                     54: /*
                     55:  * Assign a value to a variable.
                     56:  */
                     57: void
1.7       millert    58: assign(char *name, char *value)
1.1       deraadt    59: {
1.5       millert    60:        struct var *vp;
                     61:        int h;
1.1       deraadt    62:
                     63:        h = hash(name);
                     64:        vp = lookup(name);
1.7       millert    65:        if (vp == NULL) {
1.8     ! millert    66:                if ((vp = (struct var *)calloc(sizeof(*vp), 1)) == NULL)
        !            67:                        errx(1, "Out of memory");
1.1       deraadt    68:                vp->v_name = vcopy(name);
                     69:                vp->v_link = variables[h];
                     70:                variables[h] = vp;
                     71:        }
                     72:        else
                     73:                vfree(vp->v_value);
                     74:        vp->v_value = vcopy(value);
                     75: }
                     76:
                     77: /*
                     78:  * Free up a variable string.  We do not bother to allocate
                     79:  * strings whose value is "" since they are expected to be frequent.
                     80:  * Thus, we cannot free same!
                     81:  */
                     82: void
1.7       millert    83: vfree(char *cp)
1.1       deraadt    84: {
1.7       millert    85:
1.1       deraadt    86:        if (*cp)
1.4       millert    87:                (void)free(cp);
1.1       deraadt    88: }
                     89:
                     90: /*
                     91:  * Copy a variable value into permanent (ie, not collected after each
                     92:  * command) space.  Do not bother to alloc space for ""
                     93:  */
                     94: char *
1.7       millert    95: vcopy(char *str)
1.1       deraadt    96: {
                     97:        char *new;
                     98:
                     99:        if (*str == '\0')
1.3       millert   100:                return("");
1.7       millert   101:        if ((new = strdup(str)) == NULL)
1.5       millert   102:                errx(1, "Out of memory");
1.3       millert   103:        return(new);
1.1       deraadt   104: }
                    105:
                    106: /*
                    107:  * Get the value of a variable and return it.
                    108:  * Look in the environment if its not available locally.
                    109:  */
                    110:
                    111: char *
1.7       millert   112: value(char *name)
1.1       deraadt   113: {
1.5       millert   114:        struct var *vp;
1.6       millert   115:        char *env;
1.1       deraadt   116:
1.7       millert   117:        if ((vp = lookup(name)) != NULL)
1.6       millert   118:                return(vp->v_value);
                    119:        else if ((env = getenv(name)))
                    120:                return(env);
                    121:        /* not set, see if we can provide a default */
                    122:        else if (strcmp(name, "SHELL") == 0)
                    123:                return(_PATH_CSHELL);
                    124:        else if (strcmp(name, "LISTER") == 0)
                    125:                return(_PATH_LS);
                    126:        else if (strcmp(name, "PAGER") == 0)
                    127:                return(_PATH_MORE);
                    128:        else
                    129:                return(NULL);
1.1       deraadt   130: }
                    131:
                    132: /*
                    133:  * Locate a variable and return its variable
                    134:  * node.
                    135:  */
                    136: struct var *
1.7       millert   137: lookup(char *name)
1.1       deraadt   138: {
1.5       millert   139:        struct var *vp;
1.1       deraadt   140:
1.7       millert   141:        for (vp = variables[hash(name)]; vp != NULL; vp = vp->v_link)
1.1       deraadt   142:                if (*vp->v_name == *name && equal(vp->v_name, name))
                    143:                        return(vp);
1.7       millert   144:        return(NULL);
1.1       deraadt   145: }
                    146:
                    147: /*
                    148:  * Locate a group name and return it.
                    149:  */
                    150: struct grouphead *
1.7       millert   151: findgroup(char *name)
1.1       deraadt   152: {
1.5       millert   153:        struct grouphead *gh;
1.1       deraadt   154:
1.7       millert   155:        for (gh = groups[hash(name)]; gh != NULL; gh = gh->g_link)
1.1       deraadt   156:                if (*gh->g_name == *name && equal(gh->g_name, name))
                    157:                        return(gh);
1.7       millert   158:        return(NULL);
1.1       deraadt   159: }
                    160:
                    161: /*
                    162:  * Print a group out on stdout
                    163:  */
                    164: void
1.7       millert   165: printgroup(char *name)
1.1       deraadt   166: {
1.5       millert   167:        struct grouphead *gh;
                    168:        struct group *gp;
1.1       deraadt   169:
1.7       millert   170:        if ((gh = findgroup(name)) == NULL) {
1.1       deraadt   171:                printf("\"%s\": not a group\n", name);
                    172:                return;
                    173:        }
                    174:        printf("%s\t", gh->g_name);
1.7       millert   175:        for (gp = gh->g_list; gp != NULL; gp = gp->ge_link)
1.1       deraadt   176:                printf(" %s", gp->ge_name);
                    177:        putchar('\n');
                    178: }
                    179:
                    180: /*
                    181:  * Hash the passed string and return an index into
                    182:  * the variable or group hash table.
                    183:  */
                    184: int
1.7       millert   185: hash(char *name)
1.1       deraadt   186: {
1.5       millert   187:        int h = 0;
1.1       deraadt   188:
                    189:        while (*name) {
                    190:                h <<= 2;
                    191:                h += *name++;
                    192:        }
                    193:        if (h < 0 && (h = -h) < 0)
                    194:                h = 0;
1.3       millert   195:        return(h % HSHSIZE);
1.1       deraadt   196: }