Simplify siphash as we always have a round number of 64-bit words

Allow environment variables to override clang/LLVM paths

Use common per-source lookup between v4 and v6/64

Since v4 has 32 bits of slack in the struct anyway, we might as
well just make it a u64 and unify the codepaths.

COrrect daddr gt handling in RuleNode::__lt__

Use -Oz rather than -O3, which seems more robust

Aavoid incomparable assertion when using mixed src/no-src rules

Remove extra shift in per_pkt_ns for readability

Having a shift in one place and unshift in a totally different file
is confusing.

Correct three bugs in the rate limiter.

 * We should be dividing by the packet size, not multiplying, as we
   should be crediting fewer packets for larger packets, not more.
 * We should handle the packet count underflowing as it may have
   been some time since the last packet.
 * The bucket limit needs to be `<= 0xd00`, not `< 0xf00`, as
   `0xf00` + `0x100` overflows our counter and resets the bucket.

Add additional comments explaining how the rate limiter works

Prefer existing src buckets even if others timed out

If we have some timed-out buckets in a source-based ratelimit,
we'll use those even if a later bucket is already storing the
counter for the source of the current packet. This is obviously
busted, so don't do that.

Clarify what collision_prob is calculating for users

Stop dumping match count before update, users can get it if they want

Partially implement sorting

Combine redundant rule conditions to work around LLVM bug 52455 fully

This adds a trivial optimization pass to combine redundant rule
conditions in back-to-back rules before printing them.

Make dropcount not stupid slow

Use best instruction set that the local kernel supports

Place source-address checks last to work around LLVM bug 52455

Move ratelimits into map lookup fn to reduce BPF verifier instructions

Use a single command to install xdp instead of remove+add

Avoid inlining siphash globally to avoid hitting BPF instruction limits

Fix/better handling of no-stats-tracking rules

Reduce bash CPU time for high-core-count machines in dropcount.sh

Double hashtable bucket size, halve parallelism.

256-way parallelism should suffice for most use-cases, but 16-entry
buckets should allow for much lower collisions than 8-entry buckets.

This also adds calculation for hash table collision.

Reuse hash table bucket entries if they're stale 32+ seconds

Rate limit by hard-coded 16-packet leaky bucket with less storage

Optimize per-src v6 matching on <= /64s to avoid always storing 4 0-bytes

Now that mem is more compact, bump max tracked src IPs to 1M

Also bump paralellism on maps to 512

Rewrite per-source ratelimiting rules to use a custom hashtable

The in-kernel hashtable isn't at all fancy, and we can just use a
custom one to get basically the same outcomes, with much less
overhead due to the per-CPU stuff we have to do to get sensible
multicore access rules.

Use a common function in test and test building in XDP mode as well

Check in siphash

Drop union in rate limiting struct that is just confusing

Use BPF_F_NO_COMMON_LRU on BPF_MAP_TYPE_LRU_PERCPU_HASH maps

Drop ports_valid flag, it just wastes a register

Satisfy BPF verifier with port swhich it can't prove are init'd values

Fix fragment parsing due to further `,` overload confusion.

Ondrej said "No, fragmentation-type is just a variant of bitmask."

Pull hash table size limit from extended community byte, up to 256k

Properly parse bitmask-match `,`s, which are AND, though it is not documented

Only increment match on ratelimits when we reach the limit

Add per-source ratelimit support

Fix some casting required in mask/endian calculation

Fix checksum offset calculation

Support a wrapper XDP prog which can call the defined xdp_drop meth

Handle packet rate limits, too

Default to parse-options because some people like `ping -R`

Track both packet count and packet sizes in drop counts.

Update README to note lack of sorting.

Update README

Less effecient, but much, much less naive rate-limiter

Support ratelimiting communities

Implement (only manually-tested) flowspec community detection except ratelimit

Total across loaded interfaces

Simplify and (correctly) test DSCP matches

Track and print rule source in drop prints

Track ports valid directly - as LLVM will | pointers which BPF wont allow

Help the BPF verifier somewhat by splitting v4 and v6 rules

Clean up length checks with a macro and comment strange semantics

Support multi-if map dump and fix last element print

Print diagnostics about install location

Correct second-frag L4 matching

Add README

Improve drop count printing

Update (and test) AST grammar based on feedback

Add default installer script

Track drops

Make v6 frag parsing optional

Only parse v4/v6 if we have relevant rules for them

Improve arg parsing somewhat and add flexibility/standardness

Tag short packets as unlikely

Support v6 fragment parsing

Initial checkin