On: Tool beeps every time data is sent to Google

[Eduard]

Huh, what is https://2899908462 ?

[jffry → Eduard]

It's an IPv4 address expressed as a 4-byte integer instead of four separate decimal octets. 172.217.23.110 is an IP belonging to Google.

172<<24 + 217<<16 + 23<<8 + 110 = 2899908462

[sgjohnson → jffry]

This is also why 1.1 === 1.0.0.1

Saves 4 whole keystrokes if you quickly want to ping something to test connectivity.

[jbverschoor → jffry]

In the 90s there was a campaign about the new worldwide 10-digit phone number format.

So if you own some 31.x block, you could have a phone number which matches your IP.

[gumby → jbverschoor]

Worldwide 10 digit format? News to me. Can you say more?

[jbverschoor → gumby]

There was a campaign that went something like "de hele wereld bellen, even tot tien bellen"

I think I'm wrong, it was about the 10-digit Dutch numbers.

https://www.youtube.com/watch?v=NfcD3RiB1EA

[csnover → gumby]

Probably UPT[0].

[0] https://en.wikipedia.org/wiki/Universal_Personal_Telecommuni...

[gumby → csnover]

Has it been implemented by any carriers?

The US phone system had such a service for a few years (area code 500 iirc). It had so little uptake that it was shut down.

[ratsmack → jffry]

I wrote this a number of years ago to accomplish same:

    #!/bin/ksh                                                                                                                                                                                                     
                                                                                                                                                                                                                   
    Die() {                                                                                                                                                                                                        
        echo Bad IP                                                                                                                                                                                                
        exit 1                                                                                                                                                                                                     
    }                                                                                                                                                                                                              
                                                                                                                                                                                                                   
    [ $# = 1 ] || Die                                                                                                                                                                                              
                                                                                                                                                                                                                   
    [ ${1%%?*.?*.?*.?*} ] && Die                                                                                                                                                                                   
                                                                                                                                                                                                                   
    I=$1                                                                                                                                                                                                           
                                                                                                                                                                                                                   
    until [ ${#I} = 0 ]                                                                                                                                                                                            
    do                                                                                                                                                                                                             
        J=${I#[0-9.]}                                                                                                                                                                                              
        [ ${#I} = ${#J} ] && Die                                                                                                                                                                                   
        I=$J                                                                                                                                                                                                       
    done                                                                                                                                                                                                           
                                                                                                                                                                                                                   
    I=$1.                                                                                                                                                                                                          
                                                                                                                                                                                                                   
    typeset -ui N=0                                                                                                                                                                                                
                                                                                                                                                                                                                   
    while [ $I ]                                                                                                                                                                                                   
    do                                                                                                                                                                                                             
        J=${I%%.*}                                                                                                                                                                                                 
        I=${I#$J.}                                                                                                                                                                                                 
        [ $((J>>8)) = 0 ] || Die                                                                                                                                                                                   
        N=$(( (N<<8) + J ))                                                                                                                                                                                        
    done                                                                                                                                                                                                           
                                                                                                                                                                                                                   
    echo $N                                                                                                                                                                                                        
                                                                                                                                                                                                                   
    # End

[kukx → Eduard]

https://stackoverflow.com/questions/56804936/how-does-only-n...

[teddyh → Eduard]

  man inet_aton

[…]

  int inet_aton(const char *cp, struct in_addr *inp)
  […]
  The address supplied in cp can have one of the following forms:
  […]
  a   The  value  a is interpreted as a 32-bit value that is stored
      directly into the binary address without any byte rearrangement.

https://manpages.debian.org/stable/manpages-dev/inet_aton.3....

[TrinaryWorksToo → Eduard]

A different format for writing ip addresses

[bqmjjx0kac → TrinaryWorksToo]

Why do you need a different format for writing IP addresses to circumvent the PiHole? Shouldn't a regular IP address literal skip the DNS lookup, too?

[stiray → bqmjjx0kac]

I used that notation for fun, as most of people are not aware of it, and based on comments quite a few people learned something new :)

And it is a regular ip address, just written differently :)

[Eduard → TrinaryWorksToo]

Ah okay, I got it: it's the decimal representation of the IP address.

https://www.lookip.net/ip/172.217.23.110

Funny I wasn't aware of this despite 25 years of being an Internet user

[blooalien → Eduard]

> "Funny I wasn't aware of this despite 25 years of being an Internet user"

You're not alone… I been using the Internet longer'n that and I didn't ever think of converting an IP address to a decimal number either. It makes perfect sense now that it's been pointed out, but for some reason it just never crossed my mind to even try it.

[simonh → blooalien]

To be fair, there are many different bases. I wonder if there’s anything special about base 10 that made them support it.

[mlyle → simonh]

IPv4 addresses are written in base 10 for human users.

The "special" case is supporting network addresses to be written as 10.2932832 ("convenient" for class A's), 172.16.61031 (ditto for B's), or just one big address like 39282329, when we're used to 4 octets separated by dots.

Not every bit of host software supports these cases anymore, as basically their sole remaining use case is as a curiosity or to circumvent bad security controls.

[simonh → mlyle]

Bah, humans!