Stanford CS144 Lab.TCP Connection

void TCPConnection::segment_received(const TCPSegment &seg) { 
    DUMMY_CODE(seg); 
    // get the segment from IP level;
    if(!_active){
        return;
    }
    _time_since_last_segment_received=0;
    //not get segment no send ACK.
    //passive connection...
    //the ackno is null and no bytes is sent
    if(!_receiver.ackno().has_value()&&_sender.next_seqno_absolute()==0){
        //only recieve syn...
        if(!seg.header().syn) return;
        //as the Service side,passive connected.
        _receiver.segment_received(seg);
        //it's OK to connect.
        connect();
        return;
    }
    // active connected..
    // first connection...
    if(_sender.next_seqno_absolute() > 0 && _sender.bytes_in_flight() == _sender.next_seqno_absolute() && 
       !_receiver.ackno().has_value()){
        // the length of payload is not 0
        if(seg.payload().size() ){
            return;
        }
        // if ack is no
        // the twoside wants to setup the connection at the same time.
        if(!seg.header().ack){
            if(seg.header().syn){
                _receiver.segment_received(seg);
                // send empty ack to setup the connection.
                _sender.send_empty_segment();
            }
            return;
        }
        // ifsyn=1,ack=1,rst=1,then shut down.
        if(seg.header().rst){
            _receiver.stream_out().set_error();
            _sender.stream_in().set_error();
            _active = false;
            return;
        }
    }
    //otherwise...
    //recieve the segment
    _receiver.segment_received(seg);
    _sender.ack_received(seg.header().ackno,seg.header().win);
    // thrid connection
    if (_sender.stream_in().buffer_empty() && seg.length_in_sequence_space())
        _sender.send_empty_segment();
    if (seg.header().rst) {
        _sender.send_empty_segment();
        unclean_shutdown();
        return;
    }
    send_sender_segments();
}

size_t TCPConnection::write(const string &data) {
    DUMMY_CODE(data);
    // get the OS data... ready to be sent by TCP
    if(data.size()==0){
        return 0;
    }
    size_t write_size = _sender.stream_in().write(data);
    _sender.fill_window();
    send_sender_segments();
    return write_size;
}

//! \param[in] ms_since_last_tick number of milliseconds since the last call to this method
void TCPConnection::tick(const size_t ms_since_last_tick) { 
    DUMMY_CODE(ms_since_last_tick); 
    if(!_active) return;
    //count
    _time_since_last_segment_received += ms_since_last_tick;
    // tell the sender to tick
    _sender.tick(ms_since_last_tick);
    if(_sender.consecutive_retransmissions()>TCPConfig::MAX_RETX_ATTEMPTS){
        unclean_shutdown();
    }
    send_sender_segments();
}

void TCPConnection::send_sender_segments (){
    //travel the queue to set the ack and windows size.
    while(!_sender.segments_out().empty()){
        TCPSegment seg = _sender.segments_out().front();
        _sender.segments_out().pop();
        // the ack number is bot null
        if(_receiver.ackno().has_value()){
            seg.header().ack=true;
            seg.header().ackno=_receiver.ackno().value();
            seg.header().win=_receiver.window_size();
        }
        _segments_out.push(seg);
    }
    //every time send segment,we need to shutdown.
    clean_shutdown();
}