开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 磁盘/存储 > SCSI/ASPI > 查看源码
write.c
资源名称：cdrecord-1.8.tar.gz　[点击查看]
上传用户：xiejiait
上传日期：2007-01-06
资源大小：881k
文件大小：40k
源码类别：

SCSI/ASPI

开发平台：

MultiPlatform

write.c：源码内容
  1. /*
  2.  * Program write.c - dump memory  structures to  file for iso9660 filesystem.
  4.    Written by Eric Youngdale (1993).
  6.    Copyright 1993 Yggdrasil Computing, Incorporated
  8.    This program is free software; you can redistribute it and/or modify
  9.    it under the terms of the GNU General Public License as published by
  10.    the Free Software Foundation; either version 2, or (at your option)
  11.    any later version.
  13.    This program is distributed in the hope that it will be useful,
  14.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.    GNU General Public License for more details.
  18.    You should have received a copy of the GNU General Public License
  19.    along with this program; if not, write to the Free Software
  20.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  22. static char rcsid[] ="$Id: write.c,v 1.21 1999/03/07 17:41:19 eric Exp $";
  24. #include "config.h"
  25. #include <string.h>
  26. #include <stdlib.h>
  27. #include "mkisofs.h"
  28. #include "iso9660.h"
  29. #include <time.h>
  30. #include <errno.h>
  32. #include <sys/types.h>
  33. #include <sys/stat.h>
  34. #include <fcntl.h>
  36. #ifdef HAVE_UNISTD_H
  37. #include <unistd.h>
  38. #endif
  39.  
  40. #ifdef USE_LIBSCHILY
  41. #include <standard.h>
  42. #endif
  44. #ifdef __SVR4
  45. extern char * strdup(const char *);
  46. #endif
  48. #ifdef VMS
  49. extern char * strdup(const char *);
  50. #endif
  53. /* Max number of sectors we will write at  one time */
  54. #define NSECT 16
  56. /* Counters for statistics */
  58. static int table_size       = 0;
  59. static int total_dir_size   = 0;
  60. static int rockridge_size   = 0;
  61. static struct directory ** pathlist;
  62. static int next_path_index  = 1;
  63. static int sort_goof;
  65. static int is_rr_dir        = 0;
  67. struct output_fragment * out_tail;
  68. struct output_fragment * out_list;
  70. struct iso_primary_descriptor vol_desc;
  72. static int root_gen __PR((void));
  73. static int generate_path_tables __PR((void));
  74. static int file_gen __PR((void));
  75. static int dirtree_dump __PR((void));
  77. /* Routines to actually write the disc.  We write sequentially so that
  78.    we could write a tape, or write the disc directly */
  81. #define FILL_SPACE(X)   memset(vol_desc.X, ' ', sizeof(vol_desc.X))
  83. void FDECL2(set_721, char *, pnt, unsigned int, i)
  84. {
  85.      pnt[0] = i & 0xff;
  86.      pnt[1] = (i >> 8) &  0xff;
  87. }
  89. void FDECL2(set_722, char *, pnt, unsigned int, i)
  90. {
  91.      pnt[0] = (i >> 8) &  0xff;
  92.      pnt[1] = i & 0xff;
  93. }
  95. void FDECL2(set_723, char *, pnt, unsigned int, i)
  96. {
  97.      pnt[3] = pnt[0] = i & 0xff;
  98.      pnt[2] = pnt[1] = (i >> 8) &  0xff;
  99. }
  101. void FDECL2(set_731, char *, pnt, unsigned int, i)
  102. {
  103.      pnt[0] = i & 0xff;
  104.      pnt[1] = (i >> 8) &  0xff;
  105.      pnt[2] = (i >> 16) &  0xff;
  106.      pnt[3] = (i >> 24) &  0xff;
  107. }
  109. void FDECL2(set_732, char *, pnt, unsigned int, i)
  110. {
  111.      pnt[3] = i & 0xff;
  112.      pnt[2] = (i >> 8) &  0xff;
  113.      pnt[1] = (i >> 16) &  0xff;
  114.      pnt[0] = (i >> 24) &  0xff;
  115. }
  117. int FDECL1(get_731, char *, p)
  118. {
  119.      return ((p[0] & 0xff)
  120.      | ((p[1] & 0xff) << 8)
  121.      | ((p[2] & 0xff) << 16)
  122.      | ((p[3] & 0xff) << 24));
  123. }
  125. int FDECL1(get_732, char *, p)
  126. {
  127.      return ((p[3] & 0xff)
  128.      | ((p[2] & 0xff) << 8)
  129.      | ((p[1] & 0xff) << 16)
  130.      | ((p[0] & 0xff) << 24));
  131. }
  133. int FDECL1(get_733, char *, p)
  134. {
  135.      return ((p[0] & 0xff)
  136.      | ((p[1] & 0xff) << 8)
  137.      | ((p[2] & 0xff) << 16)
  138.      | ((p[3] & 0xff) << 24));
  139. }
  141. void FDECL2(set_733, char *, pnt, unsigned int, i)
  142. {
  143.      pnt[7] = pnt[0] = i & 0xff;
  144.      pnt[6] = pnt[1] = (i >> 8) &  0xff;
  145.      pnt[5] = pnt[2] = (i >> 16) &  0xff;
  146.      pnt[4] = pnt[3] = (i >> 24) &  0xff;
  147. }
  149. void FDECL4(xfwrite, void *, buffer, int, count, int, size, FILE *, file)
  150. {
  151. /*
  152.  * This is a hack that could be made better. XXXIs this the only place?
  153.  * It is definitely needed on Operating Systems that do not
  154.  * allow to write files that are > 2GB.
  155.  * If the system is fast enough to be able to feed 1400 KB/s
  156.  * writing speed of a DVD-R drive, use stdout.
  157.  * If the system cannot do this reliable, you need to use this
  158.  * hacky option.
  159.  */
  160. static int idx = 0;
  161. if (split_output != 0 &&
  162.     (idx == 0 || ftell(file) >= (1024 * 1024 * 1024) )) {
  163. char nbuf[512];
  164. extern char *outfile;
  166. if (idx == 0)
  167. unlink(outfile);
  168. sprintf(nbuf, "%s_%02d", outfile, idx++);
  169. file = freopen(nbuf, "wb", file);
  170. if (file == NULL) {
  171. #ifdef USE_LIBSCHILY
  172. comerr("Cannot open '%s'.n", nbuf);
  173. #else
  174. fprintf(stderr, "Cannot open '%s'.n", nbuf);
  175. exit(1);
  176. #endif
  177. }
  179. }
  180.      while(count) 
  181.      {
  182.   int got = fwrite(buffer,size,count,file);
  184.   if(got<=0) 
  185.   {
  186. #ifdef USE_LIBSCHILY
  187.        comerr("cannot fwrite %d*%dn",size,count);
  188. #else
  189.        fprintf(stderr,"cannot fwrite %d*%dn",size,count);
  190.        exit(1);
  191. #endif
  192.   }
  193.   count-=got,*(char**)&buffer+=size*got;
  194.      }
  195. }
  197. struct deferred_write
  198. {
  199.   struct deferred_write * next;
  200.   char * table;
  201.   unsigned int   extent;
  202.   unsigned int   size;
  203.   char * name;
  204. };
  206. static struct deferred_write * dw_head = NULL, * dw_tail = NULL;
  208. unsigned int last_extent_written  =0;
  209. static int path_table_index;
  210. static time_t begun;
  212. /* We recursively walk through all of the directories and assign extent
  213.    numbers to them.  We have already assigned extent numbers to everything that
  214.    goes in front of them */
  216. static int FDECL1(assign_directory_addresses, struct directory *, node)
  217. {
  218.      int dir_size;
  219.      struct directory * dpnt;
  221.      dpnt = node;
  222.      
  223.      while (dpnt)
  224.      {
  225.   /* skip if it's hidden */
  226.   if(dpnt->dir_flags & INHIBIT_ISO9660_ENTRY) {
  227.      dpnt = dpnt->next;
  228.      continue;
  229.   }
  231.   /*
  232.    * If we already have an extent for this (i.e. it came from
  233.    * a multisession disc), then don't reassign a new extent.
  234.    */
  235.   dpnt->path_index = next_path_index++;
  236.   if( dpnt->extent == 0 )
  237.   {
  238.        dpnt->extent = last_extent;
  239.        dir_size = (dpnt->size + (SECTOR_SIZE - 1)) >> 11;
  240.        
  241.        last_extent += dir_size;
  242.        
  243.        /* 
  244. * Leave room for the CE entries for this directory.  Keep them
  245. * close to the reference directory so that access will be 
  246. * quick. 
  247. */
  248.        if(dpnt->ce_bytes)
  249.        {
  250.     last_extent += ROUND_UP(dpnt->ce_bytes) >> 11;
  251.        }
  252.   }
  254.   if(dpnt->subdir) 
  255.   {
  256.        assign_directory_addresses(dpnt->subdir);
  257.   }
  259.   dpnt = dpnt->next;
  260.      }
  261.      return 0;
  262. }
  264. static void FDECL3(write_one_file, char *, filename, 
  265.    unsigned int, size, FILE *, outfile)
  266. {
  267.      char   buffer[SECTOR_SIZE * NSECT];
  268.      FILE * infile;
  269.      int   remain;
  270.      int   use;
  273.      if ((infile = fopen(filename, "rb")) == NULL) 
  274.      {
  275. #ifdef USE_LIBSCHILY
  276.   comerr("cannot open '%s'n", filename);
  277. #else
  278. #if defined(sun) || defined(_AUX_SOURCE)
  279.   fprintf(stderr, "cannot open %s: (%d)n", filename, errno);
  280. #else
  281.   fprintf(stderr, "cannot open %s: %sn", filename, strerror(errno));
  282. #endif
  283.   exit(1);
  284. #endif
  285.      }
  286.      remain = size;
  288.      while(remain > 0)
  289.      {
  290.   use =  (remain >  SECTOR_SIZE * NSECT - 1 ? NSECT*SECTOR_SIZE : remain);
  291.   use = ROUND_UP(use); /* Round up to nearest sector boundary */
  292.   memset(buffer, 0, use);
  293.   if (fread(buffer, 1, use, infile) == 0) 
  294.   {
  295. #ifdef USE_LIBSCHILY
  296. comerr("cannot read from %sn",filename); 
  297. #else
  298. fprintf(stderr,"cannot read from %sn",filename); 
  299. exit(1);
  300. #endif
  301.   }
  302.   xfwrite(buffer, 1, use, outfile);
  303.   last_extent_written += use/SECTOR_SIZE;
  304. #if 0
  305.   if((last_extent_written % 1000) < use/SECTOR_SIZE) 
  306.   {
  307.        fprintf(stderr,"%d..", last_extent_written);
  308.   }
  309. #else
  310.   if((last_extent_written % (gui?500:5000)) < use/SECTOR_SIZE)
  311.   {
  312.        time_t now;
  313.        time_t the_end;
  314.        double frac;
  315.        
  316.        time(&now);
  317.        frac = last_extent_written / (double)last_extent;
  318.        the_end = begun + (now - begun) / frac;
  319.        fprintf(stderr, "%6.2f%% done, estimate finish %s",
  320.        frac * 100., ctime(&the_end));
  321. fflush(stderr);
  322.   }
  323. #endif
  324.   remain -= use;
  325.      }
  326.      fclose(infile);
  327. } /* write_one_file(... */
  329. static void FDECL1(write_files, FILE *, outfile)
  330. {
  331.      struct deferred_write * dwpnt, *dwnext;
  332.      dwpnt = dw_head;
  333.      while(dwpnt)
  334.      {
  335.   if(dwpnt->table) 
  336.   {
  337.        xfwrite(dwpnt->table,  1, ROUND_UP(dwpnt->size), outfile);
  338.        last_extent_written += ROUND_UP(dwpnt->size) / SECTOR_SIZE;
  339.        table_size += dwpnt->size;
  340. /*   fprintf(stderr,"Size %d ", dwpnt->size); */
  341.        free(dwpnt->table);
  342.        dwpnt->table = NULL;
  343.   } 
  344.   else 
  345.   {
  347. #ifdef VMS
  348.        vms_write_one_file(dwpnt->name, dwpnt->size, outfile);
  349. #else
  350.        write_one_file(dwpnt->name, dwpnt->size, outfile);
  351. #endif
  352.        free(dwpnt->name);
  353.        dwpnt->name = NULL;
  354.   }
  356.   dwnext = dwpnt;
  357.   dwpnt = dwpnt->next;
  358.   free(dwnext);
  359.   dwnext = NULL;
  360.      }
  361. } /* write_files(... */
  363. #if 0
  364. static void dump_filelist()
  365. {
  366.      struct deferred_write * dwpnt;
  367.      dwpnt = dw_head;
  368.      while(dwpnt)
  369.      {
  370.   fprintf(stderr, "File %sn",dwpnt->name);
  371.   dwpnt = dwpnt->next;
  372.      }
  373.      fprintf(stderr,"n");
  374. }
  375. #endif
  377. static int FDECL2(compare_dirs, const void *, rr, const void *, ll) 
  378. {
  379.      char * rpnt, *lpnt;
  380.      struct directory_entry ** r, **l;
  381.      
  382.      r = (struct directory_entry **) rr;
  383.      l = (struct directory_entry **) ll;
  384.      rpnt = (*r)->isorec.name;
  385.      lpnt = (*l)->isorec.name;
  387.      /*
  388.       * If the entries are the same, this is an error.
  389.       */
  390.      if( strcmp(rpnt, lpnt) == 0 )
  391.        {
  392. #ifdef USE_LIBSCHILY
  393.  errmsgno(EX_BAD, "Error: %s and %s have the same ISO9660 namen",
  394. (*r)->whole_name, (*l)->whole_name);
  395. #else
  396.  fprintf(stderr, "Error: %s and %s have the same ISO9660 namen",
  397. (*r)->whole_name, (*l)->whole_name);
  398. #endif
  399.  sort_goof++;
  400.        }
  402.      /* Check we don't have the same RR name */
  403.      if (use_RockRidge && !is_rr_dir) {
  404. /* entries *can* have the same RR name in the "rr_moved" directory
  405.    so skip checks if we're in reloc_dir */
  406. if (!(strcmp((*r)->name, (*l)->name))) {
  407. #ifdef USE_LIBSCHILY
  408.    errmsgno(EX_BAD, "Error: %s and %s have the same Rock Ridge namen",
  409. (*r)->whole_name, (*l)->whole_name);
  410. #else
  411.    fprintf (stderr, "Error: %s and %s have the same Rock Ridge namen",
  412. (*r)->whole_name, (*l)->whole_name);
  413. #endif
  414.    sort_goof++;
  415. }
  416.      }
  418.      /*
  419.       *  Put the '.' and '..' entries on the head of the sorted list.
  420.       *  For normal ASCII, this always happens to be the case, but out of
  421.       *  band characters cause this not to be the case sometimes.
  422.       *
  423.       * FIXME(eric) - these tests seem redundant, in taht the name is
  424.       * never assigned these values.  It will instead be 00 or 01,
  425.       * and thus should always be sorted correctly.   I need to figure
  426.       * out why I thought I needed this in the first place.
  427.       */
  428. #if 0
  429.      if( strcmp(rpnt, ".") == 0 ) return -1;
  430.      if( strcmp(lpnt, ".") == 0 ) return  1;
  432.      if( strcmp(rpnt, "..") == 0 ) return -1;
  433.      if( strcmp(lpnt, "..") == 0 ) return  1;
  434. #else
  435.      /*
  436.       * The code above is wrong (as explained in Eric's comment), leading to incorrect
  437.       * sort order iff the -L option ("allow leading dots") is in effect and a directory
  438.       * contains entries that start with a dot.
  439.       *
  440.       * (TF, Tue Dec 29 13:49:24 CET 1998)
  441.       */
  442.      if((*r)->isorec.name_len[0] == 1 && *rpnt == 0) return -1; /* '.' */
  443.      if((*l)->isorec.name_len[0] == 1 && *lpnt == 0) return 1;
  445.      if((*r)->isorec.name_len[0] == 1 && *rpnt == 1) return -1; /* '..' */
  446.      if((*l)->isorec.name_len[0] == 1 && *lpnt == 1) return 1;
  447. #endif
  449.      while(*rpnt && *lpnt) 
  450.      {
  451.   if(*rpnt == ';' && *lpnt != ';') return -1;
  452.   if(*rpnt != ';' && *lpnt == ';') return 1;
  453.   
  454.   if(*rpnt == ';' && *lpnt == ';') return 0;
  455.   
  456.   if(*rpnt == '.' && *lpnt != '.') return -1;
  457.   if(*rpnt != '.' && *lpnt == '.') return 1;
  458.   
  459.   if((unsigned char)*rpnt < (unsigned char)*lpnt) return -1;
  460.   if((unsigned char)*rpnt > (unsigned char)*lpnt) return 1;
  461.   rpnt++;  lpnt++;
  462.      }
  463.      if(*rpnt) return 1;
  464.      if(*lpnt) return -1;
  465.      return 0;
  466. }
  468. /* 
  469.  * Function: sort_directory
  470.  *
  471.  * Purpose: Sort the directory in the appropriate ISO9660
  472.  * order.
  473.  *
  474.  * Notes: Returns 0 if OK, returns > 0 if an error occurred.
  475.  */
  476. int FDECL2(sort_directory, struct directory_entry **, sort_dir, int, rr)
  477. {
  478.      int dcount = 0;
  479.      int xcount = 0;
  480.      int j;
  481.      int i, len;
  482.      struct directory_entry * s_entry;
  483.      struct directory_entry ** sortlist;
  484.      
  485.      /* need to keep a count of how many entries are hidden */
  486.      s_entry = *sort_dir;
  487.      while(s_entry)
  488.      {
  489.   if (s_entry->de_flags & INHIBIT_ISO9660_ENTRY)
  490.     xcount++;
  491.   dcount++;
  492.   s_entry = s_entry->next;
  493.      }
  495.      if( dcount == 0 )
  496.      {
  497.           return 0;
  498.      }
  500.      /*
  501.       * OK, now we know how many there are.  Build a vector for sorting. 
  502.       */
  503.      sortlist =   (struct directory_entry **) 
  504.   e_malloc(sizeof(struct directory_entry *) * dcount);
  506.      j = dcount - 1;
  507.      dcount = 0;
  508.      s_entry = *sort_dir;
  509.      while(s_entry)
  510.      {
  511. if(s_entry->de_flags & INHIBIT_ISO9660_ENTRY)
  512.  {
  513.   /* put any hidden entries at the end of the vector */
  514.   sortlist[j--] = s_entry;
  515.  }
  516. else
  517.  {
  518.   sortlist[dcount] = s_entry;
  519.   dcount++;
  520.  }
  521.  len = s_entry->isorec.name_len[0];
  522.  s_entry->isorec.name[len] = 0;
  523.  s_entry = s_entry->next;
  524.      }
  525.   
  526.      /*
  527.       * Each directory is required to contain at least . and ..
  528.       */
  529.      if( dcount < 2 )
  530.        {
  531. #ifdef USE_LIBSCHILY
  532.  errmsgno(EX_BAD, "Directory size too small (. or .. missing ???)n"); 
  533. #else
  534.  fprintf(stderr, "Directory size too small (. or .. missing ???)n"); 
  535. #endif
  536.  sort_goof = 1;
  537.  
  538.        }
  539.      else
  540.        {
  541.  /* only sort the non-hidden entries */
  542.  sort_goof = 0;
  543. is_rr_dir = rr;
  544. #ifdef __STDC__
  545.  qsort(sortlist, dcount, sizeof(struct directory_entry *), 
  546.        (int (*)(const void *, const void *))compare_dirs);
  547. #else
  548.  qsort(sortlist, dcount, sizeof(struct directory_entry *), 
  549.        compare_dirs);
  550. #endif
  551.  
  552.  /* 
  553.   * Now reassemble the linked list in the proper sorted order 
  554.   * We still need the hidden entries, as they may be used in the
  555.   * Joliet tree.
  556.   */
  557.  for(i=0; i<dcount+xcount-1; i++)
  558.    {
  559.      sortlist[i]->next = sortlist[i+1];
  560.    }
  561.  
  562.  sortlist[dcount+xcount-1]->next = NULL;
  563.  *sort_dir = sortlist[0];
  564.        }
  566.      free(sortlist);
  567.      sortlist = NULL;
  568.      return sort_goof;
  569. }
  571. static int root_gen()
  572. {
  573.      init_fstatbuf();
  574.      
  575.      root_record.length[0] = 1 + offsetof(struct iso_directory_record, name[0]);
  576.      root_record.ext_attr_length[0] = 0;
  577.      set_733((char *) root_record.extent, root->extent);
  578.      set_733((char *) root_record.size, ROUND_UP(root->size));
  579.      iso9660_date(root_record.date, root_statbuf.st_mtime);
  580.      root_record.flags[0] = 2;
  581.      root_record.file_unit_size[0] = 0;
  582.      root_record.interleave[0] = 0;
  583.      set_723(root_record.volume_sequence_number, volume_sequence_number);
  584.      root_record.name_len[0] = 1;
  585.      return 0;
  586. }
  588. static void FDECL1(assign_file_addresses, struct directory *, dpnt)
  589. {
  590.      struct directory * finddir;
  591.      struct directory_entry * s_entry;
  592.      struct file_hash *s_hash;
  593.      struct deferred_write * dwpnt;
  594.      char whole_path[1024];
  596.      while (dpnt)
  597.      {
  598.   s_entry = dpnt->contents;
  599.   for(s_entry = dpnt->contents; s_entry; s_entry = s_entry->next)
  600.   {
  601.        /*
  602. * If we already have an  extent for this entry,
  603. * then don't assign a new one.  It must have come
  604. * from a previous session on the disc.  Note that
  605. * we don't end up scheduling the thing for writing
  606. * either.
  607. */
  608.        if( isonum_733((unsigned char *) s_entry->isorec.extent) != 0 )
  609.        {
  610.     continue;
  611.        }
  612.        
  613.        /* 
  614. * This saves some space if there are symlinks present 
  615. */
  616.        s_hash = find_hash(s_entry->dev, s_entry->inode);
  617.        if(s_hash)
  618.        {
  619.     if(verbose > 2)
  620.     {
  621.  fprintf(stderr, "Cache hit for %s%s%sn",s_entry->filedir->de_name, 
  622.  SPATH_SEPARATOR, s_entry->name);
  623.     }
  624.     set_733((char *) s_entry->isorec.extent, s_hash->starting_block);
  625.     set_733((char *) s_entry->isorec.size, s_hash->size);
  626.     continue;
  627.        }
  629.        /*
  630. * If this is for a directory that is not a . or a .. entry, 
  631. * then look up the information for the entry.  We have already
  632. * assigned extents for directories, so we just need to
  633. * fill in the blanks here.
  634. */
  635.        if (strcmp(s_entry->name,".") != 0 && strcmp(s_entry->name,"..") != 0 &&
  636.    s_entry->isorec.flags[0] == 2)
  637.        {
  638.     finddir = dpnt->subdir;
  639.     while(1==1)
  640.     {
  641.  if(finddir->self == s_entry) break;
  642.  finddir = finddir->next;
  643.  if(!finddir) 
  644.  {
  645. #ifdef USE_LIBSCHILY
  646.       comerrno(EX_BAD,
  647. "Fatal goof - could not find dir entry for '%s'n",
  648. s_entry->name);
  649. #else
  650.       fprintf(stderr,
  651. "Fatal goof - could not find dir entry for '%s'n",
  652. s_entry->name);
  653.       exit(1);
  654. #endif
  655.  }
  656.     }
  657.     set_733((char *) s_entry->isorec.extent, finddir->extent);
  658.     s_entry->starting_block = finddir->extent;
  659.     s_entry->size = ROUND_UP(finddir->size);
  660.     total_dir_size += s_entry->size;
  661.     add_hash(s_entry);
  662.     set_733((char *) s_entry->isorec.size, ROUND_UP(finddir->size));
  663.     continue;
  664.        }
  667.        /*
  668. * If this is . or .., then look up the relevant info from the
  669. * tables.
  670. */
  671.        if(strcmp(s_entry->name,".") == 0) 
  672.        {
  673.     set_733((char *) s_entry->isorec.extent, dpnt->extent);
  674.     
  675.     /* 
  676.      * Set these so that the hash table has the
  677.      * correct information
  678.      */
  679.     s_entry->starting_block = dpnt->extent;
  680.     s_entry->size = ROUND_UP(dpnt->size);
  681.     
  682.     add_hash(s_entry);
  683.     s_entry->starting_block = dpnt->extent;
  684.     set_733((char *) s_entry->isorec.size, ROUND_UP(dpnt->size));
  685.     continue;
  686.        }
  688.        if(strcmp(s_entry->name,"..") == 0) 
  689.        {
  690.     if(dpnt == root)
  691.     { 
  692.  total_dir_size += root->size;
  693.     }
  694.     set_733((char *) s_entry->isorec.extent, dpnt->parent->extent);
  695.     
  696.     /* 
  697.      * Set these so that the hash table has the
  698.      * correct information
  699.      */
  700.     s_entry->starting_block = dpnt->parent->extent;
  701.     s_entry->size = ROUND_UP(dpnt->parent->size);
  702.     
  703.     add_hash(s_entry);
  704.     s_entry->starting_block = dpnt->parent->extent;
  705.     set_733((char *) s_entry->isorec.size, ROUND_UP(dpnt->parent->size));
  706.     continue;
  707.        }
  709.        /* 
  710. * Some ordinary non-directory file.  Just schedule the
  711. * file to be written.  This is all quite
  712. * straightforward, just make a list and assign extents
  713. * as we go.  Once we get through writing all of the
  714. * directories, we should be ready write out these
  715. * files
  716. */
  717.        if(s_entry->size) 
  718.        {
  719.     dwpnt = (struct deferred_write *) 
  720.  e_malloc(sizeof(struct deferred_write));
  721.     if(dw_tail)
  722.     {
  723.  dw_tail->next = dwpnt;
  724.  dw_tail = dwpnt;
  725.     } 
  726.     else 
  727.     {
  728.  dw_head = dwpnt;
  729.  dw_tail = dwpnt;
  730.     }
  731.     if(s_entry->inode  ==  TABLE_INODE) 
  732.     {
  733.  dwpnt->table = s_entry->table;
  734.  dwpnt->name = NULL;
  735.  sprintf(whole_path,"%s%s%s",
  736.  s_entry->filedir->whole_name,
  737.  SPATH_SEPARATOR, trans_tbl);
  738.     } 
  739.     else 
  740.     {
  741.  dwpnt->table = NULL;
  742.  strcpy(whole_path, s_entry->whole_name);
  743.  dwpnt->name = strdup(whole_path);
  744.     }
  745.     dwpnt->next = NULL;
  746.     dwpnt->size = s_entry->size;
  747.     dwpnt->extent = last_extent;
  748.     set_733((char *) s_entry->isorec.extent, last_extent);
  749.     s_entry->starting_block = last_extent;
  750.     add_hash(s_entry);
  751.     last_extent += ROUND_UP(s_entry->size) >> 11;
  752.     if(verbose > 2)
  753.     {
  754.  fprintf(stderr,"%d %d %sn", s_entry->starting_block,
  755.  last_extent-1, whole_path);
  756.     }
  757. #ifdef DBG_ISO
  758.     if((ROUND_UP(s_entry->size) >> 11) > 500)
  759.     {
  760.  fprintf(stderr,"Warning: large file %sn", whole_path);
  761.  fprintf(stderr,"Starting block is %dn", s_entry->starting_block);
  762.  fprintf(stderr,"Reported file size is %d extentsn", s_entry->size);
  763.  
  764.     }
  765. #endif
  766. #ifdef NOT_NEEDED /* Never use this code if you like to create a DVD */
  768.     if(last_extent > (800000000 >> 11)) 
  769.     { 
  770.  /*
  771.   * More than 800Mb? Punt 
  772.   */
  773.  fprintf(stderr,"Extent overflow processing file %sn", whole_path);
  774.  fprintf(stderr,"Starting block is %dn", s_entry->starting_block);
  775.  fprintf(stderr,"Reported file size is %d extentsn", s_entry->size);
  776.  exit(1);
  777.     }
  778. #endif
  779.     continue;
  780.        }
  782.        /*
  783. * This is for zero-length files.  If we leave the extent 0,
  784. * then we get screwed, because many readers simply drop files
  785. * that have an extent of zero.  Thus we leave the size 0,
  786. * and just assign the extent number.
  787. */
  788.        set_733((char *) s_entry->isorec.extent, last_extent);
  789.   }
  790.   if(dpnt->subdir) 
  791.   {
  792.        assign_file_addresses(dpnt->subdir);
  793.   }
  794.   dpnt = dpnt->next;
  795.      }
  796. } /* assign_file_addresses(... */
  798. static void FDECL1(free_one_directory, struct directory *, dpnt)
  799. {
  800.      struct directory_entry * s_entry;
  801.      struct directory_entry * s_entry_d;
  802.      
  803.      s_entry = dpnt->contents;
  804.      while(s_entry) 
  805.      {
  806.  s_entry_d = s_entry;
  807.  s_entry = s_entry->next;
  808.  
  809.  if (s_entry_d->rr_attributes) {
  810.      free(s_entry_d->rr_attributes);
  811.      s_entry_d->rr_attributes = NULL;
  812.  }
  813.  if( s_entry_d->name != NULL )
  814.  {
  815.      free (s_entry_d->name);
  816.      s_entry_d->name = NULL;
  817.  }
  818.  if( s_entry_d->whole_name != NULL )
  819.  {
  820.      free (s_entry_d->whole_name);
  821.      s_entry_d->whole_name = NULL;
  822.  }
  823.  free (s_entry_d);
  824.  s_entry_d = NULL;
  825.      }
  826.      dpnt->contents = NULL;
  827. } /* free_one_directory(... */
  829. static void FDECL1(free_directories, struct directory *, dpnt)
  830. {
  831.   while (dpnt)
  832.     {
  833.       free_one_directory(dpnt);
  834.       if(dpnt->subdir) free_directories(dpnt->subdir);
  835.       dpnt = dpnt->next;
  836.     }
  837. }
  839. void FDECL2(generate_one_directory, struct directory *, dpnt, FILE *, outfile)
  840. {
  841.      unsigned int   ce_address = 0;
  842.      char * ce_buffer;
  843.      unsigned int   ce_index = 0;
  844.      unsigned int   ce_size;
  845.      unsigned int   dir_index;
  846.      char * directory_buffer;
  847.      int   new_reclen;
  848.      struct directory_entry * s_entry;
  849.      struct directory_entry * s_entry_d;
  850.      unsigned int   total_size;
  851.      
  852.      total_size = (dpnt->size + (SECTOR_SIZE - 1)) &  ~(SECTOR_SIZE - 1);
  853.      directory_buffer = (char *) e_malloc(total_size);
  854.      memset(directory_buffer, 0, total_size);
  855.      dir_index = 0;
  856.      
  857.      ce_size = (dpnt->ce_bytes + (SECTOR_SIZE - 1)) &  ~(SECTOR_SIZE - 1);
  858.      ce_buffer = NULL;
  859.      
  860.      if(ce_size > 0) 
  861.      {
  862.   ce_buffer = (char *) e_malloc(ce_size);
  863.   memset(ce_buffer, 0, ce_size);
  864.   
  865.   ce_index = 0;
  866.   
  867.   /*
  868.    * Absolute byte address of CE entries for this directory 
  869.    */
  870.   ce_address = last_extent_written + (total_size >> 11);
  871.   ce_address = ce_address << 11;
  872.      }
  873.      
  874.      s_entry = dpnt->contents;
  875.      while(s_entry) 
  876.      {
  877.   /* skip if it's hidden */
  878.   if(s_entry->de_flags & INHIBIT_ISO9660_ENTRY) {
  879.     s_entry = s_entry->next;
  880.     continue;
  881.   }
  883.   /* 
  884.    * We do not allow directory entries to cross sector boundaries.  
  885.    * Simply pad, and then start the next entry at the next sector 
  886.    */
  887.   new_reclen = s_entry->isorec.length[0];
  888.   if( (dir_index & (SECTOR_SIZE - 1)) + new_reclen >= SECTOR_SIZE )
  889.   {
  890.        dir_index = (dir_index + (SECTOR_SIZE - 1)) & 
  891.     ~(SECTOR_SIZE - 1);
  892.   }
  894.   memcpy(directory_buffer + dir_index, &s_entry->isorec, 
  895.  offsetof(struct iso_directory_record, name[0]) +
  896.  s_entry->isorec.name_len[0]);
  897.   dir_index += offsetof(struct iso_directory_record, name[0]) +
  898.        s_entry->isorec.name_len[0];
  900.   /*
  901.    * Add the Rock Ridge attributes, if present 
  902.    */
  903.   if(s_entry->rr_attr_size)
  904.   {
  905.        if(dir_index & 1)
  906.        {
  907.     directory_buffer[dir_index++] = 0;
  908.        }
  910.        /* 
  911. * If the RR attributes were too long, then write the
  912. * CE records, as required.
  913. */
  914.        if(s_entry->rr_attr_size != s_entry->total_rr_attr_size) 
  915.        {
  916.     unsigned char * pnt;
  917.     int len, nbytes;
  918.     
  919.     /* 
  920.      * Go through the entire record and fix up the CE entries
  921.      * so that the extent and offset are correct 
  922.      */
  923.     
  924.     pnt = s_entry->rr_attributes;
  925.     len = s_entry->total_rr_attr_size;
  926.     while(len > 3)
  927.     {
  928. #ifdef DEBUG
  929.  if (ce_size <= 0)
  930.  {
  931.       fprintf(stderr,"Warning: ce_index(%d) && ce_address(%d) not initializedn",
  932.       ce_index, ce_address);
  933.  }
  934. #endif
  935.  
  936.  if(pnt[0] == 'C' && pnt[1] == 'E') 
  937.  {
  938.       nbytes = get_733( (char *) pnt+20);
  939.       
  940.       if((ce_index & (SECTOR_SIZE - 1)) + nbytes >=
  941.  SECTOR_SIZE) 
  942.       {
  943.    ce_index = ROUND_UP(ce_index);
  944.       }
  945.       
  946.       set_733( (char *) pnt+4, 
  947.        (ce_address + ce_index) >> 11);
  948.       set_733( (char *) pnt+12, 
  949.        (ce_address + ce_index) & (SECTOR_SIZE - 1));
  950.       
  951.       
  952.       /* 
  953.        * Now store the block in the ce buffer 
  954.        */
  955.       memcpy(ce_buffer + ce_index, 
  956.      pnt + pnt[2], nbytes);
  957.       ce_index += nbytes;
  958.       if(ce_index & 1) 
  959.       {
  960.    ce_index++;
  961.       }
  962.  }
  963.  len -= pnt[2];
  964.  pnt += pnt[2];
  965.     }
  966.     
  967.        }
  969.        rockridge_size += s_entry->total_rr_attr_size;
  970.        memcpy(directory_buffer + dir_index, s_entry->rr_attributes, 
  971.       s_entry->rr_attr_size);
  972.        dir_index += s_entry->rr_attr_size;
  973.   }
  974.   if(dir_index & 1)
  975.   {
  976.        directory_buffer[dir_index++] = 0;
  977.   }
  978.   
  979.   s_entry_d = s_entry;
  980.   s_entry = s_entry->next;
  981.   
  982.   /*
  983.    * Joliet doesn't use the Rock Ridge attributes, so we free it here.
  984.    */
  985.   if (s_entry_d->rr_attributes) 
  986.     {
  987.       free(s_entry_d->rr_attributes);
  988.       s_entry_d->rr_attributes = NULL;
  989.     }
  990.      }
  992.      if(dpnt->size != dir_index)
  993.      {
  994. #ifdef USE_LIBSCHILY
  995.   errmsgno(EX_BAD,"Unexpected directory length %d expected: %d '%s'n",dpnt->size,
  996.     dir_index, dpnt->de_name);
  997. #else
  998.   fprintf(stderr,"Unexpected directory length %d expected: %d '%s'n",dpnt->size,
  999.     dir_index, dpnt->de_name);
  1000. #endif
  1001.      }
  1003.      xfwrite(directory_buffer, 1, total_size, outfile);
  1004.      last_extent_written += total_size >> 11;
  1005.      free(directory_buffer);
  1006.      directory_buffer = NULL;
  1008.      if(ce_size > 0)
  1009.      {
  1010.   if(ce_index != dpnt->ce_bytes)
  1011.   {
  1012. #ifdef USE_LIBSCHILY
  1013.        errmsgno(EX_BAD,"Continuation entry record length mismatch %d expected: %d.n",
  1014.        ce_index, dpnt->ce_bytes);
  1015. #else
  1016.        fprintf(stderr,"Continuation entry record length mismatch %d expected: %d.n",
  1017.        ce_index, dpnt->ce_bytes);
  1018. #endif
  1019.   }
  1020.   xfwrite(ce_buffer, 1, ce_size, outfile);
  1021.   last_extent_written += ce_size >> 11;
  1022.   free(ce_buffer);
  1023.   ce_buffer = NULL;
  1024.      }
  1025.      
  1026. } /* generate_one_directory(... */
  1028. static 
  1029. void FDECL1(build_pathlist, struct directory *, node)
  1030. {
  1031.      struct directory * dpnt;
  1032.      
  1033.      dpnt = node;
  1034.      
  1035.      while (dpnt)
  1036.      {
  1037. /* skip if it's hidden */
  1038. if( (dpnt->dir_flags & INHIBIT_ISO9660_ENTRY) == 0 )
  1039.   pathlist[dpnt->path_index] = dpnt;
  1041. if(dpnt->subdir) build_pathlist(dpnt->subdir);
  1042. dpnt = dpnt->next;
  1043.      }
  1044. } /* build_pathlist(... */
  1046. static int FDECL2(compare_paths, void const *, r, void const *, l) 
  1047. {
  1048.   struct directory const *ll = *(struct directory * const *)l;
  1049.   struct directory const *rr = *(struct directory * const *)r;
  1051.   if (rr->parent->path_index < ll->parent->path_index)
  1052.   {
  1053.        return -1;
  1054.   }
  1056.   if (rr->parent->path_index > ll->parent->path_index) 
  1057.   {
  1058.        return 1;
  1059.   }
  1061.   return strcmp(rr->self->isorec.name, ll->self->isorec.name);
  1062.   
  1063. } /* compare_paths(... */
  1065. static int generate_path_tables()
  1066. {
  1067.   struct directory_entry * de = NULL;
  1068.   struct directory  * dpnt;
  1069.   int    fix;
  1070.   int    i;
  1071.   int    j;
  1072.   int    namelen;
  1073.   char  * npnt;
  1074.   char  * npnt1;
  1075.   int    tablesize;
  1077.   /*
  1078.    * First allocate memory for the tables and initialize the memory 
  1079.    */
  1080.   tablesize = path_blocks << 11;
  1081.   path_table_m = (char *) e_malloc(tablesize);
  1082.   path_table_l = (char *) e_malloc(tablesize);
  1083.   memset(path_table_l, 0, tablesize);
  1084.   memset(path_table_m, 0, tablesize);
  1086.   /*
  1087.    * Now start filling in the path tables.  Start with root directory 
  1088.    */
  1089.   if( next_path_index > 0xffff )
  1090.   {
  1091. #ifdef USE_LIBSCHILY
  1092.       comerrno(EX_BAD, "Unable to generate sane path tables - too many directories (%d)n",
  1093.       next_path_index);
  1094. #else
  1095.       fprintf(stderr, "Unable to generate sane path tables - too many directories (%d)n",
  1096.       next_path_index);
  1097.       exit(1);
  1098. #endif
  1099.   }
  1101.   path_table_index = 0;
  1102.   pathlist = (struct directory **) e_malloc(sizeof(struct directory *) 
  1103.     * next_path_index);
  1104.   memset(pathlist, 0, sizeof(struct directory *) * next_path_index);
  1105.   build_pathlist(root);
  1107.   do
  1108.   {
  1109.        fix = 0;
  1110. #ifdef __STDC__
  1111.        qsort(&pathlist[1], next_path_index-1, sizeof(struct directory *), 
  1112.      (int (*)(const void *, const void *))compare_paths);
  1113. #else
  1114.        qsort(&pathlist[1], next_path_index-1, sizeof(struct directory *), 
  1115.      compare_paths);
  1116. #endif
  1118.        for(j=1; j<next_path_index; j++)
  1119.        {
  1120.     if(pathlist[j]->path_index != j)
  1121.     {
  1122.  pathlist[j]->path_index = j;
  1123.  fix++;
  1124.     }
  1125.        }
  1126.   } while(fix);
  1128.   for(j=1; j<next_path_index; j++)
  1129.   {
  1130.        dpnt = pathlist[j];
  1131.        if(!dpnt)
  1132.        {
  1133. #ifdef USE_LIBSCHILY
  1134.     comerrno(EX_BAD, "Entry %d not in path tablesn", j);
  1135. #else
  1136.     fprintf(stderr,"Entry %d not in path tablesn", j);
  1137.     exit(1);
  1138. #endif
  1139.        }
  1140.        npnt = dpnt->de_name;
  1141.        
  1142.        /* 
  1143. * So the root comes out OK 
  1144. */
  1145.        if( (*npnt == 0) || (dpnt == root) ) 
  1146.        {
  1147.     npnt = ".";  
  1148.        }
  1149.        npnt1 = strrchr(npnt, PATH_SEPARATOR);
  1150.        if(npnt1) 
  1151.        { 
  1152.     npnt = npnt1 + 1;
  1153.        }
  1154.        
  1155.        de = dpnt->self;
  1156.        if(!de) 
  1157.        {
  1158. #ifdef USE_LIBSCHILY
  1159.     comerrno(EX_BAD, "Fatal ISO9660 goof - directory has amnesian"); 
  1160. #else
  1161.     fprintf(stderr,"Fatal ISO9660 goof - directory has amnesian"); 
  1162.     exit(1);
  1163. #endif
  1164.        }
  1165.        
  1166.        
  1167.        namelen = de->isorec.name_len[0];
  1168.        
  1169.        path_table_l[path_table_index] = namelen;
  1170.        path_table_m[path_table_index] = namelen;
  1171.        path_table_index += 2;
  1172.        
  1173.        set_731(path_table_l + path_table_index, dpnt->extent); 
  1174.        set_732(path_table_m + path_table_index, dpnt->extent); 
  1175.        path_table_index += 4;
  1176.        
  1177.        set_721(path_table_l + path_table_index, 
  1178.        dpnt->parent->path_index); 
  1179.        set_722(path_table_m + path_table_index, 
  1180.        dpnt->parent->path_index); 
  1181.        path_table_index += 2;
  1182.        
  1183.        for(i =0; i<namelen; i++)
  1184.        {
  1185.     path_table_l[path_table_index] = de->isorec.name[i];
  1186.     path_table_m[path_table_index] = de->isorec.name[i];
  1187.     path_table_index++;
  1188.        }
  1189.        if(path_table_index & 1) 
  1190.        {
  1191.     path_table_index++;  /* For odd lengths we pad */
  1192.        }
  1193.   }
  1194.   
  1195.   free(pathlist);
  1196.   pathlist = NULL;
  1197.   if(path_table_index != path_table_size)
  1198.   {
  1199. #ifdef USE_LIBSCHILY
  1200.        errmsgno(EX_BAD,"Path table lengths do not match %d expected: %dn",
  1201.        path_table_index,
  1202.        path_table_size);
  1203. #else
  1204.        fprintf(stderr,"Path table lengths do not match %d expected: %dn",
  1205.        path_table_index,
  1206.        path_table_size);
  1207. #endif
  1208.   }
  1209.   return 0;
  1210. } /* generate_path_tables(... */
  1212. void
  1213. FDECL3(memcpy_max, char *, to, char *, from, int, max)
  1214. {
  1215.   int n = strlen(from);
  1216.   if (n > max)
  1217.   {
  1218.        n = max;
  1219.   }
  1220.   memcpy(to, from, n);
  1222. } /* memcpy_max(... */
  1224. void FDECL1(outputlist_insert, struct output_fragment *, frag)
  1225. {
  1226.   if( out_tail == NULL )
  1227.     {
  1228.       out_list = out_tail = frag;
  1229.     }
  1230.   else
  1231.     {
  1232.       out_tail->of_next = frag;
  1233.       out_tail = frag;
  1234.     }
  1235. }
  1237. static int FDECL1(file_write, FILE *, outfile)
  1238. {
  1239.   int should_write;
  1241.   /*
  1242.    * OK, all done with that crap.  Now write out the directories.
  1243.    * This is where the fur starts to fly, because we need to keep track of
  1244.    * each file as we find it and keep track of where we put it. 
  1245.    */
  1247.   should_write = last_extent - session_start;
  1249.   if( verbose > 2 )
  1250.     {
  1251. #ifdef DBG_ISO
  1252.       fprintf(stderr,"Total directory extents being written = %dn", last_extent);
  1253. #endif
  1254.       
  1255.       fprintf(stderr,"Total extents scheduled to be written = %dn", 
  1256.       last_extent - session_start);
  1257.     }
  1259.   /* 
  1260.    * Now write all of the files that we need. 
  1261.    */
  1262.   write_files(outfile);
  1263.   
  1264.   /*
  1265.    * The rest is just fluff.
  1266.    */
  1267.   if( verbose == 0 )
  1268.     {
  1269.       return 0;
  1270.     }
  1272.   fprintf(stderr,"Total extents actually written = %dn", 
  1273.   last_extent_written - session_start);
  1275.   /* 
  1276.    * Hard links throw us off here 
  1277.    */
  1278.   if(should_write != last_extent - session_start)
  1279.     {
  1280.       fprintf(stderr,"Number of extents written not what was predicted.  Please fix.n");
  1281.       fprintf(stderr,"Predicted = %d, written = %dn", should_write, last_extent);
  1282.     }
  1284.   fprintf(stderr,"Total translation table size: %dn", table_size);
  1285.   fprintf(stderr,"Total rockridge attributes bytes: %dn", rockridge_size);
  1286.   fprintf(stderr,"Total directory bytes: %dn", total_dir_size);
  1287.   fprintf(stderr,"Path table size(bytes): %dn", path_table_size);
  1289. #ifdef DEBUG
  1290.   fprintf(stderr, "next extent, last_extent, last_extent_written %d %d %dn",
  1291.   next_extent, last_extent, last_extent_written);
  1292. #endif
  1294.   return 0;
  1296. } /* iso_write(... */
  1298. /*
  1299.  * Function to write the PVD for the disc.
  1300.  */
  1301. static int FDECL1(pvd_write, FILE *, outfile)
  1302. {
  1303.   char iso_time[17];
  1304.   int should_write;
  1305.   struct tm local;
  1306.   struct tm gmt;
  1309.   time(&begun);
  1311.   local = *localtime(&begun);
  1312.   gmt   = *gmtime(&begun);
  1314.   /*
  1315.    * There was a comment here about breaking in the year 2000.  That's
  1316.    * not true, in 2000 tm_year == 100, so 1900+tm_year == 2000.
  1317.    */
  1318.   sprintf(iso_time, "%4.4d%2.2d%2.2d%2.2d%2.2d%2.2d00", 1900 + local.tm_year,
  1319.   local.tm_mon+1, local.tm_mday,
  1320.   local.tm_hour, local.tm_min, local.tm_sec);
  1322.   local.tm_min -= gmt.tm_min;
  1323.   local.tm_hour -= gmt.tm_hour;
  1324.   local.tm_yday -= gmt.tm_yday;
  1325.   iso_time[16] = (local.tm_min + 60*(local.tm_hour + 24*local.tm_yday)) / 15;
  1327.   /*
  1328.    * Next we write out the primary descriptor for the disc 
  1329.    */
  1330.   memset(&vol_desc, 0, sizeof(vol_desc));
  1331.   vol_desc.type[0] = ISO_VD_PRIMARY;
  1332.   memcpy(vol_desc.id, ISO_STANDARD_ID, sizeof(ISO_STANDARD_ID));
  1333.   vol_desc.version[0] = 1;
  1334.   
  1335.   memset(vol_desc.system_id, ' ', sizeof(vol_desc.system_id));
  1336.   memcpy_max(vol_desc.system_id, system_id, strlen(system_id));
  1337.   
  1338.   memset(vol_desc.volume_id, ' ', sizeof(vol_desc.volume_id));
  1339.   memcpy_max(vol_desc.volume_id, volume_id, strlen(volume_id));
  1340.   
  1341.   should_write = last_extent - session_start;
  1342.   set_733((char *) vol_desc.volume_space_size, should_write);
  1343.   set_723(vol_desc.volume_set_size, volume_set_size);
  1344.   set_723(vol_desc.volume_sequence_number, volume_sequence_number);
  1345.   set_723(vol_desc.logical_block_size, 2048);
  1346.   
  1347.   /*
  1348.    * The path tables are used by DOS based machines to cache directory
  1349.    * locations 
  1350.    */
  1352.   set_733((char *) vol_desc.path_table_size, path_table_size);
  1353.   set_731(vol_desc.type_l_path_table, path_table[0]);
  1354.   set_731(vol_desc.opt_type_l_path_table, path_table[1]);
  1355.   set_732(vol_desc.type_m_path_table, path_table[2]);
  1356.   set_732(vol_desc.opt_type_m_path_table, path_table[3]);
  1358.   /*
  1359.    * Now we copy the actual root directory record 
  1360.    */
  1361.   memcpy(vol_desc.root_directory_record, &root_record, 
  1362.  offsetof(struct iso_directory_record, name[0]) + 1);
  1364.   /*
  1365.    * The rest is just fluff.  It looks nice to fill in many of these fields,
  1366.    * though.
  1367.    */
  1368.   FILL_SPACE(volume_set_id);
  1369.   if(volset_id)  memcpy_max(vol_desc.volume_set_id,  volset_id, strlen(volset_id));
  1371.   FILL_SPACE(publisher_id);
  1372.   if(publisher)  memcpy_max(vol_desc.publisher_id,  publisher, strlen(publisher));
  1374.   FILL_SPACE(preparer_id);
  1375.   if(preparer)  memcpy_max(vol_desc.preparer_id,  preparer, strlen(preparer));
  1377.   FILL_SPACE(application_id);
  1378.   if(appid) memcpy_max(vol_desc.application_id, appid, strlen(appid));
  1380.   FILL_SPACE(copyright_file_id);
  1381.   if(copyright) memcpy_max(vol_desc.copyright_file_id, copyright, 
  1382.        strlen(copyright));
  1384.   FILL_SPACE(abstract_file_id);
  1385.   if(abstract) memcpy_max(vol_desc.abstract_file_id, abstract, 
  1386.   strlen(abstract));
  1388.   FILL_SPACE(bibliographic_file_id);
  1389.   if(biblio) memcpy_max(vol_desc.bibliographic_file_id, biblio, 
  1390.        strlen(biblio));
  1392.   FILL_SPACE(creation_date);
  1393.   FILL_SPACE(modification_date);
  1394.   FILL_SPACE(expiration_date);
  1395.   FILL_SPACE(effective_date);
  1396.   vol_desc.file_structure_version[0] = 1;
  1397.   FILL_SPACE(application_data);
  1399.   memcpy(vol_desc.creation_date,  iso_time, 17);
  1400.   memcpy(vol_desc.modification_date,  iso_time, 17);
  1401.   memcpy(vol_desc.expiration_date, "0000000000000000", 17);
  1402.   memcpy(vol_desc.effective_date,  iso_time,  17);
  1404.   /*
  1405.    * if not a bootable cd do it the old way 
  1406.    */
  1407.   xfwrite(&vol_desc, 1, 2048, outfile);
  1408.   last_extent_written++;
  1409.   return 0;
  1410. }
  1412. /*
  1413.  * Function to write the EVD for the disc.
  1414.  */
  1415. static int FDECL1(evd_write, FILE *, outfile)
  1416. {
  1417.   struct iso_primary_descriptor evol_desc;
  1419.   /*
  1420.    * Now write the end volume descriptor.  Much simpler than the other one 
  1421.    */
  1422.   memset(&evol_desc, 0, sizeof(evol_desc));
  1423.   evol_desc.type[0] = (unsigned char)ISO_VD_END;
  1424.   memcpy(evol_desc.id, ISO_STANDARD_ID, sizeof(ISO_STANDARD_ID));
  1425.   evol_desc.version[0] = 1;
  1426.   xfwrite(&evol_desc, 1, 2048, outfile);
  1427.   last_extent_written += 1;
  1428.   return 0;
  1429. }
  1431. /*
  1432.  * Function to write the EVD for the disc.
  1433.  */
  1434. static int FDECL1(pathtab_write, FILE *, outfile)
  1435. {
  1436.   /*
  1437.    * Next we write the path tables 
  1438.    */
  1439.   xfwrite(path_table_l, 1, path_blocks << 11, outfile);
  1440.   xfwrite(path_table_m, 1, path_blocks << 11, outfile);
  1441.   last_extent_written += 2*path_blocks;
  1442.   free(path_table_l);
  1443.   free(path_table_m);
  1444.   path_table_l = NULL;
  1445.   path_table_m = NULL;
  1446.   return 0;
  1447. }
  1449. static int FDECL1(exten_write, FILE *, outfile)
  1450. {
  1451.   xfwrite(extension_record, 1, SECTOR_SIZE, outfile);
  1452.   last_extent_written++;
  1453.   return 0;
  1454. }
  1456. /*
  1457.  * Functions to describe padding block at the start of the disc.
  1458.  */
  1459. int FDECL1(oneblock_size, int, starting_extent)
  1460. {
  1461.   last_extent++;
  1462.   return 0;
  1463. }
  1465. /*
  1466.  * Functions to describe padding block at the start of the disc.
  1467.  */
  1468. static int FDECL1(pathtab_size, int, starting_extent)
  1469. {
  1470.   path_table[0] = starting_extent;
  1472.   path_table[1] = 0;
  1473.   path_table[2] = path_table[0] + path_blocks;
  1474.   path_table[3] = 0;
  1475.   last_extent += 2*path_blocks;
  1476.   return 0;
  1477. }
  1479. static int FDECL1(padblock_size, int, starting_extent)
  1480. {
  1481.   last_extent= session_start + 16;
  1482.   return 0;
  1483. }
  1485. static int file_gen()
  1486. {
  1487.   assign_file_addresses(root);
  1488.   return 0;
  1489. }
  1491. static int dirtree_dump()
  1492. {
  1493.   if (verbose > 2)
  1494.   {
  1495.       dump_tree(root);
  1496.   }
  1497.   return 0;
  1498. }
  1500. static int FDECL1(dirtree_fixup, int, starting_extent)
  1501. {
  1502.   if (use_RockRidge && reloc_dir)
  1503.   finish_cl_pl_entries();
  1505.   if (use_RockRidge )
  1506.   update_nlink_field(root);
  1507.   return 0;
  1508. }
  1510. static int FDECL1(dirtree_size, int, starting_extent)
  1511. {
  1512.   assign_directory_addresses(root);
  1513.   return 0;
  1514. }
  1516. static int FDECL1(ext_size, int, starting_extent)
  1517. {
  1518.   extern int extension_record_size;
  1519.   struct directory_entry * s_entry;
  1520.   extension_record_extent = starting_extent;
  1521.   s_entry = root->contents;
  1522.   set_733((char *) s_entry->rr_attributes + s_entry->rr_attr_size - 24,
  1523.   extension_record_extent);
  1524.   set_733((char *) s_entry->rr_attributes + s_entry->rr_attr_size - 8,
  1525.   extension_record_size);
  1526.   last_extent++;
  1527.   return 0;
  1528. }
  1530. static int FDECL1(dirtree_write, FILE *, outfile)
  1531. {
  1532.   generate_iso9660_directories(root, outfile);
  1533.   return 0;
  1534. }
  1536. static int FDECL1(dirtree_cleanup, FILE *, outfile)
  1537. {
  1538.   free_directories(root);
  1539.   return 0;
  1540. }
  1542. static int FDECL1(padblock_write, FILE *, outfile)
  1543. {
  1544.   char buffer[2048];
  1545.   int i;
  1546.   int npad;
  1548.   memset(buffer, 0, sizeof(buffer));
  1550.   npad = session_start + 16 - last_extent_written;
  1552.   for(i=0; i<npad; i++)
  1553.     {
  1554.       xfwrite(buffer, 1, sizeof(buffer), outfile);
  1555.     }
  1557.   last_extent_written += npad;
  1558.   return 0;
  1559. }
  1561. struct output_fragment padblock_desc  = {NULL, padblock_size, NULL,     padblock_write};
  1562. struct output_fragment voldesc_desc   = {NULL, oneblock_size, root_gen, pvd_write};
  1563. struct output_fragment end_vol       = {NULL, oneblock_size, NULL,     evd_write};
  1564. struct output_fragment pathtable_desc = {NULL, pathtab_size,  generate_path_tables,     pathtab_write};
  1565. struct output_fragment dirtree_desc   = {NULL, dirtree_size,  NULL,     dirtree_write};
  1566. struct output_fragment dirtree_clean  = {NULL, dirtree_fixup, dirtree_dump,     dirtree_cleanup};
  1567. struct output_fragment extension_desc = {NULL, ext_size,      NULL,     exten_write};
  1568. struct output_fragment files_desc     = {NULL, NULL,          file_gen, file_write};