Return to fstab.c CVS log

Up to [CSRG BSD Unix] / 42BSD / lib / libc / gen

Annotation of 42BSD/lib/libc/gen/fstab.c, revision 1.1.1.1

1.1       root        1: #ifndef lint
                      2: static char sccsid[] = "@(#)fstab.c    4.4 (Berkeley) 6/19/83";
                      3: #endif
                      4: 
                      5: #include <fstab.h>
                      6: #include <stdio.h>
                      7: #include <ctype.h>
                      8: 
                      9: static struct fstab fs;
                     10: static char line[BUFSIZ+1];
                     11: static FILE *fs_file = 0;
                     12: 
                     13: static char *
                     14: fsskip(p)
                     15:        register char *p;
                     16: {
                     17: 
                     18:        while (*p && *p != ':')
                     19:                ++p;
                     20:        if (*p)
                     21:                *p++ = 0;
                     22:        return (p);
                     23: }
                     24: 
                     25: static char *
                     26: fsdigit(backp, string, end)
                     27:        int *backp;
                     28:        char *string, end;
                     29: {
                     30:        register int value = 0;
                     31:        register char *cp;
                     32: 
                     33:        for (cp = string; *cp && isdigit(*cp); cp++) {
                     34:                value *= 10;
                     35:                value += *cp - '0';
                     36:        }
                     37:        if (*cp == '\0')
                     38:                return ((char *)0);
                     39:        *backp = value;
                     40:        while (*cp && *cp != end)
                     41:                cp++;
                     42:        if (*cp == '\0')
                     43:                return ((char *)0);
                     44:        return (cp+1);
                     45: }
                     46: 
                     47: static
                     48: fstabscan(fs)
                     49:        struct fstab *fs;
                     50: {
                     51:        register char *cp;
                     52: 
                     53:        cp = fgets(line, 256, fs_file);
                     54:        if (cp == NULL)
                     55:                return (EOF);
                     56:        fs->fs_spec = cp;
                     57:        cp = fsskip(cp);
                     58:        fs->fs_file = cp;
                     59:        cp = fsskip(cp);
                     60:        fs->fs_type = cp;
                     61:        cp = fsskip(cp);
                     62:        cp = fsdigit(&fs->fs_freq, cp, ':');
                     63:        if (cp == 0)
                     64:                return (3);
                     65:        cp = fsdigit(&fs->fs_passno, cp, '\n');
                     66:        if (cp == 0)
                     67:                return (4);
                     68:        return (5);
                     69: }
                     70:        
                     71: setfsent()
                     72: {
                     73: 
                     74:        if (fs_file)
                     75:                endfsent();
                     76:        if ((fs_file = fopen(FSTAB, "r")) == NULL) {
                     77:                fs_file = 0;
                     78:                return (0);
                     79:        }
                     80:        return (1);
                     81: }
                     82: 
                     83: endfsent()
                     84: {
                     85: 
                     86:        if (fs_file) {
                     87:                fclose(fs_file);
                     88:                fs_file = 0;
                     89:        }
                     90:        return (1);
                     91: }
                     92: 
                     93: struct fstab *
                     94: getfsent()
                     95: {
                     96:        int nfields;
                     97: 
                     98:        if ((fs_file == 0) && (setfsent() == 0))
                     99:                return ((struct fstab *)0);
                    100:        nfields = fstabscan(&fs);
                    101:        if (nfields == EOF || nfields != 5)
                    102:                return ((struct fstab *)0);
                    103:        return (&fs);
                    104: }
                    105: 
                    106: struct fstab *
                    107: getfsspec(name)
                    108:        char *name;
                    109: {
                    110:        register struct fstab *fsp;
                    111: 
                    112:        if (setfsent() == 0)    /* start from the beginning */
                    113:                return ((struct fstab *)0);
                    114:        while((fsp = getfsent()) != 0)
                    115:                if (strcmp(fsp->fs_spec, name) == 0)
                    116:                        return (fsp);
                    117:        return ((struct fstab *)0);
                    118: }
                    119: 
                    120: struct fstab *
                    121: getfsfile(name)
                    122:        char *name;
                    123: {
                    124:        register struct fstab *fsp;
                    125: 
                    126:        if (setfsent() == 0)    /* start from the beginning */
                    127:                return ((struct fstab *)0);
                    128:        while ((fsp = getfsent()) != 0)
                    129:                if (strcmp(fsp->fs_file, name) == 0)
                    130:                        return (fsp);
                    131:        return ((struct fstab *)0);
                    132: }
                    133: 
                    134: struct fstab *
                    135: getfstype(type)
                    136:        char *type;
                    137: {
                    138:        register struct fstab *fs;
                    139: 
                    140:        if (setfsent() == 0)
                    141:                return ((struct fstab *)0);
                    142:        while ((fs = getfsent()) != 0)
                    143:                if (strcmp(fs->fs_type, type) == 0)
                    144:                        return (fs);
                    145:        return ((struct fstab *)0);
                    146: }

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