source: trunk/athena/bin/quota/quota.c @ 24068

/* Copyright 1999 by the Massachusetts Institute of Technology.
 *
 * Permission to use, copy, modify, and distribute this
 * software and its documentation for any purpose and without
 * fee is hereby granted, provided that the above copyright
 * notice appear in all copies and that both that copyright
 * notice and this permission notice appear in supporting
 * documentation, and that the name of M.I.T. not be used in
 * advertising or publicity pertaining to distribution of the
 * software without specific, written prior permission.
 * M.I.T. makes no representations about the suitability of
 * this software for any purpose.  It is provided "as is"
 * without express or implied warranty.
 */

/* This is quota, which abstracts quota-checking mechanisms for
 * various types of lockers.
 */

static const char rcsid[] = "$Id: quota.c,v 1.27 1999-11-22 16:00:16 danw Exp $";

#include <ctype.h>
#include <pwd.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <locker.h>
#include "quota.h"

char **fsnames;
locker_context context;

static void usage(void);
static void print_quota(struct quota_fs *fs);
static void heading(uid_t uid, char *name);
static int alldigits(char *s);

int main(int argc, char **argv)
{
  int opt, i, status;
  struct passwd *pw;
  uid_t myuid;
  int all = 0;
  char *user;
  uid_t uid;
  int fsind = 0, fssize = 0, heading_printed = 0;
  int verbose = 0;
  struct quota_fs *fslist = NULL;
  sigset_t mask;

  myuid = getuid();
  if (locker_init(&context, myuid, NULL, NULL) != LOCKER_SUCCESS)
    {
      fprintf(stderr, "quota: Could not initialize locker library.\n");
      exit(1);
    }

  /* Block ^Z to prevent holding locks on the attachtab. */
  sigemptyset(&mask);
  sigaddset(&mask, SIGTSTP);
  sigaddset(&mask, SIGTTOU);
  sigaddset(&mask, SIGTTIN);
  sigprocmask(SIG_BLOCK, &mask, NULL);

  while ((opt = getopt(argc, argv, "af:guv")) != -1)
    {
      switch (opt)
        {
        case 'a':
          all = 1;
          break;

        case 'v':
          verbose = 1;
          break;

        case 'g':
          fprintf(stderr, "quota: Group quotas no longer supported.\n");
          exit(1);
          break;

        case 'u':
          /* Backward-compatibility option. */
          verbose = 1;
          break;

        case 'f':
          if (fsind >= fssize - 1)
            {
              fssize = 2 * (fssize + 1);
              fsnames = realloc(fsnames, fssize * sizeof(char *));
              if (!fsnames)
                {
                  fprintf(stderr, "quota: Out of memory.\n");
                  exit(1);
                }
            }

          if (!strchr(optarg, '/'))
            {
              locker_attachent *at;

              if (locker_read_attachent(context, optarg, &at) != 
                  LOCKER_SUCCESS)
                {
                  fprintf(stderr, "quota: Unknown filesystem %s.\n", optarg);
                  exit(1);
                }
              fsnames[fsind++] = strdup(at->mountpoint);
              locker_free_attachent(context, at);
            }
          else
            fsnames[fsind++] = optarg;
          break;

        default:
          fprintf(stderr, "quota: %s: unknown option\n", argv[optind - 1]);
          usage();
          exit(1);
        }
    }

  if (fsind)
    {
      if (all)
        {
          fprintf(stderr, "quota: Can't use both -a and -f\n");
          usage();
          exit(1);
        }
      fsnames[fsind] = NULL;
    }

  if (optind < argc)
    {
      if (optind < argc - 1)
        {
          fprintf(stderr, "quota: Can only specify a single user.\n");
          exit(1);
        }

      if (alldigits(argv[optind]))
        {
          uid = atoi(argv[optind]);

          pw = getpwuid(uid);
          if (pw)
            user = strdup(pw->pw_name);
          else
            user = "(no account)";
        }
      else
        {
          user = argv[optind];

          pw = getpwnam(user);
          if (pw)
            uid = pw->pw_uid;
          else
            {
              fprintf(stderr, "quota: No passwd entry for user %s.\n", user);
              exit(1);
            }
        }

      /* Check permission if not root. */
      if (myuid != 0 && uid != myuid)
        {
          fprintf(stderr, "quota: %s (uid %lu): permission denied\n",
                  user, (unsigned long) uid);
          exit(1);
        }
    }
  else
    {
      /* Use real uid. */
      uid = myuid;
      pw = getpwuid(myuid);
      if (!pw)
        {
          fprintf(stderr, "quota: Could not get password entry for uid %lu.\n",
                  (unsigned long) myuid);
          exit(1);
        }
      user = strdup(pw->pw_name);
    }

  if (uid == 0)
    {
      if (verbose)
        printf("no disk quota for %s (uid 0)\n", user);
      exit(0);
    }

  fslist = get_fslist(all ? 0 : uid);

  /* Now print quotas */
  for (i = 0; fslist[i].type; i++)
    {
      if (!strcasecmp(fslist[i].type, "afs"))
        status = get_afs_quota(&fslist[i], uid, verbose);
      else if (!strcasecmp(fslist[i].type, "nfs"))
        {
#ifdef ENABLE_NFS
          status = get_nfs_quota(&fslist[i], uid, verbose);
#else
          status = 1;
#endif
        }
      else
        status = get_local_quota(&fslist[i], uid, verbose);

      if (!status && fslist[i].have_quota && verbose)
        {
          if (!heading_printed)
            {
              heading(uid, user);
              heading_printed = 1;
            }
          print_quota(&fslist[i]);
        }
    }
  printf("\n");

  for (i = 0; fslist[i].type; i++)
    {
      if (fslist[i].warn_blocks || fslist[i].warn_files)
        {
          if (!strcasecmp(fslist[i].type, "afs"))
            print_afs_warning(&fslist[i]);
          else
            print_mounted_warning(&fslist[i]);
        }
    }

  exit(0);
}

static void heading(uid_t uid, char *name)
{
  printf("Disk quotas for %s (uid %lu):\n", name, (unsigned long) uid);
  printf("%-16s %8s %8s %8s    %8s %8s %8s\n",
         "Filesystem",
         "usage", "quota", "limit",
         "files", "quota", "limit");
}

static void print_quota(struct quota_fs *fs)
{
  /* Ignore all-zero quotas */
  if (!fs->dqb.dqb_bsoftlimit && !fs->dqb.dqb_bhardlimit
      && !fs->dqb.dqb_curblocks && !fs->dqb.dqb_fsoftlimit
      && !fs->dqb.dqb_fhardlimit && !fs->dqb.dqb_curfiles)
    return;

  if (strlen(fs->mount) > 16)
    printf("%s\n%-16s ", fs->mount, "");
  else
    printf("%-16s ", fs->mount);

  if (fs->have_blocks)
    {
      printf("%8u %8u %8u %2s ",
             fs->dqb.dqb_curblocks / 2,
             fs->dqb.dqb_bsoftlimit / 2,
             fs->dqb.dqb_bhardlimit / 2,
             fs->warn_blocks ? "<<" : "");
    }
  else
    printf("%30s", "");

  if (fs->have_files)
    {
      printf("%8u %8u %8u %2s ",
             fs->dqb.dqb_curfiles,
             fs->dqb.dqb_fsoftlimit,
             fs->dqb.dqb_fhardlimit,
             fs->warn_files ? "<<" : "");
    }

  printf("\n");
}

static int alldigits(char *s)
{
  int c;

  c = *s++;
  do {
    if (!isdigit(c))
      return 0;
  } while ((c = *s++));
  return 1;
}

static void usage(void)
{
  fprintf(stderr, "Usage: quota [-v] [-f filesystem...] [-u] [user]\n");
  exit(1);
}