@deffn {Scheme Procedure} wait-for-link @var{name} [#:blocking? #t]

Wait until a link called @var{name} (a string such as @code{"ens3"}) shows

up.

When @var{blocking?} is false, use a non-blocking socket and cooperate via

@code{current-read-waiter}---useful when using Fibers.

@end deffn

;;;; Copyright (C) 2023 Ludovic Court??s <ludo@gnu.org>

;;;;

  #:use-module (srfi srfi-71)

            wait-for-link

(define (message->event+link msg)

  "If MSG relates to a link event, return two values: its kind (e.g.,

RTM_NEWLINK) and its associated <link> value.  Otherwise return #f and #f."

  (if (memv (message-kind msg)

            (list RTM_NEWLINK

                  RTM_DELLINK

                  RTM_SETLINK))

      (values (message-kind msg)

              (let* ((data (message-data msg))

                     (attrs (link-message-attrs data)))

                (make-link (get-attr attrs IFLA_IFNAME)

                           (link-message-index data)

                           (link-message-kind data)

                           (map int->device-flags (split-flags (link-message-flags data)))

                           (get-attr attrs IFLA_MTU)

                           (get-attr attrs IFLA_QDISC)

                           (get-attr attrs IFLA_OPERSTATE)

                           (get-attr attrs IFLA_LINKMODE)

                           (get-attr attrs IFLA_GROUP)

                           (get-attr attrs IFLA_TXQLEN)

                           (get-attr attrs IFLA_ADDRESS)

                           (get-attr attrs IFLA_BROADCAST))))

      (values #f #f)))

  (let ((kind link (message->event+link msg)))

    (and (eqv? kind RTM_NEWLINK) link)))

(define* (monitor-links proc init terminate?      ;TODO: Make public?

                        #:key (blocking? #t))

  "Wait for link events until @var{terminate?} returns true.  Call @var{init}

with the initial list of links; use its result as the initial state.  From

then on, call @code{(@var{proc} @var{event} @var{link} @var{state})} where

@var{event} is a constant such as @code{RTM_NEWLINK} and @var{link} is the

corresponding link.  Return the final state.

When @code{blocking?} is false, use a non-blocking socket and cooperate via

@code{current-read-waiter}---useful when using Fibers."

  (define request-num (random 65536))

  (define message

    (make-message

     RTM_GETLINK

     (logior NLM_F_REQUEST NLM_F_DUMP)

     request-num

     0

     (make-link-message AF_UNSPEC 0 0 0 0 '())))

  (let ((sock (connect-route #:flags (if blocking? 0 SOCK_NONBLOCK))))

    ;; Subscribe to the "link" group.

    (add-socket-membership sock RTNLGRP_LINK)

    (send-msg message sock)

    (let* ((answer (receive-and-decode-msg sock %default-route-decoder))

           (links (filter-map new-link-message->link answer)))

      (let loop ((state (init links)))

        (if (terminate? state)

            (begin

              (close-port sock)

              state)

            (loop (fold (lambda (msg state)

                          (let ((event link (message->event+link msg)))

                            (proc event link state)))

                        state

                        (receive-and-decode-msg sock %default-route-decoder))))))))

(define* (wait-for-link name #:key (blocking? #t))

  "Wait until a link called @var{name} (a string such as @code{\"ens3\"}) shows

up.

When @var{blocking?} is false, use a non-blocking socket and cooperate via

@code{current-read-waiter}---useful when using Fibers."

  (monitor-links (lambda (event link result)

                   (and (= RTM_NEWLINK)

                        (string=? (link-name link) name)

                        link))

                 (lambda (links)

                   (find (lambda (link)

                           (string=? (link-name link) name))

                         links))

                 (lambda (link)                   ;if LINK is true, terminate

                   link)

                 #:blocking? blocking?))