1// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4// 5// Responsible for generating packets on behalf of a QuicConnection. 6// Packets are serialized just-in-time. Control frames are queued. 7// Ack and Feedback frames will be requested from the Connection 8// just-in-time. When a packet needs to be sent, the Generator 9// will serialize a packet and pass it to QuicConnection::SendOrQueuePacket() 10// 11// The Generator's mode of operation is controlled by two conditions: 12// 13// 1) Is the Delegate writable? 14// 15// If the Delegate is not writable, then no operations will cause 16// a packet to be serialized. In particular: 17// * SetShouldSendAck will simply record that an ack is to be sent. 18// * AddControlFrame will enqueue the control frame. 19// * ConsumeData will do nothing. 20// 21// If the Delegate is writable, then the behavior depends on the second 22// condition: 23// 24// 2) Is the Generator in batch mode? 25// 26// If the Generator is NOT in batch mode, then each call to a write 27// operation will serialize one or more packets. The contents will 28// include any previous queued frames. If an ack should be sent 29// but has not been sent, then the Delegate will be asked to create 30// an Ack frame which will then be included in the packet. When 31// the write call completes, the current packet will be serialized 32// and sent to the Delegate, even if it is not full. 33// 34// If the Generator is in batch mode, then each write operation will 35// add data to the "current" packet. When the current packet becomes 36// full, it will be serialized and sent to the packet. When batch 37// mode is ended via |FinishBatchOperations|, the current packet 38// will be serialzied, even if it is not full. 39// 40// FEC behavior also depends on batch mode. In batch mode, FEC packets 41// will be sent after |max_packets_per_group| have been sent, as well 42// as after batch operations are complete. When not in batch mode, 43// an FEC packet will be sent after each write call completes. 44// 45// TODO(rch): This behavior should probably be tuned. When not in batch 46// mode, we should probably set a timer so that several independent 47// operations can be grouped into the same FEC group. 48// 49// When an FEC packet is generated, it will be send to the Delegate, 50// even if the Delegate has become unwritable after handling the 51// data packet immediately proceeding the FEC packet. 52 53#ifndef NET_QUIC_QUIC_PACKET_GENERATOR_H_ 54#define NET_QUIC_QUIC_PACKET_GENERATOR_H_ 55 56#include "net/quic/quic_packet_creator.h" 57#include "net/quic/quic_types.h" 58 59namespace net { 60 61namespace test { 62class QuicPacketGeneratorPeer; 63} // namespace test 64 65class QuicAckNotifier; 66 67class NET_EXPORT_PRIVATE QuicPacketGenerator { 68 public: 69 class NET_EXPORT_PRIVATE DelegateInterface { 70 public: 71 virtual ~DelegateInterface() {} 72 virtual bool ShouldGeneratePacket(TransmissionType transmission_type, 73 HasRetransmittableData retransmittable, 74 IsHandshake handshake) = 0; 75 virtual QuicAckFrame* CreateAckFrame() = 0; 76 virtual QuicCongestionFeedbackFrame* CreateFeedbackFrame() = 0; 77 virtual QuicStopWaitingFrame* CreateStopWaitingFrame() = 0; 78 // Takes ownership of |packet.packet| and |packet.retransmittable_frames|. 79 virtual bool OnSerializedPacket(const SerializedPacket& packet) = 0; 80 virtual void CloseConnection(QuicErrorCode error, bool from_peer) = 0; 81 }; 82 83 // Interface which gets callbacks from the QuicPacketGenerator at interesting 84 // points. Implementations must not mutate the state of the generator 85 // as a result of these callbacks. 86 class NET_EXPORT_PRIVATE DebugDelegate { 87 public: 88 virtual ~DebugDelegate() {} 89 90 // Called when a frame has been added to the current packet. 91 virtual void OnFrameAddedToPacket(const QuicFrame& frame) {} 92 }; 93 94 QuicPacketGenerator(QuicConnectionId connection_id, 95 QuicFramer* framer, 96 QuicRandom* random_generator, 97 DelegateInterface* delegate); 98 99 virtual ~QuicPacketGenerator(); 100 101 // Indicates that an ACK frame should be sent. If |also_send_feedback| is 102 // true, then it also indicates a CONGESTION_FEEDBACK frame should be sent. 103 // If |also_send_stop_waiting| is true, then it also indicates that a 104 // STOP_WAITING frame should be sent as well. 105 // The contents of the frame(s) will be generated via a call to the delegates 106 // CreateAckFrame() and CreateFeedbackFrame() when the packet is serialized. 107 void SetShouldSendAck(bool also_send_feedback, 108 bool also_send_stop_waiting); 109 110 // Indicates that a STOP_WAITING frame should be sent. 111 void SetShouldSendStopWaiting(); 112 113 void AddControlFrame(const QuicFrame& frame); 114 115 // Given some data, may consume part or all of it and pass it to the 116 // packet creator to be serialized into packets. If not in batch 117 // mode, these packets will also be sent during this call. Also 118 // attaches a QuicAckNotifier to any created stream frames, which 119 // will be called once the frame is ACKed by the peer. The 120 // QuicAckNotifier is owned by the QuicConnection. |notifier| may 121 // be NULL. 122 QuicConsumedData ConsumeData(QuicStreamId id, 123 const IOVector& data, 124 QuicStreamOffset offset, 125 bool fin, 126 FecProtection fec_protection, 127 QuicAckNotifier* notifier); 128 129 // Indicates whether batch mode is currently enabled. 130 bool InBatchMode(); 131 // Disables flushing. 132 void StartBatchOperations(); 133 // Enables flushing and flushes queued data which can be sent. 134 void FinishBatchOperations(); 135 136 // Flushes all queued frames, even frames which are not sendable. 137 void FlushAllQueuedFrames(); 138 139 bool HasQueuedFrames() const; 140 141 // Makes the framer not serialize the protocol version in sent packets. 142 void StopSendingVersion(); 143 144 // Creates a version negotiation packet which supports |supported_versions|. 145 // Caller owns the created packet. Also, sets the entropy hash of the 146 // serialized packet to a random bool and returns that value as a member of 147 // SerializedPacket. 148 QuicEncryptedPacket* SerializeVersionNegotiationPacket( 149 const QuicVersionVector& supported_versions); 150 151 152 // Re-serializes frames with the original packet's sequence number length. 153 // Used for retransmitting packets to ensure they aren't too long. 154 // Caller must ensure that any open FEC group is closed before calling this 155 // method. 156 SerializedPacket ReserializeAllFrames( 157 const QuicFrames& frames, 158 QuicSequenceNumberLength original_length); 159 160 // Update the sequence number length to use in future packets as soon as it 161 // can be safely changed. 162 void UpdateSequenceNumberLength( 163 QuicPacketSequenceNumber least_packet_awaited_by_peer, 164 QuicByteCount congestion_window); 165 166 // Sets the encryption level that will be applied to new packets. 167 void set_encryption_level(EncryptionLevel level); 168 169 // Sequence number of the last created packet, or 0 if no packets have been 170 // created. 171 QuicPacketSequenceNumber sequence_number() const; 172 173 size_t max_packet_length() const; 174 175 void set_max_packet_length(size_t length); 176 177 void set_debug_delegate(DebugDelegate* debug_delegate) { 178 debug_delegate_ = debug_delegate; 179 } 180 181 private: 182 friend class test::QuicPacketGeneratorPeer; 183 184 // Turn on FEC protection for subsequent packets in the generator. 185 // If no FEC group is currently open in the creator, this method flushes any 186 // queued frames in the generator and in the creator, and it then turns FEC on 187 // in the creator. This method may be called with an open FEC group in the 188 // creator, in which case, only the generator's state is altered. 189 void MaybeStartFecProtection(); 190 191 // Serializes and calls the delegate on an FEC packet if one was under 192 // construction in the creator. When |force| is false, it relies on the 193 // creator being ready to send an FEC packet, otherwise FEC packet is sent 194 // as long as one is under construction in the creator. Also tries to turns 195 // off FEC protection in the creator if it's off in the generator. 196 void MaybeSendFecPacketAndCloseGroup(bool force); 197 198 void SendQueuedFrames(bool flush); 199 200 // Test to see if we have pending ack, feedback, or control frames. 201 bool HasPendingFrames() const; 202 // Test to see if the addition of a pending frame (which might be 203 // retransmittable) would still allow the resulting packet to be sent now. 204 bool CanSendWithNextPendingFrameAddition() const; 205 // Add exactly one pending frame, preferring ack over feedback over control 206 // frames. 207 bool AddNextPendingFrame(); 208 209 bool AddFrame(const QuicFrame& frame); 210 211 void SerializeAndSendPacket(); 212 213 DelegateInterface* delegate_; 214 DebugDelegate* debug_delegate_; 215 216 QuicPacketCreator packet_creator_; 217 QuicFrames queued_control_frames_; 218 219 // True if batch mode is currently enabled. 220 bool batch_mode_; 221 222 // True if FEC protection is on. The creator may have an open FEC group even 223 // if this variable is false. 224 bool should_fec_protect_; 225 226 // Flags to indicate the need for just-in-time construction of a frame. 227 bool should_send_ack_; 228 bool should_send_feedback_; 229 bool should_send_stop_waiting_; 230 // If we put a non-retransmittable frame (namley ack or feedback frame) in 231 // this packet, then we have to hold a reference to it until we flush (and 232 // serialize it). Retransmittable frames are referenced elsewhere so that they 233 // can later be (optionally) retransmitted. 234 scoped_ptr<QuicAckFrame> pending_ack_frame_; 235 scoped_ptr<QuicCongestionFeedbackFrame> pending_feedback_frame_; 236 scoped_ptr<QuicStopWaitingFrame> pending_stop_waiting_frame_; 237 238 DISALLOW_COPY_AND_ASSIGN(QuicPacketGenerator); 239}; 240 241} // namespace net 242 243#endif // NET_QUIC_QUIC_PACKET_GENERATOR_H_ 244