{
{    The purpose of this request is to send data to a peer application over an
{  established CDNA Session connection.
{
{    Data transmitted over a connection is structured into messages.  Message
{  boundaries are specified by the sender and communicated to the receiver.
{
{    There are two operations involved in the transfer of data between peer
{  applications.  The sending application performs a send data operation to
{  transfer data into the connection.  The receiving application performs a
{  receive data operation to transfer data out of the connection.
{
{    The network holds a certain amount of data within a connection to smooth
{  out the interaction between a sender and a receiver.  However, the amount of
{  data which may be held within a connection is dependent on availability of
{  resources.  Thus the rate at which an application may send data is
{  ultimately limited by the rate at which the peer application receives data.
{
{    This request initiates a send data operation, which transfers data from
{  the application's buffer into the connection.  The transfer of data into the
{  connection is regulated by the capacity of the network to accept data.  The
{  send data operation completes when all of the data has been transferred into
{  the connection.
{
{    As data is transferred into the connection, it is fragmented into partial
{  messages if the amount of data to be transferred exceeds the current network
{  capacity.  The minimum size for a partial message generated in this manner is
{  defined by the constant nac$se_min_fragment_size (in units of bytes).  The
{  fact that such fragmentation occurs may be significant if the peer
{  (receiving) application is informed of partial message boundaries established
{  when a message is sent.
{
{    The following applies if the peer application is a CDCNET application:
{  The CDCNET application will have a message size limitation of 8468 bytes.
{  If the block to be sent down is larger, then it must be fragmented into
{  a message size less than 8468 bytes.  Otherwise, CDCNET will end the
{  connection.
{
{    The following applies if the peer application is not a CDCNET application:
{  Since the send data operation fragments and transfers data into a
{  connection as the capacity of the network to accept data allows, arbitrarily
{  large messages may be sent over a connection.  There is no need for an
{  application to fragment a large message into a series of partial messages,
{  each of which is small enough to be held entirely within a connection at some
{  instant in time, and send the partial messages individually.
{
{    However, an application may choose to send partial messages.  For instance,
{  sending partial messages might be desirable in cases where it is inconvenient
{  to compose the entire message in memory at one time.
{
{    NOTE: If the peer application is a NOS/VE network application, then it is
{  NOT informed of partial message boundaries established when a message is
{  sent (i.e. transferred into the connection).  This is true whether the
{  partial message boundaries are established by the application itself or by
{  the send data operation.
{
{    Each send data operation directly results in transmission of one or more
{  network blocks.  Data from partial messages transferred by separate send data
{  operations is not concatenated to optimize network utilization; i.e., to form
{  "full" network blocks.  The optimum_transfer_unit_size and
{  optimum_transfer_unit_incr connection attributes should be examined to
{  determine the amount of data that should be transferred by each send data
{  operation in order to optimize network block usage.
{
{    The calling task specifies whether it is to be suspended until the send
{  data operation is complete or execute concurrently with the data transfer.
{  If the data transfer is to occur concurrently with task execution, the data
{  must be left intact in the application's buffer until the transfer is
{  complete.
{
{    At any given time, only one send data operation may be active for a
{  connection.  A request to initiate a send data operation while one is already
{  in progress results in abnormal status with the condition
{  nae$send_outstanding if the calling task is to execute concurrently with the
{  data transfer.  However, if the calling task is to be suspended, the request
{  waits for the condition to clear and then initiates the send data operation.
{  In this case, the data transfer timeout includes the interval while the
{  request is waiting to initiate the operation.
{
{    If the file is closed while a concurrent send data operation is
{  outstanding, the operation is cancelled (but the ACTIVITY_STATUS parameter is
{  not updated).  This leaves the connection in an indeterminate state, since
{  the amount of data transferred into the connection is unknown.  The
{  connection should be synchronized before further usage.
{
{    Note that the STATUS parameter indicates the status of the request to
{  initiate the send data operation, while the ACTIVITY_STATUS parameter
{  indicates the status of the send data operation itself.  The caller must
{  examine both parameters to determine if the requested operation has been
{  successfully performed.
{
{        NAP$SE_SEND_DATA (FILE_IDENTIFIER, DATA, END_OF_MESSAGE,
{          QUALIFIED_DATA, WAIT, ACTIVITY_STATUS, STATUS)
{
{  FILE_IDENTIFIER: (input) This parameter specifies the file access identifier
{        established when the network file was opened.
{
{  DATA: (input) This parameter specifies a list of address/length pairs
{        defining the data to be sent.
{
{  END_OF_MESSAGE: (input) This parameter specifies whether the data being sent
{        completes a message.  If TRUE, the specified data is either a complete
{        message or a partial message which completes a message, depending on
{        whether the preceding data sent over the connection completed a
{        message.  If FALSE, the specified data is a partial message and the
{        remainder of the message is to be transferred by subsequent send data
{        operations.
{
{  QUALIFIED_DATA: (input) This parameter specifies whether the data being sent
{        is considered to be "qualified" by the sending application.  The
{        meaning of qualified (vs. unqualified) data must be agreed upon by
{        the peer applications.
{
{        The NAM performs no action dependent on this parameter -- other than
{        to verify that the same value is supplied for all data comprising a
{        message.  In general, this parameter may be considered as an another
{        bit of information (in addition to the information specified by the
{        DATA parameter) which is carried transparently over the connection.
{
{  WAIT: (input) This parameter specifies the action to be taken while waiting
{        for the send data operation to complete.  The permitted values and the
{        corresponding actions are:
{
{          osc$wait: The calling task is suspended until the send data
{            operation is complete.
{
{          osc$nowait: The calling task executes concurrently with the send
{            data operation.  The osp$await_activity_complete request may be
{            used to wait for the data transfer to complete.
{
{            The lifetime of the variable specified by the ACTIVITY_STATUS
{            parameter and the lifetime of the data specified by the DATA
{            parameter must exceed the duration of the interval until the send
{            data operation completes.
{
{            If another send data operation is outstanding on the same
{            connection, the request will return abnormal status with the
{            condition nae$send_outstanding.
{
{  ACTIVITY_STATUS: (output) This parameter specifies the status of the send
{        data operation.  The specified variable has the following fields:
{
{          complete: A boolean value which specifies whether the operation is
{            complete.
{
{          status: A status value which specifies the completion status of the
{            operation.  This value is not meaningful unless the operation is
{            complete.
{            CONDITIONS:
{                  nae$connection_terminated
{                  nae$data_transfer_timeout
{
{  STATUS: (output) This parameter specifies the request status.
{        CONDITIONS:
{              ame$improper_device_class
{              ame$improper_file_id
{              ame$ring_validation_error
{              nae$connection_terminated
{              nae$data_transfer_timeout
{              nae$improper_protocol
{              nae$inconsistent_qualified_data
{              nae$se_synchronize_in_progress
{              nae$send_outstanding
{              {other BAM conditions}
{
