Make anti-leech choker really punish underreporters

[Artoria2e5]

We previously only prevented underreporting from working. But since we can know some clients are underreporting, many by a factor of +Infinity, why not punish them?

The new change does just that. It divides the anti-leech score by the estimated under-reporting ratio. Of course we never estimate +Infinity because we do +1 on the divisor. Very light float32 math is used.

The comments are updated to explain the ways in which our solution differs from Chow et. al.

[arvidn]

../src/choker.cpp:206:52: error: implicit conversion from 'long' to 'float' may lose precision [-Werror,-Wimplicit-int-float-conversion]
                return int(std::abs(has - total_size / 2) * 2000 / total_size

[arvidn]

sorry for the delay. I finally put some thought into this. Any improvement is welcome, and maybe this is still an improvement, even if it's not perfect.

[arvidn]

one important consideration with (2) is the inherent latency in receiving HAVE messages. The complete bandwidth-delay product will always be considered lied about, by this logic. The delay in this case is worse than just the network round-trip. The other end needs to:

• put it in the disk cache
• wait for the other blocks for the same piece to be downloaded
• hash the piece (and worst-case, have to read some blocks back from disk)
• queue a HAVE message to be sent (which may end up behind other PIECE messages)

At high rates, this bandwidth delay product can easily be megabytes.

Another, perhaps less important, consideration is that this logic doesn't take into account which blocks were sent. A "cheater" that only downloads a single block per piece, but from 128 different peers, will be able to withhold 127/128 HAVE messages (99.2%) without triggering any suspicion (by this logic). This is assuming a piece size of 128 blocks, i.e. 2 MiB.

[arvidn]

I would prefer integer math here, only partly because of embedded systems but also to have deterministic results.

Since you divide by honesty below, couldn't you invert this, call it honesty and multiply it below? Then it might be reasonable to use an integer. e.g. std::int64 const honesty = std::max(1, piece_length * says_hash / (given + 1));