third-party/libutp/utp.cpp

231 	uint16_big seq_nr;

268 	uint16_big seq_nr;

571 	// the oldest un-acked packet in the send queue is seq_nr - cur_window_packets

609 	uint16 seq_nr;

767 						 uint16 ack_nr, uint16 seq_nr, byte version);

860 	uint16 seq_nr = version == 0 ? b->seq_nr : b1->seq_nr;

862 	LOG_UTPV("0x%08x: send %s len:%u id:%u timestamp:"I64u" reply_micro:%u flags:%s seq_nr:%u ack_nr:%u",

864 			 seq_nr, ack_nr);

882 		pfa.pf.seq_nr = (uint16)seq_nr;

893 		pfa1.pf.seq_nr = seq_nr;

976 						 const PackedSockAddr &addr, uint32 conn_id_send, uint16 ack_nr, uint16 seq_nr, byte version)

986 		pf.seq_nr = seq_nr;

997 		pf1.seq_nr = seq_nr;

1002 	LOG_UTPV("%s: Sending RST id:%u seq_nr:%u ack_nr:%u", addrfmt(addr, addrbuf), conn_id_send, seq_nr, ack_nr);

1095 	for (uint16 i = seq_nr - cur_window_packets; i != seq_nr; ++i) {

1106 		if (i != ((seq_nr - 1) & ACK_NR_MASK) ||

1139 			pkt = (OutgoingPacket*)outbuf.get(seq_nr - 1);

1154 			outbuf.put(seq_nr - 1, pkt);

1196 			outbuf.ensure_size(seq_nr, cur_window_packets);

1197 			outbuf.put(seq_nr, pkt);

1198 			if (version == 0) p->seq_nr = seq_nr;

1199 			else p1->seq_nr = seq_nr;

1200 			seq_nr++;

1232 		OutgoingPacket *pkt = (OutgoingPacket*)outbuf.get(seq_nr - i - 1);

1247 	assert(cur_window_packets == 0 || outbuf.get(seq_nr - cur_window_packets));

1290 			OutgoingPacket *pkt = (OutgoingPacket*)outbuf.get(seq_nr - cur_window_packets);

1323 				OutgoingPacket *pkt = (OutgoingPacket*)outbuf.get(seq_nr - i - 1);

1331 			LOG_UTP("0x%08x: Packet timeout. Resend. seq_nr:%u. timeout:%u max_window:%u",

1332 					this, seq_nr - cur_window_packets, retransmit_timeout, (uint)max_window);

1335 			timeout_seq_nr = seq_nr;

1338 				OutgoingPacket *pkt = (OutgoingPacket*)outbuf.get(seq_nr - cur_window_packets);

1470 		if (((seq_nr - v - 1) & ACK_NR_MASK) >= (uint16)(cur_window_packets - 1))

1519 		// if v >= seq_nr || v <= seq_nr - cur_window_packets

1522 		// if v == seq_nr the -1 will make it wrap. if v > seq_nr

1525 		// if v == seq_nr - cur_window_packets, the result will be

1526 		// seq_nr - (seq_nr - cur_window_packets) - 1

1527 		// == seq_nr - seq_nr + cur_window_packets - 1

1529 		// test. If v < seq_nr - cur_window_packets the result will grow

1538 		//        (seq_nr-wnd)         seq_nr

1540 		if (((seq_nr - v - 1) & ACK_NR_MASK) >= (uint16)(cur_window_packets - 1))

1563 			assert((v & outbuf.mask) != ((seq_nr - cur_window_packets) & outbuf.mask));

1775 		pk_seq_nr = pf->seq_nr;

1779 		pk_seq_nr = pf1->seq_nr;

1786 	LOG_UTPV("0x%08x: Got %s. seq_nr:%u ack_nr:%u state:%s version:%u timestamp:"I64u" reply_micro:%u",

1854 	// packet this is. ack_nr is the last acked, seq_nr is the

1870 	int acks = (pk_ack_nr - (conn->seq_nr - 1 - conn->cur_window_packets)) & ACK_NR_MASK;

1879 		if (pk_ack_nr == ((conn->seq_nr - conn->cur_window_packets - 1) & ACK_NR_MASK) &&

1902 		int seq = conn->seq_nr - conn->cur_window_packets + i;

1916 	LOG_UTPV("0x%08x: acks:%d acked_bytes:%u seq_nr:%d cur_window:%u cur_window_packets:%u relative_seqnr:%u max_window:%u min_rtt:%u rtt:%u",

1917 			 conn, acks, (uint)acked_bytes, conn->seq_nr, (uint)conn->cur_window, conn->cur_window_packets,

2023 			int ack_status = conn->ack_packet(conn->seq_nr - conn->cur_window_packets);

2032 				OutgoingPacket* pkt = (OutgoingPacket*)conn->outbuf.get(conn->seq_nr - conn->cur_window_packets);

2049 		while (conn->cur_window_packets > 0 && !conn->outbuf.get(conn->seq_nr - conn->cur_window_packets))

2057 		assert(conn->cur_window_packets == 0 || conn->outbuf.get(conn->seq_nr - conn->cur_window_packets));

2061 			OutgoingPacket *pkt = (OutgoingPacket*)conn->outbuf.get(conn->seq_nr - 1);

2076 			LOG_UTPV("Fast timeout %u,%u,%u?", (uint)conn->cur_window, conn->seq_nr - conn->timeout_seq_nr, conn->timeout_seq_nr);

2079 			if (((conn->seq_nr - conn->cur_window_packets) & ACK_NR_MASK) != conn->fast_resend_seq_nr) {

2084 				OutgoingPacket *pkt = (OutgoingPacket*)conn->outbuf.get(conn->seq_nr - conn->cur_window_packets);

2086 					LOG_UTPV("0x%08x: Packet %u fast timeout-retry.", conn, conn->seq_nr - conn->cur_window_packets);

2103 	assert(conn->cur_window_packets == 0 || conn->outbuf.get(conn->seq_nr - conn->cur_window_packets));

2105 	LOG_UTPV("0x%08x: acks:%d acked_bytes:%u seq_nr:%u cur_window:%u cur_window_packets:%u quota:%d",

2106 			 conn, acks, (uint)acked_bytes, conn->seq_nr, (uint)conn->cur_window, conn->cur_window_packets,

2137 		// sequence numbers higher than seq_nr.

2343 	conn->seq_nr = 1;

2357 	conn->fast_resend_seq_nr = conn->seq_nr;

2433 	assert(conn->outbuf.get(conn->seq_nr) == NULL);

2465 	//conn->seq_nr = 1;

2466 	conn->seq_nr = UTP_Random();

2483 		p->pf.seq_nr = conn->seq_nr;

2494 		p1->pf.seq_nr = conn->seq_nr;

2507 	conn->outbuf.ensure_size(conn->seq_nr, conn->cur_window_packets);

2508 	conn->outbuf.put(conn->seq_nr, pkt);

2509 	conn->seq_nr++;

2548 		LOG_UTPV("recv id:%u seq_nr:%u ack_nr:%u", id, (uint)pf->seq_nr, (uint)pf->ack_nr);

2550 		LOG_UTPV("recv id:%u seq_nr:%u ack_nr:%u", id, (uint)pf1->seq_nr, (uint)pf1->ack_nr);

2595 	const uint32 seq_nr = version == 0 ? pf->seq_nr : pf1->seq_nr;

2602 			if (seq_nr != g_rst_info[i].ack_nr)

2616 		r.ack_nr = seq_nr;

2619 		UTPSocket::send_rst(send_to_proc, send_to_userdata, addr, id, seq_nr, UTP_Random(), version);

2634 		conn->ack_nr = seq_nr;

2635 		conn->seq_nr = UTP_Random();

2636 		conn->fast_resend_seq_nr = conn->seq_nr;

2735 		LOG_UTPV("0x%08x: Sending packet. seq_nr:%u ack_nr:%u wnd:%u/%u/%u rcv_win:%u size:%u quota:%d cur_window_packets:%u",

2736 				 conn, conn->seq_nr, conn->ack_nr,