A link-local address is indeed an IP address used for communication within a single network segment (layer 2 domain). For IPv4, these addresses fall within the 169.254.0.0/16 range (from 169.254.0.0 to 169.254.255.255), not just the specific 169.254.1.0 you mentioned. This automatic configuration is specified in RFC 3927.

The process you described is mostly correct - this is called IPv4 Link-Local Address Autoconfiguration. Here's the detailed sequence:

1. The host randomly selects an address from 169.254.1.0 to 169.254.254.255
2. It performs ARP probes to check for address conflicts
3. If no response after 3 probes, the address is assigned
4. If conflicts occur, the process repeats (max 10 attempts)

Here's how to check link-local addresses programmatically in different languages:

# Python example
import socket
import netifaces

def get_link_local():
    for interface in netifaces.interfaces():
        addrs = netifaces.ifaddresses(interface)
        if netifaces.AF_INET in addrs:
            for addr_info in addrs[netifaces.AF_INET]:
                if addr_info['addr'].startswith('169.254.'):
                    print(f"Interface {interface}: {addr_info['addr']}")

get_link_local()

# Bash example
ip -4 addr show | grep "inet 169\.254\."

• When DHCP servers are unavailable
• In ad-hoc peer-to-peer networks
• For device discovery protocols
• In IoT device provisioning

For Linux systems, you can manually configure a link-local address:

sudo ip addr add 169.254.100.1/16 dev eth0
sudo ip link set eth0 up

Or via /etc/network/interfaces:

auto eth0
iface eth0 inet static
    address 169.254.100.1
    netmask 255.255.0.0

A link-local address is an IP address that is valid only for communications within a specific network segment (link). Unlike globally routable IP addresses, these are not assigned by a DHCP server or manually configured, but rather auto-assigned by devices when no other addressing method is available.

For IPv4, the range is strictly 169.254.0.0/16 (from 169.254.0.1 to 169.254.255.254), not just the single 169.254.1.0 subnet you mentioned. The first and last addresses in this range (169.254.0.0 and 169.254.255.255) are reserved.

In IPv6, all addresses starting with fe80::/10 are link-local. Here's a comparison:

// IPv4 Link-Local
169.254.x.x (where x ≠ 0 or 255 in last two octets)

// IPv6 Link-Local
fe80::/10 prefix (typically fe80:: followed by interface identifier)

Your understanding is correct regarding the auto-assignment process, which is called Automatic Private IP Addressing (APIPA) in Windows or IPv4 Link-Local Addressing in RFC 3927. The exact sequence:

1. Device fails to obtain address via DHCP
2. Randomly selects address from 169.254.1.0 to 169.254.254.255
3. Performs ARP probe to check for conflicts
4. If no response, assigns the address to itself

Here's how to check for link-local addresses in different languages:

Python Implementation

import socket
import ipaddress

def is_link_local(ip_str):
    try:
        ip = ipaddress.ip_address(ip_str)
        if ip.version == 4:
            return ip.is_link_local
        elif ip.version == 6:
            return ip.is_link_local
    except ValueError:
        return False

print(is_link_local("169.254.12.34"))  # True
print(is_link_local("fe80::1"))        # True
print(is_link_local("192.168.1.1"))    # False

Bash Example

# List all link-local IPv4 addresses
ip -4 addr show | grep "inet 169\.254"

# List IPv6 link-local addresses
ip -6 addr show | grep "inet6 fe80"

• Device-to-device communication without router
• Fallback when DHCP fails
• Network interface initialization
• Zero-configuration networking (Zeroconf)

When seeing link-local addresses:

• Check DHCP server availability
• Verify network connectivity
• For IPv6, remember these are required addresses (each interface must have one)
• Windows machines will show "Autoconfiguration IPv4 Address" in ipconfig