/*

 * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2016 Nicira, Inc.

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at:

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#include <config.h>

#include "netlink-notifier.h"

#include <errno.h>

#include <poll.h>

#include <stdlib.h>

#include "coverage.h"

#include "netlink.h"

#include "netlink-socket.h"

#include "openvswitch/ofpbuf.h"

#include "openvswitch/vlog.h"

VLOG_DEFINE_THIS_MODULE(netlink_notifier);

COVERAGE_DEFINE(nln_changed);

struct nln {

    struct nl_sock *notify_sock; /* Netlink socket. */

    struct ovs_list all_notifiers;   /* All nln notifiers. */

    bool has_run;                /* Guard for run and wait functions. */

    /* Passed in by nln_create(). */

    int protocol;                /* Protocol passed to nl_sock_create(). */

    nln_parse_func *parse;       /* Message parsing function. */

    void *change;                /* Change passed to parse. */

};

struct nln_notifier {

    struct ovs_list node;        /* In struct nln's 'all_notifiers' list. */

    struct nln *nln;             /* Parent nln. */

    int multicast_group;         /* Multicast group we listen on. */

    nln_notify_func *cb;

    void *aux;

};

/* Creates an nln handle which may be used to manage change notifications.  The

 * created handle will listen for netlink messages on 'multicast_group' using

 * netlink protocol 'protocol' (e.g. NETLINK_ROUTE, NETLINK_GENERIC, ...).

 * Incoming messages will be parsed with 'parse' which will be passed 'change'

 * as an argument. */

struct nln *

nln_create(int protocol, nln_parse_func *parse, void *change)

{

    struct nln *nln;

    nln = xzalloc(sizeof *nln);

    nln->notify_sock = NULL;

    nln->protocol = protocol;

    nln->parse = parse;

    nln->change = change;

    nln->has_run = false;

    ovs_list_init(&nln->all_notifiers);

    return nln;

}

/* Destroys 'nln' by freeing any memory it has reserved and closing any sockets

 * it has opened.

 *

 * The caller is responsible for destroying any notifiers created by this

 * 'nln' before destroying 'nln'. */

void

nln_destroy(struct nln *nln)

{

    if (nln) {

        ovs_assert(ovs_list_is_empty(&nln->all_notifiers));

        nl_sock_destroy(nln->notify_sock);

        free(nln);

    }

}

/* Registers 'cb' to be called with auxiliary data 'aux' with change

 * notifications.  The notifier is stored in 'notifier', which the caller must

 * not modify or free.

 *

 * This is probably not the function you want.  You should probably be using

 * message specific notifiers like rtnetlink_link_notifier_register().

 *

 * Returns an initialized nln_notifier if successful, otherwise NULL. */

struct nln_notifier *

nln_notifier_create(struct nln *nln, int multicast_group, nln_notify_func *cb,

                    void *aux)

{

    struct nln_notifier *notifier;

    int error;

    if (!nln->notify_sock) {

        struct nl_sock *sock;

        error = nl_sock_create(nln->protocol, &sock);

        if (error) {

            VLOG_WARN("could not create netlink socket: %s",

                      ovs_strerror(error));

            return NULL;

        }

        nln->notify_sock = sock;

    } else {

        /* Catch up on notification work so that the new notifier won't

         * receive any stale notifications. */

        nln_run(nln);

    }

    error = nl_sock_join_mcgroup(nln->notify_sock, multicast_group);

    if (error) {

        VLOG_WARN("could not join netlink multicast group: %s",

                  ovs_strerror(error));

        return NULL;

    }

    notifier = xmalloc(sizeof *notifier);

    notifier->multicast_group = multicast_group;

    notifier->cb = cb;

    notifier->aux = aux;

    notifier->nln = nln;

    ovs_list_push_back(&nln->all_notifiers, &notifier->node);

    return notifier;

}

/* Destroys 'notifier', which must have previously been created with

 * nln_notifier_register(). */

void

nln_notifier_destroy(struct nln_notifier *notifier)

{

    if (notifier) {

        struct nln *nln = notifier->nln;

        struct nln_notifier *iter;

        int count = 0;

        ovs_list_remove(&notifier->node);

        /* Leave the group if no other notifier is interested in it. */

        LIST_FOR_EACH (iter, node, &nln->all_notifiers) {

            if (iter->multicast_group == notifier->multicast_group) {

                count++;

            }

        }

        if (count == 0) {

            nl_sock_leave_mcgroup(nln->notify_sock, notifier->multicast_group);

        }

        if (ovs_list_is_empty(&nln->all_notifiers)) {

            nl_sock_destroy(nln->notify_sock);

            nln->notify_sock = NULL;

        }

        free(notifier);

    }

}

/* Calls all of the registered notifiers, passing along any as-yet-unreported

 * change events. */

void

nln_run(struct nln *nln)

{

    static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);

    if (!nln->notify_sock || nln->has_run) {

        return;

    }

    nln->has_run = true;

    for (;;) {

        uint64_t buf_stub[4096 / 8];

        struct ofpbuf buf;

        int error;

        ofpbuf_use_stub(&buf, buf_stub, sizeof buf_stub);

        error = nl_sock_recv(nln->notify_sock, &buf, NULL, false);

        if (!error) {

            int group = nln->parse(&buf, nln->change);

            if (group != 0) {

                nln_report(nln, nln->change, group);

            } else {

                VLOG_WARN_RL(&rl, "unexpected netlink message contents");

                nln_report(nln, NULL, 0);

            }

            ofpbuf_uninit(&buf);

        } else if (error == EAGAIN) {

            return;

        } else {

            if (error == ENOBUFS) {

                /* The socket buffer might be full, there could be too many

                 * notifications, so it makes sense to call nln_report() */

                nln_report(nln, NULL, 0);

                VLOG_WARN_RL(&rl, "netlink receive buffer overflowed");

            } else {

                VLOG_WARN_RL(&rl, "error reading netlink socket: %s",

                             ovs_strerror(error));

            }

            return;

        }

    }

}

/* Causes poll_block() to wake up when change notifications are ready. */

void

nln_wait(struct nln *nln)

{

    nln->has_run = false;

    if (nln->notify_sock) {

        nl_sock_wait(nln->notify_sock, POLLIN);

    }

}

void

nln_report(const struct nln *nln, void *change, int group)

{

    struct nln_notifier *notifier;

    if (change) {

        COVERAGE_INC(nln_changed);

    }

    LIST_FOR_EACH (notifier, node, &nln->all_notifiers) {

        if (!change || group == notifier->multicast_group) {

            notifier->cb(change, notifier->aux);

        }

    }

}