Return to is.c CVS log

Up to [Research Unix] / researchv10no / lbin / mailx

Annotation of researchv10no/lbin/mailx/is.c, revision 1.1.1.1

1.1       root        1: #ident "@(#)is.c       1.3 'attmail mail(1) command'"
                      2: #ident "@(#)mailx:is.c 1.1"
                      3: #ident "@(#)is.c       2.6 'attmail mail(1) command'"
                      4: #include "rcv.h"
                      5: #include <pwd.h>
                      6: 
                      7: static int isit();
                      8: 
                      9: /*
                     10:  * isheader(lp, ctf) - check if lp is header line and return type
                     11:  *     lp      ->      pointer to line
                     12:  *     ctfp    ->      continuation flag (should be FALSE the first time
                     13:  *                     isheader() is called on a message.  isheader() sets
                     14:  *                     it for the remaining calls to that message)
                     15:  * returns
                     16:  *     FALSE   ->      not header line
                     17:  *     H_*     ->      type of header line found.
                     18:  */
                     19: int
                     20: isheader(lp, ctfp)
                     21: char   *lp;
                     22: int    *ctfp;
                     23: {
                     24:        register char   *p, *q;
                     25:        register int    i;
                     26: 
                     27:        p = lp;
                     28:        while((*p) && (*p != '\n') && (isspace(*p))) {
                     29:                p++;
                     30:        }
                     31:        if((*p == NULL) || (*p == '\n')) {
                     32:                /* blank line */
                     33:                return (FALSE);
                     34:        }
                     35: 
                     36:        if ((*ctfp) && ((*lp == ' ') || (*lp == '\t'))) {
                     37:                return(H_CONT);
                     38:        }
                     39: 
                     40:        *ctfp = FALSE;
                     41:        for (i = 1; i < H_CONT; i++) {
                     42:                if (!isit(lp, i)) {
                     43:                        continue;
                     44:                }
                     45:                if ((i == H_FROM) || (i == H_FROM1)) {
                     46:                        /*
                     47:                         * Should NEVER get 'From ' or '>From ' line on stdin
                     48:                         * if invoked as mail (rather than rmail) since
                     49:                         * 'From ' and/or '>From ' lines are generated by
                     50:                         * program itself. Therefore, if it DOES match and
                     51:                         * ismail == TRUE, it must be part of the content.
                     52:                         */
                     53:                        if (sending && ismail) {
                     54:                                return (FALSE);
                     55:                        }
                     56:                        /* 
                     57:                         * I'm sorry, but as far as I can tell, a "From " line should
                     58:                         * _never_ be "from " or "FROM ".  Case matters in this case
                     59:                         *     --- adb
                     60:                         */
                     61:                        if( i == H_FROM && strncmp(lp,"From",4) != 0)           /* adb */
                     62:                                return(FALSE);                                  /* adb */
                     63:                }
                     64:                *ctfp = TRUE;
                     65:                return (i);
                     66:        }
                     67:        /*
                     68:         * Check if name: value pair
                     69:         */
                     70:        if ((p = strpbrk(lp, ":")) != NULL ) {
                     71:                for(q = lp; q < p; q++)  {
                     72:                        if ( (!isalnum(*q)) && (*q != '-') && (*q != '>'))  {
                     73:                                return(FALSE);
                     74:                        }
                     75:                }
                     76:                *ctfp = TRUE;
                     77:                return(H_NAMEVALUE);
                     78:        }
                     79:        return(FALSE);
                     80: }
                     81: 
                     82: /*
                     83:  * isit(lp, type) -- case independent match of "name" portion of 
                     84:  *             "name: value" pair
                     85:  *     lp      ->      pointer to line to check
                     86:  *     type    ->      type of header line to match
                     87:  * returns
                     88:  *     TRUE    ->      lp matches header type (case independent)
                     89:  *     FALSE   ->      no match
                     90:  */
                     91: static int
                     92: isit(lp, type)
                     93: register char  *lp;
                     94: register int   type;
                     95: {
                     96:        register char   *p;
                     97: 
                     98:        for (p = header[type].tag; *lp && *p; lp++, p++) {
                     99:                if (toupper(*p) != toupper(*lp))  {
                    100:                        return(FALSE);
                    101:                }
                    102:        }
                    103:        if (*p == NULL) {
                    104:                return(TRUE);
                    105:        }
                    106:        return(FALSE);
                    107: }
                    108: 
                    109: /*
                    110:  * istext(line, size) - check for text characters
                    111:  */
                    112: int
                    113: istext(lp, size)
                    114:        char    *lp;
                    115:        long    size;
                    116: {
                    117:        register unsigned char *line = (unsigned char*)lp;
                    118:        register unsigned char *ep;
                    119:        
                    120:        for (ep = line+size; --ep >= line; ) {
                    121:                if( *ep > 0177) return(FALSE);
                    122:        }
                    123:        return(TRUE);
                    124: }
                    125: 
                    126: /*
                    127:  * linecount (line, size) - determine the number of lines in a printable
                    128:  *                          file.
                    129:  */
                    130: int
                    131: linecount(lp, size)
                    132:        char    *lp;
                    133:        int     size;
                    134: {
                    135:        register unsigned char  *line = (unsigned char*)lp;
                    136:        register unsigned char *ch;
                    137:        register c;
                    138:        register int count;
                    139: 
                    140:        count = 0;
                    141:        for (ch = line+size; --ch >= line;)
                    142:        {
                    143:                c = *ch;
                    144:                if (c == '\n')
                    145:                        count++;
                    146:                continue;
                    147:        }
                    148:        return (count); 
                    149: }

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