How to get the next IP address?

I'm considering to call net.IP.String(), strings.Split(ip, "."), some code to calculate all the corner cases and finally net.ParseIP(s). Is there a better way to this?. Below is the code of my current implementation (no special case handled).

package main

import (
	"fmt"
    "net"
	"strconv"
    "strings"
)

func main() {
	ip := net.ParseIP("127.1.0.0")
	next, err := NextIP(ip)
	if err != nil {
		panic(err)
	}
	fmt.Println(ip, next)
}

func NextIP(ip net.IP) (net.IP, error) {
	s := ip.String()
	sa := strings.Split(s, ".")
	i, err := strconv.Atoi(sa[2])
	if err != nil {
		return nil, err
	}
	i++
	sa[3] = strconv.Itoa(i)
	s = strings.Join(sa, ".")
	return net.ParseIP(s), nil
}

Just increment the last octet in the IP address

ip := net.ParseIP("127.1.0.0")
// make sure it's only 4 bytes
ip = ip.To4()
// check ip != nil
ip[3]++  // check for rollover
fmt.Println(ip)
//127.1.0.1

That however is technically incorrect, since the first address in the 127.1.0.1/8 subnet is 127.0.0.1. To get the true "first" address, you will also need an IPMask. Since you didn't specify one, you could use DefaultMask for IPv4 addresses (for IPv6 you can't assume a mask, and you must provide it).

http://play.golang.org/p/P_QWwRIBIm

ip := net.IP{192, 168, 1, 10}
ip = ip.To4()
if ip == nil {
	log.Fatal("non ipv4 address")
}

ip = ip.Mask(ip.DefaultMask())
ip[3]++

fmt.Println(ip)
//192.168.1.1

If all you need is to compute the next IP address, the function nextIP() below will do the trick.

Usage:

// output is 1.0.1.0
fmt.Println(nextIP(net.ParseIP("1.0.0.255"), 1))

nextIP():

func nextIP(ip net.IP, inc uint) net.IP {
	i := ip.To4()
	v := uint(i[0])<<24 + uint(i[1])<<16 + uint(i[2])<<8 + uint(i[3])
	v += inc
	v3 := byte(v & 0xFF)
	v2 := byte((v >> 8) & 0xFF)
	v1 := byte((v >> 16) & 0xFF)
	v0 := byte((v >> 24) & 0xFF)
	return net.IPv4(v0, v1, v2, v3)
}

Playground: https://play.golang.org/p/vHrmftkVjn2

Gist: https://gist.github.com/udhos/b468fbfd376aa0b655b6b0c539a88c03

I would test against CIDR after the IP has been incremented, so overflows don't change the expected subnet.

func incrementIP(origIP, cidr string) (string, error) {
	ip := net.ParseIP(origIP)
	_, ipNet, err := net.ParseCIDR(cidr)
	if err != nil {
		return origIP, err
	}
	for i := len(ip) - 1; i >= 0; i-- {
		ip[i]++
		if ip[i] != 0 {
			break
		}
	}
	if !ipNet.Contains(ip) {
		return origIP, errors.New("overflowed CIDR while incrementing IP")
	}
	return ip.String(), nil
}

This is straightforward using the IPAddress Go library, works for both IPv4 and IPv6, and handles corner cases. Disclaimer: I am the project manager.

import (
	"fmt"
	"github.com/seancfoley/ipaddress-go/ipaddr"
)

func main() {
	fmt.Println(increment("127.0.0.1"))
	fmt.Println(increment("127.0.0.255"))
	fmt.Println(increment("::1"))
	fmt.Println(increment("255.255.255.255"))
}

func increment(addrString string) *ipaddr.IPAddress {
	addr := ipaddr.NewIPAddressString(addrString).GetAddress()
	return addr.Increment(1)
}

Output:

127.0.0.2
127.0.1.0
::2
<nil>

I've encountered this problem just now, and I want to share my solution. It's not that efficient but solves the problem in a few lines.

func nextIP(ip net.IP) net.IP {
    // Convert to big.Int and increment
    ipb := big.NewInt(0).SetBytes([]byte(ip))
    ipb.Add(ipb, big.NewInt(1))

    // Add leading zeros
    b := ipb.Bytes()
    b = append(make([]byte, len(ip)-len(b)), b...)
    return net.IP(b)
}