QUIC: retransmit packets with the correct encryption.

net/quic/quic_connection.h

 // 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.
 //
 // The entity that handles framing writes for a Quic client or server.
 // Each QuicSession will have a connection associated with it.
 //
 // On the server side, the Dispatcher handles the raw reads, and hands off
 // packets via ProcessUdpPacket for framing and processing.
 //
@@ skipping 327 matching lines @@
   // not actually writing it to the wire.
   bool ShouldSimulateLostPacket();
 
   // Sets up a packet with an QuicAckFrame and sends it out.
   void SendAck();
 
   // Called when an RTO fires.  Returns the time when this alarm
   // should next fire, or 0 if no retransmission alarm should be set.
   QuicTime OnRetransmissionTimeout();
 
-  // Changes the encrypter used by |framer_| to |encrypter|.  The function
+  // Changes the encrypter used for level |level| to |encrypter|. The function
   // takes ownership of |encrypter|.
-  void ChangeEncrypter(QuicEncrypter* encrypter);
+  void SetEncrypter(EncryptionLevel level, QuicEncrypter* encrypter);
+  const QuicEncrypter* encrypter(EncryptionLevel level) const;
 
-  // Sets the primary decrypter used by |framer_| to |decrypter|.  The current
-  // primary decrypter becomes the backup decrypter.  The function takes
-  // ownership of |decrypter|.
-  //
-  // After the function is called, |framer_| starts to decrypt packets using
-  // |decrypter|.  If the decryption fails, |framer_| falls back on the backup
-  // decrypter.  Eventually |framer_| determines that the backup decrypter is
-  // no longer needed and deletes it.
-  void PushDecrypter(QuicDecrypter* decrypter);
+  // SetDefaultEncryptionLevel sets the encryption level that will be applied
+  // to new packets.
+  void SetDefaultEncryptionLevel(EncryptionLevel level);
 
-  // Deletes the current primary decrypter and promotes the backup decrypter
-  // to be the primary decrypter.
-  void PopDecrypter();
+  // SetDecrypter sets the primary decrypter, replacing any that already exists,
+  // and takes ownership. If an alternative decrypter is in place then the
+  // function DCHECKs. This is intended for cases where one knows that future
+  // packets will be using the new decrypter and the previous decrypter is now
+  // obsolete.
+  void SetDecrypter(QuicDecrypter* decrypter);
 
-  QuicDecrypter* decrypter() const { return framer_.decrypter(); }
-  QuicEncrypter* encrypter() const { return framer_.encrypter(); }
+  // SetAlternativeDecrypter sets a decrypter that may be used to decrypt
+  // future packets and takes ownership of it. If |latch_once_used| is true,
+  // then the first time that the decrypter is successful it will replace the
+  // primary decrypter. Otherwise both decrypters will remain active and the
+  // primary decrypter will be the one last used.
+  void SetAlternativeDecrypter(QuicDecrypter* decrypter,
+                               bool latch_once_used);
+
+  const QuicDecrypter* decrypter() const;
+  const QuicDecrypter* alternative_decrypter() const;
 
  protected:
   // Deletes all missing packets before least unacked. The connection won't
   // process any packets with sequence number before |least_unacked| that it
   // received after this call. Returns true if there were missing packets before
   // |least_unacked| unacked, false otherwise.
   bool DontWaitForPacketsBefore(QuicPacketSequenceNumber least_unacked);
 
-  // Send a packet to the peer. If |sequence_number| is present in the
-  // |retransmission_map_|, then contents of this packet will be retransmitted
-  // with a new sequence number if it's not acked by the peer. Deletes
-  // |packet| via WritePacket call or transfers ownership to QueuedPacket,
-  // ultimately deleted via WritePacket. Also, it updates the entropy map
-  // corresponding to |sequence_number| using |entropy_hash|.
+  // Send a packet to the peer using encryption |level|. If |sequence_number|
+  // is present in the |retransmission_map_|, then contents of this packet will
+  // be retransmitted with a new sequence number if it's not acked by the peer.
+  // Deletes |packet| via WritePacket call or transfers ownership to
+  // QueuedPacket, ultimately deleted via WritePacket. Also, it updates the
+  // entropy map corresponding to |sequence_number| using |entropy_hash|.
   // TODO(wtc): none of the callers check the return value.
-  virtual bool SendOrQueuePacket(QuicPacketSequenceNumber sequence_number,
+  virtual bool SendOrQueuePacket(EncryptionLevel level,
+                                 QuicPacketSequenceNumber sequence_number,
                                  QuicPacket* packet,
                                  QuicPacketEntropyHash entropy_hash,
                                  HasRetransmittableData retransmittable);
 
-  // Writes the given packet to socket with the help of helper. Returns true on
-  // successful write, false otherwise. However, behavior is undefined if
-  // connection is not established or broken. In any circumstances, a return
-  // value of true implies that |packet| has been deleted and should not be
-  // accessed. If |sequence_number| is present in |retransmission_map_| it also
-  // sets up retransmission of the given packet in case of successful write. If
-  // |force| is FORCE, then the packet will be sent immediately and the send
-  // scheduler will not be consulted.
-  bool WritePacket(QuicPacketSequenceNumber sequence_number,
+  // Writes the given packet to socket, encrypted with |level|, with the help
+  // of helper. Returns true on successful write, false otherwise. However,
+  // behavior is undefined if connection is not established or broken. In any
+  // circumstances, a return value of true implies that |packet| has been
+  // deleted and should not be accessed. If |sequence_number| is present in
+  // |retransmission_map_| it also sets up retransmission of the given packet
+  // in case of successful write. If |force| is FORCE, then the packet will be
+  // sent immediately and the send scheduler will not be consulted.
+  bool WritePacket(EncryptionLevel level,
+                   QuicPacketSequenceNumber sequence_number,
                    QuicPacket* packet,
                    HasRetransmittableData retransmittable,
                    Force force);
 
   // Make sure an ack we got from our peer is sane.
   bool ValidateAckFrame(const QuicAckFrame& incoming_ack);
 
   // These two are called by OnAckFrame to update the appropriate internal
   // state.
   //
   // Updates internal state based on incoming_ack.received_info
   void UpdatePacketInformationReceivedByPeer(
       const QuicAckFrame& incoming_ack);
   // Updates internal state based in incoming_ack.sent_info
   void UpdatePacketInformationSentByPeer(const QuicAckFrame& incoming_ack);
 
   QuicConnectionHelperInterface* helper() { return helper_.get(); }
 
  private:
   friend class test::QuicConnectionPeer;
 
   // Packets which have not been written to the wire.
   // Owns the QuicPacket* packet.
   struct QueuedPacket {
     QueuedPacket(QuicPacketSequenceNumber sequence_number,
                  QuicPacket* packet,
+                 EncryptionLevel level,
                  HasRetransmittableData retransmittable)
         : sequence_number(sequence_number),
           packet(packet),
+          encryption_level(level),
           retransmittable(retransmittable) {
     }
 
     QuicPacketSequenceNumber sequence_number;
     QuicPacket* packet;
+    const EncryptionLevel encryption_level;
     HasRetransmittableData retransmittable;
   };
 
   struct RetransmissionInfo {
     explicit RetransmissionInfo(QuicPacketSequenceNumber sequence_number)
         : sequence_number(sequence_number),
           scheduled_time(QuicTime::Zero()),
           number_nacks(0),
           number_retransmissions(0) {
     }
@@ skipping 50 matching lines @@
   void MaybeSendAckInResponseToPacket();
 
   // Get the FEC group associate with the last processed packet.
   QuicFecGroup* GetFecGroup();
 
   // Closes any FEC groups protecting packets before |sequence_number|.
   void CloseFecGroupsBefore(QuicPacketSequenceNumber sequence_number);
 
   scoped_ptr<QuicConnectionHelperInterface> helper_;
   QuicFramer framer_;
+  EncryptionLevel encryption_level_;
   const QuicClock* clock_;
   QuicRandom* random_generator_;
 
   const QuicGuid guid_;
   // Address on the last successfully processed packet received from the
   // client.
   IPEndPoint self_address_;
   IPEndPoint peer_address_;
   // Address on the last(currently being processed) packet received. Not
   // verified/authenticated.
@@ skipping 94 matching lines @@
   bool received_truncated_ack_;
 
   bool send_ack_in_response_to_packet_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicConnection);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_CONNECTION_H_