125 lines
3 KiB
C
125 lines
3 KiB
C
/* This package consists of 4 routines for handling the /etc/mtab file.
|
|
* The /etc/mtab file contains information about the root and mounted file
|
|
* systems as a series of lines, each one with exactly four fields separated
|
|
* by one space as follows:
|
|
*
|
|
* special mounted_on version rw_flag
|
|
*
|
|
* where
|
|
* special is the name of the block special file
|
|
* mounted_on is the directory on which it is mounted
|
|
* version is either 1 or 2 for MINIX V1 and V2 file systems
|
|
* rw_flag is rw or ro for read/write or read only
|
|
*
|
|
* An example /etc/mtab:
|
|
*
|
|
* /dev/ram / 2 rw
|
|
* /dev/hd1 /usr 2 rw
|
|
* /dev/fd0 /user 1 ro
|
|
*
|
|
*
|
|
* The four routines for handling /etc/mtab are as follows. They use two
|
|
* (hidden) internal buffers, mtab_in for input and mtab_out for output.
|
|
*
|
|
* load_mtab(&prog_name) - read /etc/mtab into mtab_in
|
|
* get_mtab_entry(&s1, &s2, &s3, &s4) - arrays that are filled in
|
|
*
|
|
* If load_mtab works, it returns 0. If it fails, it prints its own error
|
|
* message on stderr and returns -1. When get_mtab_entry
|
|
* runs out of entries to return, it sets the first pointer to NULL and returns
|
|
* -1 instead of 0.
|
|
*/
|
|
|
|
#include <sys/types.h>
|
|
#include <lib.h>
|
|
#include <minix/minlib.h>
|
|
#include <ctype.h>
|
|
#include <fcntl.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <stdio.h>
|
|
|
|
#define BUF_SIZE 512 /* size of the /etc/mtab buffer */
|
|
|
|
char *etc_mtab = "/etc/mtab"; /* name of the /etc/mtab file */
|
|
static char mtab_in[BUF_SIZE+1]; /* holds /etc/mtab when it is read in */
|
|
static char *iptr = mtab_in; /* pointer to next line to feed out. */
|
|
|
|
int load_mtab(char *prog_name );
|
|
int get_mtab_entry(char dev[PATH_MAX], char mount_point[PATH_MAX],
|
|
char type[MNTNAMELEN], char flags[MNTFLAGLEN]);
|
|
static void err(char *prog_name, char *str );
|
|
|
|
|
|
int load_mtab(prog_name)
|
|
char *prog_name;
|
|
{
|
|
/* Read in /etc/mtab and store it in /etc/mtab. */
|
|
|
|
int fd, n;
|
|
char *ptr;
|
|
|
|
/* Open the file. */
|
|
fd = open(etc_mtab, O_RDONLY);
|
|
if (fd < 0) {
|
|
err(prog_name, ": cannot open ");
|
|
return(-1);
|
|
}
|
|
|
|
/* File opened. Read it in. */
|
|
n = read(fd, mtab_in, BUF_SIZE);
|
|
if (n <= 0) {
|
|
/* Read failed. */
|
|
err(prog_name, ": cannot read ");
|
|
return(-1);
|
|
}
|
|
if (n == BUF_SIZE) {
|
|
/* Some nut has mounted 50 file systems or something like that. */
|
|
std_err(prog_name);
|
|
std_err(": file too large: ");
|
|
std_err(etc_mtab);
|
|
return(-1);
|
|
}
|
|
|
|
close(fd);
|
|
|
|
ptr = mtab_in;
|
|
|
|
return(0);
|
|
}
|
|
|
|
int get_mtab_entry(char dev[PATH_MAX], char mount_point[PATH_MAX],
|
|
char type[MNTNAMELEN], char flags[MNTFLAGLEN])
|
|
{
|
|
/* Return the next entry from mtab_in. */
|
|
|
|
int r;
|
|
|
|
if (iptr >= &mtab_in[BUF_SIZE]) {
|
|
dev[0] = '\0';
|
|
return(-1);
|
|
}
|
|
|
|
r = sscanf(iptr, "%s on %s type %s (%[^)]s\n",
|
|
dev, mount_point, type, flags);
|
|
if (r != 4) {
|
|
dev[0] = '\0';
|
|
return(-1);
|
|
}
|
|
|
|
iptr = strchr(iptr, '\n'); /* Find end of line */
|
|
if (iptr != NULL) iptr++; /* Move to next line */
|
|
return(0);
|
|
|
|
}
|
|
|
|
static void
|
|
err(prog_name, str)
|
|
char *prog_name, *str;
|
|
{
|
|
std_err(prog_name);
|
|
std_err(str);
|
|
std_err(etc_mtab);
|
|
perror(" ");
|
|
}
|