Lines Matching defs:conn
1713 static void UTP_RegisterRecvPacket(UTPSocket *conn, size_t len)
1716 ++conn->_stats._nrecv;
1717 conn->_stats._nbytes_recv += len;
1759 size_t UTP_ProcessIncoming(UTPSocket *conn, const byte *packet, size_t len, bool syn = false)
1761 UTP_RegisterRecvPacket(conn, len);
1765 conn->update_send_quota();
1774 if (conn->version == 0) {
1787 conn, flagnames[pk_flags], pk_seq_nr, pk_ack_nr, statenames[conn->state], conn->version,
1788 conn->version == 0?(uint64)(pf->tv_sec) * 1000000 + pf->tv_usec:uint64(pf1->tv_usec),
1789 conn->version == 0?(uint32)(pf->reply_micro):(uint32)(pf1->reply_micro));
1803 const byte *data = (const byte*)pf + conn->get_header_size();
1804 if (conn->get_header_size() > len) {
1805 LOG_UTPV("0x%08x: Invalid packet size (less than header size)", conn);
1809 uint extension = conn->version == 0 ? pf->ext : pf1->ext;
1816 LOG_UTPV("0x%08x: Invalid len of extensions", conn);
1826 LOG_UTPV("0x%08x: Invalid len of extension bits header", conn);
1829 memcpy(conn->extensions, data, 8);
1830 LOG_UTPV("0x%08x: got extension bits:%02x%02x%02x%02x%02x%02x%02x%02x", conn,
1831 conn->extensions[0], conn->extensions[1], conn->extensions[2], conn->extensions[3],
1832 conn->extensions[4], conn->extensions[5], conn->extensions[6], conn->extensions[7]);
1839 if (conn->state == CS_SYN_SENT) {
1843 conn->ack_nr = (pk_seq_nr - 1) & SEQ_NR_MASK;
1847 conn->last_got_packet = g_current_ms;
1857 const uint seqnr = (pk_seq_nr - conn->ack_nr - 1) & SEQ_NR_MASK;
1862 conn->ack_time = g_current_ms + min<uint>(conn->ack_time - g_current_ms, DELAYED_ACK_TIME_THRESHOLD);
1864 LOG_UTPV(" Got old Packet/Ack (%u/%u)=%u!", pk_seq_nr, conn->ack_nr, seqnr);
1870 int acks = (pk_ack_nr - (conn->seq_nr - 1 - conn->cur_window_packets)) & ACK_NR_MASK;
1873 if (acks > conn->cur_window_packets) acks = 0;
1878 if (conn->cur_window_packets > 0) {
1879 if (pk_ack_nr == ((conn->seq_nr - conn->cur_window_packets - 1) & ACK_NR_MASK) &&
1880 conn->cur_window_packets > 0) {
1881 //++conn->duplicate_ack;
1883 conn->duplicate_ack = 0;
1902 int seq = conn->seq_nr - conn->cur_window_packets + i;
1903 OutgoingPacket *pkt = (OutgoingPacket*)conn->outbuf.get(seq);
1912 acked_bytes += conn->selective_ack_bytes((pk_ack_nr + 2) & ACK_NR_MASK,
1917 conn, acks, (uint)acked_bytes, conn->seq_nr, (uint)conn->cur_window, conn->cur_window_packets,
1918 seqnr, (uint)conn->max_window, (uint)(min_rtt / 1000), conn->rtt);
1922 if (conn->version == 0) {
1928 conn->last_measured_delay = g_current_ms;
1933 conn->reply_micro = their_delay;
1934 uint32 prev_delay_base = conn->their_hist.delay_base;
1935 if (their_delay != 0) conn->their_hist.add_sample(their_delay);
1941 wrapping_compare_less(conn->their_hist.delay_base, prev_delay_base)) {
1943 if (prev_delay_base - conn->their_hist.delay_base <= 10000) {
1944 conn->our_hist.shift(prev_delay_base - conn->their_hist.delay_base);
1948 const uint32 actual_delay = conn->version==0
1956 prev_delay_base = conn->our_hist.delay_base;
1957 if (actual_delay != 0) conn->our_hist.add_sample(actual_delay);
1970 wrapping_compare_less(conn->our_hist.delay_base, prev_delay_base)) {
1972 if (prev_delay_base - conn->our_hist.delay_base <= 10000) {
1973 conn->their_hist.Shift(prev_delay_base - conn->our_hist.delay_base);
1980 if (conn->our_hist.get_value() > uint32(min_rtt)) {
1981 conn->our_hist.shift(conn->our_hist.get_value() - min_rtt);
1988 conn->apply_ledbat_ccontrol(acked_bytes, actual_delay, min_rtt);
1992 if (acks <= conn->cur_window_packets) {
1993 conn->max_window_user = conn->version == 0
1998 if (conn->max_window_user == 0)
2000 conn->zerowindow_time = g_current_ms + 15000;
2004 if (conn->state == CS_SYN_SENT) {
2005 conn->state = CS_CONNECTED;
2006 conn->func.on_state(conn->userdata, UTP_STATE_CONNECT);
2012 } else if (conn->state == CS_FIN_SENT && conn->cur_window_packets == acks) {
2013 conn->state = CS_DESTROY;
2017 if (wrapping_compare_less(conn->fast_resend_seq_nr, (pk_ack_nr + 1) & ACK_NR_MASK))
2018 conn->fast_resend_seq_nr = pk_ack_nr + 1;
2020 LOG_UTPV("0x%08x: fast_resend_seq_nr:%u", conn, conn->fast_resend_seq_nr);
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);
2037 conn->cur_window_packets--;
2040 if (conn->cur_window_packets == 0) assert(conn->cur_window == 0);
2049 while (conn->cur_window_packets > 0 && !conn->outbuf.get(conn->seq_nr - conn->cur_window_packets))
2050 conn->cur_window_packets--;
2053 if (conn->cur_window_packets == 0) assert(conn->cur_window == 0);
2057 assert(conn->cur_window_packets == 0 || conn->outbuf.get(conn->seq_nr - conn->cur_window_packets));
2060 if (conn->cur_window_packets == 1) {
2061 OutgoingPacket *pkt = (OutgoingPacket*)conn->outbuf.get(conn->seq_nr - 1);
2064 (!(USE_PACKET_PACING) || conn->send_quota / 100 >= (int32)pkt->length)) {
2065 conn->send_packet(pkt);
2068 if (conn->reorder_count == 0) {
2069 conn->sent_ack();
2075 if (conn->fast_timeout) {
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) {
2080 conn->fast_timeout = false;
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);
2088 ++conn->_stats._fastrexmit;
2090 conn->fast_resend_seq_nr++;
2091 conn->send_packet(pkt);
2099 conn->selective_ack(pk_ack_nr + 2, selack_ptr, selack_ptr[-1]);
2103 assert(conn->cur_window_packets == 0 || conn->outbuf.get(conn->seq_nr - conn->cur_window_packets));
2106 conn, acks, (uint)acked_bytes, conn->seq_nr, (uint)conn->cur_window, conn->cur_window_packets,
2107 conn->send_quota / 100);
2111 if (conn->state == CS_CONNECTED_FULL && conn->is_writable(conn->get_packet_size())) {
2112 conn->state = CS_CONNECTED;
2114 conn, (uint)conn->max_window, (uint)conn->cur_window, conn->send_quota / 100, (uint)conn->get_packet_size());
2115 conn->func.on_state(conn->userdata, UTP_STATE_WRITABLE);
2124 if (conn->state != CS_CONNECTED &&
2125 conn->state != CS_CONNECTED_FULL &&
2126 conn->state != CS_FIN_SENT) {
2131 if (pk_flags == ST_FIN && !conn->got_fin) {
2133 conn->got_fin = true;
2134 conn->eof_pkt = pk_seq_nr;
2148 if (count > 0 && conn->state != CS_FIN_SENT) {
2149 LOG_UTPV("0x%08x: Got Data len:%u (rb:%u)", conn, (uint)count, (uint)conn->func.get_rb_size(conn->userdata));
2151 conn->func.on_read(conn->userdata, data, count);
2153 conn->ack_nr++;
2154 conn->bytes_since_ack += count;
2160 if (conn->got_fin && conn->eof_pkt == conn->ack_nr) {
2161 if (conn->state != CS_FIN_SENT) {
2162 conn->state = CS_GOT_FIN;
2163 conn->rto_timeout = g_current_ms + min<uint>(conn->rto * 3, 60);
2165 LOG_UTPV("0x%08x: Posting EOF", conn);
2166 conn->func.on_state(conn->userdata, UTP_STATE_EOF);
2170 conn->send_ack();
2178 conn->reorder_count = 0;
2182 if (conn->reorder_count == 0)
2187 byte *p = (byte*)conn->inbuf.get(conn->ack_nr+1);
2190 conn->inbuf.put(conn->ack_nr+1, NULL);
2192 if (count > 0 && conn->state != CS_FIN_SENT) {
2194 conn->func.on_read(conn->userdata, p + sizeof(uint), count);
2196 conn->ack_nr++;
2197 conn->bytes_since_ack += count;
2201 assert(conn->reorder_count > 0);
2202 conn->reorder_count--;
2206 conn->ack_time = g_current_ms + min<uint>(conn->ack_time - g_current_ms, DELAYED_ACK_TIME_THRESHOLD);
2214 if (conn->got_fin && pk_seq_nr > conn->eof_pkt) {
2217 conn, conn->reorder_count, (uint)(packet_end - data), (uint)conn->func.get_rb_size(conn->userdata));
2227 conn, conn->reorder_count, (uint)(packet_end - data), (uint)conn->func.get_rb_size(conn->userdata));
2235 conn->inbuf.ensure_size(pk_seq_nr + 1, seqnr + 1);
2239 if (conn->inbuf.get(pk_seq_nr) != NULL) {
2241 ++conn->_stats._nduprecv;
2257 // point (which is conn->ack_nr + 1).
2258 assert(conn->inbuf.get(pk_seq_nr) == NULL);
2259 assert((pk_seq_nr & conn->inbuf.mask) != ((conn->ack_nr+1) & conn->inbuf.mask));
2260 conn->inbuf.put(pk_seq_nr, mem);
2261 conn->reorder_count++;
2264 conn, conn->reorder_count, (uint)(packet_end - data), (uint)conn->func.get_rb_size(conn->userdata));
2267 conn->ack_time = g_current_ms + min<uint>(conn->ack_time - g_current_ms, 1);
2273 (uint)conn->bytes_since_ack, (int)(g_current_ms - conn->ack_time));
2274 if (conn->state == CS_CONNECTED || conn->state == CS_CONNECTED_FULL) {
2275 if (conn->bytes_since_ack > DELAYED_ACK_BYTE_THRESHOLD ||
2276 (int)(g_current_ms - conn->ack_time) >= 0) {
2277 conn->send_ack();
2288 void UTP_Free(UTPSocket *conn)
2290 LOG_UTPV("0x%08x: Killing socket", conn);
2292 conn->func.on_state(conn->userdata, UTP_STATE_DESTROYING);
2293 UTP_SetCallbacks(conn, NULL, NULL);
2295 assert(conn->idx < g_utp_sockets.GetCount());
2296 assert(g_utp_sockets[conn->idx] == conn);
2306 last->idx = conn->idx;
2308 g_utp_sockets[conn->idx] = last;
2314 for (size_t i = 0; i <= conn->inbuf.mask; i++) {
2315 free(conn->inbuf.elements[i]);
2317 for (size_t i = 0; i <= conn->outbuf.mask; i++) {
2318 free(conn->outbuf.elements[i]);
2320 free(conn->inbuf.elements);
2321 free(conn->outbuf.elements);
2324 free(conn);
2334 UTPSocket *conn = (UTPSocket*)calloc(1, sizeof(UTPSocket));
2338 UTP_SetCallbacks(conn, NULL, NULL);
2339 conn->our_hist.clear();
2340 conn->their_hist.clear();
2341 conn->rto = 3000;
2342 conn->rtt_var = 800;
2343 conn->seq_nr = 1;
2344 conn->ack_nr = 0;
2345 conn->max_window_user = 255 * PACKET_SIZE;
2346 conn->addr = PackedSockAddr((const SOCKADDR_STORAGE*)addr, addrlen);
2347 conn->send_to_proc = send_to_proc;
2348 conn->send_to_userdata = send_to_userdata;
2349 conn->ack_time = g_current_ms + 0x70000000;
2350 conn->last_got_packet = g_current_ms;
2351 conn->last_sent_packet = g_current_ms;
2352 conn->last_measured_delay = g_current_ms + 0x70000000;
2353 conn->last_rwin_decay = int32(g_current_ms) - MAX_WINDOW_DECAY;
2354 conn->last_send_quota = g_current_ms;
2355 conn->send_quota = PACKET_SIZE * 100;
2356 conn->cur_window_packets = 0;
2357 conn->fast_resend_seq_nr = conn->seq_nr;
2360 UTP_SetSockopt(conn, SO_UTPVERSION, 1);
2364 conn->max_window = conn->get_packet_size();
2365 conn->state = CS_IDLE;
2367 conn->outbuf.mask = 15;
2368 conn->inbuf.mask = 15;
2370 conn->outbuf.elements = (void**)calloc(16, sizeof(void*));
2371 conn->inbuf.elements = (void**)calloc(16, sizeof(void*));
2373 conn->idx = g_utp_sockets.Append(conn);
2375 LOG_UTPV("0x%08x: UTP_Create", conn);
2377 return conn;
2380 void UTP_SetCallbacks(UTPSocket *conn, UTPFunctionTable *funcs, void *userdata)
2382 assert(conn);
2387 conn->func = *funcs;
2388 conn->userdata = userdata;
2391 bool UTP_SetSockopt(UTPSocket* conn, int opt, int val)
2393 assert(conn);
2398 conn->opt_sndbuf = val;
2401 conn->opt_rcvbuf = val;
2404 assert(conn->state == CS_IDLE);
2405 if (conn->state != CS_IDLE) {
2409 if (conn->version == 1 && val == 0) {
2410 conn->reply_micro = INT_MAX;
2411 conn->opt_rcvbuf = 200 * 1024;
2412 conn->opt_sndbuf = OUTGOING_BUFFER_MAX_SIZE * PACKET_SIZE;
2413 } else if (conn->version == 0 && val == 1) {
2414 conn->reply_micro = 0;
2415 conn->opt_rcvbuf = 3 * 1024 * 1024 + 512 * 1024;
2416 conn->opt_sndbuf = conn->opt_rcvbuf;
2418 conn->version = val;
2427 void UTP_Connect(UTPSocket *conn)
2429 assert(conn);
2431 assert(conn->state == CS_IDLE);
2432 assert(conn->cur_window_packets == 0);
2433 assert(conn->outbuf.get(conn->seq_nr) == NULL);
2436 conn->state = CS_SYN_SENT;
2445 if (conn->version > 0) {
2453 conn, conn_seed, PACKET_SIZE, CCONTROL_TARGET / 1000,
2457 conn->retransmit_timeout = 3000;
2458 conn->rto_timeout = g_current_ms + conn->retransmit_timeout;
2459 conn->last_rcv_win = conn->get_rcv_window();
2461 conn->conn_seed = conn_seed;
2462 conn->conn_id_recv = conn_seed;
2463 conn->conn_id_send = conn_seed+1;
2465 //conn->seq_nr = 1;
2466 conn->seq_nr = UTP_Random();
2469 const size_t header_ext_size = conn->get_header_extensions_size();
2479 if (conn->version == 0) {
2480 p->pf.connid = conn->conn_id_recv;
2482 p->pf.windowsize = (byte)DIV_ROUND_UP(conn->last_rcv_win, PACKET_SIZE);
2483 p->pf.seq_nr = conn->seq_nr;
2492 p1->pf.connid = conn->conn_id_recv;
2493 p1->pf.windowsize = (uint32)conn->last_rcv_win;
2494 p1->pf.seq_nr = conn->seq_nr;
2504 // conn, addrfmt(conn->addr, addrbuf), conn_seed);
2507 conn->outbuf.ensure_size(conn->seq_nr, conn->cur_window_packets);
2508 conn->outbuf.put(conn->seq_nr, pkt);
2509 conn->seq_nr++;
2510 conn->cur_window_packets++;
2512 conn->send_packet(pkt);
2556 UTPSocket *conn = g_utp_sockets[i];
2558 // addrfmt(conn->addr, addrbuf), addrfmt(addr, addrbuf2), conn->conn_seed, conn->conn_id_send, conn->conn_id_recv, id);
2559 if (conn->addr != addr)
2562 if (flags == ST_RESET && (conn->conn_id_send == id || conn->conn_id_recv == id)) {
2563 LOG_UTPV("0x%08x: recv RST for existing connection", conn);
2564 if (!conn->userdata || conn->state == CS_FIN_SENT) {
2565 conn->state = CS_DESTROY;
2567 conn->state = CS_RESET;
2569 if (conn->userdata) {
2570 conn->func.on_overhead(conn->userdata, false, len + conn->get_udp_overhead(),
2572 const int err = conn->state == CS_SYN_SENT ?
2575 conn->func.on_error(conn->userdata, err);
2578 } else if (flags != ST_SYN && conn->conn_id_recv == id) {
2579 LOG_UTPV("0x%08x: recv processing", conn);
2580 const size_t read = UTP_ProcessIncoming(conn, buffer, len);
2581 if (conn->userdata) {
2582 conn->func.on_overhead(conn->userdata, false,
2583 (len - read) + conn->get_udp_overhead(),
2627 UTPSocket *conn = UTP_Create(send_to_proc, send_to_userdata, to, tolen);
2629 conn->conn_seed = id;
2631 conn->conn_id_send = id;
2633 conn->conn_id_recv = id+1;
2634 conn->ack_nr = seq_nr;
2635 conn->seq_nr = UTP_Random();
2636 conn->fast_resend_seq_nr = conn->seq_nr;
2638 UTP_SetSockopt(conn, SO_UTPVERSION, version);
2639 conn->state = CS_CONNECTED;
2641 const size_t read = UTP_ProcessIncoming(conn, buffer, len, true);
2643 LOG_UTPV("0x%08x: recv send connect ACK", conn);
2644 conn->send_ack(true);
2646 incoming_proc(send_to_userdata, conn);
2649 if (conn->userdata) {
2651 conn->func.on_overhead(conn->userdata, false, (len - read) + conn->get_udp_overhead(),
2654 conn->func.on_overhead(conn->userdata, true, conn->get_overhead(),
2678 UTPSocket *conn = g_utp_sockets[i];
2679 if (conn->addr == addr &&
2680 conn->conn_id_recv == id) {
2682 if (conn->state != CS_IDLE) {
2683 if (!conn->userdata || conn->state == CS_FIN_SENT) {
2684 LOG_UTPV("0x%08x: icmp packet causing socket destruction", conn);
2685 conn->state = CS_DESTROY;
2687 conn->state = CS_RESET;
2689 if (conn->userdata) {
2690 const int err = conn->state == CS_SYN_SENT ?
2693 LOG_UTPV("0x%08x: icmp packet causing error on socket:%d", conn, err);
2694 conn->func.on_error(conn->userdata, err);
2705 bool UTP_Write(UTPSocket *conn, size_t bytes)
2707 assert(conn);
2713 if (conn->state != CS_CONNECTED) {
2714 LOG_UTPV("0x%08x: UTP_Write %u bytes = false (not CS_CONNECTED)", conn, (uint)bytes);
2720 conn->update_send_quota();
2723 size_t packet_size = conn->get_packet_size();
2725 while (conn->is_writable(num_to_send)) {
2730 LOG_UTPV("0x%08x: UTP_Write %u bytes = true", conn, (uint)param);
2736 conn, conn->seq_nr, conn->ack_nr,
2737 (uint)(conn->cur_window + num_to_send),
2738 (uint)conn->max_window, (uint)conn->max_window_user,
2739 (uint)conn->last_rcv_win, num_to_send, conn->send_quota / 100,
2740 conn->cur_window_packets);
2741 conn->write_outgoing_packet(num_to_send, ST_DATA);
2746 conn->state = CS_CONNECTED_FULL;
2747 LOG_UTPV("0x%08x: UTP_Write %u bytes = false", conn, (uint)bytes);
2751 void UTP_RBDrained(UTPSocket *conn)
2753 assert(conn);
2755 const size_t rcvwin = conn->get_rcv_window();
2757 if (rcvwin > conn->last_rcv_win) {
2759 if (conn->last_rcv_win == 0) {
2760 conn->send_ack();
2762 conn->ack_time = g_current_ms + min<uint>(conn->ack_time - g_current_ms, DELAYED_ACK_TIME_THRESHOLD);
2782 UTPSocket *conn = g_utp_sockets[i];
2783 conn->check_timeouts();
2786 if (conn->state == CS_DESTROY) {
2787 LOG_UTPV("0x%08x: Destroying", conn);
2788 UTP_Free(conn);
2799 void UTP_GetPeerName(UTPSocket *conn, struct sockaddr *addr, socklen_t *addrlen)
2801 assert(conn);
2804 const SOCKADDR_STORAGE sa = conn->addr.get_sockaddr_storage(&len);
2809 void UTP_GetDelays(UTPSocket *conn, int32 *ours, int32 *theirs, uint32 *age)
2811 assert(conn);
2813 if (ours) *ours = conn->our_hist.get_value();
2814 if (theirs) *theirs = conn->their_hist.get_value();
2815 if (age) *age = g_current_ms - conn->last_measured_delay;
2819 void UTP_GetStats(UTPSocket *conn, UTPStats *stats)
2821 assert(conn);
2823 *stats = conn->_stats;
2835 void UTP_Close(UTPSocket *conn)
2837 assert(conn);
2839 assert(conn->state != CS_DESTROY_DELAY && conn->state != CS_FIN_SENT && conn->state != CS_DESTROY);
2841 LOG_UTPV("0x%08x: UTP_Close in state:%s", conn, statenames[conn->state]);
2843 switch(conn->state) {
2846 conn->state = CS_FIN_SENT;
2847 conn->write_outgoing_packet(0, ST_FIN);
2851 conn->rto_timeout = UTP_GetMilliseconds() + min<uint>(conn->rto * 2, 60);
2853 conn->state = CS_DESTROY_DELAY;
2857 conn->state = CS_DESTROY;