Method SendTransferPacket

library/cpp/netliba/v12/udp_host.cpp:722–775

    }

    TUdpHost::ESentPacketResult TUdpHost::SendTransferPacket(TConnection* connection, TUdpOutTransfer* xfer, ui64 transferId) {
        NHPTimer::STime tCopy = CurrentT;
        float deltaT = (float)NHPTimer::GetTimePassed(&tCopy);
        deltaT = ClampVal(deltaT, 0.0f, UdpTransferTimeout / 3);

        bool isCanceled = false;
        const int packetId = xfer->AckTracker.GetPacketToSend(deltaT, &isCanceled);
        if (packetId == -1) {
            if (isCanceled) {
                if (xfer->TriedToSendAtLeastOnePacket) {
                    const ui8 err = FlushPackets(); // there must be FlushPackets before any Send.* function -
                    //it guarantee we have some space in packet buffer

                    if (err & TUdpHost::EFlashPacketResult::FPR_OUT_TRANSFERS_CHANGED) {
                        //also we must check _current_ transfer because FlushPackets() could remove it
                        if (!connection->IsSendTransferAlive(transferId)) {
                            return TUdpHost::ESentPacketResult::SPR_STOP_SENDING_TRANSFER;
                        }
                    }
                    SendCancelTransfer(S, connection, transferId, xfer->AckTos);
                    xfer->AckTracker.Congestion->ForceTimeAccount();
                } else {
                    xfer->AckTracker.AckAll(); // isn't necessary actually, but just to be sure...
                    CanceledSend(TTransfer(connection, transferId));
                }
            }
            return TUdpHost::ESentPacketResult::SPR_STOP_SENDING_TRANSFER;
        }
        const int dataSize = (packetId == xfer->PacketCount - 1) ? xfer->LastPacketSize : xfer->PacketSize;

        // I intentionally use very specific comparison here to minimize possible backward compatibility issues
        if (dataSize == UDP_SMALL_PACKET_SIZE && xfer->AckTracker.Congestion->GetMTU() == UDP_XSMALL_PACKET_SIZE) {
            // Cerr << "SendTransferPacker: dataSize " << dataSize << " > mtu " << xfer->AckTracker.Congestion->GetMTU()
            //      << ", xfer " << ui64(xfer) << " marked as failed" << Endl;
            FailedSend(TTransfer(connection, transferId));
            return TUdpHost::ESentPacketResult::SPR_STOP_SENDING_TRANSFER;
        }

        const std::pair<char* const, ui8>& packetBuffer = GetPacketBuffer(dataSize + PACKET_HEADERS_SIZE, connection, transferId);

        if (!packetBuffer.first) { //buffer overflow, or current transfer removed during packet flushing
            if (packetBuffer.second & TUdpHost::EFlashPacketResult::FPR_OUT_TRANSFERS_CHANGED) {
                //transfer removed
                return TUdpHost::ESentPacketResult::SPR_STOP_SENDING_TRANSFER;
            }
            //xfer->AckTracker.AddToResend(packetId); no need here - FlushPackets adds packetId to resend
            Y_ASSERT(packetBuffer.second & TUdpHost::EFlashPacketResult::FPR_OVERFLOW);
            return TUdpHost::ESentPacketResult::SPR_OVERFLOW;
        }

        xfer->TriedToSendAtLeastOnePacket = true;
        AddDataToPacketQueue(S, packetBuffer.first, connection, transferId, *xfer, packetId, dataSize);
        return TUdpHost::ESentPacketResult::SPR_OK;
    }

    bool TUdpHost::SendCycle(ui8 prio) {
        bool res1 = Connections.ForEachSendingConnection([prio, this](TSendingConnectionsList::iterator& sc) {