/*
 * Program write.c - dump memory  structures to  file for iso9660 filesystem.

   Written by Eric Youngdale (1993).

   Copyright 1993 Yggdrasil Computing, Incorporated

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */

#include <string.h>
#include <stdlib.h>
#include "mkisofs.h"
#include "iso9660.h"
#include <time.h>
#include <errno.h>

#ifdef __svr4__
extern char * strdup(const char *);
#endif

#ifdef VMS
extern char * strdup(const char *);
#endif


/* Max number of sectors we will write at  one time */
#define NSECT 16

/* Counters for statistics */

static int table_size = 0;
static int total_dir_size = 0;
static int rockridge_size = 0;
static struct directory ** pathlist;
static next_path_index = 1;

/* Used to fill in some  of the information in the volume descriptor. */
static struct tm *local;

/* Routines to actually write the disc.  We write sequentially so that
   we could write a tape, or write the disc directly */


#define FILL_SPACE(X)   memset(vol_desc.X, ' ', sizeof(vol_desc.X))

void FDECL2(set_721, char *, pnt, unsigned int, i){
 	pnt[0] = i & 0xff;
	pnt[1] = (i >> 8) &  0xff;
}

void FDECL2(set_722, char *, pnt, unsigned int, i){
	pnt[0] = (i >> 8) &  0xff;
 	pnt[1] = i & 0xff;
}

void FDECL2(set_723, char *, pnt, unsigned int, i){
 	pnt[3] = pnt[0] = i & 0xff;
	pnt[2] = pnt[1] = (i >> 8) &  0xff;
}

void FDECL2(set_731, char *, pnt, unsigned int, i){
 	pnt[0] = i & 0xff;
	pnt[1] = (i >> 8) &  0xff;
	pnt[2] = (i >> 16) &  0xff;
	pnt[3] = (i >> 24) &  0xff;
}

void FDECL2(set_732, char *, pnt, unsigned int, i){
 	pnt[3] = i & 0xff;
	pnt[2] = (i >> 8) &  0xff;
	pnt[1] = (i >> 16) &  0xff;
	pnt[0] = (i >> 24) &  0xff;
}

int FDECL1(get_733, char *, p){
	return ((p[0] & 0xff)
		| ((p[1] & 0xff) << 8)
		| ((p[2] & 0xff) << 16)
		| ((p[3] & 0xff) << 24));
}

void FDECL2(set_733, char *, pnt, unsigned int, i){
 	pnt[7] = pnt[0] = i & 0xff;
	pnt[6] = pnt[1] = (i >> 8) &  0xff;
	pnt[5] = pnt[2] = (i >> 16) &  0xff;
	pnt[4] = pnt[3] = (i >> 24) &  0xff;
}

static FDECL4(xfwrite, void *, buffer, int, count, int, size, FILE *, file)
{
  while(count) {
	int got=fwrite(buffer,size,count,file);
	if(got<=0) fprintf(stderr,"cannot fwrite %d*%d\n",size,count),exit(1);
	count-=got,*(char**)&buffer+=size*got;
  }
}

struct deferred_write{
  struct deferred_write * next;
  char * table;
  unsigned int extent;
  unsigned int size;
  char * name;
};

static struct deferred_write * dw_head = NULL, * dw_tail = NULL;

static struct directory_entry * sort_dir;

unsigned int last_extent_written  =0;
static struct iso_primary_descriptor vol_desc;
static path_table_index;

/* We recursively walk through all of the directories and assign extent
   numbers to them.  We have already assigned extent numbers to everything that
   goes in front of them */

void FDECL1(assign_directory_addresses, struct directory *, node){
  struct directory * dpnt;
  int dir_size;

  dpnt = node;

  while (dpnt){
    dpnt->extent = last_extent;
    dpnt->path_index = next_path_index++;
    dir_size = (dpnt->size + (SECTOR_SIZE - 1)) >> 11;

    last_extent += dir_size;

    /* Leave room for the CE entries for this directory.  Keep them
       close to the reference directory so that access will be quick. */
    if(dpnt->ce_bytes)
      last_extent += ROUND_UP(dpnt->ce_bytes) >> 11;

    if(dpnt->subdir) assign_directory_addresses(dpnt->subdir);
    dpnt = dpnt->next;
  };
}

static void FDECL3(write_one_file, char *, filename, unsigned int, size, FILE *, outfile){
  FILE * infile;
  char buffer[SECTOR_SIZE * NSECT];
  int use;
  int remain;
  if ((infile = fopen(filename, "rb")) == NULL) {
#ifdef sun
      fprintf(stderr, "cannot open %s: (%d)\n", filename, errno);
#else
      fprintf(stderr, "cannot open %s: %s\n", filename, strerror(errno));
#endif
      exit(1);
  }
  remain = size;

  while(remain > 0){
	  use =  (remain >  SECTOR_SIZE * NSECT - 1 ? NSECT*SECTOR_SIZE : remain);
	  use = ROUND_UP(use); /* Round up to nearest sector boundary */
	  memset(buffer, 0, use);
	  if (fread(buffer, 1, use, infile) == 0) {
	    fprintf(stderr,"cannot read from %s\n",filename);
	    exit(1);
	  }
	  xfwrite(buffer, 1, use, outfile);
	  last_extent_written += use/SECTOR_SIZE;
	  if((last_extent_written % 1000) < use/SECTOR_SIZE) fprintf(stderr,"%d..", last_extent_written);
	  remain -= use;
  };
  fclose(infile);
}

static void FDECL1(write_files, FILE *, outfile){
  struct deferred_write * dwpnt, *dwnext;
  dwpnt = dw_head;
  while(dwpnt){
	  if(dwpnt->table) {
		  xfwrite(dwpnt->table,  1, ROUND_UP(dwpnt->size), outfile);
		  last_extent_written += ROUND_UP(dwpnt->size) / SECTOR_SIZE;
		  table_size += dwpnt->size;
/*		  fprintf(stderr,"Size %d ", dwpnt->size); */
		  free(dwpnt->table);
	  } else {

#ifdef VMS
		  vms_write_one_file(dwpnt->name, dwpnt->size, outfile);
#else
		  write_one_file(dwpnt->name, dwpnt->size, outfile);
#endif
		  free(dwpnt->name);
	  };

		  dwnext = dwpnt;
		  dwpnt = dwpnt->next;
		  free(dwnext);
  };
}

#if 0
static void dump_filelist(){
  struct deferred_write * dwpnt;
  dwpnt = dw_head;
  while(dwpnt){
    fprintf(stderr, "File %s\n",dwpnt->name);
    dwpnt = dwpnt->next;
  };
  fprintf(stderr,"\n");
};
#endif

int FDECL2(compare_dirs, struct directory_entry **, r, struct directory_entry **, l) {
  char * rpnt, *lpnt;

  rpnt = (*r)->isorec.name;
  lpnt = (*l)->isorec.name;

  while(*rpnt && *lpnt) {
    if(*rpnt == ';' && *lpnt != ';') return -1;
    if(*rpnt != ';' && *lpnt == ';') return 1;
    if(*rpnt == ';' && *lpnt == ';') return 0;
    if(*rpnt < *lpnt) return -1;
    if(*rpnt > *lpnt) return 1;
    rpnt++;  lpnt++;
  }
  if(*rpnt) return 1;
  if(*lpnt) return -1;
  return 0;
}

void FDECL1(sort_directory, struct directory_entry **, sort_dir){
  int dcount = 0;
  int i, len;
  struct directory_entry * s_entry;
  struct directory_entry ** sortlist;

  s_entry = *sort_dir;
  while(s_entry){
    dcount++;
    s_entry = s_entry->next;
  };
  /* OK, now we know how many there are.  Build a vector for sorting. */

  sortlist =   (struct directory_entry **)
    e_malloc(sizeof(struct directory_entry *) * dcount);

  dcount = 0;
  s_entry = *sort_dir;
  while(s_entry){
    sortlist[dcount] = s_entry;
    len = s_entry->isorec.name_len[0];
    s_entry->isorec.name[len] = 0;
    dcount++;
    s_entry = s_entry->next;
  };

  qsort(sortlist, dcount, sizeof(struct directory_entry *),
  	(void *)compare_dirs);

  /* Now reassemble the linked list in the proper sorted order */
  for(i=0; i<dcount-1; i++)
    sortlist[i]->next = sortlist[i+1];

  sortlist[dcount-1]->next = NULL;
  *sort_dir = sortlist[0];

  free(sortlist);

}

void generate_root_record(){
  time_t ctime;

  time (&ctime);
  local = localtime(&ctime);

  root_record.length[0] = 1 + sizeof(struct iso_directory_record);
  root_record.ext_attr_length[0] = 0;
  set_733(root_record.extent, root->extent);
  set_733(root_record.size, ROUND_UP(root->size));
  iso9660_date(root_record.date, ctime);
  root_record.flags[0] = 2;
  root_record.file_unit_size[0] = 0;
  root_record.interleave[0] = 0;
  set_723(root_record.volume_sequence_number, 1);
  root_record.name_len[0] = 1;
}

static void FDECL1(assign_file_addresses, struct directory *, dpnt){
  struct directory * finddir;
  struct directory_entry * s_entry;
  struct file_hash *s_hash;
  struct deferred_write * dwpnt;
  char whole_path[1024];

  while (dpnt){
    s_entry = dpnt->contents;
    for(s_entry = dpnt->contents; s_entry; s_entry = s_entry->next){

      /* This saves some space if there are symlinks present */
      s_hash = find_hash(s_entry->dev, s_entry->inode);
      if(s_hash){
        if(verbose)
	  fprintf(stderr, "Cache hit for %s%s%s\n",s_entry->filedir->de_name,
		  SPATH_SEPARATOR, s_entry->name);
        set_733(s_entry->isorec.extent, s_hash->starting_block);
        set_733(s_entry->isorec.size, s_hash->size);
        continue;
      };
      if (strcmp(s_entry->name,".") && strcmp(s_entry->name,"..") &&
	  s_entry->isorec.flags[0] == 2){
	finddir = dpnt->subdir;
	while(1==1){
	  if(finddir->self == s_entry) break;
	  finddir = finddir->next;
	  if(!finddir) {fprintf(stderr,"Fatal goof\n"); exit(1);};
	};
	set_733(s_entry->isorec.extent, finddir->extent);
	s_entry->starting_block = finddir->extent;
	s_entry->size = ROUND_UP(finddir->size);
	total_dir_size += s_entry->size;
	add_hash(s_entry);
	set_733(s_entry->isorec.size, ROUND_UP(finddir->size));
      } else {
        if(strcmp(s_entry->name,".") ==0 || strcmp(s_entry->name,"..") == 0) {
	  if(strcmp(s_entry->name,".") == 0) {
	    set_733(s_entry->isorec.extent, dpnt->extent);

	    /* Set these so that the hash table has the correct information */
	    s_entry->starting_block = dpnt->extent;
	    s_entry->size = ROUND_UP(dpnt->size);

	    add_hash(s_entry);
	    s_entry->starting_block = dpnt->extent;
	    set_733(s_entry->isorec.size, ROUND_UP(dpnt->size));
	  } else {
	    if(dpnt == root) total_dir_size += root->size;
	    set_733(s_entry->isorec.extent, dpnt->parent->extent);

	    /* Set these so that the hash table has the correct information */
	    s_entry->starting_block = dpnt->parent->extent;
	    s_entry->size = ROUND_UP(dpnt->parent->size);

	    add_hash(s_entry);
	    s_entry->starting_block = dpnt->parent->extent;
	    set_733(s_entry->isorec.size, ROUND_UP(dpnt->parent->size));
	  };
        } else {
	  /* Now we schedule the file to be written.  This is all quite
	     straightforward, just make a list and assign extents as we go.
	     Once we get through writing all of the directories, we should
	     be ready write out these files */

	  if(s_entry->size) {
	    dwpnt = (struct deferred_write *)
	      e_malloc(sizeof(struct deferred_write));
	    if(dw_tail){
	      dw_tail->next = dwpnt;
	      dw_tail = dwpnt;
	    } else {
	      dw_head = dwpnt;
	      dw_tail = dwpnt;
	    };
 	    if(s_entry->inode  ==  TABLE_INODE) {
	      dwpnt->table = s_entry->table;
	      dwpnt->name = NULL;
	    } else {
	      dwpnt->table = NULL;
	      strcpy(whole_path, s_entry->whole_name);
	      dwpnt->name = strdup(whole_path);
	    };
	    dwpnt->next = NULL;
	    dwpnt->size = s_entry->size;
	    dwpnt->extent = last_extent;
	    set_733(s_entry->isorec.extent, last_extent);
	    s_entry->starting_block = last_extent;
	    add_hash(s_entry);
	    last_extent += ROUND_UP(s_entry->size) >> 11;
	    if(verbose)
	      fprintf(stderr,"%d %d %s\n", s_entry->starting_block,
		      last_extent-1, whole_path);
#ifdef DBG_ISO
	    if((ROUND_UP(s_entry->size) >> 11) > 500){
	      fprintf(stderr,"Warning: large file %s\n", whole_path);
	      fprintf(stderr,"Starting block is %d\n", s_entry->starting_block);
	      fprintf(stderr,"Reported file size is %d extents\n", s_entry->size);

	    };
#endif
	    if(last_extent > (700000000 >> 11)) {  /* More than 700Mb? Punt */
	      fprintf(stderr,"Extent overflow processing file %s\n", whole_path);
	      fprintf(stderr,"Starting block is %d\n", s_entry->starting_block);
	      fprintf(stderr,"Reported file size is %d extents\n", s_entry->size);
	      exit(1);
	    };
	  } else {
	    /*
	     * This is for zero-length files.  If we leave the extent 0,
	     * then we get screwed, because many readers simply drop files
	     * that have an extent of zero.  Thus we leave the size 0,
	     * and just assign the extent number.
	     */
	    set_733(s_entry->isorec.extent, last_extent);
	  }
	};
      };
    };
    if(dpnt->subdir) assign_file_addresses(dpnt->subdir);
    dpnt = dpnt->next;
  };
}

void FDECL2(generate_one_directory, struct directory *, dpnt, FILE *, outfile){
  unsigned int total_size, ce_size;
  char * directory_buffer;
  char * ce_buffer;
  unsigned int ce_address;
  struct directory_entry * s_entry, *s_entry_d;
  int new_reclen;
  unsigned int dir_index, ce_index;

  total_size = (dpnt->size + (SECTOR_SIZE - 1)) &  ~(SECTOR_SIZE - 1);
  directory_buffer = (char *) e_malloc(total_size);
  memset(directory_buffer, 0, total_size);
  dir_index = 0;

  ce_size = (dpnt->ce_bytes + (SECTOR_SIZE - 1)) &  ~(SECTOR_SIZE - 1);
  ce_buffer = NULL;

  if(ce_size) {
    ce_buffer = (char *) e_malloc(ce_size);
    memset(ce_buffer, 0, ce_size);

    ce_index = 0;

    /* Absolute byte address of CE entries for this directory */
    ce_address = last_extent_written + (total_size >> 11);
    ce_address = ce_address << 11;
  }

  s_entry = dpnt->contents;
  while(s_entry) {

    /* We do not allow directory entries to cross sector boundaries.  Simply
       pad, and then start the next entry at the next sector */
    new_reclen = s_entry->isorec.length[0];
    if ((dir_index & (SECTOR_SIZE - 1)) + new_reclen >= SECTOR_SIZE)
      dir_index = (dir_index + (SECTOR_SIZE - 1)) &
	~(SECTOR_SIZE - 1);

    memcpy(directory_buffer + dir_index, &s_entry->isorec,
	   sizeof(struct iso_directory_record) -
	   sizeof(s_entry->isorec.name) + s_entry->isorec.name_len[0]);
     dir_index += sizeof(struct iso_directory_record) -
      sizeof (s_entry->isorec.name)+ s_entry->isorec.name_len[0];

    /* Add the Rock Ridge attributes, if present */
    if(s_entry->rr_attr_size){
      if(dir_index & 1)
	directory_buffer[dir_index++] = 0;

      /* If the RR attributes were too long, then write the CE records,
	 as required. */
      if(s_entry->rr_attr_size != s_entry->total_rr_attr_size) {
	unsigned char * pnt;
	int len, nbytes;

	/* Go through the entire record and fix up the CE entries
	   so that the extent and offset are correct */

	pnt = s_entry->rr_attributes;
	len = s_entry->total_rr_attr_size;
	while(len > 3){
	  if(pnt[0] == 'C' && pnt[1] == 'E') {
	    nbytes = get_733(pnt+20);

	    if((ce_index & (SECTOR_SIZE - 1)) + nbytes >=
	       SECTOR_SIZE) ce_index = ROUND_UP(ce_index);

	    set_733(pnt+4, (ce_address + ce_index) >> 11);
	    set_733(pnt+12, (ce_address + ce_index) & (SECTOR_SIZE - 1));


	    /* Now store the block in the ce buffer */
	    memcpy(ce_buffer + ce_index,
		   pnt + pnt[2], nbytes);
	    ce_index += nbytes;
	    if(ce_index & 1) ce_index++;
	  };
	  len -= pnt[2];
	  pnt += pnt[2];
	};

      }

      rockridge_size += s_entry->total_rr_attr_size;
      memcpy(directory_buffer + dir_index, s_entry->rr_attributes,
	     s_entry->rr_attr_size);
      dir_index += s_entry->rr_attr_size;
    };
    if(dir_index & 1)
	    directory_buffer[dir_index++] = 0;

    s_entry_d = s_entry;
    s_entry = s_entry->next;

    if (s_entry_d->rr_attributes) free(s_entry_d->rr_attributes);
    free (s_entry_d->name);
    free (s_entry_d);
  };
  sort_dir = NULL;

  if(dpnt->size != dir_index)
    fprintf(stderr,"Unexpected directory length %d %d %s\n",dpnt->size,
	    dir_index, dpnt->de_name);
  xfwrite(directory_buffer, 1, total_size, outfile);
  last_extent_written += total_size >> 11;
  free(directory_buffer);

  if(ce_size){
    if(ce_index != dpnt->ce_bytes)
      fprintf(stderr,"Continuation entry record length mismatch (%d %d).\n",
	      ce_index, dpnt->ce_bytes);
    xfwrite(ce_buffer, 1, ce_size, outfile);
    last_extent_written += ce_size >> 11;
    free(ce_buffer);
  }

}

static void FDECL1(build_pathlist, struct directory *, node){
  struct directory * dpnt;

  dpnt = node;

  while (dpnt){
    pathlist[dpnt->path_index] = dpnt;
    if(dpnt->subdir) build_pathlist(dpnt->subdir);
    dpnt = dpnt->next;
  };
}

int FDECL2(compare_paths, const struct directory **, r, const struct directory **, l) {
  if((*r)->parent->path_index < (*l)->parent->path_index) return -1;
  if((*r)->parent->path_index > (*l)->parent->path_index) return 1;
  return strcmp((*r)->self->isorec.name, (*l)->self->isorec.name);

}

void generate_path_tables(){
  struct directory * dpnt;
  char * npnt, *npnt1;
  int namelen;
  struct directory_entry * de;
  int fix;
  int tablesize;
  int i,j;
  /* First allocate memory for the tables and initialize the memory */

  tablesize = path_blocks << 11;
  path_table_m = (char *) e_malloc(tablesize);
  path_table_l = (char *) e_malloc(tablesize);
  memset(path_table_l, 0, tablesize);
  memset(path_table_m, 0, tablesize);

  /* Now start filling in the path tables.  Start with root directory */
  path_table_index = 0;
  pathlist = (struct directory **) e_malloc(sizeof(struct directory *) * next_path_index);
  memset(pathlist, 0, sizeof(struct directory *) * next_path_index);
  build_pathlist(root);

  do{
    fix = 0;
    qsort(&pathlist[1], next_path_index-1, sizeof(struct directory *), (void *)compare_paths);

    for(j=1; j<next_path_index; j++)
      if(pathlist[j]->path_index != j){
	pathlist[j]->path_index = j;
	fix++;
      };
  } while(fix);

  for(j=1; j<next_path_index; j++){
    dpnt = pathlist[j];
    if(!dpnt){
      fprintf(stderr,"Entry %d not in path tables\n", j);
      exit(1);
    };
    npnt = dpnt->de_name;
    if(*npnt == 0 || dpnt == root) npnt = ".";  /* So the root comes out OK */
    npnt1 = strrchr(npnt, PATH_SEPARATOR);
    if(npnt1) npnt = npnt1 + 1;

    de = dpnt->self;
    if(!de) {fprintf(stderr,"Fatal goof\n"); exit(1);};


    namelen = de->isorec.name_len[0];

    path_table_l[path_table_index] = namelen;
    path_table_m[path_table_index] = namelen;
    path_table_index += 2;
    set_731(path_table_l + path_table_index, dpnt->extent);
    set_732(path_table_m + path_table_index, dpnt->extent);
    path_table_index += 4;
    set_721(path_table_l + path_table_index, dpnt->parent->path_index);
    set_722(path_table_m + path_table_index, dpnt->parent->path_index);
    path_table_index += 2;
    for(i =0; i<namelen; i++){
      path_table_l[path_table_index] = de->isorec.name[i];
      path_table_m[path_table_index] = de->isorec.name[i];
      path_table_index++;
    };
    if(path_table_index & 1) path_table_index++;  /* For odd lengths we pad */
  };
  free(pathlist);
  if(path_table_index != path_table_size)
    fprintf(stderr,"Path table lengths do not match %d %d\n",path_table_index,
	    path_table_size);
}

int FDECL1(iso_write, FILE *, outfile){
  char buffer[2048];
  char iso_time[17];
  int should_write;
  int i;

  assign_file_addresses(root);

  memset(buffer, 0, sizeof(buffer));

  /* This will break  in the year  2000, I supose, but there is no good way
     to get the top two digits of the year. */
  sprintf(iso_time, "%4.4d%2.2d%2.2d%2.2d%2.2d%2.2d00", 1900 + local->tm_year,
	  local->tm_mon+1, local->tm_mday,
	  local->tm_hour, local->tm_min, local->tm_sec);

  /* First, we output 16 sectors of all zero */

  for(i=0; i<16; i++)
    xfwrite(buffer, 1, sizeof(buffer), outfile);

  last_extent_written += 16;

  /* Next we write out the primary descriptor for the disc */
  memset(&vol_desc, 0, sizeof(vol_desc));
  vol_desc.type[0] = ISO_VD_PRIMARY;
  memcpy(vol_desc.id, ISO_STANDARD_ID, sizeof(ISO_STANDARD_ID));
  vol_desc.version[0] = 1;

  memset(vol_desc.system_id, ' ', sizeof(vol_desc.system_id));
  memcpy(vol_desc.system_id, system_id, strlen(system_id));

  memset(vol_desc.volume_id, ' ', sizeof(vol_desc.volume_id));
  memcpy(vol_desc.volume_id, volume_id, strlen(volume_id));

  should_write = last_extent;
  set_733(vol_desc.volume_space_size, last_extent);
  set_723(vol_desc.volume_set_size, 1);
  set_723(vol_desc.volume_sequence_number, 1);
  set_723(vol_desc.logical_block_size, 2048);

  /* The path tables are used by DOS based machines to cache directory
     locations */

  set_733(vol_desc.path_table_size, path_table_size);
  set_731(vol_desc.type_l_path_table, path_table[0]);
  set_731(vol_desc.opt_type_l_path_table, path_table[1]);
  set_732(vol_desc.type_m_path_table, path_table[2]);
  set_732(vol_desc.opt_type_m_path_table, path_table[3]);

  /* Now we copy the actual root directory record */

  memcpy(vol_desc.root_directory_record, &root_record,
	 sizeof(struct iso_directory_record) + 1);

  /* The rest is just fluff.  It looks nice to fill in many of these fields,
     though */

  FILL_SPACE(volume_set_id);
  if(volset_id)  memcpy(vol_desc.volume_set_id,  volset_id, strlen(volset_id));

  FILL_SPACE(publisher_id);
  if(publisher)  memcpy(vol_desc.publisher_id,  publisher, strlen(publisher));

  FILL_SPACE(preparer_id);
  if(preparer)  memcpy(vol_desc.preparer_id,  preparer, strlen(preparer));

  FILL_SPACE(application_id);
  if(appid) memcpy(vol_desc.application_id, appid, strlen(appid));

  FILL_SPACE(copyright_file_id);
  if(appid) memcpy(vol_desc.copyright_file_id, appid, strlen(appid));

  FILL_SPACE(abstract_file_id);
  if(appid) memcpy(vol_desc.abstract_file_id, appid, strlen(appid));

  FILL_SPACE(bibliographic_file_id);
  if(appid) memcpy(vol_desc.bibliographic_file_id, appid, strlen(appid));

  FILL_SPACE(creation_date);
  FILL_SPACE(modification_date);
  FILL_SPACE(expiration_date);
  FILL_SPACE(effective_date);
  vol_desc.file_structure_version[0] = 1;
  FILL_SPACE(application_data);

  memcpy(vol_desc.creation_date,  iso_time, 16);
  memcpy(vol_desc.modification_date,  iso_time, 16);
  memcpy(vol_desc.expiration_date, "0000000000000000", 16);
  memcpy(vol_desc.effective_date,  iso_time,  16);

  /* For some reason, Young Minds writes this twice.  Aw, what the heck */
  xfwrite(&vol_desc, 1, 2048, outfile);
  xfwrite(&vol_desc, 1, 2048, outfile);
  last_extent_written += 2;

  /* Now write the end volume descriptor.  Much simpler than the other one */
  memset(&vol_desc, 0, sizeof(vol_desc));
  vol_desc.type[0] = ISO_VD_END;
  memcpy(vol_desc.id, ISO_STANDARD_ID, sizeof(ISO_STANDARD_ID));
  vol_desc.version[0] = 1;
  xfwrite(&vol_desc, 1, 2048, outfile);
  xfwrite(&vol_desc, 1, 2048, outfile);
  last_extent_written += 2;

  /* Next we write the path tables */
  xfwrite(path_table_l, 1, path_blocks << 11, outfile);
  xfwrite(path_table_l, 1, path_blocks << 11, outfile);
  xfwrite(path_table_m, 1, path_blocks << 11, outfile);
  xfwrite(path_table_m, 1, path_blocks << 11, outfile);
  last_extent_written += 4*path_blocks;
  free(path_table_l);
  free(path_table_m);
  path_table_l = NULL;
  path_table_m = NULL;

  /* OK, all done with that crap.  Now write out the directories.
     This is where the fur starts to fly, because we need to keep track of
     each file as we find it and keep track of where we put it. */

#ifdef DBG_ISO
  fprintf(stderr,"Total directory extents being written = %d\n", last_extent);
#endif
#if 0
 generate_one_directory(root, outfile);
#endif
  generate_iso9660_directories(root, outfile);

  if(extension_record) {
    xfwrite(extension_record, 1, SECTOR_SIZE, outfile);
    last_extent_written++;
  }

  /* Now write all of the files that we need. */
  fprintf(stderr,"Total extents scheduled to be written = %d\n", last_extent);
  write_files(outfile);

  fprintf(stderr,"Total extents actually written = %d\n", last_extent_written);
  /* Hard links throw us off here */
  if(should_write != last_extent){
    fprintf(stderr,"Number of extents written not what was predicted.  Please fix.\n");
    fprintf(stderr,"Predicted = %d, written = %d\n", should_write, last_extent);
  };

  fprintf(stderr,"Total translation table size: %d\n", table_size);
  fprintf(stderr,"Total rockridge attributes bytes: %d\n", rockridge_size);
  fprintf(stderr,"Total directory bytes: %d\n", total_dir_size);
  fprintf(stderr,"Path table size(bytes): %d\n", path_table_size);
#ifdef DEBUG
  fprintf(stderr, "next extent, last_extent, last_extent_written %d %d %d\n",
	  next_extent, last_extent, last_extent_written);
#endif
  return 0;
}