Table of Contents

Preface

1. Introduction to DCE Facilities

2. DCE Host Services

• 2.1. Managing a Host's Endpoint Map
• 2.2. Binding to dced's Services
• 2.2.1. Host Service Naming in Applications
• 2.2.2. The dced Maintains Entry Lists
• 2.2.3. Reading All of a Host Service's Data
• 2.2.4. Managing Individual dced Entries
• 2.3. Managing Host Data on a Remote Host
• 2.3.1. Kinds of Host Data Stored
• 2.3.2. Adding New Host Data
• 2.3.3. Modifying Host Data
• 2.3.4. Running Programs Automatically When Host Data Changes
• 2.4. Controlling Servers Remotely
• 2.4.1. Two States of Server Management: Configuration and Execution
• 2.4.2. Configuring Servers
• 2.4.2.1. Configuring a New DCE Server
• 2.4.2.2. Modifying a Server's Configuration Attributes
• 2.4.2.3. Deleting a DCE Server
• 2.4.3. Starting and Stopping Servers
• 2.4.4. Enabling and Disabling Services of a Server
• 2.5. Validating the Security Server
• 2.6. Managing Server Key Tables

• 3.1. DCE and Messages
• 3.2. DCE Messaging Interface Usage
• 3.2.1. A Simple DCE Messaging Example
• 3.2.1.1. Defining the Message
• 3.2.1.2. Processing the .sams File
• 3.2.1.3. Program Source
• 3.2.1.4. DCE Messaging and Message Catalogs
• 3.2.2. The DCE Message Interface and ``sams'' Input and Output Files
• 3.3. DCE Messaging Routines
• 3.3.1. Message Output Routines
• 3.3.2. Message Retrieval Routines
• 3.3.3. Message Table Routines
• 3.3.4. DCE XPG4 Routines

4. Using the DCE Serviceability Application Interface

• 4.1. Overview
• 4.1.1. How Programs Use Serviceability
• 4.1.2. Simple Serviceability Interface Tutorial
• 4.1.2.1. Defining the Message
• 4.1.2.2. Processing the sams File
• 4.1.2.3. Coding the Serviceability Calls
• 4.1.2.4. Building and Running the Program
• 4.1.2.5. Fields of a Serviceability Message
• 4.1.3. Serviceability Input and Output Files
• 4.2. Integrating Serviceability into a Server
• 4.2.1. Serviceability Strategy
• 4.2.2. Components and Subcomponents
• 4.2.3. Identifying Event Points
• 4.3. Application Use of Serviceability
• 4.3.1. Basic Server Calls
• 4.3.1.1. Extended Format Notation for Message Text
• 4.3.2. Specifying Message Severity
• 4.3.3. How to Route Messages
• 4.3.3.1. Using a Routing File
• 4.3.3.2. Routing by Environment Variable
• 4.3.3.3. Calling dce.svc.routing() to Set Routing
• 4.3.3.4. Additional Routing by Attribute
• 4.3.4. Table of Message Processing Specifiers
• 4.3.5. Logging and Log Reading
• 4.3.6. Message Action Attributes
• 4.3.7. Suppressing the Serviceability Message Prolog
• 4.3.8. Serviceability Use of the ..FILE.. Macro
• 4.3.9. Forcing Use of the In-Memory Message Table
• 4.3.10. Dynamically Filtering Messages Before Output
• 4.3.11. Using Serviceability for Debug Messages
• 4.3.11.1. Setting Debug Levels
• 4.3.11.2. Routing Debug Messages
• 4.3.12. Performance Costs of Serviceability Debugging
• 4.3.13. Using the Remote Serviceability Interface
• 4.3.13.1. Basic Steps in Setting Up the Remote Interface
• 4.3.13.2. Implementing the Remote Routines
• 4.3.13.3. Registering and Exporting the Remote Interface
• 4.3.13.4. Importing and Accessing the Remote Interface

• 5.1. Data in a Backing Store
• 5.2. Using A Backing Store
• 5.3. Header for Data
• 5.4. The User Interface
• 5.5. The IDL Encoding Services
• 5.5.1. Encoding and Decoding in the Backing Store
• 5.5.2. Conformant Arrays Not Allowed
• 5.6. The Backing Store Routines
• 5.6.1. Opening a Backing Store
• 5.6.2. Closing a Backing Store
• 5.6.3. Storing or Retrieving Data
• 5.6.4. Freeing Data
• 5.6.5. Making or Retrieving Headers
• 5.6.6. Performing Iteration
• 5.6.7. Deleting Items from a Backing Store
• 5.6.8. Locking and Unlocking a Backing Store
• 5.7. Example of Backing Store Use

• 6.1. Advantages of Using Threads
• 6.2. Software Models for Multithreaded Programming
• 6.2.1. Boss/Worker Model
• 6.2.2. Work Crew Model
• 6.2.3. Pipelining Model
• 6.2.4. Combinations of Models
• 6.3. Potential Disadvantages with Multithreaded Programming
y

• 7.1. Thread Operations
• 7.1.1. Starting a Thread
• 7.1.2. Terminating a Thread
• 7.1.3. Waiting for a Thread to Terminate
• 7.1.4. Deleting a Thread
• 7.2. New Primitives
• 7.3. Attributes Objects
• 7.3.1. Creating an Attributes Object
• 7.3.2. Deleting an Attributes Object
• 7.3.3. Thread Attributes
• 7.3.3.1. Scheduling Policy Attribute
• 7.3.3.2. Scheduling Priority Attribute
• 7.3.3.3. Inherit Scheduling Attribute
• 7.3.3.4. Stacksize Attribute
• 7.3.4. Mutex Attributes
• 7.3.5. Condition Variable Attributes
• 7.4. Synchronization Objects
• 7.4.1. Mutexes
• 7.4.2. Condition Variables
• 7.4.3. Other Synchronization Methods
• 7.5. One-Time Initialization Routines
• 7.6. Thread-Specific Data
• 7.7. Thread Cancellation
• 7.8. Thread Scheduling

• 8.1. Calling UNIX Services
• 8.1.1. Jacket Routines
• 8.1.1.1. Input and Output Jacket Routines
• 8.1.1.2. The fork() Jacket Routine
• 8.1.1.3. The atfork() Routine
• 8.1.1.4. Using the Jacketed System Calls
• 8.1.2. Blocking System Calls
• 8.1.3. Calling fork() in a Multithreaded Environment
• 8.2. Using Signals
• 8.2.1. Types of Signals
• 8.2.1.1. Terminating Signals
• 8.2.1.2. Nonterminating Signals
• 8.2.1.3. Synchronous Signals
• 8.2.1.4. Asynchronous Signals
• 8.2.2. DCE Threads Signal Handling
• 8.2.2.1. The POSIX sigwait() Service
• 8.2.2.2. The itimer VTALARM
• 8.2.3. Alternatives to Using Signals
• 8.3. Nonthreaded Libraries
• 8.3.1. Working with Nonthreaded Software
• 8.3.2. Changing Nonthreaded Code to be Thread-Reentrant
• 8.4. Avoiding Nonreentrant Software
• 8.4.1. Global Lock
• 8.4.2. Thread-Specific Storage
• 8.5. Avoiding Priority Inversion
• 8.6. Using Synchronization Objects
• 8.6.1. Race Conditions
• 8.6.2. Deadlocks
• 8.7. Signaling a Condition Variable

• 9.1. Syntax for C
• 9.2. Invoking the Exception-Returning Interface
• 9.3. Operations on Exceptions
• 9.3.1. Declaring and Initializing an Exception Object
• 9.3.2. Raising an Exception
• 9.3.3. Defining a Region of Code Over Which Exceptions Are Caught
• 9.3.4. Catching a Particular Exception or All Exceptions
• 9.3.5. Defining Epilogue Actions for a Block
• 9.3.6. Importing a System-Defined Error Status into the Program as an Exception
• 9.4. Rules and Conventions for Modular Use of Exceptions
• 9.5. DCE Threads Exceptions and Definitions

• 10.1. Details of Program Logic and Implementation

• 11.1. The Remote Procedure Call Model
• 11.1.1. RPC Application Code
• 11.1.2. Stubs
• 11.1.3. The RPC Runtime
• 11.1.4. RPC Application Components Working Together
• 11.1.5. Overview of DCE RPC Development Tasks
• 11.2. Writing an Interface Definition
• 11.2.1. RPC Interfaces Represent Services
• 11.2.2. Generating an Interface UUID
• 11.2.3. Naming the Interface
• 11.2.4. Specifying Interface Attributes
• 11.2.5. Import Declarations
• 11.2.6. Constant Declarations
• 11.2.7. Type Declarations
• 11.2.8. Operation Declarations
• 11.3. Running the IDL Compiler
• 11.4. Writing the Client Code
• 11.5. Writing the Server Code
• 11.5.1. The greet.server.c Source Code
• 11.5.1.1. Including idl-Generated Headers
• 11.5.1.2. Registering the Interface
• 11.5.1.3. Selecting Protocol Sequences
• 11.5.1.4. Obtaining the Server's Binding Handles
• 11.5.1.5. Registering Endpoints
• 11.5.1.6. Exporting to CDS
• 11.5.1.7. Listening for Calls
• 11.5.2. The greet.manager.c Source Code

• 12.1. Universal Unique Identifiers
• 12.2. Communications Protocols
• 12.3. Binding Information
• 12.3.1. Server Binding Information
• 12.3.1.1. Server Binding On a Server
• 12.3.1.2. Server Binding On a Client
• 12.3.2. Defining a Compatible Server
• 12.3.3. How Clients Obtain Server Binding Information
• 12.3.3.1. Binding Information in a Namespace
• 12.3.3.2. Binding Information in Strings
• 12.3.4. Client Binding Information for Servers
• 12.4. Endpoints
• 12.4.1. Well-Known Endpoints
• 12.4.2. Dynamic Endpoints
• 12.5. Execution Semantics
• 12.6. Communications Failures
• 12.7. Scaling Applications
• 12.8. RPC Objects

• 13.1. Overview of the RPC Routines
• 13.2. Server Initialization Using the RPC Routines
• 13.2.1. Assigning Types to Objects
• 13.2.2. Registering Interfaces
• 13.2.3. Selecting RPC Protocol Sequences
• 13.2.4. Obtaining a List of Server Binding Handles
• 13.2.5. Registering Endpoints
• 13.2.6. Making Binding Information Accessible to Clients
• 13.2.6.1. Using String Bindings to Provide Binding Information
• 13.2.6.2. Exporting Binding Information
• 13.2.7. Listening for Calls
• 13.3. How Clients Find Servers
• 13.3.1. Searching a Namespace
• 13.3.2. Using String Bindings to Obtain Binding Information

• 14.1. Threads of Execution in RPC Applications
• 14.1.1. Remote Procedure Call Threads
• 14.1.2. Cancels
• 14.1.3. Multithreaded RPC Applications
• 14.2. Security and RPC: Using Authenticated Remote Procedure Calls
• 14.2.1. Authentication
• 14.2.1.1. Cross-Cell Authentication
• 14.2.1.2. Protection Levels
• 14.2.2. Authorization
• 14.2.2.1. Name-Based Authorization
• 14.2.2.2. DCE Authorization
• 14.2.3. Authenticated RPC Routines
• 14.3. Directory Services and RPC: Using the Namespace
• 14.3.1. NSI Directory Service Entries
• 14.3.1.1. NSI Attributes
• 14.3.1.2. Structure of Entry Names
• 14.3.1.3. Server Entries
• 14.3.1.4. Groups
• 14.3.1.5. Profiles
• 14.3.1.6. Guidelines for Constructing Names of Directory Service Entries
• 14.3.1.7. Selecting the Starting Entry
• 14.3.1.8. Environment Variables
• 14.3.2. Searching the Namespace for Binding Information
• 14.3.2.1. The import.next and lookup.next Search Algorithm
• 14.3.2.2. Examples of Searching for Server Entries
• 14.3.2.3. Expiration Age of a Local Copy of Directory Service Data
• 14.3.3. Strategies for Using Directory Service Entries
• 14.3.3.1. Using Server Entries
• 14.3.3.2. Using Groups
• 14.3.3.3. Using Profiles
• 14.3.4. The Service Model for Defining Servers
• 14.3.4.1. Interchangeable Server Instances
• 14.3.4.2. Distinct Service Instances on a Single Host
• 14.3.5. The Resource Model for Defining Servers
• 14.3.5.1. Guidelines for Defining and Using RPC Resources
• 14.3.5.2. Using Objects and Groups Together
• 14.3.5.3. System-Specific Applications
• 14.3.5.4. Exporting Multiple Object UUIDs to a Single Server Entry
• 14.3.5.5. Exporting Every Object UUID to a Separate Server Entry

• 15.1. Character Sets, Code Sets, and Code Set Conversion
• 15.2. Remote Procedure Call with Character/Code Set Interoperability
• 15.3. Building An Application for Character and Code Set Interoperability
• 15.3.1. Writing the Interface Definition File
• 15.3.2. Writing the Attribute Configuration File
• 15.3.3. Writing the Stub Support Routines
• 15.3.3.1. Buffer Sizing Routines
• 15.3.3.2. Code Set Conversion Routines
• 15.3.3.3. Tag-Setting Routine
• 15.3.4. Writing the Server Code
• 15.3.4.1. Setting the Server's Locale
• 15.3.4.2. Establishing the Server's Supported Code Sets
• 15.3.4.3. Registering the Server's Supported Code Sets in the Namespace
• 15.3.4.4. Establishing a Cleanup Function for the Namespace
• 15.3.4.5. Sample Server Code
• 15.3.5. Writing the Client Code
• 15.3.5.1. Setting the Client's Locale
• 15.3.5.2. Establishing the Compatibility Evaluation Routine
• 15.3.5.3. Sample Client Code
• 15.3.6. Writing the Evaluation Routine
• 15.3.6.1. DCE RPC Evaluation Routines
• 15.3.6.2. Writing Customized Evaluation Routines
• 15.3.6.3. Notes about Tag-Setting
• 15.3.6.4. Example Character and Code Sets Evaluation Logic

• 16.1. Memory Management
• 16.1.1. Using the Memory Management Defaults
• 16.1.2. Using rpc.ss.allocate and rpc.ss.free
• 16.1.2.1. Using rpc.ss.allocate and rpc.ss.free in Manager Code
• 16.1.2.2. Using rpc.ss.allocate and rpc.ss.free in Client Code
• 16.1.3. Using Your Own Allocation and Free Routines
• 16.1.4. Using Thread Handles in Memory Management
• 16.1.4.1. Spawning Threads
• 16.1.4.2. Transitioning from Client to Server to Client
• 16.2. Guidelines for Error Handling
• 16.2.1. Exceptions
• 16.2.2. The fault.status Attribute
• 16.2.3. The comm.status Attribute
• 16.2.4. Determining Which Method to Use for Handling Exceptions
• 16.2.5. Examples of Error Handling
• 16.2.5.1. The Matrix Math Server Example
• 16.2.5.2. The Stock Quote Application Example
• 16.3. Context Handles
• 16.3.1. Context Handles in the Interface
• 16.3.2. Context Handles in a Server Manager
• 16.3.3. Context Rundown
• 16.3.4. Binding and Security Information
• 16.4. Pipes
• 16.4.1. Input Pipes
• 16.4.2. Output Pipes
• 16.4.3. Pipe Summary
• 16.5. Nested Calls and Callbacks
• 16.6. Routing Remote Procedure Calls
• 16.6.1. Obtaining an Endpoint
• 16.6.2. Buffering Call Requests
• 16.6.3. Queuing Incoming Calls
• 16.6.4. Selecting a Manager
• 16.7. Creating Portable Data Using the IDL Encoding Services
• 16.7.1. Memory Management
• 16.7.2. Buffering Styles
• 16.7.3. IDL Encoding Services Handles
• 16.7.4. Programming Example
• 16.7.5. Performing Multiple Operations on a Single Handle
• 16.7.6. Determining the Identity of an Encoding

• 17.1. The Interface Definition Language File
• 17.2. Syntax Notation Conventions
• 17.2.1. Typography
• 17.2.2. Special Symbols
• 17.3. IDL Lexical Elements
• 17.3.1. Identifiers
• 17.3.2. Keywords
• 17.3.3. Punctuation Characters
• 17.3.4. White Space
• 17.3.5. Case Sensitivity
• 17.4. IDL Versus C
• 17.4.1. Declarations
• 17.4.2. Data Types
• 17.4.3. Attributes
• 17.5. Interface Definition Structure
• 17.5.1. Interface Definition Header
• 17.5.2. Interface Definition Body
• 17.6. Overview of IDL Attributes
• 17.7. Interface Definition Header Attributes
• 17.7.1. The uuid Attribute
• 17.7.2. The version Attribute
• 17.7.3. The endpoint Attribute
• 17.7.4. The exceptions Attribute
• 17.7.5. The pointer.default Attribute
• 17.7.6. The local Attribute
• 17.7.7. Rules for Using Interface Definition Header Attributes
• 17.7.8. Examples of Interface Definition Header Attributes
• 17.8. Import Declarations
• 17.9. Constant Declarations
• 17.9.1. Integer Constants
• 17.9.2. Boolean Constants
• 17.9.3. Character Constants
• 17.9.4. String Constants
• 17.9.5. NULL Constants
• 17.10. Type Declarations
• 17.10.1. Type Attributes
• 17.10.2. Base Type Specifiers
• 17.10.3. Constructed Type Specifiers
• 17.10.4. Predefined Type Specifiers
• 17.10.5. Type Declarator
• 17.11. Operation Declarations
• 17.11.1. Operation Attributes
• 17.11.2. Operation Attributes: Execution Semantics
• 17.11.3. Operation Attributes: Memory Management
• 17.12. Parameter Declarations
• 17.13. Basic Data Types
• 17.13.1. Integer Types
• 17.13.2. Floating-Point Types
• 17.13.3. The char Type
• 17.13.4. The boolean Type
• 17.13.5. The byte Type
• 17.13.6. The void Type
• 17.13.7. The handle.t Type
• 17.13.8. The error.status.t Type
• 17.13.9. International Characters
• 17.14. Constructed Data Types
• 17.14.1. Structures
• 17.14.2. Unions
• 17.14.2.1. Encapsulated Unions
• 17.14.2.2. Nonencapsulated Unions
• 17.14.3. Enumerations
• 17.14.4. Pipes
• 17.14.4.1. IDL Pipes Example
• 17.14.4.2. Rules for Using Pipes
• 17.14.5. Arrays
• 17.14.5.1. Array Bounds
• 17.14.5.2. Conformance in Dimensions Other Than the First
• 17.14.5.3. Array Attributes
• 17.14.5.4. Rules for Using Arrays
• 17.14.6. Strings
• 17.14.7. Pointers
• 17.14.7.1. Pointer Attributes
• 17.14.7.2. Pointer Attributes in Parameters
• 17.14.7.3. Array Attributes on Pointers
• 17.14.7.4. Pointer Attributes in Function Results
• 17.14.7.5. Pointers in Structure Fields and Union Case
• 17.14.7.6. Resolving a Possible Pointer Ambiguity
• 17.14.7.7. Rules for Using Pointers
• 17.14.7.8. Memory Management for Pointed-to Nodes
• 17.14.7.9. Advanced Memory Management Support
• 17.14.7.10. Use of Thread Handles in Memory Management
• 17.14.7.11. Rules for Using the Memory Management Routines
• 17.14.7.12. Examples Using Pointers
• 17.14.8. Customized Handles
• 17.14.9. Context Handles
• 17.14.9.1. The context.handle Attribute
• 17.14.9.2. The Context Rundown Procedure
• 17.14.9.3. Creating New Context
• 17.14.9.4. Reclaiming Client Memory Resources for the Context Handle
• 17.14.9.5. Relationship of Context Handles and Binding
• 17.14.9.6. Rules for Using Context Handles
• 17.14.9.7. Examples Using Context Handles
• 17.15. Associating a Data Type with a Transmitted Type
• 17.16. IDL Grammar Synopsis

• 18.1. Syntax Notation Conventions
• 18.2. Attribute Configuration File
• 18.2.1. Naming the ACF
• 18.2.2. Compiling the ACF
• 18.2.3. ACF Features
• 18.3. Structure
• 18.3.1. ACF Interface Header
• 18.3.2. ACF Interface Body
• 18.3.3. The include Statement
• 18.3.4. The auto.handle Attribute
• 18.3.5. The explicit.handle Attribute
• 18.3.6. The implicit.handle Attribute
• 18.3.7. The comm.status and fault.status Attributes
• 18.3.8. The code and nocode Attributes
• 18.3.9. The in.line and out.of.line Attributes
• 18.3.10. The represent.as Attribute
• 18.3.11. The enable.allocate Attribute
• 18.3.12. The heap Attribute
• 18.3.13. The extern.exceptions Attribute
• 18.3.14. The encode and decode Attributes
• 18.3.15. The cs.char Attribute
• 18.3.16. The cs.stag, cs.drtag, and cs.rtag Attributes
• 18.3.17. The cs.tag.rtn Attribute
• 18.3.18. The binding.callout Attribute
• 18.4. Summary of Attributes
• 18.5. Attribute Configuration Language

• 19.1. DTS Time Representation
• 19.1.1. Absolute Time Representation
• 19.1.2. Relative Time Representation
• 19.2. Time Structures
• 19.2.1. The utc Structure
• 19.2.2. The tm Structure
• 19.2.3. The timespec Structure
• 19.2.4. The reltimespec Structure
• 19.3. DTS API Header Files
• 19.4. DTS API Routine Functions

• 20.1. General TPI Control Flow
• 20.1.1. ContactProvider Procedure
• 20.1.2. ServerRequestProviderTime Procedure
• 20.2. Time-Provider Process IDL File
• 20.3. Initializing the Time-Provider Process
• 20.4. Time-Provider Algorithm
• 20.5. DTS Synchronization Algorithm
• 20.6. Running the Time-Provider Process
• 20.7. Sources of Additional Information

• 22.1. Purpose and Organization of This Part of the Guide
• 22.2. About Authenticated RPC
• 22.3. About the Generic Security Service API
• 22.4. UNIX System Security and DCE Security
• 22.5. What Authentication and Authorization Mean
• 22.6. Authentication, Authorization, and Data Protection in Brief
• 22.7. Summary of DCE Security Services and Facilities
• 22.7.1. Interfaces to the Security Server
• 22.7.1.1. Registry Service Interfaces
• 22.7.1.2. Authentication Service Interfaces
• 22.7.1.3. Privilege Service Interfaces
• 22.7.2. Interfaces to the Login Facility
• 22.7.3. Interfaces to the Extended Registry Attribute Facility
• 22.7.4. Interfaces to the Extended Privilege Attribute Facility
• 22.7.5. Interfaces to the Key Management Facility
• 22.7.6. Interfaces to the ID Map Facility
• 22.7.7. Interfaces to the Access Control List Facility
• 22.7.8. DCE Implementations of UNIX System Program Interfaces
• 22.7.9. Interfaces to the Password Management Facility
• 22.8. Relationships Between the Security Service and DCE Applications
• 22.9. DTS, the Cell Namespace, and Security
• 22.9.1. DTS and Security
• 22.9.2. The Cell Namespace and the Security Namespace

• 23.1. Background Concepts
• 23.1.1. Principals
• 23.1.2. Cells and Realms
• 23.1.3. The Shared-Secret Authentication Protocol
• 23.1.4. Protection Levels
• 23.1.4.1. Authenticated RPC and Protection Levels
• 23.1.4.2. GSSAPI and Protection Levels
• 23.1.5. Data Encryption Mechanisms
• 23.2. A Walkthrough of the Shared-Secret Authentication Protocol
• 23.2.1. A Walkthrough of User Authentication
• 23.2.1.1. How the Security Client Obtains a Ticket-Granting Ticket
• 23.2.1.2. How the Client Obtains a Privilege-Ticket-Granting Ticket
• 23.2.1.3. The Login Context
• 23.2.1.4. Identities in a Delegation Chain
• 23.2.2. A Walkthrough of DCE Application Authentication using Authenticated RPC
• 23.2.3. A Walkthrough of DCE Application Authentication Using GSSAPI
• 23.3. Intercell Authentication
• 23.3.1. Authentication Service Surrogates
• 23.3.2. Intercell Authentication by Trust Peers

• 24.1. DCE Authorization
• 24.1.1. Object Types and ACL Types
• 24.1.2. ACL Manager Types
• 24.1.3. Access Control Lists
• 24.1.4. ACL Entries
• 24.1.4.1. Privilege Attribute Entry Types
• 24.1.4.2. Mask Entry Types
• 24.1.4.3. The Extended ACL Entry Type
• 24.1.5. Access Checking
• 24.1.5.1. The user.obj Entry Check
• 24.1.5.2. The User Entries Check
• 24.1.5.3. The Group Entries Check
• 24.1.5.4. The other.obj Entry Check
• 24.1.5.5. The foreign.other Entries Check
• 24.1.5.6. The any.other Entry Check
• 24.1.6. Examples of ACL Checking
• 24.1.6.1. Example 1
• 24.1.6.2. Example 2
• 24.1.6.3. Example 3

• 25.1. Using Default Credentials
• 25.1.1. Initiate a Security Context
• 25.1.2. Accept a Security Context
• 25.2. Creating New Credential Handles
• 25.2.1. Initiating a Security Context with New Credential Handles
• 25.2.2. Accepting a Security Context Using New Credential Handles
• 25.3. Delegating Credentials
• 25.3.1. Initiating a Security Context to Delegate Credentials
• 25.3.2. Accepting a Security Context with Delegated Credentials

• 26.1. Identities of Principals in Delegation
• 26.1.1. ACL Entry Types for Delegation
• 26.1.2. ACL Checking for Delegation
• 26.2. Calls to Establish Delegation Chains
• 26.2.1. Types of Delegation
• 26.2.2. Target and Delegate Restrictions
• 26.2.3. Optional and Required Restrictions
• 26.2.4. Compatibility Between 1.1 and Pre-1.1 Servers and Clients
• 26.3. Calls to Extract Privilege Attribute Information
• 26.3.1. Opaque Handles for sec.cred Calls
• 26.4. Disabling Delegation
• 26.5. Setting Extended Attributes

• 27.1. Binding to a Registry Site
• 27.2. The Registry Database
• 27.2.1. Creating and Maintaining PGO Items
• 27.2.2. Creating and Maintaining Accounts
• 27.2.3. Registry Properties and Policies
• 27.2.3.1. Registry Properties
• 27.2.3.2. The Registry Authentication Policy
• 27.2.3.3. Organization Policies
• 27.2.4. Routines to Return UNIX Structures
• 27.2.5. Miscellaneous Registry Routines

• 28.1. Extended Registry Attribute API
• 28.1.1. Attribute Schema
• 28.1.2. Attribute Types and Instances
• 28.1.3. Attribute Type Components
• 28.1.3.1. Attribute Encoding
• 28.1.3.2. ACL Manager Set
• 28.1.3.3. Attribute Flags
• 28.1.3.4. Intercell Action Field
• 28.1.3.5. Attribute Scope
• 28.1.3.6. Trigger Type Flag
• 28.1.3.7. Trigger Binding
• 28.2. Calls to Manipulate Schema Entries
• 28.2.1. The sec.attr.schema.entry.t Data Type
• 28.2.2. Creating and Managing Schema Entries
• 28.2.2.1. sec.rgy.attr.sch.create.entry()
• 28.2.2.2. sec.rgy.attr.sch.update.entry()
• 28.2.2.3. sec.rgy.attr.sch.delete.entry()
• 28.2.3. Reading Schema Entries
• 28.2.3.1. Using sec.attr.cursor.t with sec.rgy.attr.sch.scan()
• 28.2.3.2. sec.rgy.attr.sch.scan()
• 28.2.3.3. sec.rgy.attr.sch.lookup.by.id() and sec.rgy.attr.sch.lookup.by.name()
• 28.2.4. Reading the ACL Manager Types
• 28.3. Calls to Manipulate Attribute Instances
• 28.3.1. The sec_attr_t Data Type
• 28.3.2. Creating and Managing Attribute Instances
• 28.3.2.1. The sec_rgy_attr_update() Call
• 28.3.2.2. The sec_rgy_attr_test_and_update() Call
• 28.3.2.3. The sec_rgy_attr_delete() Call
• 28.3.3. Reading Attribute Instances
• 28.3.3.1. Using sec_rgy_attr_cursor_t with sec.rgy.attr.lookup.by.id()
• 28.3.3.2. The sec_rgy_attr_lookup_by_id() Call
• 28.3.3.3. The sec_rgy_attr_set_lookup_by_id()
• 28.3.3.4. The sec_rgy_attr_lookup_by_name() Call
• 28.4. The Attribute Trigger Facility
• 28.4.1. Defining a Attribute Trigger/Attribute Association
• 28.4.1.1. Query Triggers
• 28.4.1.2. Update Triggers
• 28.4.2. Trigger Binding
• 28.4.2.1. The sec_attr_binding_t Data Type
• 28.4.2.2. The sec_attr_bind_auth_info_t Data Type
• 28.4.3. Access Control on Attributes with Triggers
• 28.5. Calls that Access Attribute Triggers
• 28.5.1. Using sec.attr.trig.cursor.t with sec.attr.trig.query()
• 28.5.2. sec.rgy.attr.trig.query() and sec.rgy.attr.trig.update()
• 28.5.3. priv.attr.triq.query()
• 28.6. The DCE Attribute API
• 28.7. Macros to Aid Extended Attribute Programming
• 28.7.1. Macros to Access Binding Fields
• 28.7.2. Macros to Access Attribute Instance Fields
• 28.7.3. Binding Data Structure Size Calculation Macros
• 28.7.4. Schema Entry Data Structure Size Calculation Macros
• 28.7.5. Attribute Instance Data Structure Size Calculation Macros
• 28.7.6. Binding Semantic Check Macros
• 28.7.7. Schema Entry Semantic Check Macros
• 28.7.8. Attribute Instance Semantic Check Macros
• 28.7.9. Schema Entry Flag Set and Unset Macros
• 28.7.10. Schema Trigger Entry Flag Check Macros
• 28.8. Utilities to Use with Extended Attribute Calls
29. The Login Application Program Interface
• 29.1. Establishing Login Contexts
• 29.1.1. Validating the Login Context and Certifying the Security Server
• 29.1.2. Validating the Login Context Without Certifying the Security Server
• 29.1.3. Example of a System Login Program
• 29.2. Context Inheritance
• 29.2.1. The Initial Context
• 29.2.2. Private Contexts
• 29.3. Handling Expired Certificates of Identity
• 29.4. Importing and Exporting Contexts
• 29.5. Changing a Groupset
• 29.6. Miscellaneous Login API Functions
• 29.6.1. Getting the Current Context
• 29.6.2. Getting Information from a Login Context
• 29.6.3. Getting Password and Group Information for Local Process Identities
• 29.6.4. Releasing and Purging a Context
30. The Key Management Application Program Interface
• 30.1. Retrieving a Key
• 30.2. Changing a Key
• 30.3. Automatic Key Management
• 30.4. Deleting Expired Keys
• 30.5. Deleting a Compromised Key
31. The Access Control List Application Program Interfaces
• 31.1. The Client-Side API
• 31.1.1. Binding to an ACL
• 31.1.2. ACL Editors and Browsers
• 31.1.3. Errors
• 31.2. The Server-Side API
• 31.3. Guidelines for Constructing ACL Managers
• 31.4. Extended Naming of Protected Objects
• 31.4.1. The ACL Network Interface
• 31.4.2. The ACL Library
• 31.4.2.1. ACL Library Capabilities
• 31.4.2.2. The ACL Application Programmer Interface
32. The ID Map Application Program Interface 33. DCE Audit Service
• 33.1. Features of the DCE Audit Service
• 33.2. Components of DCE Audit Service
• 33.3. DCE Audit Service Concepts
• 33.3.1. Audit Clients
• 33.3.2. Code Point
• 33.3.3. Events
• 33.3.3.1. Event Names and Event Numbers
• 33.3.3.2. Event Number Formats
• 33.3.3.3. Administration of Event Numbers
• 33.3.4. Event Class
• 33.3.5. Event Class Number
• 33.3.6. Filters
• 33.3.6.1. Filter Subject Identity
• 33.3.7. Audit Records
• 33.3.8. Audit Trail File
• 33.4. Administration and Programming in DCE Audit
• 33.4.1. Programmer Tasks
• 33.4.2. Administrator Tasks
34. Using the Audit API Functions
• 34.1. Adding Audit Capability to Distributed Applications
• 34.1.1. Opening the Audit Trail
• 34.1.2. Initializing the Audit Records
• 34.1.3. Adding Event-Specific Information
• 34.1.4. Committing an Audit Record
• 34.1.5. Closing an Audit Trail File
• 34.2. Writing Audit Trail Analysis and Examination Tools
• 34.2.1. Opening an Audit Trail File for Reading
• 34.2.2. Transforming the Audit Record into Readable Text
• 34.2.3. Discarding the Audit Record
• 34.2.4. Closing the Audit Trail File
35. The Password Management Application Programming Interfaces
• 35.1. The Client-Side API
• 35.1.1. Example of a Password Change Program
• 35.2. The Password Management Network Interface

---

© 1990-1996, Transarc Corporation