View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  
18  package org.apache.commons.vfs2.util;
19  
20  import java.util.EnumMap;
21  import java.util.Map;
22  
23  /**
24   * UNIX permissions.
25   *
26   * @since 2.1
27   */
28  public class PosixPermissions {
29  
30      /**
31       * Permission types.
32       */
33      public enum Type {
34          /**
35           * User right readable.
36           */
37          UserReadable(00400),
38  
39          /**
40           * User right writable.
41           */
42          UserWritable(00200),
43  
44          /**
45           * User right executable.
46           */
47          UserExecutable(00100),
48  
49          /**
50           * Group right readable.
51           */
52          GroupReadable(00040),
53  
54          /**
55           * Group right writable.
56           */
57          GroupWritable(00020),
58  
59          /**
60           * Group right executable.
61           */
62          GroupExecutable(00010),
63  
64          /**
65           * Other right readable.
66           */
67          OtherReadable(00004),
68  
69          /**
70           * Other right writable.
71           */
72          OtherWritable(00002),
73  
74          /**
75           * Other right executable.
76           */
77          OtherExecutable(00001);
78  
79          private final int mask;
80  
81          /**
82           * Initialize with the mask
83           */
84          private Type(final int mask) {
85              this.mask = mask;
86          }
87  
88          /**
89           * Return the mask for this permission.
90           *
91           * @return the mask for this permission.
92           */
93          public int getMask() {
94              return this.mask;
95          }
96  
97      }
98  
99      /**
100      * Current permissions.
101      */
102     private final int permissions;
103 
104     /**
105      * If the user is the owner of the file.
106      */
107     private final boolean isOwner;
108 
109     /**
110      * If one user group is the group of the file.
111      */
112     private final boolean isInGroup;
113 
114     /**
115      * Creates a new PosixPermissions object.
116      *
117      * @param permissions The permissions
118      * @param isOwner true if the user is the owner of the file
119      * @param isInGroup true if the user is a group owner of the file
120      */
121     public PosixPermissions(final int permissions, final boolean isOwner, final boolean isInGroup) {
122         this.permissions = permissions;
123         this.isOwner = isOwner;
124         this.isInGroup = isInGroup;
125     }
126 
127     /**
128      * Computes new permission from old ones.
129      *
130      * @param values The permissions to set.
131      * @return The new permissions.
132      */
133     private int computeNewPermissions(final Map<Type, Boolean> values) {
134         int newPerms = this.permissions;
135         for (final Map.Entry<Type, Boolean> entry : values.entrySet()) {
136             final Type type = entry.getKey();
137             if (entry.getValue()) {
138                 newPerms |= type.getMask();
139             } else {
140                 newPerms &= ~type.getMask();
141             }
142         }
143         return newPerms;
144     }
145 
146     /**
147      * Tests whether the bit corresponding to the permission is set.
148      *
149      * @return whether the bit corresponding to the permission is set.
150      */
151     private boolean get(final Type type) {
152         return (type.getMask() & this.permissions) != 0;
153     }
154 
155     /**
156      * Gets permissions.
157      *
158      * @return permissions.
159      */
160     public int getPermissions() {
161         return this.permissions;
162     }
163 
164     /**
165      * Gets whether the permissions are executable.
166      *
167      * @return whether the permissions are executable.
168      */
169     public boolean isExecutable() {
170         if (this.isOwner) {
171             return this.get(Type.UserExecutable);
172         }
173         if (this.isInGroup) {
174             return this.get(Type.GroupExecutable);
175         }
176         return this.get(Type.OtherExecutable);
177     }
178 
179     /**
180      * Gets whether the permissions are readable.
181      *
182      * @return whether the permissions are readable.
183      */
184     public boolean isReadable() {
185         if (this.isOwner) {
186             return this.get(Type.UserReadable);
187         }
188         if (this.isInGroup) {
189             return this.get(Type.GroupReadable);
190         }
191         return this.get(Type.OtherReadable);
192     }
193 
194     /**
195      * Gets whether the permissions are writable.
196      *
197      * @return whether the permissions are writable.
198      */
199     public boolean isWritable() {
200         if (this.isOwner) {
201             return this.get(Type.UserWritable);
202         }
203         if (this.isInGroup) {
204             return this.get(Type.GroupWritable);
205         }
206         return this.get(Type.OtherWritable);
207     }
208 
209     /**
210      * Creates new permissions based on these permissions.
211      *
212      * @param executable Whether the new permissions should be readable.
213      * @param ownerOnly Whether the new permissions are only for the owner.
214      * @return the new permissions.
215      */
216     public int makeExecutable(final boolean executable, final boolean ownerOnly) {
217         final EnumMap<Type, Boolean> map = new EnumMap<>(Type.class);
218         map.put(Type.UserExecutable, executable);
219         if (!ownerOnly) {
220             map.put(Type.GroupExecutable, executable);
221             map.put(Type.OtherExecutable, executable);
222         }
223         return this.computeNewPermissions(map);
224     }
225 
226     /**
227      * Creates new permissions based on these permissions.
228      *
229      * @param readable Whether the new permissions should be readable.
230      * @param ownerOnly Whether the new permissions are only for the owner.
231      * @return the new permissions.
232      */
233     public Integer makeReadable(final boolean readable, final boolean ownerOnly) {
234         final EnumMap<Type, Boolean> map = new EnumMap<>(Type.class);
235         map.put(Type.UserReadable, readable);
236         if (!ownerOnly) {
237             map.put(Type.GroupReadable, readable);
238             map.put(Type.OtherReadable, readable);
239         }
240         return this.computeNewPermissions(map);
241     }
242 
243     /**
244      * Creates new permissions based on these permissions.
245      *
246      * @param writable Whether the new permissions should be readable.
247      * @param ownerOnly Whether the new permissions are only for the owner.
248      * @return the new permissions.
249      */
250     public Integer makeWritable(final boolean writable, final boolean ownerOnly) {
251         final EnumMap<Type, Boolean> map = new EnumMap<>(Type.class);
252         map.put(Type.UserWritable, writable);
253         if (!ownerOnly) {
254             map.put(Type.GroupWritable, writable);
255             map.put(Type.OtherWritable, writable);
256         }
257         return this.computeNewPermissions(map);
258     }
259 }