Mastering Prefix (CIDR) Operations in net/netip

This article delves into the net/netip package's Prefix type, a powerful tool for representing IP networks in CIDR notation. We'll explore its functionality, focusing on practical applications and best practices.

Understanding Prefix

The Prefix type simplifies working with IP address ranges using CIDR notation. Examples include:

• 192.168.1.0/24: Represents 256 IPv4 addresses (192.168.1.0 to 192.168.1.255).
• 2001:db8::/32: Represents a large IPv6 network.

Creating and Parsing Prefixes

Basic prefix creation and parsing:

<code class="language-go">package main

import (
    "fmt"
    "net/netip"
)

func main() {
    // Parse from CIDR string
    prefix, err := netip.ParsePrefix("192.168.1.0/24")
    if err != nil {
        panic(err)
    }

    // Create from Addr and bits
    addr := netip.MustParseAddr("192.168.1.0")
    prefix2 := netip.PrefixFrom(addr, 24)

    fmt.Printf("From string: %v\nFrom components: %v\n", prefix, prefix2)
}</code>

Key validation rules apply:

• Valid bit count (0-32 for IPv4, 0-128 for IPv6).
• Zeroed host portion of the address.
• Valid address.

Exploring Prefix Methods

Let's examine essential Prefix methods.

Basic Properties:

<code class="language-go">func explorePrefix(p netip.Prefix) {
    // Get the network address
    addr := p.Addr()
    fmt.Printf("Network address: %v\n", addr)

    // Get the prefix length (bits)
    bits := p.Bits()
    fmt.Printf("Prefix length: %d\n", bits)

    // Check if it's IPv4 or IPv6
    fmt.Printf("Is IPv4: %v\n", p.Addr().Is4())
    fmt.Printf("Is IPv6: %v\n", p.Addr().Is6())

    // Check if it represents a single IP
    fmt.Printf("Is single IP: %v\n", p.IsSingleIP())
}</code>

Network Operations: Containment and overlap checks are crucial:

<code class="language-go">func networkOperations() {
    network := netip.MustParsePrefix("192.168.1.0/24")

    // Check if an IP is in the network
    ip := netip.MustParseAddr("192.168.1.100")
    fmt.Printf("Contains IP? %v\n", network.Contains(ip))

    // Check if a smaller network is contained
    subnet := netip.MustParsePrefix("192.168.1.0/25")
    fmt.Printf("Contains subnet? %v\n", network.Contains(subnet.Addr()))

    // Check if networks overlap
    other := netip.MustParsePrefix("192.168.1.128/25")
    fmt.Printf("Overlaps? %v\n", network.Overlaps(other))
}</code>

Real-World Applications

Let's see Prefix in action.

1. IP Address Management (IPAM) System:

<code class="language-go">// ... (IPAM struct and methods omitted for brevity, refer to original article) ...</code>

2. Subnet Calculator:

<code class="language-go">// ... (SubnetInfo struct and AnalyzeSubnet function omitted for brevity, refer to original article) ...</code>

3. Firewall Rule Manager:

<code class="language-go">// ... (Action, Rule, Firewall structs and methods omitted for brevity, refer to original article) ...</code>

Advanced Operations: Subnet division and network aggregation are covered in the original article.

Best Practices

• Input Validation: Always validate CIDR input to prevent errors.
• IPv4/IPv6 Handling: Handle both address families correctly.
• Contains() for Membership: Use the Contains() method for efficient network membership checks.

The net/netip package's Prefix type significantly simplifies complex network operations. By understanding its capabilities and following best practices, you can build robust and efficient network-related applications.

The above is the detailed content of Mastering Prefix (CIDR) Operations in net/netip. For more information, please follow other related articles on the PHP Chinese website!