source: trunk/athena/bin/quota/attachtab.c @ 9810

/*
 * $Id: attachtab.c,v 1.8 1997-04-01 01:02:28 ghudson Exp $
 *
 * Copyright (c) 1989,1991 by the Massachusetts Institute of Technology.
 *
 * Contains the routines which access the attachtab file.
 */

#ifndef lint
static char rcsid_attachtab_c[] = "$Id: attachtab.c,v 1.8 1997-04-01 01:02:28 ghudson Exp $";
#endif lint

#include "attach.h"
#include <fcntl.h>
#include <sys/file.h>
#include <pwd.h>
#include <string.h>

#define TOKSEP " \t\r\n"

static int parse_attach();

struct  _attachtab      *attachtab_first, *attachtab_last;

extern char *sys_errlist[];
static int debug_flag = 0;
static char attachtab_fn[512];
static char *abort_msg = "quota: aborting\n";

/*
 * LOCK the attachtab - wait for it if it's already locked
 */
static int attach_lock_fd = -1;
static int attach_lock_count = 0;

void lock_attachtab()
{
    register char *lockfn;
    register FILE *fp;
    register int status;
    static char buf[512];
    static int initd = 0;
#ifdef POSIX
    struct flock fl;
#endif

    if (!initd) {
        if (fp = fopen("/etc/athena/attach.conf","r")) {
            while (fgets(buf, sizeof(buf), fp)) {
                if (sscanf(buf, "attachtab %s", attachtab_fn) == 1) {
                    initd = 1;
                    break;
                }
            }
            fclose(fp);
        }
        if (!initd) {
            strcpy(attachtab_fn, "/var/athena/attachtab");
            initd = 1;
        }
    }
    
    if (debug_flag)
        printf("Locking attachtab....");
    if (attach_lock_count == 0) {
        if (!(lockfn = malloc(strlen(attachtab_fn)+6))) {
            fprintf(stderr,
                    "Can't malloc for lockfile filename\n");
            fprintf(stderr, abort_msg);
            exit(ERR_FATAL);
        }
        (void) strcpy(lockfn, attachtab_fn);
        (void) strcat(lockfn, ".lock");
        
        if (attach_lock_fd < 0) {
            attach_lock_fd = open(lockfn, O_CREAT|O_RDWR, 0644);
            if (attach_lock_fd < 0) {
                fprintf(stderr,"Can't open %s: %s\n", lockfn,
                        sys_errlist[errno]);
                fprintf(stderr, abort_msg);
                exit(ERR_FATAL);
            }
        }
#ifdef POSIX
        fl.l_type = F_WRLCK;
        fl.l_whence = SEEK_SET;
        fl.l_start = 0;
        fl.l_len = 0;
        fl.l_pid = getpid();
        status = fcntl(attach_lock_fd, F_SETLKW, &fl);
#else
        status = flock(attach_lock_fd, LOCK_EX);
#endif
        if (status == -1) {
            fprintf(stderr, "Unable to lock attachtab: %s\n",
                    sys_errlist[errno]);
            fprintf(stderr, abort_msg);
            exit(ERR_FATAL);
        }
        free(lockfn);
    }
    attach_lock_count++;
}


/*
 * UNLOCK the attachtab
 */
void unlock_attachtab()
{
    if (debug_flag)
        printf("Unlocking attachtab\n");
    attach_lock_count--;
    if (attach_lock_count == 0) {
        close(attach_lock_fd);
        attach_lock_fd = -1;
    } else if (attach_lock_count < 0) {
        fprintf(stderr,
                "Programming botch!  Tried to unlock unlocked attachtab\n");
    }
}

/*
 * get_attachtab - Reads in the attachtab file and sets up the doubly
 *      linked list of attachtab entries.  Assumes attachtab is
 *      already locked.
 */
void get_attachtab()
{
    register struct _attachtab  *atprev = NULL;
    register struct _attachtab  *at = NULL;
    register FILE                       *f;
    char                                attach_buf[BUFSIZ];
        
    free_attachtab();
    if ((f = fopen(attachtab_fn, "r")) == NULL) {
        fprintf(stderr, "Unable to open %s: %s\n",
                attachtab_fn, sys_errlist[errno]);
        return;
    }
        
    while (fgets(attach_buf, sizeof attach_buf, f)) {
        if (!(at = (struct _attachtab *) malloc(sizeof(*at)))) {
            fprintf(stderr,
                    "Can't malloc while parsing attachtab\n");
            fprintf(stderr, abort_msg);
            exit(ERR_FATAL);
        }
        if (parse_attach(attach_buf, at, 0) != SUCCESS) {
            free(at);
            continue;
        }
        at->prev = atprev;
        if (atprev)
            atprev->next = at;
        else
            attachtab_first = at;
        atprev = at;
    }
    attachtab_last = at;
    fclose(f);
}

/*
 * free the linked list of attachtab entries
 */
void free_attachtab()
{
    register struct _attachtab          *at, *next;
        
    if (!(at = attachtab_first))
        return;
    while (at) {
        next = at->next;
        free(at);
        at = next;
    }
    attachtab_first = attachtab_last = NULL;
}       

#if 0
/*
 * put_attachtab - write out attachtab file from linked list and
 *      unlocks attachtab
 */
put_attachtab()
{
    register FILE       *f;
    register struct     _attachtab      *at;
    register char       *tempfn;
        
    if (!(tempfn = malloc(strlen(attachtab_fn)+6))) {
        fprintf(stderr,
                "Can't malloc while writing attachtab.\n");
        fprintf(stderr, abort_msg);
        exit(ERR_FATAL);
    }
    (void) strcpy(tempfn, attachtab_fn);
    (void) strcat(tempfn, ".temp");
    if (!(f = fopen(tempfn, "w"))) {
        fprintf(stderr,"Can't open %s for write: %s\n", attachtab_fn,
                sys_errlist[errno]);
        fprintf(stderr, abort_msg);
        exit(ERR_FATAL);
    }
    at = attachtab_first;
    while (at) {
        register int i;

        fprintf(f, "%s %c%c%s %s %s %s %s",
                at->version, at->explicit ? '1' : '0',
                at->status, (at->fs) ? at->fs->name : "---",
                at->hesiodname, at->host, at->hostdir,
                inet_ntoa(at->hostaddr[0]));
        for (i=1; i<MAXHOSTS && at->hostaddr[i].s_addr; i++)
            fprintf(f, ",%s", inet_ntoa(at->hostaddr[i]));
        fprintf(f, " %d %s %d ",
                at->rmdir, at->mntpt, at->flags);
        if (at->nowners)
            fprintf(f, "%d", at->owners[0]);
        else
            fprintf(f, ",");
        for (i=1; i < at->nowners; i++)
            fprintf(f, ",%d", at->owners[i]);
        fprintf(f, " %d %c\n", at->drivenum, at->mode);

        at = at->next;
    }
    fclose(f);

    if (rename(tempfn, attachtab_fn)) {
        fprintf(stderr,"Can't rename %s to %s\n", tempfn,
                attachtab_fn);
        fprintf(stderr, abort_msg);
        exit(ERR_FATAL);
    }
}

void lint_attachtab()
{
    register struct _attachtab  *atprev = NULL;
    register struct _attachtab  *at = NULL;
    FILE                                *f;
    char                                attach_buf[BUFSIZ];
        
    free_attachtab();
    if ((f = fopen(attachtab_fn, "r")) == NULL)
        return;
        
    while (fgets(attach_buf, sizeof attach_buf, f)) {
        if (!(at = (struct _attachtab *) malloc(sizeof(*at)))) {
            fprintf(stderr,
                    "Can't malloc while parsing attachtab\n");
            fprintf(stderr, abort_msg);
            exit(ERR_FATAL);
        }
        if(parse_attach(attach_buf, at, 1) == FAILURE)
            continue;                           /* bad line -- ignore */
        at->prev = atprev;
        if (atprev)
            atprev->next = at;
        else
            attachtab_first = at;
        atprev = at;
    }
    attachtab_last = at;
    fclose(f);
    put_attachtab();
    free_attachtab();
}
#endif

/*
 * Convert an attachtab line to an attachtab structure
 */
static int parse_attach(bfr, at, lintflag)
    register char *bfr;
    register struct _attachtab *at;
    int lintflag;
{
    register char *cp;
    register int i;

    if (!*bfr)
        goto bad_line;
        
    if (bfr[strlen(bfr)-1] < ' ')
        bfr[strlen(bfr)-1] = '\0';
        
    if (!(cp = strtok(bfr, TOKSEP)))
        goto bad_line;

    if (strcmp(cp, ATTACH_VERSION)) {
        fprintf(stderr, "Bad version number in %s\n", attachtab_fn);
        if(lintflag) 
            return FAILURE;
        fprintf(stderr, abort_msg);
        exit(ERR_FATAL);
    }
    strcpy(at->version, cp);
    
    if (!(cp = strtok(NULL, TOKSEP)))
        goto bad_line;

    if (*cp != '0' && *cp != '1')
        goto bad_line;
    at->explicit = *cp++-'0';
    
    at->status = *cp++;
    if (at->status != STATUS_ATTACHED && at->status != STATUS_ATTACHING &&
        at->status != STATUS_DETACHING)
        goto bad_line;
    /* Quota doesn't care about this entry */
    if (at->status != STATUS_ATTACHED)
        return FAILURE;

    at->fs = get_fs(cp);
    if (at->fs == NULL)
        goto bad_line;

    if (!(cp = strtok(NULL, TOKSEP)))
        goto bad_line;
    (void) strcpy(at->hesiodname, cp);

    if (!(cp = strtok(NULL, TOKSEP)))
        goto bad_line;
    (void) strcpy(at->host, cp);

    if (!(cp = strtok(NULL, TOKSEP)))
        goto bad_line;
    (void) strcpy(at->hostdir, cp);

    if (!(cp = strtok(NULL, TOKSEP)))
        goto bad_line;

    for (i=0; cp; i++) {
        register char *dp;

        if (dp = index(cp, ','))
            *dp++ = '\0';
        at->hostaddr[i].s_addr = inet_addr(cp);
        cp = dp;
    }

    if (!(cp = strtok(NULL, TOKSEP)))
        goto bad_line;
    at->rmdir = atoi(cp);

    if (!(cp = strtok(NULL, TOKSEP)))
        goto bad_line;
    (void) strcpy(at->mntpt, cp);

    if (!(cp = strtok(NULL, TOKSEP)))
        goto bad_line;
    at->flags = atoi(cp);
    
    if (!(cp = strtok(NULL, TOKSEP)))
        goto bad_line;
    at->nowners = 0;
    if (*cp == ',')                             /* If heading character is comma */
        cp = 0;                                 /* we have a null list*/
    while (cp) {
        register char *dp;
            
        if (dp = index(cp, ','))
            *dp++ = '\0';
        at->owners[at->nowners++] = atoi(cp);
        cp = dp;
    }
    
    if (!(cp = strtok(NULL, TOKSEP)))
        goto bad_line;
    
    at->drivenum = atoi(cp);
    
    if (!(cp = strtok(NULL, TOKSEP)))
        goto bad_line;
    at->mode = *cp;
#if 0
    if (at->fs->good_flags) {
        if (!index(at->fs->good_flags, at->mode))
            goto bad_line;                      /* Bad attach mode */
    }
#endif
    
    at->next = NULL;
    at->prev = NULL;
    return SUCCESS;
    
 bad_line:
    fprintf(stderr,"Badly formatted entry in %s\n", attachtab_fn);
    if (lintflag)
        return FAILURE;
    fprintf(stderr, abort_msg);
    exit(ERR_FATAL);
    /* NOTREACHED */
}

#if 0
/*
 * Routine to see if a host is in the attachtab - uses the linked list
 * attachtab in memory
 */
host_occurs(name)
    register char *name;
{
    register struct _attachtab  *p;

    p = attachtab_first;
    while (p) {
        if (!strcasecmp(p->host, name))
            return(1);
        p = p->next;
    }
    return (0);
}
#endif

/*
 * Lookup an entry in attachtab  --- uses the linked list stored in memory
 */
struct _attachtab *attachtab_lookup(hesiod)
    register char *hesiod;
{
    register struct _attachtab  *p;

    p = attachtab_first;
    while (p) {
        if (!strcmp(p->hesiodname, hesiod))
            return(p);
        p = p->next;
    }
    return (NULL);
}

/*
 * Lookup an entry in attachtab by mountpoint --- uses the linked list
 *      stored in memory
 */
struct _attachtab *attachtab_lookup_mntpt(pt)
    register char *pt;
{
    register struct _attachtab  *p;

    p = attachtab_first;
    while (p) {
        if (!strcmp(p->mntpt, pt))
            return(p);
        p = p->next;
    }
    return (NULL);
}

#if 0
/*
 * Delete an entry from the attachtab --- unlinks the passed attachtab
 *      record in the in-core linked list; assumes attachtab is locked.
 *      You must call put_attachtab to actually affect the copy on disk.
 */
attachtab_delete(at)
    register struct _attachtab  *at;
{
    if (!at)
        return;
        
    if (at->prev)
        at->prev->next = at->next;
    else
        attachtab_first = at->next;
    if (at->next)
        at->next->prev = at->prev;
    else
        attachtab_last = at->prev;
    free(at);
}

/*
 * Append an entry to the linked list database in attachtab
 */
attachtab_append(at)
    register struct _attachtab *at;
{

    register struct _attachtab *atnew;

    if (!(atnew = (struct _attachtab *)
          malloc(sizeof(struct _attachtab)))) {
        fprintf(stderr, "Can't malloc while adding to attachtab\n");
        fprintf(stderr, abort_msg);
        exit(ERR_FATAL);
    }
    *atnew = *at;

    strcpy(atnew->version, ATTACH_VERSION);
        
    if (attachtab_last)
        attachtab_last ->next = atnew;
    else
        attachtab_first = atnew;
    atnew->prev = attachtab_last;
    atnew->next = NULL;
    attachtab_last = atnew;
}

/*
 * Replace an entry in the linked list 
 */
attachtab_replace(at)
    register struct _attachtab *at;
{
    register struct _attachtab *p, *next, *prev;

    strcpy(at->version, ATTACH_VERSION);
        
    p = attachtab_first;

    while (p) {
        if (!hescmp(p, at->hesiodname) && p->explicit == explicit) {
            next = p->next;
            prev = p->prev;
            *p = *at;
            p->next = next;
            p->prev = prev;
        }
        p = p->next;
    }
}
#endif


struct _fstypes fstypes[] = {
    "NFS", TYPE_NFS,
    "RVD", TYPE_RVD,
    "UFS", TYPE_UFS,
    "ERR", TYPE_ERR,
    "AFS", TYPE_AFS,
    "MUL", TYPE_MUL,
    0, 0 };

/*
 * Convert a string type to a filesystem type entry
 */
struct _fstypes *get_fs(s)
    char *s;
{
    int i;

    if (s && *s) {
        for (i=0;fstypes[i].name;i++) {
            if (!strcasecmp(fstypes[i].name, s))
                return (&fstypes[i]);
        }
    }
    return (NULL);
}