{
{      The purpose of this request is to send a message (or part of a
{ message) across the logical connection.  The access method is only
{ capable of processing one send data request at a time.  If a send data
{ request is issued while another send data request is still being
{ processed, the following actions are performed:
{
{    1)   If the new request is synchronous (wait=osc$wait), the
{         new request is queued and processed after the pending send
{         data request is completed.
{
{    2)   If the new request is asynchronous (wait=osc$no_wait), the
{         request is rejected and a status of 'rfe$send_data_active'
{         is returned.
{
{      The access method attempts to send all the data, in the format
{ specified by the requester, across the connection.
{
{      The BLOCK_SIZE (message or record), TRANSFER_DELAY_TIME,
{ SEND_RECORD_TERMINATOR, and the OUTGOING_RECORD_ABN
{ file attributes provide external information for the send data request.
{ These attributes are further defined in the file attributes sub-section
{ of the BAM request section.
{
{      The send and receive data header section provides further
{ information on the actions performed by this request.
{
{ RFP$SEND_DATA(CONNECTION_IDENTIFIER, TRANSMISSION_MODE, DATA,
{   END_OF_MESSAGE, WAIT, ACTIVITY, DATA_SENT, STATUS)
{
{ CONNECTION_IDENTIFIER: (input) This parameter specifies an identifier
{   of an open connection file to send data on.
{
{ TRANSMISSION_MODE: (input) This parameter specifies the transmission
{   mode to be used for packaging the data (message mode or
{   record mode).  In general the message mode is a low volume
{   transmission mode for short non-contiguous data and the record
{   mode is a high volume transmission mode for large contiguous data.
{   Further information on the transmission modes is provided in the
{   general send and receive data section.
{
{ DATA: (input) This parameter specifies an adaptable array
{   of corresponding data buffers and data lengths (in 8-bit bytes).
{   The access method will pack the data into blocks starting with
{   the data in the first buffer on the list.
{
{ END_OF_MESSAGE: (input) This parameter specifies that the data
{   being sent comprises a complete message.
{
{ WAIT: (input)  This parameter specifies whether to suspend the
{   application until all data has been sent.  If osc$wait, the access
{   method will suspend the application until the transfer has been
{   completed.  If osc$nowait, control is returned to the application
{   after the first block has been queued to be sent across the
{   connection.
{
{ ACTIVITY: (output) This parameter contains two fields
{   which return the results of the send data request.
{
{      1)  complete:  This field is set to TRUE when the
{          request has been completed.  If FALSE, the status field
{          and the DATA_SENT parameter are not meaningful.
{
{      2)  status:  This field specifies whether all requested data
{          has been successfully sent by the access method.  If the
{          status is normal, all data has been successfully sent.
{          CONDITIONS:  rfe$async_req_terminated
{                       rfe$connection_terminated
{                       rfe$local_nad_failure
{                       rfe$transfer_timeout
{                       rfe$system_interrupt
{                       rfe$system_task_shutdown
{                       rfe$unable_to_send_all_data
{          IDENTIFIER:  'RF'
{
{ DATA_SENT: (output) This parameter returns the actual amount of
{   data (in 8-bit bytes) that was sent.  This parameter can be used
{   to aid recovery if an unexpected error was encountered while the
{   data was being transferred.  This parameter is also useful for
{   record mode transfers when all of the data could not be
{   transferred, because the END_OF_MESSAGE parameter was FALSE, and
{   the total DATA length was not a multiple of the RECORD_BLOCK_SIZE.
{
{ STATUS: (output) This parameter returns the results of the request.
{   A status of normal means the caller is validated to send data on
{   this connection.
{   CONDITIONS:  ame$improper_file_id
{                rfe$connect_in_progress
{                rfe$connection_not_active
{                rfe$connection_rejected
{                rfe$connection_terminated
{                rfe$invalid_data_fragment
{                rfe$local_nad_failure
{                rfe$receive_data_active
{                rfe$send_data_active
{                rfe$switch_accepted
{                rfe$switch_offered
{                rfe$system_interrupt
{                rfe$system_task_shutdown
{                rfe$transfer_timeout
{   IDENTIFIER:  'RF'
{
