#StandardLibrary | Explore Tumblr posts and blogs

hunterlevel283 · 4 years ago

Text

Get New Ip Address

Buy premium private proxies with New IP Now. Choose among 20+ locations, get started in minutes, and refresh IPs at any time. The public IP address is dynamically assigned by Verizon. The only way to change it is to call support and ask them to release your address. But there is no chance you will get a new address. Other folks on here have indicated you can release the address and then request a new address. Then again no chance you will get a new address, just a.

Change Ip Address For Free Online

How To Find Ip Address On Computer

Get New Ip Address Cox

Get New Ip Address Free

Tailscale needed a better IP address type

Tailscale is a networking application so naturally we need to work withand manipulate IP addresses and sets of IP addresses often.

Being written almost entirely in Go, the obvious choice would be forTailscale to use the Go standard library’snet.IP address type for individualIPs and net.IPNet type fornetworks. Unfortunately, the standard library’s types have a number ofproblems, so we wrote a new package,inet.af/netaddr (github) containinga new IP type and more.

What’s wrong with Go’s net.IP type?

When I was working on Go full time, I filed Go issue#18804 to track somethings that aren’t great about Go’s IP address:

It’s mutable. The underlyingtype of a net.IP is just a()byte, which means anything you pass it to might mutateit. Immutable data structures are safer, easier to reason about, anddon’t require defensive copies.

It’s notcomparablebecause a slice in Go is not comparable, which means it doesn’tsupport Go’s operator and can’t be used as a map key.

There are two IP address types in the standard library: net.IP for justa basic IPv4 or IPv6 address, and then alsonet.IPAddr if you need to supportIPv6 zone scopes.Having two types in the standard library means youneed to decide which type to accept or return from your code, orhave two+ variants, which gets annoying (e.g. Go’s Resolver.LookupIPvs Resolver.LookupIPAddr)

It’s large. A Go slice is 3 words (so 24 bytes total on 64-bitmachines) just for the slice header, without counting the underlyingarray that the slice points to (background).So an IP address with Go’s net.IP istwo parts: the 24 byte slice header, and then also the 4 or 16 bytesof IP address. If you want an IPv6 zone, you have to use net.IPAddr witha 16 byte string header also.

It allocates, #43451. Go’s net package is full of allocations everywhere,putting more work on the GC and thus the CPU. If you callnet.ParseIP or receive a UDP packet, it needs to allocate theunderlying array where it records the IP address, to put thatpointer in the returned slice header of the net.IP.

When parsing an IP from its string form, Go’s IP type can’tdistinguish betweenIPv4-mapped IPv6addressesand IPv4 addresses. The Go IP type doesn’t record the original address family.This is tracked in Go issue #37921.

It’s a transparent type. The definition of net.IP is: type IP ()byte,which means its underlying type is a byte slice,which is part of its public API and unchangeable. By contrast, Go’stime.Time type is defined like type Time struct ( /* unexported */ )so it’s free to change without breaking API promises. In fact, Go’s Time did changeits representation recently in Go 1.9 when it gainedtransparent monotonic time support.That would not have been possible if the type weren’t opaque.As some trivia: the Go Timeused to be transparent prior to Go 1.Unfortunately we weren’t wise enough at the time to do the samefor the IP address type.

Some of this was by design at the time, before Go 1 locked in thecompatibility promise in 2012, butmuch of it was just never considered well or predated enoughexperience with Go to learn what patterns worked well and whichdidn’t. In any case, the Go standard library can’t change much now.

What do we want?

In summary, this is what we want, and how Go’s net.IP fares:

FeatureGo's net.IPImmutable❌, sliceComparable❌, sliceSmall❌, 28-56 bytesAllocation free❌, slice's underlying arraySupports IPv4 & IPv6✅Can distinguish IPv4/IPv6❌, #37921Supports IPv6 zones❌, has separate net.IPAddr typeOpaque type❌, defined as ()byteInterops with standard library✅

So, let’s do better.

This story has several parts:

Take 1: wgcfg.IP

The story begins in April 2019 with89476f8cb5 in which David Crawshaw, aware of all these problems,created an IP type like:

That’s a bit better:

Featurenet.IPwgcfg.IPImmutable❌, slice✅Comparable❌, slice✅Small❌, 28-56B✅, 16BAllocation free❌✅Supports IPv4 & IPv6✅✅Can distinguish IPv4/IPv6❌❌Supports IPv6 zones❌❌Opaque type❌❌Interops with standard library✅❌, with adapters

We used that for quite a bit in some places but it wasn’t quite good enough tostart using more widely.

Making it opaque would be easy enough (unexporting the Addr field, renaming it to addr), butthat still would leave us with the lost address family bit and lackof IPv6 zones.

Take 2: netaddr.IP, opaque comparable interfaces

One bit about the Go language specification that many people don’t know isis that interfaces are comparable (support & being map keys),but they panic at runtime if theunderlying value in the interface is not comparable.

Taking advantage of that to be comparable, the firstversionof netaddr.IP was represented like this:

Notably, the IP type there is an opaque struct embedding aninterface. An interface, being 2 wordswide, is 16 bytes on 64-bitmachines, so the IP type here is 16 bytes. That’s better than thestandard library’s 24 byte (3 word) slice header used for net.IP.But both still need to a pointer to the actual bytes of the IPaddress. At least with this representation, the interface’s type wordencodes whether the address is IPv4, IPv6, or IPv6 with a zone scope.

It was good in some ways, but not perfect:

Featurenet.IPwgcfg.IP'Take 2'Immutable❌, slice✅✅Comparable❌, slice✅✅Small❌, 28-56B✅, 16B🤷, 20-32BAllocation free❌✅❌Supports IPv4 & IPv6✅✅✅Can distinguish IPv4/IPv6❌❌✅Supports IPv6 zones❌❌✅Opaque type❌❌✅Interops with standard library✅❌, with adapters❌, with adapters

I got the impression that Crawshaw in particular was very “meh” onthis representation needing to allocate compared to our existingwgcfg.IP type.

Let’s do better.

Take 3: allocation-free 24 byte representation

At some point I realized that the maximum tolerable size of our IPaddress type was 24 bytes: that’s the same size as Go’s net.IP sliceheader, and Go slices are very common. A time.Time is also a 24byte value type, so surely the compiler deals with 24 byte value typesjust fine. But mostly I didn’t want our new IP type to be worse inany dimension compared to the standard library’s net.IP, which is(in part) 24 bytes. So I somewhat arbitrarily decreed that 24 byteswas our limit.

Since an IPv6 address is already 16 bytes, that leaves us 8 bytesremaining in which to encode the following things:

Change Ip Address For Free Online

the address family (v4, v6, or neither, such as the IP zero value). There’sat least two bits.

the IPv6 zone

Also, we need to be comparable.

Using an interface is out: that’s two words (16 bytes), so that’s toobig. Likewise, a string is also two words (a pointer and length), sothat’s out.

We could play bit-packing games like:

… and try to encode the address family and zone into the 64 zoneAndFamily bits, but how?

If we have 1 or 2 bits for the address family, we have 62 or 63 bitsleft. Various options included:

shove the 7-bit ASCII string into the remaining 62 bits. But thatlimits us to 8 characters. Even our default 'tailscale0' interfacename wouldn’t fit.

encode a zone index into the 62 or 63 bits instead. But then we can’t parseand represent an interface that the local machine doesn’t have.

use a zone mapping table, mapping between zone index integers and zone name strings.That’s what the Go standard library does internally. But then we’re left susceptible to an attack where an adversary forcesus to parse a bunch of IP addresses with scopes and we forever bloat a mappingtable that we don’t have a good opportunity to ever shrink. The Go standardlibrary doesn’t need to deal with this, as it only ever maps interfaces thatexist on the machine and doesn’t expose the integers to users in representations;its net.IPAddr.Zone field is a string.

So, I didn’t like any of those options.

But then I thought of something gross. Or awesome.

We could use a pointer!

Ignoring the zone and actual definition of T for now, the addressfamily is easy: we make three sentinel pointer values to represent thefamily, and whether the IP address is the zero value (as opposed to,say, actually '0.0.0.0').

But how do we represent the zone string such that it’s comparable soGo’s works and IP values can be map keys?

Remember, our goal is that this prints true:

But comparisons on Go pointers compare the pointer values, not whatthey point to. That is, new(string) != new(string).

So we need to make sure that two separate ParseIP calls with same'eth0' zone at any point and any time in the program always returnthe same pointer value for that process.

That implies we need a mapping between these pointer values and theirprocess-wide-unique names ('eth0', etc). If this sounds a lot likethe earlier problem with the zone indexes, it is, but there’s onething that’s different: when shoving a zone index into an integerabove, we didn’t have a way to do any cleanup of the mappingtable. But with a pointer, we can useruntime.SetFinalizer.Using SetFinalizer is gross and scary and you should think twicebefore using it. We sure did. But sometimes gross and scary things arethe right tool for the job.

What we ended up writing was thego4.org/intern package tohide the bodies so ourinet.af/netaddr package couldhave plausible deniability as to its innocence.

The go4.org/intern package is tiny and worth reading infull (and perhapsworthy of a future blog post on its own), but thecore of it is this ungodliness:

Basically, it’s playing unsafe games behind the Go garbage collector’sback, hiding pointers in untyped uintptr integers so Go will beforced to eventually garbage collect things which then causes thefinalizer to be invoked to step in and either clean up its lies orclean up the map.

But the end result is that this is now true:

So our IP representation can be:

The accessors to get/set the zone are then:

How we’d do?

Featurenet.IPnetaddr.IPImmutable❌, slice✅Comparable❌, slice✅Small❌, 28-56B✅, 24B, alwaysAllocation free❌✅Supports IPv4 & IPv6✅✅Can distinguish IPv4/IPv6❌✅Supports IPv6 zones❌✅Opaque type❌✅Interops with standard library✅🤷, adaptor methods

Nailed it.

Take 4: uint64s for speed

We were pretty happy, but Dave Anderson took advantage of the type’sopaque representation and changed the representation to make it faster in4eb479db13,replacing the addr (16)byte with a pair of uint64 values:

The compiler liked that much more.

Take 5: a uint128 type

But why stop there? Being able to change the representation without affecting the API is too muchfun, so in 318330f177I replaced the uint64 pair with a new uint128 type, as Go doesn’t have a native one.

We’re now at:

But the compiler didn’t like that,so bf0e22f9f3broke it back down into:

And that’s basically where we’re at today.

We’re talking about breaking out the uint128 type into its own packagebut haven’t done so yet.

Other inet.af/netaddr fun

In addition to just IP addresses, inet.af/netaddr contains:

IPPort: a value type for an IP address and a port

IPPrefix: a value type for an IP address and a CIDR prefix (e.g. 192.168.0.1/16)

IPRange: a value type for range of IPs (e.g. 10.0.0.200-10.0.0.255)

IPSet: an efficient, immutable set of IP addresses, built with anIPSetBuilder.

As one contrived example, this code:

Outputs:

FAQ

Should you use netaddr.IP?

How To Find Ip Address On Computer

If you work with a lot of IP addresses and sets, ranges, andprefixes thereof, you’d probably benefit from using netaddr.IP overthe standard library’s types.

Is the API stable?

Mostly. We haven’t done a 1.0.0 yet and we might yet change a fewminor things, but it’spretty much done at this point.

What’s with the package name’s inet.af?

AF_INET, of course.

Was IPv6 worth it?

It is what it is.

This was too many words.

If you’d like this blog post in video form, my FOSDEM2021 talk, “Go atTailscale”discusses this starting at time 18:45.

Get New Ip Address Cox

Thanks

Get New Ip Address Free

Writing the inet.af/netaddr package was a fun collaborationwith@crawshaw,@danderson,@josharian,@mdlayher, and@tklauser.

0 notes