/*

 * libwebsockets - small server side websockets and web server implementation

 *

 * Copyright (C) 2010 - 2021 Andy Green <andy@warmcat.com>

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to

 * deal in the Software without restriction, including without limitation the

 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

 * sell copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS

 * IN THE SOFTWARE.

 *

 * We mainly focus on the routing table / gateways because those are the

 * elements that decide if we can get on to the internet or not.

 *

 * We also need to understand the source addresses of possible outgoing routes,

 * and follow LINK down (ifconfig down) to clean up routes on the interface idx

 * going down that are not otherwise cleaned.

 */

#include <private-lib-core.h>

#include <asm/types.h>

#include <sys/socket.h>

#include <linux/netlink.h>

#include <linux/rtnetlink.h>

//#define lwsl_netlink lwsl_notice

#define lwsl_cx_netlink   lwsl_cx_info

#define lwsl_cx_netlink_debug lwsl_cx_debug

static void

lws_netlink_coldplug_done_cb(lws_sorted_usec_list_t *sul)

{

  struct lws_context *ctx = lws_container_of(sul, struct lws_context,

               sul_nl_coldplug);

  ctx->nl_initial_done = 1;

#if defined(LWS_WITH_SYS_STATE)

  /* if nothing is there to intercept anything, go all the way */

  lws_state_transition_steps(&ctx->mgr_system, LWS_SYSTATE_OPERATIONAL);

#endif

}

static lws_handling_result_t

rops_handle_POLLIN_netlink(struct lws_context_per_thread *pt, struct lws *wsi,

         struct lws_pollfd *pollfd)

{

  struct lws_context  *cx = pt->context;

  uint8_t s[4096]

#if defined(_DEBUG)

          , route_change = 0

#endif

#if defined(LWS_WITH_SYS_SMD)

    , gateway_change = 0

#endif

      ;

  struct sockaddr_nl  nladdr;

  lws_route_t   robj, *rou;

  struct nlmsghdr   *h;

  struct msghdr   msg;

  struct iovec    iov;

  unsigned int    n, removed;

  char      buf[72];

  if (!(pollfd->revents & LWS_POLLIN))

    return LWS_HPI_RET_HANDLED;

  memset(&msg, 0, sizeof(msg));

  iov.iov_base    = (void *)s;

  iov.iov_len   = sizeof(s);

  msg.msg_name    = (void *)&(nladdr);

  msg.msg_namelen   = sizeof(nladdr);

  msg.msg_iov   = &iov;

  msg.msg_iovlen    = 1;

  n = (unsigned int)recvmsg(wsi->desc.sockfd, &msg, 0);

  if ((int)n < 0) {

    lwsl_cx_notice(cx, "recvmsg failed");

    return LWS_HPI_RET_PLEASE_CLOSE_ME;

  }

  // lwsl_hexdump_notice(s, (size_t)n);

  h = (struct nlmsghdr *)s;

  /* we can get a bunch of messages coalesced in one read*/

  for ( ; NLMSG_OK(h, n); h = NLMSG_NEXT(h, n)) {

    struct ifaddrmsg *ifam;

    struct rtattr *ra;

    struct rtmsg *rm;

#if !defined(LWS_WITH_NO_LOGS) && defined(_DEBUG)

    struct ndmsg *nd;

#endif

    unsigned int ra_len;

    uint8_t *p;

    struct ifinfomsg *ifi;

    struct rtattr *attribute;

    unsigned int len;

    lwsl_cx_netlink(cx, "RTM %d", h->nlmsg_type);

    memset(&robj, 0, sizeof(robj));

    robj.if_idx = -1;

    robj.priority = -1;

    rm = (struct rtmsg *)NLMSG_DATA(h);

    /*

     * We have to care about NEWLINK so we can understand when a

     * network interface went down, and clear the related routes.

     *

     * We don't get individual DELROUTEs for these.

     */

    switch (h->nlmsg_type) {

    case RTM_NEWLINK:

      ifi = NLMSG_DATA(h);

      len = (unsigned int)(h->nlmsg_len - NLMSG_LENGTH(sizeof(*ifi)));

      /* loop over all attributes for the NEWLINK message */

      for (attribute = IFLA_RTA(ifi); RTA_OK(attribute, len);

           attribute = RTA_NEXT(attribute, len)) {

        lwsl_cx_netlink(cx, "if attr %d",

              (int)attribute->rta_type);

        switch(attribute->rta_type) {

        case IFLA_IFNAME:

          lwsl_cx_netlink(cx, "NETLINK ifidx %d : %s",

                 ifi->ifi_index,

                 (char *)RTA_DATA(attribute));

          break;

        default:

          break;

        } /* switch */

      } /* for loop */

      lwsl_cx_netlink(cx, "NEWLINK ifi_index %d, flags 0x%x",

          ifi->ifi_index, ifi->ifi_flags);

      /*

       * Despite "New"link this is actually telling us there

       * is some change on the network interface IFF_ state

       */

      if (!(ifi->ifi_flags & IFF_UP)) {

        /*

         * Interface is down, so scrub all routes that

         * applied to it

         */

        lwsl_cx_netlink(cx, "NEWLINK: ifdown %d",

            ifi->ifi_index);

        lws_pt_lock(pt, __func__);

        _lws_route_table_ifdown(pt, ifi->ifi_index);

        lws_pt_unlock(pt);

      }

      continue; /* ie, not break, no second half */

    case RTM_NEWADDR:

    case RTM_DELADDR:

      ifam = (struct ifaddrmsg *)NLMSG_DATA(h);

      robj.source_ads = 1;

      robj.dest_len = ifam->ifa_prefixlen;

      robj.if_idx = (int)ifam->ifa_index;

      robj.scope = ifam->ifa_scope;

      robj.ifa_flags = ifam->ifa_flags;

      robj.dest.sa4.sin_family = ifam->ifa_family;

      /* address attributes */

      ra = (struct rtattr *)IFA_RTA(ifam);

      ra_len = (unsigned int)IFA_PAYLOAD(h);

      lwsl_cx_netlink(cx, "%s",

        h->nlmsg_type == RTM_NEWADDR ? "NEWADDR" : "DELADDR");

      // Parse attributes.

      for ( ; RTA_OK(ra, ra_len); ra = RTA_NEXT(ra, ra_len)) {

        //lwsl_cx_netlink_debug(cx, "%s: IFA %d\n", __func__, ra->rta_type);

        switch (ra->rta_type) {

        case IFA_LOCAL:

          // Local address

          lws_sa46_copy_address(&robj.src, RTA_DATA(ra), rm->rtm_family);

          robj.src_len = rm->rtm_src_len;

          lws_sa46_write_numeric_address(&robj.src, buf, sizeof(buf));

          lwsl_cx_netlink_debug(cx, "IFA_LOCAL: %s/%d", buf, robj.src_len);

          break;

        case IFA_ADDRESS:

          // Prefix address, not local interface.

          lws_sa46_copy_address(&robj.dest, RTA_DATA(ra), rm->rtm_family);

          robj.dest_len = rm->rtm_dst_len;

          lws_sa46_write_numeric_address(&robj.dest, buf, sizeof(buf));

          lwsl_cx_netlink_debug(cx, "IFA_ADDRESS: %s/%d", buf, robj.dest_len);

          break;

        case IFA_FLAGS:

          lwsl_cx_netlink_debug(cx, "IFA_FLAGS: 0x%x (not handled)",

              *(unsigned int*)RTA_DATA(ra));

          break;

        case IFA_BROADCAST:

          lwsl_cx_netlink_debug(cx, "IFA_BROADCAST (not handled)");

          break;

        case IFA_ANYCAST:

          lwsl_cx_netlink_debug(cx, "IFA_ANYCAST (not handled)");

          break;

        case IFA_CACHEINFO:

          lwsl_cx_netlink_debug(cx, "IFA_CACHEINFO (not handled)");

          break;

        case IFA_LABEL:

          strncpy(buf, RTA_DATA(ra), sizeof(buf));

          buf[sizeof(buf)-1] = '\0';

          lwsl_cx_netlink_debug(cx, "IFA_LABEL: %s (not used)", buf);

          break;

        default:

          lwsl_cx_netlink_debug(cx, "unknown IFA attr type %d", ra->rta_type);

          break;

        }

        //lwsl_cx_debug(cx, "rta payload length: %ld", RTA_PAYLOAD(ra));

      } /* for */

      /*

       * almost nothing interesting within IFA_* attributes:

       * so skip it and goto to the second half

       */

      goto second_half;

    case RTM_NEWROUTE:

    case RTM_DELROUTE:

      lwsl_cx_netlink(cx, "%s",

             h->nlmsg_type == RTM_NEWROUTE ?

                 "NEWROUTE" : "DELROUTE");

      /* route attributes */

      ra = (struct rtattr *)RTM_RTA(rm);

      ra_len = (unsigned int)RTM_PAYLOAD(h);

      break;

    case RTM_DELNEIGH:

    case RTM_NEWNEIGH:

      lwsl_cx_netlink(cx, "%s", h->nlmsg_type ==

            RTM_NEWNEIGH ? "NEWNEIGH" :

                     "DELNEIGH");

#if !defined(LWS_WITH_NO_LOGS) && defined(_DEBUG)

      nd = (struct ndmsg *)rm;

      lwsl_cx_netlink(cx, "fam %u, ifidx %u, flags 0x%x",

            nd->ndm_family, nd->ndm_ifindex,

            nd->ndm_flags);

#endif

      ra = (struct rtattr *)RTM_RTA(rm);

      ra_len = (unsigned int)RTM_PAYLOAD(h);

      for ( ; RTA_OK(ra, ra_len); ra = RTA_NEXT(ra, ra_len)) {

        lwsl_cx_netlink(cx, "atr %d", ra->rta_type);

        switch (ra->rta_type) {

        case NDA_DST:

          lwsl_cx_netlink(cx, "dst len %d",

              ra->rta_len);

          break;

        }

      }

      lws_pt_lock(pt, __func__);

      _lws_route_pt_close_unroutable(pt);

      lws_pt_unlock(pt);

      continue;

    default:

      lwsl_cx_netlink(cx, "*** Unknown RTM_%d",

          h->nlmsg_type);

      continue;

    } /* switch */

    robj.proto = rm->rtm_protocol;

    // iterate over route attributes

    for ( ; RTA_OK(ra, ra_len); ra = RTA_NEXT(ra, ra_len)) {

      // lwsl_netlink("%s: atr %d\n", __func__, ra->rta_type);

      switch (ra->rta_type) {

      case RTA_PREFSRC: /* protocol ads: preferred src ads */

      case RTA_SRC:

        lws_sa46_copy_address(&robj.src, RTA_DATA(ra),

              rm->rtm_family);

        robj.src_len = rm->rtm_src_len;

        lws_sa46_write_numeric_address(&robj.src, buf, sizeof(buf));

        if (ra->rta_type == RTA_SRC)

          lwsl_cx_netlink_debug(cx, "RTA_SRC: %s/%d", buf, robj.src_len);

        else

          lwsl_cx_netlink_debug(cx, "RTA_PREFSRC: %s/%d", buf, robj.src_len);

        break;

      case RTA_DST:

        /* check if is local addr -> considering it as src addr too */

        if (rm->rtm_type == RTN_LOCAL &&

            ((rm->rtm_family == AF_INET && rm->rtm_dst_len == 32) ||

             (rm->rtm_family == AF_INET6 && rm->rtm_dst_len == 128))) {

          lws_sa46_copy_address(&robj.src, RTA_DATA(ra),

              rm->rtm_family);

          lwsl_cx_netlink_debug(cx, "Local addr: RTA_DST -> added to RTA_SRC");

        }

        lws_sa46_copy_address(&robj.dest, RTA_DATA(ra),

                  rm->rtm_family);

        robj.dest_len = rm->rtm_dst_len;

        lws_sa46_write_numeric_address(&robj.dest, buf, sizeof(buf));

        lwsl_cx_netlink_debug(cx, "RTA_DST: %s/%d", buf, robj.dest_len);

        break;

      case RTA_GATEWAY:

        lws_sa46_copy_address(&robj.gateway, RTA_DATA(ra),

                  rm->rtm_family);

        lws_sa46_write_numeric_address(&robj.gateway, buf, sizeof(buf));

        lwsl_cx_netlink_debug(cx, "RTA_GATEWAY: %s", buf);

#if defined(LWS_WITH_SYS_SMD)

        gateway_change = 1;

#endif

        break;

      case RTA_IIF: /* int: input interface index */

      case RTA_OIF: /* int: output interface index */

        robj.if_idx = *(int *)RTA_DATA(ra);

        lwsl_cx_netlink_debug(cx, "RTA_IIF/RTA_OIF: %d", robj.if_idx);

        break;

      case RTA_PRIORITY: /* int: priority of route */

        p = RTA_DATA(ra);

        robj.priority = p[3] << 24 | p[2] << 16 |

             p[1] << 8  | p[0];

        lwsl_cx_netlink_debug(cx, "RTA_PRIORITY: %d", robj.priority);

        break;

      case RTA_CACHEINFO: /* struct rta_cacheinfo */

        lwsl_cx_netlink_debug(cx, "RTA_CACHEINFO (not handled)");

        break;

#if defined(LWS_HAVE_RTA_PREF)

      case RTA_PREF: /* char: RFC4191 v6 router preference */

        lwsl_cx_netlink_debug(cx, "RTA_PREF (not handled)");

        break;

#endif

      case RTA_TABLE: /* int */

        lwsl_cx_netlink_debug(cx, "RTA_TABLE (not handled)");

        break;

      default:

        lwsl_cx_netlink_debug(cx, "unknown attr type %d", ra->rta_type);

        break;

      }

      //lwsl_cx_debug(cx, "rta payload length: %ld", RTA_PAYLOAD(ra));

    } /* for */

    /*

     * the second half, once all the attributes were collected

     */

second_half:

    switch (h->nlmsg_type) {

    case RTM_DELROUTE:

      /*

       * This will also take down wsi marked as using it

       */

      lwsl_cx_netlink(cx, "DELROUTE: if_idx %d",

          robj.if_idx);

      lws_pt_lock(pt, __func__);

      _lws_route_remove(pt, &robj, 0);

      lws_pt_unlock(pt);

      goto inform;

    case RTM_NEWROUTE:

      /*

       * We don't want any routing debris like /32 or broadcast

       * in our routing table... we will collect source addresses

       * bound to interfaces via NEWADDR

       */

      if (rm->rtm_type != RTN_UNICAST

          && rm->rtm_type != RTN_LOCAL) {

        lwsl_cx_netlink(cx, "NEWROUTE: IGNORED (%s)",

            rm->rtm_type == RTN_BROADCAST   ? "broadcast" :

            rm->rtm_type == RTN_ANYCAST     ? "anycast" :

            rm->rtm_type == RTN_MULTICAST   ? "multicast" :

            rm->rtm_type == RTN_UNREACHABLE   ? "unreachable" :

            rm->rtm_type == RTN_NAT   ? "nat" :

            rm->rtm_type == RTN_UNSPEC      ? "unspecified" :

                    "other");

        break;

      }

      if (rm->rtm_flags & RTM_F_CLONED) {

        lwsl_cx_netlink(cx, "NEWROUTE: IGNORED (cloned)");

        break;

      }

      lwsl_cx_netlink(cx, "NEWROUTE: ACCEPTED (if_idx %d)",

          robj.if_idx);

#if defined(_DEBUG)

      _lws_routing_entry_dump(cx, &robj);

#endif

      /*

       * 1. Allocate new route for linked-list.

       *    (robj is on stack, do NOT use)

       */    

      rou = lws_malloc(sizeof(*rou), __func__);

      if (!rou) {

        lwsl_cx_err(cx, "oom");

        return LWS_HPI_RET_HANDLED;

      }

      *rou = robj;

      // 2. Remove duplicates and add route (both under a lock).

      lws_pt_lock(pt, __func__);

      /*

       * Is robj a dupe in the routing table already?

       *

       * match on pri ignore == set pri and skip

       * no match == add

       *

       * returns zero ALWAYS

       *

       * We could be adding a route to the same destination with

       * a higher or lower priority from a different source, so why

       * all existing routes? Only remove if its the same source and

       * destination, effectively a change in priority.

       */

      _lws_route_remove(pt, &robj,

          LRR_MATCH_DST | LRR_MATCH_SRC | LRR_IGNORE_PRI);

      /* add route to linked-list */

      rou->uidx = _lws_route_get_uidx(cx);

      lws_dll2_add_tail(&rou->list, &cx->routing_table);

      lws_pt_unlock(pt);

      lwsl_cx_netlink_debug(cx, "route list size %u",

        cx->routing_table.count);

      /*

       * 3. Close anyything we cant reach anymore due to the removal.

       *    (don't need to or want to do this under lock)

       */

      _lws_route_pt_close_unroutable(pt);

inform:

#if defined(_DEBUG)

      route_change = 1;

#endif

#if defined(LWS_WITH_SYS_SMD)

      /*

       * Reflect the route add / del event using SMD.

       * Participants interested can refer to the pt

       * routing table

       */

      (void)lws_smd_msg_printf(cx, LWSSMDCL_NETWORK,

           "{\"rt\":\"%s\"}\n",

           (h->nlmsg_type == RTM_NEWROUTE) ?

            "add" : "del");

#endif

      break;

    case RTM_DELADDR:

      lwsl_cx_notice(cx, "DELADDR");

#if defined(_DEBUG)

      _lws_routing_entry_dump(cx, &robj);

#endif

      lws_pt_lock(pt, __func__);

      removed = cx->routing_table.count;

      _lws_route_remove(pt, &robj, LRR_MATCH_SRC | LRR_IGNORE_PRI);

      removed -= cx->routing_table.count;

      lws_pt_unlock(pt);

      _lws_route_pt_close_unroutable(pt);

      if (removed > 0)

        goto inform;

      break;

    case RTM_NEWADDR:

      lwsl_cx_netlink(cx, "NEWADDR (nothing to do)");

#if defined(_DEBUG)

      _lws_routing_entry_dump(cx, &robj);

#endif

      /*

       * An address alone does not provide new routes.

       * NEWADDR will happen when the DHCP lease is being

       * renewed, and will likely not change any routes.

       */

      break;

    default:

      // lwsl_info("%s: unknown msg type %d\n", __func__,

      //    h->nlmsg_type);

      break;

    }

  } /* message iterator */

#if defined(LWS_WITH_SYS_SMD)

  if (gateway_change)

    /*

     * If a route with a gw was added or deleted, retrigger captive

     * portal detection if we have that

     */

    (void)lws_smd_msg_printf(cx, LWSSMDCL_NETWORK,

           "{\"trigger\": \"cpdcheck\", "

           "\"src\":\"gw-change\"}");

#endif

#if defined(_DEBUG)

  if (route_change) {

    lws_context_lock(cx, __func__);

    _lws_routing_table_dump(cx);

    lws_context_unlock(cx);

  }

#endif

  if (!cx->nl_initial_done &&

      pt == &cx->pt[0] &&

      cx->routing_table.count) {

    /*

     * While netlink info still coming, keep moving the timer for

     * calling it "done" to +100ms until after it stops coming

     */

    lws_context_lock(cx, __func__);

    lws_sul_schedule(cx, 0, &cx->sul_nl_coldplug,

         lws_netlink_coldplug_done_cb,

         100 * LWS_US_PER_MS);

    lws_context_unlock(cx);

  }

  return LWS_HPI_RET_HANDLED;

}

struct nl_req_s {

  struct nlmsghdr hdr;

  struct rtmsg gen;

};

int

rops_pt_init_destroy_netlink(struct lws_context *context,

           const struct lws_context_creation_info *info,

           struct lws_context_per_thread *pt, int destroy)

{

  struct sockaddr_nl sanl;

  struct nl_req_s req;

  struct msghdr msg;

  struct iovec iov;

  struct lws *wsi;

  int n, ret = 1;

  if (destroy) {

    /*

     * pt netlink wsi closed + freed as part of pt's destroy

     * wsi mass close, just need to take down the routing table

     */

    _lws_route_table_empty(pt);

    return 0;

  }

  if (context->netlink)

    return 0;

  if (pt > &context->pt[0])

    /* we can only have one netlink socket */

    return 0;

  lwsl_cx_info(context, "creating netlink skt");

  /*

   * We want a netlink socket per pt as well

   */

  lws_context_lock(context, __func__);

  wsi = __lws_wsi_create_with_role(context, (int)(pt - &context->pt[0]),

               &role_ops_netlink, NULL);

  lws_context_unlock(context);

  if (!wsi)

    goto bail;

  wsi->desc.sockfd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);

  if (wsi->desc.sockfd == LWS_SOCK_INVALID) {

    lwsl_cx_err(context, "unable to open netlink");

    goto bail1;

  }

  lws_plat_set_nonblocking(wsi->desc.sockfd);

  __lws_lc_tag(context, &context->lcg[LWSLCG_VHOST], &wsi->lc,

      "netlink");

  memset(&sanl, 0, sizeof(sanl));

  sanl.nl_family    = AF_NETLINK;

  sanl.nl_groups    = RTMGRP_LINK | RTMGRP_IPV4_ROUTE | RTMGRP_IPV4_IFADDR

#if defined(LWS_WITH_IPV6)

          | RTMGRP_IPV6_ROUTE | RTMGRP_IPV6_IFADDR

#endif

         ;

  if (lws_fi(&context->fic, "netlink_bind") ||

      bind(wsi->desc.sockfd, (struct sockaddr*)&sanl, sizeof(sanl)) < 0) {

    lwsl_cx_warn(context, "netlink bind failed");

    ret = 0; /* some systems deny access, just ignore */

    goto bail2;

  }

  context->netlink = wsi;

  if (lws_wsi_inject_to_loop(pt, wsi))

    goto bail2;

/*  if (lws_change_pollfd(wsi, 0, LWS_POLLIN)) {

    lwsl_err("%s: pollfd in fail\n", __func__);

    goto bail2;

  }

*/

  /*

   * Since we're starting the PT, ask to be sent all the existing routes.

   *

   * This requires CAP_ADMIN, or root... we do this early before dropping

   * privs

   */

  memset(&sanl, 0, sizeof(sanl));

  memset(&msg, 0, sizeof(msg));

  memset(&req, 0, sizeof(req));

  sanl.nl_family    = AF_NETLINK;

  req.hdr.nlmsg_len = NLMSG_LENGTH(sizeof(req.gen));

  req.hdr.nlmsg_type  = RTM_GETROUTE;

  req.hdr.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;

  req.hdr.nlmsg_seq = 1;

  req.hdr.nlmsg_pid = (uint32_t)getpid();

  req.gen.rtm_family  = AF_PACKET;

  req.gen.rtm_table = RT_TABLE_DEFAULT;

  iov.iov_base    = &req;

  iov.iov_len   = req.hdr.nlmsg_len;

  msg.msg_iov   = &iov;

  msg.msg_iovlen    = 1;

  msg.msg_name    = &sanl;

  msg.msg_namelen   = sizeof(sanl);

  n = (int)sendmsg(wsi->desc.sockfd, (struct msghdr *)&msg, 0);

  if (n < 0) {

    lwsl_cx_notice(context, "rt dump req failed... permissions? errno %d",

        LWS_ERRNO);

  }

  /*

   * Responses are going to come asynchronously, let's block moving

   * off state IFACE_COLDPLUG until we have had them.  This is important

   * since if we don't hold there, when we do get the responses we may

   * cull any ongoing connections as unroutable otherwise

   */

  lwsl_cx_debug(context, "starting netlink coldplug wait");

  return 0;

bail2:

  __lws_lc_untag(wsi->a.context, &wsi->lc);

  compatible_close(wsi->desc.sockfd);

bail1:

  lws_dll2_remove(&wsi->pre_natal);

  lws_free(wsi);

bail:

  return ret;

}

static const lws_rops_t rops_table_netlink[] = {

  /*  1 */ { .pt_init_destroy = rops_pt_init_destroy_netlink },

  /*  2 */ { .handle_POLLIN = rops_handle_POLLIN_netlink },

};

const struct lws_role_ops role_ops_netlink = {

  /* role name */     "netlink",

  /* alpn id */     NULL,

  /* rops_table */    rops_table_netlink,

  /* rops_idx */      {

    /* LWS_ROPS_check_upgrades */

    /* LWS_ROPS_pt_init_destroy */    0x01,

    /* LWS_ROPS_init_vhost */

    /* LWS_ROPS_destroy_vhost */      0x00,

    /* LWS_ROPS_service_flag_pending */

    /* LWS_ROPS_handle_POLLIN */      0x02,

    /* LWS_ROPS_handle_POLLOUT */

    /* LWS_ROPS_perform_user_POLLOUT */   0x00,

    /* LWS_ROPS_callback_on_writable */

    /* LWS_ROPS_tx_credit */      0x00,

    /* LWS_ROPS_write_role_protocol */

    /* LWS_ROPS_encapsulation_parent */   0x00,

    /* LWS_ROPS_alpn_negotiated */

    /* LWS_ROPS_close_via_role_protocol */  0x00,

    /* LWS_ROPS_close_role */

    /* LWS_ROPS_close_kill_connection */    0x00,

    /* LWS_ROPS_destroy_role */

    /* LWS_ROPS_adoption_bind */      0x00,

    /* LWS_ROPS_client_bind */

    /* LWS_ROPS_issue_keepalive */    0x00,

          },

  /* adoption_cb clnt, srv */ { 0, 0 },

  /* rx_cb clnt, srv */   { 0, 0 },

  /* writeable cb clnt, srv */  { 0, 0 },

  /* close cb clnt, srv */  { 0, 0 },

  /* protocol_bind_cb c,s */  { 0, 0 },

  /* protocol_unbind_cb c,s */  { 0, 0 },

  /* file_handle */   0,

};