# Source code

    001/*
    002 * Licensed to the Apache Software Foundation (ASF) under one
    003 * or more contributor license agreements.  See the NOTICE file
    004 * distributed with this work for additional information
    005 * regarding copyright ownership.  The ASF licenses this file
    006 * to you under the Apache License, Version 2.0 (the
    007 * "License"); you may not use this file except in compliance
    008 * with the License.  You may obtain a copy of the License at
    009 *
    010 * http://www.apache.org/licenses/LICENSE-2.0
    011 *
    012 * Unless required by applicable law or agreed to in writing,
    013 * software distributed under the License is distributed on an
    014 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    015 * KIND, either express or implied.  See the License for the
    016 * specific language governing permissions and limitations
    017 * under the License.
    018 */
    019package org.apache.commons.compress.archivers.dump;
    020
    021import java.util.Collections;
    022import java.util.Date;
    023import java.util.EnumSet;
    024import java.util.HashSet;
    025import java.util.Set;
    026import org.apache.commons.compress.archivers.ArchiveEntry;
    027
    028/**
    029 * This class represents an entry in a Dump archive. It consists
    030 * of the entry's header, the entry's File and any extended attributes.
    031 * <p>
    032 * DumpEntries that are created from the header bytes read from
    033 * an archive are instantiated with the DumpArchiveEntry( byte[] )
    034 * constructor. These entries will be used when extracting from
    035 * or listing the contents of an archive. These entries have their
    036 * header filled in using the header bytes. They also set the File
    037 * to null, since they reference an archive entry not a file.
    038 * <p>
    039 * DumpEntries can also be constructed from nothing but a name.
    040 * This allows the programmer to construct the entry by hand, for
    041 * instance when only an InputStream is available for writing to
    042 * the archive, and the header information is constructed from
    043 * other information. In this case the header fields are set to
    044 * defaults and the File is set to null.
    045 *
    046 * <p>
    047 * The C structure for a Dump Entry's header is:
    048 * <pre>
    049 * #define TP_BSIZE    1024          // size of each file block
    050 * #define NTREC       10            // number of blocks to write at once
    051 * #define HIGHDENSITYTREC 32        // number of blocks to write on high-density tapes
    052 * #define TP_NINDIR   (TP_BSIZE/2)  // number if indirect inodes in record
    053 * #define TP_NINOS    (TP_NINDIR / sizeof (int32_t))
    054 * #define LBLSIZE     16
    055 * #define NAMELEN     64
    056 *
    057 * #define OFS_MAGIC     (int)60011  // old format magic value
    058 * #define NFS_MAGIC     (int)60012  // new format magic value
    059 * #define FS_UFS2_MAGIC (int)0x19540119
    060 * #define CHECKSUM      (int)84446  // constant used in checksum algorithm
    061 *
    062 * struct  s_spcl {
    063 *   int32_t c_type;             // record type (see below)
    064 *   int32_t <b>c_date</b>;             // date of this dump
    065 *   int32_t <b>c_ddate</b>;            // date of previous dump
    066 *   int32_t c_volume;           // dump volume number
    067 *   u_int32_t c_tapea;          // logical block of this record
    068 *   dump_ino_t c_ino;           // number of inode
    069 *   int32_t <b>c_magic</b>;            // magic number (see above)
    070 *   int32_t c_checksum;         // record checksum
    071 * #ifdef  __linux__
    072 *   struct  new_bsd_inode c_dinode;
    073 * #else
    074 * #ifdef sunos
    075 *   struct  new_bsd_inode c_dinode;
    076 * #else
    077 *   struct  dinode  c_dinode;   // ownership and mode of inode
    078 * #endif
    079 * #endif
    080 *   int32_t c_count;            // number of valid c_addr entries
    081 *   union u_data c_data;        // see above
    082 *   char    <b>c_label[LBLSIZE]</b>;   // dump label
    083 *   int32_t <b>c_level</b>;            // level of this dump
    084 *   char    <b>c_filesys[NAMELEN]</b>; // name of dumpped file system
    085 *   char    <b>c_dev[NAMELEN]</b>;     // name of dumpped device
    086 *   char    <b>c_host[NAMELEN]</b>;    // name of dumpped host
    087 *   int32_t c_flags;            // additional information (see below)
    088 *   int32_t c_firstrec;         // first record on volume
    089 *   int32_t c_ntrec;            // blocksize on volume
    090 *   int32_t c_extattributes;    // additional inode info (see below)
    091 *   int32_t c_spare[30];        // reserved for future uses
    092 * } s_spcl;
    093 *
    094 * //
    095 * // flag values
    096 * //
    097 * #define DR_NEWHEADER     0x0001  // new format tape header
    098 * #define DR_NEWINODEFMT   0x0002  // new format inodes on tape
    099 * #define DR_COMPRESSED    0x0080  // dump tape is compressed
    100 * #define DR_METAONLY      0x0100  // only the metadata of the inode has been dumped
    101 * #define DR_INODEINFO     0x0002  // [SIC] TS_END header contains c_inos information
    102 * #define DR_EXTATTRIBUTES 0x8000
    103 *
    104 * //
    105 * // extattributes inode info
    106 * //
    107 * #define EXT_REGULAR         0
    108 * #define EXT_MACOSFNDRINFO   1
    109 * #define EXT_MACOSRESFORK    2
    110 * #define EXT_XATTR           3
    111 *
    112 * // used for EA on tape
    113 * #define EXT2_GOOD_OLD_INODE_SIZE    128
    114 * #define EXT2_XATTR_MAGIC        0xEA020000  // block EA
    115 * #define EXT2_XATTR_MAGIC2       0xEA020001  // in inode EA
    116 * </pre>
    117 * <p>
    118 * The fields in <b>bold</b> are the same for all blocks. (This permitted
    119 * multiple dumps to be written to a single tape.)
    120 * </p>
    121 *
    122 * <p>
    123 * The C structure for the inode (file) information is:
    124 * <pre>
    125 * struct bsdtimeval {           //  **** alpha-*-linux is deviant
    126 *   __u32   tv_sec;
    127 *   __u32   tv_usec;
    128 * };
    129 *
    130 * #define NDADDR      12
    131 * #define NIADDR       3
    132 *
    133 * //
    134 * // This is the new (4.4) BSD inode structure
    135 * // copied from the FreeBSD 2.0 &lt;ufs/ufs/dinode.h&gt; include file
    136 * //
    137 * struct new_bsd_inode {
    138 *   __u16       di_mode;           // file type, standard Unix permissions
    139 *   __s16       di_nlink;          // number of hard links to file.
    140 *   union {
    141 *      __u16       oldids[2];
    142 *      __u32       inumber;
    143 *   }           di_u;
    144 *   u_quad_t    di_size;           // file size
    145 *   struct bsdtimeval   di_atime;  // time file was last accessed
    146 *   struct bsdtimeval   di_mtime;  // time file was last modified
    147 *   struct bsdtimeval   di_ctime;  // time file was created
    148 *   __u32       di_db[NDADDR];
    149 *   __u32       di_ib[NIADDR];
    150 *   __u32       di_flags;          //
    151 *   __s32       di_blocks;         // number of disk blocks
    152 *   __s32       di_gen;            // generation number
    153 *   __u32       di_uid;            // user id (see /etc/passwd)
    154 *   __u32       di_gid;            // group id (see /etc/group)
    155 *   __s32       di_spare[2];       // unused
    156 * };
    157 * </pre>
    158 * <p>
    159 * It is important to note that the header DOES NOT have the name of the
    160 * file. It can't since hard links mean that you may have multiple filenames
    161 * for a single physical file. You must read the contents of the directory
    162 * entries to learn the mapping(s) from filename to inode.
    163 * </p>
    164 *
    165 * <p>
    166 * The C structure that indicates if a specific block is a real block
    167 * that contains data or is a sparse block that is not persisted to the
    168 * disk is:</p>
    169 * <pre>
    170 * #define TP_BSIZE    1024
    171 * #define TP_NINDIR   (TP_BSIZE/2)
    172 *
    173 * union u_data {
    174 *   char    s_addrs[TP_NINDIR]; // 1 =&gt; data; 0 =&gt; hole in inode
    175 *   int32_t s_inos[TP_NINOS];   // table of first inode on each volume
    176 * } u_data;
    177 * </pre>
    178 *
    179 * @NotThreadSafe
    180 */
    181public class DumpArchiveEntry implements ArchiveEntry {
    182    private String name;
    183    private TYPE type = TYPE.UNKNOWN;
    184    private int mode;
    185    private Set<PERMISSION> permissions = Collections.emptySet();
    186    private long size;
    187    private long atime;
    188    private long mtime;
    189    private int uid;
    190    private int gid;
    191
    192    /**
    193     * Currently unused
    194     */
    195    private final DumpArchiveSummary summary = null;
    196
    197    // this information is available from standard index.
    198    private final TapeSegmentHeader header = new TapeSegmentHeader();
    199    private String simpleName;
    200    private String originalName;
    201
    202    // this information is available from QFA index
    203    private int volume;
    204    private long offset;
    205    private int ino;
    206    private int nlink;
    207    private long ctime;
    208    private int generation;
    209    private boolean isDeleted;
    210
    211    /**
    212     * Default constructor.
    213     */
    214    public DumpArchiveEntry() {
    215    }
    216
    217    /**
    218     * Constructor taking only filename.
    219     * @param name pathname
    220     * @param simpleName actual filename.
    221     */
    222    public DumpArchiveEntry(final String name, final String simpleName) {
    223        setName(name);
    224        this.simpleName = simpleName;
    225    }
    226
    227    /**
    228     * Constructor taking name, inode and type.
    229     *
    230     * @param name the name
    231     * @param simpleName the simple name
    232     * @param ino the ino
    233     * @param type the type
    234     */
    235    protected DumpArchiveEntry(final String name, final String simpleName, final int ino,
    236                               final TYPE type) {
    237        setType(type);
    238        setName(name);
    239        this.simpleName = simpleName;
    240        this.ino = ino;
    241        this.offset = 0;
    242    }
    243
    244    /**
    245     * Returns the path of the entry.
    246     * @return the path of the entry.
    247     */
    248    public String getSimpleName() {
    249        return simpleName;
    250    }
    251
    252    /**
    253     * Sets the path of the entry.
    254     * @param simpleName the simple name
    255     */
    256    protected void setSimpleName(final String simpleName) {
    257        this.simpleName = simpleName;
    258    }
    259
    260    /**
    261     * Returns the ino of the entry.
    262     * @return the ino
    263     */
    264    public int getIno() {
    265        return header.getIno();
    266    }
    267
    268    /**
    269     * Return the number of hard links to the entry.
    270     * @return the number of hard links
    271     */
    272    public int getNlink() {
    273        return nlink;
    274    }
    275
    276    /**
    277     * Set the number of hard links.
    278     * @param nlink the number of hard links
    279     */
    280    public void setNlink(final int nlink) {
    281        this.nlink = nlink;
    282    }
    283
    284    /**
    285     * Get file creation time.
    286     * @return the creation time
    287     */
    288    public Date getCreationTime() {
    289        return new Date(ctime);
    290    }
    291
    292    /**
    293     * Set the file creation time.
    294     * @param ctime the creation time
    295     */
    296    public void setCreationTime(final Date ctime) {
    297        this.ctime = ctime.getTime();
    298    }
    299
    300    /**
    301     * Return the generation of the file.
    302     * @return the generation
    303     */
    304    public int getGeneration() {
    305        return generation;
    306    }
    307
    308    /**
    309     * Set the generation of the file.
    310     * @param generation the generation
    311     */
    312    public void setGeneration(final int generation) {
    313        this.generation = generation;
    314    }
    315
    316    /**
    317     * Has this file been deleted? (On valid on incremental dumps.)
    318     * @return whether the file has been deleted
    319     */
    320    public boolean isDeleted() {
    321        return isDeleted;
    322    }
    323
    324    /**
    325     * Set whether this file has been deleted.
    326     * @param isDeleted whether the file has been deleted
    327     */
    328    public void setDeleted(final boolean isDeleted) {
    329        this.isDeleted = isDeleted;
    330    }
    331
    332    /**
    333     * Return the offset within the archive
    334     * @return the offset
    335     */
    336    public long getOffset() {
    337        return offset;
    338    }
    339
    340    /**
    341     * Set the offset within the archive.
    342     * @param offset the offset
    343     */
    344    public void setOffset(final long offset) {
    345        this.offset = offset;
    346    }
    347
    348    /**
    349     * Return the tape volume where this file is located.
    350     * @return the volume
    351     */
    352    public int getVolume() {
    353        return volume;
    354    }
    355
    356    /**
    357     * Set the tape volume.
    358     * @param volume the volume
    359     */
    360    public void setVolume(final int volume) {
    361        this.volume = volume;
    362    }
    363
    364    /**
    365     * Return the type of the tape segment header.
    366     * @return the segment header
    367     */
    368    public DumpArchiveConstants.SEGMENT_TYPE getHeaderType() {
    369        return header.getType();
    370    }
    371
    372    /**
    373     * Return the number of records in this segment.
    374     * @return the number of records
    375     */
    376    public int getHeaderCount() {
    377        return header.getCount();
    378    }
    379
    380    /**
    381     * Return the number of sparse records in this segment.
    382     * @return the number of sparse records
    383     */
    384    public int getHeaderHoles() {
    385        return header.getHoles();
    386    }
    387
    388    /**
    389     * Is this a sparse record?
    390     * @param idx index of the record to check
    391     * @return whether this is a sparse record
    392     */
    393    public boolean isSparseRecord(final int idx) {
    394        return (header.getCdata(idx) & 0x01) == 0;
    395    }
    396
    397    @Override
    398    public int hashCode() {
    399        return ino;
    400    }
    401
    402    @Override
    403    public boolean equals(final Object o) {
    404        if (o == this) {
    405            return true;
    406        } else if (o == null || !o.getClass().equals(getClass())) {
    407            return false;
    408        }
    409
    410        final DumpArchiveEntry rhs = (DumpArchiveEntry) o;
    411
    412        if ((header == null) || (rhs.header == null)) {
    413            return false;
    414        }
    415
    416        if (ino != rhs.ino) {
    417            return false;
    418        }
    419
    420        if ((summary == null && rhs.summary != null)
    421            || (summary != null && !summary.equals(rhs.summary))) {
    422            return false;
    423        }
    424
    425        return true;
    426    }
    427
    428    @Override
    429    public String toString() {
    430        return getName();
    431    }
    432
    433    /**
    434     * Populate the dump archive entry and tape segment header with
    435     * the contents of the buffer.
    436     *
    437     * @param buffer buffer to read content from
    438     */
    439    static DumpArchiveEntry parse(final byte[] buffer) {
    440        final DumpArchiveEntry entry = new DumpArchiveEntry();
    441        final TapeSegmentHeader header = entry.header;
    442
    443        header.type = DumpArchiveConstants.SEGMENT_TYPE.find(DumpArchiveUtil.convert32(
    444                    buffer, 0));
    445
    446        //header.dumpDate = new Date(1000L * DumpArchiveUtil.convert32(buffer, 4));
    447        //header.previousDumpDate = new Date(1000L * DumpArchiveUtil.convert32(
    448        //            buffer, 8));
    449        header.volume = DumpArchiveUtil.convert32(buffer, 12);
    450        //header.tapea = DumpArchiveUtil.convert32(buffer, 16);
    451        entry.ino = header.ino = DumpArchiveUtil.convert32(buffer, 20);
    452
    453        //header.magic = DumpArchiveUtil.convert32(buffer, 24);
    454        //header.checksum = DumpArchiveUtil.convert32(buffer, 28);
    455        final int m = DumpArchiveUtil.convert16(buffer, 32);
    456
    457        // determine the type of the file.
    458        entry.setType(TYPE.find((m >> 12) & 0x0F));
    459
    460        // determine the standard permissions
    461        entry.setMode(m);
    462
    463        entry.nlink = DumpArchiveUtil.convert16(buffer, 34);
    464        // inumber, oldids?
    465        entry.setSize(DumpArchiveUtil.convert64(buffer, 40));
    466
    467        long t = (1000L * DumpArchiveUtil.convert32(buffer, 48)) +
    468            (DumpArchiveUtil.convert32(buffer, 52) / 1000);
    469        entry.setAccessTime(new Date(t));
    470        t = (1000L * DumpArchiveUtil.convert32(buffer, 56)) +
    471            (DumpArchiveUtil.convert32(buffer, 60) / 1000);
    472        entry.setLastModifiedDate(new Date(t));
    473        t = (1000L * DumpArchiveUtil.convert32(buffer, 64)) +
    474            (DumpArchiveUtil.convert32(buffer, 68) / 1000);
    475        entry.ctime = t;
    476
    477        // db: 72-119 - direct blocks
    478        // id: 120-131 - indirect blocks
    479        //entry.flags = DumpArchiveUtil.convert32(buffer, 132);
    480        //entry.blocks = DumpArchiveUtil.convert32(buffer, 136);
    481        entry.generation = DumpArchiveUtil.convert32(buffer, 140);
    482        entry.setUserId(DumpArchiveUtil.convert32(buffer, 144));
    483        entry.setGroupId(DumpArchiveUtil.convert32(buffer, 148));
    484        // two 32-bit spare values.
    485        header.count = DumpArchiveUtil.convert32(buffer, 160);
    486
    487        header.holes = 0;
    488
    489        for (int i = 0; (i < 512) && (i < header.count); i++) {
    490            if (buffer[164 + i] == 0) {
    491                header.holes++;
    492            }
    493        }
    494
    495        System.arraycopy(buffer, 164, header.cdata, 0, 512);
    496
    497        entry.volume = header.getVolume();
    498
    499        //entry.isSummaryOnly = false;
    500        return entry;
    501    }
    502
    503    /**
    504     * Update entry with information from next tape segment header.
    505     */
    506    void update(final byte[] buffer) {
    507        header.volume = DumpArchiveUtil.convert32(buffer, 16);
    508        header.count = DumpArchiveUtil.convert32(buffer, 160);
    509
    510        header.holes = 0;
    511
    512        for (int i = 0; (i < 512) && (i < header.count); i++) {
    513            if (buffer[164 + i] == 0) {
    514                header.holes++;
    515            }
    516        }
    517
    518        System.arraycopy(buffer, 164, header.cdata, 0, 512);
    519    }
    520
    521    /**
    522     * Archive entry as stored on tape. There is one TSH for (at most)
    523     * every 512k in the file.
    524     */
    525    static class TapeSegmentHeader {
    526        private DumpArchiveConstants.SEGMENT_TYPE type;
    527        private int volume;
    528        private int ino;
    529        private int count;
    530        private int holes;
    531        private final byte[] cdata = new byte[512]; // map of any 'holes'
    532
    533        public DumpArchiveConstants.SEGMENT_TYPE getType() {
    534            return type;
    535        }
    536
    537        public int getVolume() {
    538            return volume;
    539        }
    540
    541        public int getIno() {
    542            return ino;
    543        }
    544
    545        void setIno(final int ino) {
    546            this.ino = ino;
    547        }
    548
    549        public int getCount() {
    550            return count;
    551        }
    552
    553        public int getHoles() {
    554            return holes;
    555        }
    556
    557        public int getCdata(final int idx) {
    558            return cdata[idx];
    559        }
    560    }
    561
    562    /**
    563     * Returns the name of the entry.
    564     * @return the name of the entry.
    565     */
    566    @Override
    567    public String getName() {
    568        return name;
    569    }
    570
    571    /**
    572     * Returns the unmodified name of the entry.
    573     * @return the name of the entry.
    574     */
    575    String getOriginalName() {
    576        return originalName;
    577    }
    578
    579    /**
    580     * Sets the name of the entry.
    581     * @param name the name
    582     */
    583    public final void setName(String name) {
    584        this.originalName = name;
    585        if (name != null) {
    586            if (isDirectory() && !name.endsWith("/")) {
    587                name += "/";
    588            }
    589            if (name.startsWith("./")) {
    590                name = name.substring(2);
    591            }
    592        }
    593        this.name = name;
    594    }
    595
    596    /**
    597     * The last modified date.
    598     * @return the last modified date
    599     */
    600    @Override
    601    public Date getLastModifiedDate() {
    602        return new Date(mtime);
    603    }
    604
    605    /**
    606     * Is this a directory?
    607     * @return whether this is a directory
    608     */
    609    @Override
    610    public boolean isDirectory() {
    611        return type == TYPE.DIRECTORY;
    612    }
    613
    614    /**
    615     * Is this a regular file?
    616     * @return whether this is a regular file
    617     */
    618    public boolean isFile() {
    619        return type == TYPE.FILE;
    620    }
    621
    622    /**
    623     * Is this a network device?
    624     * @return whether this is a socket
    625     */
    626    public boolean isSocket() {
    627        return type == TYPE.SOCKET;
    628    }
    629
    630    /**
    631     * Is this a character device?
    632     * @return whether this is a character device
    633     */
    634    public boolean isChrDev() {
    635        return type == TYPE.CHRDEV;
    636    }
    637
    638    /**
    639     * Is this a block device?
    640     * @return whether this is a block device
    641     */
    642    public boolean isBlkDev() {
    643        return type == TYPE.BLKDEV;
    644    }
    645
    646    /**
    647     * Is this a fifo/pipe?
    648     * @return whether this is a fifo
    649     */
    650    public boolean isFifo() {
    651        return type == TYPE.FIFO;
    652    }
    653
    654    /**
    655     * Get the type of the entry.
    656     * @return the type
    657     */
    658    public TYPE getType() {
    659        return type;
    660    }
    661
    662    /**
    663     * Set the type of the entry.
    664     * @param type the type
    665     */
    666    public void setType(final TYPE type) {
    667        this.type = type;
    668    }
    669
    670    /**
    671     * Return the access permissions on the entry.
    672     * @return the access permissions
    673     */
    674    public int getMode() {
    675        return mode;
    676    }
    677
    678    /**
    679     * Set the access permissions on the entry.
    680     * @param mode the access permissions
    681     */
    682    public void setMode(final int mode) {
    683        this.mode = mode & 07777;
    684        this.permissions = PERMISSION.find(mode);
    685    }
    686
    687    /**
    688     * Returns the permissions on the entry.
    689     * @return the permissions
    690     */
    691    public Set<PERMISSION> getPermissions() {
    692        return permissions;
    693    }
    694
    695    /**
    696     * Returns the size of the entry.
    697     * @return the size
    698     */
    699    @Override
    700    public long getSize() {
    701        return isDirectory() ? SIZE_UNKNOWN : size;
    702    }
    703
    704    /**
    705     * Returns the size of the entry as read from the archive.
    706     */
    707    long getEntrySize() {
    708        return size;
    709    }
    710
    711    /**
    712     * Set the size of the entry.
    713     * @param size the size
    714     */
    715    public void setSize(final long size) {
    716        this.size = size;
    717    }
    718
    719    /**
    720     * Set the time the file was last modified.
    721     * @param mtime the last modified time
    722     */
    723    public void setLastModifiedDate(final Date mtime) {
    724        this.mtime = mtime.getTime();
    725    }
    726
    727    /**
    728     * Returns the time the file was last accessed.
    729     * @return the access time
    730     */
    731    public Date getAccessTime() {
    732        return new Date(atime);
    733    }
    734
    735    /**
    736     * Set the time the file was last accessed.
    737     * @param atime the access time
    738     */
    739    public void setAccessTime(final Date atime) {
    740        this.atime = atime.getTime();
    741    }
    742
    743    /**
    744     * Return the user id.
    745     * @return the user id
    746     */
    747    public int getUserId() {
    748        return uid;
    749    }
    750
    751    /**
    752     * Set the user id.
    753     * @param uid the user id
    754     */
    755    public void setUserId(final int uid) {
    756        this.uid = uid;
    757    }
    758
    759    /**
    760     * Return the group id
    761     * @return the group id
    762     */
    763    public int getGroupId() {
    764        return gid;
    765    }
    766
    767    /**
    768     * Set the group id.
    769     * @param gid the group id
    770     */
    771    public void setGroupId(final int gid) {
    772        this.gid = gid;
    773    }
    774
    775    public enum TYPE {
    776        WHITEOUT(14),
    777        SOCKET(12),
    778        LINK(10),
    779        FILE(8),
    780        BLKDEV(6),
    781        DIRECTORY(4),
    782        CHRDEV(2),
    783        FIFO(1),
    784        UNKNOWN(15);
    785
    786        private int code;
    787
    788        private TYPE(final int code) {
    789            this.code = code;
    790        }
    791
    792        public static TYPE find(final int code) {
    793            TYPE type = UNKNOWN;
    794
    795            for (final TYPE t : TYPE.values()) {
    796                if (code == t.code) {
    797                    type = t;
    798                }
    799            }
    800
    801            return type;
    802        }
    803    }
    804
    805    public enum PERMISSION {
    806        SETUID(04000),
    807        SETGUI(02000),
    808        STICKY(01000),
    809        USER_READ(00400),
    810        USER_WRITE(00200),
    811        USER_EXEC(00100),
    812        GROUP_READ(00040),
    813        GROUP_WRITE(00020),
    814        GROUP_EXEC(00010),
    815        WORLD_READ(00004),
    816        WORLD_WRITE(00002),
    817        WORLD_EXEC(00001);
    818
    819        private int code;
    820
    821        private PERMISSION(final int code) {
    822            this.code = code;
    823        }
    824
    825        public static Set<PERMISSION> find(final int code) {
    826            final Set<PERMISSION> set = new HashSet<>();
    827
    828            for (final PERMISSION p : PERMISSION.values()) {
    829                if ((code & p.code) == p.code) {
    830                    set.add(p);
    831                }
    832            }
    833
    834            if (set.isEmpty()) {
    835                return Collections.emptySet();
    836            }
    837
    838            return EnumSet.copyOf(set);
    839        }
    840    }
    841}