feat(network): inet_pton()/inet_ntop() cover IPv6, the family they always claimed

[Guikingone]

Fixes #692.

inet_pton('127.0.0.1');            // PHP: 4 bytes   elephc: 4 bytes
inet_pton('2001:4860:4860::8888'); // PHP: 16 bytes  elephc: false

The helper was a dotted-quad parser wearing the builtin's name: its own header said
"Parses a dotted-quad IPv4 string", and every IPv6 address came back false. A program
validating a proxy-provided client address rejected half the internet.

The parsing is the platform's

inet_pton(3) and inet_ntop(3) are in libc on every target this compiler emits for, and
they are where PHP's own implementation goes. Reproducing them by hand would mean
reimplementing :: compression, the embedded-IPv4 form and the canonical-spelling rules —
twice, once per architecture, and wrong in a different way on each.

So the helpers materialize the arguments and call them. __rt_inet_pton copies its borrowed
bytes into a NUL-terminated stack buffer (the C parser needs one; PHP strings are
pointer+length) and parses into reserved scratch. __rt_inet_ntop renders into a stack
buffer and copies the result out.

The family is chosen the way php-src chooses it: a : anywhere in the text selects
AF_INET6, and on the way back the packed length does — 4 or 16, anything else false.

The IPv4 paths stay where they were

__rt_inet_ntop still renders a 4-byte address by packing the octets and tail-calling
__rt_long2ip, with no C call. That path was never wrong, and it is the common one.

AF_INET6 is the TARGET's

Darwin spells it 30 and Linux 10. Handing inet_pton(3) the wrong one makes it answer
EAFNOSUPPORT for every IPv6 address — reported as false here — so a cross-compiled binary
would reject addresses the same source accepts natively, and no host-run test would see it.
Both helpers carry emitter tests that pin the constant per target, iOS and the iOS simulator
included.

Three things the first cut got wrong, all Linux-visible

Review caught all three, and none of them reproduces on an ARM64 macOS host — which is the
shape of all three.

• The x86_64 IPv4 address never reached long2ip. The rewrite dropped mov rdi, rax
  before the tail jump, so the callee read the caller's packed-string pointer as an IPv4
  integer and rendered an unrelated address on every x86_64 target. Restored, and the IPv4
  emitter test now asserts the move as well as the jump.
• Zone identifiers were a macOS promise sold as a portable one. inet_pton(3) takes
  fe80::1%eth0 on Darwin and refuses it on glibc — measured both ways. PHP has the same
  split, for the same reason, so elephc's behaviour was right and its claim was wrong. The
  portable fixtures, the docs and the example no longer assert the macOS answer; the docs state
  the divergence as the inherited libc behaviour it is.
• Both helpers wrote past the scratch buffer. They took their destination straight from
  _concat_buf + _concat_off, as the IPv4-only version did for its four bytes; sixteen bytes
  of packed address, or up to 45 of rendering, run off the end of the 64 KiB buffer once an
  earlier result has pushed the cursor near it. Both now reserve through
  __rt_concat_reserve and publish through __rt_concat_publish, which brings the heap
  fallback with it. A unit test per helper asserts both calls are present and that
  _concat_off is never named directly.

Verified

Against host PHP 8.5.10, byte-identical across the shapes that are portable: the issue's own
reproducer; ::1, ::, the expanded and compressed spellings of the same address, ::ffff:
mapped addresses; the IPv4 family and its invalid inputs (256.0.0.1, 1.2.3, empty); IPv6
inputs that must stay invalid (1:2:3:4:5:6:7:8:9, gggg::1); and round trips through both
helpers, including the canonical spelling inet_ntop() picks when several are possible.

Both helpers write into the shared concat buffer, so a fixture keeps three packed addresses
alive at once, puts calls inside a concatenation that is also writing there, and runs 50 round
trips in a loop.

The five codegen tests were confirmed load-bearing by reverting both helpers: four fail, and
the fifth is the IPv4 guard, which is meant to pass either way.

cargo test --test codegen_tests -- codegen::strings passes in full (357), as do 1922 unit
tests and 1542 error tests.

One deliberate divergence

The copy into the NUL-terminated buffer bounds the input at 255 bytes; anything longer is
false without being parsed. Reference PHP has no bound. That bound cannot be isolated
portably — the only longer inputs any platform would otherwise parse carry a zone identifier —
so what the fixture pins is the observable contract: long junk is false, and the refusal
leaves nothing behind for the calls after it.

Docs and example

docs/php/strings.md states both families, the spellings accepted everywhere, what rendering
canonicalizes, the zone-identifier split, and the input bound.

docs/internals/the-runtime.md records which half is hand-written and which is libc, how the
family is chosen, why AF_INET6 is pinned per target, and that both destinations are reserved
rather than taken from the cursor.

examples/ip-conversion/main.php packs and renders IPv6 beside the IPv4 it already had: the
byte length that distinguishes the families, the canonical spelling, an IPv4-mapped address,
and the false cases. Its output is verbatim host PHP 8.5.10.

🤖 Generated with Claude Code

https://claude.ai/code/session_01KSAAWPyNBq6dP2b5puN3wr

[greptile-apps]

Confidence Score: 5/5

The PR appears safe to merge; all previous findings are resolved and no new actionable defects remain.

Summary

This PR extends inet_pton() and inet_ntop() from IPv4-only behavior to IPv4 and IPv6 while preserving target-specific ABI and libc behavior.

• Delegates IPv6 parsing and rendering to the target platform’s inet_pton(3) and inet_ntop(3).
• Uses target-specific AF_INET6 constants across Darwin and Linux targets.
• Reserves and publishes concat-buffer storage safely, including cleanup after failed parsing.
• Adds cross-target emitter tests, end-to-end address fixtures, diagnostic tests, documentation, and an updated example.

Diagram

%%{init: {'theme': 'neutral'}}%%
flowchart TD
  A[PHP inet_pton text] --> B{Contains colon?}
  B -->|No| C[AF_INET / 4-byte reservation]
  B -->|Yes| D[Target AF_INET6 / 16-byte reservation]
  C --> E[libc inet_pton]
  D --> E
  E -->|Success| F[Publish packed bytes]
  E -->|Failure| G[Release unpublished reservation]
  H[PHP inet_ntop packed bytes] --> I{Packed length}
  I -->|4 bytes| J[Existing long2ip path]
  I -->|16 bytes| K[libc inet_ntop]
  I -->|Other| L[Return false]
  K --> M[Reserve and publish rendered text]

Loading

_{Reviews (4) · Last reviewed commit: "fix(network): release an inet_pton() res..."}