/* * libpri: An implementation of Primary Rate ISDN * * Written by Mark Spencer <markster@digium.com> * * Copyright (C) 2001-2005, Digium * All Rights Reserved. * * 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. *  * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the * GNU General Public License for more details. *  * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  * */#include <stdio.h>#include <string.h>#include <stdlib.h>#include <unistd.h>#include <errno.h>#include "compat.h"#include "libpri.h"#include "pri_internal.h"#include "pri_q921.h" #include "pri_q931.h"/* * Define RANDOM_DROPS To randomly drop packets in order to simulate loss for testing * retransmission functionality *//*#define RANDOM_DROPS*/#define Q921_INIT(pri, hf) do { \	memset(&(hf),0,sizeof(hf)); \	(hf).h.sapi = (pri)->sapi; \	(hf).h.ea1 = 0; \	(hf).h.ea2 = 1; \	(hf).h.tei = (pri)->tei; \} while(0)static void reschedule_t203(struct pri *pri);static void q921_discard_retransmissions(struct pri *pri){	struct q921_frame *f, *p;	f = pri->txqueue;	while(f) {		p = f;		f = f->next;		/* Free frame */		free(p);	}	pri->txqueue = NULL;}static int q921_transmit(struct pri *pri, q921_h *h, int len) {	int res;	if (pri->master)		return q921_transmit(pri->master, h, len);#ifdef RANDOM_DROPS   if (!(random() % 3)) {         pri_message(pri, " === Dropping Packet ===\n");         return 0;   }#endif   #ifdef LIBPRI_COUNTERS	pri->q921_txcount++;      #endif	/* Just send it raw */	if (pri->debug & (PRI_DEBUG_Q921_DUMP | PRI_DEBUG_Q921_RAW))		q921_dump(pri, h, len, pri->debug & PRI_DEBUG_Q921_RAW, 1);	/* Write an extra two bytes for the FCS */	res = pri->write_func ? pri->write_func(pri, h, len + 2) : 0;	if (res != (len + 2)) {		pri_error(pri, "Short write: %d/%d (%s)\n", res, len + 2, strerror(errno));		return -1;	}	reschedule_t203(pri);	return 0;}static void q921_send_ua(struct pri *pri, int pfbit){	q921_h h;	Q921_INIT(pri, h);	h.u.m3 = 3;		/* M3 = 3 */	h.u.m2 = 0;		/* M2 = 0 */	h.u.p_f = pfbit;	/* Final bit on */	h.u.ft = Q921_FRAMETYPE_U;	switch(pri->localtype) {	case PRI_NETWORK:		h.h.c_r = 0;		break;	case PRI_CPE:		h.h.c_r = 1;		break;	default:		pri_error(pri, "Don't know how to U/A on a type %d node\n", pri->localtype);		return;	}	if (pri->debug & (PRI_DEBUG_Q921_STATE | PRI_DEBUG_Q921_DUMP))		pri_message(pri, "Sending Unnumbered Acknowledgement\n");	q921_transmit(pri, &h, 3);}static void q921_send_sabme_now(void *vpri);static void q921_send_sabme(void *vpri, int now){	struct pri *pri = vpri;	q921_h h;	pri_schedule_del(pri, pri->sabme_timer);	pri->sabme_timer = 0;	pri->sabme_timer = pri_schedule_event(pri, pri->timers[PRI_TIMER_T200], q921_send_sabme_now, pri);	if (!now)		return;	Q921_INIT(pri, h);	h.u.m3 = 3;	/* M3 = 3 */	h.u.m2 = 3;	/* M2 = 3 */	h.u.p_f = 1;	/* Poll bit set */	h.u.ft = Q921_FRAMETYPE_U;	switch(pri->localtype) {	case PRI_NETWORK:		h.h.c_r = 1;		break;	case PRI_CPE:		h.h.c_r = 0;		break;	default:		pri_error(pri, "Don't know how to U/A on a type %d node\n", pri->localtype);		return;	}	if (pri->debug & (PRI_DEBUG_Q921_STATE | PRI_DEBUG_Q921_DUMP))		pri_message(pri, "Sending Set Asynchronous Balanced Mode Extended\n");	q921_transmit(pri, &h, 3);	if (pri->debug & PRI_DEBUG_Q921_STATE && pri->q921_state != Q921_AWAITING_ESTABLISH)		pri_message(pri, DBGHEAD "q921_state now is Q921_AWAITING_ESTABLISH\n", DBGINFO);	pri->q921_state = Q921_AWAITING_ESTABLISH;}static void q921_send_sabme_now(void *vpri){	q921_send_sabme(vpri, 1);}static int q921_ack_packet(struct pri *pri, int num){	struct q921_frame *f, *prev = NULL;	f = pri->txqueue;	while(f) {		if (f->h.n_s == num) {			/* Cancel each packet as necessary */			/* That's our packet */			if (prev)				prev->next = f->next;			else				pri->txqueue = f->next;			if (pri->debug & PRI_DEBUG_Q921_DUMP)				pri_message(pri, "-- ACKing packet %d, new txqueue is %d (-1 means empty)\n", f->h.n_s, pri->txqueue ? pri->txqueue->h.n_s : -1);			/* Update v_a */			pri->v_a = num;			free(f);			/* Reset retransmission counter if we actually acked something */			pri->retrans = 0;			/* Decrement window size */			pri->windowlen--;			/* Search for something to send */			f = pri->txqueue;			while(f) {				if (!f->transmitted) {					/* Send it now... */					if (pri->debug & PRI_DEBUG_Q921_DUMP)						pri_message(pri, "-- Finally transmitting %d, since window opened up\n", f->h.n_s);					f->transmitted++;					pri->windowlen++;					f->h.n_r = pri->v_r;					q921_transmit(pri, (q921_h *)(&f->h), f->len);					break;				}				f = f->next;			}			return 1;		}		prev = f;		f = f->next;	}	return 0;}static void t203_expire(void *);static void t200_expire(void *);static pri_event *q921_dchannel_down(struct pri *pri);static void reschedule_t203(struct pri *pri){	if (pri->t203_timer) {		pri_schedule_del(pri, pri->t203_timer);		if (pri->debug & PRI_DEBUG_Q921_DUMP)			pri_message(pri, "-- Restarting T203 counter\n");		/* Nothing to transmit, start the T203 counter instead */		pri->t203_timer = pri_schedule_event(pri, pri->timers[PRI_TIMER_T203], t203_expire, pri);	}}static pri_event *q921_ack_rx(struct pri *pri, int ack){	int x;	int cnt=0;	pri_event *ev;	/* Make sure the ACK was within our window */	for (x=pri->v_a; (x != pri->v_s) && (x != ack); Q921_INC(x));	if (x != ack) {		/* ACK was outside of our window --- ignore */		pri_error(pri, "ACK received for '%d' outside of window of '%d' to '%d', restarting\n", ack, pri->v_a, pri->v_s);		ev = q921_dchannel_down(pri);		q921_start(pri, 1);		pri->schedev = 1;		return ev;	}	/* Cancel each packet as necessary */	if (pri->debug & PRI_DEBUG_Q921_DUMP)		pri_message(pri, "-- ACKing all packets from %d to (but not including) %d\n", pri->v_a, ack);	for (x=pri->v_a; x != ack; Q921_INC(x)) 		cnt += q921_ack_packet(pri, x);		if (!pri->txqueue) {		if (pri->debug & PRI_DEBUG_Q921_DUMP)			pri_message(pri, "-- Since there was nothing left, stopping T200 counter\n");		/* Something was ACK'd.  Stop T200 counter */		pri_schedule_del(pri, pri->t200_timer);		pri->t200_timer = 0;	}	if (pri->t203_timer) {		if (pri->debug & PRI_DEBUG_Q921_DUMP)			pri_message(pri, "-- Stopping T203 counter since we got an ACK\n");		pri_schedule_del(pri, pri->t203_timer);		pri->t203_timer = 0;	}	if (pri->txqueue) {		/* Something left to transmit, Start the T200 counter again if we stopped it */		if (pri->debug & PRI_DEBUG_Q921_DUMP)			pri_message(pri, "-- Something left to transmit (%d), restarting T200 counter\n", pri->txqueue->h.n_s);		if (!pri->t200_timer)			pri->t200_timer = pri_schedule_event(pri, pri->timers[PRI_TIMER_T200], t200_expire, pri);	} else {		if (pri->debug & PRI_DEBUG_Q921_DUMP)			pri_message(pri, "-- Nothing left, starting T203 counter\n");		/* Nothing to transmit, start the T203 counter instead */		pri->t203_timer = pri_schedule_event(pri, pri->timers[PRI_TIMER_T203], t203_expire, pri);	}	return NULL;}static void q921_reject(struct pri *pri, int pf){	q921_h h;	Q921_INIT(pri, h);	h.s.x0 = 0;	/* Always 0 */	h.s.ss = 2;	/* Reject */	h.s.ft = 1;	/* Frametype (01) */	h.s.n_r = pri->v_r;	/* Where to start retransmission */	h.s.p_f = pf;		switch(pri->localtype) {	case PRI_NETWORK:		h.h.c_r = 0;		break;	case PRI_CPE:		h.h.c_r = 1;		break;	default:		pri_error(pri, "Don't know how to U/A on a type %d node\n", pri->localtype);		return;	}	if (pri->debug & PRI_DEBUG_Q921_DUMP)		pri_message(pri, "Sending Reject (%d)\n", pri->v_r);	pri->sentrej = 1;	q921_transmit(pri, &h, 4);}static void q921_rr(struct pri *pri, int pbit, int cmd) {	q921_h h;	Q921_INIT(pri, h);	h.s.x0 = 0;	/* Always 0 */	h.s.ss = 0; /* Receive Ready */	h.s.ft = 1;	/* Frametype (01) */	h.s.n_r = pri->v_r;	/* N/R */	h.s.p_f = pbit;		/* Poll/Final set appropriately */	switch(pri->localtype) {	case PRI_NETWORK:		if (cmd)			h.h.c_r = 1;		else			h.h.c_r = 0;		break;	case PRI_CPE:		if (cmd)			h.h.c_r = 0;		else			h.h.c_r = 1;		break;	default:		pri_error(pri, "Don't know how to U/A on a type %d node\n", pri->localtype);		return;	}	pri->v_na = pri->v_r;	/* Make a note that we've already acked this */	if (pri->debug & PRI_DEBUG_Q921_DUMP)		pri_message(pri, "Sending Receiver Ready (%d)\n", pri->v_r);	q921_transmit(pri, &h, 4);}static void t200_expire(void *vpri){	struct pri *pri = vpri;	if (pri->txqueue) {		/* Retransmit first packet in the queue, setting the poll bit */		if (pri->debug & PRI_DEBUG_Q921_DUMP)			pri_message(pri, "-- T200 counter expired, What to do...\n");		/* Force Poll bit */		pri->txqueue->h.p_f = 1;			/* Update nr */		pri->txqueue->h.n_r = pri->v_r;		pri->v_na = pri->v_r;		pri->solicitfbit = 1;		pri->retrans++;      /* Up to three retransmissions */      if (pri->retrans < pri->timers[PRI_TIMER_N200]) {         /* Reschedule t200_timer */         if (pri->debug & PRI_DEBUG_Q921_DUMP)            pri_message(pri, "-- Retransmitting %d bytes\n", pri->txqueue->len);		if (pri->busy) 			q921_rr(pri, 1, 1);		else {			if (!pri->txqueue->transmitted) 				pri_error(pri, "!! Not good - head of queue has not been transmitted yet\n");			q921_transmit(pri, (q921_h *)&pri->txqueue->h, pri->txqueue->len);		}         if (pri->debug & PRI_DEBUG_Q921_DUMP)               pri_message(pri, "-- Rescheduling retransmission (%d)\n", pri->retrans);         pri->t200_timer = pri_schedule_event(pri, pri->timers[PRI_TIMER_T200], t200_expire, pri);      } else {         if (pri->debug & PRI_DEBUG_Q921_STATE)               pri_message(pri, "-- Timeout occured, restarting PRI\n");	if (pri->debug & PRI_DEBUG_Q921_STATE && pri->q921_state != Q921_LINK_CONNECTION_RELEASED)		pri_message(pri, DBGHEAD "q921_state now is Q921_LINK_CONNECTION_RELEASED\n",DBGINFO);         pri->q921_state = Q921_LINK_CONNECTION_RELEASED;      	pri->t200_timer = 0;         q921_dchannel_down(pri);         q921_start(pri, 1);         pri->schedev = 1;      }	} else if (pri->solicitfbit) {         if (pri->debug & PRI_DEBUG_Q921_DUMP)            pri_message(pri, "-- Retrying poll with f-bit\n");		pri->retrans++;		if (pri->retrans < pri->timers[PRI_TIMER_N200]) {			pri->solicitfbit = 1;			q921_rr(pri, 1, 1);			pri->t200_timer = pri_schedule_event(pri, pri->timers[PRI_TIMER_T200], t200_expire, pri);		} else {			if (pri->debug & PRI_DEBUG_Q921_STATE)				pri_message(pri, "-- Timeout occured, restarting PRI\n");			if (pri->debug & PRI_DEBUG_Q921_STATE && pri->q921_state != Q921_LINK_CONNECTION_RELEASED)				pri_message(pri, DBGHEAD "q921_state now is Q921_LINK_CONNECTION_RELEASED\n", DBGINFO);			pri->q921_state = Q921_LINK_CONNECTION_RELEASED;			pri->t200_timer = 0;			q921_dchannel_down(pri);			q921_start(pri, 1);			pri->schedev = 1;		}	} else {		pri_error(pri, "T200 counter expired, nothing to send...\n");	   	pri->t200_timer = 0;	}}int q921_transmit_iframe(struct pri *pri, void *buf, int len, int cr){	q921_frame *f, *prev=NULL;	for (f=pri->txqueue; f; f = f->next) prev = f;	f = malloc(sizeof(q921_frame) + len + 2);	if (f) {		memset(f,0,sizeof(q921_frame) + len + 2);		Q921_INIT(pri, f->h);		switch(pri->localtype) {		case PRI_NETWORK:			if (cr)				f->h.h.c_r = 1;			else				f->h.h.c_r = 0;		break;		case PRI_CPE:			if (cr)				f->h.h.c_r = 0;			else				f->h.h.c_r = 1;		break;		}		f->next = NULL;		f->transmitted = 0;		f->len = len + 4;		memcpy(f->h.data, buf, len);		f->h.n_s = pri->v_s;		f->h.n_r = pri->v_r;		pri->v_s++;		pri->v_na = pri->v_r;		f->h.p_f = 0;		f->h.ft = 0;		if (prev)			prev->next = f;		else			pri->txqueue = f;		/* Immediately transmit unless we're in a recovery state, or the window		   size is too big */		if (!pri->retrans && !pri->busy) {			if (pri->windowlen < pri->window) {				pri->windowlen++;				q921_transmit(pri, (q921_h *)(&f->h), f->len);				f->transmitted++;			} else {				if (pri->debug & PRI_DEBUG_Q921_DUMP)					pri_message(pri, "Delaying transmission of %d, window is %d/%d long\n", 						f->h.n_s, pri->windowlen, pri->window);			}		}		if (pri->t203_timer) {			if (pri->debug & PRI_DEBUG_Q921_DUMP)				pri_message(pri, "Stopping T_203 timer\n");			pri_schedule_del(pri, pri->t203_timer);			pri->t203_timer = 0;		}		if (!pri->t200_timer) {			if (pri->debug & PRI_DEBUG_Q921_DUMP)				pri_message(pri, "Starting T_200 timer\n");			pri->t200_timer = pri_schedule_event(pri, pri->timers[PRI_TIMER_T200], t200_expire, pri);		} else			if (pri->debug & PRI_DEBUG_Q921_DUMP)				pri_message(pri, "T_200 timer already going (%d)\n", pri->t200_timer);			} else {		pri_error(pri, "!! Out of memory for Q.921 transmit\n");		return -1;	}	return 0;}static void t203_expire(void *vpri){	struct pri *pri = vpri;	if (pri->q921_state == Q921_LINK_CONNECTION_ESTABLISHED) {		if (pri->debug & PRI_DEBUG_Q921_DUMP)			pri_message(pri, "T203 counter expired, sending RR and scheduling T203 again\n");		/* Solicit an F-bit in the other's RR */		pri->solicitfbit = 1;		pri->retrans = 0;		q921_rr(pri, 1, 1);		/* Start timer T200 to resend our RR if we don't get it */		pri->t203_timer = pri_schedule_event(pri, pri->timers[PRI_TIMER_T200], t200_expire, pri);	} else {		if (pri->debug & PRI_DEBUG_Q921_DUMP)			pri_message(pri, "T203 counter expired in weird state %d\n", pri->q921_state);		pri->t203_timer = 0;	}}static pri_event *q921_handle_iframe(struct pri *pri, q921_i *i, int len){	int res;	pri_event *ev;	/* Make sure this is a valid packet */	if (i->n_s == pri->v_r) {		/* Increment next expected I-frame */		Q921_INC(pri->v_r);