void RUDPSocket::send_data(uint64_t ack_seq_id, uint64_t cur_seq_id, const uint8_t* data, uint16_t data_size, uint64_t now_ts)
{
if(state_ != RUDP_CONNECTED || remote_rudp_id_ < 0 || data_size <= 0)
{
RUDP_WARNING("send data failed! rudp socket id = " << rudp_id_);
return ;
}
RUDPHeadPacket head;
head.msg_id_ = RUDP_DATA;
head.remote_rudp_id_ = remote_rudp_id_;
head.check_sum_ = check_sum_;
RUDPData body;
body.ack_seq_id_ = recv_buffer_.get_ack_id();
body.cur_seq_id_ = cur_seq_id;
//body.data_.assign((const char*)data, data_size); //todo:减少一次拷贝
//设置一个最后发送ACK的时刻
recv_buffer_.set_send_last_ack_ts(now_ts);
strm_.rewind(true);
strm_ << local_title_ << head << body;
//加入数据
strm_.push_data(data, data_size);
RUDP()->send_udp(local_index_, strm_, remote_addr_);
}
void RUDPSocket::process_syn_ack(BinStream& strm, const Inet_Addr& remote_addr)
{
RUDP_INFO("recv syn ack from " << remote_addr << ", rudp id = " << rudp_id_);
RUDP()->delete_peer_index(remote_rudp_id_, remote_addr_);
RUDP_INFO("recv syn ack from " << remote_addr);
if(state_ != RUDP_CONNECTED)
{
RUDP_FATAL("state != RUDP_CONNECTED");
return ;
}
PARSE_RUDP_MESSAGE(strm, RUDPSyn2AckPacket, ack, "parse syn_ack failed!");
//计算RTT
uint64_t now_ts = CBaseTimeValue::get_time_value().msec();
uint32_t rtt = static_cast<uint32_t>(now_ts > ack.remote_ts_ ? (now_ts - ack.remote_ts_) : 5);
ccc_.set_rtt(rtt);
RUDP_INFO("rtt = " << rtt << ", rudp socket id = " << rudp_id_);
//触发一个写事件
if(event_handler_ != NULL)
event_handler_->rudp_output_event(rudp_id_);
}
int32_t RecvUDPHandler::close()
{
REACTOR_INSTANCE()->delete_handler(this);
sock_dgram_.close();
//注销桥接口
RUDP()->unattach(&adapter_);
return 0;
}
void RUDPSocket::process(uint8_t msg_id, uint16_t check_sum, BinStream& strm, const Inet_Addr& remote_addr)
{
if(check_sum != check_sum_)
return ;
keeplive_count_ = 0;
//地址学习
if(remote_addr_ != remote_addr)
{
RUDP()->delete_peer_index(remote_rudp_id_, remote_addr_);
remote_addr_ = remote_addr;
}
switch(msg_id)
{
case RUDP_DATA:
process_data(strm, remote_addr);
break;
case RUDP_DATA_ACK:
process_data_ack(strm, remote_addr);
break;
case RUDP_DATA_NACK:
process_data_nack(strm, remote_addr);
break;
case RUDP_SYN2:
process_syn2(strm, remote_addr);
break;
case RUDP_SYN_ACK:
process_syn_ack(strm, remote_addr);
break;
case RUDP_FIN:
process_fin(strm, remote_addr);
break;
case RUDP_FIN2:
process_fin2(strm, remote_addr);
break;
case RUDP_KEEPALIVE:
process_keeplive(strm, remote_addr);
break;
case RUDP_KEEPALIVE_ACK:
process_keeplive_ack(strm, remote_addr);
break;
}
heartbeat();
}
void RUDPSocket::send_fin()
{
RUDPHeadPacket head;
head.msg_id_ = RUDP_FIN;
head.remote_rudp_id_ = remote_rudp_id_;
head.check_sum_ = check_sum_;
strm_.rewind(true);
strm_ << local_title_ << head;
RUDP()->send_udp(local_index_, strm_, remote_addr_);
}
void RUDPSocket::send_keeplive_ack(uint64_t ts)
{
RUDPHeadPacket head;
head.msg_id_ = RUDP_KEEPALIVE_ACK;
head.remote_rudp_id_ = remote_rudp_id_;
head.check_sum_ = check_sum_;
RDUPKeepLive body;
body.timestamp_ = ts;
strm_.rewind(true);
strm_ << local_title_ << head << body;
RUDP()->send_udp(local_index_, strm_, remote_addr_);
}
int32_t RUDPListenHandler::rudp_accept_event(int32_t rudp_id)
{
RUDPConnection *conn = new RUDPConnection();
RUDPStream& sock = conn->get_rudp_stream();
sock.set_handler(rudp_id);
int buffer_size = RUDP_SEND_BUFFER;
sock.set_option(RUDP_SEND_BUFF_SIZE, buffer_size);
//¹ØÁªHANDLER
RUDP()->bind_event_handle(sock.get_handler(), conn);
conn->set_state(RUDP_CONN_CONNECTED);
return 0;
}
void RUDPSocket::set_state(uint16_t state)
{
if(state_ >= state)
return ;
state_ = state;
send_count_ = 0;
cancel_timer();
//释放SOCKET对象
if(state == RUDP_CLOSE)
{
RUDP()->free_sockets(rudp_id_);
}
}
void RUDPSocket::send_syn_ack(uint8_t result , uint64_t remote_ts)
{
RUDPHeadPacket head;
head.msg_id_ = RUDP_SYN_ACK;
head.remote_rudp_id_ = remote_rudp_id_;
head.check_sum_ = check_sum_;
RUDPSyn2AckPacket syn_ack;
syn_ack.result_ = result;
syn_ack.remote_ts_ = remote_ts;
strm_.rewind(true);
strm_ << local_title_ << head << syn_ack;
RUDP()->send_udp(local_index_, strm_, remote_addr_);
}
int32_t RUDPConnection::send(RUDPTestPacket& packet)
{
int32_t ret = -1;
BinStream *bin_strm = STREAMPOOL.pop_obj();
bin_strm->rewind(true);
*bin_strm << packet;
if (sbuffer_.put(*bin_strm))
{
RUDP()->register_event(rudp_sock_.get_handler(), MASK_WRITE);
ret = 0;
}
bin_strm->rewind(true);
STREAMPOOL.push_obj(bin_strm);
return ret;
}
void RUDPSocket::send_syn()
{
RUDPHeadPacket head;
head.msg_id_ = RUDP_SYN;
head.remote_rudp_id_ = INVALID_RUDP_HANDLE;
head.check_sum_ = check_sum_;
RUDPSynPacket syn;
syn.version_ = RUDP_VERSION;
syn.local_rudp_id_ = rudp_id_;
syn.local_ts_ = CBaseTimeValue::get_time_value().msec();
syn.max_segment_size_ = MAX_SEGMENT_SIZE;
syn.start_seq_ = send_buffer_.get_buffer_seq();
strm_.rewind(true);
strm_ << local_title_ << head << syn;
RUDP()->send_udp(local_index_, strm_, remote_addr_);
}
int32_t RUDPConnection::connect(const Inet_Addr& src_addr, const Inet_Addr& dst_addr)
{
if(rudp_sock_.open(src_addr) != 0)
{
return -1;
}
rudp_setoption(rudp_sock_.get_handler(), RUDP_NAGLE, 1);
if(rudp_sock_.connect(dst_addr) != 0)
{
this->close();
return -1;
}
//绑定一个事件器
RUDP()->bind_event_handle(rudp_sock_.get_handler(), this);
state_ = RUDP_CONN_CONNECTING;
set_timer(23000);
return 0;
}
void RUDPSocket::send_syn2(uint8_t result, uint64_t remote_ts)
{
RUDPHeadPacket head;
head.msg_id_ = RUDP_SYN2;
head.remote_rudp_id_ = remote_rudp_id_;
head.check_sum_ = check_sum_;
RUDPSyn2Packet syn2;
syn2.version_ = RUDP_VERSION;
syn2.local_rudp_id_ = rudp_id_;
syn2.local_ts_ = CBaseTimeValue::get_time_value().msec();
syn2.remote_ts_ = remote_ts;
syn2.syn2_result_ = result;
syn2.max_segment_size_ = MAX_SEGMENT_SIZE;
syn2.start_seq_ = send_buffer_.get_buffer_seq();
strm_.rewind(true);
strm_ << local_title_ << head << syn2;
for(uint8_t i = 0; i < 3; ++i)
RUDP()->send_udp(local_index_, strm_, remote_addr_);
}
void RUDPSocket::send_nack(uint64_t base_seq_id, const LossIDArray& ids)
{
if(state_ != RUDP_CONNECTED || remote_rudp_id_ < 0)
{
RUDP_WARNING("send nack failed! rudp socket id = " << rudp_id_);
return ;
}
RUDPHeadPacket head;
head.msg_id_ = RUDP_DATA_NACK;
head.remote_rudp_id_ = remote_rudp_id_;
head.check_sum_ = check_sum_;
RUDPDataNack nack;
nack.base_seq_ = base_seq_id;
nack.loss_ids_ = ids;
strm_.rewind(true);
strm_ << local_title_ << head << nack;
RUDP()->send_udp(local_index_, strm_, remote_addr_);
}
void RUDPSocket::send_ack(uint64_t ack_seq_id)
{
if(state_ != RUDP_CONNECTED || remote_rudp_id_ < 0)
{
RUDP_WARNING("send ack failed! rudp socket id = " << rudp_id_);
return ;
}
RUDPHeadPacket head;
head.msg_id_ = RUDP_DATA_ACK;
head.remote_rudp_id_ = remote_rudp_id_;
head.check_sum_ = check_sum_;
RUDPDataAck ack;
ack.ack_seq_id_ = ack_seq_id;
strm_.rewind(true);
strm_ << local_title_ << head << ack;
//RUDP_DEBUG("send ack, rudp_id = " << rudp_id_ << ", seq = " << ack_seq_id);
RUDP()->send_udp(local_index_, strm_, remote_addr_);
}
int32_t RecvUDPHandler::open(const Inet_Addr& local_addr)
{
int32_t ret = sock_dgram_.open(local_addr, true);
if(ret == 0)
{
//设置缓冲区大小
int32_t buf_size = 10 * 1024 * 1024; //10M
sock_dgram_.set_option(SOL_SOCKET, SO_RCVBUF, (void *)&buf_size, sizeof(int32_t));
sock_dgram_.set_option(SOL_SOCKET, SO_SNDBUF, (void *)&buf_size, sizeof(int32_t));
//本地UDP桥接口
adapter_.set_title(0);
adapter_.set_local_addr(local_addr);
RUDP()->attach(&adapter_);
return REACTOR_INSTANCE()->register_handler(this, MASK_READ);
}
else
{
return -1;
}
}
void RUDPConnection::close()
{
RUDP()->bind_event_handle(rudp_sock_.get_handler(), NULL);
rudp_close_event(rudp_sock_.get_handler());
}
