home *** CD-ROM | disk | FTP | other *** search
/ The UNIX CD Bookshelf / OREILLY_TUCB_UNIX_CD.iso / upt / examples / SOURCES / TAR / RSEPATCH. < prev    next >
Encoding:
Text File  |  1998-07-24  |  5.8 KB  |  238 lines
  1. *** create.c.orig    Mon Sep 14 17:19:28 1992
  2. --- create.c    Wed Oct 28 12:58:36 1992
  3. ***************
  4. *** 373,379 ****
  5.           
  6.           header_moved = 0;
  7.   
  8. - #ifdef BSD42
  9.           if (f_sparse_files) {
  10.           /*
  11.             * JK - This is the test for sparseness: whether the
  12. --- 373,378 ----
  13. ***************
  14. *** 384,393 ****
  15.            * at least one of those records in the file is just
  16.            * a useless hole.
  17.            */
  18.   #ifdef hpux    /* Nice of HPUX to gratuitiously change it, huh?  - mib */
  19. !                 if (hstat.st_size - (hstat.st_blocks * 1024) > 1024 )
  20.   #else
  21. !             if (hstat.st_size - (hstat.st_blocks * RECORDSIZE) > RECORDSIZE)
  22.   #endif
  23.                 {
  24.                   int    filesize = hstat.st_size;
  25. --- 383,398 ----
  26.            * at least one of those records in the file is just
  27.            * a useless hole.
  28.            */
  29. + #ifdef BSD42
  30.   #ifdef hpux    /* Nice of HPUX to gratuitiously change it, huh?  - mib */
  31. !                 if (hstat.st_size - (hstat.st_blocks * 1024) > 1024 
  32. ! #else
  33. !             if (hstat.st_size - (hstat.st_blocks * RECORDSIZE) > RECORDSIZE
  34. ! #endif
  35. !                             || check_sparse(p))
  36.   #else
  37. !                         if (check_sparse(p))
  38. ! 
  39.   #endif
  40.                 {
  41.                   int    filesize = hstat.st_size;
  42. ***************
  43. *** 455,463 ****
  44. --- 460,470 ----
  45.                       
  46.               }
  47.           }
  48. + /*
  49.   #else
  50.           upperbound=SPARSE_IN_HDR-1;
  51.   #endif
  52. + */
  53.           
  54.           sizeleft = hstat.st_size;
  55.           /* Don't bother opening empty, world readable files. */
  56. *** tar.c.orig    Mon Sep 14 17:31:38 1992
  57. --- tar.c    Wed Oct 28 13:33:15 1992
  58. ***************
  59. *** 92,97 ****
  60. --- 92,100 ----
  61.   
  62.   extern FILE *msg_file;
  63.   
  64. + int    check_sparse();
  65. + void    add_sparse();
  66. + void    add_sparse_file();
  67.   int    check_exclude();
  68.   void    add_exclude();
  69.   void    add_exclude_file();
  70. ***************
  71. *** 184,189 ****
  72. --- 187,194 ----
  73.       {"portability",        0,    0,            'o'},
  74.       {"compress",        0,    &f_compress,        1},
  75.       {"compress-block",    0,    &f_compress,        2},
  76. +     {"sparse-list",        1,    0,            18},
  77. +     {"sparse-file",        1,    0,            19},
  78.       {"sparse",        0,    &f_sparse_files,    1},
  79.       {"tape-length",        1,    0,            'L'},
  80.       {"remove-files",    0,    &f_remove_files,    1},
  81. ***************
  82. *** 358,363 ****
  83. --- 363,378 ----
  84.               f_volno_file = optarg;
  85.               break;
  86.               
  87. +         case 18:
  88. +             f_sparse_files++;
  89. +             add_sparse_file(optarg);
  90. +             break;
  91. +             
  92. +         case 19:
  93. +             f_sparse_files++;
  94. +             add_sparse(optarg);
  95. +             break;
  96. +             
  97.           case 'g':    /* We are making a GNU dump; save
  98.                      directories at the beginning of
  99.                      the archive, and include in each
  100. ***************
  101. *** 704,709 ****
  102. --- 719,726 ----
  103.       --preserve-order    list of names to extract is sorted to match archive\n\
  104.   --same-owner        create extracted files with the same ownership \n\
  105.   -S, --sparse        handle sparse files efficiently\n\
  106. + --sparse-file FILE    treat FILE as sparse (implicit -S as well)\n\
  107. + --sparse-list FILE    treat files listed in FILE as sparse (implicit -S)\n\
  108.   -T, --files-from F    get names to extract or create from file F\n\
  109.   --null            -T reads null-terminated names, disable -C\n\
  110.   --totals            print total bytes written with --create\n\
  111. ***************
  112. *** 1394,1399 ****
  113. --- 1411,1534 ----
  114.           if(   (str=strstr(name,exclude[n]))
  115.               && (str==name || str[-1]=='/')
  116.              && str[strlen(exclude[n])]=='\0')
  117. +             return 1;
  118. +     }
  119. +     return 0;
  120. + }
  121. + 
  122. + char *s_buffer = 0;
  123. + int size_s_buffer;
  124. + int free_s_buffer;
  125. + 
  126. + char **sparse = 0;
  127. + int size_sparse = 0;
  128. + int free_sparse = 0;
  129. + 
  130. + char **re_sparse = 0;
  131. + int size_re_sparse = 0;
  132. + int free_re_sparse = 0;
  133. + 
  134. + void
  135. + add_sparse(name)
  136. + char *name;
  137. + {
  138. + /*    char *rname;*/
  139. + /*    char **tmp_ptr;*/
  140. +     int size_buf;
  141. + 
  142. +     un_quote_string(name);
  143. +     size_buf = strlen(name);
  144. + 
  145. +     if(s_buffer==0) {
  146. +         s_buffer = (char *)ck_malloc(size_buf+1024);
  147. +         free_s_buffer=1024;
  148. +     } else if(free_s_buffer<=size_buf) {
  149. +         char *old_s_buffer;
  150. +         char **tmp_ptr;
  151. + 
  152. +         old_s_buffer = s_buffer;
  153. +         s_buffer = (char *)ck_realloc(s_buffer,size_s_buffer+1024);
  154. +         free_s_buffer = 1024;
  155. +         for(tmp_ptr=sparse;tmp_ptr<sparse+size_sparse;tmp_ptr++)
  156. +             *tmp_ptr= s_buffer + ((*tmp_ptr) - old_s_buffer);
  157. +         for(tmp_ptr=re_sparse;tmp_ptr<re_sparse+size_re_sparse;tmp_ptr++)
  158. +             *tmp_ptr= s_buffer + ((*tmp_ptr) - old_s_buffer);
  159. +     }
  160. + 
  161. +     if(is_regex(name)) {
  162. +         if(free_re_sparse==0) {
  163. +             re_sparse= (char **)(re_sparse ? ck_realloc(re_sparse,(size_re_sparse+32)*sizeof(char *)) : ck_malloc(sizeof(char *)*32));
  164. +             free_re_sparse+=32;
  165. +         }
  166. +         re_sparse[size_re_sparse]=s_buffer+size_s_buffer;
  167. +         size_re_sparse++;
  168. +         free_re_sparse--;
  169. +     } else {
  170. +         if(free_sparse==0) {
  171. +             sparse=(char **)(sparse ? ck_realloc(sparse,(size_sparse+32)*sizeof(char *)) : ck_malloc(sizeof(char *)*32));
  172. +             free_sparse+=32;
  173. +         }
  174. +         sparse[size_sparse]=s_buffer+size_s_buffer;
  175. +         size_sparse++;
  176. +         free_sparse--;
  177. +     }
  178. +     strcpy(s_buffer+size_s_buffer,name);
  179. +     size_s_buffer+=size_buf+1;
  180. +     free_s_buffer-=size_buf+1;
  181. + }
  182. + 
  183. + void
  184. + add_sparse_file(file)
  185. + char *file;
  186. + {
  187. +     FILE *fp;
  188. +     char buf[1024];
  189. + 
  190. +     if(strcmp(file, "-"))
  191. +         fp=fopen(file,"r");
  192. +     else
  193. +         /* Let's hope the person knows what they're doing. */
  194. +         /* Using -X - -T - -f - will get you *REALLY* strange
  195. +            results. . . */
  196. +         fp=stdin;
  197. + 
  198. +     if(!fp) {
  199. +         msg_perror("can't open %s",file);
  200. +         exit(2);
  201. +     }
  202. +     while(fgets(buf,1024,fp)) {
  203. + /*        int size_buf;*/
  204. +         char *end_str;
  205. + 
  206. +         end_str=rindex(buf,'\n');
  207. +         if(end_str)
  208. +             *end_str='\0';
  209. +         add_sparse(buf);
  210. + 
  211. +     }
  212. +     fclose(fp);
  213. + }
  214. + 
  215. + /* Returns non-zero if the file 'name' should be treated as sparse */
  216. + int
  217. + check_sparse(name)
  218. + char *name;
  219. + {
  220. +     int n;
  221. +     char *str;
  222. +     extern char *strstr();
  223. + 
  224. +     for(n=0;n<size_re_sparse;n++) {
  225. +         if(fnmatch(re_sparse[n], name, FNM_TARPATH) == 0)
  226. +             return 1;
  227. +     }
  228. +     for(n=0;n<size_sparse;n++) {
  229. +         /* Accept the output from strstr only if it is the last
  230. +            part of the string.  There is certainly a faster way to
  231. +            do this. . . */
  232. +         if(   (str=strstr(name,sparse[n]))
  233. +             && (str==name || str[-1]=='/')
  234. +            && str[strlen(sparse[n])]=='\0')
  235.               return 1;
  236.       }
  237.       return 0;
  238.