sequence ID for handling reliability

Question

I'm trying to figure out a simple way to handle reliability for UDP messages. I figured I would just send each one with a sequencing ID and by comparing the ID to the one previously received, a loss can be detected. I would normally just use integers however the idea that it would just keep incrementing indefinitely did not sit right with me.

I could use base64, but that would only make it a bit more readable but doesn't really solve anything.

I also considered prefixing a date stamp however that would be kind of sloppy when dealing messages received around midnight.

I feel like there must a better solution that someone could suggest, even if that is to just stick with integers.

Answer 1

My preference for this particular job is to use an incrementing (at least 64-bit) integer sequence seeded with a high-resolution timestamp. In this way, even if there is a loss of state at the sending end, when the sequence is re-seeded from the time, it will in all likelihood simply jump forward. Any Year 10K bugs that this might introduce are left as an exercise for Lazarus Long. :-)

Keep in mind that sequence-gap detection is essentially an optimization. The transmitting end needs to retransmit until an ack is received, with a nack (for a gap or corrupted datagram) simply eliciting earlier retransmission. (ZMODEM is a rare exception to this rule, with its default mode of operation being the use of a single ack at the end of the stream and all other retransmissions governed by nacks; as a file transfer protocol, however, it is essentially one giant multipart datagram.)

Answer 2

Use TCP? This is why TCP is different to UDP

I don't mean to be sarcastic, but this is why TCP is there.