source: trunk/minix/lib/other/mtab.c@ 20

/* 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
 *      put_mtab_entry(&s1, &s2, &s3, &s4) - append a line to mtab_out
 *      rewrite_mtab(&prog_name)           - write mtab_out to /etc/mtab
 *
 * If load_mtab and rewrite_mtab work, they return 0.  If they fail, they
 * print their own error messages on stderr and return -1.  When get_mtab_entry
 * runs out of entries to return, it sets the first pointer to NULL and returns
 * -1 instead of 0.  Also, rewrite_mtab returns -1 if it fails.
 */
 
#include <sys/types.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 mtab_out[BUF_SIZE+1]; /* buf to build /etc/mtab for output later */
static char *iptr = mtab_in;      /* pointer to next line to feed out. */
static char *optr = mtab_out;     /* pointer to place where next line goes */

_PROTOTYPE(int load_mtab, (char *prog_name ));
_PROTOTYPE(int rewrite_mtab, (char *prog_name ));
_PROTOTYPE(int get_mtab_entry, (char *special, char *mounted_on, 
                                        char *version, char *rw_flag));
_PROTOTYPE(int put_mtab_entry, (char *special, char *mounted_on, 
                                        char *version, char *rw_flag));
_PROTOTYPE(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);

  /* Replace all the whitespace by '\0'. */
  ptr = mtab_in;
  while (*ptr != '\0') {
        if (isspace(*ptr)) *ptr = '\0';
        ptr++;
  }
  return(0);
}


int rewrite_mtab(prog_name)
char *prog_name;
{
/* Write mtab_out to /etc/mtab. */

  int fd, n;

  /* Do a creat to truncate the file. */
  fd = creat(etc_mtab, 0777);
  if (fd < 0) {
        err(prog_name, ": cannot overwrite ");
        return(-1);
  }

  /* File created.  Write it. */
  n = write(fd, mtab_out, (unsigned int)(optr - mtab_out));
  if (n <= 0) {
        /* Write failed. */
        err(prog_name, " could not write ");
        return(-1);
  }

  close(fd);
  return(0);
}


int get_mtab_entry(special, mounted_on, version, rw_flag)
char *special;
char *mounted_on;
char *version;
char *rw_flag;
{
/* Return the next entry from mtab_in. */

  if (iptr >= &mtab_in[BUF_SIZE]) {
        special[0] = '\0';
        return(-1);
  }

  strcpy(special, iptr);
  while (isprint(*iptr)) iptr++;
  while (*iptr == '\0'&& iptr < &mtab_in[BUF_SIZE]) iptr++;

  strcpy(mounted_on, iptr);
  while (isprint(*iptr)) iptr++;
  while (*iptr == '\0'&& iptr < &mtab_in[BUF_SIZE]) iptr++;

  strcpy(version, iptr);
  while (isprint(*iptr)) iptr++;
  while (*iptr == '\0'&& iptr < &mtab_in[BUF_SIZE]) iptr++;

  strcpy(rw_flag, iptr);
  while (isprint(*iptr)) iptr++;
  while (*iptr == '\0'&& iptr < &mtab_in[BUF_SIZE]) iptr++;
  return(0);
}


int put_mtab_entry(special, mounted_on, version, rw_flag)
char *special;
char *mounted_on;
char *version;
char *rw_flag;
{
/* Append an entry to the mtab_out buffer. */

  int n1, n2, n3, n4;

  n1 = strlen(special);
  n2 = strlen(mounted_on);
  n3 = strlen(version);
  n4 = strlen(rw_flag);

  if (optr + n1 + n2 + n3 + n4 + 5 >= &mtab_out[BUF_SIZE]) return(-1);
  strcpy(optr, special);
  optr += n1;
  *optr++ = ' ';

  strcpy(optr, mounted_on);
  optr += n2;
  *optr++ = ' ';

  strcpy(optr, version);
  optr += n3;
  *optr++ = ' ';

  strcpy(optr, rw_flag);
  optr += n4;
  *optr++ = '\n';
  return(0);
}


void
err(prog_name, str)
char *prog_name, *str;
{
  std_err(prog_name); 
  std_err(str);
  std_err(etc_mtab);
  perror(" ");
}