/* RxRPC remote transport endpoint management
 *
 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */

#include <linux/module.h>
#include <linux/net.h>
#include <linux/skbuff.h>
#include <linux/udp.h>
#include <linux/in.h>
#include <linux/in6.h>
#include <linux/icmp.h>
#include <linux/slab.h>
#include <net/sock.h>
#include <net/af_rxrpc.h>
#include <net/ip.h>
#include <net/route.h>
#include "ar-internal.h"

static LIST_HEAD(rxrpc_peers);
static DEFINE_RWLOCK(rxrpc_peer_lock);
static DECLARE_WAIT_QUEUE_HEAD(rxrpc_peer_wq);

static void rxrpc_destroy_peer(struct work_struct *work);

/*
 * assess the MTU size for the network interface through which this peer is
 * reached
 */
static void rxrpc_assess_MTU_size(struct rxrpc_peer *peer)
{
        struct rtable *rt;
        struct flowi4 fl4;

        peer->if_mtu = 1500;

        rt = ip_route_output_ports(&init_net, &fl4, NULL,
                                   peer->srx.transport.sin.sin_addr.s_addr, 0,
                                   htons(7000), htons(7001),
                                   IPPROTO_UDP, 0, 0);
        if (IS_ERR(rt)) {
                _leave(" [route err %ld]", PTR_ERR(rt));
                return;
        }

        peer->if_mtu = dst_mtu(&rt->dst);
        dst_release(&rt->dst);

        _leave(" [if_mtu %u]", peer->if_mtu);
}

/*
 * allocate a new peer
 */
static struct rxrpc_peer *rxrpc_alloc_peer(struct sockaddr_rxrpc *srx,
                                           gfp_t gfp)
{
        struct rxrpc_peer *peer;

        _enter("");

        peer = kzalloc(sizeof(struct rxrpc_peer), gfp);
        if (peer) {
                INIT_WORK(&peer->destroyer, &rxrpc_destroy_peer);
                INIT_LIST_HEAD(&peer->link);
                INIT_LIST_HEAD(&peer->error_targets);
                spin_lock_init(&peer->lock);
                atomic_set(&peer->usage, 1);
                peer->debug_id = atomic_inc_return(&rxrpc_debug_id);
                memcpy(&peer->srx, srx, sizeof(*srx));

                rxrpc_assess_MTU_size(peer);
                peer->mtu = peer->if_mtu;

                if (srx->transport.family == AF_INET) {
                        peer->hdrsize = sizeof(struct iphdr);
                        switch (srx->transport_type) {
                        case SOCK_DGRAM:
                                peer->hdrsize += sizeof(struct udphdr);
                                break;
                        default:
                                BUG();
                                break;
                        }
                } else {
                        BUG();
                }

                peer->hdrsize += sizeof(struct rxrpc_header);
                peer->maxdata = peer->mtu - peer->hdrsize;
        }

        _leave(" = %p", peer);
        return peer;
}

/*
 * obtain a remote transport endpoint for the specified address
 */
struct rxrpc_peer *rxrpc_get_peer(struct sockaddr_rxrpc *srx, gfp_t gfp)
{
        struct rxrpc_peer *peer, *candidate;
        const char *new = "old";
        int usage;

        _enter("{%d,%d,%pI4+%hu}",
               srx->transport_type,
               srx->transport_len,
               &srx->transport.sin.sin_addr,
               ntohs(srx->transport.sin.sin_port));

        /* search the peer list first */
        read_lock_bh(&rxrpc_peer_lock);
        list_for_each_entry(peer, &rxrpc_peers, link) {
                _debug("check PEER %d { u=%d t=%d l=%d }",
                       peer->debug_id,
                       atomic_read(&peer->usage),
                       peer->srx.transport_type,
                       peer->srx.transport_len);

                if (atomic_read(&peer->usage) > 0 &&
                    peer->srx.transport_type == srx->transport_type &&
                    peer->srx.transport_len == srx->transport_len &&
                    memcmp(&peer->srx.transport,
                           &srx->transport,
                           srx->transport_len) == 0)
                        goto found_extant_peer;
        }
        read_unlock_bh(&rxrpc_peer_lock);

        /* not yet present - create a candidate for a new record and then
         * redo the search */
        candidate = rxrpc_alloc_peer(srx, gfp);
        if (!candidate) {
                _leave(" = -ENOMEM");
                return ERR_PTR(-ENOMEM);
        }

        write_lock_bh(&rxrpc_peer_lock);

        list_for_each_entry(peer, &rxrpc_peers, link) {
                if (atomic_read(&peer->usage) > 0 &&
                    peer->srx.transport_type == srx->transport_type &&
                    peer->srx.transport_len == srx->transport_len &&
                    memcmp(&peer->srx.transport,
                           &srx->transport,
                           srx->transport_len) == 0)
                        goto found_extant_second;
        }

        /* we can now add the new candidate to the list */
        peer = candidate;
        candidate = NULL;
        usage = atomic_read(&peer->usage);

        list_add_tail(&peer->link, &rxrpc_peers);
        write_unlock_bh(&rxrpc_peer_lock);
        new = "new";

success:
        _net("PEER %s %d {%d,%u,%pI4+%hu}",
             new,
             peer->debug_id,
             peer->srx.transport_type,
             peer->srx.transport.family,
             &peer->srx.transport.sin.sin_addr,
             ntohs(peer->srx.transport.sin.sin_port));

        _leave(" = %p {u=%d}", peer, usage);
        return peer;

        /* we found the peer in the list immediately */
found_extant_peer:
        usage = atomic_inc_return(&peer->usage);
        read_unlock_bh(&rxrpc_peer_lock);
        goto success;

        /* we found the peer on the second time through the list */
found_extant_second:
        usage = atomic_inc_return(&peer->usage);
        write_unlock_bh(&rxrpc_peer_lock);
        kfree(candidate);
        goto success;
}

/*
 * find the peer associated with a packet
 */
struct rxrpc_peer *rxrpc_find_peer(struct rxrpc_local *local,
                                   __be32 addr, __be16 port)
{
        struct rxrpc_peer *peer;

        _enter("");

        /* search the peer list */
        read_lock_bh(&rxrpc_peer_lock);

        if (local->srx.transport.family == AF_INET &&
            local->srx.transport_type == SOCK_DGRAM
            ) {
                list_for_each_entry(peer, &rxrpc_peers, link) {
                        if (atomic_read(&peer->usage) > 0 &&
                            peer->srx.transport_type == SOCK_DGRAM &&
                            peer->srx.transport.family == AF_INET &&
                            peer->srx.transport.sin.sin_port == port &&
                            peer->srx.transport.sin.sin_addr.s_addr == addr)
                                goto found_UDP_peer;
                }

                goto new_UDP_peer;
        }

        read_unlock_bh(&rxrpc_peer_lock);
        _leave(" = -EAFNOSUPPORT");
        return ERR_PTR(-EAFNOSUPPORT);

found_UDP_peer:
        _net("Rx UDP DGRAM from peer %d", peer->debug_id);
        atomic_inc(&peer->usage);
        read_unlock_bh(&rxrpc_peer_lock);
        _leave(" = %p", peer);
        return peer;

new_UDP_peer:
        _net("Rx UDP DGRAM from NEW peer");
        read_unlock_bh(&rxrpc_peer_lock);
        _leave(" = -EBUSY [new]");
        return ERR_PTR(-EBUSY);
}

/*
 * release a remote transport endpoint
 */
void rxrpc_put_peer(struct rxrpc_peer *peer)
{
        _enter("%p{u=%d}", peer, atomic_read(&peer->usage));

        ASSERTCMP(atomic_read(&peer->usage), >, 0);

        if (likely(!atomic_dec_and_test(&peer->usage))) {
                _leave(" [in use]");
                return;
        }

        rxrpc_queue_work(&peer->destroyer);
        _leave("");
}

/*
 * destroy a remote transport endpoint
 */
static void rxrpc_destroy_peer(struct work_struct *work)
{
        struct rxrpc_peer *peer =
                container_of(work, struct rxrpc_peer, destroyer);

        _enter("%p{%d}", peer, atomic_read(&peer->usage));

        write_lock_bh(&rxrpc_peer_lock);
        list_del(&peer->link);
        write_unlock_bh(&rxrpc_peer_lock);

        _net("DESTROY PEER %d", peer->debug_id);
        kfree(peer);

        if (list_empty(&rxrpc_peers))
                wake_up_all(&rxrpc_peer_wq);
        _leave("");
}

/*
 * preemptively destroy all the peer records from a transport endpoint rather
 * than waiting for them to time out
 */
void __exit rxrpc_destroy_all_peers(void)
{
        DECLARE_WAITQUEUE(myself,current);

        _enter("");

        /* we simply have to wait for them to go away */
        if (!list_empty(&rxrpc_peers)) {
                set_current_state(TASK_UNINTERRUPTIBLE);
                add_wait_queue(&rxrpc_peer_wq, &myself);

                while (!list_empty(&rxrpc_peers)) {
                        schedule();
                        set_current_state(TASK_UNINTERRUPTIBLE);
                }

                remove_wait_queue(&rxrpc_peer_wq, &myself);
                set_current_state(TASK_RUNNING);
        }

        _leave("");
}