OSDN Git Service

Change skip behavior on extracting.
[lha/lha.git] / src / lhext.c
1 /* ------------------------------------------------------------------------ */
2 /* LHa for UNIX                                                             */
3 /*              lhext.c -- LHarc extract                                    */
4 /*                                                                          */
5 /*      Copyright (C) MCMLXXXIX Yooichi.Tagawa                              */
6 /*      Modified                Nobutaka Watazaki                           */
7 /*                                                                          */
8 /*  Ver. 0.00  Original                             1988.05.23  Y.Tagawa    */
9 /*  Ver. 1.00  Fixed                                1989.09.22  Y.Tagawa    */
10 /*  Ver. 0.03  LHa for UNIX                         1991.12.17  M.Oki       */
11 /*  Ver. 1.12  LHa for UNIX                         1993.10.01  N.Watazaki  */
12 /*  Ver. 1.13b Symbolic Link Update Bug Fix         1994.06.21  N.Watazaki  */
13 /*  Ver. 1.14  Source All chagned                   1995.01.14  N.Watazaki  */
14 /*  Ver. 1.14e bugfix                               1999.04.30  T.Okamoto   */
15 /* ------------------------------------------------------------------------ */
16 #include "lha.h"
17 /* ------------------------------------------------------------------------ */
18 static int      skip_flg = FALSE;   /* FALSE..No Skip , TRUE..Skip */
19 static char    *methods[] =
20 {
21     LZHUFF0_METHOD, LZHUFF1_METHOD, LZHUFF2_METHOD, LZHUFF3_METHOD,
22     LZHUFF4_METHOD, LZHUFF5_METHOD, LZHUFF6_METHOD, LZHUFF7_METHOD,
23     LARC_METHOD, LARC5_METHOD, LARC4_METHOD,
24     LZHDIRS_METHOD,
25     PMARC0_METHOD, PMARC2_METHOD,
26     NULL
27 };
28
29 static void add_dirinfo(char* name, LzHeader* hdr);
30 static void adjust_dirinfo();
31
32 #ifdef HAVE_LIBAPPLEFILE
33 static boolean decode_macbinary(FILE *ofp, off_t size, const char *outPath);
34 #endif
35
36 /* ------------------------------------------------------------------------ */
37 static          boolean
38 inquire_extract(name)
39     char           *name;
40 {
41     struct stat     stbuf;
42
43     skip_flg = FALSE;
44     if (stat(name, &stbuf) >= 0) {
45         if (!is_regularfile(&stbuf)) {
46             error("\"%s\" already exists (not a file)", name);
47             return FALSE;
48         }
49
50         if (noexec) {
51             printf("EXTRACT %s but file is exist.\n", name);
52             return FALSE;
53         }
54         else if (!force) {
55             if (!isatty(0)) {
56                 warning("skip to extract %s.", name);
57                 return FALSE;
58             }
59
60             switch (inquire("OverWrite ?(Yes/[No]/All/Skip)", name, "YyNnAaSs\n")) {
61             case 0:
62             case 1:/* Y/y */
63                 break;
64             case 2:
65             case 3:/* N/n */
66             case 8:/* Return */
67                 return FALSE;
68             case 4:
69             case 5:/* A/a */
70                 force = TRUE;
71                 break;
72             case 6:
73             case 7:/* S/s */
74                 skip_flg = TRUE;
75                 break;
76             }
77         }
78     }
79
80     if (noexec)
81         printf("EXTRACT %s\n", name);
82
83     return TRUE;
84 }
85
86 static boolean
87 make_name_with_pathcheck(char *name, size_t namesz, const char *q)
88 {
89     int offset = 0;
90     const char *p;
91     int sz;
92     struct stat stbuf;
93
94     if (extract_directory) {
95         sz = xsnprintf(name, namesz, "%s/", extract_directory);
96         if (sz == -1) {
97             return FALSE;
98         }
99         offset += sz;
100     }
101
102 #ifdef S_IFLNK
103     while ((p = strchr(q, '/')) != NULL) {
104         if (namesz - offset < (p - q) + 2) {
105             return FALSE;
106         }
107         memcpy(name + offset, q, (p - q));
108         name[offset + (p - q)] = 0;
109
110         offset += (p - q);
111         q = p + 1;
112
113         if (lstat(name, &stbuf) < 0) {
114             name[offset++] = '/';
115             break;
116         }
117         if (is_symlink(&stbuf)) {
118             return FALSE;
119         }
120         name[offset++] = '/';
121     }
122 #endif
123
124     str_safe_copy(name + offset, q, namesz - offset);
125
126     return TRUE;
127 }
128
129 /* ------------------------------------------------------------------------ */
130 static          boolean
131 make_parent_path(name)
132     char           *name;
133 {
134     char            path[FILENAME_LENGTH];
135     struct stat     stbuf;
136     register char  *p;
137
138     /* make parent directory name into PATH for recursive call */
139     str_safe_copy(path, name, sizeof(path));
140     for (p = path + strlen(path); p > path; p--)
141         if (p[-1] == '/') {
142             *--p = '\0';
143             break;
144         }
145
146     if (p == path) {
147         message("invalid path name \"%s\"", name);
148         return FALSE;   /* no more parent. */
149     }
150
151     if (GETSTAT(path, &stbuf) >= 0) {
152         if (is_directory(&stbuf))
153             return TRUE;
154     }
155
156     if (verbose)
157         message("Making directory \"%s\".", path);
158
159 #if defined __MINGW32__
160     if (mkdir(path) >= 0)
161         return TRUE;
162 #else
163     if (mkdir(path, 0777) >= 0) /* try */
164         return TRUE;    /* successful done. */
165 #endif
166
167     if (!make_parent_path(path))
168         return FALSE;
169
170 #if defined __MINGW32__
171     if (mkdir(path) < 0) {      /* try again */
172         error("Cannot make directory \"%s\"", path);
173         return FALSE;
174     }
175 #else
176     if (mkdir(path, 0777) < 0) {    /* try again */
177         error("Cannot make directory \"%s\"", path);
178         return FALSE;
179     }
180 #endif
181
182     return TRUE;
183 }
184
185 /* ------------------------------------------------------------------------ */
186 static FILE    *
187 open_with_make_path(name)
188     char           *name;
189 {
190     FILE           *fp;
191
192     if ((fp = fopen(name, WRITE_BINARY)) == NULL) {
193         if (!make_parent_path(name) ||
194             (fp = fopen(name, WRITE_BINARY)) == NULL)
195             error("Cannot extract a file \"%s\"", name);
196     }
197     return fp;
198 }
199
200 /* ------------------------------------------------------------------------ */
201 static int
202 symlink_with_make_path(realname, name)
203     const char     *realname;
204     const char     *name;
205 {
206     int l_code;
207
208     l_code = symlink(realname, name);
209     if (l_code < 0) {
210         make_parent_path(name);
211         l_code = symlink(realname, name);
212     }
213
214     return l_code;
215 }
216
217 /* ------------------------------------------------------------------------ */
218 static void
219 adjust_info(name, hdr)
220     char           *name;
221     LzHeader       *hdr;
222 {
223     struct utimbuf utimebuf;
224
225     /* adjust file stamp */
226     utimebuf.actime = utimebuf.modtime = hdr->unix_last_modified_stamp;
227
228     if ((hdr->unix_mode & UNIX_FILE_TYPEMASK) != UNIX_FILE_SYMLINK)
229         utime(name, &utimebuf);
230
231     if (hdr->extend_type == EXTEND_UNIX
232         || hdr->extend_type == EXTEND_OS68K
233         || hdr->extend_type == EXTEND_XOSK) {
234
235         if ((hdr->unix_mode & UNIX_FILE_TYPEMASK) != UNIX_FILE_SYMLINK) {
236             chmod(name, hdr->unix_mode);
237         }
238
239         if (!getuid()){
240             uid_t uid = hdr->unix_uid;
241             gid_t gid = hdr->unix_gid;
242
243 #if HAVE_GETPWNAM && HAVE_GETGRNAM
244             if (hdr->user[0]) {
245                 struct passwd *ent = getpwnam(hdr->user);
246                 if (ent) uid = ent->pw_uid;
247             }
248             if (hdr->group[0]) {
249                 struct group *ent = getgrnam(hdr->group);
250                 if (ent) gid = ent->gr_gid;
251             }
252 #endif
253
254 #if HAVE_LCHOWN
255             if ((hdr->unix_mode & UNIX_FILE_TYPEMASK) == UNIX_FILE_SYMLINK)
256                 lchown(name, uid, gid);
257             else
258 #endif /* HAVE_LCHWON */
259                 chown(name, uid, gid);
260         }
261     }
262 #if __CYGWIN__
263     else {
264         /* On Cygwin, execute permission should be set for .exe or .dll. */
265         mode_t m;
266
267         umask(m = umask(0));    /* get current umask */
268         chmod(name, 0777 & ~m);
269     }
270 #endif
271 }
272
273 /* ------------------------------------------------------------------------ */
274 static off_t
275 extract_one(afp, hdr)
276     FILE           *afp;    /* archive file */
277     LzHeader       *hdr;
278 {
279     FILE           *fp; /* output file */
280 #if HAVE_LIBAPPLEFILE
281     FILE           *tfp; /* temporary output file */
282 #endif
283     struct stat     stbuf;
284     char            name[FILENAME_LENGTH];
285     unsigned int crc;
286     int             method;
287     boolean         save_quiet, save_verbose, up_flag;
288     char           *q = hdr->name, c;
289     off_t read_size = 0;
290
291     if (ignore_directory && strrchr(hdr->name, '/')) {
292         q = (char *) strrchr(hdr->name, '/') + 1;
293     }
294     else {
295         if (is_directory_traversal(q)) {
296             error("Possible directory traversal hack attempt in %s", q);
297             exit(1);
298         }
299
300         if (*q == '/') {
301             while (*q == '/') { q++; }
302
303             /*
304              * if OSK then strip device name
305              */
306             if (hdr->extend_type == EXTEND_OS68K
307                 || hdr->extend_type == EXTEND_XOSK) {
308                 do
309                     c = (*q++);
310                 while (c && c != '/');
311                 if (!c || !*q)
312                     q = ".";    /* if device name only */
313             }
314         }
315     }
316
317     if (!make_name_with_pathcheck(name, sizeof(name), q)) {
318         error("Possible symlink traversal hack attempt in %s", q);
319         exit(1);
320     }
321
322     /* LZHDIRS_METHODを持つヘッダをチェックする */
323     /* 1999.4.30 t.okamoto */
324     for (method = 0;; method++) {
325         if (methods[method] == NULL) {
326             error("Unknown method \"%.*s\"; \"%s\" will be skipped ...",
327                   5, hdr->method, name);
328             return read_size;
329         }
330         if (memcmp(hdr->method, methods[method], 5) == 0)
331             break;
332     }
333
334     if ((hdr->unix_mode & UNIX_FILE_TYPEMASK) == UNIX_FILE_REGULAR
335         && method != LZHDIRS_METHOD_NUM) {
336     extract_regular:
337 #if 0
338         for (method = 0;; method++) {
339             if (methods[method] == NULL) {
340                 error("Unknown method \"%.*s\"; \"%s\" will be skipped ...",
341                       5, hdr->method, name);
342                 return read_size;
343             }
344             if (memcmp(hdr->method, methods[method], 5) == 0)
345                 break;
346         }
347 #endif
348
349         reading_filename = archive_name;
350         writing_filename = name;
351         if (output_to_stdout || verify_mode) {
352             /* "Icon\r" should be a resource fork file encoded in MacBinary
353                format, so that it should be skipped. */
354             if (hdr->extend_type == EXTEND_MACOS
355                 && strcmp(basename(name), "Icon\r") == 0
356                 && decode_macbinary_contents) {
357                 return read_size;
358             }
359
360             if (noexec) {
361                 printf("%s %s\n", verify_mode ? "VERIFY" : "EXTRACT", name);
362                 return read_size;
363             }
364
365             save_quiet = quiet;
366             save_verbose = verbose;
367             if (!quiet && output_to_stdout) {
368                 printf("::::::::\n%s\n::::::::\n", name);
369                 quiet = TRUE;
370                 verbose = FALSE;
371             }
372             else if (verify_mode) {
373                 quiet = FALSE;
374                 verbose = TRUE;
375             }
376
377 #if defined(__MINGW32__) || defined(__DJGPP__)
378             {
379                 int old_mode;
380                 fflush(stdout);
381                 old_mode = setmode(fileno(stdout), O_BINARY);
382 #endif
383
384 #if HAVE_LIBAPPLEFILE
385             /* On default, MacLHA encodes into MacBinary. */
386             if (hdr->extend_type == EXTEND_MACOS && !verify_mode && decode_macbinary_contents) {
387                 /* build temporary file */
388                 tfp = NULL; /* avoid compiler warnings `uninitialized' */
389                 tfp = build_temporary_file();
390
391                 crc = decode_lzhuf(afp, tfp,
392                                    hdr->original_size, hdr->packed_size,
393                                    name, method, &read_size);
394                 fclose(tfp);
395                 decode_macbinary(stdout, hdr->original_size, name);
396                 unlink(temporary_name);
397             } else {
398                 crc = decode_lzhuf(afp, stdout,
399                                    hdr->original_size, hdr->packed_size,
400                                    name, method, &read_size);
401             }
402 #else
403             crc = decode_lzhuf(afp, stdout,
404                                hdr->original_size, hdr->packed_size,
405                                name, method, &read_size);
406 #endif /* HAVE_LIBAPPLEFILE */
407 #if defined(__MINGW32__) || defined(__DJGPP__)
408                 fflush(stdout);
409                 setmode(fileno(stdout), old_mode);
410             }
411 #endif
412             quiet = save_quiet;
413             verbose = save_verbose;
414         }
415         else {
416 #ifndef __APPLE__
417             /* "Icon\r" should be a resource fork of parent folder's icon,
418                so that it can be skipped when system is not Mac OS X. */
419             if (hdr->extend_type == EXTEND_MACOS
420                 && strcmp(basename(name), "Icon\r") == 0
421                 && decode_macbinary_contents) {
422                 make_parent_path(name); /* create directory only */
423                 return read_size;
424             }
425 #endif /* __APPLE__ */
426             if (skip_flg == FALSE)  {
427                 up_flag = inquire_extract(name);
428                 if (up_flag == FALSE && force == FALSE) {
429                     return read_size;
430                 }
431             }
432
433             if (skip_flg == TRUE) { /* if skip_flg */
434                 if (stat(name, &stbuf) == 0 && force != TRUE) {
435                     /* if (stbuf.st_mtime >= hdr->unix_last_modified_stamp) {*/
436                         if (quiet != TRUE)
437                             printf("%s : Skipped...\n", name);
438                         return read_size;
439                     /* } */
440                 }
441             }
442             if (noexec) {
443                 return read_size;
444             }
445
446             signal(SIGINT, interrupt);
447 #ifdef SIGHUP
448             signal(SIGHUP, interrupt);
449 #endif
450
451             unlink(name);
452             remove_extracting_file_when_interrupt = TRUE;
453
454             if ((fp = open_with_make_path(name)) != NULL) {
455 #if HAVE_LIBAPPLEFILE
456                 if (hdr->extend_type == EXTEND_MACOS && !verify_mode && decode_macbinary_contents) {
457                     /* build temporary file */
458                     tfp = NULL; /* avoid compiler warnings `uninitialized' */
459                     tfp = build_temporary_file();
460
461                     crc = decode_lzhuf(afp, tfp,
462                                        hdr->original_size, hdr->packed_size,
463                                        name, method, &read_size);
464                     fclose(tfp);
465                     decode_macbinary(fp, hdr->original_size, name);
466 #ifdef __APPLE__
467                     /* TODO: set resource fork */
468                     /* after processing, "Icon\r" is not needed. */
469                     if (strcmp(basename(name), "Icon\r") == 0) {
470                         unlink(name);
471                     }
472 #endif /* __APPLE__ */
473                     unlink(temporary_name);
474                 } else {
475                     crc = decode_lzhuf(afp, fp,
476                                        hdr->original_size, hdr->packed_size,
477                                        name, method, &read_size);
478                 }
479 #else /* HAVE_LIBAPPLEFILE */
480                 crc = decode_lzhuf(afp, fp,
481                                    hdr->original_size, hdr->packed_size,
482                                    name, method, &read_size);
483 #endif /* HAVE_LIBAPPLEFILE */
484                 fclose(fp);
485             }
486             remove_extracting_file_when_interrupt = FALSE;
487             signal(SIGINT, SIG_DFL);
488 #ifdef SIGHUP
489             signal(SIGHUP, SIG_DFL);
490 #endif
491             if (!fp)
492                 return read_size;
493         }
494
495         if (hdr->has_crc && crc != hdr->crc)
496             error("CRC error: \"%s\"", name);
497     }
498     else if ((hdr->unix_mode & UNIX_FILE_TYPEMASK) == UNIX_FILE_DIRECTORY
499              || (hdr->unix_mode & UNIX_FILE_TYPEMASK) == UNIX_FILE_SYMLINK
500              || method == LZHDIRS_METHOD_NUM) {
501         /* ↑これで、Symbolic Link は、大丈夫か? */
502         if (!ignore_directory && !verify_mode && !output_to_stdout) {
503             if (noexec) {
504                 if (quiet != TRUE)
505                     printf("EXTRACT %s (directory)\n", name);
506                 return read_size;
507             }
508             /* NAME has trailing SLASH '/', (^_^) */
509             if ((hdr->unix_mode & UNIX_FILE_TYPEMASK) == UNIX_FILE_SYMLINK) {
510                 int             l_code;
511
512 #ifdef S_IFLNK
513                 if (skip_flg == FALSE)  {
514                     up_flag = inquire_extract(name);
515                     if (up_flag == FALSE && force == FALSE) {
516                         return read_size;
517                     }
518                 }
519
520                 if (skip_flg == TRUE) { /* if skip_flg */
521                     if (GETSTAT(name, &stbuf) == 0 && force != TRUE) {
522                         /* if (stbuf.st_mtime >= hdr->unix_last_modified_stamp) { */
523                             if (quiet != TRUE)
524                                 printf("%s : Skipped...\n", name);
525                             return read_size;
526                         /* } */
527                     }
528                 }
529
530                 unlink(name);
531                 l_code = symlink_with_make_path(hdr->realname, name);
532                 if (l_code < 0) {
533                     if (quiet != TRUE)
534                         warning("Can't make Symbolic Link \"%s\" -> \"%s\"",
535                                 name, hdr->realname);
536                 }
537                 if (quiet != TRUE) {
538                     message("Symbolic Link %s -> %s",
539                             name, hdr->realname);
540                 }
541 #else
542                 warning("Can't make Symbolic Link %s -> %s",
543                         name, hdr->realname);
544                 return read_size;
545 #endif
546             }
547             else { /* make directory */
548                 if (!make_parent_path(name))
549                     return read_size;
550                 /* save directory information */
551                 add_dirinfo(name, hdr);
552             }
553         }
554     }
555     else {
556         if (force)              /* force extract */
557             goto extract_regular;
558         else
559             error("Unknown file type: \"%s\". use `f' option to force extract.", name);
560     }
561
562     if (!output_to_stdout && !verify_mode) {
563         if ((hdr->unix_mode & UNIX_FILE_TYPEMASK) != UNIX_FILE_DIRECTORY)
564             adjust_info(name, hdr);
565     }
566
567     return read_size;
568 }
569
570 static int
571 skip_to_nextpos(FILE *fp, off_t pos, off_t off, off_t read_size)
572 {
573     if (pos != -1) {
574         if (fseeko(fp, pos + off, SEEK_SET) != 0) {
575             return -1;
576         }
577     }
578     else {
579         off_t i = off - read_size;
580         while (i--) {
581             if (fgetc(fp) == EOF) {
582                 return -1;
583             }
584         }
585     }
586     return 0;
587 }
588
589 /* ------------------------------------------------------------------------ */
590 /* EXTRACT COMMAND MAIN                                                     */
591 /* ------------------------------------------------------------------------ */
592 void
593 cmd_extract()
594 {
595     LzHeader        hdr;
596     off_t           pos;
597     FILE           *afp;
598     off_t read_size;
599
600     /* open archive file */
601     if ((afp = open_old_archive()) == NULL)
602         fatal_error("Cannot open archive file \"%s\"", archive_name);
603
604     if (archive_is_msdos_sfx1(archive_name))
605         seek_lha_header(afp);
606
607     /* extract each files */
608     while (get_header(afp, &hdr)) {
609         pos = ftello(afp);
610         if (need_file(hdr.name)) {
611             read_size = extract_one(afp, &hdr);
612             if (read_size != hdr.packed_size) {
613                 /* when error occurred in extract_one(), should adjust
614                    point of file stream */
615                 if (skip_to_nextpos(afp, pos, hdr.packed_size, read_size) == -1) {
616                     fatal_error("Cannot seek to next header position from \"%s\"", hdr.name);
617                 }
618             }
619         } else {
620             if (skip_to_nextpos(afp, pos, hdr.packed_size, 0) == -1) {
621                 fatal_error("Cannot seek to next header position from \"%s\"", hdr.name);
622             }
623         }
624     }
625
626     /* close archive file */
627     fclose(afp);
628
629     /* adjust directory information */
630     adjust_dirinfo();
631
632     return;
633 }
634
635 int
636 is_directory_traversal(char *path)
637 {
638     int state = 0;
639
640     for (; *path; path++) {
641         switch (state) {
642         case 0:
643             if (*path == '.') state = 1;
644             else state = 3;
645             break;
646         case 1:
647             if (*path == '.') state = 2;
648             else if (*path == '/') state = 0;
649             else state = 3;
650             break;
651         case 2:
652             if (*path == '/') return 1;
653             else state = 3;
654             break;
655         case 3:
656             if (*path == '/') state = 0;
657             break;
658         }
659     }
660
661     return state == 2;
662 }
663
664 /*
665  * restore directory information (timestamp, permission and uid/gid).
666  * added by A.Iriyama  2003.12.12
667  */
668
669 typedef struct LzHeaderList_t {
670     struct LzHeaderList_t *next;
671     LzHeader hdr;
672 } LzHeaderList;
673
674 static LzHeaderList *dirinfo;
675
676 static void add_dirinfo(char *name, LzHeader *hdr)
677 {
678     LzHeaderList *p, *tmp, top;
679
680     if (memcmp(hdr->method, LZHDIRS_METHOD, 5) != 0)
681         return;
682
683     p = xmalloc(sizeof(LzHeaderList));
684
685     memcpy(&p->hdr, hdr, sizeof(LzHeader));
686     strncpy(p->hdr.name, name, sizeof(p->hdr.name));
687     p->hdr.name[sizeof(p->hdr.name)-1] = 0;
688
689 #if 0
690     /* push front */
691     {
692         tmp = dirinfo;
693         dirinfo = p;
694         dirinfo->next = tmp;
695     }
696 #else
697
698     /*
699       reverse sorted by pathname order
700
701          p->hdr.name = "a"
702
703          dirinfo->hdr.name             = "a/b/d"
704          dirinfo->next->hdr.name       = "a/b/c"
705          dirinfo->next->next->hdr.name = "a/b"
706
707        result:
708
709          dirinfo->hdr.name                   = "a/b/d"
710          dirinfo->next->hdr.name             = "a/b/c"
711          dirinfo->next->next->hdr.name       = "a/b"
712          dirinfo->next->next->next->hdr.name = "a"
713     */
714
715     top.next = dirinfo;
716
717     for (tmp = &top; tmp->next; tmp = tmp->next) {
718         if (strcmp(p->hdr.name, tmp->next->hdr.name) > 0) {
719             p->next = tmp->next;
720             tmp->next = p;
721             break;
722         }
723     }
724     if (tmp->next == NULL) {
725         p->next = NULL;
726         tmp->next = p;
727     }
728
729     dirinfo = top.next;
730 #endif
731 }
732
733 static void adjust_dirinfo()
734 {
735     while (dirinfo) {
736         /* message("adjusting [%s]", dirinfo->hdr.name); */
737         adjust_info(dirinfo->hdr.name, &dirinfo->hdr);
738
739         {
740             LzHeaderList *tmp = dirinfo;
741             dirinfo = dirinfo->next;
742             free(tmp);
743         }
744     }
745 }
746
747 #if HAVE_LIBAPPLEFILE
748 static boolean
749 decode_macbinary(ofp, size, outPath)
750     FILE *ofp;
751     off_t size;
752     const char *outPath;
753 {
754     af_file_t *afp = NULL;
755     FILE *ifp = NULL;
756     unsigned char *datap;
757     size_t dlen;
758
759     if ((afp = af_open(temporary_name)) != NULL) {
760         /* fetch datafork */
761         datap = af_data(afp, &dlen);
762         fwrite(datap, sizeof(unsigned char), dlen, ofp);
763         af_close(afp);
764         return TRUE;
765     } else { /* it may be not encoded in MacBinary */
766         /* try to copy */
767         if ((ifp = fopen(temporary_name, READ_BINARY)) == NULL) {
768             error("Cannot open a temporary file \"%s\"", temporary_name);
769             return FALSE;
770         }
771         copyfile(ifp, ofp, size, 0, 0);
772         fclose(ifp);
773         return TRUE;
774     }
775
776     return FALSE;
777 }
778 #endif /* HAVE_LIBAPPLEFILE */