Return to isofs_util.c CVS log

Up to [Net/2] / Net2 / isofs

Annotation of Net2/isofs/isofs_util.c, revision 1.1

1.1     ! root        1: int
        !             2: isonum_711 (p)
        !             3: char *p;
        !             4: {
        !             5:        return (*p & 0xff);
        !             6: }
        !             7: 
        !             8: int
        !             9: isonum_712 (p)
        !            10: char *p;
        !            11: {
        !            12:        int val;
        !            13: 
        !            14:        val = *p;
        !            15:        if (val & 0x80)
        !            16:                val |= 0xffffff00;
        !            17:        return (val);
        !            18: }
        !            19: 
        !            20: int
        !            21: isonum_721 (p)
        !            22: char *p;
        !            23: {
        !            24:        return ((p[0] & 0xff) | ((p[1] & 0xff) << 8));
        !            25: }
        !            26: 
        !            27: int
        !            28: isonum_722 (p)
        !            29: char *p;
        !            30: {
        !            31:        return (((p[0] & 0xff) << 8) | (p[1] & 0xff));
        !            32: }
        !            33: 
        !            34: int
        !            35: isonum_723 (p)
        !            36: char *p;
        !            37: {
        !            38: #if 0
        !            39:        if (p[0] != p[3] || p[1] != p[2]) {
        !            40:                fprintf (stderr, "invalid format 7.2.3 number\n");
        !            41:                exit (1);
        !            42:        }
        !            43: #endif
        !            44:        return (isonum_721 (p));
        !            45: }
        !            46: 
        !            47: int
        !            48: isonum_731 (p)
        !            49: char *p;
        !            50: {
        !            51:        return ((p[0] & 0xff)
        !            52:                | ((p[1] & 0xff) << 8)
        !            53:                | ((p[2] & 0xff) << 16)
        !            54:                | ((p[3] & 0xff) << 24));
        !            55: }
        !            56: 
        !            57: int
        !            58: isonum_732 (p)
        !            59: char *p;
        !            60: {
        !            61:        return (((p[0] & 0xff) << 24)
        !            62:                | ((p[1] & 0xff) << 16)
        !            63:                | ((p[2] & 0xff) << 8)
        !            64:                | (p[3] & 0xff));
        !            65: }
        !            66: 
        !            67: int
        !            68: isonum_733 (p)
        !            69: char *p;
        !            70: {
        !            71:        int i;
        !            72: 
        !            73: #if 0
        !            74:        for (i = 0; i < 4; i++) {
        !            75:                if (p[i] != p[7-i]) {
        !            76:                        fprintf (stderr, "bad format 7.3.3 number\n");
        !            77:                        exit (1);
        !            78:                }
        !            79:        }
        !            80: #endif
        !            81:        return (isonum_731 (p));
        !            82: }
        !            83: 
        !            84: /*
        !            85:  * translate and compare a filename
        !            86:  */
        !            87: isofncmp(char *fn, int fnlen, char *isofn, int isolen) {
        !            88:        int fnidx;
        !            89: 
        !            90:        fnidx = 0;
        !            91:        for (fnidx = 0; fnidx < isolen; fnidx++, fn++) {
        !            92:                char c = *isofn++;
        !            93: 
        !            94:                if (fnidx > fnlen)
        !            95:                        return (0);
        !            96: 
        !            97:                if (c >= 'A' && c <= 'Z') {
        !            98:                        if (c + ('a' - 'A') !=  *fn)
        !            99:                                return(0);
        !           100:                        else
        !           101:                                continue;
        !           102:                }
        !           103:                if (c == ';')
        !           104:                        return ((fnidx == fnlen));
        !           105:                if (c != *fn)
        !           106:                        return (0);
        !           107:        }
        !           108:        return (1);
        !           109: }
        !           110: 
        !           111: /*
        !           112:  * translate a filename
        !           113:  */
        !           114: void
        !           115: isofntrans(char *infn, int infnlen, char *outfn, short *outfnlen) {
        !           116:        int fnidx;
        !           117: 
        !           118:        fnidx = 0;
        !           119:        for (fnidx = 0; fnidx < infnlen; fnidx++) {
        !           120:                char c = *infn++;
        !           121: 
        !           122:                if (c >= 'A' && c <= 'Z')
        !           123:                        *outfn++ = c + ('a' - 'A');
        !           124:                else if (c == ';') {
        !           125:                        *outfnlen = fnidx;
        !           126:                        return;
        !           127:                } else
        !           128:                        *outfn++ = c;
        !           129:        }
        !           130:        *outfnlen = infnlen;
        !           131: }

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