Sent QUIC "PING" frames when a stream is open and the connection

net/quic/quic_connection.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/quic_connection.h"
 
 #include <string.h>
 #include <sys/types.h>
 #include <algorithm>
 #include <iterator>
@@ skipping 57 matching lines @@
       : connection_(connection) {
   }
 
   virtual QuicTime OnAlarm() OVERRIDE {
     connection_->SendAck();
     return QuicTime::Zero();
   }
 
  private:
   QuicConnection* connection_;
+
+  DISALLOW_COPY_AND_ASSIGN(AckAlarm);
 };
 
 // This alarm will be scheduled any time a data-bearing packet is sent out.
 // When the alarm goes off, the connection checks to see if the oldest packets
 // have been acked, and retransmit them if they have not.
 class RetransmissionAlarm : public QuicAlarm::Delegate {
  public:
   explicit RetransmissionAlarm(QuicConnection* connection)
       : connection_(connection) {
   }
 
   virtual QuicTime OnAlarm() OVERRIDE {
     connection_->OnRetransmissionTimeout();
     return QuicTime::Zero();
   }
 
  private:
   QuicConnection* connection_;
+
+  DISALLOW_COPY_AND_ASSIGN(RetransmissionAlarm);
 };
 
 // An alarm that is scheduled when the sent scheduler requires a
 // a delay before sending packets and fires when the packet may be sent.
 class SendAlarm : public QuicAlarm::Delegate {
  public:
   explicit SendAlarm(QuicConnection* connection)
       : connection_(connection) {
   }
 
   virtual QuicTime OnAlarm() OVERRIDE {
     connection_->WriteIfNotBlocked();
     // Never reschedule the alarm, since CanWrite does that.
     return QuicTime::Zero();
   }
 
  private:
   QuicConnection* connection_;
+
+  DISALLOW_COPY_AND_ASSIGN(SendAlarm);
 };
 
 class TimeoutAlarm : public QuicAlarm::Delegate {
  public:
   explicit TimeoutAlarm(QuicConnection* connection)
       : connection_(connection) {
   }
 
   virtual QuicTime OnAlarm() OVERRIDE {
     connection_->CheckForTimeout();
     // Never reschedule the alarm, since CheckForTimeout does that.
     return QuicTime::Zero();
   }
 
  private:
   QuicConnection* connection_;
+
+  DISALLOW_COPY_AND_ASSIGN(TimeoutAlarm);
+};
+
+class PingAlarm : public QuicAlarm::Delegate {
+ public:
+  explicit PingAlarm(QuicConnection* connection)
+      : connection_(connection) {
+  }
+
+  virtual QuicTime OnAlarm() override {
+    connection_->SendPing();
+    return QuicTime::Zero();
+  }
+
+ private:
+  QuicConnection* connection_;
 };
 
 QuicConnection::PacketType GetPacketType(
     const RetransmittableFrames* retransmittable_frames) {
   if (!retransmittable_frames) {
     return QuicConnection::NORMAL;
   }
   for (size_t i = 0; i < retransmittable_frames->frames().size(); ++i) {
     if (retransmittable_frames->frames()[i].type == CONNECTION_CLOSE_FRAME) {
       return QuicConnection::CONNECTION_CLOSE;
@@ skipping 44 matching lines @@
       received_packet_manager_(
           FLAGS_quic_congestion_control_inter_arrival ? kInterArrival : kTCP,
           &stats_),
       ack_queued_(false),
       stop_waiting_count_(0),
       ack_alarm_(helper->CreateAlarm(new AckAlarm(this))),
       retransmission_alarm_(helper->CreateAlarm(new RetransmissionAlarm(this))),
       send_alarm_(helper->CreateAlarm(new SendAlarm(this))),
       resume_writes_alarm_(helper->CreateAlarm(new SendAlarm(this))),
       timeout_alarm_(helper->CreateAlarm(new TimeoutAlarm(this))),
+      ping_alarm_(helper->CreateAlarm(new PingAlarm(this))),
       debug_visitor_(NULL),
       packet_creator_(connection_id_, &framer_, random_generator_, is_server),
       packet_generator_(this, NULL, &packet_creator_),
       idle_network_timeout_(
           QuicTime::Delta::FromSeconds(kDefaultInitialTimeoutSecs)),
       overall_connection_timeout_(QuicTime::Delta::Infinite()),
       creation_time_(clock_->ApproximateNow()),
       time_of_last_received_packet_(clock_->ApproximateNow()),
       time_of_last_sent_new_packet_(clock_->ApproximateNow()),
       sequence_number_of_last_sent_packet_(0),
@@ skipping 847 matching lines @@
       QueueUndecryptablePacket(packet);
     }
     DVLOG(1) << ENDPOINT << "Unable to process packet.  Last packet processed: "
              << last_header_.packet_sequence_number;
     return;
   }
 
   MaybeProcessUndecryptablePackets();
   MaybeProcessRevivedPacket();
   MaybeSendInResponseToPacket();
+  SetPingAlarm();
 }
 
 void QuicConnection::OnCanWrite() {
   DCHECK(!writer_->IsWriteBlocked());
 
   WriteQueuedPackets();
   WritePendingRetransmissions();
 
   IsHandshake pending_handshake = visitor_->HasPendingHandshake() ?
       IS_HANDSHAKE : NOT_HANDSHAKE;
@@ skipping 329 matching lines @@
     DVLOG(1) << "Write failed with error code: " << result.error_code;
     // We can't send an error as the socket is presumably borked.
     CloseConnection(QUIC_PACKET_WRITE_ERROR, false);
     return false;
   }
 
   QuicTime now = clock_->Now();
   if (transmission_type == NOT_RETRANSMISSION) {
     time_of_last_sent_new_packet_ = now;
   }
+  SetPingAlarm();
   DVLOG(1) << ENDPOINT << "time of last sent packet: "
            << now.ToDebuggingValue();
 
   // TODO(ianswett): Change the sequence number length and other packet creator
   // options by a more explicit API than setting a struct value directly.
   packet_creator_.UpdateSequenceNumberLength(
       received_packet_manager_.least_packet_awaited_by_peer(),
       sent_packet_manager_.GetCongestionWindow());
 
   bool reset_retransmission_alarm =
@@ skipping 55 matching lines @@
   queued_packets_.push_back(queued_packet);
   return false;
 }
 
 void QuicConnection::UpdateStopWaiting(QuicStopWaitingFrame* stop_waiting) {
   stop_waiting->least_unacked = GetLeastUnacked();
   stop_waiting->entropy_hash = sent_entropy_manager_.EntropyHash(
       stop_waiting->least_unacked - 1);
 }
 
+void QuicConnection::SendPing() {

[jar (doing other things), 2014/04/19 16:54:15]

Per offline discussion... Please add an early return here if there is a
retransmission alarm set.  

Retransmission alarms are usually much shorter than a ping alarm duration, but I
wanted to be sure that some exponetial backoff of retransmits (perhaps even
retransmits of a ping!?!) doesn't open the door for more pings to be sent. 

[Ryan Hamilton, 2014/04/19 19:18:48]

Done.

+  if (version() <= QUIC_VERSION_17) {
+    // TODO(rch): remove this when we remove version 17.
+    // This is a horrible hideous hack which we should not support.
+    IOVector data;
+    char c_data[] = "C";
+    data.Append(c_data, 1);
+    QuicConsumedData consumed_data =
+        packet_generator_.ConsumeData(kCryptoStreamId, data, 0, false, NULL);
+    if (consumed_data.bytes_consumed == 0) {
+      DLOG(ERROR) << "Unable to send ping!?";
+    }
+  } else {
+    // TODO(rch): enable this when we merge version 18.
+    // packet_generator_.AddControlFrame(QuicFrame(new QuicPingFrame));
+  }
+}
+
 void QuicConnection::SendAck() {
   ack_alarm_->Cancel();
   stop_waiting_count_ = 0;
   // TODO(rch): delay this until the CreateFeedbackFrame
   // method is invoked.  This requires changes SetShouldSendAck
   // to be a no-arg method, and re-jiggering its implementation.
   bool send_feedback = false;
   if (received_packet_manager_.GenerateCongestionFeedback(
           &outgoing_congestion_feedback_)) {
     DVLOG(1) << ENDPOINT << "Sending feedback: "
@@ skipping 300 matching lines @@
     if (connection_timeout < timeout) {
       timeout = connection_timeout;
     }
   }
 
   timeout_alarm_->Cancel();
   timeout_alarm_->Set(clock_->ApproximateNow().Add(timeout));
   return false;
 }
 
+void QuicConnection::SetPingAlarm() {
+  if (is_server_) {
+    // Only clients send pings.
+    return;
+  }
+  ping_alarm_->Cancel();
+  if (!visitor_->HasOpenStreams()) {
+    // Don't send a ping unless there are open streams.
+    return;
+  }
+  QuicTime::Delta ping_timeout = idle_network_timeout_.Multiply(0.5);

[jar (doing other things), 2014/04/19 16:35:43]

This trick (50% of idle timeout) is perchance OK for now... but it really should
be a separate number.

I anticipate having an idle_network_timeout_ of closer to 5 minutes.  We only
set it to 30 seconds *because* we had no ping, and the NAT will likely rebind
:-(.  Now that we have even this ghetto ping, the idle_network_timeout_ should
be independent.

I'd suggest a new value, such as ping_timeout_.  Today (in the ghetto) it should
probably default to a constant 15 seconds, but it should probably be negotiable
in the future.

If you don't want to mess with this further, could you put a TODO in at the
point you give up?  For instance, if you want to leave it as as... drop the TODO
here.

[Ryan Hamilton, 2014/04/19 19:18:48]

Done. Added a new constant for this.

+  ping_alarm_->Set(clock_->ApproximateNow().Add(ping_timeout));
+}
+
 QuicConnection::ScopedPacketBundler::ScopedPacketBundler(
     QuicConnection* connection,
     AckBundling send_ack)
     : connection_(connection),
       already_in_batch_mode_(connection->packet_generator_.InBatchMode()) {
   // Move generator into batch mode. If caller wants us to include an ack,
   // check the delayed-ack timer to see if there's ack info to be sent.
   if (!already_in_batch_mode_) {
     DVLOG(1) << "Entering Batch Mode.";
     connection_->packet_generator_.StartBatchOperations();
@@ skipping 12 matching lines @@
   // If we changed the generator's batch state, restore original batch state.
   if (!already_in_batch_mode_) {
     DVLOG(1) << "Leaving Batch Mode.";
     connection_->packet_generator_.FinishBatchOperations();
   }
   DCHECK_EQ(already_in_batch_mode_,
             connection_->packet_generator_.InBatchMode());
 }
 
 }  // namespace net