View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *   http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.codehaus.plexus.archiver.util;
20  
21  import java.util.ArrayList;
22  import java.util.List;
23  
24  import org.codehaus.plexus.util.StringUtils;
25  import org.slf4j.Logger;
26  
27  /**
28   * @author Olivier Lamy
29   * @since 1.0.1
30   */
31  public class FilePermissionUtils {
32  
33      private FilePermissionUtils() {
34          // no op
35      }
36  
37      /**
38       * @param mode file mode "a la" unix ie 664, 440, etc
39       *
40       * @return FilePermission associated to the mode (group permission are ignored here)
41       */
42      public static FilePermission getFilePermissionFromMode(String mode, Logger logger) {
43          if (StringUtils.isBlank(mode)) {
44              throw new IllegalArgumentException(" file mode cannot be empty");
45          }
46          // 4 characters works on some unix (ie solaris)
47          if (mode.length() != 3 && mode.length() != 4) {
48              throw new IllegalArgumentException(" file mode must be 3 or 4 characters");
49          }
50  
51          List<String> modes = new ArrayList<>(mode.length());
52          for (int i = 0, size = mode.length(); i < size; i++) {
53              modes.add(String.valueOf(mode.charAt(i)));
54          }
55  
56          boolean executable = false,
57                  ownerOnlyExecutable = true,
58                  ownerOnlyReadable = true,
59                  readable = false,
60                  ownerOnlyWritable = true,
61                  writable = false;
62  
63          // handle user perm
64          try {
65              int userMode = Integer.parseInt(modes.get(mode.length() == 4 ? 1 : 0));
66              switch (userMode) {
67                  case 0:
68                      break;
69                  case 1:
70                      executable = true;
71                      break;
72                  case 2:
73                      writable = true;
74                      break;
75                  case 3:
76                      writable = true;
77                      executable = true;
78                      break;
79                  case 4:
80                      readable = true;
81                      break;
82                  case 5:
83                      readable = true;
84                      executable = true;
85                      break;
86                  case 6:
87                      readable = true;
88                      writable = true;
89                      break;
90                  case 7:
91                      writable = true;
92                      readable = true;
93                      executable = true;
94                      break;
95                  default:
96                      logger.warn("ignore file mode " + userMode);
97              }
98          } catch (NumberFormatException e) {
99              throw new IllegalArgumentException(" file mode must contains only number " + mode);
100         }
101 
102         // handle all perm
103         try {
104             int allMode = Integer.parseInt(modes.get(mode.length() == 4 ? 3 : 2));
105             switch (allMode) {
106                 case 0:
107                     break;
108                 case 1:
109                     executable = true;
110                     ownerOnlyExecutable = false;
111                     break;
112                 case 2:
113                     writable = true;
114                     ownerOnlyWritable = false;
115                     break;
116                 case 3:
117                     writable = true;
118                     executable = true;
119                     ownerOnlyExecutable = false;
120                     ownerOnlyWritable = false;
121                     break;
122                 case 4:
123                     readable = true;
124                     ownerOnlyReadable = false;
125                     break;
126                 case 5:
127                     readable = true;
128                     executable = true;
129                     ownerOnlyReadable = false;
130                     ownerOnlyExecutable = false;
131                     break;
132                 case 6:
133                     readable = true;
134                     ownerOnlyReadable = false;
135                     writable = true;
136                     ownerOnlyWritable = false;
137                     break;
138                 case 7:
139                     writable = true;
140                     readable = true;
141                     executable = true;
142                     ownerOnlyReadable = false;
143                     ownerOnlyExecutable = false;
144                     ownerOnlyWritable = false;
145                     break;
146                 default:
147                     logger.warn("ignore file mode " + allMode);
148             }
149         } catch (NumberFormatException e) {
150             throw new IllegalArgumentException(" file mode must contains only number " + mode);
151         }
152 
153         return new FilePermission(
154                 executable, ownerOnlyExecutable, ownerOnlyReadable, readable, ownerOnlyWritable, writable);
155     }
156 }