Previous section.
CDE 1.1: Remote Procedure Call
Copyright © 1997 The Open Group
Connectionless RPC Protocol Machines
This chapter specifies the connectionless RPC protocol as a
series of statecharts and accompanying tables of definitions.
CL_CLIENT Machine
CL_CLIENT Statechart
shows the CL_CLIENT machine statechart.
Figure: CL_CLIENT Statechart
CL_CLIENT Activities
The CL_CLIENT statechart defines the following activities:
- Chart:
- CL_CLIENT
- Activity:
- ABORT_CALL
- Description:
- Flush and discard any further responses for this call.
If this activity was caused by a detected failure,
there may be numerous additional packets in the pipeline.
The flush may be lazy, upon subsequent receive processing.
Also, notify the run-time system and stub to reclaim any resources for this call.
- Chart:
- CL_CLIENT
- Activity:
- EXCEPTION
- Description:
- Raise a fault and return to calling routine.
- Chart:
- CL_CLIENT
- Activity:
- FETCH_TICKET
- Description:
- Obtains the security context for the RPC session from the security service
(that is, kerberos ticket, if authentication service
is rpc_c_authn_dce_secret).
The activity resets the conditional flag TICKET to false at the
beginning, and sets TICKET to true before termination only if the
fetch operation succeeded. FETCH_TICKET is a self-terminating
activity.
- Chart:
- CL_CLIENT
- Activity:
- HANDLE_OUT_FRAG
- Description:
- This activity is invoked at each received fragment evaluation of
out parameters for multi-fragmented RPC responses.
The HANDLE_OUT_FRAG activity makes received data of continuous
fragments available to the stub for unmarshalling
and the object UUID (RT_OBJ_ID) available to the manager routine.
This does not require a transfer of control from the run-time system to the stub
for each fragment; implementation policy determines when
control is transferred.
In addition, if the client receives a fragment out of order, HANDLE_OUT_FRAG
buffers this fragment temporarily until subsequently received fragments
allow for a consecutive inclusion of these temporarily buffered fragments.
The fragment ordering is determined by the fragment number (RT_OUT_FRAG_NUM).
If previously buffered out of order fragments are appended
to the continuous receive buffer (RT_OUT_PARAMS), HANDLE_OUT_FRAG must also
adjust the state variable RT_CONT_OUT_FRAG_NUM.
HANDLE_OUT_FRAG also maintains the selective acknowledgement bit masks
which are used in the fack PDU.
Modifications of RT_CONT_OUT_FRAG_NUM must be synchronised with
other actions (DO_OUT_PKT) performed by the protocol machine.
- Chart:
- CL_CLIENT
- Activity:
- RESET_IN_FRAG
- Description:
- This activity is invoked if the protocol machine determines that a set
of fragments needs to be retransmitted. RESET_IN_FRAG resets the
values of SND_FRAG_NUM and RT_IN_FRAG to the beginning of the
transmission queue. Note that the condition LAST_IN_FRAG must also be
set appropriately.
The first fragment in this queue may not have fragment number 0, since
other fragment acknowledgements may have been received, allowing the
client to free previously sent data packets. Run time implementations
must keep state about the acknowledgement of sent fragmented request
PDUs.
This activity generates the event RESEND and marks TRANSMIT_REQ as
true to trigger the transitions that actually invoke the
appropriate SEND_PKT activities.
- Chart:
- CL_CLIENT
- Activity:
- SEND_PKT
- Description:
- Prepare a PDU to send to the server, adding the appropriate header
information as necessary. If security services were requested
(conditional flag AUTH is true), apply per-message security services.
Send the PDU.
The conditional flags and data items set in the run-time system (with prefix
SND_) provide the appropriate input for generating the PDU data.
Note that actions within the same execution step that started this
activity may have assigned values to the SND_* variables which have to
be taken by this instance of the activity.
After sending a request PDU, the RT_IN_FRAG pointer is incremented
accordingly, to point to the remaining data in the transmit queue.
- Note:
- The SEND_PKT activity may be invoked simultaneously by several
orthogonal states (DATA, CONTROL, CANCEL, and so on). The run-time system
must catch these send requests, buffer these and the associated data,
and perform the sends in sequential order.
- Chart:
- CL_CLIENT
- Activity:
- VERIFY_AUTH
- Description:
- Verify the authentication trailer of PDU and decrypt message if necessary.
This activity takes as input values the PDU header field auth_proto
(authentication protocol specifier: RT_AUTH_SPEC) and the
authentication verifier (PDU trailer: RT_AUTH_VERIFIER).
Depending on the result of the verification, the activity VERIFY_AUTH
generates either the event AUTHENTICATED (success) or DENIED
(authentication failure).
The algorithm applied to this activity is dependent on the security
service in use (determined by RT_AUTH_SPEC). The general evaluation
steps for authentication service rpc_c_authn_dce_secret are as
follows (for more details see
Security
):
-
Check the protection level applied to the PDU (parameter in
RT_AUTH_VERIFIER) against the protection level for the call
(negotiated security context). If matching, proceed with
verification, otherwise raise DENIED.
-
Decrypt the cyphertext portion of the verifier and verify PDUs
integrity. If discrepancies are found, raise DENIED, otherwise raise
AUTHENTICATED and proceed (if privacy protected).
-
If privacy protection is requested, decrypt PDU body data.
- Note:
- The VERIFY_AUTH activity may be invoked simultaneously by several
orthogonal states (DATA, CONTROL and CANCEL). VERIFY_AUTH must not
generate the event AUTHENTICATED unless the entire requested
authentication processing is completed. If VERIFY_AUTH detects an
authentication failure and generates the event DENIED, the protocol
machine rejects the RPC call and no further processing is required.
CL_CLIENT States
The CL_CLIENT statechart defines the following states:
- Chart:
- CL_CLIENT
- State:
- AUTHENTICATION
- Description:
- Process authentication verification.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| [RT_SECURITY_CONTEXT]
| st!(VERIFY_AUTH)
|
|---|
- Chart:
- CL_CLIENT
- State:
- AUTHENTICATION
- Description:
- Process authentication verification.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| [RT_SECURITY_CONTEXT]
| st!(VERIFY_AUTH)
|
|---|
- Chart:
- CL_CLIENT
- State:
- CANCEL
- Description:
- Processing of requests to terminate a call in progress.
- Chart:
- CL_CLIENT
- State:
- CAN_IDLE
- Description:
- Wait for cancel requests.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| en(CAN_IDLE)
| IF
CURRENT_PENDING_CANCEL
THEN
tr!(RT_PENDING_CANCEL)
END IF
|
|---|
- Chart:
- CL_CLIENT
- State:
- CL_CLIENT
- Description:
- Main state for statechart CL_CLIENT.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| entering
| SND_ACTIVITY_ID:=SESSION_ACTIVITY_ID
|
|---|
- Chart:
- CL_CLIENT
- State:
- CNTL_IDLE
- Description:
- Wait for incoming control PDUs.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| en(CNTL_IDLE)
| fs!(FAULT_PDU);
fs!(WORKING_PDU);
fs!(NOCALL_PDU);
fs!(REJECT_PDU);
fs!(FACK_PDU);
fs!(CANCEL_ACK_PDU)
T{
RECEIVE_PDU[PDU_TYPE=FACK
and VALID_PDU_HEADER]
|
|---|
| RECEIVE_PDU[PDU_TYPE=FAULT
and VALID_PDU_HEADER]
| tr!(FAULT_PDU)
|
| exiting
| IF
AUTH
THEN
RT_AUTH_VERIFIER_CNTL:=
PDU_AUTH_VERIFIER
END IF
|
| RECEIVE_PDU[PDU_TYPE=WORKING
and VALID_PDU_HEADER]
| tr!(WORKING_PDU)
|
| RECEIVE_PDU[PDU_TYPE=NOCALL
and VALID_PDU_HEADER]
| tr!(NOCALL_PDU)
|
| RECEIVE_PDU[PDU_TYPE=REJECT
and VALID_PDU_HEADER]
| tr!(REJECT_PDU)
|
| RECEIVE_PDU[PDU_TYPE=CANCEL_ACK
and VALID_PDU_HEADER]
| tr!(CANCEL_ACK_PDU);
RT_RCV_CANCEL_ID:=PDU_CANCEL_ID
|
| RECEIVE_PDU[CNTL_PDU
and VALID_PDU_HEADER]
| RCV_CNTL_PDU
|
- Chart:
- CL_CLIENT
- State:
- COMM_FAIL
- Description:
- Handle communication failures.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| en(COMM_FAIL)
| RT_EXCEPTION_STATUS:=CONST_COMM_FAILURE;
st!(EXCEPTION);
st!(ABORT_CALL)
|
|---|
- Chart:
- CL_CLIENT
- State:
- COMPLETE
- Description:
- Call completed successfully (If NON_IDEMPOTENT wait for ACK_TIMEOUT).
- Chart:
- CL_CLIENT
- State:
- CONFIRMATION
- Description:
- Process response data (out parameters) for remote procedure call.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| en(CONFIRMATION)
| fs!(RESPONSE_ACTIVE);
RT_OUT_PARAMS:=NULL;
RT_OUT_SERIAL_NUM:=-1;
RT_CONT_OUT_FRAG_NUM:=-1;
RT_LAST_OUT_FRAG_NUM:=-1;
fs!(LAST_OUT_FRAG)
|
|---|
- Chart:
- CL_CLIENT
- State:
- CONF_IDLE
- Description:
- Receive response data from server (possibly fragmented).
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| en(CONF_IDLE)[RESPONSE_ACTIVE and
RT_OUT_FRAG_NUM=RT_CONT_OUT_FRAG_NUM+1]
| DO_OUT_PKT;
st!(HANDLE_OUT_FRAG)
|
|---|
| en(CONF_IDLE)[RESPONSE_ACTIVE and (not
NO_FACK or NO_FACK and RT_BUF_LIMIT)]
| FACK_CALL
|
| en(CONF_IDLE)[RESPONSE_ACTIVE and
RT_OUT_FRAG_NUM/=RT_CONT_OUT_FRAG_NUM+1]
| st!(HANDLE_OUT_FRAG)
|
| RECEIVE_PDU[PDU_TYPE=RESPONSE and
VALID_PDU_HEADER and not AUTH]
| tr!(RESPONSE_ACTIVE);
DO_RESP;
RCV_FRAG_PDU
|
| RECEIVE_PDU[PDU_TYPE=RESPONSE and
VALID_PDU_HEADER and AUTH]
| tr!(RESPONSE_ACTIVE);
DO_RESP;
RCV_FRAG_PDU_A
|
| en(CONF_IDLE)[RESPONSE_ACTIVE and
LAST_OUT_FRAG and
RT_LAST_OUT_FRAG_NUM=
RT_CONT_OUT_FRAG_NUM+1]
| RCV_LAST_OUT_FRAG
|
- Chart:
- CL_CLIENT
- State:
- CONTROL
- Description:
- Process received control PDUs.
- Chart:
- CL_CLIENT
- State:
- DATA
- Description:
- Process RPC call data.
- Chart:
- CL_CLIENT
- State:
- FAULT
- Description:
- Handle faults in processing call.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| en(FAULT)[FAULT_PDU]
| RT_EXCEPTION_STATUS:=PDU_FAULT_STATUS;
st!(EXCEPTION);
st!(ABORT_CALL)
|
|---|
| en(FAULT)[REJECT_PDU]
| RT_EXCEPTION_STATUS:=PDU_REJECT_STATUS;
st!(EXCEPTION);
st!(ABORT_CALL)
|
en(FAULT)[not FAULT_PDU
and not REJECT_PDU]
| RT_EXCEPTION_STATUS:=PDU_REJECT_STATUS;
st!(EXCEPTION);
st!(ABORT_CALL)
|
- Chart:
- CL_CLIENT
- State:
- GET_TICKET
- Description:
- Get authentication ticket from security server (security
service-specific).
- Activities Throughout:
FETCH_TICKET
- Chart:
- CL_CLIENT
- State:
- INIT
- Description:
- Initial remote procedure call state.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| exiting
| SETUP_CALL
|
|---|
- Chart:
- CL_CLIENT
- State:
- PING
- Description:
- Main state to handle asynchronous ping requests.
- Chart:
- CL_CLIENT
- State:
- PING_IDLE
- Description:
- Wait for expiration of WAIT_TIMEOUT.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| exiting
| RT_PING_COUNT:=0
|
|---|
- Chart:
- CL_CLIENT
- State:
- REQUEST
- Description:
- Process request data (in parameters) for remote procedure call.
- Chart:
- CL_CLIENT
- State:
- REQ_WAIT
- Description:
- Handle fragmented requests to server.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| tm(en(REQ_WAIT), TIMEOUT_FRAG)
| RESEND_IN_FRAGS
|
|---|
| en(REQ_WAIT)[not REQUEST_ACTIVE]
| FIRST_REQ
|
- Chart:
- CL_CLIENT
- State:
- SND_CAN
- Description:
- Process cancel requests. Sends cancel PDU.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| en(SND_CAN) or CLIENT_CANCEL or
tm(CLIENT_CANCEL, TIMEOUT_CANCEL)
| CAN_CALL
|
|---|
- Chart:
- CL_CLIENT
- State:
- SND_PING
- Description:
- Send ping PDU.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| en(SND_PING) or
tm(en(SND_PING),
TIMEOUT_PING)
| RT_PING_COUNT:=RT_PING_COUNT+1;
SND_SERIAL_NUM:=SND_SERIAL_NUM+1;
SND_REQUEST_TYPE:=PING;
st!(SEND_PKT)
|
|---|
- Chart:
- CL_CLIENT
- State:
- WORKING
- Description:
- Main working state for call instance.
CL_CLIENT Events
The CL_CLIENT statechart defines the following events:
- Chart:
- CL_CLIENT
- Event:
- ABORT
- Description:
- RPC session (same activity UUID) has terminated.
- Definition:
- st(ABORT_CALL) or sp(FETCH_TICKET)[not
TICKET]
- Chart:
- CL_CLIENT
- Event:
- AUTHENTICATED
- Description:
- Authentication processing completed successfully.
- Chart:
- CL_CLIENT
- Event:
- CANCEL_REQ
- Description:
- Events which cause a transition into an active cancel state.
- Definition:
- CLIENT_CANCEL or [RT_PENDING_CANCEL] or
tm(CLIENT_CANCEL, TIMEOUT_CANCEL)
- Chart:
- CL_CLIENT
- Event:
- CLIENT_CANCEL
- Description:
- The client has issued a request to terminate a call.
- Chart:
- CL_CLIENT
- Event:
- COMPLETE
- Description:
- RPC completed (with success or fault).
- Definition:
- (en(COMPLETE)[not NON_IDEMPOTENT] or
en(CONFIRMATION)[MAYBE] or TM_ACK) and not
NO_CONNECTION and not FAULTS
- Chart:
- CL_CLIENT
- Event:
- DENIED
- Description:
- Authentication failure detected.
The VERIFY_AUTH activity generates this event if either the integrity check
failed or the requested protection level for authentication services
does not match.
- Chart:
- CL_CLIENT
- Event:
- FAULTS
- Description:
- Received a fault or reject PDU or a PDU with wrong
authentication verifier.
- Definition:
- (RCV_FAULT or DENIED) and not NO_CONNECTION
- Chart:
- CL_CLIENT
- Event:
- FETCHED_TICKET
- Description:
- Client fetched a valid Ticket Granting Ticket.
- Definition:
- sp(FETCH_TICKET)[TICKET]
- Chart:
- CL_CLIENT
- Event:
- LAST_IN_PKT
- Description:
- Statechart internal event: last packet of fragmented request.
- Definition:
- [TRANSMIT_REQ and LAST_IN_FRAG and BURST and
REQUEST_ACTIVE] or
en(CNTL_IDLE)[TRANSMIT_REQ and FACK_PDU
and LAST_IN_FRAG and IN_FRAG_NUM_EQ and
REQUEST_ACTIVE]
- Chart:
- CL_CLIENT
- Event:
- NEXT_IN_PKT
- Description:
- Statechart internal event: intermediate packet of fragmented request.
- Definition:
- [TRANSMIT_REQ and not LAST_IN_FRAG and BURST
and REQUEST_ACTIVE] or
en(CNTL_IDLE)[TRANSMIT_REQ and FACK_PDU
and not LAST_IN_FRAG and IN_FRAG_NUM_EQ and
REQUEST_ACTIVE]
- Chart:
- CL_CLIENT
- Event:
- NO_CONNECTION
- Description:
- Detected communications failure due to timeout events or excessive retries.
- Definition:
- tm(en(CONFIRMATION),
TIMEOUT_BROADCAST)[BROADCAST] or
[in(SND_PING) and
RT_PING_COUNT>MAX_PINGS] or
[RT_REQUEST_COUNT>MAX_REQUESTS]
- Chart:
- CL_CLIENT
- Event:
- RCV_CNTL_PDU
- Description:
- Received one of the control PDUs with valid header.
- Chart:
- CL_CLIENT
- Event:
- RCV_FAULT
- Description:
- Received a fault or reject PDU. Generated in CNTL_CALL action.
- Chart:
- CL_CLIENT
- Event:
- RCV_FRAG_PDU
- Description:
- Received a response PDU for a non-authenticated call.
- Chart:
- CL_CLIENT
- Event:
- RCV_FRAG_PDU_A
- Description:
- Received a response PDU for an authenticated call.
- Chart:
- CL_CLIENT
- Event:
- RCV_LAST_OUT_FRAG
- Description:
- Received last fragment of response PDU and signalled completion
to stub.
The last fragment of a multi-fragmented response or a single packet
response was received. RCV_LAST_OUT_FRAG signals that the complete
response data is available to the stub for unmarshalling.
- Chart:
- CL_CLIENT
- Event:
- RECEIVE_PDU
- Description:
- Received a PDU from server.
- Chart:
- CL_CLIENT
- Event:
- RESEND
- Description:
- Statechart internal event that triggers a resend of previously sent
request PDUs.
- Chart:
- CL_CLIENT
- Event:
- RESEND_REQ
- Description:
- Resend the request if no fault was detected.
- Definition:
- RESEND and not NO_CONNECTION and not FAULTS
- Chart:
- CL_CLIENT
- Event:
- RESET
- Description:
- Reset ping processing after receiving an acknowledge from server.
- Definition:
- en(CNTL_IDLE)[WORKING_PDU] or
en(CONF_IDLE) or ex(CONFIRMATION)
- Chart:
- CL_CLIENT
- Event:
- START_CALL
- Description:
- Client has initiated an RPC and allocated the data (INVOKE service
primitive).
The AUTH conditional flag is initialised by the run-time system to
reflect the requested security context.
- Chart:
- CL_CLIENT
- Event:
- TM_ACK
- Description:
- Timeout for sending an acknowledge PDU for non-idempotent calls.
- Definition:
- tm(ex(CONFIRMATION),
TIMEOUT_ACK)[NON_IDEMPOTENT]
- Chart:
- CL_CLIENT
- Event:
- TM_WAIT
- Description:
- Timeout for receiving a response PDU.
- Definition:
- tm(en(CONF_IDLE) or
en(PING_IDLE)[in(CONF_IDLE)],
TIMEOUT_WAIT)
CL_CLIENT Conditions
The CL_CLIENT statechart defines the following conditions:
- Chart:
- CL_CLIENT
- Condition:
- AUTH
- Description:
- Statechart internal flag: indicates that call is authenticated.
- Chart:
- CL_CLIENT
- Condition:
- BOOT_TIME_EQ
- Description:
- Statechart internal flag.
- Definition:
- SND_BOOT_TIME=PDU_BOOT_TIME or
SND_BOOT_TIME=0
- Chart:
- CL_CLIENT
- Condition:
- BROADCAST
- Description:
- Statechart internal flag: broadcast call semantic.
- Chart:
- CL_CLIENT
- Condition:
- BURST
- Description:
- Run time internal flag set if no fack is expected before sending
next fragment. This flag is used by RPC run-time implementations to
optimise the frequency of fragmented outbound packets.
The algorithms used to optimise traffic and avoid congestion
are implementation-specific. The protocol machine waits for
incoming fack PDUs if burst mode is off. The next outbound
fragment is triggered by an inbound fack PDU.
Run time implementations are responsible for setting the corresponding
nofack flags in the PDU header.
- Chart:
- CL_CLIENT
- Condition:
- CANCEL_ACK_PDU
- Description:
- Statechart internal flag: received cancel_ack PDU.
- Chart:
- CL_CLIENT
- Condition:
- CNTL_PDU
- Description:
- Statechart internal flag: control PDUs to be received.
- Definition:
- PDU_TYPE=FAULT or PDU_TYPE=WORKING or
PDU_TYPE=NOCALL or PDU_TYPE=REJECT or
PDU_TYPE=FACK
- Chart:
- CL_CLIENT
- Condition:
- CURRENT_PENDING_CANCEL
- Description:
- Cancel pending state passed from stub during initialisation of call.
- Chart:
- CL_CLIENT
- Condition:
- FACK_PDU
- Description:
- Statechart internal flag: received fack PDU.
- Chart:
- CL_CLIENT
- Condition:
- FAULT_PDU
- Description:
- Statechart internal flag: received fault PDU.
- Chart:
- CL_CLIENT
- Condition:
- IDEMPOTENT
- Description:
- Statechart internal flag: idempotent call.
- Chart:
- CL_CLIENT
- Condition:
- IN_FRAG_NUM_EQ
- Description:
- Statechart internal flag: received frag at server and last sent frag
are equal.
This condition verifies the fragment number that was received in a
fack PDU. (See
RPC PDU Encodings
for details.)
- Definition:
- SND_FRAG_NUM=PDU_FRAG_NUM
- Chart:
- CL_CLIENT
- Condition:
- IN_FRAG_NUM_NE
- Description:
- Statechart internal flag: received frag at server and last sent frag are
not equal.
This condition verifies the fragment number that was received in a
fack PDU. (See
RPC PDU Encodings
for details.)
- Definition:
- SND_FRAG_NUM/=PDU_FRAG_NUM
- Chart:
- CL_CLIENT
- Condition:
- LAST_IN_FRAG
- Description:
- Statechart internal flag: last in fragment or non-frag in
packet ready to send.
This flag is set by the run-time system if the transmit queue contains the
last fragment (see also
Connection-oriented Protocol
).
- Chart:
- CL_CLIENT
- Condition:
- LAST_OUT_FRAG
- Description:
- Statechart internal flag: last out fragment or non-frag out
packet received.
- Chart:
- CL_CLIENT
- Condition:
- MAYBE
- Description:
- Statechart internal flag: maybe call.
- Chart:
- CL_CLIENT
- Condition:
- NOCALL_PDU
- Description:
- Statechart internal flag: received nocall PDU.
- Chart:
- CL_CLIENT
- Condition:
- NON_IDEMPOTENT
- Description:
- Statechart internal flag: non-idempotent (at-most-once) call.
- Definition:
- not IDEMPOTENT and not BROADCAST and not MAYBE
- Chart:
- CL_CLIENT
- Condition:
- NO_FACK
- Description:
- Statechart internal flag: received PDU with nofack flag true.
- Chart:
- CL_CLIENT
- Condition:
- PDU_FRAG
- Description:
- PDU flag fragment.
- Chart:
- CL_CLIENT
- Condition:
- PDU_LAST_FRAG
- Description:
- PDU flag lastfrag.
- Chart:
- CL_CLIENT
- Condition:
- PDU_NO_FACK
- Description:
- PDU flag nofack.
- Chart:
- CL_CLIENT
- Condition:
- REJECT_PDU
- Description:
- Statechart internal flag: received reject PDU.
- Chart:
- CL_CLIENT
- Condition:
- REQUEST_ACTIVE
- Description:
- Statechart internal flag: send request has started.
- Chart:
- CL_CLIENT
- Condition:
- RESPONSE_ACTIVE
- Description:
- Statechart internal flag: indicates availability of response data.
- Chart:
- CL_CLIENT
- Condition:
- RT_BUF_LIMIT
- Description:
- Statechart internal flag: buffer limit reached for out packets.
The conditional flag RT_BUF_LIMIT triggers the generation of a
fack PDU which requests the sender of data fragments to
readjust the transmission rate.
It is a mechanism to indicate internal buffer limits (overflow)
for avoidance of congestions and retransmissions.
Since recipients may not evaluate the fack body data
in a certain way, implementations must not rely on changes
in the transmission rate. This indication is an advisory.
Run time implementations are responsible
for setting the RT_BUF_LIMIT flag, according to its policies.
- Chart:
- CL_CLIENT
- Condition:
- RT_PENDING_CANCEL
- Description:
- Statechart internal: cancel pending state at server's provider.
- Chart:
- CL_CLIENT
- Condition:
- RT_SECURITY_CONTEXT
- Description:
- Statechart internal flag: set true if security context for
call has been established.
- Chart:
- CL_CLIENT
- Condition:
- SEQ_NUM_GTE
- Description:
- Statechart internal flag: received sequence number >= initial call
sequence number.
- Definition:
- PDU_SEQ_NUM>=RT_SEQ_NUM
- Chart:
- CL_CLIENT
- Condition:
- SESSION
- Description:
- Verify that call request is for same session (activity UUID matches).
- Definition:
- SND_ACTIVITY_ID=SESSION_ACTIVITY_ID
- Chart:
- CL_CLIENT
- Condition:
- SND_FRAG
- Description:
- Statechart internal flag: header flag frag of next fragments
to be sent.
- Chart:
- CL_CLIENT
- Condition:
- SND_LAST_FRAG
- Description:
- Statechart internal flag: header flag lastfrag for PDU to be sent.
- Chart:
- CL_CLIENT
- Condition:
- TICKET
- Description:
- The authentication ticket is valid (not expired or about to expire).
The authentication ticket from the call's client principal to the
server's principal is valid. The particular ticket depends on
the client/server pair of principals, and may be different for
different RPCs.
Note that implementations may cache unexpired tickets, even across
process invocations or system reboots. Therefore, this condition
predicate may be maintained external to the RPC run-time system.
- Chart:
- CL_CLIENT
- Condition:
- TRANSMIT_REQ
- Description:
- One or more fragments queued for transmission of request data.
This flag indicates that one or more request fragment(s) are queued in
a run-time internal buffer and ready to be transmitted. In conjunction
with the BURST flag and possibly expected fack PDUs, an event for
transmitting the next fragment will be generated.
The run-time system
internally sets this flag to true after the stub initially
provided data in the transmit queue, sufficient for at least the first
PDU fragment to be transmitted. The protocol machine resets this flag
if it has detected and taken an event for sending the next fragment in
the queue. The run-time system sets this flag again after completion of a
SEND_PKT activity if the transmit queue contains enough data for the
next PDU fragment to be transmitted.
- Chart:
- CL_CLIENT
- Condition:
- VALID_PDU_HEADER
- Description:
- Pre-evaluation of PDU header (before authentication processing).
- Definition:
- PDU_ACTIVITY_ID=SESSION_ACTIVITY_ID and
PDU_AUTH_SPEC=RT_AUTH_SPEC and
SEQ_NUM_GTE and BOOT_TIME_EQ and
PDU_VERSION_NUM=CL_VERSION_NUM_V20
- Chart:
- CL_CLIENT
- Condition:
- WORKING_PDU
- Description:
- Statechart internal flag: received working PDU.
CL_CLIENT Actions
The CL_CLIENT statechart defines the following actions:
- Chart:
- CL_CLIENT
- Action:
- CAN_CALL
- Description:
- Set up cancel PDU to be sent.
- Definition:
- INCR_CANCEL_ID;
SND_REQUEST_TYPE:=CANCEL;
st!(SEND_PKT)
- Chart:
- CL_CLIENT
- Action:
- CNTL_CALL
- Description:
- Reactions on received control PDUs.
- Definition:
- IF
CANCEL_ACK_PDU and
RT_RCV_CANCEL_ID>RT_CANCEL_ID
THEN
RT_CANCEL_ID:=RT_RCV_CANCEL_ID
END IF;
IF
FACK_PDU or NOCALL_PDU and
PDU_FACK_BODY/=NULL
THEN
EVAL_FACK_BODY
END IF;
IF
WORKING_PDU
THEN
RT_WAIT_COUNT:=RT_WAIT_COUNT+1
END IF;
IF
NOCALL_PDU or FACK_PDU and
IN_FRAG_NUM_NE
THEN
RESEND_IN_FRAGS
END IF;
IF
FAULT_PDU or REJECT_PDU
THEN
RCV_FAULT
END IF
- Chart:
- CL_CLIENT
- Action:
- DO_OUT_PKT
- Description:
- Append received response PDU body data to internal buffer.
- Definition:
- RT_CONT_OUT_FRAG_NUM:=RT_CONT_OUT_FRAG_NUM+1;
RT_OUT_PARAMS:=RT_OUT_PARAMS+RT_BODY
- Chart:
- CL_CLIENT
- Action:
- DO_REQ
- Description:
- Send last in fragment to server.
- Definition:
- fs!(TRANSMIT_REQ);
IF
LAST_IN_FRAG
THEN
tr!(SND_LAST_FRAG)
ELSE
fs!(SND_LAST_FRAG)
END IF;
SND_FRAG_NUM:=SND_FRAG_NUM+1;
SND_SERIAL_NUM:=SND_SERIAL_NUM+1;
RT_REQUEST_COUNT:=0;
RT_WAIT_COUNT:=0;
SND_IN_PARAMS:=RT_IN_FRAG;
SND_REQUEST_TYPE:=REQUEST;
st!(SEND_PKT)
- Chart:
- CL_CLIENT
- Action:
- DO_RESP
- Description:
- Evaluate response PDU header.
- Definition:
- RT_BODY:=PDU_BODY;
RT_OUT_FRAG_NUM:=PDU_FRAG_NUM;
RT_OUT_SERIAL_NUM:=PDU_SERIAL_NUM;
IF
AUTH
THEN
RT_AUTH_VERIFIER_CALL:=PDU_AUTH_VERIFIER
END IF;
IF
PDU_NO_FACK
THEN
tr!(NO_FACK)
ELSE
fs!(NO_FACK)
END IF;
IF
PDU_LAST_FRAG or not PDU_FRAG
THEN
tr!(LAST_OUT_FRAG);
RT_LAST_OUT_FRAG_NUM:=PDU_FRAG_NUM
END IF
- Chart:
- CL_CLIENT
- Action:
- EVAL_FACK_BODY
- Description:
- Invoke implementation-specific activity to evaluate fack PDU
body data.
This action reads the fack PDU body data according to the PDU
specification. It is RPC run-time system implementation-specific how
this data will be evaluated and used for subsequent fragmented
transmissions. Note that this action also handles nocall PDUs that
have body data, equivalent to fack PDU body data.
- Definition:
- rd!(PDU_FACK_BODY)
- Chart:
- CL_CLIENT
- Action:
- FACK_CALL
- Description:
- Send fack PDU if nofack flag is false or receiver
has buffer full condition.
- Definition:
- SND_IN_PARAMS:=RT_FACK_BODY;
SND_REQUEST_TYPE:=FACK;
st!(SEND_PKT)
- Chart:
- CL_CLIENT
- Action:
- FINAL
- Description:
- Send ack PDU to server (for non-idempotent calls only).
- Definition:
- WHEN
TM_ACK
THEN
SND_REQUEST_TYPE:=ACK;
st!(SEND_PKT)
END WHEN
- Chart:
- CL_CLIENT
- Action:
- FIRST_REQ
- Description:
- Set up and send first request PDU.
If the request is non-fragmented (single PDU), the actual send
activity will be performed through the LAST_REQ action.
- Definition:
- tr!(REQUEST_ACTIVE);
SND_FRAG_NUM:=0;
RT_IN_FRAG:=RT_IN_PARAMS;
SND_SEQ_NUM:=RT_SEQ_NUM;
SND_IF_ID:=RT_IF_ID;
SND_IF_VERSION:=RT_IF_VERSION;
SND_OBJ_ID:=RT_OBJ_ID;
SND_OP_NUM:=RT_OP_NUM;
SND_AUTH_SPEC:=RT_AUTH_SPEC;
RT_WAIT_COUNT:=0;
IF
not LAST_IN_FRAG
THEN
fs!(TRANSMIT_REQ);
tr!(SND_FRAG);
SND_IN_PARAMS:=RT_IN_PARAMS;
SND_REQUEST_TYPE:=REQUEST;
st!(SEND_PKT)
ELSE
fs!(SND_FRAG)
END IF
- Chart:
- CL_CLIENT
- Action:
- INCR_CANCEL_ID
- Description:
- Increment cancel_id (implementation-specific algorithm).
- Definition:
- RT_CANCEL_ID:=RT_CANCEL_ID+1
- Chart:
- CL_CLIENT
- Action:
- INIT_CANCEL_ID
- Description:
- Initialise the cancel_id to be sent in the 1st request
(implementation-specific).
- Definition:
- RT_CANCEL_ID:=0;
RT_RCV_CANCEL_ID:=0
- Chart:
- CL_CLIENT
- Action:
- RESEND_IN_FRAGS
- Description:
- Perform a resend of previously sent request fragments.
- Definition:
- fs!(TRANSMIT_REQ);
RT_REQUEST_COUNT:=RT_REQUEST_COUNT+1;
st!(RESET_IN_FRAG)
- Chart:
- CL_CLIENT
- Action:
- SETUP_CALL
- Description:
- Set up and initialise call data.
- Definition:
- fs!(REQUEST_ACTIVE);
RT_SEQ_NUM:=RT_SEQ_NUM+1;
RT_REQUEST_COUNT:=0;
fs!(SND_LAST_FRAG);
SND_SERIAL_NUM:=0;
INIT_CANCEL_ID;
fs!(RT_PENDING_CANCEL)
CL_CLIENT Data-Items
The CL_CLIENT statechart defines the following data items:
- Chart:
- CL_CLIENT
- Data Item:
- ACK
- Description:
- Constant: PDU type ack.
- Definition:
- 7
- Chart:
- CL_CLIENT
- Data Item:
- CANCEL
- Description:
- Constant: PDU type cancel.
- Definition:
- 8
- Chart:
- CL_CLIENT
- Data Item:
- CANCEL_ACK
- Description:
- Constant: PDU type cancel_ack.
- Definition:
- 10
- Chart:
- CL_CLIENT
- Data Item:
- CL_VERSION_NUM_V20
- Description:
- Constant: RPC protocol version 2.0 version number.
- Definition:
- 4
- Chart:
- CL_CLIENT
- Data Item:
- CONST_COMM_FAILURE
- Description:
- Reject status code.
- Chart:
- CL_CLIENT
- Data Item:
- FACK
- Description:
- Constant: PDU type fack.
- Definition:
- 9
- Chart:
- CL_CLIENT
- Data Item:
- FAULT
- Description:
- Constant: PDU type fault.
- Definition:
- 3
- Chart:
- CL_CLIENT
- Data Item:
- MAX_PINGS
- Description:
- Constant for max numbers of unacknowledged pings.
- Chart:
- CL_CLIENT
- Data Item:
- MAX_REQUESTS
- Description:
- Constant for maximum numbers of requests that should be sent per call.
- Chart:
- CL_CLIENT
- Data Item:
- NOCALL
- Description:
- Constant: PDU type nocall.
- Definition:
- 5
- Chart:
- CL_CLIENT
- Data Item:
- PDU_ACTIVITY_ID
- Description:
- PDU header field: act_id.
- Chart:
- CL_CLIENT
- Data Item:
- PDU_AUTH_SPEC
- Description:
- PDU header field: auth_proto.
- Chart:
- CL_CLIENT
- Data Item:
- PDU_AUTH_VERIFIER
- Description:
- PDU trailer: authentication verifier (authentication protocol-specific).
- Chart:
- CL_CLIENT
- Data Item:
- PDU_BODY
- Description:
- Array of PDU body data.
- Chart:
- CL_CLIENT
- Data Item:
- PDU_BOOT_TIME
- Description:
- PDU header field: server_boot (value of zero at first request
from client).
- Chart:
- CL_CLIENT
- Data Item:
- PDU_CANCEL_ID
- Description:
- cancel_id of received cancel_ack PDU body data.
- Chart:
- CL_CLIENT
- Data Item:
- PDU_FACK_BODY
- Description:
- Body information of fack PDU (implementation-dependent).
- Chart:
- CL_CLIENT
- Data Item:
- PDU_FAULT_STATUS
- Description:
- Fault status associated with the fault PDU body.
- Chart:
- CL_CLIENT
- Data Item:
- PDU_FRAG_NUM
- Description:
- PDU header field: fragnum.
- Chart:
- CL_CLIENT
- Data Item:
- PDU_REJECT_STATUS
- Description:
- Reject status code associated with reject PDU body.
- Chart:
- CL_CLIENT
- Data Item:
- PDU_SEQ_NUM
- Description:
- PDU header field: seqnum.
- Chart:
- CL_CLIENT
- Data Item:
- PDU_SERIAL_NUM
- Description:
- PDU header field: serial_hi.
- Chart:
- CL_CLIENT
- Data Item:
- PDU_TYPE
- Description:
- PDU header field: ptype.
- Chart:
- CL_CLIENT
- Data Item:
- PDU_VERSION_NUM
- Description:
- PDU header field: rpc_vers.
- Chart:
- CL_CLIENT
- Data Item:
- PING
- Description:
- Constant: PDU type ping.
- Definition:
- 1
- Chart:
- CL_CLIENT
- Data Item:
- REJECT
- Description:
- Constant: PDU type reject.
- Definition:
- 6
- Chart:
- CL_CLIENT
- Data Item:
- REQUEST
- Description:
- Constant: PDU type request.
- Definition:
- 0
- Chart:
- CL_CLIENT
- Data Item:
- RESPONSE
- Description:
- Constant: PDU type response.
- Definition:
- 2
- Chart:
- CL_CLIENT
- Data Item:
- RT_AUTH_SPEC
- Description:
- Statechart internal: authentication protocol specifier used in current call.
- Chart:
- CL_CLIENT
- Data Item:
- RT_AUTH_VERIFIER_CALL
- Description:
- Statechart internal: received authentication trailer (verifier) for
response PDU.
- Chart:
- CL_CLIENT
- Data Item:
- RT_AUTH_VERIFIER_CNTL
- Description:
- Received authentication trailer (verifier) for control PDU.
- Chart:
- CL_CLIENT
- Data Item:
- RT_BODY
- Description:
- Statechart internal: temporarily buffered response PDU body data.
- Chart:
- CL_CLIENT
- Data Item:
- RT_CANCEL_ID
- Description:
- Statechart internal: cancel_id as received with cancel_ack PDU.
- Chart:
- CL_CLIENT
- Data Item:
- RT_CONT_OUT_FRAG_NUM
- Description:
- Statechart internal: last fragment number of continuously buffered
out block.
- Chart:
- CL_CLIENT
- Data Item:
- RT_EXCEPTION_STATUS
- Description:
- Statechart internal: status value passed to exception handler.
- Chart:
- CL_CLIENT
- Data Item:
- RT_FACK_BODY
- Description:
- Statechart internal: body data for fack PDU.
- Chart:
- CL_CLIENT
- Data Item:
- RT_IF_ID
- Description:
- Statechart internal: buffered interface UUID of RPC.
- Chart:
- CL_CLIENT
- Data Item:
- RT_IF_VERSION
- Description:
- Statechart internal: buffered interface version of RPC.
- Chart:
- CL_CLIENT
- Data Item:
- RT_IN_FRAG
- Description:
- Statechart internal pointer to data to be sent in next request PDU.
The SEND_PKT activity increments this pointer after a request
PDU was sent.
- Chart:
- CL_CLIENT
- Data Item:
- RT_IN_PARAMS
- Description:
- Statechart internal: buffered array of reassembled input data.
RT_IN_PARAMS is the queue of transmit data provided by the stub.
A possible segmentation of this queue is not equivalent to the sizes
of PDU fragments sent by the run-time system (SEND_PKT) activity.
The RT_IN_FRAG variable is a pointer data type that points to the
to be transmitted data fragment within this RT_IN_PARAMS queue.
- Chart:
- CL_CLIENT
- Data Item:
- RT_LAST_OUT_FRAG_NUM
- Description:
- Fragment number of last out fragment of remote procedure call.
- Chart:
- CL_CLIENT
- Data Item:
- RT_OBJ_ID
- Description:
- Statechart internal: buffered object UUID of RPC.
- Chart:
- CL_CLIENT
- Data Item:
- RT_OP_NUM
- Description:
- Statechart internal: buffered operation number of RPC.
- Chart:
- CL_CLIENT
- Data Item:
- RT_OUT_FRAG_NUM
- Description:
- Statechart internal: fragnum of currently received
response PDU.
- Chart:
- CL_CLIENT
- Data Item:
- RT_OUT_PARAMS
- Description:
- Buffered array of unfragmented output data.
- Chart:
- CL_CLIENT
- Data Item:
- RT_OUT_SERIAL_NUM
- Description:
- Serial number of sent fragment.
- Chart:
- CL_CLIENT
- Data Item:
- RT_PING_COUNT
- Description:
- Counter for transmitted ping PDUs per WAIT cycle.
- Chart:
- CL_CLIENT
- Data Item:
- RT_RCV_CANCEL_ID
- Description:
- Statechart internal: received cancel identifier.
- Chart:
- CL_CLIENT
- Data Item:
- RT_REQUEST_COUNT
- Description:
- The number of times a request PDU has been sent for
the current fragment.
- Chart:
- CL_CLIENT
- Data Item:
- RT_SEQ_NUM
- Description:
- Sequence number of call: determined by the run-time system
(implementation-specific).
The SETUP_CALL action increments this sequence number for every new
instance of a call. Implementations may choose a different algorithm,
complying to the definition of sequence numbers as specified in
Connectionless RPC PDUs
.
- Chart:
- CL_CLIENT
- Data Item:
- RT_WAIT_COUNT
- Description:
- Statechart internal: counter to determine the length of wait in
REQ_WAIT state.
- Chart:
- CL_CLIENT
- Data Item:
- SESSION_ACTIVITY_ID
- Description:
- Statechart internal: activity UUID of current RPC (passed from stub).
- Chart:
- CL_CLIENT
- Data Item:
- SND_ACTIVITY_ID
- Description:
- Activity UUID of current RPC.
- Chart:
- CL_CLIENT
- Data Item:
- SND_AUTH_SPEC
- Description:
- Authentication specifier used for current RPC.
- Chart:
- CL_CLIENT
- Data Item:
- SND_BOOT_TIME
- Description:
- Boot time value promoted to SEND_PKT activity.
- Chart:
- CL_CLIENT
- Data Item:
- SND_FRAG_NUM
- Description:
- Fragment number of PDU to be sent.
- Chart:
- CL_CLIENT
- Data Item:
- SND_IF_ID
- Description:
- Interface UUID of current RPC.
- Chart:
- CL_CLIENT
- Data Item:
- SND_IF_VERSION
- Description:
- Interface version number of current RPC.
- Chart:
- CL_CLIENT
- Data Item:
- SND_IN_PARAMS
- Description:
- PDU body data promoted to SEND_PKT activity.
- Chart:
- CL_CLIENT
- Data Item:
- SND_OBJ_ID
- Description:
- Object UUID of current RPC.
- Chart:
- CL_CLIENT
- Data Item:
- SND_OP_NUM
- Description:
- Operation number of current RPC.
- Chart:
- CL_CLIENT
- Data Item:
- SND_REQUEST_TYPE
- Description:
- PDU type to be sent.
- Chart:
- CL_CLIENT
- Data Item:
- SND_SEQ_NUM
- Description:
- Sequence number of current RPC.
- Chart:
- CL_CLIENT
- Data Item:
- SND_SERIAL_NUM
- Description:
- Serial number of PDU to be sent.
- Chart:
- CL_CLIENT
- Data Item:
- TIMEOUT_ACK
- Description:
- Timeout value for how long the client will wait before sending an
ack PDU.
- Chart:
- CL_CLIENT
- Data Item:
- TIMEOUT_BROADCAST
- Description:
- Timeout value for how long the client will wait for response to a
broadcast PDU.
- Chart:
- CL_CLIENT
- Data Item:
- TIMEOUT_CANCEL
- Description:
- Timeout value for cancel requests.
Sets the lower bound on the time to wait before timing out after
forwarding a cancel PDU to the server. The default of this timeout
value is set to one second (refer to
Architected and Default Values for Protocol Machines
.)
Applications may set a different value via the
rpc_mgmt_set_cancel_timeout RPC API.
- Chart:
- CL_CLIENT
- Data Item:
- TIMEOUT_FRAG
- Description:
- Timeout value for wait for a fack PDU after a request PDU
(no nofack) sent.
- Chart:
- CL_CLIENT
- Data Item:
- TIMEOUT_PING
- Description:
- Timeout value for how long to wait for response to a ping PDU.
- Chart:
- CL_CLIENT
- Data Item:
- TIMEOUT_WAIT
- Description:
- Timeout value for how long the client will wait for a response.
- Chart:
- CL_CLIENT
- Data Item:
- WORKING
- Description:
- Constant: PDU type working.
- Definition:
- 4
CL_SERVER Machine
CL_SERVER Statechart
shows the CL_SERVER machine statechart.
Figure: CL_SERVER Statechart
CL_SERVER Activities
The CL_SERVER statechart defines the following activities:
- Chart:
- CL_SERVER
- Activity:
- ABORT_CALL
- Description:
- Flush and discard any further received packets for this call. If this
activity was caused by a detected failure, there may be numerous
additional packets in the pipeline. The flush may be lazy, upon
subsequent receive processing. Also, notify the run-time system and stub to
reclaim any resources for this call.
- Chart:
- CL_SERVER
- Activity:
- CANCEL_NOTIFY_APP
- Description:
- This activity notifies the manager routine of the RPC application
about the cancel request issued by the client.
CANCEL_NOTIFY_APP activity terminates after acknowledgement from the
stub. The stub sets the RETURN_PENDING_CANCEL flag appropriately.
- Chart:
- CL_SERVER
- Activity:
- HANDLE_IN_FRAG
- Description:
- This activity is invoked at each received fragment evaluation of
in parameters for multi-fragmented RPC requests.
The HANDLE_IN_FRAG activity makes received data of continuous
fragments available to the stub for unmarshalling and passes the
object UUID (RT_OBJ_ID) to the manager routine. This does not require
a transfer of control from the run-time system to the stub for each fragment;
implementation policy determines when control is transferred.
In addition, if the server receives a fragment out of order,
HANDLE_IN_FRAG buffers this fragment temporarily until subsequently
received fragments allow for a consecutive inclusion of these
temporarily buffered fragments. The fragment ordering is determined
by the fragment number (RT_IN_FRAG_NUM). If previously buffered out
of order fragments are appended to the continuous receive buffer
(RT_IN_PARAMS), HANDLE_IN_FRAG must also adjust the state variable
RT_CONT_IN_FRAG_NUM. HANDLE_IN_FRAG also maintains the selective
acknowledgement bit masks which are used in the fack PDU.
Modifications of RT_CONT_IN_FRAG_NUM must be synchronised with other
actions (DO_IN_PKT) performed by the protocol machine.
- Chart:
- CL_SERVER
- Activity:
- RESET_OUT_FRAG
- Description:
- This activity is invoked if the protocol machine determines that a set
of fragments needs to be retransmitted. RESET_OUT_FRAG resets the
values of SND_FRAG_NUM and RT_OUT_FRAG to the beginning of the
transmission queue. Note that the condition LAST_OUT_FRAG must also
be set appropriately.
The first fragment in this queue may not fragment number 0, since
other fragment acknowledgements may have been received, allowing the
server to free previously sent data packets. Implementations
must keep state about the acknowledgement of sent fragmented response
PDUs.
This activity generates the event RESEND and marks TRANSMIT_RESP as
true to trigger the transitions that actually invoke the
appropriate SEND_PKT activities.
- Chart:
- CL_SERVER
- Activity:
- SEND_PKT
- Description:
- Prepare a PDU to send to the client, adding the appropriate header
information as necessary. If security services were requested
(conditional flag AUTH is true), apply per-message security services.
Send the PDU.
The conditional flags and data items set in the run-time system (with prefix
SND_) provide the appropriate input for generating the PDU data.
Note that actions within the same execution step that started this
activity may have assigned values to the SND_* variables which have to
be taken by this instance of the activity.
After sending a response PDU, the RT_OUT_FRAG pointer is incremented
accordingly, to point to the remaining data in the transmit queue.
- Note:
- The SEND_PKT activity may be invoked simultaneously by several
orthogonal states (WORKING, CONTROL, CANCEL, and so on).
The run-time system must catch these send requests, buffer these and the
associated data, and perform the sends in sequential order.
- Chart:
- CL_SERVER
- Activity:
- SEND_WAY
- Description:
- Set up and perform the conversation manager remote procedure call
conv_who_are_you() (specified in
Conversation Manager Interface Definition
).
Conversation manager operations enable servers to enforce
at-most-once execution semantics.
The server invokes this activity when it does not have a record of the
client's call sequence number.
There are three cases in which a server will have no record of a
client's sequence number:
-
when the request is the first request from the client
-
when the request is a duplicate and the server has executed the
original request, but due to a crash, the server has not sent a
response and has lost all information about the client
-
when the request is a duplicate, the server has executed the original
request, and the server has sent a response, but due to a delay in the
client acknowledgement, the server has discarded all information about
the client.
Input parameters for this call are:
- h
- The primitive call handle.
- actuid
- This is SND_ACTIVITY_ID, passed from the protocol machine; the
activity UUID of the current outstanding request. In implementations
that support multiple simultaneous client requests, this value is used
to identify the client about whose request the server is querying.
- boot_time
- This is SYS_BOOT_TIME, passed from the protocol machine; the server's
boot time.
Output parameters are:
- seq
- This is passed as PARAM_CB_SEQ_NUM to the protocol machine: the
sequence number that the client associates with its current
outstanding request.
- st
- This is passed as PARAM_CB_STATUS to the protocol machine; the status
information returned by the operation. This may be one of:
- CONST_RPC_S_OK
- Operation succeeded.
- CONST_YOU_CRASHED
- The server has crashed and rebooted since establishing communication
with the client.
- CONST_BAD_ACT_ID
- The activity UUID was wrong.
The client of the initiating RPC acts as server for an idempotent
call with the same activity identifier (that is, a CL_SERVER protocol
machine gets instantiated). The client (now acting as server) sets
the received server boot_time (SYS_BOOT_TIME) in the client protocol
machine (SND_BOOT_TIME). If the client subsequently receives a
conversation manager request whose SYS_BOOT_TIME is later than the
stored SND_BOOT_TIME, the client knows that the server has crashed and
rebooted and sends a status CONST_YOU_CRASHED in its response.
- Chart:
- CL_SERVER
- Activity:
- SEND_WAY2
- Description:
- SEND_WAY2 supersedes SEND_WAY and is called only if the server stub
signals that it requires the execution context of the current call and
if the run-time protocol machine has not obtained this state
information yet. This activity performs the conv_who_are_you2()
remote procedure call (specified in
Conversation Manager Interface Definition
).
The additional output parameter is:
- cas_uuid
- This is passed as PARAM_CLIENT_EXECUTION_CONTEXT to the protocol
machine: a UUID that uniquely identifies the execution context
(address space) of the calling client. This information is needed for
servers that maintain client context state.
- Note:
- If the RPC is an authenticated call, the run-time system should have the
execution context information already, since
PARAM_CLIENT_EXECUTION_CONTEXT is carried as out parameter of the
SEND_WAYAUTH activity.
- Chart:
- CL_SERVER
- Activity:
- SEND_WAYAUTH
- Description:
- SEND_WAYAUTH supersedes SEND_WAY and SEND_WAY2 and is called
only for authenticated RPC requests (conditional flag AUTH
is true) that do not use a previously established security
context (RT_SECURITY_CONTEXT condition is false). This
activity performs the conv_who_are_you_auth() remote
procedure call (specified in
Conversation Manager Interface Definition
).
Should the security information be larger than a full packet, the
client returns a partial credentials status code. The server then
makes additional calls to conv_who_are_you_auth_more()
until the complete security credentials are assembled. If the
conv_who_are_you_auth() call is returned with a challenge
malformed, the server then assumes that the client does not support
EPAC and an old style challenge is issued.
The additional input parameters for conv_who_are_you_auth() are:
- in_len
- This is SND_CB_IN_LEN, passed from the protocol machine;
the length in bytes of SND_CB_IN_DATA.
- in_data
- This is SND_CB_IN_DATA, passed from the protocol machine;
An array of bytes issued to the client as an authentication
challenge.
Contents of in_data are determined by the authentication
protocol used. Encodings for the protocol
dce_c_rpc_authn_protocol_krb5 are specified in
Security Services for Connectionless Protocol
.
- out_max_len
- This is SND_CB_OUT_MAX_LEN, passed from the protocol machine;
the maximum length in bytes of the array to be returned in
PARAM_CB_OUT_DATA.
The additional output parameters are:
- out_len
- This is passed as PARAM_CB_OUT_LEN to the protocol machine;
the length in bytes of PARAM_CB_OUT_DATA.
- out_data
- This is passed as PARAM_CB_OUT_DATA to the protocol machine; an array
of bytes returned to the server as an authentication response.
Contents of out_data are determined by the authentication
protocol used. Encodings for dce_c_rpc_authn_protocol_krb5
protocol are specified in
Security Services for Connectionless Protocol
.
The client of the initiating RPC (now acting as server) verifies
the received challenge message and sets (if succeeded) the condition
flag RT_SECURITY_CONTEXT in the client protocol machine to true,
otherwise it sets RT_SECURITY_CONTEXT to false and raises the event
DENIED.
- Chart:
- CL_SERVER
- Activity:
- VERIFY_AUTH
- Description:
- Verify the authentication trailer of PDU and decrypt message if
necessary.
This activity takes as input values the PDU header field auth_proto
(authentication protocol specifier: RT_AUTH_SPEC) and the
authentication verifier (PDU trailer: RT_AUTH_VERIFIER).
Depending on the result of the verification, the activity VERIFY_AUTH
generates either the event AUTHENTICATED (success) or DENIED
(authentication failure).
The algorithm applied to this activity is dependent on the security
service in use (determined by RT_AUTH_SPEC). The general evaluation
steps for authentication service rpc_c_authn_dce_secret are as
follows (for more details see
Security
):
- Note:
- The VERIFY_AUTH activity may be invoked simultaneously by several
orthogonal states (WORKING, CONTROL and CANCEL). VERIFY_AUTH must
not generate the event AUTHENTICATED unless the entire requested
authentication processing is completed. If VERIFY_AUTH detects an
authentication failure and generates the event DENIED, the protocol
machine rejects the RPC and no further processing is required.
- Chart:
- CL_SERVER
- Activity:
- VERIFY_AUTH_CONTEXT
- Description:
- Verifies the results of the conversation manager callback
(SEND_WAYAUTH) according to the authentication protocol used.
This activity evaluates the returned parameter PARAM_CB_OUT_DATA
(PARAM_CB_OUT_LEN), containing the authentication response. It sets
the condition flag RT_SECURITY_CONTEXT to true if verification
succeeded or raises DENIED if verification failed.
CL_SERVER States
The CL_SERVER statechart defines the following states:
- Chart:
- CL_SERVER
- State:
- AUTHENTICATION
- Description:
- Process authentication verification.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| [RT_SECURITY_CONTEXT]
| st!(VERIFY_AUTH)
|
|---|
- Chart:
- CL_SERVER
- State:
- AUTHENTICATION
- Description:
- Process authentication verification.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| [RT_SECURITY_CONTEXT]
| st!(VERIFY_AUTH)
|
|---|
- Chart:
- CL_SERVER
- State:
- AUTHENTICATION
- Description:
- Process authentication verification.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| [RT_SECURITY_CONTEXT]
| st!(VERIFY_AUTH)
|
|---|
- Chart:
- CL_SERVER
- State:
- CALL
- Description:
- Processing a remote procedure call request.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| entering
| RT_IN_PARAMS:=NULL;
RT_CONT_IN_FRAG_NUM:=-1
|
|---|
| entering
| IF
PDU_IDEMPOTENT
THEN
tr!(IDEMPOTENT)
END IF
|
| entering
| IF
PDU_MAYBE
THEN
tr!(MAYBE)
END IF
|
| entering
| IF
PDU_BROADCAST
THEN
tr!(BROADCAST)
END IF
|
| entering
| IF
SEQ_NUM_GT
THEN
RT_SEQ_NUM:=PDU_SEQ_NUM
END IF
|
- Chart:
- CL_SERVER
- State:
- CALLBACK
- Description:
- Processing of conversation manager callback procedures.
- Chart:
- CL_SERVER
- State:
- CANCEL
- Description:
- Processing of client requests to terminate the call in progress.
The reaction within this state senses the termination of the
CANCEL_NOTIFY_APP activity as cancel acknowledgement from the server
manager routine. The manager routine also sets the
RETURN_PENDING_CANCEL flag appropriately.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| entering
| fs!(SND_PENDING_CANCEL);
RT_CANCEL_ID:=0
|
|---|
| sp(CANCEL_NOTIFY_APP)
| IF
RETURN_PENDING_CANCEL
THEN
tr!(SND_PENDING_CANCEL)
END IF;
CANACK_CALL
|
- Chart:
- CL_SERVER
- State:
- CAN_IDLE
- Description:
- Waits for cancel requests.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| exiting
| IF
AUTH
THEN
RT_AUTH_VERIFIER_CAN:=PDU_AUTH_VERIFIER
END IF
|
|---|
- Chart:
- CL_SERVER
- State:
- CHK_SEC_CNTXT
- Description:
- Verify the security context negotiated through SEND_WAYAUTH callback.
- Activities Throughout:
VERIFY_AUTH_CONTEXT
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| ex(CHK_SEC_CNTXT)
|
|
|---|
| [RT_SECURITY_CONTEXT]
| fs!(CONTEXT_REQUEST);
RT_CLIENT_EXECUTION_CONTEXT:=
PARAM_CLIENT_EXECUTION_CONTEXT
|
- Chart:
- CL_SERVER
- State:
- CL_SERVER
- Description:
- Main state for statechart CL_SERVER.
- Chart:
- CL_SERVER
- State:
- CNTL_IDLE
- Description:
- Waits for incoming control PDUs.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| RECEIVE_PDU[PDU_TYPE=ACK
and VALID_PDU_HEADER]
| tr!(ACK_PDU)
|
|---|
| RECEIVE_PDU[PDU_TYPE=FACK
and VALID_PDU_HEADER]
| tr!(FACK_PDU)
|
| RECEIVE_PDU[PDU_TYPE=PING
and VALID_PDU_HEADER]
| tr!(PING_PDU)
|
| exiting
| IF
AUTH
THEN
RT_AUTH_VERIFIER_CNTL:=
PDU_AUTH_VERIFIER
END IF
|
| en(CNTL_IDLE)
| fs!(ACK_PDU);
fs!(FACK_PDU);
fs!(PING_PDU)
|
| RECEIVE_PDU[CNTL_PDU
and VALID_PDU_HEADER]
| RCV_CNTL_PDU
|
- Chart:
- CL_SERVER
- State:
- CONTROL
- Description:
- Processing received control PDUs.
- Chart:
- CL_SERVER
- State:
- DATA
- Description:
- Processing the data PDUs for remote procedure call.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| en(DATA)
| SND_SERIAL_NUM:=0;
RT_REPLY_COUNT:=0
|
|---|
- Chart:
- CL_SERVER
- State:
- INDICATION
- Description:
- Handles incoming RPC request fragments.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| en(INDICATION)[not NO_FACK or not
LAST_IN_FRAG and RT_BUF_LIMIT
and NO_FACK]
| FACK_CALL
|
|---|
| en(INDICATION)[not LAST_IN_FRAG and
RT_IN_FRAG_NUM=RT_CONT_IN_FRAG_NUM+1]
| DO_IN_PKT;
st!(HANDLE_IN_FRAG)
|
| en(INDICATION)[not LAST_IN_FRAG and
RT_IN_FRAG_NUM/=RT_CONT_IN_FRAG_NUM+1]
| st!(HANDLE_IN_FRAG)
|
| RECEIVE_PDU[PDU_TYPE=REQUEST and
VALID_PDU_HEADER and not AUTH]
| DO_REQ;
RCV_FRAG_PDU
|
| RECEIVE_PDU[PDU_TYPE=REQUEST and
VALID_PDU_HEADER and AUTH]
| DO_REQ;
RCV_FRAG_PDU_A
|
| en(INDICATION)[LAST_IN_FRAG and
RT_LAST_IN_FRAG_NUM=
RT_CONT_IN_FRAG_NUM+1]
| st!(HANDLE_IN_FRAG);
RCV_LAST_IN_FRAG
|
- Chart:
- CL_SERVER
- State:
- INIT
- Description:
- Initial call state. Waits for request from client.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| RECEIVE_PDU[PDU_TYPE=REQUEST
and not BOOT_TIME_EQ]
| REJECT_CALL
|
|---|
| tm(en(WORKING), TIMEOUT_IDLE)
| st!(ABORT_CALL)
|
- Chart:
- CL_SERVER
- State:
- PROCESS_REQ
- Description:
- Promotes completely received request to manager routine (RPC stub).
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| entering
| RT_OUT_PARAMS:=NULL
|
|---|
- Chart:
- CL_SERVER
- State:
- REPLIED
- Description:
- Terminal state for at-most-once calls.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| tm(en(REPLIED), TIMEOUT_RESEND)
| RESEND_OUT_FRAGS
|
|---|
- Chart:
- CL_SERVER
- State:
- REPLYING
- Description:
- Handles fragmented reply to client.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| tm(en(REPLYING), TIMEOUT_RESEND)
| RESEND_OUT_FRAGS
|
|---|
- Chart:
- CL_SERVER
- State:
- WAIT_WAY
- Description:
- Invoke conversation manager and wait for response.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| en(WAIT_WAY)
| DO_CALLBACK
|
|---|
| ex(WAIT_WAY)[not AUTH
and CONTEXT_REQUEST]
| fs!(CONTEXT_REQUEST);
RT_CLIENT_EXECUTION_CONTEXT:=
PARAM_CLIENT_EXECUTION_CONTEXT
|
- Chart:
- CL_SERVER
- State:
- WAY_IDLE
- Description:
- Idle unless new conversation manager request.
- Chart:
- CL_SERVER
- State:
- WORKING
- Description:
- Main working state for call instance.
| Reactions
|
|---|
| Trigger
| Action
|
|---|
| en(WORKING)
| fs!(BROADCAST);
fs!(MAYBE);
fs!(IDEMPOTENT);
fs!(LAST_IN_FRAG)
|
|---|
CL_SERVER Events
The CL_SERVER statechart defines the following events:
- Chart:
- CL_SERVER
- Event:
- ABORT
- Description:
- RPC session (same activity UUID) has terminated.
- Definition:
- st(ABORT_CALL)
- Chart:
- CL_SERVER
- Event:
- AUTHENTICATED
- Description:
- Authentication processing completed successfully.
- Chart:
- CL_SERVER
- Event:
- AUTHENTICATED_RES
- Description:
- Authentication for cancel PDU successful (request already processed).
- Definition:
- AUTHENTICATED[in(CANCEL.AUTHENTICATION)
and (in(REPLYING) or in(REPLIED))]
- Chart:
- CL_SERVER
- Event:
- CB_COMPLETES
- Description:
- Callback completes successfully: the conversation manager callback has
completed.
- Definition:
- (sp(SEND_WAY) or
sp(SEND_WAYAUTH))[PARAM_CB_STATUS=CONST_RPC_S_OK]
- Chart:
- CL_SERVER
- Event:
- CB_FAULT
- Description:
- Callback completes: client detected mismatch in sequence numbers.
- Definition:
- (sp(SEND_WAY) or
sp(SEND_WAYAUTH))[RT_SEQ_NUM/=PARAM_CB_SEQ_NUM]
- Chart:
- CL_SERVER
- Event:
- CB_REJECT
- Description:
- Callback completes: client detected wrong activity identifier or a
server boot time error.
- Definition:
- (sp(SEND_WAY) or
sp(SEND_WAYAUTH))[PARAM_CB_STATUS=CONST_YOU_CRASHED
or PARAM_CB_STATUS=CONST_BAD_ACT_ID]
- Chart:
- CL_SERVER
- Event:
- COMPLETE
- Description:
- RPC completed (with success or fault).
- Definition:
- sp(SEND_PKT)[SND_REPLY_TYPE=CANCEL_ACK]
or CB_FAULT or CB_REJECT or
PROCESSING_FAULT[IDEMPOTENT or BROADCAST or MAYBE]
or COMPLETE_CLEAR or COMPLETE_FREE
or en(REPLIED)[LAST_OUT_FRAG and IDEMPOTENT]
or DENIED
- Chart:
- CL_SERVER
- Event:
- COMPLETE_CLEAR
- Description:
- Ready to clear out parameters.
- Definition:
- PROCESSING_FDNE[IDEMPOTENT] or
[(in(REPLYING) or in(REPLIED)) and
RT_REPLY_COUNT>MAX_REPLIES] or
AUTHENTICATED_RES or
en(CNTL_IDLE)[ACK_PDU and NON_IDEMPOTENT]
- Chart:
- CL_SERVER
- Event:
- COMPLETE_FREE
- Description:
- Ready to free activity record for requesting client.
- Definition:
- PROC_RESPONSE[MAYBE] or
PROCESSING_FDNE[BROADCAST or MAYBE] or
[AUTH and TICKET_EXP]
- Chart:
- CL_SERVER
- Event:
- DENIED
- Description:
- Authentication failure detected.
The VERIFY_AUTH activity generates this event if either the integrity
check failed or the requested protection level for authentication
services does not match.
- Chart:
- CL_SERVER
- Event:
- LAST_OUT_PKT
- Description:
- Statechart internal event: last fragment of fragmented response.
- Definition:
- [TRANSMIT_RESP and LAST_OUT_FRAG and BURST]
or en(CNTL_IDLE)[TRANSMIT_RESP and
FACK_PDU and LAST_OUT_FRAG and
OUT_FRAG_NUM_EQ]
- Chart:
- CL_SERVER
- Event:
- NEXT_OUT_PKT
- Description:
- Statechart internal event: intermediate fragment of fragmented response
- Definition:
- [TRANSMIT_RESP and not LAST_OUT_FRAG and
BURST] or en(CNTL_IDLE)[TRANSMIT_RESP and
FACK_PDU and not LAST_OUT_FRAG and
OUT_FRAG_NUM_EQ]
- Chart:
- CL_SERVER
- Event:
- PROCESSING_FAULT
- Description:
- Execution of procedure failed. Returned from called procedure (stub).
- Chart:
- CL_SERVER
- Event:
- PROCESSING_FDNE
- Description:
- Stub (manager routine) or run-time system rejected RPC request.
The call did not execute.
- Chart:
- CL_SERVER
- Event:
- PROC_FAULT
- Description:
- Cannot execute or fault returned from called procedure (stub).
- Definition:
- PROCESSING_FAULT or PROCESSING_FDNE[not
BROADCAST and not MAYBE]
- Chart:
- CL_SERVER
- Event:
- PROC_RESPONSE
- Description:
- Call returned from called procedure (server manager routine).
This event indicates that the called application procedure is ready to
response to the RPC request and has provided out parameter data in the
RT_OUT_PARAMS queue. The processing of the application procedure may
not have been completed and more out parameter data may to be queued
(sensed by the TRANSMIT_RESP and LAST_OUT_FRAG condition flags).
- Chart:
- CL_SERVER
- Event:
- RCV_CAN_PDU
- Description:
- Received cancel PDU with valid header.
- Definition:
- RECEIVE_PDU[PDU_TYPE=CANCEL and
VALID_PDU_HEADER and
PDU_CANCEL_VERSION=CONST_CANCEL_VERSION
and in(DATA)]
- Chart:
- CL_SERVER
- Event:
- RCV_CNTL_PDU
- Description:
- Received one of the control PDUs (ack, fack or ping)
with valid header.
- Chart:
- CL_SERVER
- Event:
- RCV_FRAG_PDU
- Description:
- Received PDU for nonauthenticated fragmented requests with valid header.
- Chart:
- CL_SERVER
- Event:
- RCV_FRAG_PDU_A
- Description:
- Received PDU for authenticated fragmented request with valid header.
- Chart:
- CL_SERVER
- Event:
- RCV_LAST_IN_FRAG
- Description:
- Received last fragment of request PDU and callback completed (for
at-most-once).
All fragments of a multi-fragmented request are received or a single
packet request was received. RCV_LAST_IN_FRAG signals that the
complete request data is available to the stub for unmarshalling, and
it transfers the control from the run-time system to the stub for processing
the RPC request.
- Chart:
- CL_SERVER
- Event:
- RCV_NEXT_CALL
- Description:
- Receive next remote procedure call with same activity ID.
- Definition:
- RCV_REQ_PDU[in(REPLIED)]
- Chart:
- CL_SERVER
- Event:
- RCV_REQ_PDU
- Description:
- Received request PDU (first packet for fragmented requests)
with valid header.
- Definition:
- RECEIVE_PDU[PDU_TYPE=REQUEST and
(PDU_FRAG and PDU_FRAG_NUM=0 or not
PDU_FRAG) and SEQ_NUM_GT and BOOT_TIME_EQ
and PDU_VERSION_NUM=CL_VERSION_NUM_V20]
- Chart:
- CL_SERVER
- Event:
- RECEIVE_PDU
- Description:
- Received a PDU from client.
- Chart:
- CL_SERVER
- Event:
- RESEND
- Description:
- Statechart internal event that triggers a resend of complete reply PDUs.
- Chart:
- CL_SERVER
- Event:
- SEND_RESPONSE
- Description:
- Called procedure provided out parameters to be sent.
- Definition:
- PROC_RESPONSE[not MAYBE]
CL_SERVER Actions
The CL_SERVER statechart defines the following actions:
- Chart:
- CL_SERVER
- Action:
- CANACK_CALL
- Description:
- Set up cancel_ack PDU to be sent.
The body data of this cancel acknowledgement message consists of:
-
CONST_CANCEL_VERSION (that is, version number 0)
-
RT_CANCEL_ID
-
RT_PENDING_CANCEL.
(See also the PDU encoding of cancel_ack.)
- Definition:
- SND_REPLY_TYPE:=CANCEL_ACK;
st!(SEND_PKT)
- Chart:
- CL_SERVER
- Action:
- CNTL_CALL
- Description:
- Reactions on received control PDUs.
- Definition:
- IF
PING_PDU
THEN
PING_CALL
END IF;
IF
FACK_PDU
THEN
EVAL_FACK_BODY;
IF
in(REPLYING) and OUT_FRAG_NUM_NE or
in(REPLIED) and SEQ_NUM_LE
THEN
RESEND_OUT_FRAGS
END IF
END IF
- Chart:
- CL_SERVER
- Action:
- DO_CALLBACK
- Description:
- Initialise and start activity SEND_WAY (conversation manager callback
procedure).
- Definition:
- SND_ACTIVITY_ID:=RT_ACTIVITY_ID;
SND_AUTH_SPEC:=RT_AUTH_SPEC;
IF
not AUTH and not CONTEXT_REQUEST or AUTH
and RT_SECURITY_CONTEXT
THEN
st!(SEND_WAY)
END IF;
IF
not AUTH and CONTEXT_REQUEST
THEN
st!(SEND_WAY2)
END IF;
IF
AUTH and not RT_SECURITY_CONTEXT
THEN
st!(SEND_WAYAUTH)
END IF
- Chart:
- CL_SERVER
- Action:
- DO_IN_PKT
- Description:
- Append received request PDU body data to internal buffer.
- Definition:
- RT_CONT_IN_FRAG_NUM:=RT_CONT_IN_FRAG_NUM+1;
RT_IN_PARAMS:=RT_IN_PARAMS+RT_BODY
- Chart:
- CL_SERVER
- Action:
- DO_REPLY
- Description:
- Send out fragment to requesting client.
- Definition:
- fs!(TRANSMIT_RESP);
IF
LAST_OUT_FRAG
THEN
tr!(SND_LAST_FRAG)
ELSE
fs!(SND_LAST_FRAG)
END IF;
SND_FRAG_NUM:=SND_FRAG_NUM+1;
SND_SERIAL_NUM:=SND_SERIAL_NUM+1;
SND_OUT_PARAMS:=RT_OUT_FRAG;
SND_REPLY_TYPE:=RESPONSE;
st!(SEND_PKT)
- Chart:
- CL_SERVER
- Action:
- DO_REQ
- Description:
- Evaluate request PDU header.
- Definition:
- RT_BODY:=PDU_BODY;
RT_IN_FRAG_NUM:=PDU_FRAG_NUM;
RT_IN_SERIAL_NUM:=PDU_SERIAL_NUM;
IF
PDU_AUTH_SPEC/=0
THEN
RT_AUTH_VERIFIER_CALL:=PDU_AUTH_VERIFIER
END IF;
IF
PDU_NO_FACK or PDU_FRAG
THEN
tr!(NO_FACK)
ELSE
fs!(NO_FACK)
END IF;
IF
PDU_LAST_FRAG or not PDU_FRAG
THEN
tr!(LAST_IN_FRAG);
RT_LAST_IN_FRAG_NUM:=PDU_FRAG_NUM
END IF
- Chart:
- CL_SERVER
- Action:
- ERROR_CALL
- Description:
- Set up error PDU (fault or reject) to be sent.
- Definition:
- WHEN
PROCESSING_FAULT[not BROADCAST and not
MAYBE]
THEN
RT_OUT_PARAMS:=SND_FAULT_STATUS;
SND_REPLY_TYPE:=FAULT;
st!(SEND_PKT)
ELSE
WHEN
PROCESSING_FDNE[not BROADCAST and
not MAYBE]
THEN
RT_OUT_PARAMS:=SND_REJECT_STATUS;
SND_REPLY_TYPE:=REJECT;
st!(SEND_PKT)
END WHEN
END WHEN
- Chart:
- CL_SERVER
- Action:
- EVAL_FACK_BODY
- Description:
- Invoke implementation-specific activity to evaluate fack body
data.
This action reads the fack PDU body data according to the PDU
specification. It is RPC run-time implementation-specific how this data
will be evaluated and used for subsequent fragmented transmissions.
- Definition:
- rd!(PDU_FACK_BODY)
- Chart:
- CL_SERVER
- Action:
- FACK_CALL
- Description:
- Send fack PDU if nofack flag is false or receiver
has buffer full condition.
- Definition:
- SND_OUT_PARAMS:=RT_FACK_BODY;
SND_REPLY_TYPE:=FACK;
st!(SEND_PKT)
- Chart:
- CL_SERVER
- Action:
- FINAL
- Description:
- Perform final actions for RPC.
- Definition:
- WHEN
COMPLETE_CLEAR
THEN
RT_OUT_PARAMS:=NULL
END WHEN;
WHEN
COMPLETE_FREE
THEN
st!(ABORT_CALL)
END WHEN;
WHEN
DENIED
THEN
SND_OUT_PARAMS:=CONST_NCA_S_INVALID_CHKSUM;
SND_REPLY_TYPE:=REJECT;
st!(SEND_PKT)
END WHEN;
WHEN
CB_REJECT
THEN
SND_OUT_PARAMS:=PARAM_CB_STATUS;
SND_REPLY_TYPE:=REJECT;
st!(SEND_PKT)
END WHEN
- Chart:
- CL_SERVER
- Action:
- FIRST_REPLY
- Description:
- Initialise and send first reply PDU.
- Definition:
- fs!(TRANSMIT_RESP);
IF
LAST_OUT_FRAG
THEN
fs!(SND_FRAG);
tr!(SND_LAST_FRAG)
ELSE
tr!(SND_FRAG);
fs!(SND_LAST_FRAG)
END IF;
SND_SEQ_NUM:=RT_SEQ_NUM;
SND_IF_ID:=RT_IF_ID;
SND_IF_VERSION:=RT_IF_VERSION;
SND_OBJ_ID:=RT_OBJ_ID;
SND_OP_NUM:=RT_OP_NUM;
SND_ACTIVITY_ID:=RT_ACTIVITY_ID;
SND_AUTH_SPEC:=RT_AUTH_SPEC;
SND_BOOT_TIME:=RT_BOOT_TIME;
RT_OUT_FRAG:=RT_OUT_PARAMS;
SND_OUT_PARAMS:=RT_OUT_PARAMS;
SND_FRAG_NUM:=0;
SND_REPLY_TYPE:=RESPONSE;
st!(SEND_PKT)
- Chart:
- CL_SERVER
- Action:
- NO_CALL
- Description:
- Set up nocall PDU to be sent.
- Definition:
- SND_OUT_PARAMS:=RT_FACK_BODY;
SND_REPLY_TYPE:=NOCALL;
st!(SEND_PKT)
- Chart:
- CL_SERVER
- Action:
- PING_CALL
- Description:
- Actions in response to a ping PDU call.
- Definition:
- IF
BOOT_TIME_EQ
THEN
IF
in(INIT) or (in(INDICATION) or
in(DATA.AUTHENTICATION)) and
SEQ_NUM_EQ or SEQ_NUM_GT
THEN
NO_CALL
END IF;
IF
in(PROCESS_REQ) and SEQ_NUM_EQ
THEN
SND_REPLY_TYPE:=WORKING;
st!(SEND_PKT)
END IF;
IF
(in(REPLYING) or in(REPLIED)) and
SEQ_NUM_LE
THEN
RESEND_OUT_FRAGS
END IF
ELSE
SND_OUT_PARAMS:=CONST_WRONG_BOOT_TIME;
SND_REPLY_TYPE:=REJECT;
st!(SEND_PKT)
END IF
- Chart:
- CL_SERVER
- Action:
- PROCESS_CAN
- Description:
- Process cancel request (signal manager routine).
- Definition:
- IF
PDU_CANCEL_ID>RT_CANCEL_ID
THEN
RT_CANCEL_ID:=PDU_CANCEL_ID
END IF;
IF
in(DATA) and not in(REPLYING) and not
in(REPLIED)
THEN
st!(CANCEL_NOTIFY_APP)
END IF;
IF
in(REPLYING) or in(REPLIED)
THEN
tr!(SND_PENDING_CANCEL);
CANACK_CALL
END IF
- Chart:
- CL_SERVER
- Action:
- REJECT_CALL
- Description:
- Perform a reject call.
- Definition:
- IF
not BOOT_TIME_EQ
THEN
SND_OUT_PARAMS:=CONST_WRONG_BOOT_TIME
ELSE
SND_OUT_PARAMS:=CONST_UNSPEC_REJECT
END IF;
SND_REPLY_TYPE:=REJECT;
st!(SEND_PKT)
- Chart:
- CL_SERVER
- Action:
- RESEND_OUT_FRAGS
- Description:
- Perform a resend of previously sent response PDUs.
- Definition:
- fs!(TRANSMIT_RESP);
RT_REPLY_COUNT:=RT_REPLY_COUNT+1;
IF
SND_FRAG
THEN
fs!(LAST_OUT_FRAG)
END IF;
st!(RESET_OUT_FRAG)
- Chart:
- CL_SERVER
- Action:
- SETUP_CALL
- Description:
- Set up call data at first call's request PDU.
- Definition:
- RT_CLIENT_EXECUTION_CONTEXT:=NULL;
fs!(CONTEXT_REQUEST);
tr!(NO_FACK);
RT_ACTIVITY_ID:=PDU_ACTIVITY_ID;
RT_SEQ_NUM:=PDU_SEQ_NUM;
RT_IF_ID:=PDU_IF_ID;
RT_IF_VERSION:=PDU_IF_VERSION;
RT_OBJ_ID:=PDU_OBJ_ID;
RT_OP_NUM:=PDU_OP_NUM;
RT_AUTH_SPEC:=PDU_AUTH_SPEC;
IF
PDU_AUTH_SPEC/=0
THEN
RT_AUTH_VERIFIER_CALL:=PDU_AUTH_VERIFIER
tr!(AUTH)
ELSE
fs!(AUTH)
END IF
CL_SERVER Conditions
The CL_SERVER statechart defines the following conditions:
- Chart:
- CL_SERVER
- Condition:
- ACK_PDU
- Description:
- Statechart internal flag: received PDU type ack.
- Chart:
- CL_SERVER
- Condition:
- AUTH
- Description:
- Statechart internal flag: false if PDU auth_id = 0;
true otherwise.
- Chart:
- CL_SERVER
- Condition:
- BOOT_TIME_EQ
- Description:
- Statechart internal flag.
- Definition:
- PDU_BOOT_TIME=SYS_BOOT_TIME or
PDU_BOOT_TIME=0 and (RT_IN_FRAG_NUM=0 or
not PDU_FRAG)
- Chart:
- CL_SERVER
- Condition:
- BROADCAST
- Description:
- Statechart internal flag: broadcast call semantic.
- Chart:
- CL_SERVER
- Condition:
- BURST
- Description:
- Run time internal flag set if no fack is expected before sending
next fragment.
This flag is used by run-time implementations to optimise the frequency
of fragmented outbound packets.
The algorithms used to optimise traffic and avoid congestion
are implementation-specific. The protocol machine (state
RESP_WAIT) waits for inbound fack PDUs if burst mode is off. The next
outbound fragment is triggered by an inbound fack PDU. Implementations
are responsible for setting the corresponding nofack flags in the PDU
header.
- Chart:
- CL_SERVER
- Condition:
- CNTL_PDU
- Description:
- Statechart internal flag: control PDUs to be received.
- Definition:
- PDU_TYPE=ACK or PDU_TYPE=PING or
PDU_TYPE=FACK
- Chart:
- CL_SERVER
- Condition:
- CONTEXT_REQUEST
- Description:
- Stub requests client's execution context for which it has no record.
- Chart:
- CL_SERVER
- Condition:
- FACK_PDU
- Description:
- Statechart internal flag: received PDU type fack.
- Chart:
- CL_SERVER
- Condition:
- IDEMPOTENT
- Description:
- Statechart internal flag: idempotent call.
- Chart:
- CL_SERVER
- Condition:
- LAST_IN_FRAG
- Description:
- Statechart internal flag: last in fragment or non-frag in
packet received.
- Chart:
- CL_SERVER
- Condition:
- LAST_OUT_FRAG
- Description:
- Statechart internal flag: last out fragment or non-frag
out packet ready to send.
This flag is set by the run-time system if the transmit queue contains the
last fragment (see also
Connection-oriented Protocol
).
- Chart:
- CL_SERVER
- Condition:
- LOST
- Description:
- Statechart internal: server boot time = 0 or client's context or
cached sequence number lost.
- Definition:
- (PDU_BOOT_TIME=0 or SEQ_NUM_LOST) and
NON_IDEMPOTENT or AUTH and not
RT_SECURITY_CONTEXT or CONTEXT_REQUEST and
RT_CLIENT_EXECUTION_CONTEXT=NULL
- Chart:
- CL_SERVER
- Condition:
- MAYBE
- Description:
- Statechart internal flag: maybe call.
- Chart:
- CL_SERVER
- Condition:
- NON_IDEMPOTENT
- Description:
- Statechart internal flag: non-idempotent (at-most-once) call.
- Definition:
- not IDEMPOTENT and not BROADCAST and not MAYBE
- Chart:
- CL_SERVER
- Condition:
- NO_FACK
- Description:
- Statechart internal flag: received PDU with nofack flag true.
- Chart:
- CL_SERVER
- Condition:
- OUT_FRAG_NUM_EQ
- Description:
- Statechart internal flag: received fragment number at client and last sent
fragment number are equal.
This condition verifies the fragment number that was received in a
fack PDU. (See
RPC PDU Encodings
for details.)
- Definition:
- SND_FRAG_NUM=PDU_FRAG_NUM
- Chart:
- CL_SERVER
- Condition:
- OUT_FRAG_NUM_NE
- Description:
- Statechart internal flag: received fragment number at client and last
sent fragment number are not equal.
This condition verifies the fragment number that was received in a
fack PDU. (See
RPC PDU Encodings
for details.)
- Definition:
- SND_FRAG_NUM/=PDU_FRAG_NUM
- Chart:
- CL_SERVER
- Condition:
- PDU_BROADCAST
- Description:
- PDU flag broadcast.
- Chart:
- CL_SERVER
- Condition:
- PDU_FRAG
- Description:
- PDU flag frag.
- Chart:
- CL_SERVER
- Condition:
- PDU_IDEMPOTENT
- Description:
- PDU flag idempotent.
- Chart:
- CL_SERVER
- Condition:
- PDU_LAST_FRAG
- Description:
- PDU flag lastfrag.
- Chart:
- CL_SERVER
- Condition:
- PDU_MAYBE
- Description:
- PDU flag maybe.
- Chart:
- CL_SERVER
- Condition:
- PDU_NO_FACK
- Description:
- PDU flag nofack.
- Chart:
- CL_SERVER
- Condition:
- PING_PDU
- Description:
- Statechart internal flag: received PDU type ping.
- Chart:
- CL_SERVER
- Condition:
- RETURN_PENDING_CANCEL
- Description:
- Cancel pending state returned from stub after processing the cancel
request.
- Chart:
- CL_SERVER
- Condition:
- RT_BUF_LIMIT
- Description:
- Statechart internal flag: buffer limit reached for in packets.
The conditional flag RT_BUF_LIMIT triggers the generation of a
fack PDU which requests the sender of data fragments to
readjust the transmission rate.
This is a mechanism to indicate internal buffer limits (overflow) for
avoidance of congestion and retransmissions. Since recipients may
evaluate fack body data in an implementation-dependent way,
implementations must not rely on changes in the transmission rate.
This indication is an advisory.
Run-time implementations are responsible for setting the RT_BUF_LIMIT
flag according to their own policies.
- Chart:
- CL_SERVER
- Condition:
- RT_SECURITY_CONTEXT
- Description:
- Security context associated with call activity UUID is set up and valid.
- Chart:
- CL_SERVER
- Condition:
- SEQ_NUM_EQ
- Description:
- Statechart internal flag: received sequence number equals cached
sequence number.
- Definition:
- PDU_SEQ_NUM=RT_SEQ_NUM
- Chart:
- CL_SERVER
- Condition:
- SEQ_NUM_GT
- Description:
- Statechart internal flag: received sequence number > cached sequence
number.
- Definition:
- PDU_SEQ_NUM>RT_SEQ_NUM
- Chart:
- CL_SERVER
- Condition:
- SEQ_NUM_LE
- Description:
- Statechart internal flag: received sequence number <= cached
sequence number.
- Definition:
- PDU_SEQ_NUM<=RT_SEQ_NUM
- Chart:
- CL_SERVER
- Condition:
- SEQ_NUM_LOST
- Description:
- Statechart internal flag: cached sequence number invalid.
- Definition:
- RT_SEQ_NUM=0
- Chart:
- CL_SERVER
- Condition:
- SND_FRAG
- Description:
- Statechart internal flag: header flag frag of fragments to be sent.
- Chart:
- CL_SERVER
- Condition:
- SND_LAST_FRAG
- Description:
- Statechart internal flag: header flag lastfrag for PDU to be sent.
- Chart:
- CL_SERVER
- Condition:
- SND_PENDING_CANCEL
- Description:
- Cancel pending state for current call at server.
- Chart:
- CL_SERVER
- Condition:
- TICKET_EXP
- Description:
- Statechart internal flag: ticket expired.
- Definition:
- SYS_TIME>GRACE_PERIOD+PDU_EXP_TIME
- Chart:
- CL_SERVER
- Condition:
- TRANSMIT_RESP
- Description:
- One or more fragments queued for transmission of response data.
This flag indicates that one or more response fragments
are queued in a run-time internal buffer and ready to be
transmitted. In conjunction with the BURST flag and possibly
expected fack PDUs, an event for transmitting the next fragment
will be generated.
The run-time system internally sets this flag (true) after the stub initially
provides data in the transmit queue, sufficient for at least the first
PDU fragment to be transmitted. The protocol machine resets this flag
if it has detected and taken an event for sending the next fragment in
the queue.
The run-time system sets this flag again after completion of a SEND_PKT
activity if the transmit queue contains enough data for the next PDU
fragment to be transmitted.
- Chart:
- CL_SERVER
- Condition:
- VALID_PDU_HEADER
- Description:
- Pre-evaluation of PDU header (before authentication processing).
- Definition:
- PDU_ACTIVITY_ID=RT_ACTIVITY_ID and
PDU_AUTH_SPEC=RT_AUTH_SPEC and SEQ_NUM_EQ
and BOOT_TIME_EQ and
PDU_VERSION_NUM=CL_VERSION_NUM_V20
CL_SERVER Data-Items
The CL_SERVER statechart defines the following data items:
- Chart:
- CL_SERVER
- Data Item:
- ACK
- Description:
- Constant: PDU type ack.
- Definition:
- 7
- Chart:
- CL_SERVER
- Data Item:
- CANCEL
- Description:
- Constant: PDU type cancel.
- Definition:
- 8
- Chart:
- CL_SERVER
- Data Item:
- CANCEL_ACK
- Description:
- Constant: PDU cancel_ack.
- Definition:
- 10
- Chart:
- CL_SERVER
- Data Item:
- CL_VERSION_NUM_V20
- Description:
- Constant: RPC protocol version 2.0 version number.
- Definition:
- 4
- Chart:
- CL_SERVER
- Data Item:
- CONST_BAD_ACT_ID
- Description:
- Reject status code for WAY callback. The encoding is specified in
Conversation Manager Interface Definition
.
- Chart:
- CL_SERVER
- Data Item:
- CONST_CANCEL_VERSION
- Description:
- Supported version number for cancel PDU body data.
- Definition:
- 0
- Chart:
- CL_SERVER
- Data Item:
- CONST_NCA_S_INVALID_CHKSUM
- Description:
- Constant: reject status code nca_s_invalid_chksum.
- Chart:
- CL_SERVER
- Data Item:
- CONST_RPC_S_OK
- Description:
- Constant: status code for successful completion of WAY callback.
- Definition:
- 0
- Chart:
- CL_SERVER
- Data Item:
- CONST_UNSPEC_REJECT
- Description:
- Constant: unspecified reject status code (0x1C000009).
- Chart:
- CL_SERVER
- Data Item:
- CONST_WRONG_BOOT_TIME
- Description:
- Reject status code.
- Chart:
- CL_SERVER
- Data Item:
- CONST_YOU_CRASHED
- Description:
- Reject status code for WAY callback. Specified in
Conversation Manager Interface Definition
.
- Chart:
- CL_SERVER
- Data Item:
- FACK
- Description:
- Constant: PDU type fack.
- Definition:
- 9
- Chart:
- CL_SERVER
- Data Item:
- FAULT
- Description:
- Constant: PDU type fault.
- Definition:
- 3
- Chart:
- CL_SERVER
- Data Item:
- GRACE_PERIOD
- Description:
- Grace period on server after ticket expiration (implementation-specific).
- Chart:
- CL_SERVER
- Data Item:
- MAX_REPLIES
- Description:
- Maximum number of times a response PDU should be resent.
- Chart:
- CL_SERVER
- Data Item:
- NOCALL
- Description:
- Constant: PDU type nocall.
- Definition:
- 5
- Chart:
- CL_SERVER
- Data Item:
- PARAM_CB_OUT_DATA
- Description:
- Callback out parameter: the returned authentication response
as array of bytes.
- Chart:
- CL_SERVER
- Data Item:
- PARAM_CB_OUT_LEN
- Description:
- Callback out parameter: length of received PARAM_CB_OUT_DATA field.
- Chart:
- CL_SERVER
- Data Item:
- PARAM_CB_SEQ_NUM
- Description:
- Callback out parameter: sequence number.
- Chart:
- CL_SERVER
- Data Item:
- PARAM_CB_STATUS
- Description:
- Callback out parameter: status.
- Chart:
- CL_SERVER
- Data Item:
- PARAM_CLIENT_EXECUTION_CONTEXT
- Description:
- Callback out parameter: client address space UUID (execution context).
- Chart:
- CL_SERVER
- Data Item:
- PDU_ACTIVITY_ID
- Description:
- PDU header field: act_id.
- Chart:
- CL_SERVER
- Data Item:
- PDU_AUTH_SPEC
- Description:
- PDU header field: auth_proto.
- Chart:
- CL_SERVER
- Data Item:
- PDU_AUTH_VERIFIER
- Description:
- PDU trailer: authentication verifier (authentication protocol-specific).
- Chart:
- CL_SERVER
- Data Item:
- PDU_BODY
- Description:
- Array of PDU body data.
- Chart:
- CL_SERVER
- Data Item:
- PDU_BOOT_TIME
- Description:
- PDU header field: server_boot. Zero at first request from client.
- Chart:
- CL_SERVER
- Data Item:
- PDU_CANCEL_ID
- Description:
- cancel_id of received cancel PDU body data.
- Chart:
- CL_SERVER
- Data Item:
- PDU_CANCEL_VERSION
- Description:
- Version number (vers) of cancel PDUs body data format
(currently supported version 0).
- Chart:
- CL_SERVER
- Data Item:
- PDU_EXP_TIME
- Description:
- Ticket expiration time transmitted in the authentication verifier.
- Chart:
- CL_SERVER
- Data Item:
- PDU_FACK_BODY
- Description:
- Body information of fack PDU (implementation-dependent).
- Chart:
- CL_SERVER
- Data Item:
- PDU_FRAG_NUM
- Description:
- PDU header field: frag_num.
- Chart:
- CL_SERVER
- Data Item:
- PDU_IF_ID
- Description:
- PDU header field: if_id.
- Chart:
- CL_SERVER
- Data Item:
- PDU_IF_VERSION
- Description:
- PDU header field: if_vers.
- Chart:
- CL_SERVER
- Data Item:
- PDU_OBJ_ID
- Description:
- PDU header field: object.
- Chart:
- CL_SERVER
- Data Item:
- PDU_OP_NUM
- Description:
- PDU header field: opnum.
- Chart:
- CL_SERVER
- Data Item:
- PDU_SEQ_NUM
- Description:
- PDU header field: seqnum.
- Chart:
- CL_SERVER
- Data Item:
- PDU_SERIAL_NUM
- Description:
- PDU header field: serial_hi.
- Chart:
- CL_SERVER
- Data Item:
- PDU_TYPE
- Description:
- PDU header field: ptype.
- Chart:
- CL_SERVER
- Data Item:
- PDU_VERSION_NUM
- Description:
- PDU header field: rpc_vers.
- Chart:
- CL_SERVER
- Data Item:
- PING
- Description:
- Constant: PDU type ping.
- Definition:
- 1
- Chart:
- CL_SERVER
- Data Item:
- REJECT
- Description:
- Constant: PDU type reject.
- Definition:
- 6
- Chart:
- CL_SERVER
- Data Item:
- REQUEST
- Description:
- Constant: PDU type request.
- Definition:
- 0
- Chart:
- CL_SERVER
- Data Item:
- RESPONSE
- Description:
- Constant: PDU type response.
- Definition:
- 2
- Chart:
- CL_SERVER
- Data Item:
- RT_ACTIVITY_ID
- Description:
- Statechart internal: activity UUID of current RPC.
- Chart:
- CL_SERVER
- Data Item:
- RT_AUTH_SPEC
- Description:
- Statechart internal: authentication protocol specifier received and
used in call.
- Chart:
- CL_SERVER
- Data Item:
- RT_AUTH_VERIFIER_CALL
- Description:
- Statechart internal: authentication verifier received in CALL state.
- Chart:
- CL_SERVER
- Data Item:
- RT_AUTH_VERIFIER_CAN
- Description:
- Authentication verifier received for cancel PDU.
- Chart:
- CL_SERVER
- Data Item:
- RT_AUTH_VERIFIER_CNTL
- Description:
- Authentication verifier received for control PDU.
- Chart:
- CL_SERVER
- Data Item:
- RT_BODY
- Description:
- Statechart internal: temporarily buffered request PDU body data.
- Chart:
- CL_SERVER
- Data Item:
- RT_BOOT_TIME
- Description:
- Statechart internal: boot time of server system.
- Chart:
- CL_SERVER
- Data Item:
- RT_CANCEL_ID
- Description:
- Statechart internal: identifier for received cancel request with
highest count.
- Chart:
- CL_SERVER
- Data Item:
- RT_CLIENT_EXECUTION_CONTEXT
- Description:
- The UUID uniquely identifying the execution context (address space)
of the client.
- Chart:
- CL_SERVER
- Data Item:
- RT_CONT_IN_FRAG_NUM
- Description:
- Statechart internal: last fragment number of continuously buffered
in block.
- Chart:
- CL_SERVER
- Data Item:
- RT_FACK_BODY
- Description:
- Statechart internal: body data for fack PDU.
The run-time implementation must ensure that fack and
nocall PDU body data is generated in accordance with the
specifications given in
RPC PDU Encodings
.
- Chart:
- CL_SERVER
- Data Item:
- RT_IF_ID
- Description:
- Statechart internal: buffered interface UUID of RPC.
- Chart:
- CL_SERVER
- Data Item:
- RT_IF_VERSION
- Description:
- Statechart internal: buffered interface version of RPC.
- Chart:
- CL_SERVER
- Data Item:
- RT_IN_FRAG_NUM
- Description:
- Statechart internal: fragment number of currently received
request PDU.
- Chart:
- CL_SERVER
- Data Item:
- RT_IN_PARAMS
- Description:
- Statechart internal: buffered array of reassembled input data.
- Chart:
- CL_SERVER
- Data Item:
- RT_IN_SERIAL_NUM
- Description:
- Statechart internal: serial number of previously received fragment.
- Chart:
- CL_SERVER
- Data Item:
- RT_LAST_IN_FRAG_NUM
- Description:
- Fragment number of last in fragment of remote procedure call.
- Chart:
- CL_SERVER
- Data Item:
- RT_OBJ_ID
- Description:
- Statechart internal: buffered object UUID of RPC.
- Chart:
- CL_SERVER
- Data Item:
- RT_OP_NUM
- Description:
- Statechart internal: buffered operation number of RPC.
- Chart:
- CL_SERVER
- Data Item:
- RT_OUT_FRAG
- Description:
- Statechart internal pointer to data to be sent in next response PDU.
The SEND_PKT activity increments this pointer after a
response PDU was sent.
- Chart:
- CL_SERVER
- Data Item:
- RT_OUT_PARAMS
- Description:
- Buffered array of unfragmented output data.
RT_OUT_PARAMS is the queue of transmit data provided by the stub.
A possible segmentation of this queue is not equivalent to the sizes
of PDU fragments sent by the run-time system (SEND_PKT) activity.
The RT_OUT_FRAG variable is a pointer data type that points to the
to be transmitted data fragment within this RT_IN_PARAMS queue.
- Chart:
- CL_SERVER
- Data Item:
- RT_REPLY_COUNT
- Description:
- Counter for transmitted replies.
- Chart:
- CL_SERVER
- Data Item:
- RT_SEQ_NUM
- Description:
- Sequence number of previously received PDU.
- Chart:
- CL_SERVER
- Data Item:
- SND_ACTIVITY_ID
- Description:
- Activity UUID to be sent.
- Chart:
- CL_SERVER
- Data Item:
- SND_AUTH_SPEC
- Description:
- Authentication specifier to be sent.
- Chart:
- CL_SERVER
- Data Item:
- SND_BOOT_TIME
- Description:
- Boot time to be sent.
- Chart:
- CL_SERVER
- Data Item:
- SND_CB_IN_DATA
- Description:
- Callback in parameter: the authentication challenge as an
array of bytes.
- Chart:
- CL_SERVER
- Data Item:
- SND_CB_IN_LEN
- Description:
- Callback in parameter: the length of SND_CB_IN_DATA parameter.
- Chart:
- CL_SERVER
- Data Item:
- SND_CB_OUT_MAX_LEN
- Description:
- Callback in parameter: the maximum length for the out
field PARAM_CB_OUT_DATA.
- Chart:
- CL_SERVER
- Data Item:
- SND_FAULT_STATUS
- Description:
- Fault status associated with the fault PDU body represented as NDR
unsigned long.
- Chart:
- CL_SERVER
- Data Item:
- SND_FRAG_NUM
- Description:
- Fragment number of PDU to be sent.
- Chart:
- CL_SERVER
- Data Item:
- SND_IF_ID
- Description:
- Interface UUID to be sent.
- Chart:
- CL_SERVER
- Data Item:
- SND_IF_VERSION
- Description:
- Interface version number to be sent.
- Chart:
- CL_SERVER
- Data Item:
- SND_OBJ_ID
- Description:
- Object UUID to be sent.
- Chart:
- CL_SERVER
- Data Item:
- SND_OP_NUM
- Description:
- Operation number to be sent.
- Chart:
- CL_SERVER
- Data Item:
- SND_OUT_PARAMS
- Description:
- PDU body data promoted to SEND_PKT activity.
- Chart:
- CL_SERVER
- Data Item:
- SND_REJECT_STATUS
- Description:
- Reject status code associated with reject PDU body represented
as NDR type.
- Chart:
- CL_SERVER
- Data Item:
- SND_REPLY_TYPE
- Description:
- PDU type to be sent.
- Chart:
- CL_SERVER
- Data Item:
- SND_SEQ_NUM
- Description:
- Sequence number of PDU to be sent.
- Chart:
- CL_SERVER
- Data Item:
- SND_SERIAL_NUM
- Description:
- Serial number of PDU to be sent.
- Chart:
- CL_SERVER
- Data Item:
- SYS_BOOT_TIME
- Description:
- Boot time of server system: an implementation-specific value.
- Chart:
- CL_SERVER
- Data Item:
- SYS_TIME
- Description:
- Secure reference time of local system
- Chart:
- CL_SERVER
- Data Item:
- TIMEOUT_IDLE
- Description:
- Timeout value for keeping client's activity record.
- Chart:
- CL_SERVER
- Data Item:
- TIMEOUT_RESEND
- Description:
- Timeout value for retransmitting a response PDU.
- Chart:
- CL_SERVER
- Data Item:
- WORKING
- Description:
- Constant: PDU type working.
- Definition:
- 4
Please note that the html version of this specification
may contain formatting aberrations. The definitive version
is available as an electronic publication on CD-ROM
from The Open Group.