/*
 * Copyright 2000, International Business Machines Corporation and others.
 * All Rights Reserved.
 * 
 * This software has been released under the terms of the IBM Public
 * License.  For details, see the LICENSE file in the top-level source
 * directory or online at http://www.openafs.org/dl/license10.html
 */

/*
**	Lists all files in a /vicepX partition. This started as an
**	exercise to know the layout of AFS data in a fileserver
**	partition. Later on, it proved useful in debugging problems 
**	at customer sites too. 
**
*/
#include <afsconfig.h>
#include <afs/param.h>

RCSID("$Header: /cvs/openafs/src/vol/test/updateDirInode.c,v 1.4 2001/07/12 19:59:34 shadow Exp $");

#include <rx/xdr.h>
#include <afs/afsint.h>
#include <ctype.h>
#include <sys/param.h>
#if !defined(AFS_SGI_ENV)
#ifdef	AFS_OSF_ENV
#include <ufs/fs.h>
#else	/* AFS_OSF_ENV */
#ifdef AFS_VFSINCL_ENV
#define VFS
#ifdef	AFS_SUN5_ENV
#include <sys/fs/ufs_fs.h>
#else
#include <ufs/fs.h>
#endif
#else /* AFS_VFSINCL_ENV */
#ifndef	AFS_AIX_ENV
#include <sys/fs.h>
#endif
#endif AFS_VFSINCL_ENV
#endif	/* AFS_OSF_ENV */
#endif /* AFS_SGI_ENV */
#include <sys/errno.h>
#include <sys/stat.h>
#include <stdio.h>
#include <sys/file.h>
#if defined(AFS_SGI_ENV) || (defined(AFS_SUN_ENV) && !defined(AFS_BSD_ENV))
#include <dirent.h>
#else
#include <sys/dir.h>
#endif
#ifdef	AFS_AIX_ENV
#include <sys/vfs.h>
#include <fcntl.h>
#else
#ifdef	AFS_HPUX_ENV
#include <fcntl.h>
#include <mntent.h>
#else
#if	defined(AFS_SUN_ENV) || defined(AFS_SUN5_ENV)
#ifdef	AFS_SUN5_ENV
#include <sys/mnttab.h>
#include <sys/mntent.h>
#else
#include <mntent.h>
#endif
#else
#if defined(AFS_SGI_ENV)
#include <fcntl.h>
#include <mntent.h>

/*
#include <sys/fs/efs.h>
*/
#include "efs.h" /* until 5.1 release */

#define ROOTINO EFS_ROOTINO
#else
#include <fstab.h>
#endif
#endif /* AFS_SGI_ENV */
#endif /* AFS_HPUX_ENV */
#endif
#include <netdb.h>
#include <netinet/in.h>
#include <sys/wait.h>
#include <setjmp.h>
#ifndef ITIMER_REAL
#include <sys/time.h>
#endif /* ITIMER_REAL */

#include "nfs.h"
#include <afs/errors.h>
#include "lock.h"
#include "lwp.h"
#include "vnode.h"
#include "volume.h"
#include "vldb.h"
#include "partition.h"
#include "afs/assert.h"
#include "filesignal.h"
#include "vutils.h"
#include "fssync.h"
#include <afs/auxinode.h>
#include <afs/dir.h>
#include <unistd.h>

#ifdef	AFS_OSF_ENV
extern void *calloc(), *realloc();
#endif
#include "salvage.h"
int volumeId;
int VolumeChanged;   /* to satisfy library libdir use */

#include "listVicepx.h"
char*	orphan_NoVnode = "ORPHANED_NoVnode";
char*	orphan_NoUnique = "ORPHANED_NoUnique";
#define READBUFSIZE	5*1024


#define	allNull		0x00
#define verbose		0x01
#define	update		0x02	/* update specified dir inode */

int 
Usage( name)
char*	name;
{
	assert(name);
	printf("Usage is %s -p <partition name> -v <volume name> -dirInode <directory inode> -f <directoryFileName> -verbose\n", name);
	exit(1);
}
	

main(argc, argv)
int argc;
char*	argv[];
{
	char 		fullName[32+VNAMESIZE+sizeof(VHDREXT)+4];
	char 		partition[32], volume[VNAMESIZE];
	struct stat	statBuf;
	struct VolumeHeader	volumeHeader;
	int fd,i, sawPart=0, sawVolume=0, sawDirContents=0, sawDirFile=0;
	char option = allNull;			/* no default options */
	Inode  dirInode;		/* destination dir Inode */
	char*	fileName;		/* source directory file */

	for (i = 1; i < argc; i++)
	{
	    if (!strcmp(argv[i], "-p"))	
	    {
		if ( (i+1) >= argc )
		   Usage(argv[0]);
		assert(strlen(argv[i+1]) < 32 );
		strcpy( partition, argv[++i]);
		sawPart = 1;
	    } 
	    else if ( !strcmp(argv[i], "-v"))
	    {
		if ( (i+1) >= argc )
			Usage(argv[0]);
		assert(strlen(argv[i+1]) < VNAMESIZE );
		strcpy( volume, argv[++i]);
		sawVolume = 1;
	    } 
	    else if ( !strcmp(argv[i], "-dirInode"))
	    {
		if ( (i+1) >= argc )
			Usage(argv[0]);
		dirInode = atoi(argv[++i]);
		sawDirContents = 1;
		option |= update;
	    }
	    else if ( !strcmp(argv[i], "-f"))
	    {
		if ( (i+1) >= argc )
			Usage(argv[0]);
		fileName = argv[++i];
		sawDirFile = 1;
	    }
	    else if ( !strcmp(argv[i], "-verbose"))
		option |= verbose;
	    else
		Usage(argv[0]);
	}

	/* option to verify whether input file is syntactically good */
	if ( sawDirFile && !sawPart && !sawVolume && !sawDirContents)
        {
	    scanDirFile(0, 0, fileName, option);	
	    exit(2);
	}

	/* check input parameters */
	if ( !sawPart || !sawVolume || !sawDirFile || !sawDirContents)
		Usage(argv[0]);

	/* extract volume id */
	volumeId = atoi(volume);

	/* construct  unix file name */
	strcpy(fullName, partition);
	strcat(fullName,"/V");
	strcat(fullName,volume);
	strcat(fullName, VHDREXT);

	/* check to see that volume exists */
	if ( stat(fullName, &statBuf) < 0 )	
	{
		printf("Error in stat(%s) : %d\n", fullName, errno);
		exit(2);
	}

	/* read volume header */
	if ( (fd=open(fullName, O_RDONLY)) < 0 ) 
	{
		printf("Error in open(%s) : %d\n", fullName, errno);
		exit(3);
	}
	if ( read(fd, &volumeHeader, sizeof(struct VolumeHeader)) < sizeof(struct VolumeHeader))
	{
		printf("Error in reading Volume Header : %d\n", errno);
		exit(4);
	}

	scanDirFile(statBuf.st_dev, dirInode, fileName, option);	
	close(fd);
}

int 
scanDirFile(dev, node, fileName, option)
dev_t	dev;
Inode 	node;		/* destination directory inode number */
char*	fileName;	/* source file to update from */
char 	option;			/* user options */
{
    int              fd, i, j, temp;
    FILE*	     fp;
    char             dirPage[2048];
    char	     buf[READBUFSIZE];	/* read buffer */
    struct DirHeader *dhp= (struct DirHeader*)&dirPage[0];
    struct stat	     statBuf;
    int 		pgCount = 0;	/* current page */
	
    /* open this directory source file */
    if ( (fp = fopen(fileName, "r")) == 0 )
    {
       	printf("fopen of %s failed : %d\n", fileName, errno);
       	exit(6);
    }

    fgets(buf, READBUFSIZE, fp);      /* ignore "Alloc map:" */
    for ( i=0; i < MAXPAGES; i++)		/* read alloMap */
    {
	fscanf(fp, "%x", &temp);
	dhp->alloMap[i] = ( unsigned char )temp;
    }
    fgets(buf, READBUFSIZE, fp);      /* ignore trailing spaces */

    fgets(buf, READBUFSIZE, fp);      /* ignore "Hash map:" */
    for ( i=0; i < NHASHENT; i++)
    {
	fscanf(fp, "%d", &temp);
	dhp->hashTable[i] = (unsigned short)temp;
    }
    fgets(buf, READBUFSIZE, fp);      /* ignore trailing spaces */

    while ( ReadPage(fp, dhp, pgCount))	 /* read from source file */
    {
	if ( option  & verbose )
    	    PrintDir(dhp, pgCount); 
	if ( option & update )		/* update destnation dir inode */
	{
	    if ( pgCount == 0 ) 	/* first page */
		if ( (fd = iopen(dev, node, O_WRONLY)) < 0 )
		{
		    printf("Error in opening destination inode %d(err %d)\n",
					node, errno);
		    exit(1);
		}
	    if ( write(fd, dirPage, sizeof(dirPage)) != sizeof(dirPage))
	    {
		printf("Error in writing %d th page into inode %d(err %d)\n",
				pgCount, node, errno);
		exit(1);
	    }
	}
	pgCount++;
    }
    fclose(fp);
    close(fd);
}

			/* prints out a directory data */
PrintDir(dhp, pgCount)
struct DirHeader *dhp;
int 	pgCount; 	/* current page Number */
{
    int i;
    struct DirEntry  *de;
    struct PageHeader *pg;

    if ( pgCount == 0 ) 	/* first page */
    {
        printf("Alloc map: ");
        for ( i=0; i < MAXPAGES; i++)		/* read alloMap */
        {
	    if ( (i % 16) == 0 )
                printf("\n");
	    printf("%.2x ", dhp->alloMap[i]);
        }
        printf("\nHash table:");
        for ( i=0; i < NHASHENT; i++)
        {
            if ( (i % 16) == 0 )
                printf("\n");
            printf("%.2d ", dhp->hashTable[i]);
        }
        printf("\n");

        /* print page header info */
        printf("--------------- Page 0 ---------------\n");
	printf("pgcnt      :%d\n", dhp->header.pgcount);
	printf("tag        :%d\n", dhp->header.tag);
	printf("freecnt    :%d(not used)\n", dhp->header.freecount);
	printf("freebitmap :");
	for ( i=0; i < EPP/8; i++)
    		printf("%.2x ", (unsigned char)(dhp->header.freebitmap[i]));
	printf("\n");

        /* print slots in the first page of this directory */
        de = ((struct DirPage0 *)dhp)->entry;
        for(i=DHE+1; i<EPP; i++, de = (struct DirEntry*)((char *)de+32))
            printf("ent %d: f=%d l=%d n=%d vn=%d vu=%d name:%s\n",
                i, de->flag, de->length, de->next,
                de->fid.vnode, de->fid.vunique, de->name);
    }
    else
    {
	pg = &((struct DirPage1 *)dhp)->header; /* page header */
	de = ((struct DirPage1 *)dhp)->entry;

	/* print page header info */
	printf("--------------- Page %d ---------------\n", pgCount);
        printf("pgcnt      :%d\n", pg->pgcount);
        printf("tag        :%d\n", pg->tag);
        printf("freecnt    :%d(not used)\n", pg->freecount);
        printf("freebitmap :");
        for ( i=0; i < EPP/8; i++)
            printf("%.2x ", (unsigned char)(pg->freebitmap[i]));
        printf("\n");

        /* print slots in this page */
        for(i=1; i<EPP; i++, de = (struct DirEntry*)((char *)de+32))
            printf("ent %d: f=%d l=%d n=%d vn=%d vu=%d name:%s\n",
                i, de->flag, de->length, de->next,
                de->fid.vnode, de->fid.vunique, de->name);
    }
}

/*
** Returns 0 if there are no more pages 
** Returns 1 if there are more pages to be read 
*/
ReadPage(fp, dhp, pageNo) /* Read one page(pageNo) from file fp into dhp*/
FILE*	fp;
struct DirHeader *dhp;
int pageNo;
{
    int 	pgcnt, page, freecnt, freebit[EPP/8];
    int 	tag;
    char	buf[READBUFSIZE];       /* read buffer */
    int 	start;
    int		i, ent, f, l, n, vnode, unique;
    char	dirName[18];
    struct DirEntry 	*dirEntry;
    struct PageHeader 	*pageHeader;

    if(fscanf(fp,"--------------- Page %d ---------------\n",&page)!=1)
    {
	return 0;		/* no more pages */
    }
    /* defensive check */
    if ( page != pageNo )
    {
	printf("Wrong page: pageNo %d does not match data in file %d\n",
			pageNo, page);
	exit(1);
    }

    if ( fscanf(fp, "pgcnt      :%d", &pgcnt) != 1 )
    {
	printf("Error in looking for pgcnt:<int> in page %d\n", pageNo);
	exit(1);
    }
    fgets(buf, READBUFSIZE, fp);      /* ignore trailing spaces */

    if ( fscanf(fp, "tag        :%d", &tag) != 1 )
    {
	printf("Error in looking for tag:<int> in page %d\n", pageNo);
	exit(1);
    }
    fgets(buf, READBUFSIZE, fp);      /* ignore trailing spaces */

    if ( fscanf(fp, "freecnt    :%d", &freecnt) != 1 )
    {
	printf("Error in looking for freecnt:<int> in page %d\n", pageNo);
	exit(1);
    }
    fgets(buf, READBUFSIZE, fp);      /* ignore trailing spaces */

    if ( fscanf(fp, "freebitmap :%x %x %x %x %x %x %x %x", 
		&freebit[0], &freebit[1], &freebit[2], &freebit[3],
		&freebit[4], &freebit[5], &freebit[6], &freebit[7]) != 8 )
    {
	printf("Error in looking for freecnt:<ints> in page %d\n", pageNo);
	exit(1);
    }
    fgets(buf, READBUFSIZE, fp);      /* ignore trailing spaces */

    if ( pageNo == 0 )			/* first page */
    {
	start = DHE+1;			/* this is 13 */
	dirEntry = ((struct DirPage0 *)dhp)->entry;
        pageHeader = &(dhp->header);
    }
    else
    {
	start = 1;
	dirEntry = ((struct DirPage1 *)dhp)->entry;
	pageHeader = &( ((struct DirPage1 *)dhp)->header);
    }

		/* update page header */
    pageHeader->pgcount = pgcnt;
    pageHeader->tag	= tag;
    pageHeader->freecount = freecnt; /* this is currently unused */
    for ( i=0; i < EPP/8; i++)
	pageHeader->freebitmap[i] = freebit[i];

		/* update directory entries */
    for ( ; start < EPP; start++ )
    {
	if ( fscanf(fp, "ent %d: f=%d l=%d n=%d vn=%d vu=%d name:%s\n",
	    &ent, &f, &l, &n, &vnode, &unique, dirName) != 7 )
        {
	    printf("Error in reading the %d th entry in page %d\n", 
				start, pageNo);
	    exit(1);
        }
	if ( ent != start )
        {
	    printf("Wrong dir entry: found %d, has to be %\n",
				ent, start);
	    exit(1);
        }
	dirEntry->flag = f;
	dirEntry->length = l;
	dirEntry->next = n;
	dirEntry->fid.vnode = vnode;
	dirEntry->fid.vunique = unique;
	memcpy(dirEntry->name, dirName, 18);
	strncpy(dirEntry->name, dirName);

	dirEntry = ( struct DirEntry *) ( (char *)dirEntry + 32 );
    }
    return 1; 	/* there are more pages */
}
