This source file includes following definitions.
- cpio_defer_find
- cpio_skip_padding
- cpio_new_archive
- cpio_free_archive
- cpio_open_cpio_file
- cpio_read_head
- cpio_find_head
- cpio_create_entry
- cpio_read_bin_head
- cpio_read_oldc_head
- cpio_read_crc_head
- cpio_open_archive
- cpio_super_check
- cpio_super_same
- cpio_read
- cpio_fh_open
- vfs_init_cpiofs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33 #include <config.h>
34
35 #include <errno.h>
36 #include <sys/types.h>
37 #include <sys/stat.h>
38
39 #include "lib/global.h"
40 #include "lib/unixcompat.h"
41 #include "lib/util.h"
42 #include "lib/widget.h"
43
44 #include "lib/vfs/vfs.h"
45 #include "lib/vfs/utilvfs.h"
46 #include "lib/vfs/xdirentry.h"
47 #include "lib/vfs/gc.h"
48
49 #include "cpio.h"
50
51
52
53
54
55 #define CPIO_SUPER(super) ((cpio_super_t *) (super))
56
57 #define CPIO_POS(super) cpio_position
58
59
60
61 #define CPIO_SEEK_SET(super, where) mc_lseek (CPIO_SUPER(super)->fd, CPIO_POS(super) = (where), SEEK_SET)
62 #define CPIO_SEEK_CUR(super, where) mc_lseek (CPIO_SUPER(super)->fd, CPIO_POS(super) += (where), SEEK_SET)
63
64 #define MAGIC_LENGTH (6)
65 #define SEEKBACK CPIO_SEEK_CUR(super, ptr - top)
66 #define RETURN(x) return (CPIO_SUPER(super)->type = (x))
67 #define TYPEIS(x) ((CPIO_SUPER(super)->type == CPIO_UNKNOWN) || (CPIO_SUPER(super)->type == (x)))
68
69 #define HEAD_LENGTH (26)
70
71
72
73 enum
74 {
75 STATUS_START,
76 STATUS_OK,
77 STATUS_TRAIL,
78 STATUS_FAIL,
79 STATUS_EOF
80 };
81
82 enum
83 {
84 CPIO_UNKNOWN = 0,
85 CPIO_BIN,
86 CPIO_BINRE,
87 CPIO_OLDC,
88 CPIO_NEWC,
89 CPIO_CRC
90 };
91
92 struct old_cpio_header
93 {
94 unsigned short c_magic;
95 short c_dev;
96 unsigned short c_ino;
97 unsigned short c_mode;
98 unsigned short c_uid;
99 unsigned short c_gid;
100 unsigned short c_nlink;
101 short c_rdev;
102 unsigned short c_mtimes[2];
103 unsigned short c_namesize;
104 unsigned short c_filesizes[2];
105 };
106
107 struct new_cpio_header
108 {
109 unsigned short c_magic;
110 unsigned long c_ino;
111 unsigned long c_mode;
112 unsigned long c_uid;
113 unsigned long c_gid;
114 unsigned long c_nlink;
115 unsigned long c_mtime;
116 unsigned long c_filesize;
117 long c_dev;
118 long c_devmin;
119 long c_rdev;
120 long c_rdevmin;
121 unsigned long c_namesize;
122 unsigned long c_chksum;
123 };
124
125 typedef struct
126 {
127 unsigned long inumber;
128 dev_t device;
129 struct vfs_s_inode *inode;
130 } defer_inode;
131
132 typedef struct
133 {
134 struct vfs_s_super base;
135
136 int fd;
137 struct stat st;
138 int type;
139 GSList *deferred;
140 } cpio_super_t;
141
142
143
144 static ssize_t cpio_find_head (struct vfs_class *me, struct vfs_s_super *super);
145 static ssize_t cpio_read_bin_head (struct vfs_class *me, struct vfs_s_super *super);
146 static ssize_t cpio_read_oldc_head (struct vfs_class *me, struct vfs_s_super *super);
147 static ssize_t cpio_read_crc_head (struct vfs_class *me, struct vfs_s_super *super);
148
149
150
151 static struct vfs_s_subclass cpio_subclass;
152 static struct vfs_class *vfs_cpiofs_ops = VFS_CLASS (&cpio_subclass);
153
154 static off_t cpio_position;
155
156
157
158
159
160 static int
161 cpio_defer_find (const void *a, const void *b)
162 {
163 const defer_inode *a1 = (const defer_inode *) a;
164 const defer_inode *b1 = (const defer_inode *) b;
165
166 return (a1->inumber == b1->inumber && a1->device == b1->device) ? 0 : 1;
167 }
168
169
170
171 static ssize_t
172 cpio_skip_padding (struct vfs_s_super *super)
173 {
174 switch (CPIO_SUPER (super)->type)
175 {
176 case CPIO_BIN:
177 case CPIO_BINRE:
178 return CPIO_SEEK_CUR (super, (2 - (CPIO_POS (super) % 2)) % 2);
179 case CPIO_NEWC:
180 case CPIO_CRC:
181 return CPIO_SEEK_CUR (super, (4 - (CPIO_POS (super) % 4)) % 4);
182 case CPIO_OLDC:
183 return CPIO_POS (super);
184 default:
185 g_assert_not_reached ();
186 return 42;
187 }
188 }
189
190
191
192 static struct vfs_s_super *
193 cpio_new_archive (struct vfs_class *me)
194 {
195 cpio_super_t *arch;
196
197 arch = g_new0 (cpio_super_t, 1);
198 arch->base.me = me;
199 arch->fd = -1;
200 arch->type = CPIO_UNKNOWN;
201
202 return VFS_SUPER (arch);
203 }
204
205
206
207 static void
208 cpio_free_archive (struct vfs_class *me, struct vfs_s_super *super)
209 {
210 cpio_super_t *arch = CPIO_SUPER (super);
211
212 (void) me;
213
214 if (arch->fd != -1)
215 {
216 mc_close (arch->fd);
217 arch->fd = -1;
218 }
219
220 g_clear_slist (&arch->deferred, g_free);
221 }
222
223
224
225 static int
226 cpio_open_cpio_file (struct vfs_class *me, struct vfs_s_super *super, const vfs_path_t * vpath)
227 {
228 int fd, type;
229 cpio_super_t *arch;
230 mode_t mode;
231 struct vfs_s_inode *root;
232
233 fd = mc_open (vpath, O_RDONLY);
234 if (fd == -1)
235 {
236 message (D_ERROR, MSG_ERROR, _("Cannot open cpio archive\n%s"), vfs_path_as_str (vpath));
237 return -1;
238 }
239
240 super->name = g_strdup (vfs_path_as_str (vpath));
241 arch = CPIO_SUPER (super);
242 mc_stat (vpath, &arch->st);
243
244 type = get_compression_type (fd, super->name);
245 if (type == COMPRESSION_NONE)
246 mc_lseek (fd, 0, SEEK_SET);
247 else
248 {
249 char *s;
250 vfs_path_t *tmp_vpath;
251
252 mc_close (fd);
253 s = g_strconcat (super->name, decompress_extension (type), (char *) NULL);
254 tmp_vpath = vfs_path_from_str_flags (s, VPF_NO_CANON);
255 fd = mc_open (tmp_vpath, O_RDONLY);
256 vfs_path_free (tmp_vpath, TRUE);
257 if (fd == -1)
258 {
259 message (D_ERROR, MSG_ERROR, _("Cannot open cpio archive\n%s"), s);
260 g_free (s);
261 MC_PTR_FREE (super->name);
262 return -1;
263 }
264 g_free (s);
265 }
266
267 arch->fd = fd;
268 mode = arch->st.st_mode & 07777;
269 mode |= (mode & 0444) >> 2;
270 mode |= S_IFDIR;
271
272 root = vfs_s_new_inode (me, super, &arch->st);
273 root->st.st_mode = mode;
274 root->data_offset = -1;
275 root->st.st_nlink++;
276 root->st.st_dev = VFS_SUBCLASS (me)->rdev++;
277
278 super->root = root;
279
280 CPIO_SEEK_SET (super, 0);
281
282 return fd;
283 }
284
285
286
287 static ssize_t
288 cpio_read_head (struct vfs_class *me, struct vfs_s_super *super)
289 {
290 switch (cpio_find_head (me, super))
291 {
292 case CPIO_UNKNOWN:
293 return -1;
294 case CPIO_BIN:
295 case CPIO_BINRE:
296 return cpio_read_bin_head (me, super);
297 case CPIO_OLDC:
298 return cpio_read_oldc_head (me, super);
299 case CPIO_NEWC:
300 case CPIO_CRC:
301 return cpio_read_crc_head (me, super);
302 default:
303 g_assert_not_reached ();
304 return 42;
305 }
306 }
307
308
309
310 static ssize_t
311 cpio_find_head (struct vfs_class *me, struct vfs_s_super *super)
312 {
313 cpio_super_t *arch = CPIO_SUPER (super);
314 char buf[BUF_SMALL * 2];
315 ssize_t ptr = 0;
316 ssize_t top;
317 ssize_t tmp;
318
319 top = mc_read (arch->fd, buf, sizeof (buf));
320 if (top > 0)
321 CPIO_POS (super) += top;
322
323 while (TRUE)
324 {
325 if (ptr + MAGIC_LENGTH >= top)
326 {
327 if (top > (ssize_t) (sizeof (buf) / 2))
328 {
329 memmove (buf, buf + top - sizeof (buf) / 2, sizeof (buf) / 2);
330 ptr -= top - sizeof (buf) / 2;
331 top = sizeof (buf) / 2;
332 }
333 tmp = mc_read (arch->fd, buf, top);
334 if (tmp == 0 || tmp == -1)
335 {
336 message (D_ERROR, MSG_ERROR, _("Premature end of cpio archive\n%s"), super->name);
337 cpio_free_archive (me, super);
338 return CPIO_UNKNOWN;
339 }
340 top += tmp;
341 }
342 if (TYPEIS (CPIO_BIN) && ((*(unsigned short *) (buf + ptr)) == 070707))
343 {
344 SEEKBACK;
345 RETURN (CPIO_BIN);
346 }
347 else if (TYPEIS (CPIO_BINRE)
348 && ((*(unsigned short *) (buf + ptr)) == GUINT16_SWAP_LE_BE_CONSTANT (070707)))
349 {
350 SEEKBACK;
351 RETURN (CPIO_BINRE);
352 }
353 else if (TYPEIS (CPIO_OLDC) && (strncmp (buf + ptr, "070707", 6) == 0))
354 {
355 SEEKBACK;
356 RETURN (CPIO_OLDC);
357 }
358 else if (TYPEIS (CPIO_NEWC) && (strncmp (buf + ptr, "070701", 6) == 0))
359 {
360 SEEKBACK;
361 RETURN (CPIO_NEWC);
362 }
363 else if (TYPEIS (CPIO_CRC) && (strncmp (buf + ptr, "070702", 6) == 0))
364 {
365 SEEKBACK;
366 RETURN (CPIO_CRC);
367 };
368 ptr++;
369 }
370 }
371
372
373
374 static int
375 cpio_create_entry (struct vfs_class *me, struct vfs_s_super *super, struct stat *st, char *name)
376 {
377 cpio_super_t *arch = CPIO_SUPER (super);
378 struct vfs_s_inode *inode = NULL;
379 struct vfs_s_inode *root = super->root;
380 struct vfs_s_entry *entry = NULL;
381 char *tn;
382
383 switch (st->st_mode & S_IFMT)
384 {
385 case S_IFCHR:
386 case S_IFBLK:
387 #ifdef S_IFSOCK
388
389 case S_IFSOCK:
390 #endif
391 #ifdef S_IFIFO
392
393 case S_IFIFO:
394 #endif
395 #ifdef S_IFNAM
396
397 case S_IFNAM:
398 #endif
399 #ifdef HAVE_STRUCT_STAT_ST_RDEV
400 if ((st->st_size != 0) && (st->st_rdev == 0x0001))
401 {
402
403
404 st->st_rdev = (unsigned) st->st_size;
405 st->st_size = 0;
406 }
407 #endif
408 break;
409 default:
410 break;
411 }
412
413 if ((st->st_nlink > 1) && ((arch->type == CPIO_NEWC) || (arch->type == CPIO_CRC)))
414 {
415 defer_inode i = { st->st_ino, st->st_dev, NULL };
416 GSList *l;
417
418 l = g_slist_find_custom (arch->deferred, &i, cpio_defer_find);
419 if (l != NULL)
420 {
421 inode = ((defer_inode *) l->data)->inode;
422 if (inode->st.st_size != 0 && st->st_size != 0 && (inode->st.st_size != st->st_size))
423 {
424 message (D_ERROR, MSG_ERROR,
425 _("Inconsistent hardlinks of\n%s\nin cpio archive\n%s"),
426 name, super->name);
427 inode = NULL;
428 }
429 else if (inode->st.st_size == 0)
430 inode->st.st_size = st->st_size;
431 }
432 }
433
434
435 for (tn = name + strlen (name) - 1; tn >= name && IS_PATH_SEP (*tn); tn--)
436 *tn = '\0';
437
438 tn = strrchr (name, PATH_SEP);
439 if (tn == NULL)
440 tn = name;
441 else if (tn == name + 1)
442 {
443
444 tn++;
445 }
446 else
447 {
448 *tn = '\0';
449 root = vfs_s_find_inode (me, super, name, LINK_FOLLOW, FL_MKDIR);
450 *tn = PATH_SEP;
451 tn++;
452 }
453
454 entry = VFS_SUBCLASS (me)->find_entry (me, root, tn, LINK_FOLLOW, FL_NONE);
455
456 if (entry != NULL)
457 {
458
459
460
461
462 if (!S_ISDIR (entry->ino->st.st_mode))
463 {
464
465 message (D_ERROR, MSG_ERROR,
466 _("%s contains duplicate entries! Skipping!"), super->name);
467 }
468 else
469 {
470 entry->ino->st.st_mode = st->st_mode;
471 entry->ino->st.st_uid = st->st_uid;
472 entry->ino->st.st_gid = st->st_gid;
473 #ifdef HAVE_STRUCT_STAT_ST_MTIM
474 entry->ino->st.st_atim = st->st_atim;
475 entry->ino->st.st_mtim = st->st_mtim;
476 entry->ino->st.st_ctim = st->st_ctim;
477 #else
478 entry->ino->st.st_atime = st->st_atime;
479 entry->ino->st.st_mtime = st->st_mtime;
480 entry->ino->st.st_ctime = st->st_ctime;
481 #endif
482 }
483
484 g_free (name);
485 }
486 else
487 {
488
489
490
491
492 if (root != NULL)
493 {
494 if (inode == NULL)
495 {
496 inode = vfs_s_new_inode (me, super, st);
497 if ((st->st_nlink > 0) && ((arch->type == CPIO_NEWC) || (arch->type == CPIO_CRC)))
498 {
499
500 defer_inode *i;
501
502 i = g_new (defer_inode, 1);
503 i->inumber = st->st_ino;
504 i->device = st->st_dev;
505 i->inode = inode;
506
507 arch->deferred = g_slist_prepend (arch->deferred, i);
508 }
509 }
510
511 if (st->st_size != 0)
512 inode->data_offset = CPIO_POS (super);
513
514 entry = vfs_s_new_entry (me, tn, inode);
515 vfs_s_insert_entry (me, root, entry);
516 }
517
518 g_free (name);
519
520 if (!S_ISLNK (st->st_mode))
521 CPIO_SEEK_CUR (super, st->st_size);
522 else
523 {
524 if (inode != NULL)
525 {
526
527
528 inode->linkname = g_malloc (st->st_size + 1);
529
530 if (mc_read (arch->fd, inode->linkname, st->st_size) < st->st_size)
531 {
532 inode->linkname[0] = '\0';
533 return STATUS_EOF;
534 }
535
536 inode->linkname[st->st_size] = '\0';
537 }
538
539 CPIO_POS (super) += st->st_size;
540 cpio_skip_padding (super);
541 }
542 }
543
544 return STATUS_OK;
545 }
546
547
548
549 static ssize_t
550 cpio_read_bin_head (struct vfs_class *me, struct vfs_s_super *super)
551 {
552 union
553 {
554 struct old_cpio_header buf;
555 short shorts[HEAD_LENGTH >> 1];
556 } u;
557
558 cpio_super_t *arch = CPIO_SUPER (super);
559 ssize_t len;
560 char *name;
561 struct stat st;
562
563 len = mc_read (arch->fd, (char *) &u.buf, HEAD_LENGTH);
564 if (len < HEAD_LENGTH)
565 return STATUS_EOF;
566 CPIO_POS (super) += len;
567 if (arch->type == CPIO_BINRE)
568 {
569 int i;
570 for (i = 0; i < (HEAD_LENGTH >> 1); i++)
571 u.shorts[i] = GUINT16_SWAP_LE_BE_CONSTANT (u.shorts[i]);
572 }
573
574 if (u.buf.c_magic != 070707 || u.buf.c_namesize == 0 || u.buf.c_namesize > MC_MAXPATHLEN)
575 {
576 message (D_ERROR, MSG_ERROR, _("Corrupted cpio header encountered in\n%s"), super->name);
577 return STATUS_FAIL;
578 }
579 name = g_malloc (u.buf.c_namesize);
580 len = mc_read (arch->fd, name, u.buf.c_namesize);
581 if (len < u.buf.c_namesize)
582 {
583 g_free (name);
584 return STATUS_EOF;
585 }
586 name[u.buf.c_namesize - 1] = '\0';
587 CPIO_POS (super) += len;
588 cpio_skip_padding (super);
589
590 if (!strcmp ("TRAILER!!!", name))
591 {
592 g_free (name);
593 return STATUS_TRAIL;
594 }
595
596 st.st_dev = u.buf.c_dev;
597 st.st_ino = u.buf.c_ino;
598 st.st_mode = u.buf.c_mode;
599 st.st_nlink = u.buf.c_nlink;
600 st.st_uid = u.buf.c_uid;
601 st.st_gid = u.buf.c_gid;
602 #ifdef HAVE_STRUCT_STAT_ST_RDEV
603 st.st_rdev = u.buf.c_rdev;
604 #endif
605 st.st_size = ((off_t) u.buf.c_filesizes[0] << 16) | u.buf.c_filesizes[1];
606 #ifdef HAVE_STRUCT_STAT_ST_MTIM
607 st.st_atim.tv_nsec = st.st_mtim.tv_nsec = st.st_ctim.tv_nsec = 0;
608 #endif
609 st.st_atime = st.st_mtime = st.st_ctime =
610 ((time_t) u.buf.c_mtimes[0] << 16) | u.buf.c_mtimes[1];
611
612 return cpio_create_entry (me, super, &st, name);
613 }
614
615
616
617 #undef HEAD_LENGTH
618 #define HEAD_LENGTH (76)
619
620 static ssize_t
621 cpio_read_oldc_head (struct vfs_class *me, struct vfs_s_super *super)
622 {
623 cpio_super_t *arch = CPIO_SUPER (super);
624 struct new_cpio_header hd;
625 union
626 {
627 struct stat st;
628 char buf[HEAD_LENGTH + 1];
629 } u;
630 ssize_t len;
631 char *name;
632
633 if (mc_read (arch->fd, u.buf, HEAD_LENGTH) != HEAD_LENGTH)
634 return STATUS_EOF;
635 CPIO_POS (super) += HEAD_LENGTH;
636 u.buf[HEAD_LENGTH] = 0;
637
638 if (sscanf (u.buf, "070707%6lo%6lo%6lo%6lo%6lo%6lo%6lo%11lo%6lo%11lo",
639 (unsigned long *) &hd.c_dev, &hd.c_ino, &hd.c_mode, &hd.c_uid, &hd.c_gid,
640 &hd.c_nlink, (unsigned long *) &hd.c_rdev, &hd.c_mtime,
641 &hd.c_namesize, &hd.c_filesize) < 10)
642 {
643 message (D_ERROR, MSG_ERROR, _("Corrupted cpio header encountered in\n%s"), super->name);
644 return STATUS_FAIL;
645 }
646
647 if (hd.c_namesize == 0 || hd.c_namesize > MC_MAXPATHLEN)
648 {
649 message (D_ERROR, MSG_ERROR, _("Corrupted cpio header encountered in\n%s"), super->name);
650 return STATUS_FAIL;
651 }
652 name = g_malloc (hd.c_namesize);
653 len = mc_read (arch->fd, name, hd.c_namesize);
654 if ((len == -1) || ((unsigned long) len < hd.c_namesize))
655 {
656 g_free (name);
657 return STATUS_EOF;
658 }
659 name[hd.c_namesize - 1] = '\0';
660 CPIO_POS (super) += len;
661 cpio_skip_padding (super);
662
663 if (!strcmp ("TRAILER!!!", name))
664 {
665 g_free (name);
666 return STATUS_TRAIL;
667 }
668
669 u.st.st_dev = hd.c_dev;
670 u.st.st_ino = hd.c_ino;
671 u.st.st_mode = hd.c_mode;
672 u.st.st_nlink = hd.c_nlink;
673 u.st.st_uid = hd.c_uid;
674 u.st.st_gid = hd.c_gid;
675 #ifdef HAVE_STRUCT_STAT_ST_RDEV
676 u.st.st_rdev = hd.c_rdev;
677 #endif
678 u.st.st_size = hd.c_filesize;
679 #ifdef HAVE_STRUCT_STAT_ST_MTIM
680 u.st.st_atim.tv_nsec = u.st.st_mtim.tv_nsec = u.st.st_ctim.tv_nsec = 0;
681 #endif
682 u.st.st_atime = u.st.st_mtime = u.st.st_ctime = hd.c_mtime;
683
684 return cpio_create_entry (me, super, &u.st, name);
685 }
686
687
688
689 #undef HEAD_LENGTH
690 #define HEAD_LENGTH (110)
691
692 static ssize_t
693 cpio_read_crc_head (struct vfs_class *me, struct vfs_s_super *super)
694 {
695 cpio_super_t *arch = CPIO_SUPER (super);
696 struct new_cpio_header hd;
697 union
698 {
699 struct stat st;
700 char buf[HEAD_LENGTH + 1];
701 } u;
702 ssize_t len;
703 char *name;
704
705 if (mc_read (arch->fd, u.buf, HEAD_LENGTH) != HEAD_LENGTH)
706 return STATUS_EOF;
707
708 CPIO_POS (super) += HEAD_LENGTH;
709 u.buf[HEAD_LENGTH] = '\0';
710
711 if (sscanf (u.buf, "%6ho%8lx%8lx%8lx%8lx%8lx%8lx%8lx%8lx%8lx%8lx%8lx%8lx%8lx",
712 &hd.c_magic, &hd.c_ino, &hd.c_mode, &hd.c_uid, &hd.c_gid,
713 &hd.c_nlink, &hd.c_mtime, &hd.c_filesize,
714 (unsigned long *) &hd.c_dev, (unsigned long *) &hd.c_devmin,
715 (unsigned long *) &hd.c_rdev, (unsigned long *) &hd.c_rdevmin,
716 &hd.c_namesize, &hd.c_chksum) < 14)
717 {
718 message (D_ERROR, MSG_ERROR, _("Corrupted cpio header encountered in\n%s"), super->name);
719 return STATUS_FAIL;
720 }
721
722 if ((arch->type == CPIO_NEWC && hd.c_magic != 070701) ||
723 (arch->type == CPIO_CRC && hd.c_magic != 070702))
724 return STATUS_FAIL;
725
726 if (hd.c_namesize == 0 || hd.c_namesize > MC_MAXPATHLEN)
727 {
728 message (D_ERROR, MSG_ERROR, _("Corrupted cpio header encountered in\n%s"), super->name);
729 return STATUS_FAIL;
730 }
731
732 name = g_malloc (hd.c_namesize);
733 len = mc_read (arch->fd, name, hd.c_namesize);
734
735 if ((len == -1) || ((unsigned long) len < hd.c_namesize))
736 {
737 g_free (name);
738 return STATUS_EOF;
739 }
740 name[hd.c_namesize - 1] = '\0';
741 CPIO_POS (super) += len;
742 cpio_skip_padding (super);
743
744 if (strcmp ("TRAILER!!!", name) == 0)
745 {
746 g_free (name);
747 return STATUS_TRAIL;
748 }
749
750 u.st.st_dev = makedev (hd.c_dev, hd.c_devmin);
751 u.st.st_ino = hd.c_ino;
752 u.st.st_mode = hd.c_mode;
753 u.st.st_nlink = hd.c_nlink;
754 u.st.st_uid = hd.c_uid;
755 u.st.st_gid = hd.c_gid;
756 #ifdef HAVE_STRUCT_STAT_ST_RDEV
757 u.st.st_rdev = makedev (hd.c_rdev, hd.c_rdevmin);
758 #endif
759 u.st.st_size = hd.c_filesize;
760 #ifdef HAVE_STRUCT_STAT_ST_MTIM
761 u.st.st_atim.tv_nsec = u.st.st_mtim.tv_nsec = u.st.st_ctim.tv_nsec = 0;
762 #endif
763 u.st.st_atime = u.st.st_mtime = u.st.st_ctime = hd.c_mtime;
764
765 return cpio_create_entry (me, super, &u.st, name);
766 }
767
768
769
770
771 static int
772 cpio_open_archive (struct vfs_s_super *super, const vfs_path_t * vpath,
773 const vfs_path_element_t * vpath_element)
774 {
775 (void) vpath_element;
776
777 if (cpio_open_cpio_file (vpath_element->class, super, vpath) == -1)
778 return -1;
779
780 while (TRUE)
781 {
782 ssize_t status;
783
784 status = cpio_read_head (vpath_element->class, super);
785 if (status < 0)
786 return (-1);
787
788 switch (status)
789 {
790 case STATUS_EOF:
791 {
792 message (D_ERROR, MSG_ERROR, _("Unexpected end of file\n%s"),
793 vfs_path_as_str (vpath));
794 return 0;
795 }
796 case STATUS_OK:
797 continue;
798 case STATUS_TRAIL:
799 break;
800 default:
801 break;
802 }
803 break;
804 }
805
806 return 0;
807 }
808
809
810
811
812 static void *
813 cpio_super_check (const vfs_path_t * vpath)
814 {
815 static struct stat sb;
816 int stat_result;
817
818 stat_result = mc_stat (vpath, &sb);
819 return (stat_result == 0 ? &sb : NULL);
820 }
821
822
823
824 static int
825 cpio_super_same (const vfs_path_element_t * vpath_element, struct vfs_s_super *parc,
826 const vfs_path_t * vpath, void *cookie)
827 {
828 struct stat *archive_stat = cookie;
829
830 (void) vpath_element;
831
832 if (strcmp (parc->name, vfs_path_as_str (vpath)))
833 return 0;
834
835
836 if (parc != NULL && CPIO_SUPER (parc)->st.st_mtime < archive_stat->st_mtime)
837 {
838
839 vfs_cpiofs_ops->free ((vfsid) parc);
840 vfs_rmstamp (vfs_cpiofs_ops, (vfsid) parc);
841 return 2;
842 }
843
844 vfs_stamp (vfs_cpiofs_ops, (vfsid) parc);
845 return 1;
846 }
847
848
849
850 static ssize_t
851 cpio_read (void *fh, char *buffer, size_t count)
852 {
853 vfs_file_handler_t *file = VFS_FILE_HANDLER (fh);
854 struct vfs_class *me = VFS_FILE_HANDLER_SUPER (fh)->me;
855 int fd = CPIO_SUPER (VFS_FILE_HANDLER_SUPER (fh))->fd;
856 off_t begin = file->ino->data_offset;
857 ssize_t res;
858
859 if (mc_lseek (fd, begin + file->pos, SEEK_SET) != begin + file->pos)
860 ERRNOR (EIO, -1);
861
862 count = MIN (count, (size_t) (file->ino->st.st_size - file->pos));
863
864 res = mc_read (fd, buffer, count);
865 if (res == -1)
866 ERRNOR (errno, -1);
867
868 file->pos += res;
869 return res;
870 }
871
872
873
874 static int
875 cpio_fh_open (struct vfs_class *me, vfs_file_handler_t * fh, int flags, mode_t mode)
876 {
877 (void) fh;
878 (void) mode;
879
880 if ((flags & O_ACCMODE) != O_RDONLY)
881 ERRNOR (EROFS, -1);
882 return 0;
883 }
884
885
886
887
888
889 void
890 vfs_init_cpiofs (void)
891 {
892
893 vfs_init_subclass (&cpio_subclass, "cpiofs", VFSF_READONLY, "ucpio");
894 vfs_cpiofs_ops->read = cpio_read;
895 vfs_cpiofs_ops->setctl = NULL;
896 cpio_subclass.archive_check = cpio_super_check;
897 cpio_subclass.archive_same = cpio_super_same;
898 cpio_subclass.new_archive = cpio_new_archive;
899 cpio_subclass.open_archive = cpio_open_archive;
900 cpio_subclass.free_archive = cpio_free_archive;
901 cpio_subclass.fh_open = cpio_fh_open;
902 vfs_register_class (vfs_cpiofs_ops);
903 }
904
905