/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
/*
* Copyright 2003 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#ident "%Z%%M% %I% %E% SMI" /* SVr4.0 1.8 */
/*
* acctdusg [-u file] [-p file] > dtmp-file
* -u file for names of files not charged to anyone
* -p get password info from file
* reads std input (normally from find / -print)
* and computes disk resource consumption by login
*/
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <pwd.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <libcmdutils.h>
#include "acctdef.h"
struct disk {
struct disk *next; /* next entry at same hash tbl index */
uid_t dsk_uid; /* user id of login name */
blkcnt_t dsk_du; /* disk usage */
char dsk_name[NSZ+1]; /* login name */
char validuser; /* set if the uid exists */
};
static char *pfile = NULL;
static FILE *nchrg = NULL;
static avl_tree_t *tree = NULL;
static struct disk *usglist[MAXUSERS]; /* holds data on disk usg by uid */
#define HASHKEY(x) ((int)((unsigned int)(x) % MAXUSERS))
static struct disk *hash_insert(uid_t);
static struct disk *hash_find(uid_t);
static void openerr(char *);
static void output(void);
static void validate_entry(struct disk *, struct passwd *);
static void charge(char *);
#ifdef DEBUG
static void pdisk(void);
#endif
int
main(int argc, char **argv)
{
char fbuf[PATH_MAX+1], *fb;
FILE *pwf;
int c;
struct passwd *pw;
struct disk *entry;
while ((c = getopt(argc, argv, "p:u:")) != EOF) {
switch (c) {
case 'u':
if ((nchrg = fopen(optarg, "w")) == NULL)
openerr(optarg);
(void) chmod(optarg, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
break;
case 'p':
pfile = optarg;
break;
default:
exit(1);
}
}
if (pfile) {
if ((pwf = fopen(pfile, "r")) == NULL) {
openerr(pfile);
}
/* fill usglist with the user's in the passwd file */
while ((pw = fgetpwent(pwf)) != NULL) {
if ((entry = hash_find(pw->pw_uid)) == NULL)
entry = hash_insert(pw->pw_uid);
validate_entry(entry, pw);
}
(void) fclose(pwf);
}
/* charge the files listed in names to users listed in the usglist */
while (fgets(fbuf, sizeof (fbuf), stdin) != NULL) {
if ((fb = strchr(fbuf, '\n')) != NULL) {
/*
* replace the newline char at the end of the
* filename with a null character
*/
*fb = '\0';
}
charge(fbuf);
}
output();
if (nchrg)
(void) fclose(nchrg);
#ifdef DEBUG
pdisk();
#endif
return (0);
}
/*
* create a new entry and insert.
*/
static struct disk *
hash_insert(uid_t uid)
{
struct disk *curdisk;
int key = HASHKEY(uid);
if ((curdisk = malloc(sizeof (struct disk))) == NULL) {
(void) fprintf(stderr, "acctdusg: cannot allocate memory "
"for hash table entry\n");
exit(1);
}
curdisk->dsk_uid = uid;
curdisk->dsk_du = 0;
curdisk->validuser = 0; /* initially invalid */
curdisk->next = usglist[key];
usglist[key] = curdisk;
return (curdisk);
}
/*
* return the disk entry for given uid. return NULL if not found.
*/
static struct disk *
hash_find(uid_t uid)
{
struct disk *curdisk;
for (curdisk = usglist[HASHKEY(uid)];
curdisk != NULL; curdisk = curdisk->next) {
if (curdisk->dsk_uid == uid) {
return (curdisk);
}
}
return (NULL);
}
static void
openerr(char *file)
{
(void) fprintf(stderr, "Cannot open %s\n", file);
exit(1);
}
static void
output(void)
{
int index;
struct disk *entry;
for (index = 0; index < MAXUSERS; index++) {
for (entry = usglist[index];
entry != NULL; entry = entry->next) {
if (entry->dsk_du != 0) {
(void) printf("%ld\t%s\t%lld\n",
entry->dsk_uid,
entry->dsk_name,
entry->dsk_du);
}
}
}
}
/*
* Initialize the disk entry for a valid passwd entry.
*/
static void
validate_entry(struct disk *entry, struct passwd *pw)
{
(void) strlcpy(entry->dsk_name, pw->pw_name,
sizeof (entry->dsk_name));
entry->validuser = 1;
}
static void
charge(char *n)
{
struct stat statb;
struct disk *entry;
struct passwd *pw;
if (lstat(n, &statb) == -1)
return;
/*
* do not count the duplicate entries.
*/
if (statb.st_nlink > 1) {
switch (add_tnode(&tree, statb.st_dev, statb.st_ino)) {
case 0:
/* already exist */
return;
case 1:
/* added */
break;
default:
perror("acctdusg");
exit(1);
}
}
/*
* st_blocks is not defined for character/block special files.
*/
if (S_ISCHR(statb.st_mode) || S_ISBLK(statb.st_mode))
statb.st_blocks = 0;
/*
* If -p is given, we've all loaded the passwd entries.
* Files with unknown uid should go into nchrg. Otherwise
* (without -p), we try creating new entry for the uid.
*/
if ((entry = hash_find(statb.st_uid)) == NULL) {
if (pfile == NULL) {
pw = getpwuid(statb.st_uid);
entry = hash_insert(statb.st_uid);
if (pw != NULL) {
validate_entry(entry, pw);
}
}
}
if (entry != NULL && entry->validuser) {
entry->dsk_du += statb.st_blocks;
} else if (nchrg) {
(void) fprintf(nchrg, "%9ld\t%7llu\t%s\n",
statb.st_uid, statb.st_blocks, n);
}
}
#ifdef DEBUG
static void
pdisk()
{
int index;
struct disk *entry;
for (index = 0; index < MAXUSERS; index++) {
for (entry = usglist[index];
entry != NULL; entry = entry->next) {
(void) fprintf(stderr, "%.8s\t%9ld\t%7llu\n",
entry->dsk_name,
entry->dsk_uid,
entry->dsk_du);
}
}
}
#endif