Skip navigation links

Oracle® Information Rights Management Server Java API Reference
11g Release 1 (11.1.1)

E12907-03


oracle.irm.j2ee.jws.content.sealing
Interface SealingServicesEndpoint


public interface SealingServicesEndpoint

Web Service end point interface for Sealing Services. Sealing is the process of taking unprotected content, encrypting it and adding in meta data called a classification. Unsealing is the term used when sealed content is decrypted. Resealing is the term used when altering the sealed content meta data or classification. Peeking is the term given to the process of extracting meta data from sealed content without decrypting the content.

The methods on the sealing services are designed to used remotely, where the content is sent to a server, processes and the results returned to the client.

The sealing services support the MTOM (Message Transmission Optimization Mechanism) feature. This allows the services to transfer the binary sealed and unsealed content in the most optimal form available. When sending content to using the sealing services it is recommended to enable MTOM in the client web service stack.

WSDL

The WSDL for this end point interface can be downloaded from the server using the following URL:

 http://irm.example.com/irm_sealing/sealing_services?wsdl
 

Endpoint URL

Requests for this web service should be sent to the following URL:

 https://irm.example.com/irm_sealing/sealing_services
 

Method Summary
 ContentDescription peek(DataHandler input)
          Peek sealed content.
 DataHandler reclassify(DataHandler input, Classification classification)
          Re-classify sealed content.
 DataHandler reseal(DataHandler input, CustomData[] customData)
          Reseal content with new custom data.
 DataHandler seal(DataHandler stream, String mimeType, SealingOptions options)
          Seal content.
 DataHandler unseal(DataHandler input)
          Unseal a stream into an output stream.
 ContentDescription validatedPeek(DataHandler input)
          Peek sealed content (with validation of the signature).

 

Method Detail

seal

DataHandler seal(DataHandler stream,
                 String mimeType,
                 SealingOptions options)
                 throws UnsupportedContentTypeFault,
                        IllegalEncryptedContentBlockSizeFault,
                        PublicHeaderLengthFault,
                        AuthorizationDeniedFault
Seal content. Sealing is the process of taking plaintext content, encrypting and signing the content with an associated Classification.

If the classification provided is a context classification system classification, this method will provide an automatic ItemCode if one is not specified in the classification details.

To perform a sealing operation the authenticated user must have the rights to seal content for the specified classification. Sealing is authorized if the authenticated user has a license that allows the oracle.irm.generic.Seal Feature for the Classification specified in the sealing options.

Sealing a file

The following code demonstrates how to seal a file. The sample writes the resulting stream out as a file with a sealed file name inferred from the unsealed file name. The file is sealed using the context classification system, specifying a context with a known UUID value and an item code.
 import static oracle.irm.engine.classifications.context.ContextConstants.CONTEXT_CLASSIFICATION_SYSTEM_UUID;
 import static oracle.irm.engine.content.type.ContentTypeOperationsInstance.getContentTypeFromPath;
 import static oracle.irm.engine.content.type.ContentTypeOperationsInstance.getSealedFileName;
 import static oracle.irm.j2ee.jws.content.sealing.SealingServices.getSealingServicesEndpoint;
 
 import java.io.File;
 import java.net.URI;
 import java.util.Date;
 import java.util.Map;
 import java.util.UUID;
 
 import javax.activation.DataHandler;
 import javax.activation.FileDataSource;
 import javax.xml.ws.BindingProvider;
 
 import oracle.irm.engine.content.type.ContentType;
 import oracle.irm.engine.types.classifications.context.ContextCookie;
 import oracle.irm.engine.types.classifications.context.ContextRef;
 import oracle.irm.engine.types.classifications.item.ItemCode;
 import oracle.irm.engine.types.content.sealing.SealingOptions;
 import oracle.irm.engine.types.core.classification.Classification;
 import oracle.irm.engine.types.core.classification.ClassificationSystemRef;
 import oracle.irm.j2ee.jws.content.sealing.SealingServicesEndpoint;
 
 import com.sun.xml.ws.developer.JAXWSProperties;
 import com.sun.xml.ws.developer.StreamingDataHandler;
 
 public class SealFile {
 
     public static void main(String[] args) throws Exception {
 
         String hostPort = args[0];
         String username = args[1];
         String password = args[2];
 
         // The server URI. e.g. https://irm.example.com/irm_desktop
         URI serverURI = URI.create(args[3]);
 
         // The filename to seal
         String filename = args[4];
 
         // Context UUID is fixed for sample code
         ContextRef context = new ContextRef(UUID.fromString("46f910d9-dd30-476e-b060-4d01f88f8b05"));
 
         // Provide an explicit item code value and time
         ItemCode itemCode = new ItemCode();
         itemCode.setValue(new File(filename).getName());
         itemCode.setTime(new Date());
 
         // Create a context cookie for the classification - this specifies which context to use as
         // well as the item code for the content.
         ContextCookie cookie = new ContextCookie();
         cookie.setContext(context);
         cookie.setItemCode(itemCode);
 
         // Create the classification details used in the sealing options
         Classification classification = new Classification();
 
         // For the context classification system the classification Id is the context UUID value.
         classification.setId("46f910d9-dd30-476e-b060-4d01f88f8b05");
 
         // Context classification system
         classification.setSystem(new ClassificationSystemRef(CONTEXT_CLASSIFICATION_SYSTEM_UUID));
 
         // As the key set is not known get the sealing process to automatically fill this in
         classification.setKeySet(null);
 
         // URL sealed into content that tells the desktop where to go to get licenses
         classification.setUri(serverURI);
 
         // Classification time set explicitly to the current time
         classification.setClassificationTime(new Date());
 
         // As the labels are not known get the sealing process to automatically fill these in
         classification.setLabels(null);
 
         // Set the context and item code details
         classification.setCookie(cookie);
 
         // The classification is the only mandatory property for sealing options
         SealingOptions sealingOptions = new SealingOptions();
 
         sealingOptions.setClassification(classification);
 
         // Get the MIME type of the file to seal, this is inferred from the unsealed file name
         ContentType contentType = getContentTypeFromPath(filename);
 
         String mimeType = contentType.getMimeTypes()[0];
 
         // Get the sealing services web service proxy
         SealingServicesEndpoint sealingServices = getSealingServicesEndpoint(hostPort);
 
         // Set the user name and password
         Map<String, Object> requestContext = ((BindingProvider)sealingServices).getRequestContext();
 
         requestContext.put(BindingProvider.USERNAME_PROPERTY, username);
         requestContext.put(BindingProvider.PASSWORD_PROPERTY, password);
 
         // Without this setting the client may get an java.lang.OutOfMemoryException
         // when large files are buffered into memory by the HTTP stack.
         //
         // For more information see:
         //  https://jax-ws.dev.java.net/guide/HTTP_client_streaming_support.html
         //  https://jax-ws.dev.java.net/guide/Large_Attachments.html
         requestContext.put(JAXWSProperties.HTTP_CLIENT_STREAMING_CHUNK_SIZE, 4096);
 
         // Send the file contents to the server for sealing
         DataHandler input = new DataHandler(new FileDataSource(filename));
 
         StreamingDataHandler results = (StreamingDataHandler)sealingServices.seal(input, mimeType, sealingOptions);
 
         // Get the sealed equivalent of the unsealed filename
         String sealedFilename = getSealedFileName(filename);
 
         // Copy the downloaded file to the relevant location
         results.moveTo(new File(sealedFilename));
     }
 }
Parameters:
stream - the data stream.
mimeType - the unsealed or sealed MIME type of the data provided in the stream. The stream is assumed to contain unsealed data. It is advisable to use the sealed MIME type; this ensures the sealed content content type is unambiguous. e.g. the {text/plain} content type can be sealed as sealed text or sealed email. If the {text/plain} MIME type is specified the content will be sealed as sealed text.
options - the sealing options.
Returns:
sealed data stream.
Throws:
UnsupportedContentTypeFault - unsupported MIME type. The MIME type is not a supported sealable content type.
IllegalEncryptedContentBlockSizeFault - illegal encrypted content block size specified in the sealing options.
PublicHeaderLengthFault - the classification and custom data exceeds the maximum permitted size.
AuthorizationDeniedFault - thrown if sealing content using the provided classification is not allowed.

unseal

DataHandler unseal(DataHandler input)
                   throws ContentParseFault,
                          AuthorizationDeniedFault
Unseal a stream into an output stream. Unsealing is the process of taking sealed content, de-crypting it and returning the original unsealed content.

To perform an unsealing operation the authenticated user must have the rights to unseal content. Unsealing is allowed if the authenticated user has a license that allows the oracle.irm.generic.SaveUnsealed Feature for the content's Classification.

Unsealing a file

The following code demonstrates how to unseal a sealed file using the unseal method. The sample writes the resulting unsealed stream out to a file.
 import static oracle.irm.j2ee.jws.content.sealing.SealingServices.getSealingServicesEndpoint;
 
 import java.io.File;
 import java.util.Map;
 
 import javax.activation.DataHandler;
 import javax.activation.FileDataSource;
 import javax.xml.ws.BindingProvider;
 
 import oracle.irm.j2ee.jws.content.sealing.SealingServicesEndpoint;
 
 import com.sun.xml.ws.developer.JAXWSProperties;
 import com.sun.xml.ws.developer.StreamingDataHandler;
 
 public class UnsealFile {
 
     public static void main(String[] args) throws Exception {
 
         String hostPort = args[0];
         String username = args[1];
         String password = args[2];
 
         // The file to unseal
         String sealedFilename = args[3];
 
         // The unsealed file name
         String unsealedFilename = args[4];
 
         // Get the sealing services web service proxy
         SealingServicesEndpoint sealingServices = getSealingServicesEndpoint(hostPort);
 
         // Set the user name and password
         Map<String, Object> requestContext = ((BindingProvider)sealingServices).getRequestContext();
 
         requestContext.put(BindingProvider.USERNAME_PROPERTY, username);
         requestContext.put(BindingProvider.PASSWORD_PROPERTY, password);
 
         // Without this setting the client may get an java.lang.OutOfMemoryException
         // when large files are buffered into memory by the HTTP stack.
         //
         // For more information see:
         //  https://jax-ws.dev.java.net/guide/HTTP_client_streaming_support.html
         //  https://jax-ws.dev.java.net/guide/Large_Attachments.html
         requestContext.put(JAXWSProperties.HTTP_CLIENT_STREAMING_CHUNK_SIZE, 4096);
 
         // Send the file contents to the server for unsealing
         DataHandler input = new DataHandler(new FileDataSource(sealedFilename));
 
         StreamingDataHandler results = (StreamingDataHandler)sealingServices.unseal(input);
 
         // Copy the downloaded file to the relevant location
         results.moveTo(new File(unsealedFilename));
     }
 }
Parameters:
input - sealed data.
Returns:
unsealed data stream.
Throws:
ContentParseFault - indicates that there was an issue parsing the sealed content. The exception will contains a reason that identifies which section of the sealed content which caused the parsing to fail.
AuthorizationDeniedFault - thrown if unsealing for the classification is not allowed.

reseal

DataHandler reseal(DataHandler input,
                   CustomData[] customData)
                   throws ContentParseFault,
                          AuthorizationDeniedFault
Reseal content with new custom data. Resealing is the process of altering the data or meta-data in sealed content. This method allows the custom data portion of the meta data to be replaced.

To perform a resealing operation the authenticated user must have the rights to reseal the content. Resealing is allowed if the authenticated user has a valid license that has the oracle.irm.generic.Reseal Feature for the content's Classification.

Reseal a file with different custom data

The following code demonstrates how to reseal a sealed file using the reseal method. This sample adds XML based custom data to the sealed file.
 import static oracle.irm.j2ee.jws.content.sealing.SealingServices.getSealingServicesEndpoint;
 
 import java.io.File;
 import java.util.Map;
 import java.util.UUID;
 
 import javax.activation.DataHandler;
 import javax.activation.FileDataSource;
 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;
 import javax.xml.ws.BindingProvider;
 
 import oracle.irm.engine.types.content.sealing.CustomData;
 import oracle.irm.j2ee.jws.content.sealing.SealingServicesEndpoint;
 
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;
 
 import com.sun.xml.ws.developer.JAXWSProperties;
 import com.sun.xml.ws.developer.StreamingDataHandler;
 
 public class ResealFile {
 
        public static void main(String[] args) throws Exception {
 
         String hostPort = args[0];
         String username = args[1];
         String password = args[2];
 
         // Get the file to reseal
         String filename = args[3];
 
         // Get the sealing services web service proxy
         SealingServicesEndpoint sealingServices = getSealingServicesEndpoint(hostPort);
 
         // Set the user name and password
         Map<String, Object> requestContext = ((BindingProvider)sealingServices).getRequestContext();
 
         requestContext.put(BindingProvider.USERNAME_PROPERTY, username);
         requestContext.put(BindingProvider.PASSWORD_PROPERTY, password);
 
            // Without this setting the client may get an java.lang.OutOfMemoryException
            // when large files are buffered into memory by the HTTP stack.
            //
            // For more information see:
            //  https://jax-ws.dev.java.net/guide/HTTP_client_streaming_support.html
         //  https://jax-ws.dev.java.net/guide/Large_Attachments.html
            requestContext.put(JAXWSProperties.HTTP_CLIENT_STREAMING_CHUNK_SIZE, 4096);
 
         // Custom data is provided as XML
         DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
         DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
         Document document = documentBuilder.newDocument();
 
         Element element = document.createElement("SampleCustomData");
         element.setTextContent("Some example custom data provided as an XML text element");
 
         CustomData data = new CustomData();
 
         // UUID identifies the custom data, in this example just use a random UUID value
         data.setUuid(UUID.randomUUID());
 
         // Custom data is XML document
         data.setData(element);
 
         // Send the sealed file contents to the server for resealing
         DataHandler input = new DataHandler(new FileDataSource(filename));
 
         StreamingDataHandler results = (StreamingDataHandler)sealingServices.reseal(input, new CustomData[] {data});
 
         // Copy the downloaded file to the relevant location
         results.moveTo(new File(filename));
        }
 }
 
Parameters:
input - sealed data.
customData - the new custom data. This parameter is optional, it is valid to pass null or an empty collection.
Returns:
updated sealed data stream.
Throws:
ContentParseFault - indicates that there was an issue parsing the sealed content. The exception will contains a reason that identifies which section of the sealed content which caused the parsing to fail.
AuthorizationDeniedFault - thrown if resealing for the classification is not allowed.

reclassify

DataHandler reclassify(DataHandler input,
                       Classification classification)
                       throws ContentParseFault,
                              AuthorizationDeniedFault
Re-classify sealed content. Re-classification is the process of altering the Classification of the sealed content without having to perform a two step unseal and seal. During re-classification the content is re-encrypted and re-signed.

If the classification labels or key set are not provided then the sealing process will attempt to fill in these details. If no labels are provided in the classification the labels are filled in automatically. Labels can only be filled in if provided classification Id matches the classification returned by the server. If no key set is provided then the key set is filled in from the license used to perform the sealing operation. If the license specifies multiple key sets then the first key set in the license is used.

To perform a resealing operation the authenticated user must have a license for both the source classification and the target classification. The source classification license must allow the oracle.irm.generic.CopyTo or oracle.irm.generic.SaveUnsealed Feature. The target classification license must allow the oracle.irm.generic.Seal feature. If the source license has a copy to feature the transformation is only permitted if target classification is allowed by the trusted Destinations of the source classification license. If the source license has a save unsealed feature then there are no restrictions on the target classification.

Reclassifying a file

The following code demonstrates how to reclassify a sealed file using the reclassify method. The sample changes the labels of the classification and then writes the resulting stream out as a file.
 import static oracle.irm.j2ee.jws.content.sealing.SealingServices.getSealingServicesEndpoint;
 
 import java.io.File;
 import java.util.Locale;
 import java.util.Map;
 
 import javax.activation.DataHandler;
 import javax.activation.FileDataSource;
 import javax.xml.ws.BindingProvider;
 
 import oracle.irm.engine.types.content.sealing.ContentDescription;
 import oracle.irm.engine.types.core.classification.Classification;
 import oracle.irm.engine.types.core.general.Label;
 import oracle.irm.j2ee.jws.content.sealing.SealingServicesEndpoint;
 
 import com.sun.xml.ws.developer.JAXWSProperties;
 import com.sun.xml.ws.developer.StreamingDataHandler;
 
 public class ReclassifyFile {
 
        public static void main(String[] args) throws Exception {
 
         String hostPort = args[0];
         String username = args[1];
         String password = args[2];
 
         // Get the file to reclassify
         String filename = args[3];
 
         // Get the label to apply to the classification
         String labelName = args[4];
 
         // Get the sealing services web service proxy
         SealingServicesEndpoint sealingServices = getSealingServicesEndpoint(hostPort);
 
         // Set the user name and password
         Map<String, Object> requestContext = ((BindingProvider)sealingServices).getRequestContext();
 
         requestContext.put(BindingProvider.USERNAME_PROPERTY, username);
         requestContext.put(BindingProvider.PASSWORD_PROPERTY, password);
 
         // Without this setting the client may get an java.lang.OutOfMemoryException
         // when large files are buffered into memory by the HTTP stack.
         //
         // For more information see:
         //  https://jax-ws.dev.java.net/guide/HTTP_client_streaming_support.html
         //  https://jax-ws.dev.java.net/guide/Large_Attachments.html
         requestContext.put(JAXWSProperties.HTTP_CLIENT_STREAMING_CHUNK_SIZE, 4096);
 
         // Peek the contents of the file to obtain the classification details
         DataHandler input = new DataHandler(new FileDataSource(filename));
 
         ContentDescription contentDescription = sealingServices.peek(input);
 
         // Extract the classification from the content description
         Classification classification = contentDescription.getClassification();
 
         // Replace the labels with one
         Label label = new Label(
             Locale.ENGLISH,
             labelName,
             null);
 
         classification.setLabels(new Label[] { label });
 
         // Reclassify the sealed file with the new classification
         StreamingDataHandler results = (StreamingDataHandler)sealingServices.reclassify(input, classification);
 
         // Copy the downloaded file to the relevant location
         results.moveTo(new File(filename));
        }
 }
 
Parameters:
input - sealed data.
classification - new classification.
Returns:
updated sealed data stream.
Throws:
ContentParseFault - indicates that there was an issue parsing the sealed content. The exception will contains a reason that identifies which section of the sealed content which caused the parsing to fail.
AuthorizationDeniedFault - thrown if reclassification from the source to target classification is not allowed.

peek

ContentDescription peek(DataHandler input)
                        throws ContentParseFault
Peek sealed content. Peeking is the process of extracting the meta-data added to sealed content. This variant does not attempt to check the public header against its declared signature. If the meta-data has been altered post-sealing this method will not throw an exception. Any sealed content can be peek, the authenticated account does not require a license for the content's classification.

This meta-data includes the Classification as well as information such as the CreationTime.

The peeking process only examines the start of the sealed content. If a file is large it is not necessary to send the complete content, just the start of the file that contains the public header XML. This can improve performance when peeking large files.

Peeking a sealed file

The following code demonstrates how to extract the meta-data from sealed content using the peek method. This method sends the sealed content to the sealing server, the server extracts the meta data and returns this information to the caller. Once peeked the file meta data, which includes the Classification details, can be examined. The sample code prints out the human readable classification details (the labels) that were sealed into the content.
 import static oracle.irm.j2ee.jws.content.sealing.SealingServices.getSealingServicesEndpoint;
 
 import java.util.Map;
 
 import javax.activation.DataHandler;
 import javax.activation.FileDataSource;
 import javax.xml.ws.BindingProvider;
 
 import oracle.irm.engine.types.content.sealing.ContentDescription;
 import oracle.irm.engine.types.core.classification.Classification;
 import oracle.irm.engine.types.core.general.Label;
 import oracle.irm.j2ee.jws.content.sealing.SealingServicesEndpoint;
 
 import com.sun.xml.ws.developer.JAXWSProperties;
 
 public class PeekFile {
 
     public static void main(String[] args) throws Exception {
 
         String hostPort = args[0];
         String username = args[1];
         String password = args[2];
 
         // The name of the file to peek
         String filename = args[3];
 
         // Get the sealing services web service proxy
         SealingServicesEndpoint sealingServices = getSealingServicesEndpoint(hostPort);
 
         // Set the user name and password
         Map<String, Object> requestContext = ((BindingProvider)sealingServices).getRequestContext();
 
         requestContext.put(BindingProvider.USERNAME_PROPERTY, username);
         requestContext.put(BindingProvider.PASSWORD_PROPERTY, password);
 
         // Without this setting the client may get an java.lang.OutOfMemoryException
         // when large files are buffered into memory by the HTTP stack.
         //
         // For more information see:
         //  https://jax-ws.dev.java.net/guide/HTTP_client_streaming_support.html
         //  https://jax-ws.dev.java.net/guide/Large_Attachments.html
         requestContext.put(JAXWSProperties.HTTP_CLIENT_STREAMING_CHUNK_SIZE, 4096);
 
         // Perform the peek, providing a stream to the sealed file
         DataHandler input = new DataHandler(new FileDataSource(filename));
 
         ContentDescription results = sealingServices.peek(input);
 
         // Extract the classification details from the content
         Classification classification = results.getClassification();
 
         // Show all the labels sealed into content (assumes labels are available)
         for (Label label : classification.getLabels()) {
             System.out.println(label.getLocale().getDisplayName() + " : " + label.getName());
         }
     }
 }
Parameters:
input - sealed data.
Returns:
the meta-data and classification details sealed into the content.
Throws:
ContentParseFault - indicates that there was an issue parsing the sealed content. The exception will contains a reason that identifies which section of the sealed content which caused the parsing to fail.

validatedPeek

ContentDescription validatedPeek(DataHandler input)
                                 throws ContentParseFault,
                                        AuthorizationDeniedFault
Peek sealed content (with validation of the signature). Peeking is the process of extracting the meta-data added to sealed content. This variant attempts to check the public header against its declared signature. If the public header meta-data has been altered post sealing this method will throw an exception.

A validated peek is allowed if the authenticated user has a license that has the open Feature for the content's Classification.

The peeking process only examines the start of the sealed content. If a file is large it is not necessary to send the complete content, just the start of the file that contains the public header XML and signature. This can improve performance when peeking large files.

Peeking a sealed file and check the digital signature

The following code demonstrates how to extract the meta-data from sealed content using the validatedPeek method. This method sends the sealed content to the sealing server, the server extracts the meta data and returns this information to the caller. Once peeked the file meta data, which includes the Classification details, can be examined. The sample code prints out the human readable classification details (the labels) that were sealed into the content.
 import static oracle.irm.j2ee.jws.content.sealing.SealingServices.getSealingServicesEndpoint;
 
 import java.util.Map;
 
 import javax.activation.DataHandler;
 import javax.activation.FileDataSource;
 import javax.xml.ws.BindingProvider;
 
 import com.sun.xml.ws.developer.JAXWSProperties;
 
 import oracle.irm.engine.types.content.sealing.ContentDescription;
 import oracle.irm.engine.types.core.classification.Classification;
 import oracle.irm.engine.types.core.general.Label;
 import oracle.irm.j2ee.jws.content.sealing.SealingServicesEndpoint;
 
 public class ValidatedPeekFile {
 
     public static void main(String[] args) throws Exception {
 
         String hostPort = args[0];
         String username = args[1];
         String password = args[2];
 
         // The name of the file to peek
         String filename = args[3];
 
         // Get the sealing services web service proxy
         SealingServicesEndpoint sealingServices = getSealingServicesEndpoint(hostPort);
 
         // Set the user name and password
         Map<String, Object> requestContext = ((BindingProvider)sealingServices).getRequestContext();
 
         requestContext.put(BindingProvider.USERNAME_PROPERTY, username);
         requestContext.put(BindingProvider.PASSWORD_PROPERTY, password);
 
         // Without this setting the client may get an java.lang.OutOfMemoryException
         // when large files are buffered into memory by the HTTP stack.
         //
         // For more information see:
         //  https://jax-ws.dev.java.net/guide/HTTP_client_streaming_support.html
         //  https://jax-ws.dev.java.net/guide/Large_Attachments.html
         requestContext.put(JAXWSProperties.HTTP_CLIENT_STREAMING_CHUNK_SIZE, 4096);
 
         // Send the file contents to the server for peeking
         DataHandler input = new DataHandler(new FileDataSource(filename));
 
         ContentDescription results = sealingServices.validatedPeek(input);
 
         // Extract the classification details from the content
         Classification classification = results.getClassification();
 
         // Show all the labels sealed into content (assumes labels are available)
         for (Label label : classification.getLabels()) {
             System.out.println(label.getLocale().getDisplayName() + " : " + label.getName());
         }
     }
 }
Parameters:
input - sealed data.
Returns:
the meta-data and classification details sealed into the content.
Throws:
ContentParseFault - indicates that there was an issue parsing the sealed content. The exception will contains a reason that identifies which section of the sealed content which caused the parsing to fail.
AuthorizationDeniedFault - thrown if peeking the classification is not allowed.

Skip navigation links

Oracle® Information Rights Management Server Java API Reference
11g Release 1 (11.1.1)

E12907-03


Copyright © 2011, Oracle. All rights reserved.