Return to formataddr.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / mh / sbr

Annotation of 43BSDReno/contrib/mh/sbr/formataddr.c, revision 1.1

1.1     ! root        1: /* formataddr.c - format an address field (from formatsbr) */
        !             2: 
        !             3: #include "../h/mh.h"
        !             4: #include "../h/addrsbr.h"
        !             5: #include "../h/formatsbr.h"
        !             6: #include <ctype.h>
        !             7: #include <stdio.h>
        !             8: 
        !             9: static char *buf;              /* our current working buffer */
        !            10: static char *bufend;           /* end of working buffer */
        !            11: static char *last_dst;         /* buf ptr at end of last call */
        !            12: static unsigned int bufsiz;    /* current size of buf */
        !            13: 
        !            14: #define BUFINCR 512            /* how much to expand buf when if fills */
        !            15: 
        !            16: #define CPY(s) { cp = (s); while (*dst++ = *cp++) ; --dst; }
        !            17: 
        !            18: /* check if there's enough room in buf for str.  add more mem if needed */
        !            19: #define CHECKMEM(str) \
        !            20:            if ((len = strlen (str)) >= bufend - dst) {\
        !            21:                int dst_offset = dst - buf;\
        !            22:                bufsiz += ((dst + len - bufend) / BUFINCR + 1) * BUFINCR;\
        !            23:                buf = realloc (buf, bufsiz);\
        !            24:                dst = buf + dst_offset;\
        !            25:                if (! buf)\
        !            26:                    adios (NULLCP, "formataddr: couldn't get buffer space");\
        !            27:                bufend = buf + bufsiz;\
        !            28:            }
        !            29: 
        !            30: 
        !            31: /* fmtscan will call this routine if the user includes the function
        !            32:  * "(formataddr {component})" in a format string.  "orig" is the
        !            33:  * original contents of the string register.  "str" is the address
        !            34:  * string to be formatted and concatenated onto orig.  This routine
        !            35:  * returns a pointer to the concatenated address string.
        !            36:  *
        !            37:  * We try to not do a lot of malloc/copy/free's (which is why we
        !            38:  * don't call "getcpy") but still place no upper limit on the
        !            39:  * length of the result string.
        !            40:  *
        !            41:  * This routine is placed in a separate library so it can be
        !            42:  * overridden by particular programs (e.g., "replsbr").
        !            43:  */
        !            44: char *formataddr (orig, str)
        !            45:     char *orig;
        !            46:     char *str;
        !            47: {
        !            48:     register int  len;
        !            49:     register int  isgroup;
        !            50:     register char  *dst;
        !            51:     register char  *cp;
        !            52:     register char  *sp;
        !            53:     register struct mailname *mp = NULL;
        !            54: 
        !            55:     /* if we don't have a buffer yet, get one */
        !            56:     if (bufsiz == 0) {
        !            57:        buf = malloc (BUFINCR);
        !            58:        if (! buf)
        !            59:            adios (NULLCP, "formataddr: couldn't allocate buffer space");
        !            60:        bufsiz = BUFINCR - 6;  /* leave some slop */
        !            61:        bufend = buf + bufsiz;
        !            62:     }
        !            63:     /*
        !            64:      * If "orig" points to our buffer we can just pick up where we
        !            65:      * left off.  Otherwise we have to copy orig into our buffer.
        !            66:      */
        !            67:     if (orig == buf)
        !            68:        dst = last_dst;
        !            69:     else if (!orig || !*orig) {
        !            70:        dst = buf;
        !            71:        *dst = '\0';
        !            72:     } else {
        !            73:        CHECKMEM (orig);
        !            74:        CPY (orig);
        !            75:     }
        !            76: 
        !            77:     /* concatenate all the new addresses onto 'buf' */
        !            78:     for (isgroup = 0; cp = getname (str); ) {
        !            79:        if ((mp = getm (cp, NULLCP, 0, fmt_norm, NULLCP)) == NULL)
        !            80:            continue;
        !            81: 
        !            82:        if (isgroup && (mp->m_gname || !mp->m_ingrp)) {
        !            83:            *dst++ = ';';
        !            84:            isgroup = 0;
        !            85:        }
        !            86:        /* if we get here we're going to add an address */
        !            87:        if (dst != buf) {
        !            88:            *dst++ = ',';
        !            89:            *dst++ = ' ';
        !            90:        }
        !            91:        if (mp->m_gname) {
        !            92:            CHECKMEM (mp->m_gname);
        !            93:            CPY (mp->m_gname);
        !            94:            isgroup++;
        !            95:        }
        !            96:        sp = adrformat (mp);
        !            97:        CHECKMEM (sp);
        !            98:        CPY (sp);
        !            99:        mnfree (mp);
        !           100:     }
        !           101: 
        !           102:     if (isgroup)
        !           103:        *dst++ = ';';
        !           104: 
        !           105:     *dst = '\0';
        !           106:     last_dst = dst;
        !           107:     return (buf);
        !           108: }

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