
  PROCEDURE [INLINE] dfp$queue_client_task_request
    (    p_queue_interface_table: dft$p_queue_interface_table;
         queue_index: dft$queue_index;
         queue_entry_index: dft$queue_entry_index;
     VAR status: ost$status);

*copyc dfc$queue_request_constants

    VAR
      maximum_request_count: integer,
      message: string (40),
      new_out: integer,
      old_out: integer,
      queue_request_status: dft$queue_request_status,
      request_buffer_entry: dft$request_buffer_entry,
      request_buffer_queue_index: 0 .. 0FF(16),
      retry_count: integer;

{ Attempt to queue the request.  If it is queued, OK.  If it is not queued, keep trying until:
{   . it is queued
{   . request buffer full status has been seen too many times
{   . any other unexpected status
{ If it cannot be queued because of server terminated, set terminated status and return.
{ If it cannot be queued because of request buffer full, set timeout status and then
{   . if the blocking request buffer entry belongs to the same queue as the executor of this code, return to
{     process the timeout status.
{   . if the blocking request buffer entry belongs to some other queue, wait a bit for the timeout to process,
{     and then attempt to queue the request again.

    maximum_request_count := dfv$task_queue_timeout_interval DIV dfc$request_delay;

  /queue_request/
    WHILE TRUE DO { attempt to queue the request
      old_out := -1;
      status.normal := TRUE;

      REPEAT
        osp$begin_system_activity;
        dfp$queue_request (p_queue_interface_table, queue_index, queue_entry_index, queue_request_status);
        osp$end_system_activity;
        IF queue_request_status = dfc$qrs_request_buffer_full THEN
          new_out := dfp$current_rq_buffer_out_index (p_queue_interface_table);
          IF new_out = old_out THEN
            retry_count := retry_count + 1;
          ELSE
            retry_count := 0;
            old_out := new_out;
          IFEND;
          syp$wait (dfc$request_delay);
        IFEND;
      UNTIL (queue_request_status <> dfc$qrs_request_buffer_full) OR (retry_count > maximum_request_count);

      IF queue_request_status = dfc$qrs_entry_queued THEN
        RETURN;
      IFEND;

      IF queue_request_status = dfc$qrs_server_terminated THEN
        dfp$set_terminated_status (p_queue_interface_table, queue_index, status);
        RETURN;
      ELSEIF (queue_request_status = dfc$qrs_request_buffer_full) AND
            (retry_count > maximum_request_count) THEN
        dfp$get_current_rq_buffer_entry (p_queue_interface_table, old_out, request_buffer_entry);

{  If queue_index is 0, request buffer entry has been freed since we last looked.

        request_buffer_queue_index := request_buffer_entry.queue_index;
        IF request_buffer_queue_index = 0 THEN
          CYCLE /queue_request/;
        IFEND;

        IF dfv$file_server_debug_enabled THEN
          message := ' DF- Partner mainframe ';
          message (24, *) := p_queue_interface_table^.queue_directory.cpu_queue_pva_directory
                [request_buffer_queue_index].p_cpu_queue^.queue_header.destination_mainframe_name;
          display_to_console (message);
          log_display ($pmt$ascii_logset [pmc$system_log, pmc$job_log], message);
          display_integer_to_console (' DF- Timing out queue, QI = ', request_buffer_queue_index);
          log_display_integer ($pmt$ascii_logset [pmc$system_log, pmc$job_log],
               ' DF- Timing out queue, QI = ', request_buffer_queue_index);
        IFEND;
        dfp$set_queue_timed_out (p_queue_interface_table, request_buffer_queue_index, status);
        IF queue_index = request_buffer_queue_index THEN
          RETURN; { to process own timeout }
        IFEND;
      ELSE
        log_display_integer ($pmt$ascii_logset [pmc$system_log, pmc$job_log],
             ' DF- Unexpected queue request status: ', $integer (queue_request_status));
        log_display_integer ($pmt$ascii_logset [pmc$system_log, pmc$job_log],
             '     Queue index: ', $integer (queue_index));
        osp$system_error (' UNEXPECTED QUEUE REQUEST STATUS ', NIL);
      IFEND;
      IF dfv$file_server_debug_enabled THEN
        display_to_console (' DF- Queue_Client_Task_Request:');
        display_integer_to_console (' DF- Waiting for request_buffer entry timeout, QI = ',
              request_buffer_queue_index);
      IFEND;
      log_display ($pmt$ascii_logset [pmc$system_log, pmc$job_log],
           ' DF- Queue_Client_Task_Request: ');
      log_display_integer ($pmt$ascii_logset [pmc$system_log, pmc$job_log],
           ' DF- Waiting for request_buffer entry timeout, QI = ', request_buffer_queue_index);
      syp$wait (dfc$timeout_delay);
    WHILEND /queue_request/;

  PROCEND dfp$queue_client_task_request;
?? PUSH (LISTEXT := ON) ??
*copyc dfd$driver_queue_types
*copyc dfe$error_condition_codes
*copyc dfi$console_display
*copyc dfi$log_display
*copyc dfp$current_rq_buffer_out_index
*copyc dfp$get_current_rq_buffer_entry
*copyc dfp$queue_request
*copyc dfp$set_queue_timed_out
*copyc dfp$set_terminated_status
*copyc dft$request_buffer
*copyc dfv$file_server_debug_enabled
*copyc dfv$task_queue_timeout_interval
*copyc osp$begin_system_activity
*copyc osp$end_system_activity
*copyc osp$set_status_abnormal
*copyc osp$system_error
*copyc syp$wait
?? POP ??
