/* AF_RXRPC local 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/slab.h>
  #include <net/sock.h>
  #include <net/af_rxrpc.h>
  #include "ar-internal.h"
  
  static LIST_HEAD(rxrpc_locals);
  DEFINE_RWLOCK(rxrpc_local_lock);
  static DECLARE_RWSEM(rxrpc_local_sem);
  static DECLARE_WAIT_QUEUE_HEAD(rxrpc_local_wq);
  
  static void rxrpc_destroy_local(struct work_struct *work);
  
  /*
   * allocate a new local
   */
  static
  struct rxrpc_local *rxrpc_alloc_local(struct sockaddr_rxrpc *srx)
  {
  	struct rxrpc_local *local;
  
  	local = kzalloc(sizeof(struct rxrpc_local), GFP_KERNEL);
  	if (local) {
  		INIT_WORK(&local->destroyer, &rxrpc_destroy_local);
  		INIT_WORK(&local->acceptor, &rxrpc_accept_incoming_calls);
  		INIT_WORK(&local->rejecter, &rxrpc_reject_packets);
  		INIT_LIST_HEAD(&local->services);
  		INIT_LIST_HEAD(&local->link);
  		init_rwsem(&local->defrag_sem);
  		skb_queue_head_init(&local->accept_queue);
  		skb_queue_head_init(&local->reject_queue);
  		spin_lock_init(&local->lock);
  		rwlock_init(&local->services_lock);
  		atomic_set(&local->usage, 1);
  		local->debug_id = atomic_inc_return(&rxrpc_debug_id);
  		memcpy(&local->srx, srx, sizeof(*srx));
  	}
  
  	_leave(" = %p", local);
  	return local;
  }
  
  /*
   * create the local socket
   * - must be called with rxrpc_local_sem writelocked
   */
  static int rxrpc_create_local(struct rxrpc_local *local)
  {
  	struct sock *sock;
  	int ret, opt;
  
  	_enter("%p{%d}", local, local->srx.transport_type);
  
  	/* create a socket to represent the local endpoint */
  	ret = sock_create_kern(PF_INET, local->srx.transport_type, IPPROTO_UDP,
  			       &local->socket);
  	if (ret < 0) {
  		_leave(" = %d [socket]", ret);
  		return ret;
  	}
  
  	/* if a local address was supplied then bind it */
  	if (local->srx.transport_len > sizeof(sa_family_t)) {
  		_debug("bind");
  		ret = kernel_bind(local->socket,
  				  (struct sockaddr *) &local->srx.transport,
  				  local->srx.transport_len);
  		if (ret < 0) {
  			_debug("bind failed");
  			goto error;
  		}
  	}
  
  	/* we want to receive ICMP errors */
  	opt = 1;
  	ret = kernel_setsockopt(local->socket, SOL_IP, IP_RECVERR,
  				(char *) &opt, sizeof(opt));
  	if (ret < 0) {
  		_debug("setsockopt failed");
  		goto error;
  	}
  
  	/* we want to set the don't fragment bit */
  	opt = IP_PMTUDISC_DO;
  	ret = kernel_setsockopt(local->socket, SOL_IP, IP_MTU_DISCOVER,
  				(char *) &opt, sizeof(opt));
  	if (ret < 0) {
  		_debug("setsockopt failed");
  		goto error;
  	}
  
  	write_lock_bh(&rxrpc_local_lock);
  	list_add(&local->link, &rxrpc_locals);
  	write_unlock_bh(&rxrpc_local_lock);
  
  	/* set the socket up */
  	sock = local->socket->sk;
  	sock->sk_user_data	= local;
  	sock->sk_data_ready	= rxrpc_data_ready;
  	sock->sk_error_report	= rxrpc_UDP_error_report;
  	_leave(" = 0");
  	return 0;
  
  error:
  	kernel_sock_shutdown(local->socket, SHUT_RDWR);
  	local->socket->sk->sk_user_data = NULL;
  	sock_release(local->socket);
  	local->socket = NULL;
  
  	_leave(" = %d", ret);
  	return ret;
  }
  
  /*
   * create a new local endpoint using the specified UDP address
   */
  struct rxrpc_local *rxrpc_lookup_local(struct sockaddr_rxrpc *srx)
  {
  	struct rxrpc_local *local;
  	int ret;
  
  	_enter("{%d,%u,%pI4+%hu}",
  	       srx->transport_type,
  	       srx->transport.family,
  	       &srx->transport.sin.sin_addr,
  	       ntohs(srx->transport.sin.sin_port));
  
  	down_write(&rxrpc_local_sem);
  
  	/* see if we have a suitable local local endpoint already */
  	read_lock_bh(&rxrpc_local_lock);
  
  	list_for_each_entry(local, &rxrpc_locals, link) {
  		_debug("CMP {%d,%u,%pI4+%hu}",
  		       local->srx.transport_type,
  		       local->srx.transport.family,
  		       &local->srx.transport.sin.sin_addr,
  		       ntohs(local->srx.transport.sin.sin_port));
  
  		if (local->srx.transport_type != srx->transport_type ||
  		    local->srx.transport.family != srx->transport.family)
  			continue;
  
  		switch (srx->transport.family) {
  		case AF_INET:
  			if (local->srx.transport.sin.sin_port !=
  			    srx->transport.sin.sin_port)
  				continue;
  			if (memcmp(&local->srx.transport.sin.sin_addr,
  				   &srx->transport.sin.sin_addr,
  				   sizeof(struct in_addr)) != 0)
  				continue;
  			goto found_local;
  
  		default:
  			BUG();
  		}
  	}
  
  	read_unlock_bh(&rxrpc_local_lock);
  
  	/* we didn't find one, so we need to create one */
  	local = rxrpc_alloc_local(srx);
  	if (!local) {
  		up_write(&rxrpc_local_sem);
  		return ERR_PTR(-ENOMEM);
  	}
  
  	ret = rxrpc_create_local(local);
  	if (ret < 0) {
  		up_write(&rxrpc_local_sem);
  		kfree(local);
  		_leave(" = %d", ret);
  		return ERR_PTR(ret);
  	}
  
  	up_write(&rxrpc_local_sem);
  
  	_net("LOCAL new %d {%d,%u,%pI4+%hu}",
  	     local->debug_id,
  	     local->srx.transport_type,
  	     local->srx.transport.family,
  	     &local->srx.transport.sin.sin_addr,
  	     ntohs(local->srx.transport.sin.sin_port));
  
  	_leave(" = %p [new]", local);
  	return local;
  
  found_local:
  	rxrpc_get_local(local);
  	read_unlock_bh(&rxrpc_local_lock);
  	up_write(&rxrpc_local_sem);
  
  	_net("LOCAL old %d {%d,%u,%pI4+%hu}",
  	     local->debug_id,
  	     local->srx.transport_type,
  	     local->srx.transport.family,
  	     &local->srx.transport.sin.sin_addr,
  	     ntohs(local->srx.transport.sin.sin_port));
  
  	_leave(" = %p [reuse]", local);
  	return local;
  }
  
  /*
   * release a local endpoint
   */
  void rxrpc_put_local(struct rxrpc_local *local)
  {
  	_enter("%p{u=%d}", local, atomic_read(&local->usage));
  
  	ASSERTCMP(atomic_read(&local->usage), >, 0);
  
  	/* to prevent a race, the decrement and the dequeue must be effectively
  	 * atomic */
  	write_lock_bh(&rxrpc_local_lock);
  	if (unlikely(atomic_dec_and_test(&local->usage))) {
  		_debug("destroy local");
  		rxrpc_queue_work(&local->destroyer);
  	}
  	write_unlock_bh(&rxrpc_local_lock);
  	_leave("");
  }
  
  /*
   * destroy a local endpoint
   */
  static void rxrpc_destroy_local(struct work_struct *work)
  {
  	struct rxrpc_local *local =
  		container_of(work, struct rxrpc_local, destroyer);
  
  	_enter("%p{%d}", local, atomic_read(&local->usage));
  
  	down_write(&rxrpc_local_sem);
  
  	write_lock_bh(&rxrpc_local_lock);
  	if (atomic_read(&local->usage) > 0) {
  		write_unlock_bh(&rxrpc_local_lock);
  		up_read(&rxrpc_local_sem);
  		_leave(" [resurrected]");
  		return;
  	}
  
  	list_del(&local->link);
  	local->socket->sk->sk_user_data = NULL;
  	write_unlock_bh(&rxrpc_local_lock);
  
  	downgrade_write(&rxrpc_local_sem);
  
  	ASSERT(list_empty(&local->services));
  	ASSERT(!work_pending(&local->acceptor));
  	ASSERT(!work_pending(&local->rejecter));
  
  	/* finish cleaning up the local descriptor */
  	rxrpc_purge_queue(&local->accept_queue);
  	rxrpc_purge_queue(&local->reject_queue);
  	kernel_sock_shutdown(local->socket, SHUT_RDWR);
  	sock_release(local->socket);
  
  	up_read(&rxrpc_local_sem);
  
  	_net("DESTROY LOCAL %d", local->debug_id);
  	kfree(local);
  
  	if (list_empty(&rxrpc_locals))
  		wake_up_all(&rxrpc_local_wq);
  
  	_leave("");
  }
  
  /*
   * preemptively destroy all local local endpoint rather than waiting for
   * them to be destroyed
   */
  void __exit rxrpc_destroy_all_locals(void)
  {
  	DECLARE_WAITQUEUE(myself,current);
  
  	_enter("");
  
  	/* we simply have to wait for them to go away */
  	if (!list_empty(&rxrpc_locals)) {
  		set_current_state(TASK_UNINTERRUPTIBLE);
  		add_wait_queue(&rxrpc_local_wq, &myself);
  
  		while (!list_empty(&rxrpc_locals)) {
  			schedule();
  			set_current_state(TASK_UNINTERRUPTIBLE);
  		}
  
  		remove_wait_queue(&rxrpc_local_wq, &myself);
  		set_current_state(TASK_RUNNING);
  	}
  
  	_leave("");
  }