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

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

SCSI/ASPI

开发平台：

MultiPlatform

rock.c：源码内容
  1. /*
  2.  * File rock.c - generate RRIP  records for iso9660 filesystems.
  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: rock.c,v 1.8 1999/03/02 03:41:26 eric Exp $";
  24. #include "config.h"
  25. #include <stdlib.h>
  26. #include <unixstd.h>
  27. #include <device.h>
  29. #include "mkisofs.h"
  30. #include "iso9660.h"
  31. #include <string.h>
  33. #ifdef DOESNT_WORK
  35. #ifdef NON_UNIXFS
  36. /*
  37.  * This is the dead code
  38.  */
  39. #define S_ISLNK(m) (0)
  40. #else
  41. #ifndef S_ISLNK
  42. #define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
  43. #endif
  44. #endif
  46. #else
  47. /*
  48.  * This is the new code
  49.  */
  50. #include <statdefs.h>
  51. #endif
  53. #ifdef USE_LIBSCHILY
  54. #include <standard.h>
  55. #endif
  57. #define SU_VERSION 1
  59. #define SL_ROOT    8
  60. #define SL_PARENT  4
  61. #define SL_CURRENT 2
  62. #define SL_CONTINUE 1
  64. #define CE_SIZE 28
  65. #define CL_SIZE 12
  66. #define ER_SIZE 8
  67. #define NM_SIZE 5
  68. #define PL_SIZE 12
  69. #define PN_SIZE 20
  70. #define PX_SIZE 36
  71. #define RE_SIZE 4
  72. #define SL_SIZE 20
  73. #define ZZ_SIZE 15
  74. #ifdef __QNX__
  75. #define TF_SIZE (5 + 4 * 7)
  76. #else
  77. #define TF_SIZE (5 + 3 * 7)
  78. #endif
  80. /* If we need to store this number of bytes, make sure we
  81.    do not box ourselves in so that we do not have room for
  82.    a CE entry for the continuation record */
  84. #define MAYBE_ADD_CE_ENTRY(BYTES) 
  85.     (BYTES + CE_SIZE + currlen + (ipnt - recstart) > reclimit ? 1 : 0) 
  87. /*
  88.  * Buffer to build RR attributes
  89.  */
  91. static unsigned char Rock[16384];
  92. static unsigned char symlink_buff[256];
  93. static int ipnt = 0;
  94. static int recstart = 0;
  95. static int currlen = 0;
  96. static int mainrec = 0;
  97. static int reclimit;
  99. static void add_CE_entry __PR((void));
  101. static void add_CE_entry(){
  102.           if(recstart)
  103.     set_733((char*)Rock + recstart - 8, ipnt + 28 - recstart);
  104.   Rock[ipnt++] ='C';
  105.   Rock[ipnt++] ='E';
  106.   Rock[ipnt++] = CE_SIZE;
  107.   Rock[ipnt++] = SU_VERSION;
  108.   set_733((char*)Rock + ipnt, 0);
  109.   ipnt += 8;
  110.   set_733((char*)Rock + ipnt, 0);
  111.   ipnt += 8;
  112.   set_733((char*)Rock + ipnt, 0);
  113.   ipnt += 8;
  114.   recstart = ipnt;
  115.   currlen = 0;
  116.   if(!mainrec) mainrec = ipnt;
  117.   reclimit = SECTOR_SIZE - 8; /* Limit to one sector */
  118. }
  120. #ifdef __STDC__
  121. int generate_rock_ridge_attributes (char * whole_name, char * name,
  122.     struct directory_entry * s_entry,
  123.     struct stat * statbuf,
  124.     struct stat * lstatbuf,
  125.     int deep_opt)
  126. #else
  127. int generate_rock_ridge_attributes (whole_name, name,
  128.     s_entry,
  129.     statbuf,
  130.     lstatbuf,
  131.     deep_opt)
  132. char * whole_name; char * name; struct directory_entry * s_entry;
  133. struct stat * statbuf, *lstatbuf;
  134. int deep_opt;
  135. #endif
  136. {
  137.   int flagpos, flagval;
  138.   int need_ce;
  140.   statbuf = statbuf;        /* this shuts up unreferenced compiler warnings */
  141.   mainrec = recstart = ipnt = 0;
  142.   reclimit = 0xf8;
  144.   /* no need to fill in the RR stuff if we won't see the file */
  145.   if (s_entry->de_flags & INHIBIT_ISO9660_ENTRY)
  146.     return 0;
  148.   /* Obtain the amount of space that is currently used for the directory
  149.      record.  Assume max for name, since name conflicts may cause us
  150.      to rename the file later on */
  151.   currlen = sizeof(s_entry->isorec);
  153.   /* Identify that we are using the SUSP protocol */
  154.   if(deep_opt & NEED_SP){
  155.   Rock[ipnt++] ='S';
  156.   Rock[ipnt++] ='P';
  157.   Rock[ipnt++] = 7;
  158.   Rock[ipnt++] = SU_VERSION;
  159.   Rock[ipnt++] = 0xbe;
  160.   Rock[ipnt++] = 0xef;
  161.   Rock[ipnt++] = 0;
  162.   };
  164.   /* First build the posix name field */
  165.   Rock[ipnt++] ='R';
  166.   Rock[ipnt++] ='R';
  167.   Rock[ipnt++] = 5;
  168.   Rock[ipnt++] = SU_VERSION;
  169.   flagpos = ipnt;
  170.   flagval = 0;
  171.   Rock[ipnt++] = 0;   /* We go back and fix this later */
  173.   if(strcmp(name,".")  && strcmp(name,"..")){
  174.     char * npnt;
  175.     int remain, use;
  177.     remain = strlen(name);
  178.     npnt = name;
  180.     while(remain){
  181.           use = remain;
  182.   need_ce = 0;
  183.   /* Can we fit this SUSP and a CE entry? */
  184.   if(use + currlen + CE_SIZE + (ipnt - recstart) > reclimit) {
  185.     use = reclimit - currlen - CE_SIZE - (ipnt - recstart);
  186.     need_ce++;
  187.   }
  189.   /* Only room for 256 per SUSP field */
  190.   if(use > 0xf8) use = 0xf8;
  192.   /* First build the posix name field */
  193.   Rock[ipnt++] ='N';
  194.   Rock[ipnt++] ='M';
  195.   Rock[ipnt++] = NM_SIZE + use;
  196.   Rock[ipnt++] = SU_VERSION;
  197.   Rock[ipnt++] = (remain != use ? 1 : 0);
  198.   flagval |= (1<<3);
  199.   strncpy((char *)&Rock[ipnt], npnt, use);
  200.   npnt += use;
  201.   ipnt += use;
  202.   remain -= use;
  203.   if(remain && need_ce) add_CE_entry();
  204. };
  205.   };
  207.   /*
  208.    * Add the posix modes 
  209.    */
  210.   if(MAYBE_ADD_CE_ENTRY(PX_SIZE)) add_CE_entry();
  211.   Rock[ipnt++] ='P';
  212.   Rock[ipnt++] ='X';
  213.   Rock[ipnt++] = PX_SIZE;
  214.   Rock[ipnt++] = SU_VERSION;  
  215.   flagval |= (1<<0);
  216.   set_733((char*)Rock + ipnt, lstatbuf->st_mode);
  217.   ipnt += 8;
  218.   set_733((char*)Rock + ipnt, lstatbuf->st_nlink);
  219.   ipnt += 8;
  220.   set_733((char*)Rock + ipnt, lstatbuf->st_uid);
  221.   ipnt += 8;
  222.   set_733((char*)Rock + ipnt, lstatbuf->st_gid);
  223.   ipnt += 8;
  225.   /*
  226.    * Check for special devices
  227.    */
  228. #if defined(S_IFCHR) || defined(S_IFBLK)
  230. #ifndef NON_UNIXFS
  231.   if (S_ISCHR(lstatbuf->st_mode) || S_ISBLK(lstatbuf->st_mode)) {
  232.     if(MAYBE_ADD_CE_ENTRY(PN_SIZE)) add_CE_entry();
  233.     Rock[ipnt++] ='P';
  234.     Rock[ipnt++] ='N';
  235.     Rock[ipnt++] = PN_SIZE;
  236.     Rock[ipnt++] = SU_VERSION;  
  237.     flagval |= (1<<1);
  238. #if 1
  239.     /*
  240.      * This is the new and only code which uses <device.h>
  241.      */
  242.     set_733((char*)Rock + ipnt, major(lstatbuf->st_rdev ));
  243.     ipnt += 8;
  244.     set_733((char*)Rock + ipnt, minor(lstatbuf->st_rdev));
  245.     ipnt += 8;
  246. #else
  247.     /*
  248.      * If we don't have sysmacros.h, then we have to guess as to how
  249.      * best to pick apart the device number for major/minor.
  250.      * Note: this may very well be wrong for many systems, so
  251.      * it is always best to use the major/minor macros if the
  252.      * system supports it.
  253.      */
  254.     if(sizeof(dev_t) <= 2) {
  255.         set_733((char*)Rock + ipnt, (lstatbuf->st_rdev >> 8));
  256.         ipnt += 8;
  257.         set_733((char*)Rock + ipnt, lstatbuf->st_rdev & 0xff);
  258.         ipnt += 8;
  259.     }
  260.     else if(sizeof(dev_t) <= 4) {
  261.         set_733((char*)Rock + ipnt, (lstatbuf->st_rdev >> 8) >> 8);
  262.         ipnt += 8;
  263.         set_733((char*)Rock + ipnt, lstatbuf->st_rdev & 0xffff);
  264.         ipnt += 8;
  265.     }
  266.     else {
  267.         set_733((char*)Rock + ipnt, (lstatbuf->st_rdev >> 16) >> 16);
  268.         ipnt += 8;
  269.         set_733((char*)Rock + ipnt, lstatbuf->st_rdev);
  270.         ipnt += 8;
  271.     }
  272. #endif
  273.   };
  274. #endif
  275. #endif /* defined(S_IFCHR) || defined(S_IFBLK) */
  277.   /*
  278.    * Check for and symbolic links.  VMS does not have these.
  279.    */
  280. #ifdef S_IFLNK
  281.   if (S_ISLNK(lstatbuf->st_mode)){
  282.     int lenpos, lenval, j0, j1;
  283.     int nchar;
  284.     unsigned char * cpnt, *cpnt1;
  285. #ifdef HAVE_READLINK
  286.     nchar = readlink(whole_name, (char *)symlink_buff, sizeof(symlink_buff));
  287. #else
  288.     nchar = -1;
  289. #endif /* HAVE_READLINK */
  290.     symlink_buff[nchar < 0 ? 0 : nchar] = 0;
  291.     nchar = strlen((char *) symlink_buff);
  292.     set_733(s_entry->isorec.size, 0);
  293.     cpnt = &symlink_buff[0];
  294.     flagval |= (1<<2);
  296.     if (! split_SL_field) 
  297.       {
  298. int sl_bytes = 0;
  299. for (cpnt1 = cpnt; *cpnt1 != ''; cpnt1++) 
  300.   {
  301.     if (*cpnt1 == '/') 
  302.       {
  303. sl_bytes += 4;
  304.       } 
  305.     else 
  306.       {
  307. sl_bytes += 1;
  308.       }
  309.   }
  310. if (sl_bytes > 250) 
  311.   {
  312.     /* 
  313.      * the symbolic link won't fit into one SL System Use Field
  314.      * print an error message and continue with splited one 
  315.      */
  316.     fprintf(stderr,"symbolic link ``%s'' to long for one SL System Use Field, splitting", cpnt);
  317.   }
  318.        if(MAYBE_ADD_CE_ENTRY(SL_SIZE + sl_bytes)) add_CE_entry();
  319.      }
  321.     while(nchar){
  322.       if(MAYBE_ADD_CE_ENTRY(SL_SIZE)) add_CE_entry();
  323.       Rock[ipnt++] ='S';
  324.       Rock[ipnt++] ='L';
  325.       lenpos = ipnt;
  326.       Rock[ipnt++] = SL_SIZE;
  327.       Rock[ipnt++] = SU_VERSION;  
  328.       Rock[ipnt++] = 0; /* Flags */
  329.       lenval = 5;
  330.       while(*cpnt){
  331. cpnt1 = (unsigned char *) strchr((char *) cpnt, '/');
  332. if(cpnt1) {
  333.   nchar--;
  334.   *cpnt1 = 0;
  335. };
  337. /* We treat certain components in a special way.  */
  338. if(cpnt[0] == '.' && cpnt[1] == '.' && cpnt[2] == 0){
  339.   if(MAYBE_ADD_CE_ENTRY(2)) add_CE_entry();
  340.   Rock[ipnt++] = SL_PARENT;
  341.   Rock[ipnt++] = 0;  /* length is zero */
  342.   lenval += 2;
  343.   nchar -= 2;
  344. } else if(cpnt[0] == '.' && cpnt[1] == 0){
  345.   if(MAYBE_ADD_CE_ENTRY(2)) add_CE_entry();
  346.   Rock[ipnt++] = SL_CURRENT;
  347.   Rock[ipnt++] = 0;  /* length is zero */
  348.   lenval += 2;
  349.   nchar -= 1;
  350. } else if(cpnt[0] == 0){
  351.   if(MAYBE_ADD_CE_ENTRY(2)) add_CE_entry();
  352.   Rock[ipnt++] = SL_ROOT;
  353.   Rock[ipnt++] = 0;  /* length is zero */
  354.   lenval += 2;
  355. } else {
  356.   /* If we do not have enough room for a component, start
  357.      a new continuations segment now */
  358.          if(split_SL_component ? MAYBE_ADD_CE_ENTRY(6) :
  359.                                  MAYBE_ADD_CE_ENTRY(6 + strlen ((char *) cpnt))) 
  360.    {
  361.      add_CE_entry();
  362.      if(cpnt1)
  363.        {
  364.  *cpnt1 = '/';
  365.  nchar++;
  366.  cpnt1 = NULL; /* A kluge so that we can restart properly */
  367.        }
  368.      break;
  369.    }
  370.   j0 = strlen((char *) cpnt);
  371.   while(j0) {
  372.     j1 = j0;
  373.     if(j1 > 0xf8) j1 = 0xf8;
  374.     need_ce = 0;
  375.     if(j1 + currlen + CE_SIZE + (ipnt - recstart) > reclimit) {
  376.       j1 = reclimit - currlen - CE_SIZE - (ipnt - recstart);
  377.       need_ce++;
  378.     }
  379.     Rock[ipnt++] = (j1 != j0 ? SL_CONTINUE : 0);
  380.     Rock[ipnt++] = j1;
  381.     strncpy((char *) Rock + ipnt, (char *) cpnt, j1);
  382.     ipnt += j1;
  383.     lenval += j1 + 2;
  384.     cpnt += j1;
  385.     nchar -= j1;  /* Number we processed this time */
  386.     j0 -= j1;
  387.     if(need_ce) {
  388.       add_CE_entry();
  389.       if(cpnt1) {
  390. *cpnt1 = '/';
  391.                 nchar++;
  392. cpnt1 = NULL; /* A kluge so that we can restart properly */
  393.       }
  394.       break;
  395.     }
  396.   }
  397. };
  398. if(cpnt1) {
  399.   cpnt = cpnt1 + 1;
  400. } else
  401.   break;
  402.       }
  403.       Rock[lenpos] = lenval;
  404.       if(nchar) Rock[lenpos + 2] = SL_CONTINUE; /* We need another SL entry */
  405.     } /* while nchar */
  406.   } /* Is a symbolic link */
  407. #endif /* S_IFLNK */
  409.   /* 
  410.    * Add in the Rock Ridge TF time field
  411.    */
  412.   if(MAYBE_ADD_CE_ENTRY(TF_SIZE)) add_CE_entry();
  413.   Rock[ipnt++] ='T';
  414.   Rock[ipnt++] ='F';
  415.   Rock[ipnt++] = TF_SIZE;
  416.   Rock[ipnt++] = SU_VERSION;
  417. #ifdef __QNX__
  418.   Rock[ipnt++] = 0x0f;
  419. #else
  420.   Rock[ipnt++] = 0x0e;
  421. #endif
  422.   flagval |= (1<<7);
  423. #ifdef __QNX__
  424.   iso9660_date((char *) &Rock[ipnt], lstatbuf->st_ftime);
  425.   ipnt += 7;
  426. #endif
  427.   iso9660_date((char *) &Rock[ipnt], lstatbuf->st_mtime);
  428.   ipnt += 7;
  429.   iso9660_date((char *) &Rock[ipnt], lstatbuf->st_atime);
  430.   ipnt += 7;
  431.   iso9660_date((char *) &Rock[ipnt], lstatbuf->st_ctime);
  432.   ipnt += 7;
  434.   /* 
  435.    * Add in the Rock Ridge RE time field
  436.    */
  437.   if(deep_opt & NEED_RE){
  438.           if(MAYBE_ADD_CE_ENTRY(RE_SIZE)) add_CE_entry();
  439.   Rock[ipnt++] ='R';
  440.   Rock[ipnt++] ='E';
  441.   Rock[ipnt++] = RE_SIZE;
  442.   Rock[ipnt++] = SU_VERSION;
  443.   flagval |= (1<<6);
  444.   };
  445.   /* 
  446.    * Add in the Rock Ridge PL record, if required.
  447.    */
  448.   if(deep_opt & NEED_PL){
  449.           if(MAYBE_ADD_CE_ENTRY(PL_SIZE)) add_CE_entry();
  450.   Rock[ipnt++] ='P';
  451.   Rock[ipnt++] ='L';
  452.   Rock[ipnt++] = PL_SIZE;
  453.   Rock[ipnt++] = SU_VERSION;
  454.   set_733((char*)Rock + ipnt, 0);
  455.   ipnt += 8;
  456.   flagval |= (1<<5);
  457.   };
  459.   /* 
  460.    * Add in the Rock Ridge CL field, if required.
  461.    */
  462.   if(deep_opt & NEED_CL){
  463.           if(MAYBE_ADD_CE_ENTRY(CL_SIZE)) add_CE_entry();
  464.   Rock[ipnt++] ='C';
  465.   Rock[ipnt++] ='L';
  466.   Rock[ipnt++] = CL_SIZE;
  467.   Rock[ipnt++] = SU_VERSION;
  468.   set_733((char*)Rock + ipnt, 0);
  469.   ipnt += 8;
  470.   flagval |= (1<<4);
  471.   };
  473. #ifndef VMS
  474.   /* If transparent compression was requested, fill in the correct
  475.      field for this file */
  476.   if(transparent_compression && 
  477.      S_ISREG(lstatbuf->st_mode) &&
  478.      strlen(name) > 3 &&
  479.      strcmp(name + strlen(name) - 3,".gZ") == 0){
  480.     FILE * zipfile;
  481.     char * checkname;
  482.     unsigned int file_size;
  483.     unsigned char header[8];
  484.     int OK_flag;
  486.     /* First open file and verify that the correct algorithm was used */
  487.     file_size = 0;
  488.     OK_flag = 1;
  490.     zipfile = fopen(whole_name, "rb");
  491.     fread(header, 1, sizeof(header), zipfile);
  493.     /* Check some magic numbers from gzip. */
  494.     if(header[0] != 0x1f || header[1] != 0x8b || header[2] != 8) OK_flag = 0;
  495.     /* Make sure file was blocksized. */
  496.     if(((header[3] & 0x40) == 0)) OK_flag = 0;
  497.     /* OK, now go to the end of the file and get some more info */
  498.     if(OK_flag){
  499.       int status;
  500.       status = (long)lseek(fileno(zipfile), (off_t)(-8), SEEK_END);
  501.       if(status == -1) OK_flag = 0;
  502.     }
  503.     if(OK_flag){
  504.       if(read(fileno(zipfile), (char*)header, sizeof(header)) != sizeof(header))
  505. OK_flag = 0;
  506.       else {
  507. int blocksize;
  508. blocksize = (header[3] << 8) | header[2];
  509. file_size = ((unsigned int)header[7] << 24) | 
  510.     ((unsigned int)header[6] << 16) | 
  511.     ((unsigned int)header[5] << 8)  | header[4];
  512. #if 0
  513. fprintf(stderr,"Blocksize = %d %dn", blocksize, file_size);
  514. #endif
  515. if(blocksize != SECTOR_SIZE) OK_flag = 0;
  516.       }
  517.     }
  518.     fclose(zipfile);
  520.     checkname = strdup(whole_name);
  521.     checkname[strlen(whole_name)-3] = 0;
  522.     zipfile = fopen(checkname, "rb");
  523.     if(zipfile) {
  524.       OK_flag = 0;
  525. #ifdef USE_LIBSCHILY
  526.       errmsg("Unable to insert transparent compressed file - name conflictn");
  527. #else
  528.       fprintf(stderr, "Unable to insert transparent compressed file - name conflictn");
  529. #endif
  530.       fclose(zipfile);
  531.     }
  533.     free(checkname);
  535.     if(OK_flag){
  536.       if(MAYBE_ADD_CE_ENTRY(ZZ_SIZE)) add_CE_entry();
  537.       Rock[ipnt++] ='Z';
  538.       Rock[ipnt++] ='Z';
  539.       Rock[ipnt++] = ZZ_SIZE;
  540.       Rock[ipnt++] = SU_VERSION;
  541.       Rock[ipnt++] = 'g'; /* Identify compression technique used */
  542.       Rock[ipnt++] = 'z';
  543.       Rock[ipnt++] = 3;
  544.       set_733((char*)Rock + ipnt, file_size); /* Real file size */
  545.       ipnt += 8;
  546.     };
  547.   }
  548. #endif
  549.   /* 
  550.    * Add in the Rock Ridge CE field, if required.  We use  this for the
  551.    * extension record that is stored in the root directory.
  552.    */
  553.   if(deep_opt & NEED_CE) add_CE_entry();
  554.   /*
  555.    * Done filling in all of the fields.  Now copy it back to a buffer for the
  556.    * file in question.
  557.    */
  559.   /* Now copy this back to the buffer for the file */
  560.   Rock[flagpos] = flagval;
  562.   /* If there was a CE, fill in the size field */
  563.   if(recstart)
  564.     set_733((char*)Rock + recstart - 8, ipnt - recstart);
  566.   s_entry->rr_attributes = (unsigned char *) e_malloc(ipnt);
  567.   s_entry->total_rr_attr_size = ipnt;
  568.   s_entry->rr_attr_size = (mainrec ? mainrec : ipnt);
  569.   memcpy(s_entry->rr_attributes, Rock, ipnt);
  570.   return ipnt;
  571. }
  573. /* Guaranteed to  return a single sector with the relevant info */
  575. char * FDECL4(generate_rr_extension_record, char *, id,  char  *, descriptor,
  576.     char *, source, int  *, size){
  577.   int lipnt = 0;
  578.   char * pnt;
  579.   int len_id, len_des, len_src;
  581.   len_id = strlen(id);
  582.   len_des =  strlen(descriptor);
  583.   len_src = strlen(source);
  584.   Rock[lipnt++] ='E';
  585.   Rock[lipnt++] ='R';
  586.   Rock[lipnt++] = ER_SIZE + len_id + len_des + len_src;
  587.   Rock[lipnt++] = 1;
  588.   Rock[lipnt++] = len_id;
  589.   Rock[lipnt++] = len_des;
  590.   Rock[lipnt++] = len_src;
  591.   Rock[lipnt++] = 1;
  593.   memcpy(Rock  + lipnt, id, len_id);
  594.   lipnt += len_id;
  596.   memcpy(Rock  + lipnt, descriptor, len_des);
  597.   lipnt += len_des;
  599.   memcpy(Rock  + lipnt, source, len_src);
  600.   lipnt += len_src;
  602.   if(lipnt  > SECTOR_SIZE) {
  603. #ifdef USE_LIBSCHILY
  604.   comerrno(EX_BAD, "Extension record too longn");
  605. #else
  606.   fprintf(stderr,"Extension record too longn");
  607.   exit(1);
  608. #endif
  609.   };
  610.   pnt = (char *) e_malloc(SECTOR_SIZE);
  611.   memset(pnt, 0,  SECTOR_SIZE);
  612.   memcpy(pnt, Rock, lipnt);
  613.   *size = lipnt;
  614.   return pnt;
  615. }