OSF DCE Application Devel. Guide--Core Components

• Preface
  • Copyright Information

  • Overview

  • Document Usage

  • Related Documents

  • Typographic and Keying Conventions

  • Problem Reporting

  • Path Names of Directories and Files in DCE Documentation

• Part 1. DCE Facilities
  • Part 1 Topics

• Introduction to DCE Facilities
  • Overview - Introduction to DCE Facilities

• DCE Host Services
  • Overview - DCE Host Services

  • Types of Applications

  • Issues of Distributed Applications

  • Managing a Host's Endpoint Map

  • Binding to dced Services
    • Binding to dced Services

    • Host Service Naming in Applications

    • The dced Programs Maintains Entry Lists

    • Reading All of a Host Service's Data

    • Managing Individual dced Entries

  • Managing Hostdata on a Remote Host
    • Managing Hostdata on a Remote Host

    • Kinds of Hostdata Stored

    • Adding New Hostdata

    • Modifying Hostdata

    • Running Programs Automatically When Hostdata Changes

  • Controlling Servers Remotely
    • Controlling Servers Remotely

    • Two States of Server Management: Configuration and Execution

    • Configuring Servers
      • Configuring Servers

      • Configuring a New DCE Server

      • Modifying a Server's Configuration Attributes

      • Deleting a DCE Server

    • Starting and Stopping Servers
      • Starting and Stopping Servers

    • Enabling and Disabling Services of a Server
      • Enabling and Disabling Services of a Server

  • Validating the Security Server
    • Validating the Security Server

  • Managing Server Key Tables
    • Managing Server Key Tables

  • Sample dced Application
    • Sample dced Application

    • Running the Program

    • greet_dced.idl

    • greet_dced_server.c

    • greet_dced_manager.c

    • greet_dced_client.c

    • util.c

    • util.h

    • greet_dced.install

    • greet_dced.delete

    • Makefile

• DCE Application Messaging
  • Overview - DCE Application Messaging

  • DCE and Messages

  • DCE Messaging Interface Usage
    • DCE Messaging Interface Usage

    • A Simple DCE Messaging Example
      • A Simple DCE Messaging Example

      • Defining the Message

      • Processing the .sams File

      • Program Source

      • DCE Messaging and Message Catalogs

    • The DCE Message Interface and sams Input and Output Files
      • The DCE Message Interface and sams Input and Output Files

  • DCE Messaging Routines
    • DCE Messaging Routines

    • Message Output Routines

    • Message Retrieval Routines

    • Message Table Routines

    • DCE XPG4 Routines

• Using the DCE Serviceability Application Interface
  • Overview - Using the DCE Serviceability Application Interface
    • Overview - Using the DCE Serviceability Application Interface

    • How Programs Use Serviceability

    • Simple Serviceability Interface Tutorial
      • Simple Serviceability Interface Tutorial

      • Defining the Message

      • Processing the sams File

      • Coding the Serviceability Calls

      • Building and Running the Program

      • Fields of a Serviceability Message

    • Serviceability Input and Output Files
      • Serviceability Input and Output Files

  • Integrating Serviceability into a Server
    • Integrating Serviceability into a Server

    • Serviceability Strategy

    • Components and Subcomponents

    • Identifying Event Points

  • Application Use of Serviceability
    • Application Use of Serviceability

    • Basic Server Calls

    • Extended Format Notation for Message Text

    • Specifying Message Severity

    • How to Route Messages
      • How to Route Messages

      • Using a Routing File

      • Routing by Environment Variable

      • Calling dce_svc_routing( ) to Set Routing

      • Additional Routing by Attribute

    • Table of Message Processing Specifiers
      • Table of Message Processing Specifiers

    • Logging and Log Reading
      • Logging and Log Reading

    • Message Action Attributes
      • Message Action Attributes

    • Suppressing the Serviceability Message Prolog
      • Suppressing the Serviceability Message Prolog

    • Serviceability Use of the __FILE__ Macro
      • Serviceability Use of the __FILE__ Macro

    • Forcing Use of the In-Memory Message Table
      • Forcing Use of the In-Memory Message Table

    • Dynamically Filtering Messages Before Output
      • Dynamically Filtering Messages Before Output

    • Using Serviceability for Debug Messages
      • Using Serviceability for Debug Messages

      • Setting Debug Levels

      • Routing Debug Messages

    • Performance Costs of Serviceability Debugging
      • Performance Costs of Serviceability Debugging

    • Using the Remote Serviceability Interface
      • Using the Remote Serviceability Interface

      • Basic Steps in Setting Up the Remote Interface

      • Implementing the Remote Routines

      • Registering and Exporting the Remote Interface

      • Importing and Accessing the Remote Interface

• The DCE Backing Store
  • Overview - The DCE Backing Store

  • Data in a Backing Store

  • Using a Backing Store

  • Header for Data

  • The User Interface

  • The IDL Encoding Services
    • The IDL Encoding Services

    • Encoding and Decoding in the Backing Store

    • Conformant Arrays Not Allowed

  • The Backing Store Routines
    • The Backing Store Routines

    • Opening a Backing Store

    • Closing a Backing Store

    • Storing or Retrieving Data

    • Freeing Data

    • Making or Retrieving Headers

    • Performing Iteration

    • Deleting Items from a Backing Store

    • Locking and Unlocking a Backing Store

  • Example of Backing Store Use
    • Example of Backing Store Use

• Part 2. DCE Threads
  • Part 2 Topics

• Introduction to Multithreaded Programming
  • Overview - Introduction to Multithreaded Programming

  • Advantages of Using Threads

  • Software Models for Multithreaded Programming
    • Software Models for Multithreaded Programming

    • Boss/Worker Model

    • Work Crew Model

    • Pipelining Model

    • Combinations of Models

  • Potential Disadvantages of Multithreaded Programming
    • Potential Disadvantages of Multithreaded Programming

• Thread Concepts and Operations
  • Overview - Thread Concepts and Operations

  • Thread Operations
    • Thread Operations

    • Starting a Thread

    • Terminating a Thread

    • Waiting for a Thread to Terminate

    • Deleting a Thread

  • New Primitives
    • New Primitives

  • Attributes Objects
    • Attributes Objects

    • Creating an Attributes Object

    • Deleting an Attributes Object

    • Thread Attributes
      • Thread Attributes

      • Scheduling Policy Attribute

      • Scheduling Priority Attribute

      • Inherit Scheduling Attribute

      • Stacksize Attribute

    • Mutex Attributes
      • Mutex Attributes

    • Condition Variable Attributes
      • Condition Variable Attributes

  • Synchronization Objects
    • Synchronization Objects

    • Mutexes

    • Condition Variables

    • Other Synchronization Methods

  • One-Time Initialization Routines
    • One-Time Initialization Routines

  • Thread-Specific Data
    • Thread-Specific Data

  • Thread Cancellation
    • Thread Cancellation

  • Thread Scheduling
    • Thread Scheduling

• Programming with Threads
  • Overview - Programming with Threads

  • Calling UNIX Services
    • Calling UNIX Services

    • Jacket Routines
      • Jacket Routines

      • Input and Output Jacket Routines

      • The fork( ) Jacket Routine

      • The atfork( ) Routine

      • Using the Jacketed System Calls

    • Blocking System Calls
      • Blocking System Calls

    • Calling fork( ) in a Multithreaded Environment
      • Calling fork( ) in a Multithreaded Environment

  • Using Signals
    • Using Signals

    • Types of Signals
      • Types of Signals

      • Terminating Signals

      • Nonterminating Signals

      • Synchronous Signals

      • Asynchronous Signals

    • DCE Threads Signal Handling
      • DCE Threads Signal Handling

      • The POSIX sigwait( ) Service

      • The POSIX sigaction( ) Service

      • The itimer VTALARM

    • Alternatives to Using Signals
      • Alternatives to Using Signals

  • Nonthreaded Libraries
    • Nonthreaded Libraries

    • Working with Nonthreaded Software

    • Making Nonthreaded Code Thread-Reentrant

  • Avoiding Nonreentrant Software
    • Avoiding Nonreentrant Software

    • Global Lock

    • Thread-Specific Storage

  • Avoiding Priority Inversion
    • Avoiding Priority Inversion

  • Using Synchronization Objects
    • Using Synchronization Objects

    • Race Conditions

    • Deadlocks

  • Signaling a Condition Variable
    • Signaling a Condition Variable

• Using the DCE Threads Exception-Returning Interface
  • Overview - Using the DCE Threads Exception-Returning Interface

  • Syntax for C

  • Invoking the Exception-Returning Interface

  • Operations on Exceptions
    • Operations on Exceptions

    • Declaring and Initializing an Exception Object

    • Raising an Exception

    • Defining a Region of Code over Which Exceptions Are Caught

    • Catching a Particular Exception or All Exceptions

    • Defining Epilogue Actions for a Block

    • Importing a System-Defined Error Status into the Program as an Exception

  • Rules and Conventions for Modular Use of Exceptions
    • Rules and Conventions for Modular Use of Exceptions

  • DCE Threads Exceptions and Definitions
    • DCE Threads Exceptions and Definitions

• DCE Threads Example
  • Overview - DCE Threads Example

  • Details of Program Logic and Implementation

  • DCE Threads Example Body

• Part 3. DCE Remote Procedure Call
  • Part 3 Topics

• Developing a Simple RPC Application
  • Overview - Developing a Simple RPC Application

  • The Remote Procedure Call Model
    • The Remote Procedure Call Model

    • RPC Application Code

    • Stubs

    • The RPC Runtime

    • RPC Application Components That Work Together

    • Overview of DCE RPC Development Tasks

  • Writing an Interface Definition
    • Writing an Interface Definition

    • RPC Interfaces That Represent Services

    • Generating an Interface UUID

    • Naming the Interface

    • Specifying Interface Attributes

    • Import Declarations

    • Constant Declarations

    • Type Declarations

    • Operation Declarations

  • Running the IDL Compiler
    • Running the IDL Compiler

  • Writing the Client Code
    • Writing the Client Code

  • Writing the Server Code
    • Writing the Server Code

    • The greet_server.c Source Code
      • The greet_server.c Source Code

      • Including idl-Generated Headers

      • Registering the Interface

      • Selecting Protocol Sequences

      • Obtaining the Server's Binding Handles

      • Registering Endpoints

      • Exporting to CDS

      • Listening for Calls

    • The greet_manager.c Source Code
      • The greet_manager.c Source Code

  • Building the greet Programs
    • Building the greet Programs

  • Running the greet Programs
    • Running the greet Programs

• RPC Fundamentals
  • Overview - RPC Fundamentals

  • Universal Unique Identifiers

  • Communications Protocols

  • Binding Information
    • Binding Information

    • Server Binding Information
      • Server Binding Information

      • Server Binding On a Server

      • Server Binding On a Client

    • Defining a Compatible Server
      • Defining a Compatible Server

    • How Clients Obtain Server Binding Information
      • How Clients Obtain Server Binding Information

      • Binding Information in a Namespace

      • Binding Information in Strings

    • Client Binding Information for Servers
      • Client Binding Information for Servers

  • Endpoints
    • Endpoints

    • Well-Known Endpoints

    • Dynamic Endpoints

  • Execution Semantics
    • Execution Semantics

  • Communications Failures
    • Communications Failures

  • Scaling Applications
    • Scaling Applications

  • RPC Objects
    • RPC Objects

• Basic RPC Routine Usage
  • Overview - Basic RPC Routine Usage

  • Overview of the RPC Routines
    • Overview of the RPC Routines

    • Basic Operations of RPC Communications

    • Basic Operations of the NSI

    • Basic Operations of Authenticated RPCs

  • Server Initialization Using the RPC Routines
    • Server Initialization Using the RPC Routines

    • Assigning Types to Objects

    • Registering Interfaces

    • Selecting RPC Protocol Sequences

    • Obtaining a List of Server Binding Handles

    • Registering Endpoints

    • Making Binding Information Accessible to Clients
      • Making Binding Information Accessible to Clients

      • Using String Bindings to Provide Binding Information

      • Exporting Binding Information

    • Listening for Calls
      • Listening for Calls

  • How Clients Find Servers
    • How Clients Find Servers

    • Searching a Namespace

    • Using String Bindings to Obtain Binding Information

• RPC and Other DCE Components
  • Overview - RPC and Other DCE Components

  • Threads of Execution in RPC Applications
    • Threads of Execution in RPC Applications

    • Remote Procedure Call Threads

    • Cancels

    • Multithreaded RPC Applications

  • Security and RPC: Using Authenticated Remote Procedure Calls
    • Security and RPC: Using Authenticated Remote Procedure Calls

    • Authentication
      • Authentication

      • Cross-Cell Authentication

      • Protection Levels

    • Authorization
      • Authorization

      • Name-Based Authorization

      • DCE Authorization

    • Authenticated RPC Routines
      • Authenticated RPC Routines

    • Using RPC Within a Single Thread
      • Using RPC Within a Single Thread

  • Directory Services and RPC: Using the Namespace
    • Directory Services and RPC: Using the Namespace

    • NSI Directory Service Entries
      • NSI Directory Service Entries

      • NSI Attributes

      • Structure of Entry Names

      • Server Entries

      • Groups

      • Profiles

      • Guidelines for Constructing Names of Directory Service Entries

      • Selecting the Starting Entry

      • Environment Variables

    • Searching the Namespace for Binding Information
      • Searching the Namespace for Binding Information

      • The import_next and lookup_next Search Algorithm

      • Examples of Searching for Server Entries

      • Expiration Age of a Local Copy of Directory Service Data

    • Strategies for Using Directory Service Entries
      • Strategies for Using Directory Service Entries

      • Using Server Entries

      • Using Groups

      • Using Profiles

    • The Service Model for Defining Servers
      • The Service Model for Defining Servers

      • Interchangeable Server Instances

      • Distinct Service Instances on a Single Host

    • The Resource Model for Defining Servers
      • The Resource Model for Defining Servers

      • Guidelines for Defining and Using RPC Resources

      • Using Objects and Groups Together

      • System-Specific Applications

      • Exporting Multiple Object UUIDs to a Single Server Entry

      • Exporting Every Object UUID to a Separate Server Entry

• Developing Applications that Use Distributed Objects
  • Overview - Developing Applications that Use Distributed Objects

  • IDL and the Class Hierarchy of a DCE Application
    • IDL and the Class Hierarchy of a DCE Application

    • Specifying a C++ Class via an IDL Interface

    • IDL-Generated Classes as Part of Your Hierarchy

  • Servers that Manage Distributed Objects
    • Servers that Manage Distributed Objects

    • Initializing Object-Oriented Servers

    • Implementing Distributed-Dynamic Objects

    • Implementing Static Member Functions

    • When Function Parameters Are Remote Objects

    • Naming Objects
      • Naming Objects

      • Registering Named Objects

      • Placing an Object's Name Directly in the Name Service

      • Dynamically Creating Named or Persistent Objects

      • Storing and Retrieving Persistent Objects

  • Clients That Use Distributed Objects
    • Clients That Use Distributed Objects

    • Creating Remote-Dynamic Objects

    • Creating Client-Local Objects

    • Location Transparency of Local and Remote Objects

    • Finding Known Remote Objects
      • Finding Known Remote Objects

      • Binding to Named Objects By Name

      • Binding to Named Objects by UUID

      • Binding Explicitly to Known Objects

  • Multiple Interfaces and Interface Inheritance
    • Multiple Interfaces and Interface Inheritance

    • Implementing Multiple Managers

    • Using Objects that Support Multiple Interfaces
      • Using Objects that Support Multiple Interfaces

      • Binding by Object Reference to Use a Different Interface

      • Finding Out if an Interface is Supported

      • Multiple Interfaces and Local Objects: a C++ Enhancement

  • Passing C++ Objects as DCE RPC Parameters
    • Passing C++ Objects as DCE RPC Parameters

    • Representation

    • Delegation

  • Integrating C and C++ Clients and Servers
    • Integrating C and C++ Clients and Servers

    • Writing a C++ Client for C Servers

    • Writing a C Client for C++ Servers

• Writing Internationalized RPC Applications
  • Overview - Writing Internationalized RPC Applications

  • Character Sets, Code Sets, and Code Set Conversion

  • Remote Procedure Call with Character/Code Set Interoperability

  • Building An Application for Character and Code Set Interoperability
    • Building An Application for Character and Code Set Interoperability

    • Writing the Interface Definition File

    • Writing the Attribute Configuration File

    • Writing the Stub Support Routines
      • Writing the Stub Support Routines

      • Buffer Sizing Routines

      • Code Set Conversion Routines

      • Tag-Setting Routine

    • Writing the Server Code
      • Writing the Server Code

      • Setting the Server's Locale

      • Establishing the Server's Supported Code Sets

      • Registering the Server's Supported Code Sets in the Namespace

      • Establishing a Cleanup Function for the Namespace

      • Sample Server Code

    • Writing the Client Code
      • Writing the Client Code

      • Setting the Client's Locale

      • Establishing the Compatibility Evaluation Routine

      • Sample Client Code

    • Writing the Evaluation Routine
      • Writing the Evaluation Routine

      • DCE RPC Evaluation Routines

      • Writing Customized Evaluation Routines

      • Notes about Tag-Setting

      • Example Character and Code Sets Evaluation Logic

• Topics in RPC Application Development
  • Overview - Topics in RPC Application Development

  • Memory Management
    • Memory Management

    • Using the Memory Management Defaults

    • Using rpc_ss_allocate and rpc_ss_free
      • Using rpc_ss_allocate and rpc_ss_free

      • Using rpc_ss_allocate and rpc_ss_free in Manager Code

      • Using rpc_ss_allocate and rpc_ss_free in Client Code

    • Using Your Own Allocation and Free Routines
      • Using Your Own Allocation and Free Routines

    • Using Thread Handles in Memory Management
      • Using Thread Handles in Memory Management

      • Spawning Threads

      • Transitioning from Client to Server to Client

  • Guidelines for Error Handling
    • Guidelines for Error Handling

    • Exceptions

    • The fault_status Attribute

    • The comm_status Attribute

    • Determining Which Method to Use for Handling Exceptions

    • Examples of Error Handling
      • Examples of Error Handling

      • The Matrix Math Server Example

      • The Stock Quote Application Example

  • Context Handles
    • Context Handles

    • Context Handles in the Interface

    • Context Handles in a Server Manager

    • Context Rundown

    • Binding and Security Information

  • Pipes
    • Pipes

    • Input Pipes

    • Output Pipes

    • Pipe Summary

  • Nested Calls and Callbacks
    • Nested Calls and Callbacks

  • Routing Remote Procedure Calls
    • Routing Remote Procedure Calls

    • Obtaining an Endpoint

    • Buffering Call Requests

    • Queuing Incoming Calls

    • Selecting a Manager

  • Creating Portable Data via the IDL Encoding Services
    • Creating Portable Data via the IDL Encoding Services

    • Memory Management

    • Buffering Styles

    • IDL Encoding Services Handles

    • Programming Example

    • Performing Multiple Operations on a Single Handle

    • Determining the Identity of an Encoding

• Interface Definition Language
  • Language Overview - Interface Definition Language

  • The Interface Definition Language File

  • Syntax Notation Conventions
    • Syntax Notation Conventions

    • Typography

    • Special Symbols

  • IDL Lexical Elements
    • IDL Lexical Elements

    • Identifiers

    • Keywords

    • Punctuation Characters

    • White Space

    • Case Sensitivity

  • IDL Versus C
    • IDL Versus C

    • Declarations

    • Data Types

    • Attributes

  • Interface Definition Structure
    • Interface Definition Structure

    • Interface Definition Header

    • Interface Definition Body

  • Overview of IDL Attributes
    • Overview of IDL Attributes

  • Interface Definition Header Attributes
    • Interface Definition Header Attributes

    • The uuid Attribute

    • The version Attribute

    • The endpoint Attribute

    • The exceptions Attribute

    • The pointer_default Attribute

    • The local Attribute

    • Rules for Using Interface Definition Header Attributes

    • Examples of Interface Definition Header Attributes

  • Import Declarations
    • Import Declarations

  • Constant Declarations
    • Constant Declarations

    • Integer Constants

    • Boolean Constants

    • Character Constants

    • String Constants

    • NULL Constants

  • Type Declarations
    • Type Declarations

    • Type Attributes

    • Base Type Specifiers

    • Constructed Type Specifiers

    • Predefined Type Specifiers

    • Type Declarator

  • Operation Declarations
    • Operation Declarations

    • Operation Attributes

    • Operation Attributes: Execution Semantics

    • Operation Attributes: Memory Management

  • Parameter Declarations
    • Parameter Declarations

  • Basic Data Types
    • Basic Data Types

    • Integer Types

    • Floating-Point Types

    • The char Type

    • The boolean Type

    • The byte Type

    • The void Type

    • The handle_t Type

    • The error_status_t Type

    • International Characters

  • Constructed Data Types
    • Constructed Data Types

    • Structures

    • Unions
      • Unions

      • Encapsulated Unions

      • Nonencapsulated Unions

    • Enumeration
      • Enumeration

    • Pipes
      • Pipes

      • IDL Pipes Example

      • Rules for Using Pipes

    • Arrays
      • Arrays

      • Array Bounds

      • Conformance in Dimensions Other Than the First

      • Array Attributes

      • Rules for Using Arrays

    • Strings
      • Strings

    • Pointers
      • Pointers

      • Pointer Attributes

      • Pointer Attributes in Parameters

      • Array Attributes on Pointers

      • Pointer Attributes in Function Results

      • Pointers in Structure Fields and Union Case

      • Resolving a Possible Pointer Ambiguity

      • Rules for Using Pointers

      • Memory Management for Pointed-to Nodes

      • Advanced Memory Management Support

      • Use of Thread Handles in Memory Management

      • Rules for Using the Memory Management Routines

      • Examples Using Pointers

    • Customized Handles
      • Customized Handles

    • Context Handles
      • Context Handles

      • The context_handle Attribute

      • The Context Rundown Procedure

      • Creating New Context

      • Reclaiming Client Memory Resources for the Context Handle

      • Relationship of Context Handles and Binding

      • Rules for Using Context Handles

      • Examples Using Context Handles

  • IDL Support for C++
    • IDL Support for C++

    • The idl-generated Class Hierarchy

    • The Interface Inheritance Operator

    • The static Keyword for Operations

    • The C++ Reference Operator (&) on Parameters

    • Functions Generated by IDL

  • Associating a Data Type with a Transmitted Type
    • Associating a Data Type with a Transmitted Type

  • IDL Grammar Synopsis
    • IDL Grammar Synopsis

• Attribute Configuration Language
  • ACF Overview - Attribute Configuration Language

  • Syntax Notation Conventions

  • Attribute Configuration File
    • Attribute Configuration File

    • Naming the ACF

    • Compiling the ACF

    • ACF Features

  • Structure
    • Structure

    • ACF Interface Header

    • ACF Interface Body

    • The include Statement and the C++ cstub and sstub

    • The auto_handle Attribute

    • The explicit_handle Attribute

    • The implicit_handle Attribute

    • The client_memory Attribute

    • The comm_status and fault_status Attributes

    • The code and nocode Attributes

    • The represent_as Attribute

    • The enable_allocate Attribute

    • The heap Attribute

    • The extern_exceptions Attribute

    • The encode and decode Attributes

    • The cs_char Attribute

    • The cs_stag, cs_drtag, and cs_rtag Attributes

    • The cs_tag_rtn Attribute

    • The binding_callout Attribute

    • The C++ Attributes cxx_new, cxx_static, cxx_lookup, and cxx_delegate
      • The C++ Attributes cxx_new, cxx_static, cxx_lookup, and cxx_delegate

      • Using cxx_new to Declare an Object Creator Function

      • Using cxx_static to Specify Static Interface Member Functions

      • Using cxx_lookup to Declare a Server's Object Lookup Function

  • Summary of Attributes
    • Summary of Attributes

  • Attribute Configuration Language
    • Attribute Configuration Language

• Part 4. DCE Distributed Time Service
  • Part 4 Topics

• Introduction to the Distributed Time Service API
  • Overview - Introduction to the Distributed Time Service API

  • DTS Time Representation
    • DTS Time Representation

    • Absolute Time Representation

    • Relative Time Representation
      • Relative Time Representation

      • Representing Periods of Time

      • The Data Element Parts

  • Time Structures
    • Time Structures

    • The utc Structure

    • The tm Structure

    • The timespec Structure

    • The reltimespec Structure

  • DTS API Header Files
    • DTS API Header Files

  • DTS API Routine Functions
    • DTS API Routine Functions

• Time-Provider Interface
  • Overview - Time-Provider Interface

  • General TPI Control Flow
    • General TPI Control Flow

    • ContactProvider Procedure

    • ServerRequestProviderTime Procedure

  • Time-Provider Process IDL File
    • Time-Provider Process IDL File

  • Initializing the Time-Provider Process
    • Initializing the Time-Provider Process

  • Time-Provider Algorithm
    • Time-Provider Algorithm

  • DTS Synchronization Algorithm
    • DTS Synchronization Algorithm

  • Running the Time-Provider Process
    • Running the Time-Provider Process

  • Sources of Additional Information
    • Sources of Additional Information

• DTS API Routines Programming Example
  • Overview - DTS API Routines Programming Example

  • DTS API Routines Programming Example

• Part 5. DCE Security Service
  • Part 5 Topics

• Overview of Security
  • Overview - Overview of Security

  • Purpose and Organization of the Security Topics

  • About Authenticated RPC

  • About the GSSAPI

  • UNIX System Security and DCE Security

  • What Authentication and Authorization Mean

  • Authentication, Authorization, and Data Protection in Brief

  • Summary of DCE Security Services and Facilities
    • Summary of DCE Security Services and Facilities

    • Interfaces to the Security Server
      • Interfaces to the Security Server

      • Registry Service Interfaces

      • Authentication Service Interfaces

      • Privilege Service Interfaces

    • Interfaces to the Login Facility
      • Interfaces to the Login Facility

    • Interfaces to the Extended Registry Attribute Facility
      • Interfaces to the Extended Registry Attribute Facility

    • Interfaces to the Extended Privilege Attribute Facility
      • Interfaces to the Extended Privilege Attribute Facility

    • Interfaces to the Key Management Facility
      • Interfaces to the Key Management Facility

    • Interfaces to the ID Map Facility
      • Interfaces to the ID Map Facility

    • Interfaces to the Access Control List Facility
      • Interfaces to the Access Control List Facility

    • DCE Implementations of UNIX System Program Interfaces
      • DCE Implementations of UNIX System Program Interfaces

    • Interfaces to the Password Management Facility
      • Interfaces to the Password Management Facility

  • Relationships Between the DCE Security Service and DCE Applications
    • Relationships Between the DCE Security Service and DCE Applications

  • DTS, the Cell Namespace, and Security
    • DTS, the Cell Namespace, and Security

    • DTS and Security

    • The Cell Namespace and the Security Namespace

• Authentication
  • Overview - Authentication

  • Background Concepts
    • Background Concepts

    • Principals

    • The Shared-Secret Authentication Protocol

    • Cells and Realms

    • Protection Levels
      • Protection Levels

      • Authenticated RPC and Protection Levels

      • GSSAPI and Protection Levels

    • Data Encryption Mechanisms
      • Data Encryption Mechanisms

  • A Walkthrough of Shared-Secret Authentication Protocols
    • A Walkthrough of Shared-Secret Authentication Protocols

    • Authenticating a User
      • Authenticating a User

      • How the Client Obtains a TGT for the User

      • How the Client Obtains a PTGT for the User

      • The Login Context

      • Identities in a Delegation Chain

    • Authenticating an Application
      • Authenticating an Application

      • Authentication Using Authenticated RPC

      • Authentication Using GSSAPI

  • Intercell Authentication
    • Intercell Authentication

    • KDS Surrogates

    • Intercell Authentication by Trust Peers

• Authorization
  • Overview - Authorization

  • DCE Authorization
    • DCE Authorization

    • Object Types and ACL Types

    • ACL Manager Types

    • Access Control Lists

    • ACL Entries
      • ACL Entries

      • Privilege Attribute Entry Types

      • Mask Entry Types

      • The Extended ACL Entry Type

    • Access Checking
      • Access Checking

    • Examples of ACL Checking
      • Examples of ACL Checking

      • Example 1

      • Example 2

      • Example 3

  • Name-Based Authorization
    • Name-Based Authorization

• GSSAPI Credentials
  • Overview - GSSAPI Credentials

  • Using Default Credentials
    • Using Default Credentials

    • Initiating a Security Context

    • Accepting a Security Context

  • Creating New Credential Handles
    • Creating New Credential Handles

    • Initiating a Security Context with New Credential Handles

    • Accepting a Security Context Using New Credential Handles

  • Delegating Credentials
    • Delegating Credentials

    • Initiating a Security Context to Delegate Credentials

    • Accepting a Security Context with Delegated Credentials

• The Extended Privilege Attribute API
  • Overview - The Extended Privilege Attribute API

  • Identities of Principals in Delegation
    • Identities of Principals in Delegation

    • ACL Entry Types for Delegation

    • ACL Checking for Delegation

  • Calls to Establish Delegation Chains
    • Calls to Establish Delegation Chains

    • Types of Delegation

    • Target and Delegate Restrictions
      • Target and Delegate Restrictions

      • The Anonymous Principal

      • Target and Delegate Restriction Syntax

    • Optional and Required Restrictions
      • Optional and Required Restrictions

    • Compatibility Between Version 1.1 and Pre-Version 1.1 Servers and Clients
      • Compatibility Between Version 1.1 and Pre-Version 1.1 Servers and Clients

  • Calls to Extract Privilege Attribute Information
    • Calls to Extract Privilege Attribute Information

  • Disabling Delegation
    • Disabling Delegation

  • Setting Extended Attributes
    • Setting Extended Attributes

• The Registry API
  • Overview - The Registry API

  • Binding to a Registry Site

  • The Registry Database
    • The Registry Database

    • Creating and Maintaining PGO Items

    • Creating and Maintaining Accounts

    • Registry Properties and Policies
      • Registry Properties and Policies

      • Registry Properties

      • The Registry Authentication Policy

      • Organization Policies

    • Routines to Return UNIX Structures
      • Routines to Return UNIX Structures

    • Miscellaneous Registry Routines
      • Miscellaneous Registry Routines

• The Extended Attribute API
  • Overview - The Extended Attribute API

  • The ERA API
    • The ERA API

    • Attribute Schema

    • Attribute Types and Instances

    • Attribute Type Components
      • Attribute Type Components

      • Attribute Encoding

      • ACL Manager Set

      • Attribute Flags

      • The Intercell Action Field

      • Attribute Scope

      • Trigger Type Flag

      • Trigger Binding

  • Calls to Manipulate Schema Entries
    • Calls to Manipulate Schema Entries

    • The sec_attr_schema_entry_t Data Type

    • Creating and Managing Schema Entries
      • Creating and Managing Schema Entries

      • The sec_rgy_attr_sch_create_entry( ) Call

      • The sec_rgy_attr_sch_update_entry( ) Call

      • The sec_rgy_attr_sch_delete_entry( ) Call

    • Reading Schema Entries
      • Reading Schema Entries

      • Using sec_attr_cursor_t with sec_rgy_attr_sch_scan( )

      • The sec_rgy_attr_sch_scan( ) Call

      • The sec_rgy_attr_sch_lookup_by_id( ) and sec_rgy_attr_sch_lookup_by_name( ) Calls

    • Reading the ACL Manager Types
      • Reading the ACL Manager Types

  • Calls to Manipulate Attribute Instances
    • Calls to Manipulate Attribute Instances

    • The sec_attr_t Data Type

    • Creating and Managing Attribute Instances
      • Creating and Managing Attribute Instances

      • The sec_rgy_attr_update( ) Call

      • The sec_rgy_attr_test_and_update( ) Call

      • The sec_rgy_attr_delete( ) Call

    • Reading Attribute Instances
      • Reading Attribute Instances

      • Using sec_rgy_attr_cursor_t with sec_rgy_attr_lookup_by_id( )

      • The sec_rgy_attr_lookup_by_id( ) Call

      • The sec_rgy_attr_set_lookup_by_id( ) Call

      • The sec_rgy_attr_lookup_by_name( ) Call

  • The Attribute Trigger Facility
    • The Attribute Trigger Facility

    • Defining an Attribute Trigger/Attribute Association
      • Defining an Attribute Trigger/Attribute Association

      • Query Triggers

      • Update Triggers

    • Trigger Binding
      • Trigger Binding

      • The sec_attr_binding_t Data Type

      • The sec_attr_bind_auth_info_t Data Type

    • Access Control on Attributes with Triggers
      • Access Control on Attributes with Triggers

  • Calls that Access Attribute Triggers
    • Calls that Access Attribute Triggers

    • Using sec_attr_trig_cursor_t with sec_attr_trig_query( )

    • The sec_rgy_attr_trig_query( ) and sec_rgy_attr_trig_update( ) Calls

    • The priv_attr_triq_query( ) Call

  • The DCE Attribute API
    • The DCE Attribute API

  • Macros to Aid Extended Attribute Programming
    • Macros to Aid Extended Attribute Programming

    • Macros to Access Binding Fields

    • Macros to Access Schema Entry Fields

    • Macros to Access Attribute Instance Fields

    • Binding Data Structure Size Calculation Macros

    • Schema Entry Data Structure Size Calculation Macros

    • Attribute Instance Data Structure Size Calculation Macros

    • Binding Semantic Check Macros

    • Schema Entry Semantic Check Macros

    • Attribute Instance Semantic Check Macros

    • Schema Entry Flag Set and Unset Macros

    • Schema Trigger Entry Flag Check Macros

  • Utilities to Use with Extended Attribute Calls
    • Utilities to Use with Extended Attribute Calls

• The Login API
  • Overview - The Login API

  • Establishing Login Contexts
    • Establishing Login Contexts

    • Validating the Login Context and Certifying the Security Server

    • Validating the Login Context Without Certifying the Security Server

    • Example of a System Login Program

  • Context Inheritance
    • Context Inheritance

    • The Initial Context

    • Private Contexts

  • Handling Expired Certificates of Identity
    • Handling Expired Certificates of Identity

  • Importing and Exporting Contexts
    • Importing and Exporting Contexts

  • Changing a Groupset
    • Changing a Groupset

  • Miscellaneous Login API Functions
    • Miscellaneous Login API Functions

    • Getting the Current Context

    • Getting Information from a Login Context

    • Getting Password and Group Information for Local Process Identities

    • Releasing and Purging a Context

• The Key Management API
  • Overview - The Key Management API

  • Retrieving a Key

  • Changing a Key

  • Automatic Key Management

  • Deleting Expired Keys

  • Deleting a Compromised Key

• The Access Control List APIs
  • Overview - The Access Control List APIs

  • The Client-Side API
    • The Client-Side API

    • Binding to an ACL

    • ACL Editors and Browsers

    • Errors

  • Guidelines for Constructing ACL Managers
    • Guidelines for Constructing ACL Managers

  • Extended Naming of Protected Objects
    • Extended Naming of Protected Objects

    • The ACL Network Interface

    • The ACL Library
      • The ACL Library

      • ACL Library Capabilities

      • The ACL API

• The ID Map API
  • Overview - The ID Map API

• DCE Audit Service
  • Overview - DCE Audit Service

  • Features of the DCE Audit Service

  • Components of the DCE Audit Service

  • DCE Audit Service Concepts

  • Administration and Programming in DCE Audit
    • Administration and Programming in DCE Audit

    • Programmer Tasks

    • Administrator Tasks

• Using the Audit API Functions
  • Overview - Using the Audit API Functions

  • Adding Audit Capability to Distributed Applications
    • Adding Audit Capability to Distributed Applications

    • Opening the Audit Trail

    • Initializing the Audit Records

    • Adding Event-Specific Information

    • Committing an Audit Record

    • Closing an Audit Trail File

  • Writing Audit Trail Analysis and Examination Tools
    • Writing Audit Trail Analysis and Examination Tools

    • Opening an Audit Trail File for Reading

    • Reading the Desired Audit Records into a Buffer

    • Transforming the Audit Record into Readable Text

    • Discarding the Audit Record

    • Closing the Audit Trail File

• The Password Management API
  • Overview - The Password Management API

  • The Client-Side API

  • The Password Management Network Interface

• The DCE Certification Service
  • Overview - The DCE Certification Service

  • Who Needs to Use the Certification API?

  • Overview of DCE Certification
    • Overview of DCE Certification

    • Use of Public Keys

    • Contents of Certificates

    • Component Parts of the DCE Certification API

    • High Level Certification API

    • Policy Models

  • Implementing and Registering a Cryptographic Module
    • Implementing and Registering a Cryptographic Module

    • Contents of a Cryptographic Module

    • Accessing a Registered Cryptographic Module

    • Signature Algorithms Provided by DCE Certification

    • Registering a Cryptographic Module

  • Implementing and Registering a Policy Module
    • Implementing and Registering a Policy Module

  • The Low Level Certificate Manipulation API
    • The Low Level Certificate Manipulation API