// The configuration name to use.
     public static final String CONFIGNAME = "policydomain";

     // The policy domain shares the same name as its configuration.
     // The policy domain name to use.
    public static final String POLICYDOMAIN = "policydomain";

// Initialize this applications configuration.
AppConfig cfg = new AppConfig();
// Policydomains are named after their configurations.
        cfg.useConfiguration( CONFIGNAME );
// Initialize the security runtime.
        try {
            SecurityRuntime.initialize( cfg );
        }
        catch( ParameterException pExc ) {
            // An error occurred with our configuration.
            System.out.println( pExc.getLocalizedMessage() );
            System.exit(pExc.hashCode());
        }
// Get an instance of the runtime
        SecurityRuntime rt = SecurityRuntime.getInstance();
        System.out.println("Security Runtime Initialized");

       // Fetch the policy domain from the runtime.

       PolicyDomain pd = null;
       try { 
            pd = rt.getPolicyDomain( POLICYDOMAIN );
       }
       catch( ParameterException pExc ) {
            // We could not get the policy domain.
            System.out.println( pExc.getLocalizedMessage() );
            System.exit(pExc.hashCode());
       } 
       System.out.println("Retrieved Policy Domain");

// Get the authentication service from the policy domain.
       AuthenticationService atnSvc = null;
       try {
            atnSvc = (AuthenticationService) pd.getService(
                                              ServiceType.AUTHENTICATION  );
       }
       catch( ServiceNotAvailableException naExc ) {
            // We could not fetch the service.
            System.out.println( naExc.getLocalizedMessage() );
            System.exit( naExc.hashCode() );
       }
       System.out.println("Retrieved Authentication Service");

// Validate that the service we retrieve is the type and level of
// compatibility we need.
// Get the policy domain.
PolicyDomain pd = null;
try {
    pd = rt.getPolicyDomain( "POLICYDOMAIN" );
}
catch( ParameterException pExc ) {
    System.err.println( pExc.getMessage() );
    System.exit(-10);
}

// Get the authentication service.
PublicSecurityService myService = null;

try {
    myService = pd.getService( ServiceType.AUTHENTICATION );
}
catch( ServiceNotAvailableException svcExc ) {
    System.err.println(svcExc.getMessage());
    System.exit(-10);
}

// Lets make sure that what is returned is an authentication
// service.

ServiceType sType = myService.getServiceType();

if ( sType != ServiceType.AUTHENTICATION ) {
   System.err.println("We did not receive an authentication service!");
   System.exit(-10);
}

// Lets make sure this service is compatible with the version we are coding
// against - version 1.0.

ServiceVersion expectedVersion = new ServiceVersion( 1, 0 );

int compatiblity_flag = myService.isCompatible( expectedVersion );

if ( compatibility_flag == PublicSecurityService.COMPATIBLE ) {
   // This service is fully compatible with this application
   // proceed with initialization.
} else if ( compatibility_flag ==
PublicSecurityService.COMPATIBLE_DEPRECATED ) {
   // This service is fully compatible with this application
   // except some functions will be changing in upcoming versions (some
   // functions have been deprecated between versions).
   // Warn the developers in a log file
   log_warning("Authentication Service may use deprecated methods in version
                             " + myService.getVersion() )
} else if ( compatibility_flag == PublicSecurityService
                                        .COMPATIBLE_UNKNOWN)
{
   // The compatibility of this service is unknown. Usually because we
   // expect a larger service version than what is currently installed. 
   // Compatibility may be assumed (you can try it)
   // or you may choose to fail on unknown. We will warn the user
   popup_warning("Authentication Service expects version " + expectedVersion
+ " and got version " + myService.getVersion());
} else if ( compatibility_flass == PublicSecurityService.NOT_COMPATIBLE ) {
   // This service is known not to be compatible with the version expected.
   // Stop initialization and exit this application
   popup_warning("Authentication Service version " + myService.getVersion()
                          + " is not compatible with this application" );
   System.exit(-20);
}

// Continue with application initialization...

        // Start authentication
        AuthenticIdentity ident=null;

        try {
           ident = atnSvc.authenticate( new AuthenticationHandler() );
        }
        catch( IdentityNotAuthenticException naExc ) {
           System.out.println( naExc.getLocalizedMessage() );
           System.exit( naExc.hashCode() );
        }

        System.out.println("Authentication Succeeded");
        System.out.println( ident.toString() );

    public static class AuthenticationHandler implements
         javax.security.auth.callback.CallbackHandler {

       protected String username = null;
       protected char[] password = null;

       public String getPassword() {
            return new String( password );
       }

       public String getUsername() {
            return username;
       }

       public AuthenticationHandler( ) {
       }

       public AuthenticationHandler( String username, String password ) {
           this.username = username;
           this.password = password.toCharArray();
       }

       public void handle(Callback[] callbacks) throws IOException,
                        UnsupportedCallbackException {

          // Loop through the callbacks and prompt the user with the
                    appropriate input to gather credentials

            for ( int numcb=0; numcb < callbacks.length; numcb++ ) {

                // Fill in the username
              if ( callbacks[numcb] instanceof
                       javax.security.auth.callback.NameCallback ) {
               javax.security.auth.callback.NameCallback ncb = (
                javax.security.auth.callback.NameCallback ) callbacks[numcb];

               if ( username == null ) {
               // Fetch the username from the user
                username = Input.getString( ncb.getPrompt() );
                ncb.setName( username );
                 } else {
                  ncb.setName( username );
                  }
               }

               // Fill in the password
               if ( callbacks[numcb] instanceof
                javax.security.auth.callback.PasswordCallback ) {
                   javax.security.auth.callback.PasswordCallback pcb = (
                        javax.security.auth.callback.PasswordCallback )
                                  callbacks[numcb];

                    if ( password == null ) {
                    String pwd = Input.getString( pcb.getPrompt() );
                    password = pwd.toCharArray();
                    } 
                     pcb.setPassword( password );
                 }

           }

       }
    }

    public static class Input {
       public static String getString( String prompt ) { 

            BufferedReader stdin = new BufferedReader( new InputStreamReader(
                                                       System.in ) );
           System.out.print( prompt );
           System.out.flush();
           String input = null;
           try {
             input = stdin.readLine();
           } 
           catch( IOException ioExc ) {
                System.out.println( ioExc.getLocalizedMessage() );
           }
            if ( input == null ) {
                return "";
            } else {
                return input;
            }
         }

    }

        // Authentication complete - now authorize a resource.
        // Get the authorization service from the policy domain.

        AuthorizationService atzSvc = null; 

        try { 

            atzSvc = (AuthorizationService) pd.getService(
                                 ServiceType.AUTHORIZATION  );
       }
       catch( ServiceNotAvailableException naExc ) {
           // We could not fetch the service
           System.out.println( naExc.getLocalizedMessage() );
           System.exit( naExc.hashCode() );
       }
       System.out.println("Retrieved Authorization Service");

       // Output the resource string defined by the naming authority.

       System.out.println("EXAMPLERESAUTHORITY is defined as:
           servername:user@filename-fieldname (i.e.
                        www:bob@index.html-searchinput )");

        String resourcestring = Input.getString("Enter a resource string in
                        the format defined by EXAMPLERESAUTHORITY: ");

       // Create the resource object
       RuntimeResource rResource = new RuntimeResource( resourcestring,
                                          "EXAMPLERESAUTHORITY" );

System.out.println("EXAMPLEACTAUTHORITY is defined as:
                             mainaction:followup (i.e. GET:LOG)");
       String actionstring = Input.getString("Enter an action string 
                            in the format defined by EXAMPLEACTAUTHORITY: ");

       // Create the action object.
       RuntimeAction rAction = new RuntimeAction( actionstring,
                                            "EXAMPLEACTAUTHORITY" );

       // Output the parsed action for user confirmation.

System.out.println("Authorizing user for this resource and action\n");

       AccessResult rResult = null;
       try {
            rResult = atzSvc.isAccessAllowed( ident , rResource, rAction );
       }
       catch( IdentityNotAuthenticException idExc ) {
           System.out.println( idExc.getLocalizedMessage() );
           System.exit( idExc.hashCode() );
        }

        // We got a valid result
       System.out.println("Access Result:");
       System.out.println("   Access Allowed: " + String.valueOf(
                              rResult.isAllowed() ) );
       System.out.println("   Decision Time: " +
                               rResult.getDecisionTime().toString() );
}

       // Get the audting service.
        PublicSecurityService myService = null;

        try {
            myService = pd.getService( ServiceType.AUDIT );
        }
        catch( ServiceNotAvailableException svcExc ) {
          // Exception is thrown if service is not present
            System.err.println(svcExc.getMessage());
            System.exit(-10);
        }

        AuditingService adtService = (AuditingService) myService;

        // Create an audit record to determine it's naming authority,
        // severity, and message.

        AuditRecord adtRec = new AuditRecord("MyAppError", AuditRecord.ERROR,
                                                "This is an ERROR message");

        // Record the audit record to the auditing service provider
        adtService.recordEvent( adtRec );

// Get the role service from the policy domain
       RoleService rmService = null;
       try {
            rmService = (RoleService) pd.getService(
                                              ServiceType.ROLE  );
       }
       catch( ServiceNotAvailableException naExc ) {
            // We could not fetch the service
            System.out.println( naExc.getLocalizedMessage() );
            System.exit( naExc.hashCode() );
       }
       System.out.println("Retrieved Role Service");

        // Determine what roles myUser is in when accessing
        // http://www.bea.com/index.html with a HTTP GET.
        // Create the resource.
        RuntimeResource beaurl = new RuntimeResource(
                         "http://www.bea.com/index.html" , "URL_AUTHORITY" );

        // Create the action.
        RuntimeAction action = new RuntimeAction( "GET", "SIMPLE_ACTION" );

        // Get a reference to the application context
        AppContext ctx = MySession.getContext();

        // Try fetching our roles
        Vector roles=null;
        try {
            roles = rmService.getRoles( myUser, beaurl,  action, ctx );
        }
        catch( IdentityNotAuthenticException identExc ) {
          // Exception is thrown if myUser is not properly authenticated
            System.err.println( identExc.getMessage() );
        }

        if ( roles != null ) {
          // Print the roles and descriptions
            for ( int loop=0; loop < roles.size(); loop++ ) {
                IdentityRole role = (IdentityRole) roles.elementAt( loop );
                System.out.println( role.getName() );
                System.out.println( role.getDescription() );
            }
        }

// Get the CredentialMapping service from the policy domain
       RoleService rmService = null;
       try {
            cmService = (CredentialMappingService) pd.getService(
                                              ServiceType.CredentialMapping  );
       }
       catch( ServiceNotAvailableException naExc ) {
            // We could not fetch the service
            System.out.println( naExc.getLocalizedMessage() );
            System.exit( naExc.hashCode() );
       }
       System.out.println("Retrieved CredentialMapping Service");

      // Retrieve credentials for MyUser according to the current resource and
    // action being accessed and from a list of credential types that I am
    // interrested in.
        // Create the resource.
        RuntimeResource beaurl = new RuntimeResource(
                   "http://www.bea.com/index.html" , "URL_AUTHORITY" );

        // Create the action.
        RuntimeAction action = new RuntimeAction( "GET", "SIMPLE_ACTION" );

        // Try fetching the credentials.
        String[] askingCreds = new String[2];
        askingCreds[0] = "oracledb";
        askingCreds[1] = "3desDecryptionKey";
        Vector creds=null;
        try {
            // Both byIdent and forIdent are the same since I am fetching these
          // credentials for myself.
            creds = cmService.getCredentials( myUser, myUser, beaurl,  action,
                                               askingCreds );
        }
        catch( IdentityNotAuthenticException identExc ) {
            assertNull( identExc.getMessage(), identExc );
        }
        catch( ParameterException pExc ) {
            assertNull( pExc.getMessage(), pExc );
        }

        if ( creds != null ) {
            System.out.print("Returned " + String.valueOf( creds.size() ) + 
                                      "credential objects.");
            for ( int loop=0; loop < creds.size(); loop++ ) {
                Object cred = creds.elementAt( loop );

            // The type of objects returned depend on the credential type.
            // Either javax.resource.spi.security.PasswordCredential or
            // javax.resource.spi.security.GenericCredential are
            // recommended.
            // However, custom credential types are allowed.
                if ( cred instanceof
                       javax.resource.spi.security.PasswordCredential ) {
                  // This is a password credential.
              ...
            } else if ( cred instanceof
                       javax.resource.spi.security.GenericCredential ) {
                // This is a generic credential.
                  ...
            } else {
                // This is a custom credential type.
                  ...
            }
            }
        }