vfs/cpio.c

   1 /* Virtual File System: GNU Tar file system.
   2    Copyright (C) 2000 The Free Software Foundation
   3
   4    Written by: 2000 Jan Hudec
   5
   6    $Id$
   7
   8    This program is free software; you can redistribute it and/or
   9    modify it under the terms of the GNU Library General Public License
  10    as published by the Free Software Foundation; either version 2 of
  11    the License, or (at your option) any later version.
  12
  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 Library General Public License for more details.
  17
  18    You should have received a copy of the GNU Library General Public
  19    License along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 #include <config.h>
  23 #include <glib.h>
  24 #include <errno.h>
  25 #include "utilvfs.h"
  26 #include "xdirentry.h"
  27
  28 /* #include "utilvfs.h" */
  29
  30 #include "../src/dialog.h"
  31 /* #include "cpio.h" */
  32 #include "names.h"
  33
  34 enum {
  35     STATUS_START,
  36     STATUS_OK,
  37     STATUS_TRAIL,
  38     STATUS_FAIL,
  39     STATUS_EOF
  40 };
  41
  42 enum {
  43     CPIO_UNKNOWN = 0, /* Not determined yet */
  44     CPIO_BIN,         /* Binary format */
  45     CPIO_BINRE,       /* Binary format, reverse endianity */
  46     CPIO_OLDC,        /* Old ASCII format */
  47     CPIO_NEWC,        /* New ASCII format */
  48     CPIO_CRC          /* New ASCII format + CRC */
  49 };
  50
  51 struct old_cpio_header
  52 {
  53   unsigned short c_magic;
  54   short c_dev;
  55   unsigned short c_ino;
  56   unsigned short c_mode;
  57   unsigned short c_uid;
  58   unsigned short c_gid;
  59   unsigned short c_nlink;
  60   short c_rdev;
  61   unsigned short c_mtimes[2];
  62   unsigned short c_namesize;
  63   unsigned short c_filesizes[2];
  64 };
  65
  66 struct new_cpio_header
  67 {
  68   unsigned short c_magic;
  69   unsigned long c_ino;
  70   unsigned long c_mode;
  71   unsigned long c_uid;
  72   unsigned long c_gid;
  73   unsigned long c_nlink;
  74   unsigned long c_mtime;
  75   unsigned long c_filesize;
  76   long c_dev;
  77   long c_devmin;
  78   long c_rdev;
  79   long c_rdevmin;
  80   unsigned long c_namesize;
  81   unsigned long c_chksum;
  82 };
  83
  84 struct defer_inode {
  85     struct defer_inode *next;
  86     unsigned long inumber;
  87     unsigned short device;
  88     vfs_s_inode *inode;
  89 };
  90
  91 static int cpio_position;
  92
  93 static int cpio_find_head(vfs *me, vfs_s_super *super);
  94 static int cpio_read_bin_head(vfs *me, vfs_s_super *super);
  95 static int cpio_read_oldc_head(vfs *me, vfs_s_super *super);
  96 static int cpio_read_crc_head(vfs *me, vfs_s_super *super);
  97 static int cpio_create_entry(vfs *me, vfs_s_super *super, struct stat *stat, char *name);
  98 static int cpio_read(void *fh, char *buffer, int count);
  99
 100 #define CPIO_POS(super) cpio_position
 101 /* If some time reentrancy should be needed change it to */
 102 /* #define CPIO_POS(super) (super)->u.cpio.fd */
 103
 104 #define CPIO_SEEK_SET(super, where) mc_lseek((super)->u.cpio.fd, CPIO_POS(super) = (where), SEEK_SET)
 105 #define CPIO_SEEK_CUR(super, where) mc_lseek((super)->u.cpio.fd, CPIO_POS(super) += (where), SEEK_SET)
 106
 107 static struct defer_inode * defer_find(struct defer_inode *l, struct defer_inode *i)
 108 {
 109     if(!l) return NULL;
 110     return l->inumber == i->inumber && l->device == i->device ? l :
 111            defer_find(l->next, i);
 112 }
 113
 114 static int cpio_skip_padding(vfs_s_super *super)
 115 {
 116     switch(super->u.cpio.type) {
 117     case CPIO_BIN:
 118     case CPIO_BINRE:
 119         return CPIO_SEEK_CUR(super, (2 - (CPIO_POS(super) % 2)) % 2);
 120     case CPIO_NEWC:
 121     case CPIO_CRC:
 122         return CPIO_SEEK_CUR(super, (4 - (CPIO_POS(super) % 4)) % 4);
 123     default:
 124         g_assert_not_reached();
 125         return 42; /* & the compiler is happy :-) */
 126     }
 127 }
 128
 129 static void cpio_free_archive(vfs *me, vfs_s_super *super)
 130 {
 131     if(super->u.cpio.fd != -1)
 132         mc_close(super->u.cpio.fd);
 133 }
 134
 135 static int cpio_open_cpio_file(vfs *me, vfs_s_super *super, char *name)
 136 {
 137     int fd, size, type;
 138     mode_t mode;
 139     vfs_s_inode *root;
 140
 141     if((fd = mc_open(name, O_RDONLY)) == -1) {
 142         message_2s(1, MSG_ERROR, _("Couldn't open cpio archive\n%s"), name);
 143         return -1;
 144     }
 145
 146     super->name = g_strdup(name);
 147     super->u.cpio.fd = -1; /* for now */
 148     mc_stat(name, &(super->u.cpio.stat));
 149     super->u.cpio.type = CPIO_UNKNOWN;
 150
 151     size = is_gunzipable(fd, &type);
 152     if(size > 0) {
 153         char *s;
 154
 155         mc_close(fd);
 156         s = g_strconcat(name, decompress_extension(type), NULL);
 157         if((fd = mc_open(s, O_RDONLY)) == -1) {
 158             message_2s(1, MSG_ERROR, _("Couldn't open cpio archive\n%s"), s);
 159             g_free(s);
 160             return -1;
 161         }
 162         g_free(s);
 163     }
 164
 165     super->u.cpio.fd = fd;
 166     mode = super->u.cpio.stat.st_mode & 07777;
 167     mode |= (mode & 0444) >> 2; /* set eXec where Read is */
 168     mode |= S_IFDIR;
 169
 170     root = vfs_s_new_inode(me, super, &(super->u.cpio.stat));
 171     root->st.st_mode = mode;
 172     root->u.cpio.offset = -1;
 173     root->st.st_nlink++;
 174     root->st.st_dev = MEDATA->rdev++;
 175
 176     vfs_s_add_dots(me, root, NULL);
 177     super->root = root;
 178
 179     CPIO_SEEK_SET(super, 0);
 180
 181     return fd;
 182 }
 183
 184 static int cpio_read_head(vfs *me, vfs_s_super *super)
 185 {
 186     switch(cpio_find_head(me, super)) {
 187     case CPIO_UNKNOWN:
 188         return -1;
 189     case CPIO_BIN:
 190     case CPIO_BINRE:
 191         return cpio_read_bin_head(me, super);
 192     case CPIO_OLDC:
 193         return cpio_read_oldc_head(me, super);
 194     case CPIO_NEWC:
 195     case CPIO_CRC:
 196         return cpio_read_crc_head(me, super);
 197     default:
 198         g_assert_not_reached();
 199         return 42; /* & the compiler is happy :-) */
 200     }
 201 }
 202
 203 #define MAGIC_LENGTH (6) /* How many bytes we have to read ahead */
 204 #define SEEKBACK CPIO_SEEK_CUR(super, ptr - top)
 205 #define RETURN(x) return(super->u.cpio.type = (x))
 206 #define TYPEIS(x) ((super->u.cpio.type == CPIO_UNKNOWN) || (super->u.cpio.type == (x)))
 207 static int cpio_find_head(vfs *me, vfs_s_super *super)
 208 {
 209     char buf[256];
 210     int ptr = 0;
 211     int top = 0;
 212     int tmp;
 213
 214     top = mc_read(super->u.cpio.fd, buf, 256);
 215     CPIO_POS(super) += top;
 216     for(;;) {
 217         if(ptr + MAGIC_LENGTH >= top) {
 218             if(top > 128) {
 219                 memmove(buf, buf + top - 128, 128);
 220                 top = 128;
 221                 ptr -= top - 128;
 222             }
 223             if((tmp = mc_read(super->u.cpio.fd, buf, top)) == 0 || tmp == -1) {
 224                 message_2s(1, MSG_ERROR, _("Premature end of cpio archive\n%s"), super->name);
 225                 cpio_free_archive(me, super);
 226                 return CPIO_UNKNOWN;
 227             }
 228             top += tmp;
 229         }
 230         if(TYPEIS(CPIO_BIN) && ((*(unsigned short *)(buf + ptr)) == 070707)) {
 231             SEEKBACK; RETURN(CPIO_BIN);
 232         } else if(TYPEIS(CPIO_BINRE) && ((*(unsigned short *)(buf + ptr)) == GUINT16_SWAP_LE_BE_CONSTANT(070707))) {
 233             SEEKBACK; RETURN(CPIO_BINRE);
 234         } else if(TYPEIS(CPIO_OLDC) && (!strncmp(buf + ptr, "070707", 6))) {
 235             SEEKBACK; RETURN(CPIO_OLDC);
 236         } else if(TYPEIS(CPIO_NEWC) && (!strncmp(buf + ptr, "070701", 6))) {
 237             SEEKBACK; RETURN(CPIO_NEWC);
 238         } else if(TYPEIS(CPIO_CRC) && (!strncmp(buf + ptr, "070702", 6))) {
 239             SEEKBACK; RETURN(CPIO_CRC);
 240         };
 241         ptr++;
 242     }
 243 }
 244 #undef RETURN
 245 #undef SEEKBACK
 246
 247 #define HEAD_LENGTH (26)
 248 static int cpio_read_bin_head(vfs *me, vfs_s_super *super)
 249 {
 250     struct old_cpio_header buf;
 251     int len;
 252     char *name;
 253     struct stat stat;
 254
 255     if((len = mc_read(super->u.cpio.fd, (char *)&buf, HEAD_LENGTH)) < HEAD_LENGTH)
 256         return STATUS_EOF;
 257     CPIO_POS(super) += len;
 258     if(super->u.cpio.type == CPIO_BINRE) {
 259         int i;
 260         for(i = 0; i < (HEAD_LENGTH >> 1); i++)
 261             ((short *)&buf)[i] = GUINT16_SWAP_LE_BE(((short *)&buf)[i]);
 262     }
 263     g_assert(buf.c_magic == 070707);
 264
 265     name = g_malloc(buf.c_namesize);
 266     if((len = mc_read(super->u.cpio.fd, name, buf.c_namesize)) < buf.c_namesize){
 267         g_free(name);
 268         return STATUS_EOF;
 269     }
 270     CPIO_POS(super) += len;
 271     cpio_skip_padding(super);
 272
 273     if(!strcmp("TRAILER!!!", name)) { /* We got to the last record */
 274         g_free(name);
 275         return STATUS_TRAIL;
 276     }
 277
 278     stat.st_dev = buf.c_dev;
 279     stat.st_ino = buf.c_ino;
 280     stat.st_mode = buf.c_mode;
 281     stat.st_nlink = buf.c_nlink;
 282     stat.st_uid = buf.c_uid;
 283     stat.st_gid = buf.c_gid;
 284     stat.st_rdev = buf.c_rdev;
 285     stat.st_size = (buf.c_filesizes[0] << 16) | buf.c_filesizes[1];
 286     stat.st_atime = stat.st_mtime = stat.st_ctime = (buf.c_mtimes[0] << 16) | buf.c_mtimes[1];
 287
 288     return cpio_create_entry(me, super, &stat, name);
 289 }
 290 #undef HEAD_LENGTH
 291
 292 #define HEAD_LENGTH (76)
 293 static int cpio_read_oldc_head(vfs *me, vfs_s_super *super)
 294 {
 295     struct new_cpio_header hd;
 296     struct stat stat;
 297     char *buf[HEAD_LENGTH + 1];
 298     int len;
 299     char *name;
 300
 301     if((len = mc_read(super->u.cpio.fd, (void *)buf, HEAD_LENGTH)) < HEAD_LENGTH)
 302         return STATUS_EOF;
 303     CPIO_POS(super) += len;
 304     buf[HEAD_LENGTH] = 0;
 305
 306     if(sscanf((void *)buf, "070707%6lo%6lo%6lo%6lo%6lo%6lo%6lo%11lo%6lo%11lo",
 307               &hd.c_dev, &hd.c_ino, &hd.c_mode, &hd.c_uid, &hd.c_gid,
 308               &hd.c_nlink, &hd.c_rdev, &hd.c_mtime,
 309               &hd.c_namesize, &hd.c_filesize) < 10) {
 310         message_2s(1, MSG_ERROR, _("Corrupt cpio header encountered in\n%s"), super->name);
 311         return STATUS_FAIL;
 312     }
 313
 314     name = g_malloc(hd.c_namesize);
 315     if((len = mc_read(super->u.cpio.fd, name, hd.c_namesize)) < hd.c_namesize) {
 316         g_free (name);
 317         return STATUS_EOF;
 318     }
 319     CPIO_POS(super) +=  len;
 320     cpio_skip_padding(super);
 321
 322     if(!strcmp("TRAILER!!!", name)) { /* We got to the last record */
 323         g_free(name);
 324         return STATUS_TRAIL;
 325     }
 326
 327     stat.st_dev = hd.c_dev;
 328     stat.st_ino = hd.c_ino;
 329     stat.st_mode = hd.c_mode;
 330     stat.st_nlink = hd.c_nlink;
 331     stat.st_uid = hd.c_uid;
 332     stat.st_gid = hd.c_gid;
 333     stat.st_rdev = hd.c_rdev;
 334     stat.st_size = hd.c_filesize;
 335     stat.st_atime = stat.st_mtime = stat.st_ctime = hd.c_mtime;
 336
 337     return cpio_create_entry(me, super, &stat, name);
 338 }
 339 #undef HEAD_LENGTH
 340
 341 #define HEAD_LENGTH (110)
 342 static int cpio_read_crc_head(vfs *me, vfs_s_super *super)
 343 {
 344     struct new_cpio_header hd;
 345     struct stat stat;
 346     char buf[HEAD_LENGTH + 1];
 347     int len;
 348     char *name;
 349
 350     if((len = mc_read(super->u.cpio.fd, buf, HEAD_LENGTH)) < HEAD_LENGTH)
 351         return STATUS_EOF;
 352     CPIO_POS(super) += len;
 353     buf[HEAD_LENGTH] = 0;
 354
 355     if(sscanf(buf, "%6ho%8lx%8lx%8lx%8lx%8lx%8lx%8lx%8lx%8lx%8lx%8lx%8lx%8lx",
 356               &hd.c_magic, &hd.c_ino, &hd.c_mode, &hd.c_uid, &hd.c_gid,
 357               &hd.c_nlink,  &hd.c_mtime, &hd.c_filesize,
 358               &hd.c_dev, &hd.c_devmin, &hd.c_rdev, &hd.c_rdevmin,
 359               &hd.c_namesize, &hd.c_chksum) < 14) {
 360         message_2s(1, MSG_ERROR, _("Corrupt cpio header encountered in\n%s"), super->name);
 361         return STATUS_FAIL;
 362     }
 363
 364     if((super->u.cpio.type == CPIO_NEWC && hd.c_magic != 070701) ||
 365        (super->u.cpio.type == CPIO_CRC && hd.c_magic != 070702))
 366         return STATUS_FAIL;
 367
 368     name = g_malloc(hd.c_namesize);
 369     if((len = mc_read(super->u.cpio.fd, name, hd.c_namesize)) < hd.c_namesize){
 370         g_free (name);
 371         return STATUS_EOF;
 372     }
 373     CPIO_POS(super) += len;
 374     cpio_skip_padding(super);
 375
 376     if(!strcmp("TRAILER!!!", name)) { /* We got to the last record */
 377         g_free(name);
 378         return STATUS_TRAIL;
 379     }
 380
 381     stat.st_dev = (hd.c_dev << 8) + hd.c_devmin;
 382     stat.st_ino = hd.c_ino;
 383     stat.st_mode = hd.c_mode;
 384     stat.st_nlink = hd.c_nlink;
 385     stat.st_uid = hd.c_uid;
 386     stat.st_gid = hd.c_gid;
 387     stat.st_rdev = (hd.c_rdev << 8) + hd.c_rdevmin;
 388     stat.st_size = hd.c_filesize;
 389     stat.st_atime = stat.st_mtime = stat.st_ctime = hd.c_mtime;
 390
 391     return cpio_create_entry(me, super, &stat, name);
 392 }
 393
 394 static int cpio_create_entry(vfs *me, vfs_s_super *super, struct stat *stat, char *name)
 395 {
 396     vfs_s_inode *inode = NULL;
 397     vfs_s_inode *root = super->root;
 398     vfs_s_entry *entry = NULL;
 399     char *tn;
 400
 401     switch (stat->st_mode & S_IFMT) { /* For case of HP/UX archives */
 402     case S_IFCHR:
 403     case S_IFBLK:
 404 #ifdef S_IFSOCK
 405     case S_IFSOCK:
 406 #endif
 407 #ifdef S_IFIFO
 408     case S_IFIFO:
 409 #endif
 410         if((stat->st_size != 0) &&
 411            (stat->st_rdev == 0x0001)) {
 412             stat->st_rdev = (unsigned) stat->st_size;
 413             stat->st_size = 0;
 414         }
 415         break;
 416     default:
 417         break;
 418     }
 419
 420     if((stat->st_nlink > 1) &&
 421        (super->u.cpio.type == CPIO_NEWC ||
 422         super->u.cpio.type == CPIO_CRC)) { /* For case of harlinked files */
 423         struct defer_inode i, *l;
 424         i.inumber = stat->st_ino;
 425         i.device = stat->st_dev;
 426         i.inode = NULL;
 427         if((l = defer_find(super->u.cpio.defered, &i)) != NULL) {
 428             inode = l->inode;
 429             if(inode->st.st_size && stat->st_size && (inode->st.st_size != stat->st_size)) {
 430                 message_3s(1, MSG_ERROR, _("Inconsistent hardlinks of\n%s\nin cpio archive\n%s"),
 431                            name, super->name);
 432                 inode = NULL;
 433             }
 434         }
 435     }
 436
 437     while(name[strlen(name)-1] == PATH_SEP) name[strlen(name)-1] = 0;
 438     if((tn = strrchr(name, PATH_SEP))) {
 439         *tn = 0;
 440         root = vfs_s_find_inode(me, root, name, LINK_FOLLOW, FL_MKDIR); /* CHECKME! What function here? */
 441         *tn = PATH_SEP;
 442         tn++;
 443     } else
 444         tn = name;
 445
 446     entry = vfs_s_find_entry_tree(me, root, tn, LINK_FOLLOW, FL_NONE); /* In case entry is already there */
 447
 448     if(entry) { /* This shouldn't happen! (well, it can happen if there is a record for a
 449                    file and than a record for a directory it is in; cpio would die with
 450                    'No such file or directory' is such case) */
 451
 452         if(!S_ISDIR(entry->ino->st.st_mode)) { /* This can be considered archive inconsistency */
 453             message_2s(1, MSG_ERROR, _("%s contains duplicit entries! Skiping!"), super->name);
 454         } else {
 455             entry->ino->st.st_mode = stat->st_mode;
 456             entry->ino->st.st_uid = stat->st_uid;
 457             entry->ino->st.st_gid = stat->st_gid;
 458             entry->ino->st.st_atime = stat->st_atime;
 459             entry->ino->st.st_mtime = stat->st_mtime;
 460             entry->ino->st.st_ctime = stat->st_ctime;
 461         }
 462
 463     } else { /* !entry */
 464
 465         if(!inode) {
 466             inode = vfs_s_new_inode(me, super, stat);
 467             if((stat->st_nlink > 0) &&
 468                (super->u.cpio.type == CPIO_NEWC ||
 469                 super->u.cpio.type == CPIO_CRC)) { /* For case of hardlinked files */
 470                 struct defer_inode *i;
 471                 i = g_new(struct defer_inode, 1);
 472                 i->inumber = stat->st_ino;
 473                 i->device = stat->st_dev;
 474                 i->inode = inode;
 475                 i->next = super->u.cpio.defered;
 476                 super->u.cpio.defered = i;
 477             }
 478         }
 479
 480         if(stat->st_size)
 481             inode->u.cpio.offset = CPIO_POS(super);
 482
 483         entry = vfs_s_new_entry(me, tn, inode);
 484         vfs_s_insert_entry(me, root, entry);
 485
 486         if(S_ISDIR(stat->st_mode))
 487             vfs_s_add_dots(me, inode, root);
 488
 489         if(S_ISLNK(stat->st_mode)) {
 490             inode->linkname = g_malloc(stat->st_size + 1);
 491             if(mc_read(super->u.cpio.fd, inode->linkname, stat->st_size) < stat->st_size) {
 492                 inode->linkname[0] = 0;
 493                 return STATUS_EOF;
 494             }
 495             inode->linkname[stat->st_size] = 0; /* Linkname stored without terminating \0 !!! */
 496             cpio_skip_padding(super);
 497         } else {
 498             CPIO_SEEK_CUR(super, stat->st_size);
 499         }
 500
 501     } /* !entry */
 502
 503     return STATUS_OK;
 504 }
 505
 506 /* Need to CPIO_SEEK_CUR to skip the file at the end of add entry!!!! */
 507
 508 static int cpio_open_archive(vfs *me, vfs_s_super *super, char *name, char *op)
 509 {
 510     int status = STATUS_START;
 511
 512     if(cpio_open_cpio_file(me, super, name) == -1)
 513         return -1;
 514
 515     for(;;) {
 516         status = cpio_read_head(me, super);
 517
 518         switch(status) {
 519         case STATUS_EOF:
 520             message_2s(1, MSG_ERROR, _("Unexpected end of file\n%s"), name);
 521             return 0;
 522         case STATUS_OK:
 523             continue;
 524         case STATUS_TRAIL:
 525             break;
 526         }
 527         break;
 528     }
 529
 530     return 0;
 531 }
 532
 533 /* Remaining functions are exactly same as for tarfs (and were in fact just copied) */
 534 static void *cpio_super_check(vfs *me, char *archive_name, char *op)
 535 {
 536     static struct stat sb;
 537     if(mc_stat(archive_name, &sb))
 538         return NULL;
 539     return &sb;
 540 }
 541
 542 static int cpio_super_same(vfs *me, struct vfs_s_super *parc, char *archive_name, char *op, void *cookie)
 543 {
 544     struct stat *archive_stat = cookie; /* stat of main archive */
 545
 546     if(strcmp(parc->name, archive_name)) return 0;
 547
 548     if(vfs_uid && (!(archive_stat->st_mode & 0004)))
 549         if((archive_stat->st_gid != vfs_gid) || !(archive_stat->st_mode & 0040))
 550             if((archive_stat->st_uid != vfs_uid) || !(archive_stat->st_mode & 0400))
 551                 return 0;
 552 /* Has the cached archive been changed on the disk? */
 553     if(parc->u.cpio.stat.st_mtime < archive_stat->st_mtime) { /* Yes, reload! */
 554         (*vfs_cpiofs_ops.free) ((vfsid) parc);
 555         vfs_rmstamp (&vfs_cpiofs_ops, (vfsid) parc, 0);
 556         return 2;
 557     }
 558     /* Hasn't been modified, give it a new timeout */
 559     vfs_stamp (&vfs_cpiofs_ops, (vfsid) parc);
 560     return 1;
 561 }
 562
 563 static int cpio_read(void *fh, char *buffer, int count)
 564 {
 565     off_t begin = FH->ino->u.tar.data_offset;
 566     int fd = FH_SUPER->u.tar.fd;
 567     vfs *me = FH_SUPER->me;
 568
 569     if (mc_lseek (fd, begin + FH->pos, SEEK_SET) !=
 570         begin + FH->pos) ERRNOR (EIO, -1);
 571
 572     count = MIN(count, FH->ino->st.st_size - FH->pos);
 573
 574     if ((count = mc_read (fd, buffer, count)) == -1) ERRNOR (errno, -1);
 575
 576     FH->pos += count;
 577     return count;
 578 }
 579
 580 static int cpio_ungetlocalcopy(vfs *me, char *path, char *local, int has_changed)
 581 {
 582 /* We do just nothing. (We are read only and do not need to free local,
 583    since it will be freed when tar archive will be freed */
 584     return 0;
 585 }
 586
 587 static int cpio_fh_open(vfs *me, vfs_s_fh *fh, int flags, int mode)
 588 {
 589     if ((flags & O_ACCMODE) != O_RDONLY) ERRNOR (EROFS, -1);
 590     return 0;
 591 }
 592
 593 static struct vfs_s_data cpiofs_data = {
 594     NULL,
 595     0,
 596     0,
 597     NULL,
 598
 599     NULL, /* init inode */
 600     NULL, /* free inode */
 601     NULL, /* init entry */
 602
 603     cpio_super_check,
 604     cpio_super_same,
 605     cpio_open_archive,
 606     cpio_free_archive,
 607
 608     cpio_fh_open,
 609     NULL,
 610
 611     vfs_s_find_entry_tree,
 612     NULL,
 613     NULL
 614     /* ??? */
 615 };
 616
 617 vfs vfs_cpiofs_ops = {
 618     NULL, /* next pointer */
 619     "cpiofs",
 620     0, /* flags */
 621     "ucpio", /* prefix */
 622     &cpiofs_data, /* vfs_s_data */
 623     0, /* errno */
 624
 625     NULL,
 626     NULL,
 627     vfs_s_fill_names,
 628
 629     NULL,
 630
 631     vfs_s_open,
 632     vfs_s_close,
 633     cpio_read,
 634     NULL,
 635
 636     vfs_s_opendir,
 637     vfs_s_readdir,
 638     vfs_s_closedir,
 639     vfs_s_telldir,
 640     vfs_s_seekdir,
 641
 642     vfs_s_stat,
 643     vfs_s_lstat,
 644     vfs_s_fstat,
 645
 646     NULL,
 647     NULL,
 648     NULL,
 649
 650     vfs_s_readlink,
 651     NULL,
 652     NULL,
 653     NULL,
 654
 655     NULL,
 656     vfs_s_chdir,
 657     vfs_s_ferrno,
 658     vfs_s_lseek,
 659     NULL,
 660
 661     vfs_s_getid,
 662     vfs_s_nothingisopen,
 663     vfs_s_free,
 664
 665     vfs_s_getlocalcopy,
 666     cpio_ungetlocalcopy,
 667
 668     NULL,
 669     NULL,
 670     NULL,
 671     NULL
 672
 673 MMAPNULL
 674 };