. "$BST_LIB"

# libmnl 1.0.5 (BRINTOS-1852) -- the minimalistic user-space Netlink library:
# a message builder (mnl_nlmsg_*), a TLV attribute builder and parser
# (mnl_attr_*), a batching helper, two callback runners, and a thin socket
# wrapper.
#
# THE ARCHIVE WAS ALREADY ON THIS IMAGE AND THE HEADER WAS NOT. libmnl is built
# here for libnftnl and the libnetfilter_* family, and libmnl-staticdev reached
# IMAGE_INSTALL through the -l name-closure sweep rather than through a port --
# so /usr/lib/libmnl.a shipped while /usr/include/libmnl/libmnl.h did not, and
# nothing measured either. This port adds libmnl-dev and this suite. The recipe
# is poky's own and takes no bbappend, no patch and no site answer.
#
# ---------------------------------------------------------------------------
# WHAT IS COVERED, AND WHAT IS DELIBERATELY NOT
#
# The BUILDER AND PARSER are covered, through data/libmnl-probe (source in
# src/libmnl_probe.c), cross-linked with wasmcc-glibc against THE VERY ARCHIVE
# THAT SHIPS. BRINTOS-217 is why a payload-shape suite is not enough: oniguruma
# compiled and packaged perfectly on this arm and then returned silently wrong
# offsets to every caller. libmnl is the same shape of risk and smaller -- its
# entire body is MNL_ALIGN arithmetic over size_t and a walk that advances a
# `struct nlattr *` by a byte count and compares it against a tail pointer
# derived by char* arithmetic. On a 32-bit target that is exactly where a
# pointer-as-offset confusion corrupts a parse rather than trapping.
#
# The SOCKET half is not covered, and its absence is a platform fact rather than
# an omission:
#
#   - mnl_socket_open(NETLINK_NETFILTER) answers EPROTONOSUPPORT on this image.
#     wasm32_defconfig sets CONFIG_NET=y with no CONFIG_NETFILTER at all, so
#     netlink protocol 12 is never registered (brintos/linux#86, the gap
#     libnfnetlink and the two libnetfilter_* ports are held by).
#   - Worse, a consumer that RECEIVES cannot even be LINKED here.
#     MNL_SOCKET_BUFFER_SIZE is a sysconf(3) expression, so the idiomatic
#     `char buf[MNL_SOCKET_BUFFER_SIZE]` is a variable-length array whose
#     address escapes to recvfrom(2), and the HWJS-3 coroutinize pass refuses
#     that class outright (linux-in-the-browser#178 -- the refusal that keeps
#     xtables-nft-multi out of the iptables port, and that nftables carries a
#     patch for).
#
# So the socket functions are asserted PRESENT IN THE ARCHIVE below and never
# called. The probe uses MNL_SOCKET_DUMP_SIZE -- a plain 32768 constant, not a
# sysconf expression -- and touches no descriptor, which is why it links with
# zero coro refusals. That is a statement about the probe's shape and NOT a
# claim that #178 is fixed.
#
# ---------------------------------------------------------------------------
# EVERY EXPECTED VALUE IS THE VALUE A NATIVE x86_64 BUILD OF THE IDENTICAL
# RELEASE PRODUCES. The probe compares internally and prints its own verdict;
# the cases below assert the verdict and the console carries the detail. The
# native control scored 166/166, and it corrected five assertions of mine before
# it did -- each one a plausible reading of the API that the library does not
# hold to:
#
#   - a wrong-LENGTH validation is ERANGE, not EINVAL; EINVAL is reserved for a
#     string that is present but unterminated;
#   - mnl_attr_validate2's exp_len is an EXACT length, not a floor -- a payload
#     LONGER than exp_len is refused too;
#   - mnl_attr_type_valid returns 1 on success, the one function here whose
#     success value is not zero;
#   - mnl_cb_run reports a wrong port id as ESRCH and only a stale sequence as
#     EPROTO;
#   - mnl_nlmsg_batch_start's buffer must be LARGER than its limit, because
#     batch_next lets the overflowing message be built in place before saying it
#     does not fit. Sizing them equally overran the buffer and the control run
#     aborted on the stack guard.
#
# WHY BUILTIN MATCHING INSTEAD OF check_out. The probe runs ONCE and the payload
# files are read ONCE into shell variables; every assertion is a `case` glob
# against them, so there is no fork per case. On this runtime the forking is the
# cost rather than the work -- the cjson suite next door was killed by the
# runner's per-suite bound at 156 check_out cases.
# ---------------------------------------------------------------------------

incd=/usr/include/libmnl
lib=/usr/lib/libmnl.a
pc=/usr/lib/pkgconfig/libmnl.pc

nl='
'

# hasfile <id> <path>          -- ok iff <path> is a non-empty regular file.
# has     <id> <needle> <text> -- ok iff <text> contains the literal <needle>.
# hasline <id> <name> <list>   -- ok iff <list> carries <name> as a WHOLE line,
#                                 so mnl_attr_get_u32 cannot satisfy a lookup
#                                 for mnl_attr_get_u3 and mnl_nlmsg_batch_stop
#                                 cannot satisfy one for mnl_nlmsg_batch_sto.
hasfile() { if [ -s "$2" ]; then bst_ok "$1"; else bst_notok "$1" "absent or empty: $2"; fi; }
has()     { case "$3" in *"$2"*) bst_ok "$1" ;; *) bst_notok "$1" "not found: $2" ;; esac; }
hasline() { case "$nl$3$nl" in *"$nl$2$nl"*) bst_ok "$1" ;; *) bst_notok "$1" "not in archive: $2" ;; esac; }

# --- the shipped payload -----------------------------------------------------
hasfile libmnl/header    "$incd/libmnl.h"
hasfile libmnl/archive   "$lib"
hasfile libmnl/pkgconfig "$pc"

# There is deliberately no libmnl/no-shared-object case: shared objects are
# refused distro-wide on this arm, so an absent libmnl.so is the distro's
# property and not this port's.

pctext=$(cat "$pc" 2>/dev/null)
has libmnl/pc-name    "Name: libmnl" "$pctext"
has libmnl/pc-version "Version: 1.0.5" "$pctext"
has libmnl/pc-libs    "-lmnl" "$pctext"
has libmnl/pc-cflags  "-I\${includedir}" "$pctext"

# The header's own constants, which are the numbers every offset in this library
# is computed from. A header/archive skew shows up here before anything runs.
hdrtext=$(cat "$incd/libmnl.h" 2>/dev/null)
has libmnl/hdr-alignto     "#define MNL_ALIGNTO		4" "$hdrtext"
has libmnl/hdr-dump-size   "#define MNL_SOCKET_DUMP_SIZE	32768" "$hdrtext"
has libmnl/hdr-autopid     "#define MNL_SOCKET_AUTOPID	0" "$hdrtext"
has libmnl/hdr-cb-error    "#define MNL_CB_ERROR		-1" "$hdrtext"
has libmnl/hdr-cb-stop     "#define MNL_CB_STOP		 0" "$hdrtext"
has libmnl/hdr-cb-ok       "#define MNL_CB_OK		 1" "$hdrtext"
has libmnl/hdr-attr-types  "MNL_TYPE_NUL_STRING" "$hdrtext"
has libmnl/hdr-for-each    "define mnl_attr_for_each(" "$hdrtext"
# MNL_SOCKET_BUFFER_SIZE is the sysconf(3) expression behind #178. Asserting it
# is still in the header is how this suite would notice a local redefinition
# being slipped in as a fix -- the port does not do that, and the record should
# say so out of the shipped artifact rather than out of a commit message.
has libmnl/hdr-buffer-size-is-sysconf "sysconf(_SC_PAGESIZE)" "$hdrtext"

# --- symbol completeness, tracked from the INSTALLED header ------------------
# Every function the installed header declares must be present in the installed
# archive, so a partial compile, a visibility mistake or a header/library skew
# all fail this. The list is derived from the header rather than written here,
# so it survives a version bump; two pipelines are the only forks.
arcsyms=$(grep -ao 'mnl_[a-z0-9_]*' "$lib" 2>/dev/null | sort -u)
hdrsyms=$(grep -oE '\bmnl_[a-z0-9_]*\(' "$incd/libmnl.h" 2>/dev/null \
          | sed 's/(//' | sort -u)

nsym=0
nmiss=0
missing=""
for f in $hdrsyms; do
  # The four mnl_attr_for_each* names are MACROS defined in the header, not
  # archive symbols, and are excluded by construction rather than to make this
  # pass -- they expand at the call site and upstream's src/libmnl.map does not
  # list them either.
  case "$f" in
    mnl_attr_for_each|mnl_attr_for_each_nested|mnl_attr_for_each_payload) continue ;;
  esac
  nsym=$((nsym + 1))
  case "$nl$arcsyms$nl" in
    *"$nl$f$nl"*) ;;
    *) nmiss=$((nmiss + 1)); missing="$missing $f" ;;
  esac
done
if [ "$nmiss" -eq 0 ]; then
  bst_ok libmnl/symbols-complete
else
  bst_notok libmnl/symbols-complete "$nmiss missing:$missing"
fi
check_eq libmnl/symbols-count 68 "$nsym"

# A spot-check that the derivation above is really reading the archive and not
# an empty string that would make the loop vacuously green.
hasline libmnl/sym-nlmsg-put-header mnl_nlmsg_put_header "$arcsyms"
hasline libmnl/sym-attr-put-u32     mnl_attr_put_u32     "$arcsyms"
hasline libmnl/sym-attr-validate2   mnl_attr_validate2   "$arcsyms"
hasline libmnl/sym-cb-run2          mnl_cb_run2          "$arcsyms"
hasline libmnl/sym-nlmsg-batch-stop mnl_nlmsg_batch_stop "$arcsyms"

# The socket half SHIPS even though nothing on this image can use it (see the
# header note). These five say the archive is whole -- a build that quietly
# dropped socket.c because nothing linked it would be a different library from
# the one the recipe claims to install, and only these cases would notice.
hasline libmnl/sym-socket-open        mnl_socket_open        "$arcsyms"
hasline libmnl/sym-socket-bind        mnl_socket_bind        "$arcsyms"
hasline libmnl/sym-socket-sendto      mnl_socket_sendto      "$arcsyms"
hasline libmnl/sym-socket-recvfrom    mnl_socket_recvfrom    "$arcsyms"
hasline libmnl/sym-socket-get-portid  mnl_socket_get_portid  "$arcsyms"

# --- the library RUNNING, via the cross-linked probe -------------------------
probe=${TMPDIR:-/tmp}/bst-libmnl-probe.$$
if cp "$BST_DATA/libmnl-probe" "$probe" 2>/dev/null && chmod +x "$probe" 2>/dev/null; then
  out=$("$probe" 2>&1); prc=$?


  # sizes and offsets: on wasm32 size_t is 32 bits and the control is
  # 64, so MNL_ALIGN arithmetic is where the two can differ without crashing
  has libmnl/run-align-nlmsghdr-size "MNL-align-nlmsghdr-size OK" "$out"
  has libmnl/run-align-nlattr-size "MNL-align-nlattr-size OK" "$out"
  has libmnl/run-align-hdrlen "MNL-align-hdrlen OK" "$out"
  has libmnl/run-align-attr-hdrlen "MNL-align-attr-hdrlen OK" "$out"
  has libmnl/run-align-to "MNL-align-to OK" "$out"
  has libmnl/run-align-round-0 "MNL-align-round-0 OK" "$out"
  has libmnl/run-align-round-1 "MNL-align-round-1 OK" "$out"
  has libmnl/run-align-round-3 "MNL-align-round-3 OK" "$out"
  has libmnl/run-align-round-4 "MNL-align-round-4 OK" "$out"
  has libmnl/run-align-round-5 "MNL-align-round-5 OK" "$out"
  has libmnl/run-align-round-13 "MNL-align-round-13 OK" "$out"
  has libmnl/run-align-nlmsg-size-0 "MNL-align-nlmsg-size-0 OK" "$out"
  has libmnl/run-align-nlmsg-size-1 "MNL-align-nlmsg-size-1 OK" "$out"
  has libmnl/run-align-nlmsg-size-4 "MNL-align-nlmsg-size-4 OK" "$out"

  # the message and attribute builders, and the lengths they write
  has libmnl/run-put-header-at-buf "MNL-put-header-at-buf OK" "$out"
  has libmnl/run-put-header-len "MNL-put-header-len OK" "$out"
  has libmnl/run-put-header-type-zeroed "MNL-put-header-type-zeroed OK" "$out"
  has libmnl/run-put-header-flags-zeroed "MNL-put-header-flags-zeroed OK" "$out"
  has libmnl/run-put-header-seq-zeroed "MNL-put-header-seq-zeroed OK" "$out"
  has libmnl/run-put-header-pid-zeroed "MNL-put-header-pid-zeroed OK" "$out"
  has libmnl/run-put-header-payload-len-0 "MNL-put-header-payload-len-0 OK" "$out"
  has libmnl/run-put-header-payload-ptr "MNL-put-header-payload-ptr OK" "$out"
  has libmnl/run-put-header-tail-is-payload "MNL-put-header-tail-is-payload OK" "$out"
  has libmnl/run-put-extra-ptr "MNL-put-extra-ptr OK" "$out"
  has libmnl/run-put-extra-len "MNL-put-extra-len OK" "$out"
  has libmnl/run-put-extra-zeroed "MNL-put-extra-zeroed OK" "$out"
  has libmnl/run-put-extra-offset "MNL-put-extra-offset OK" "$out"
  has libmnl/run-put-total-len "MNL-put-total-len OK" "$out"
  has libmnl/run-put-payload-len "MNL-put-payload-len OK" "$out"

  # the values read back out, including the 64-bit one assembled from
  # two 32-bit halves on this arm
  has libmnl/run-get-u8-type "MNL-get-u8-type OK" "$out"
  has libmnl/run-get-u8-len "MNL-get-u8-len OK" "$out"
  has libmnl/run-get-u8-payload-len "MNL-get-u8-payload-len OK" "$out"
  has libmnl/run-get-u8-value "MNL-get-u8-value OK" "$out"
  has libmnl/run-get-u8-payload-ptr "MNL-get-u8-payload-ptr OK" "$out"
  has libmnl/run-get-u16-type "MNL-get-u16-type OK" "$out"
  has libmnl/run-get-u16-len "MNL-get-u16-len OK" "$out"
  has libmnl/run-get-u16-value "MNL-get-u16-value OK" "$out"
  has libmnl/run-get-u32-type "MNL-get-u32-type OK" "$out"
  has libmnl/run-get-u32-len "MNL-get-u32-len OK" "$out"
  has libmnl/run-get-u32-value "MNL-get-u32-value OK" "$out"
  has libmnl/run-get-u64-type "MNL-get-u64-type OK" "$out"
  has libmnl/run-get-u64-len "MNL-get-u64-len OK" "$out"
  has libmnl/run-get-u64-value "MNL-get-u64-value OK" "$out"
  has libmnl/run-get-strz-type "MNL-get-strz-type OK" "$out"
  has libmnl/run-get-strz-len "MNL-get-strz-len OK" "$out"
  has libmnl/run-get-strz-value "MNL-get-strz-value OK" "$out"
  has libmnl/run-put-str-unterminated-len "MNL-put-str-unterminated-len OK" "$out"
  has libmnl/run-put-strz-terminated-len "MNL-put-strz-terminated-len OK" "$out"
  has libmnl/run-put-blob-attr-len "MNL-put-blob-attr-len OK" "$out"
  has libmnl/run-put-blob-msg-len "MNL-put-blob-msg-len OK" "$out"
  has libmnl/run-put-blob-payload "MNL-put-blob-payload OK" "$out"

  # mnl_attr_for_each: the loop every consumer writes
  has libmnl/run-walk-count "MNL-walk-count OK" "$out"
  has libmnl/run-walk-order "MNL-walk-order OK" "$out"
  has libmnl/run-walk-offset-count "MNL-walk-offset-count OK" "$out"
  has libmnl/run-walk-empty "MNL-walk-empty OK" "$out"
  has libmnl/run-walk-raw-count "MNL-walk-raw-count OK" "$out"

  # the refusals. A guard that says `true` for any of these is a silent
  # out-of-bounds read in every consumer
  has libmnl/run-trunc-ok-whole "MNL-trunc-ok-whole OK" "$out"
  has libmnl/run-trunc-ok-extra "MNL-trunc-ok-extra OK" "$out"
  has libmnl/run-trunc-one-short "MNL-trunc-one-short OK" "$out"
  has libmnl/run-trunc-header-short "MNL-trunc-header-short OK" "$out"
  has libmnl/run-trunc-zero "MNL-trunc-zero OK" "$out"
  has libmnl/run-trunc-negative "MNL-trunc-negative OK" "$out"
  has libmnl/run-trunc-len-under-hdrlen "MNL-trunc-len-under-hdrlen OK" "$out"
  has libmnl/run-trunc-len-over-buffer "MNL-trunc-len-over-buffer OK" "$out"
  has libmnl/run-trunc-attr-ok "MNL-trunc-attr-ok OK" "$out"
  has libmnl/run-trunc-attr-short "MNL-trunc-attr-short OK" "$out"
  has libmnl/run-trunc-attr-len-over "MNL-trunc-attr-len-over OK" "$out"

  # mnl_attr_validate/validate2, rc AND errno -- a caller that logs the
  # errno cannot tell the failures apart unless each is what it claims
  has libmnl/run-validate-u8 "MNL-validate-u8 OK" "$out"
  has libmnl/run-validate-u16 "MNL-validate-u16 OK" "$out"
  has libmnl/run-validate-u32 "MNL-validate-u32 OK" "$out"
  has libmnl/run-validate-u64 "MNL-validate-u64 OK" "$out"
  has libmnl/run-validate-strz-string "MNL-validate-strz-string OK" "$out"
  has libmnl/run-validate-strz-nulstring "MNL-validate-strz-nulstring OK" "$out"
  has libmnl/run-validate-u8-as-u32-rc "MNL-validate-u8-as-u32-rc OK" "$out"
  has libmnl/run-validate-u8-as-u32-errno "MNL-validate-u8-as-u32-errno OK" "$out"
  has libmnl/run-validate-u32-as-u64-rc "MNL-validate-u32-as-u64-rc OK" "$out"
  has libmnl/run-validate-u32-as-u64-errno "MNL-validate-u32-as-u64-errno OK" "$out"
  has libmnl/run-validate-u64-as-u8 "MNL-validate-u64-as-u8 OK" "$out"
  has libmnl/run-validate-u32-as-flag "MNL-validate-u32-as-flag OK" "$out"
  has libmnl/run-validate-u64-as-msecs "MNL-validate-u64-as-msecs OK" "$out"
  has libmnl/run-validate-any-as-binary "MNL-validate-any-as-binary OK" "$out"
  has libmnl/run-validate-unterminated-rc "MNL-validate-unterminated-rc OK" "$out"
  has libmnl/run-validate-unterminated-errno "MNL-validate-unterminated-errno OK" "$out"
  has libmnl/run-validate-unterminated-as-string "MNL-validate-unterminated-as-string OK" "$out"
  has libmnl/run-validate-empty-string-rc "MNL-validate-empty-string-rc OK" "$out"
  has libmnl/run-validate-empty-string-errno "MNL-validate-empty-string-errno OK" "$out"

  # exp_len is an EXACT length, not a floor
  has libmnl/run-validate2-exact "MNL-validate2-exact OK" "$out"
  has libmnl/run-validate2-longer-rc "MNL-validate2-longer-rc OK" "$out"
  has libmnl/run-validate2-longer-errno "MNL-validate2-longer-errno OK" "$out"
  has libmnl/run-validate2-short-rc "MNL-validate2-short-rc OK" "$out"
  has libmnl/run-validate2-short-errno "MNL-validate2-short-errno OK" "$out"

  # mnl_attr_type_valid, whose success value is 1 and not 0
  has libmnl/run-type-valid-in-range "MNL-type-valid-in-range OK" "$out"
  has libmnl/run-type-valid-over-max-rc "MNL-type-valid-over-max-rc OK" "$out"
  has libmnl/run-type-valid-over-max-errno "MNL-type-valid-over-max-errno OK" "$out"

  # nest_start/end writes a length back through a saved pointer that
  # other puts have grown the buffer past in the meantime
  has libmnl/run-nest-flag-set "MNL-nest-flag-set OK" "$out"
  has libmnl/run-nest-type "MNL-nest-type OK" "$out"
  has libmnl/run-nest-len "MNL-nest-len OK" "$out"
  has libmnl/run-nest-validate "MNL-nest-validate OK" "$out"
  has libmnl/run-nest-inner-count "MNL-nest-inner-count OK" "$out"
  has libmnl/run-nest-outer-count "MNL-nest-outer-count OK" "$out"
  has libmnl/run-nest-first-inner "MNL-nest-first-inner OK" "$out"
  has libmnl/run-nest-cancel-restores-len "MNL-nest-cancel-restores-len OK" "$out"
  has libmnl/run-nest-cancel-count "MNL-nest-cancel-count OK" "$out"

  # the _check twins. One that returns true here writes past the end of
  # the caller's buffer, which is the worst thing this library can do
  has libmnl/run-check-u32-fits "MNL-check-u32-fits OK" "$out"
  has libmnl/run-check-u64-fits "MNL-check-u64-fits OK" "$out"
  has libmnl/run-check-strz-fits "MNL-check-strz-fits OK" "$out"
  has libmnl/run-check-blob-refused "MNL-check-blob-refused OK" "$out"
  has libmnl/run-check-refused-len-unchanged "MNL-check-refused-len-unchanged OK" "$out"
  has libmnl/run-check-u8-refused "MNL-check-u8-refused OK" "$out"
  has libmnl/run-check-u16-refused "MNL-check-u16-refused OK" "$out"
  has libmnl/run-check-str-refused "MNL-check-str-refused OK" "$out"
  has libmnl/run-check-nest-refused "MNL-check-nest-refused OK" "$out"
  has libmnl/run-check-nest-fits "MNL-check-nest-fits OK" "$out"

  # the batch helper, whose whole state is three pointers into a
  # caller-owned buffer
  has libmnl/run-batch-start "MNL-batch-start OK" "$out"
  has libmnl/run-batch-empty-initially "MNL-batch-empty-initially OK" "$out"
  has libmnl/run-batch-size-initially "MNL-batch-size-initially OK" "$out"
  has libmnl/run-batch-head-is-buf "MNL-batch-head-is-buf OK" "$out"
  has libmnl/run-batch-refuses-overflow "MNL-batch-refuses-overflow OK" "$out"
  has libmnl/run-batch-fits-nine "MNL-batch-fits-nine OK" "$out"
  has libmnl/run-batch-not-empty "MNL-batch-not-empty OK" "$out"
  has libmnl/run-batch-size "MNL-batch-size OK" "$out"
  has libmnl/run-batch-walk-count "MNL-batch-walk-count OK" "$out"
  has libmnl/run-batch-walk-len-drained "MNL-batch-walk-len-drained OK" "$out"
  has libmnl/run-batch-reset-size "MNL-batch-reset-size OK" "$out"
  has libmnl/run-batch-reset-not-empty "MNL-batch-reset-not-empty OK" "$out"
  has libmnl/run-batch-stop "MNL-batch-stop OK" "$out"

  # mnl_attr_parse and mnl_cb_run reach the caller through a FUNCTION
  # POINTER, which is the indirect-call path the coroutinize pass marks
  has libmnl/run-cb-parse-rc "MNL-cb-parse-rc OK" "$out"
  has libmnl/run-cb-parse-count "MNL-cb-parse-count OK" "$out"
  has libmnl/run-cb-parse-u32 "MNL-cb-parse-u32 OK" "$out"
  has libmnl/run-cb-parse-str "MNL-cb-parse-str OK" "$out"
  has libmnl/run-cb-stop-rc "MNL-cb-stop-rc OK" "$out"
  has libmnl/run-cb-stop-count "MNL-cb-stop-count OK" "$out"
  has libmnl/run-cb-error-rc "MNL-cb-error-rc OK" "$out"
  has libmnl/run-cb-error-errno "MNL-cb-error-errno OK" "$out"
  has libmnl/run-cb-parse-payload-rc "MNL-cb-parse-payload-rc OK" "$out"
  has libmnl/run-cb-parse-payload-count "MNL-cb-parse-payload-count OK" "$out"
  has libmnl/run-cb-parse-nested-rc "MNL-cb-parse-nested-rc OK" "$out"
  has libmnl/run-cb-parse-nested-count "MNL-cb-parse-nested-count OK" "$out"
  has libmnl/run-cb-parse-nested-u32 "MNL-cb-parse-nested-u32 OK" "$out"
  has libmnl/run-cb-parse-nested-str "MNL-cb-parse-nested-str OK" "$out"
  has libmnl/run-cb-unknown-rc "MNL-cb-unknown-rc OK" "$out"
  has libmnl/run-cb-unknown-seen "MNL-cb-unknown-seen OK" "$out"
  has libmnl/run-cb-run-done-rc "MNL-cb-run-done-rc OK" "$out"
  has libmnl/run-cb-run-done-count "MNL-cb-run-done-count OK" "$out"
  has libmnl/run-cb-run-badseq-rc "MNL-cb-run-badseq-rc OK" "$out"
  has libmnl/run-cb-run-badseq-errno "MNL-cb-run-badseq-errno OK" "$out"
  has libmnl/run-cb-run-badseq-count "MNL-cb-run-badseq-count OK" "$out"
  has libmnl/run-cb-run-badpid-rc "MNL-cb-run-badpid-rc OK" "$out"
  has libmnl/run-cb-run-badpid-errno "MNL-cb-run-badpid-errno OK" "$out"
  has libmnl/run-cb-run-ack-rc "MNL-cb-run-ack-rc OK" "$out"
  has libmnl/run-cb-run-ack-count "MNL-cb-run-ack-count OK" "$out"
  has libmnl/run-cb-run-error-rc "MNL-cb-run-error-rc OK" "$out"
  has libmnl/run-cb-run-error-errno "MNL-cb-run-error-errno OK" "$out"
  has libmnl/run-cb-run-noop-rc "MNL-cb-run-noop-rc OK" "$out"
  has libmnl/run-cb-run-noop-count "MNL-cb-run-noop-count OK" "$out"
  has libmnl/run-cb-seq-wildcard "MNL-cb-seq-wildcard OK" "$out"
  has libmnl/run-cb-portid-wildcard "MNL-cb-portid-wildcard OK" "$out"
  has libmnl/run-cb-seq-match "MNL-cb-seq-match OK" "$out"
  has libmnl/run-cb-seq-mismatch "MNL-cb-seq-mismatch OK" "$out"
  has libmnl/run-cb-portid-match "MNL-cb-portid-match OK" "$out"
  has libmnl/run-cb-portid-mismatch "MNL-cb-portid-mismatch OK" "$out"
  has libmnl/run-cb-seq-caller-wildcard "MNL-cb-seq-caller-wildcard OK" "$out"

  # mnl_nlmsg_next decrements the caller's length by the ALIGNED message
  # length; getting that rounding wrong drifts the walk by two bytes
  has libmnl/run-next-buffer-used "MNL-next-buffer-used OK" "$out"
  has libmnl/run-next-count "MNL-next-count OK" "$out"
  has libmnl/run-next-order "MNL-next-order OK" "$out"
  has libmnl/run-next-drained "MNL-next-drained OK" "$out"

  # The probe's own tally and its exit status, both from the SAME run: 166/166
  # is what this source scores against a native x86_64 build of the identical
  # release, so a target run that differs differs from a measured control and
  # not from an expectation.
  has      libmnl/run-summary "MNL-SUMMARY 166/166" "$out"
  check_eq libmnl/run-exit0 0 "$prc"
else
  bst_notok libmnl/run-stage "cannot stage $BST_DATA/libmnl-probe"
fi

rm -f "$probe"