IP address conversion: conversion between numbers and strings

There are generally two formats for storing IP addresses in the IP address database, one is dotted decimal format (192.168.1.1), and the other is digital format (3232235777). In applications, it is often necessary to convert between these two formats.

[[260382]]

To solve this problem, I implemented a quick method for converting between the two in the exnet extension package:

• func IP2Long(ip net.IP) (uint, error) IP2Long converts net.IP to a numeric value
• func Long2IP(i uint) (net.IP, error) Long2IP converts the value to net.IP
• func IPString2Long(ip string) (uint, error) IPString2Long converts the ip string to a numeric value
• func Long2IPString(i uint) (string, error) Long2IPString converts the value to an IP string

Example of use:

 package main 
 
 import (
 "fmt"  
 "net"  
 "reflect"   
 
 "github.com/thinkeridea/go-extend/exnet"  
 ) 
 
 func main() {
 ip := "192.168.1.1"   
 
    n, _ := exnet.IPString2Long(ip)
    s, _ := exnet.Long2IPString(n) 
 
 fmt.Println(n, s == ip) 
 
 Ip1 := net.ParseIP(ip) // You will get a 16-byte byte, mainly for compatibility with ipv6
 n, _ = exnet.IP2Long(Ip1) 
 
    Ip2, _ := exnet.Long2IP(n) 
 
    fmt.Println(n, reflect.DeepEqual(Ip1[12:], Ip2))
 }

So how do you convert a dotted decimal IP address into a number?

An IPv4 address has 4 bytes and looks like this:

• MSB————–LSB
• b4 b3 b2 b1

Each byte represents the range:

• byte4: 4294967296 (1<<32)
• byte3: 16777216(1<<24)
• byte2: 65536(1<<16)
• byte1: 256(1<<8)

General formula: b4<<24 | b3<<16 | b2<<16 | b1

For example, 222.173.108.86

Conversion method: 222<<24 | 173<<16 | 108<<8 | 86 = 3735907414

For example, 1.0.1.1

Conversion method: 1<<24 | 0<<16 | 1<<8 | 1 = 16777473

The implementation in exnet is as follows:

 // IPString2Long converts the IP string into a numerical value
 func IPString2Long(ip string) (uint, error) {
    b := net.ParseIP(ip).To4()
 if b == nil {
 return 0, errors.New( "invalid ipv4 format" )
 } 
 
 return uint(b[3]) | uint(b[2])<<8 | uint(b[1])<<16 | uint(b[0])<<24, nil
 }

Just flip the logic of converting a numeric value to a string. This is implemented in exnet as follows:

 // Long2IPString converts the value to an IP string
 func Long2IPString(i uint) (string, error) {
 if i > math.MaxUint32 {
 return   "" , errors.New( "beyond the scope of ipv4" )
 } 
 
    ip := make(net.IP, net.IPv4len)
 ip[0] = byte(i >> 24)
 ip[1] = byte(i >> 16)
 ip[2] = byte(i >> 8)
 ip[3] = byte(i) 
 
 return ip.String(), nil
 }