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
bgcolor="#FFFFFF" 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 bgcolor="#FFFFFF" 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 bgcolor="#FFFFFF"
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 bgcolor="#FFFFFF" data.
This action reads the fack PDU body bgcolor="#FFFFFF"
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 bgcolor="#FFFFFF"
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 bgcolor="#FFFFFF" 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
bgcolor="#FFFFFF" 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
bgcolor="#FFFFFF".
- 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 bgcolor="#FFFFFF".
- 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 bgcolor="#FFFFFF" 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 bgcolor="#FFFFFF"
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 bgcolor="#FFFFFF" 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
):
- 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.
Note that bind requests are used for negotiating the security
context. Therefore, the protection level will not be verified for these
PDUs; this verification takes only place for actual call PDUs.
- 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
bgcolor="#FFFFFF" data.
- 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 bgcolor="#FFFFFF" 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 bgcolor="#FFFFFF"
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 bgcolor="#FFFFFF" data.
This action reads the fack PDU body bgcolor="#FFFFFF"
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 bgcolor="#FFFFFF" 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 bgcolor="#FFFFFF"
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 bgcolor="#FFFFFF" 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 bgcolor="#FFFFFF"
data.
- Chart:
- CL_SERVER
- Data Item:
- PDU_CANCEL_VERSION
- Description:
- Version number (vers) of cancel PDUs body bgcolor="#FFFFFF"
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 bgcolor="#FFFFFF" 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 bgcolor="#FFFFFF"
data for fack PDU.
The run-time implementation must ensure that fack and
nocall PDU body bgcolor="#FFFFFF" 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 bgcolor="#FFFFFF"
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 bgcolor="#FFFFFF" data promoted to
SEND_PKT activity.
- Chart:
- CL_SERVER
- Data Item:
- SND_REJECT_STATUS
- Description:
- Reject status code associated with reject PDU
body bgcolor="#FFFFFF" 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.