path: root/net/ax25/ax25_timer.c

/*
 * ax25_timer.c: timer subroutines for NEW-AX.25
 *
 * Authors:    Jens David (DG1KJD), Matthias Welwarsky (DG2FEF), Jonathan (G4KLX
 *             Alan Cox (GW4PTS), Joerg (DL1BKE), et al
 *
 * Comment:
 *
 * Changelog:
 *
 * License:    This module 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/config.h>
#include <linux/netdevice.h>
#include <linux/tcp.h>
#include <net/sock.h>
#include <net/ax25dev.h>
#include <net/ax25.h>

#include "ax25_core.h"
#include "ax25_ddi.h"
#include "ax25_in.h"
#include "ax25_subr.h"
#include "ax25_timer.h"

static void ax25_wrt_timeout(ax25_cb *);

/*
 *	AX.25 TIMER
 *
 *	This routine is called every 100ms. Decrement timer by this
 *	amount - if expired then process the event.
 */
void ax25_timer(ax25_cb *ax25)
{
	int wrt_timeout;

	switch (ax25->state) {
        case AX25_LISTEN:
		/*
		 * never kill listening sockets. let the be moved to
		 * AX25_STATE_0 first. ax25_release() does this.
		 */
		return;

	case AX25_STATE_0:
		/*
		 * don't kill if a frame signalling a state change is
		 * still pending
		 */
		if (ax25->condition & AX25_COND_STATE_CHANGE)
			break;

		if (ax25->sk) {
			/*
			 * ax25_release() sets ax25->sk = NULL, releasing the
			 * connection between the socket and the underlying control
			 * structure, we handle that further down
			 */

			/* almost dead, notify socket */
			if (!ax25->sk->dead)
				ax25_close_socket(ax25->sk, 0);
			break;
		}

		/*
		 * wait a certain time before destroying the control block
		 */
		if (ax25->killtimer > 0 && --ax25->killtimer > 0)
			break;

		/*
		 * if a peer exists in STATE [12], disconnect it. this handles
		 * "connection timed out" for digipeated connections.
		 *
		 * else if no peer exists, destroy this control block.
		 */
		if (ax25->peer) {
			if (ax25->peer->state < AX25_STATE_3)
				ax25_destroy_cb(ax25->peer);
			else
				break;
		}

		ax25_destroy_cb(ax25);
		return;

	case AX25_STATE_3:
	        write_lock(&ax25->timer_lock);
		if (!ax25->peer && !ax25->sk && ax25->idletimer > 0 && --ax25->idletimer == 0)
			ax25_set_cond(ax25, AX25_COND_RELEASE);
		write_unlock(&ax25->timer_lock);
		/* fall through */
	case AX25_STATE_4:
	        write_lock(&ax25->timer_lock);
		if (ax25->condition & AX25_COND_ACK_PENDING) {
			if (ax25->ack_timer > 0)
				ax25->ack_timer--;
			else
				ax25_timeout_response(ax25);
		}

		/*
		 * Our peer connection has seen a DISC or DM and we're about to change to
		 * state 2. We don't DISC until we've delivered all queued data
		 */
		if (ax25->condition & AX25_COND_RELEASE) {
			if (!skb_queue_len(&ax25->write_queue) && !skb_queue_len(&ax25->ack_queue)) {
				ax25->n2count   = 1;
				ax25->ack_timer = 0;
				ax25_start_t1(ax25);
				ax25_clr_cond(ax25, AX25_COND_RELEASE);
				ax25->state = AX25_STATE_2;
				ax25_tx_command(ax25, AX25_DISC, AX25_POLLON);
			}

		/*
		 * Check the state of the receive buffer. This is part of the flow control
		 * and should be done in ax25_rcvmsg();
		 */
		} else  if (ax25->sk && skb_queue_len(&ax25->rcv_queue)) {
			struct sk_buff *skb;

			while ((skb = skb_peek(&ax25->rcv_queue)) != NULL) {
				if (ax25->sk->shutdown & RCV_SHUTDOWN)
					break;
				if (atomic_read(&ax25->sk->rmem_alloc) + skb->truesize < ax25->sk->rcvbuf) {
					skb_dequeue(&ax25->rcv_queue);
					sock_queue_rcv_skb(ax25->sk, skb);
				} else
					break;
			}
			if (skb == NULL) {
				ax25_clr_cond(ax25, AX25_COND_OWN_RX_BUSY);
				ax25_set_cond(ax25, AX25_COND_STATE_CHANGE);
				ax25->state = AX25_STATE_4;
				ax25_transmit_enquiry(ax25);
			}
		}
		write_unlock(&ax25->timer_lock);
		break;

	default: /* state 1/2 */
		break;
	}

	/* ax25_wrt_timout() must be called unlocked as ax25_disconnect()
	 * sets ax25->timer_lock
	 */

	write_lock(&ax25->timer_lock);
	wrt_timeout = (ax25->wrt_timer > 0 && --ax25->wrt_timer == 0);
	write_unlock(&ax25->timer_lock);

	if (wrt_timeout)
		ax25_wrt_timeout(ax25);


}

static void ax25_wrt_timeout(ax25_cb *ax25)
{
	ax25_cb *peer = ax25->peer;
	switch (ax25->state) {
	case AX25_STATE_1:
		if (ax25->n2count == ax25->n2) {
			if (ax25->seqmask == AX25_SEQMASK) {
				ax25_disconnect(ax25, ETIMEDOUT);
				if (ax25->sk)
					ax25_close_socket(ax25->sk, ETIMEDOUT);
				else if (peer) {
					ax25_disconnect(peer, 0);
				}
			} else {
				ax25->seqmask   = AX25_SEQMASK;
				ax25->window    = ax25_dev_get_value(ax25->device, AX25_VALUES_WINDOW);
				ax25->n2count   = 0;
				ax25_start_t1(ax25);
				ax25_tx_command(ax25, AX25_SABM, AX25_POLLON);
			}
		} else {
			ax25->n2count++;
			ax25_start_t1(ax25);
			if (ax25->seqmask == AX25_SEQMASK)
				ax25_tx_command(ax25, AX25_SABM, AX25_POLLON);
			else
				ax25_tx_command(ax25, AX25_SABME, AX25_POLLON);
		}
		break;

	case AX25_STATE_2:
		if (ax25->n2count == ax25->n2) {
			if (ax25->sk)
				ax25_close_socket(ax25->sk, 0);
			ax25_disconnect(ax25, 0);
		} else {
			ax25->n2count++;
			ax25_start_t1(ax25);
			ax25_tx_command(ax25, AX25_DISC, AX25_POLLON);
		}
		break;

	case AX25_STATE_3:
		ax25->vs_rtt  = -1;
		ax25->n2count = 1;
		ax25_start_t1(ax25);
		ax25->state = AX25_STATE_4;

		/*
		 * We are angry now.
		 * Use CSMA. If master responds to poll, circuit will be saved
		 * and dama_mode will be re-enabled automagically in ax25_in.c
		 */
		ax25_dev_set_dama(ax25->device, 0);
		ax25_transmit_enquiry(ax25);
		break;

	case AX25_STATE_4:
		if (ax25->n2count == ax25->n2) {
			if (peer) {
				ax25_set_cond(peer, AX25_COND_RELEASE);
				ax25->killtimer  = 90 * AX25_SLOWHZ;
			} else if (ax25->sk)
				ax25_close_socket(ax25->sk, ETIMEDOUT);
			ax25_disconnect(ax25, ETIMEDOUT);
		} else {
			ax25->n2count++;
			ax25_transmit_enquiry(ax25);
		}
		break;
	}
}


/* -------------------------------------------------------------------- */

/************************************************************************/
/*	Module support functions follow.				*/
/************************************************************************/

static struct protocol_struct {
	struct protocol_struct *next;
	unsigned int pid;
	int (*func)(struct sk_buff *, ax25_cb *);
} *protocol_list = NULL;

static struct linkfail_struct {
	struct linkfail_struct *next;
	void (*func)(ax25_cb *, int);
} *linkfail_list = NULL;

static struct listen_struct {
	struct listen_struct *next;
	ax25_address  callsign;
	struct net_device *dev;
} *listen_list = NULL;

int ax25_protocol_register(unsigned int pid, int (*func)(struct sk_buff *, ax25_cb *))
{
	struct protocol_struct *protocol;
	unsigned long flags;

	if (pid == AX25_P_TEXT || pid == AX25_P_SEGMENT)
		return 0;

	if ((protocol = (struct protocol_struct *)kmalloc(sizeof(*protocol), GFP_ATOMIC)) == NULL)
		return 0;

	protocol->pid  = pid;
	protocol->func = func;

	save_flags(flags);
	cli();

	protocol->next = protocol_list;
	protocol_list  = protocol;

	restore_flags(flags);

	return 1;
}

void ax25_protocol_release(unsigned int pid)
{
	struct protocol_struct *s, *protocol = protocol_list;
	unsigned long flags;

	if (protocol == NULL)
		return;

	save_flags(flags);
	cli();

	if (protocol->pid == pid) {
		protocol_list = protocol->next;
		restore_flags(flags);
		kfree(protocol);
		return;
	}

	while (protocol != NULL && protocol->next != NULL) {
		if (protocol->next->pid == pid) {
			s = protocol->next;
			protocol->next = protocol->next->next;
			restore_flags(flags);
			kfree(s);
			return;
		}

		protocol = protocol->next;
	}

	restore_flags(flags);
}

int ax25_linkfail_register(void (*func)(ax25_cb *, int))
{
	struct linkfail_struct *linkfail;
	unsigned long flags;

	if ((linkfail = (struct linkfail_struct *)kmalloc(sizeof(*linkfail), GFP_ATOMIC)) == NULL)
		return 0;

	linkfail->func = func;

	save_flags(flags);
	cli();

	linkfail->next = linkfail_list;
	linkfail_list  = linkfail;

	restore_flags(flags);

	return 1;
}

void ax25_linkfail_release(void (*func)(ax25_cb *, int))
{
	struct linkfail_struct *s, *linkfail = linkfail_list;
	unsigned long flags;

	if (linkfail == NULL)
		return;

	save_flags(flags);
	cli();

	if (linkfail->func == func) {
		linkfail_list = linkfail->next;
		restore_flags(flags);
		kfree(linkfail);
		return;
	}

	while (linkfail != NULL && linkfail->next != NULL) {
		if (linkfail->next->func == func) {
			s = linkfail->next;
			linkfail->next = linkfail->next->next;
			restore_flags(flags);
			kfree(s);
			return;
		}

		linkfail = linkfail->next;
	}

	restore_flags(flags);
}

static char empty_addr[AX25_ADDR_LEN] = {0, 0, 0, 0, 0, 0, 0};

int ax25_listen_register(ax25_address *callsign, struct net_device *dev)
{
	ax25_cb *ax25;

	ax25_addr_t addr;

	addr.dcount = 0;
	addr.src    = *callsign;
	memcpy(&addr.dest, empty_addr, AX25_ADDR_LEN);

	if (ax25_find_cb(&addr, dev) != NULL)
		return 0;

	if ((ax25 = ax25_create_cb()) == NULL)
		return 0;

	ax25->addr.src = *callsign;

	ax25_fillin_cb(ax25, dev);
	ax25_insert_cb(ax25);

	return 1;
}

void ax25_listen_release(ax25_address *callsign, struct net_device *dev)
{
	ax25_cb *ax25;

	ax25_addr_t addr;

	addr.dcount = 0;
	addr.src    = *callsign;
	memcpy(&addr.dest, empty_addr, AX25_ADDR_LEN);

	if ((ax25 = ax25_find_cb(&addr, dev)) != NULL)
		ax25_destroy_cb(ax25);
}

int (*ax25_protocol_function(unsigned int pid))(struct sk_buff *, ax25_cb *)
{
	struct protocol_struct *protocol;

	for (protocol = protocol_list; protocol != NULL; protocol = protocol->next)
		if (protocol->pid == pid)
			return protocol->func;

	return NULL;
}

int ax25_listen_mine(ax25_address *callsign, struct net_device *dev)
{
	struct listen_struct *listen;

	for (listen = listen_list; listen != NULL; listen = listen->next)
		if (ax25cmp(&listen->callsign, callsign) == 0 && (listen->dev == dev || listen->dev == NULL))
			return 1;

	return 0;
}

void ax25_link_failed(ax25_cb *ax25, int reason)
{
	struct linkfail_struct *linkfail;

	for (linkfail = linkfail_list; linkfail != NULL; linkfail = linkfail->next)
		(linkfail->func)(ax25, reason);
}

int ax25_protocol_is_registered(unsigned int pid)
{
	struct protocol_struct *protocol;

	for (protocol = protocol_list; protocol != NULL; protocol = protocol->next)
		if (protocol->pid == pid)
			return 1;

	return 0;
}