Return to seal.c CVS log

Up to [Research Unix] / researchv10no / cmd / odist / opkg

Annotation of researchv10no/cmd/odist/opkg/seal.c, revision 1.1

1.1     ! root        1: /*
        !             2:  *     seal - prepare a package for shipment
        !             3:  */
        !             4: 
        !             5: #include "asd.h"
        !             6: #include "seal.h"
        !             7: #include <ctype.h>
        !             8: #include <string.h>
        !             9: 
        !            10: static long length;
        !            11: static unsigned long checksum;
        !            12: 
        !            13: /*
        !            14:  *     convert the characters in the range (in,inend] to
        !            15:  *     storage starting at "out" -- return the number of
        !            16:  *     output characters.
        !            17:  */
        !            18: 
        !            19: static int
        !            20: hrform (char *in, char *inend, char *out)
        !            21: {
        !            22:        register char *r = out;
        !            23: 
        !            24:        /* special handling for the first character(s) */
        !            25:        if (in < inend) {
        !            26:                if (*in == '.' || *in == '!' ||
        !            27:                    (*in == 'F' && strncmp (in, "From", 4) == 0))
        !            28:                        *r++ = '\\';
        !            29: 
        !            30:                do {
        !            31:                        register int ch = (unsigned char) *in++;
        !            32: 
        !            33:                        if (isprint (ch)) {
        !            34:                                if (ch == '\\')
        !            35:                                        *r++ = '\\';
        !            36:                                *r++ = ch;
        !            37:                        } else {
        !            38:                                if (ch == ' ' || ch == '\t' || ch == '\n')
        !            39:                                        *r++ = ch;
        !            40:                                else {
        !            41:                                        *r++ = '\\';
        !            42:                                        *r++ = hextab[(ch >> 4) & 0xf];
        !            43:                                        *r++ = hextab[ch & 0xf];
        !            44:                                }
        !            45:                        }
        !            46:                } while (in < inend);
        !            47: 
        !            48:                if (r[-1] != '\n') {
        !            49:                        *r++ = '\\';
        !            50:                        *r++ = '\n';
        !            51:                }
        !            52:        }
        !            53: 
        !            54:        return r - out;
        !            55: }
        !            56: 
        !            57: static int
        !            58: mrform (char *in, char *inend, char *out)
        !            59: {
        !            60:        char *r;
        !            61:        register int len;
        !            62: 
        !            63:        len = inend - in;
        !            64:        if (len <= 0)
        !            65:                return 0;
        !            66: 
        !            67:        r = out;
        !            68: 
        !            69:        *r++ = '.';
        !            70: 
        !            71:        do {
        !            72:                register unsigned long bits;
        !            73:                register int n, outn;
        !            74:                register char *rr;
        !            75: 
        !            76:                n = len;
        !            77:                if (n > INCPW)
        !            78:                        n = INCPW;
        !            79:                len -= n;
        !            80:                outn = n + OUTCPW - INCPW;
        !            81: 
        !            82:                bits = 0;
        !            83:                do      bits = (bits << BPC) | (*in++ & BYTEMASK);
        !            84:                while (--n > 0);
        !            85: 
        !            86:                rr = r = r + outn;
        !            87:                do {
        !            88:                        *--rr = RADBASE + bits % RADIX;
        !            89:                        bits /= RADIX;
        !            90:                } while (--outn > 0);
        !            91:        } while (len > 0);
        !            92: 
        !            93:        *r++ = '\n';
        !            94: 
        !            95:        return r - out;
        !            96: }
        !            97: 
        !            98: 
        !            99: static int
        !           100: seal (FILE *f, char *fname)
        !           101: {
        !           102:        static int first = 1;
        !           103: 
        !           104:        if (first) {
        !           105:                first = 0;
        !           106:                printf ("!<seal>\n");
        !           107:        }
        !           108: 
        !           109:        do {
        !           110:                char line[MAXLINE];
        !           111:                char outline[MAXLINE*3+10];
        !           112:                register char *p, *endl;
        !           113:                register int ch;
        !           114: 
        !           115:                /* read a line, possibly short */
        !           116:                p = line;
        !           117:                endl = line + MAXLINE;
        !           118: 
        !           119:                do {
        !           120:                        ch = getc (f);
        !           121:                        if (ch == EOF)
        !           122:                                break;
        !           123:                        *p++ = ch;
        !           124:                } while (ch != '\n' && p < endl);
        !           125: 
        !           126:                endl = p;
        !           127: 
        !           128:                /*
        !           129:                 * endl now points one past the last char
        !           130:                 * in the line we have read.  If we didn't
        !           131:                 * get any characters at all, we're done.
        !           132:                 */
        !           133: 
        !           134:                if (line == endl)
        !           135:                        return ferror (f) != 0;
        !           136: 
        !           137:                length += endl - line;
        !           138: 
        !           139:                /* now convert the line to external form */
        !           140:                ch = hrform (line, endl, outline);
        !           141:                if (ch > (endl - line + INCPW - 1) / INCPW * OUTCPW + 2)
        !           142:                        ch = mrform (line, endl, outline);
        !           143:                p = outline;
        !           144: 
        !           145:                /* if encrypting, do so */
        !           146:                if (kflag || Kflag)
        !           147:                        mangle (line, endl);
        !           148: 
        !           149:                /* accumulate the (possibly encrypted) checksum */
        !           150:                checksum = mkcsum (checksum, line, endl);
        !           151: 
        !           152:                while (--ch >= 0)
        !           153:                        putchar (*p++);
        !           154:        } while (!feof (f) && !ferror (f));
        !           155: 
        !           156:        return ferror (f) != 0;
        !           157: }
        !           158: 
        !           159: int
        !           160: main (int argc, char **argv)
        !           161: {
        !           162:        int rc = 0;
        !           163:        static char stdbuf[BUFSIZ];
        !           164: 
        !           165:        setbuf (stdout, stdbuf);
        !           166: 
        !           167:        length = 0;
        !           168:        checksum = 0;
        !           169: 
        !           170:        rc = getargs (argc, argv, "kK:", seal);
        !           171: 
        !           172:        printf ("!end %ld %lu\n", length, checksum);
        !           173: 
        !           174:        return rc;
        !           175: }

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