getnetent#

Read the next entry from the networks database.

getnetent wraps the C library routine of the same name. It walks the system networks database (usually /etc/networks, sometimes augmented by NIS or other resolver backends) one record at a time, returning the next entry on each call. Pair it with setnetent to rewind or control the connection, and endnetent to close it.

Synopsis#

my ($name, $aliases, $addrtype, $net) = getnetent;
my $name                              = getnetent;   # scalar context

What you get back#

In list context, a four-element list:

$name — canonical network name (e.g. "loopback").
$aliases — space-separated string of alternative names.
$addrtype — address family, typically AF_INET (2).
$net — network number as an integer in host byte order. Convert to dotted form with Socket::inet_ntoa(pack("N", $net)).

In scalar context, just $name.

When the iterator is exhausted (no more records), list context returns the empty list and scalar context returns undef. A missing entry during a direct lookup returns a single meaningless true value per perlfunc convention, but since getnetent takes no key, the only terminal condition is “end of database.”

Global state it touches#

getnetent reads from a process-wide iterator maintained by the C library. Every call advances that iterator; there is no per-scope state, and concurrent iteration from two places in the same process will interleave records. setnetent rewinds it and optionally asks the library to keep the backing connection open for the duration of iteration; endnetent closes it.

Examples#

Walk the entire networks database:

setnetent(1);
while (my ($name, $aliases, $addrtype, $net) = getnetent) {
    printf "%-20s %s\n", $name, join(" ", split / /, $aliases);
}
endnetent();

Scalar context gives just the name — useful for a quick enumeration:

setnetent(1);
while (defined(my $name = getnetent)) {
    print "$name\n";
}
endnetent();

Decode the network number into dotted form:

use Socket;
setnetent(1);
while (my ($name, undef, undef, $net) = getnetent) {
    printf "%-20s %s\n", $name, inet_ntoa(pack "N", $net);
}
endnetent();

Object-oriented access through Net::netent — the by-name interface from the standard library replaces the positional return list with a blessed object:

use Net::netent;
while (my $n = getnetent()) {
    printf "%s => %d\n", $n->name, $n->net;
}

Edge cases#

Iterator exhaustion: list context returns (), scalar context returns undef. The loop forms above terminate naturally.
No setnetent before the loop: the first call implicitly opens the database. Calling setnetent(1) is still recommended — without the “stay open” flag, some C libraries reopen the file on every record and performance collapses.
Multiple concurrent walks: the iterator is process-global. Two loops over getnetent in the same process will split the records between them. Collect into an array first if both need the full set.
Unsupported on some platforms: Windows has no /etc/networks equivalent and the underlying C routine is absent. Attempting to call getnetent there raises The getnetent function is unimplemented. On Linux, glibc provides the function but the database is often empty — most systems rely on DNS instead, which this interface does not consult.
Thread safety: the C library’s iterator is not thread-safe. Perl may transparently substitute getnetent_r on systems that provide it, but do not assume this is universal. In a threaded program, serialise access through a single thread.
Tainting: when tainting is enabled, all four return fields are tainted — they come from a file (or a remote resolver) outside the program’s control.

Differences from upstream#

Fully compatible with upstream Perl 5.42.