Find Usages Diff Raw Download HTML Widget Stack Overflow Q&A
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
1. Java - How to find out which Jar file an import comes from?
The project I'm working on has about 10 jar files as libraries. At the top of one of the files there's an import statement like: import jpe.nar.crat.maker.ObjectMakerFactory; Is there a way to tell which Jar file it comes from? (I'm using Netbeans if that matters.)
2. Getting file path in java
Is there a way for java program to determine its location in the file system?
3. How do I get my current working directory in Java?
Let's say I have my main class in C:\Users\Justian\Documents. How can I get my program to show that it's in C:\Users\Justian\Documents. Hard-Coding is not an option- it needs to be adaptable if it's moved to another location. I want to dump a bunch of CSV files in a folder, have the program recognize all the files, then load the data and manipulate them. I really just want to know how to nav...
4. Other SecurityManager implementations available?
Is there any other implementation (e.g. in an OSS project) of a Java SecurityManager available which has more features than the one in the JDK? I'm looking for features like configurable at runtime policies updateable at runtime, read from other data sources than a security.policy file Thread-aware, e.g. different policies per Thread Higher-level policies, e.g. "Disable network functions, bu...
5. Update Java security policy at runtime?
Is there a legal way to add/remove permissions to Java security policy at runtime?
6. How can a JACC provider use the Principal-to-role mapping facilities of the server it's deployed on?
I am writing a JACC provider. Along the way, this means implementing a PolicyConfiguration. The PolicyConfiguration is responsible for accepting configuration information from the application server, such as which permissions accrue to which roles. This is so that a Policy later on can make authorization decisions when handed information about the current user and what he's trying to do. Ho... 
1
  /*
2
   * Copyright 1997-2006 Sun Microsystems, Inc.  All Rights Reserved.
3
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
   *
5
   * This code is free software; you can redistribute it and/or modify it
6
   * under the terms of the GNU General Public License version 2 only, as
7
   * published by the Free Software Foundation.  Sun designates this
8
   * particular file as subject to the "Classpath" exception as provided
9
   * by Sun in the LICENSE file that accompanied this code.
10
  *
11
  * This code is distributed in the hope that it will be useful, but WITHOUT
12
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14
  * version 2 for more details (a copy is included in the LICENSE file that
15
  * accompanied this code).
16
  *
17
  * You should have received a copy of the GNU General Public License version
18
  * 2 along with this work; if not, write to the Free Software Foundation,
19
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20
  *
21
  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22
  * CA 95054 USA or visit www.sun.com if you need additional information or
23
  * have any questions.
24
  */
25
 
26
 package java.security;
27
 
29
 import java.util.List;

This ProtectionDomain class encapsulates the characteristics of a domain, which encloses a set of classes whose instances are granted a set of permissions when being executed on behalf of a given set of Principals.

A static set of permissions can be bound to a ProtectionDomain when it is constructed; such permissions are granted to the domain regardless of the Policy in force. However, to support dynamic security policies, a ProtectionDomain can also be constructed such that it is dynamically mapped to a set of permissions by the current Policy whenever a permission is checked.

Author(s):
Li Gong
Roland Schemers
Gary Ellison
52
 
53
 
54
 public class ProtectionDomain {
55
 
56
     /* CodeSource */
57
     private CodeSource codesource ;
58
 
59
     /* ClassLoader the protection domain was consed from */
60
     private ClassLoader classloader;
61
 
62
     /* Principals running-as within this protection domain */
63
     private Principal[] principals;
64
 
65
     /* the rights this protection domain is granted */
66
     private PermissionCollection permissions;
67
 
68
     /* if the permissions object has AllPermission */
69
     private boolean hasAllPerm = false;
70
 
71
     /* the PermissionCollection is static (pre 1.4 constructor)
72
        or dynamic (via a policy refresh) */
73
     private boolean staticPermissions;
74
 
75
     private static final Debug debug = Debug.getInstance("domain");

    
Creates a new ProtectionDomain with the given CodeSource and Permissions. If the permissions object is not null, then setReadOnly()) will be called on the passed in Permissions object. The only permissions granted to this domain are the ones specified; the current Policy will not be consulted.

Parameters:
codesource the codesource associated with this domain
permissions the permissions granted to this domain
86
 
87
     public ProtectionDomain(CodeSource codesource,
88
                             PermissionCollection permissions) {
89
         this. = codesource;
90
         if (permissions != null) {
91
             this. = permissions;
92
             this..setReadOnly();
93
             if (permissions instanceof Permissions &&
94
                 ((Permissions)permissions). != null) {
95
                  = true;
96
             }
97
         }
98
         this. = null;
99
         this. = new Principal[0];
100
         = true;
101
    }

    
Creates a new ProtectionDomain qualified by the given CodeSource, Permissions, ClassLoader and array of Principals. If the permissions object is not null, then setReadOnly() will be called on the passed in Permissions object. The permissions granted to this domain are dynamic; they include both the static permissions passed to this constructor, and any permissions granted to this domain by the current Policy at the time a permission is checked.

This constructor is typically used by ClassLoaders and DomainCombiners which delegate to Policy to actively associate the permissions granted to this domain. This constructor affords the Policy provider the opportunity to augment the supplied PermissionCollection to reflect policy changes.

Parameters:
codesource the CodeSource associated with this domain
permissions the permissions granted to this domain
classloader the ClassLoader associated with this domain
principals the array of Principals associated with this domain. The contents of the array are copied to protect against subsequent modification.
Since:
1.4
See also:
Policy.refresh()
Policy.getPermissions(java.security.ProtectionDomain)
132
    public ProtectionDomain(CodeSource codesource,
133
                            PermissionCollection permissions,
134
                            ClassLoader classloader,
135
                            Principal[] principals) {
136
        this. = codesource;
137
        if (permissions != null) {
138
            this. = permissions;
139
            this..setReadOnly();
140
            if (permissions instanceof Permissions &&
141
                ((Permissions)permissions). != null) {
142
                 = true;
143
            }
144
        }
145
        this. = classloader;
146
        this. = (principals != null ? principals.clone():
147
                           new Principal[0]);
148
         = false;
149
    }

    
Returns the CodeSource of this domain.

Returns:
the CodeSource of this domain which may be null.
Since:
1.2
156
    public final CodeSource getCodeSource() {
157
        return this.;
158
    }


    
Returns the ClassLoader of this domain.

Returns:
the ClassLoader of this domain which may be null.
Since:
1.4
167
    public final ClassLoader getClassLoader() {
168
        return this.;
169
    }


    
Returns an array of principals for this domain.

Returns:
a non-null array of principals for this domain. Returns a new array each time this method is called.
Since:
1.4
179
    public final Principal[] getPrincipals() {
180
        return this..clone();
181
    }

    
Returns the static permissions granted to this domain.

Returns:
the static set of permissions for this domain which may be null.
See also:
Policy.refresh()
Policy.getPermissions(java.security.ProtectionDomain)
190
    public final PermissionCollection getPermissions() {
191
        return ;
192
    }

    
Check and see if this ProtectionDomain implies the permissions expressed in the Permission object.

The set of permissions evaluated is a function of whether the ProtectionDomain was constructed with a static set of permissions or it was bound to a dynamically mapped set of permissions.

If the ProtectionDomain was constructed to a statically bound PermissionCollection then the permission will only be checked against the PermissionCollection supplied at construction.

However, if the ProtectionDomain was constructed with the constructor variant which supports dynamically binding permissions, then the permission will be checked against the combination of the PermissionCollection supplied at construction and the current Policy binding.

Parameters:
permission the Permission object to check.
Returns:
true if "permission" is implicit to this ProtectionDomain.
221
    public boolean implies(Permission permission) {
223
        if () {
224
            // internal permission collection already has AllPermission -
225
            // no need to go to policy
226
            return true;
227
        }
229
        if (! &&
230
            Policy.getPolicyNoCheck().implies(this, permission))
231
            return true;
232
        if ( != null)
233
            return .implies(permission);
235
        return false;
236
    }

    
Convert a ProtectionDomain to a String. 
241
    public String toString() {
242
        String pals = "<no principals>";
243
        if ( != null && . > 0) {
244
            StringBuilder palBuf = new StringBuilder("(principals ");
246
            for (int i = 0; i < .; i++) {
247
                palBuf.append([i].getClass().getName() +
248
                            " \"" + [i].getName() +
249
                            "\"");
250
                if (i < .-1)
251
                    palBuf.append(",\n");
252
                else
253
                    palBuf.append(")\n");
254
            }
255
            pals = palBuf.toString();
256
        }
258
        // Check if policy is set; we don't want to load
259
        // the policy prematurely here
260
        PermissionCollection pc = Policy.isSet() && seeAllp() ?
261
                                      mergePermissions():
262
                                      getPermissions();
264
        return "ProtectionDomain "+
265
            " "++"\n"+
266
            " "++"\n"+
267
            " "+pals+"\n"+
268
            " "+pc+"\n";
269
    }

    
Return true (merge policy permissions) in the following cases: . SecurityManager is null . SecurityManager is not null, debug is not null, SecurityManager impelmentation is in bootclasspath, Policy implementation is in bootclasspath (the bootclasspath restrictions avoid recursion) . SecurityManager is not null, debug is null, caller has Policy.getPolicy permission 
286
    private static boolean seeAllp() {
287
        SecurityManager sm = System.getSecurityManager();
289
        if (sm == null) {
290
            return true;
291
        } else {
292
            if ( != null) {
293
                if (sm.getClass().getClassLoader() == null &&
294
                    Policy.getPolicyNoCheck().getClass().getClassLoader()
295
                                                                == null) {
296
                    return true;
297
                }
298
            } else {
299
                try {
300
                    sm.checkPermission(.);
301
                    return true;
302
                } catch (SecurityException se) {
303
                    // fall thru and return false
304
                }
305
            }
306
        }
308
        return false;
309
    }
312
        if ()
313
            return ;
315
        PermissionCollection perms =
316
            java.security.AccessController.doPrivileged
317
            (new java.security.PrivilegedAction<PermissionCollection>() {
318
                    public PermissionCollection run() {
319
                        Policy p = Policy.getPolicyNoCheck();
320
                        return p.getPermissions(ProtectionDomain.this);
321
                    }
322
                });
324
        Permissions mergedPerms = new Permissions();
325
        int swag = 32;
326
        int vcap = 8;
327
        Enumeration<Permission> e;
328
        List<Permission> pdVector = new ArrayList<Permission>(vcap);
329
        List<Permission> plVector = new ArrayList<Permission>(swag);
331
        //
332
        // Build a vector of domain permissions for subsequent merge
333
        if ( != null) {
334
            synchronized () {
335
                e = .elements();
336
                while (e.hasMoreElements()) {
337
                    pdVector.add(e.nextElement());
338
                }
339
            }
340
        }
342
        //
343
        // Build a vector of Policy permissions for subsequent merge
344
        if (perms != null) {
345
            synchronized (perms) {
346
                e = perms.elements();
347
                while (e.hasMoreElements()) {
348
                    plVector.add(e.nextElement());
349
                    vcap++;
350
                }
351
            }
352
        }
354
        if (perms != null &&  != null) {
355
            //
356
            // Weed out the duplicates from the policy. Unless a refresh
357
            // has occured since the pd was consed this should result in
358
            // an empty vector.
359
            synchronized () {
360
                e = .elements();   // domain vs policy
361
                while (e.hasMoreElements()) {
362
                    Permission pdp = e.nextElement();
363
                    Class pdpClass = pdp.getClass();
364
                    String pdpActions = pdp.getActions();
365
                    String pdpName = pdp.getName();
366
                    for (int i = 0; i < plVector.size(); i++) {
367
                        Permission pp = plVector.get(i);
368
                        if (pdpClass.isInstance(pp)) {
369
                            // The equals() method on some permissions
370
                            // have some side effects so this manual
371
                            // comparison is sufficient.
372
                            if (pdpName.equals(pp.getName()) &&
373
                                pdpActions.equals(pp.getActions())) {
374
                                plVector.remove(i);
375
                                break;
376
                            }
377
                        }
378
                    }
379
                }
380
            }
381
        }
383
        if (perms !=null) {
384
            // the order of adding to merged perms and permissions
385
            // needs to preserve the bugfix 4301064
387
            for (int i = plVector.size()-1; i >= 0; i--) {
388
                mergedPerms.add(plVector.get(i));
389
            }
390
        }
391
        if ( != null) {
392
            for (int i = pdVector.size()-1; i >= 0; i--) {
393
                mergedPerms.add(pdVector.get(i));
394
            }
395
        }
397
        return mergedPerms;
398
    }
New to GrepCode? Check out our FAQ X