/* net/atm/signaling.c - ATM signaling */
  
  /* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */

  #define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__

  
  #include <linux/errno.h>	/* error codes */
  #include <linux/kernel.h>	/* printk */
  #include <linux/skbuff.h>
  #include <linux/wait.h>
  #include <linux/sched.h>	/* jiffies and HZ */
  #include <linux/atm.h>		/* ATM stuff */
  #include <linux/atmsap.h>
  #include <linux/atmsvc.h>
  #include <linux/atmdev.h>
  #include <linux/bitops.h>

  #include <linux/slab.h>

  
  #include "resources.h"
  #include "signaling.h"

  #undef WAIT_FOR_DEMON		/* #define this if system calls on SVC sockets
  				   should block until the demon runs.
  				   Danger: may cause nasty hangs if the demon
  				   crashes. */

  struct atm_vcc *sigd = NULL;
  #ifdef WAIT_FOR_DEMON
  static DECLARE_WAIT_QUEUE_HEAD(sigd_sleep);
  #endif

  static void sigd_put_skb(struct sk_buff *skb)
  {
  #ifdef WAIT_FOR_DEMON

  	DECLARE_WAITQUEUE(wait, current);

  	add_wait_queue(&sigd_sleep, &wait);

  	while (!sigd) {
  		set_current_state(TASK_UNINTERRUPTIBLE);

  		pr_debug("atmsvc: waiting for signaling daemon...
  ");

  		schedule();
  	}
  	current->state = TASK_RUNNING;

  	remove_wait_queue(&sigd_sleep, &wait);

  #else
  	if (!sigd) {

  		pr_debug("atmsvc: no signaling daemon
  ");

  		kfree_skb(skb);
  		return;
  	}
  #endif

  	atm_force_charge(sigd, skb->truesize);
  	skb_queue_tail(&sk_atm(sigd)->sk_receive_queue, skb);

  	sk_atm(sigd)->sk_data_ready(sk_atm(sigd), skb->len);
  }

  static void modify_qos(struct atm_vcc *vcc, struct atmsvc_msg *msg)

  {
  	struct sk_buff *skb;

  	if (test_bit(ATM_VF_RELEASED, &vcc->flags) ||
  	    !test_bit(ATM_VF_READY, &vcc->flags))

  		return;
  	msg->type = as_error;

  	if (!vcc->dev->ops->change_qos)
  		msg->reply = -EOPNOTSUPP;

  	else {
  		/* should lock VCC */

  		msg->reply = vcc->dev->ops->change_qos(vcc, &msg->qos,
  						       msg->reply);
  		if (!msg->reply)
  			msg->type = as_okay;

  	}
  	/*
  	 * Should probably just turn around the old skb. But the, the buffer
  	 * space accounting needs to follow the change too. Maybe later.
  	 */

  	while (!(skb = alloc_skb(sizeof(struct atmsvc_msg), GFP_KERNEL)))

  		schedule();

  	*(struct atmsvc_msg *)skb_put(skb, sizeof(struct atmsvc_msg)) = *msg;

  	sigd_put_skb(skb);
  }

  static int sigd_send(struct atm_vcc *vcc, struct sk_buff *skb)

  {
  	struct atmsvc_msg *msg;
  	struct atm_vcc *session_vcc;
  	struct sock *sk;
  
  	msg = (struct atmsvc_msg *) skb->data;
  	atomic_sub(skb->truesize, &sk_atm(vcc)->sk_wmem_alloc);

  	vcc = *(struct atm_vcc **) &msg->vcc;

  	pr_debug("%d (0x%lx)
  ", (int)msg->type, (unsigned long)vcc);

  	sk = sk_atm(vcc);
  
  	switch (msg->type) {

  	case as_okay:
  		sk->sk_err = -msg->reply;
  		clear_bit(ATM_VF_WAITING, &vcc->flags);
  		if (!*vcc->local.sas_addr.prv && !*vcc->local.sas_addr.pub) {
  			vcc->local.sas_family = AF_ATMSVC;
  			memcpy(vcc->local.sas_addr.prv,
  			       msg->local.sas_addr.prv, ATM_ESA_LEN);
  			memcpy(vcc->local.sas_addr.pub,
  			       msg->local.sas_addr.pub, ATM_E164_LEN + 1);
  		}
  		session_vcc = vcc->session ? vcc->session : vcc;
  		if (session_vcc->vpi || session_vcc->vci)

  			break;

  		session_vcc->itf = msg->pvc.sap_addr.itf;
  		session_vcc->vpi = msg->pvc.sap_addr.vpi;
  		session_vcc->vci = msg->pvc.sap_addr.vci;
  		if (session_vcc->vpi || session_vcc->vci)
  			session_vcc->qos = msg->qos;
  		break;
  	case as_error:
  		clear_bit(ATM_VF_REGIS, &vcc->flags);
  		clear_bit(ATM_VF_READY, &vcc->flags);
  		sk->sk_err = -msg->reply;
  		clear_bit(ATM_VF_WAITING, &vcc->flags);
  		break;
  	case as_indicate:
  		vcc = *(struct atm_vcc **)&msg->listen_vcc;
  		sk = sk_atm(vcc);
  		pr_debug("as_indicate!!!
  ");
  		lock_sock(sk);
  		if (sk_acceptq_is_full(sk)) {
  			sigd_enq(NULL, as_reject, vcc, NULL, NULL);
  			dev_kfree_skb(skb);
  			goto as_indicate_complete;
  		}
  		sk->sk_ack_backlog++;
  		skb_queue_tail(&sk->sk_receive_queue, skb);

  		pr_debug("waking sk_sleep(sk) 0x%p
  ", sk_sleep(sk));

  		sk->sk_state_change(sk);

  as_indicate_complete:

  		release_sock(sk);
  		return 0;
  	case as_close:
  		set_bit(ATM_VF_RELEASED, &vcc->flags);
  		vcc_release_async(vcc, msg->reply);
  		goto out;
  	case as_modify:
  		modify_qos(vcc, msg);
  		break;
  	case as_addparty:
  	case as_dropparty:
  		sk->sk_err_soft = msg->reply;
  					/* < 0 failure, otherwise ep_ref */
  		clear_bit(ATM_VF_WAITING, &vcc->flags);
  		break;
  	default:
  		pr_alert("bad message type %d
  ", (int)msg->type);
  		return -EINVAL;

  	}
  	sk->sk_state_change(sk);
  out:
  	dev_kfree_skb(skb);
  	return 0;
  }

  void sigd_enq2(struct atm_vcc *vcc, enum atmsvc_msg_type type,
  	       struct atm_vcc *listen_vcc, const struct sockaddr_atmpvc *pvc,
  	       const struct sockaddr_atmsvc *svc, const struct atm_qos *qos,
  	       int reply)

  {
  	struct sk_buff *skb;
  	struct atmsvc_msg *msg;

  	static unsigned int session = 0;

  	pr_debug("%d (0x%p)
  ", (int)type, vcc);

  	while (!(skb = alloc_skb(sizeof(struct atmsvc_msg), GFP_KERNEL)))

  		schedule();

  	msg = (struct atmsvc_msg *)skb_put(skb, sizeof(struct atmsvc_msg));
  	memset(msg, 0, sizeof(*msg));

  	msg->type = type;
  	*(struct atm_vcc **) &msg->vcc = vcc;
  	*(struct atm_vcc **) &msg->listen_vcc = listen_vcc;
  	msg->reply = reply;

  	if (qos)
  		msg->qos = *qos;
  	if (vcc)
  		msg->sap = vcc->sap;
  	if (svc)
  		msg->svc = *svc;
  	if (vcc)
  		msg->local = vcc->local;
  	if (pvc)
  		msg->pvc = *pvc;

  	if (vcc) {
  		if (type == as_connect && test_bit(ATM_VF_SESSION, &vcc->flags))
  			msg->session = ++session;
  			/* every new pmp connect gets the next session number */
  	}
  	sigd_put_skb(skb);

  	if (vcc)
  		set_bit(ATM_VF_REGIS, &vcc->flags);

  }

  void sigd_enq(struct atm_vcc *vcc, enum atmsvc_msg_type type,
  	      struct atm_vcc *listen_vcc, const struct sockaddr_atmpvc *pvc,
  	      const struct sockaddr_atmsvc *svc)

  {

  	sigd_enq2(vcc, type, listen_vcc, pvc, svc, vcc ? &vcc->qos : NULL, 0);

  	/* other ISP applications may use "reply" */
  }

  static void purge_vcc(struct atm_vcc *vcc)
  {
  	if (sk_atm(vcc)->sk_family == PF_ATMSVC &&

  	    !test_bit(ATM_VF_META, &vcc->flags)) {
  		set_bit(ATM_VF_RELEASED, &vcc->flags);
  		clear_bit(ATM_VF_REGIS, &vcc->flags);

  		vcc_release_async(vcc, -EUNATCH);
  	}
  }

  static void sigd_close(struct atm_vcc *vcc)
  {

  	struct sock *s;
  	int i;

  	pr_debug("
  ");

  	sigd = NULL;
  	if (skb_peek(&sk_atm(vcc)->sk_receive_queue))

  		pr_err("closing with requests pending
  ");

  	skb_queue_purge(&sk_atm(vcc)->sk_receive_queue);
  
  	read_lock(&vcc_sklist_lock);

  	for (i = 0; i < VCC_HTABLE_SIZE; ++i) {

  		struct hlist_head *head = &vcc_hash[i];

  		sk_for_each(s, head) {

  			vcc = atm_sk(s);

  			purge_vcc(vcc);

  		}
  	}
  	read_unlock(&vcc_sklist_lock);
  }

  static struct atmdev_ops sigd_dev_ops = {
  	.close = sigd_close,
  	.send =	sigd_send
  };

  static struct atm_dev sigd_dev = {
  	.ops =		&sigd_dev_ops,
  	.type =		"sig",
  	.number =	999,

  	.lock =		__SPIN_LOCK_UNLOCKED(sigd_dev.lock)

  };

  int sigd_attach(struct atm_vcc *vcc)
  {

  	if (sigd)
  		return -EADDRINUSE;

  	pr_debug("
  ");

  	sigd = vcc;
  	vcc->dev = &sigd_dev;
  	vcc_insert_socket(sk_atm(vcc));

  	set_bit(ATM_VF_META, &vcc->flags);
  	set_bit(ATM_VF_READY, &vcc->flags);

  #ifdef WAIT_FOR_DEMON
  	wake_up(&sigd_sleep);
  #endif
  	return 0;
  }