1/*
   2 * llc_c_ac.c - actions performed during connection state transition.
   3 *
   4 * Description:
   5 *   Functions in this module are implementation of connection component actions
   6 *   Details of actions can be found in IEEE-802.2 standard document.
   7 *   All functions have one connection and one event as input argument. All of
   8 *   them return 0 On success and 1 otherwise.
   9 *
  10 * Copyright (c) 1997 by Procom Technology, Inc.
  11 * 		 2001-2003 by Arnaldo Carvalho de Melo <acme@conectiva.com.br>
  12 *
  13 * This program can be redistributed or modified under the terms of the
  14 * GNU General Public License as published by the Free Software Foundation.
  15 * This program is distributed without any warranty or implied warranty
  16 * of merchantability or fitness for a particular purpose.
  17 *
  18 * See the GNU General Public License for more details.
  19 */
  20#include <linux/netdevice.h>
  21#include <linux/slab.h>
  22#include <net/llc_conn.h>
  23#include <net/llc_sap.h>
  24#include <net/sock.h>
  25#include <net/llc_c_ev.h>
  26#include <net/llc_c_ac.h>
  27#include <net/llc_c_st.h>
  28#include <net/llc_pdu.h>
  29#include <net/llc.h>
  30
  31
  32static int llc_conn_ac_inc_vs_by_1(struct sock *sk, struct sk_buff *skb);
  33static void llc_process_tmr_ev(struct sock *sk, struct sk_buff *skb);
  34static int llc_conn_ac_data_confirm(struct sock *sk, struct sk_buff *ev);
  35
  36static int llc_conn_ac_inc_npta_value(struct sock *sk, struct sk_buff *skb);
  37
  38static int llc_conn_ac_send_rr_rsp_f_set_ackpf(struct sock *sk,
  39					       struct sk_buff *skb);
  40
  41static int llc_conn_ac_set_p_flag_1(struct sock *sk, struct sk_buff *skb);
  42
  43#define INCORRECT 0
  44
  45int llc_conn_ac_clear_remote_busy(struct sock *sk, struct sk_buff *skb)
  46{
  47	struct llc_sock *llc = llc_sk(sk);
  48
  49	if (llc->remote_busy_flag) {
  50		u8 nr;
  51		struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
  52
  53		llc->remote_busy_flag = 0;
  54		del_timer(&llc->busy_state_timer.timer);
  55		nr = LLC_I_GET_NR(pdu);
  56		llc_conn_resend_i_pdu_as_cmd(sk, nr, 0);
  57	}
  58	return 0;
  59}
  60
  61int llc_conn_ac_conn_ind(struct sock *sk, struct sk_buff *skb)
  62{
  63	struct llc_conn_state_ev *ev = llc_conn_ev(skb);
  64
  65	ev->ind_prim = LLC_CONN_PRIM;
  66	return 0;
  67}
  68
  69int llc_conn_ac_conn_confirm(struct sock *sk, struct sk_buff *skb)
  70{
  71	struct llc_conn_state_ev *ev = llc_conn_ev(skb);
  72
  73	ev->cfm_prim = LLC_CONN_PRIM;
  74	return 0;
  75}
  76
  77static int llc_conn_ac_data_confirm(struct sock *sk, struct sk_buff *skb)
  78{
  79	struct llc_conn_state_ev *ev = llc_conn_ev(skb);
  80
  81	ev->cfm_prim = LLC_DATA_PRIM;
  82	return 0;
  83}
  84
  85int llc_conn_ac_data_ind(struct sock *sk, struct sk_buff *skb)
  86{
  87	llc_conn_rtn_pdu(sk, skb);
  88	return 0;
  89}
  90
  91int llc_conn_ac_disc_ind(struct sock *sk, struct sk_buff *skb)
  92{
  93	struct llc_conn_state_ev *ev = llc_conn_ev(skb);
  94	u8 reason = 0;
  95	int rc = 0;
  96
  97	if (ev->type == LLC_CONN_EV_TYPE_PDU) {
  98		struct llc_pdu_un *pdu = llc_pdu_un_hdr(skb);
  99
 100		if (LLC_PDU_IS_RSP(pdu) &&
 101		    LLC_PDU_TYPE_IS_U(pdu) &&
 102		    LLC_U_PDU_RSP(pdu) == LLC_2_PDU_RSP_DM)
 103			reason = LLC_DISC_REASON_RX_DM_RSP_PDU;
 104		else if (LLC_PDU_IS_CMD(pdu) &&
 105			   LLC_PDU_TYPE_IS_U(pdu) &&
 106			   LLC_U_PDU_CMD(pdu) == LLC_2_PDU_CMD_DISC)
 107			reason = LLC_DISC_REASON_RX_DISC_CMD_PDU;
 108	} else if (ev->type == LLC_CONN_EV_TYPE_ACK_TMR)
 109		reason = LLC_DISC_REASON_ACK_TMR_EXP;
 110	else
 111		rc = -EINVAL;
 112	if (!rc) {
 113		ev->reason   = reason;
 114		ev->ind_prim = LLC_DISC_PRIM;
 115	}
 116	return rc;
 117}
 118
 119int llc_conn_ac_disc_confirm(struct sock *sk, struct sk_buff *skb)
 120{
 121	struct llc_conn_state_ev *ev = llc_conn_ev(skb);
 122
 123	ev->reason   = ev->status;
 124	ev->cfm_prim = LLC_DISC_PRIM;
 125	return 0;
 126}
 127
 128int llc_conn_ac_rst_ind(struct sock *sk, struct sk_buff *skb)
 129{
 130	u8 reason = 0;
 131	int rc = 1;
 132	struct llc_conn_state_ev *ev = llc_conn_ev(skb);
 133	struct llc_pdu_un *pdu = llc_pdu_un_hdr(skb);
 134	struct llc_sock *llc = llc_sk(sk);
 135
 136	switch (ev->type) {
 137	case LLC_CONN_EV_TYPE_PDU:
 138		if (LLC_PDU_IS_RSP(pdu) &&
 139		    LLC_PDU_TYPE_IS_U(pdu) &&
 140		    LLC_U_PDU_RSP(pdu) == LLC_2_PDU_RSP_FRMR) {
 141			reason = LLC_RESET_REASON_LOCAL;
 142			rc = 0;
 143		} else if (LLC_PDU_IS_CMD(pdu) &&
 144			   LLC_PDU_TYPE_IS_U(pdu) &&
 145			   LLC_U_PDU_CMD(pdu) == LLC_2_PDU_CMD_SABME) {
 146			reason = LLC_RESET_REASON_REMOTE;
 147			rc = 0;
 148		}
 149		break;
 150	case LLC_CONN_EV_TYPE_ACK_TMR:
 151	case LLC_CONN_EV_TYPE_P_TMR:
 152	case LLC_CONN_EV_TYPE_REJ_TMR:
 153	case LLC_CONN_EV_TYPE_BUSY_TMR:
 154		if (llc->retry_count > llc->n2) {
 155			reason = LLC_RESET_REASON_LOCAL;
 156			rc = 0;
 157		}
 158		break;
 159	}
 160	if (!rc) {
 161		ev->reason   = reason;
 162		ev->ind_prim = LLC_RESET_PRIM;
 163	}
 164	return rc;
 165}
 166
 167int llc_conn_ac_rst_confirm(struct sock *sk, struct sk_buff *skb)
 168{
 169	struct llc_conn_state_ev *ev = llc_conn_ev(skb);
 170
 171	ev->reason   = 0;
 172	ev->cfm_prim = LLC_RESET_PRIM;
 173	return 0;
 174}
 175
 176int llc_conn_ac_clear_remote_busy_if_f_eq_1(struct sock *sk,
 177					    struct sk_buff *skb)
 178{
 179	struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 180
 181	if (LLC_PDU_IS_RSP(pdu) &&
 182	    LLC_PDU_TYPE_IS_I(pdu) &&
 183	    LLC_I_PF_IS_1(pdu) && llc_sk(sk)->ack_pf)
 184		llc_conn_ac_clear_remote_busy(sk, skb);
 185	return 0;
 186}
 187
 188int llc_conn_ac_stop_rej_tmr_if_data_flag_eq_2(struct sock *sk,
 189					       struct sk_buff *skb)
 190{
 191	struct llc_sock *llc = llc_sk(sk);
 192
 193	if (llc->data_flag == 2)
 194		del_timer(&llc->rej_sent_timer.timer);
 195	return 0;
 196}
 197
 198int llc_conn_ac_send_disc_cmd_p_set_x(struct sock *sk, struct sk_buff *skb)
 199{
 200	int rc = -ENOBUFS;
 201	struct llc_sock *llc = llc_sk(sk);
 202	struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_U, 0);
 203
 204	if (nskb) {
 205		struct llc_sap *sap = llc->sap;
 206
 207		llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap,
 208				    llc->daddr.lsap, LLC_PDU_CMD);
 209		llc_pdu_init_as_disc_cmd(nskb, 1);
 210		rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
 211		if (unlikely(rc))
 212			goto free;
 213		llc_conn_send_pdu(sk, nskb);
 214		llc_conn_ac_set_p_flag_1(sk, skb);
 215	}
 216out:
 217	return rc;
 218free:
 219	kfree_skb(nskb);
 220	goto out;
 221}
 222
 223int llc_conn_ac_send_dm_rsp_f_set_p(struct sock *sk, struct sk_buff *skb)
 224{
 225	int rc = -ENOBUFS;
 226	struct llc_sock *llc = llc_sk(sk);
 227	struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_U, 0);
 228
 229	if (nskb) {
 230		struct llc_sap *sap = llc->sap;
 231		u8 f_bit;
 232
 233		llc_pdu_decode_pf_bit(skb, &f_bit);
 234		llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap,
 235				    llc->daddr.lsap, LLC_PDU_RSP);
 236		llc_pdu_init_as_dm_rsp(nskb, f_bit);
 237		rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
 238		if (unlikely(rc))
 239			goto free;
 240		llc_conn_send_pdu(sk, nskb);
 241	}
 242out:
 243	return rc;
 244free:
 245	kfree_skb(nskb);
 246	goto out;
 247}
 248
 249int llc_conn_ac_send_dm_rsp_f_set_1(struct sock *sk, struct sk_buff *skb)
 250{
 251	int rc = -ENOBUFS;
 252	struct llc_sock *llc = llc_sk(sk);
 253	struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_U, 0);
 254
 255	if (nskb) {
 256		struct llc_sap *sap = llc->sap;
 257
 258		llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap,
 259				    llc->daddr.lsap, LLC_PDU_RSP);
 260		llc_pdu_init_as_dm_rsp(nskb, 1);
 261		rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
 262		if (unlikely(rc))
 263			goto free;
 264		llc_conn_send_pdu(sk, nskb);
 265	}
 266out:
 267	return rc;
 268free:
 269	kfree_skb(nskb);
 270	goto out;
 271}
 272
 273int llc_conn_ac_send_frmr_rsp_f_set_x(struct sock *sk, struct sk_buff *skb)
 274{
 275	u8 f_bit;
 276	int rc = -ENOBUFS;
 277	struct sk_buff *nskb;
 278	struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 279	struct llc_sock *llc = llc_sk(sk);
 280
 281	llc->rx_pdu_hdr = *((u32 *)pdu);
 282	if (LLC_PDU_IS_CMD(pdu))
 283		llc_pdu_decode_pf_bit(skb, &f_bit);
 284	else
 285		f_bit = 0;
 286	nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_U,
 287			       sizeof(struct llc_frmr_info));
 288	if (nskb) {
 289		struct llc_sap *sap = llc->sap;
 290
 291		llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap,
 292				    llc->daddr.lsap, LLC_PDU_RSP);
 293		llc_pdu_init_as_frmr_rsp(nskb, pdu, f_bit, llc->vS,
 294					 llc->vR, INCORRECT);
 295		rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
 296		if (unlikely(rc))
 297			goto free;
 298		llc_conn_send_pdu(sk, nskb);
 299	}
 300out:
 301	return rc;
 302free:
 303	kfree_skb(nskb);
 304	goto out;
 305}
 306
 307int llc_conn_ac_resend_frmr_rsp_f_set_0(struct sock *sk, struct sk_buff *skb)
 308{
 309	int rc = -ENOBUFS;
 310	struct llc_sock *llc = llc_sk(sk);
 311	struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_U,
 312					       sizeof(struct llc_frmr_info));
 313
 314	if (nskb) {
 315		struct llc_sap *sap = llc->sap;
 316		struct llc_pdu_sn *pdu = (struct llc_pdu_sn *)&llc->rx_pdu_hdr;
 317
 318		llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap,
 319				    llc->daddr.lsap, LLC_PDU_RSP);
 320		llc_pdu_init_as_frmr_rsp(nskb, pdu, 0, llc->vS,
 321					 llc->vR, INCORRECT);
 322		rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
 323		if (unlikely(rc))
 324			goto free;
 325		llc_conn_send_pdu(sk, nskb);
 326	}
 327out:
 328	return rc;
 329free:
 330	kfree_skb(nskb);
 331	goto out;
 332}
 333
 334int llc_conn_ac_resend_frmr_rsp_f_set_p(struct sock *sk, struct sk_buff *skb)
 335{
 336	u8 f_bit;
 337	int rc = -ENOBUFS;
 338	struct sk_buff *nskb;
 339	struct llc_sock *llc = llc_sk(sk);
 340
 341	llc_pdu_decode_pf_bit(skb, &f_bit);
 342	nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_U,
 343			       sizeof(struct llc_frmr_info));
 344	if (nskb) {
 345		struct llc_sap *sap = llc->sap;
 346		struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 347
 348		llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap,
 349				    llc->daddr.lsap, LLC_PDU_RSP);
 350		llc_pdu_init_as_frmr_rsp(nskb, pdu, f_bit, llc->vS,
 351					 llc->vR, INCORRECT);
 352		rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
 353		if (unlikely(rc))
 354			goto free;
 355		llc_conn_send_pdu(sk, nskb);
 356	}
 357out:
 358	return rc;
 359free:
 360	kfree_skb(nskb);
 361	goto out;
 362}
 363
 364int llc_conn_ac_send_i_cmd_p_set_1(struct sock *sk, struct sk_buff *skb)
 365{
 366	int rc;
 367	struct llc_sock *llc = llc_sk(sk);
 368	struct llc_sap *sap = llc->sap;
 369
 370	llc_pdu_header_init(skb, LLC_PDU_TYPE_I, sap->laddr.lsap,
 371			    llc->daddr.lsap, LLC_PDU_CMD);
 372	llc_pdu_init_as_i_cmd(skb, 1, llc->vS, llc->vR);
 373	rc = llc_mac_hdr_init(skb, llc->dev->dev_addr, llc->daddr.mac);
 374	if (likely(!rc)) {
 375		skb_get(skb);
 376		llc_conn_send_pdu(sk, skb);
 377		llc_conn_ac_inc_vs_by_1(sk, skb);
 378	}
 379	return rc;
 380}
 381
 382static int llc_conn_ac_send_i_cmd_p_set_0(struct sock *sk, struct sk_buff *skb)
 383{
 384	int rc;
 385	struct llc_sock *llc = llc_sk(sk);
 386	struct llc_sap *sap = llc->sap;
 387
 388	llc_pdu_header_init(skb, LLC_PDU_TYPE_I, sap->laddr.lsap,
 389			    llc->daddr.lsap, LLC_PDU_CMD);
 390	llc_pdu_init_as_i_cmd(skb, 0, llc->vS, llc->vR);
 391	rc = llc_mac_hdr_init(skb, llc->dev->dev_addr, llc->daddr.mac);
 392	if (likely(!rc)) {
 393		skb_get(skb);
 394		llc_conn_send_pdu(sk, skb);
 395		llc_conn_ac_inc_vs_by_1(sk, skb);
 396	}
 397	return rc;
 398}
 399
 400int llc_conn_ac_send_i_xxx_x_set_0(struct sock *sk, struct sk_buff *skb)
 401{
 402	int rc;
 403	struct llc_sock *llc = llc_sk(sk);
 404	struct llc_sap *sap = llc->sap;
 405
 406	llc_pdu_header_init(skb, LLC_PDU_TYPE_I, sap->laddr.lsap,
 407			    llc->daddr.lsap, LLC_PDU_CMD);
 408	llc_pdu_init_as_i_cmd(skb, 0, llc->vS, llc->vR);
 409	rc = llc_mac_hdr_init(skb, llc->dev->dev_addr, llc->daddr.mac);
 410	if (likely(!rc)) {
 411		skb_get(skb);
 412		llc_conn_send_pdu(sk, skb);
 413		llc_conn_ac_inc_vs_by_1(sk, skb);
 414	}
 415	return 0;
 416}
 417
 418int llc_conn_ac_resend_i_xxx_x_set_0(struct sock *sk, struct sk_buff *skb)
 419{
 420	struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 421	u8 nr = LLC_I_GET_NR(pdu);
 422
 423	llc_conn_resend_i_pdu_as_cmd(sk, nr, 0);
 424	return 0;
 425}
 426
 427int llc_conn_ac_resend_i_xxx_x_set_0_or_send_rr(struct sock *sk,
 428						struct sk_buff *skb)
 429{
 430	u8 nr;
 431	struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 432	int rc = -ENOBUFS;
 433	struct llc_sock *llc = llc_sk(sk);
 434	struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_U, 0);
 435
 436	if (nskb) {
 437		struct llc_sap *sap = llc->sap;
 438
 439		llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap,
 440				    llc->daddr.lsap, LLC_PDU_RSP);
 441		llc_pdu_init_as_rr_rsp(nskb, 0, llc->vR);
 442		rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
 443		if (likely(!rc))
 444			llc_conn_send_pdu(sk, nskb);
 445		else
 446			kfree_skb(skb);
 447	}
 448	if (rc) {
 449		nr = LLC_I_GET_NR(pdu);
 450		rc = 0;
 451		llc_conn_resend_i_pdu_as_cmd(sk, nr, 0);
 452	}
 453	return rc;
 454}
 455
 456int llc_conn_ac_resend_i_rsp_f_set_1(struct sock *sk, struct sk_buff *skb)
 457{
 458	struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 459	u8 nr = LLC_I_GET_NR(pdu);
 460
 461	llc_conn_resend_i_pdu_as_rsp(sk, nr, 1);
 462	return 0;
 463}
 464
 465int llc_conn_ac_send_rej_cmd_p_set_1(struct sock *sk, struct sk_buff *skb)
 466{
 467	int rc = -ENOBUFS;
 468	struct llc_sock *llc = llc_sk(sk);
 469	struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0);
 470
 471	if (nskb) {
 472		struct llc_sap *sap = llc->sap;
 473
 474		llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
 475				    llc->daddr.lsap, LLC_PDU_CMD);
 476		llc_pdu_init_as_rej_cmd(nskb, 1, llc->vR);
 477		rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
 478		if (unlikely(rc))
 479			goto free;
 480		llc_conn_send_pdu(sk, nskb);
 481	}
 482out:
 483	return rc;
 484free:
 485	kfree_skb(nskb);
 486	goto out;
 487}
 488
 489int llc_conn_ac_send_rej_rsp_f_set_1(struct sock *sk, struct sk_buff *skb)
 490{
 491	int rc = -ENOBUFS;
 492	struct llc_sock *llc = llc_sk(sk);
 493	struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0);
 494
 495	if (nskb) {
 496		struct llc_sap *sap = llc->sap;
 497
 498		llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
 499				    llc->daddr.lsap, LLC_PDU_RSP);
 500		llc_pdu_init_as_rej_rsp(nskb, 1, llc->vR);
 501		rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
 502		if (unlikely(rc))
 503			goto free;
 504		llc_conn_send_pdu(sk, nskb);
 505	}
 506out:
 507	return rc;
 508free:
 509	kfree_skb(nskb);
 510	goto out;
 511}
 512
 513int llc_conn_ac_send_rej_xxx_x_set_0(struct sock *sk, struct sk_buff *skb)
 514{
 515	int rc = -ENOBUFS;
 516	struct llc_sock *llc = llc_sk(sk);
 517	struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0);
 518
 519	if (nskb) {
 520		struct llc_sap *sap = llc->sap;
 521
 522		llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
 523				    llc->daddr.lsap, LLC_PDU_RSP);
 524		llc_pdu_init_as_rej_rsp(nskb, 0, llc->vR);
 525		rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
 526		if (unlikely(rc))
 527			goto free;
 528		llc_conn_send_pdu(sk, nskb);
 529	}
 530out:
 531	return rc;
 532free:
 533	kfree_skb(nskb);
 534	goto out;
 535}
 536
 537int llc_conn_ac_send_rnr_cmd_p_set_1(struct sock *sk, struct sk_buff *skb)
 538{
 539	int rc = -ENOBUFS;
 540	struct llc_sock *llc = llc_sk(sk);
 541	struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0);
 542
 543	if (nskb) {
 544		struct llc_sap *sap = llc->sap;
 545
 546		llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
 547				    llc->daddr.lsap, LLC_PDU_CMD);
 548		llc_pdu_init_as_rnr_cmd(nskb, 1, llc->vR);
 549		rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
 550		if (unlikely(rc))
 551			goto free;
 552		llc_conn_send_pdu(sk, nskb);
 553	}
 554out:
 555	return rc;
 556free:
 557	kfree_skb(nskb);
 558	goto out;
 559}
 560
 561int llc_conn_ac_send_rnr_rsp_f_set_1(struct sock *sk, struct sk_buff *skb)
 562{
 563	int rc = -ENOBUFS;
 564	struct llc_sock *llc = llc_sk(sk);
 565	struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0);
 566
 567	if (nskb) {
 568		struct llc_sap *sap = llc->sap;
 569
 570		llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
 571				    llc->daddr.lsap, LLC_PDU_RSP);
 572		llc_pdu_init_as_rnr_rsp(nskb, 1, llc->vR);
 573		rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
 574		if (unlikely(rc))
 575			goto free;
 576		llc_conn_send_pdu(sk, nskb);
 577	}
 578out:
 579	return rc;
 580free:
 581	kfree_skb(nskb);
 582	goto out;
 583}
 584
 585int llc_conn_ac_send_rnr_xxx_x_set_0(struct sock *sk, struct sk_buff *skb)
 586{
 587	int rc = -ENOBUFS;
 588	struct llc_sock *llc = llc_sk(sk);
 589	struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0);
 590
 591	if (nskb) {
 592		struct llc_sap *sap = llc->sap;
 593
 594		llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
 595				    llc->daddr.lsap, LLC_PDU_RSP);
 596		llc_pdu_init_as_rnr_rsp(nskb, 0, llc->vR);
 597		rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
 598		if (unlikely(rc))
 599			goto free;
 600		llc_conn_send_pdu(sk, nskb);
 601	}
 602out:
 603	return rc;
 604free:
 605	kfree_skb(nskb);
 606	goto out;
 607}
 608
 609int llc_conn_ac_set_remote_busy(struct sock *sk, struct sk_buff *skb)
 610{
 611	struct llc_sock *llc = llc_sk(sk);
 612
 613	if (!llc->remote_busy_flag) {
 614		llc->remote_busy_flag = 1;
 615		mod_timer(&llc->busy_state_timer.timer,
 616			 jiffies + llc->busy_state_timer.expire);
 617	}
 618	return 0;
 619}
 620
 621int llc_conn_ac_opt_send_rnr_xxx_x_set_0(struct sock *sk, struct sk_buff *skb)
 622{
 623	int rc = -ENOBUFS;
 624	struct llc_sock *llc = llc_sk(sk);
 625	struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0);
 626
 627	if (nskb) {
 628		struct llc_sap *sap = llc->sap;
 629
 630		llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
 631				    llc->daddr.lsap, LLC_PDU_RSP);
 632		llc_pdu_init_as_rnr_rsp(nskb, 0, llc->vR);
 633		rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
 634		if (unlikely(rc))
 635			goto free;
 636		llc_conn_send_pdu(sk, nskb);
 637	}
 638out:
 639	return rc;
 640free:
 641	kfree_skb(nskb);
 642	goto out;
 643}
 644
 645int llc_conn_ac_send_rr_cmd_p_set_1(struct sock *sk, struct sk_buff *skb)
 646{
 647	int rc = -ENOBUFS;
 648	struct llc_sock *llc = llc_sk(sk);
 649	struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0);
 650
 651	if (nskb) {
 652		struct llc_sap *sap = llc->sap;
 653
 654		llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
 655				    llc->daddr.lsap, LLC_PDU_CMD);
 656		llc_pdu_init_as_rr_cmd(nskb, 1, llc->vR);
 657		rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
 658		if (unlikely(rc))
 659			goto free;
 660		llc_conn_send_pdu(sk, nskb);
 661	}
 662out:
 663	return rc;
 664free:
 665	kfree_skb(nskb);
 666	goto out;
 667}
 668
 669int llc_conn_ac_send_rr_rsp_f_set_1(struct sock *sk, struct sk_buff *skb)
 670{
 671	int rc = -ENOBUFS;
 672	struct llc_sock *llc = llc_sk(sk);
 673	struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0);
 674
 675	if (nskb) {
 676		struct llc_sap *sap = llc->sap;
 677		u8 f_bit = 1;
 678
 679		llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
 680				    llc->daddr.lsap, LLC_PDU_RSP);
 681		llc_pdu_init_as_rr_rsp(nskb, f_bit, llc->vR);
 682		rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
 683		if (unlikely(rc))
 684			goto free;
 685		llc_conn_send_pdu(sk, nskb);
 686	}
 687out:
 688	return rc;
 689free:
 690	kfree_skb(nskb);
 691	goto out;
 692}
 693
 694int llc_conn_ac_send_ack_rsp_f_set_1(struct sock *sk, struct sk_buff *skb)
 695{
 696	int rc = -ENOBUFS;
 697	struct llc_sock *llc = llc_sk(sk);
 698	struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0);
 699
 700	if (nskb) {
 701		struct llc_sap *sap = llc->sap;
 702
 703		llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
 704				    llc->daddr.lsap, LLC_PDU_RSP);
 705		llc_pdu_init_as_rr_rsp(nskb, 1, llc->vR);
 706		rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
 707		if (unlikely(rc))
 708			goto free;
 709		llc_conn_send_pdu(sk, nskb);
 710	}
 711out:
 712	return rc;
 713free:
 714	kfree_skb(nskb);
 715	goto out;
 716}
 717
 718int llc_conn_ac_send_rr_xxx_x_set_0(struct sock *sk, struct sk_buff *skb)
 719{
 720	int rc = -ENOBUFS;
 721	struct llc_sock *llc = llc_sk(sk);
 722	struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0);
 723
 724	if (nskb) {
 725		struct llc_sap *sap = llc->sap;
 726
 727		llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
 728				    llc->daddr.lsap, LLC_PDU_RSP);
 729		llc_pdu_init_as_rr_rsp(nskb, 0, llc->vR);
 730		rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
 731		if (unlikely(rc))
 732			goto free;
 733		llc_conn_send_pdu(sk, nskb);
 734	}
 735out:
 736	return rc;
 737free:
 738	kfree_skb(nskb);
 739	goto out;
 740}
 741
 742int llc_conn_ac_send_ack_xxx_x_set_0(struct sock *sk, struct sk_buff *skb)
 743{
 744	int rc = -ENOBUFS;
 745	struct llc_sock *llc = llc_sk(sk);
 746	struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0);
 747
 748	if (nskb) {
 749		struct llc_sap *sap = llc->sap;
 750
 751		llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
 752				    llc->daddr.lsap, LLC_PDU_RSP);
 753		llc_pdu_init_as_rr_rsp(nskb, 0, llc->vR);
 754		rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
 755		if (unlikely(rc))
 756			goto free;
 757		llc_conn_send_pdu(sk, nskb);
 758	}
 759out:
 760	return rc;
 761free:
 762	kfree_skb(nskb);
 763	goto out;
 764}
 765
 766void llc_conn_set_p_flag(struct sock *sk, u8 value)
 767{
 768	int state_changed = llc_sk(sk)->p_flag && !value;
 769
 770	llc_sk(sk)->p_flag = value;
 771
 772	if (state_changed)
 773		sk->sk_state_change(sk);
 774}
 775
 776int llc_conn_ac_send_sabme_cmd_p_set_x(struct sock *sk, struct sk_buff *skb)
 777{
 778	int rc = -ENOBUFS;
 779	struct llc_sock *llc = llc_sk(sk);
 780	struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_U, 0);
 781
 782	if (nskb) {
 783		struct llc_sap *sap = llc->sap;
 784		const u8 *dmac = llc->daddr.mac;
 785
 786		if (llc->dev->flags & IFF_LOOPBACK)
 787			dmac = llc->dev->dev_addr;
 788		llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap,
 789				    llc->daddr.lsap, LLC_PDU_CMD);
 790		llc_pdu_init_as_sabme_cmd(nskb, 1);
 791		rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, dmac);
 792		if (unlikely(rc))
 793			goto free;
 794		llc_conn_send_pdu(sk, nskb);
 795		llc_conn_set_p_flag(sk, 1);
 796	}
 797out:
 798	return rc;
 799free:
 800	kfree_skb(nskb);
 801	goto out;
 802}
 803
 804int llc_conn_ac_send_ua_rsp_f_set_p(struct sock *sk, struct sk_buff *skb)
 805{
 806	u8 f_bit;
 807	int rc = -ENOBUFS;
 808	struct llc_sock *llc = llc_sk(sk);
 809	struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_U, 0);
 810
 811	llc_pdu_decode_pf_bit(skb, &f_bit);
 812	if (nskb) {
 813		struct llc_sap *sap = llc->sap;
 814
 815		nskb->dev = llc->dev;
 816		llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap,
 817				    llc->daddr.lsap, LLC_PDU_RSP);
 818		llc_pdu_init_as_ua_rsp(nskb, f_bit);
 819		rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
 820		if (unlikely(rc))
 821			goto free;
 822		llc_conn_send_pdu(sk, nskb);
 823	}
 824out:
 825	return rc;
 826free:
 827	kfree_skb(nskb);
 828	goto out;
 829}
 830
 831int llc_conn_ac_set_s_flag_0(struct sock *sk, struct sk_buff *skb)
 832{
 833	llc_sk(sk)->s_flag = 0;
 834	return 0;
 835}
 836
 837int llc_conn_ac_set_s_flag_1(struct sock *sk, struct sk_buff *skb)
 838{
 839	llc_sk(sk)->s_flag = 1;
 840	return 0;
 841}
 842
 843int llc_conn_ac_start_p_timer(struct sock *sk, struct sk_buff *skb)
 844{
 845	struct llc_sock *llc = llc_sk(sk);
 846
 847	llc_conn_set_p_flag(sk, 1);
 848	mod_timer(&llc->pf_cycle_timer.timer,
 849		  jiffies + llc->pf_cycle_timer.expire);
 850	return 0;
 851}
 852
 853/**
 854 *	llc_conn_ac_send_ack_if_needed - check if ack is needed
 855 *	@sk: current connection structure
 856 *	@skb: current event
 857 *
 858 *	Checks number of received PDUs which have not been acknowledged, yet,
 859 *	If number of them reaches to "npta"(Number of PDUs To Acknowledge) then
 860 *	sends an RR response as acknowledgement for them.  Returns 0 for
 861 *	success, 1 otherwise.
 862 */
 863int llc_conn_ac_send_ack_if_needed(struct sock *sk, struct sk_buff *skb)
 864{
 865	u8 pf_bit;
 866	struct llc_sock *llc = llc_sk(sk);
 867
 868	llc_pdu_decode_pf_bit(skb, &pf_bit);
 869	llc->ack_pf |= pf_bit & 1;
 870	if (!llc->ack_must_be_send) {
 871		llc->first_pdu_Ns = llc->vR;
 872		llc->ack_must_be_send = 1;
 873		llc->ack_pf = pf_bit & 1;
 874	}
 875	if (((llc->vR - llc->first_pdu_Ns + 1 + LLC_2_SEQ_NBR_MODULO)
 876			% LLC_2_SEQ_NBR_MODULO) >= llc->npta) {
 877		llc_conn_ac_send_rr_rsp_f_set_ackpf(sk, skb);
 878		llc->ack_must_be_send	= 0;
 879		llc->ack_pf		= 0;
 880		llc_conn_ac_inc_npta_value(sk, skb);
 881	}
 882	return 0;
 883}
 884
 885/**
 886 *	llc_conn_ac_rst_sendack_flag - resets ack_must_be_send flag
 887 *	@sk: current connection structure
 888 *	@skb: current event
 889 *
 890 *	This action resets ack_must_be_send flag of given connection, this flag
 891 *	indicates if there is any PDU which has not been acknowledged yet.
 892 *	Returns 0 for success, 1 otherwise.
 893 */
 894int llc_conn_ac_rst_sendack_flag(struct sock *sk, struct sk_buff *skb)
 895{
 896	llc_sk(sk)->ack_must_be_send = llc_sk(sk)->ack_pf = 0;
 897	return 0;
 898}
 899
 900/**
 901 *	llc_conn_ac_send_i_rsp_f_set_ackpf - acknowledge received PDUs
 902 *	@sk: current connection structure
 903 *	@skb: current event
 904 *
 905 *	Sends an I response PDU with f-bit set to ack_pf flag as acknowledge to
 906 *	all received PDUs which have not been acknowledged, yet. ack_pf flag is
 907 *	set to one if one PDU with p-bit set to one is received.  Returns 0 for
 908 *	success, 1 otherwise.
 909 */
 910static int llc_conn_ac_send_i_rsp_f_set_ackpf(struct sock *sk,
 911					      struct sk_buff *skb)
 912{
 913	int rc;
 914	struct llc_sock *llc = llc_sk(sk);
 915	struct llc_sap *sap = llc->sap;
 916
 917	llc_pdu_header_init(skb, LLC_PDU_TYPE_I, sap->laddr.lsap,
 918			    llc->daddr.lsap, LLC_PDU_RSP);
 919	llc_pdu_init_as_i_cmd(skb, llc->ack_pf, llc->vS, llc->vR);
 920	rc = llc_mac_hdr_init(skb, llc->dev->dev_addr, llc->daddr.mac);
 921	if (likely(!rc)) {
 922		skb_get(skb);
 923		llc_conn_send_pdu(sk, skb);
 924		llc_conn_ac_inc_vs_by_1(sk, skb);
 925	}
 926	return rc;
 927}
 928
 929/**
 930 *	llc_conn_ac_send_i_as_ack - sends an I-format PDU to acknowledge rx PDUs
 931 *	@sk: current connection structure.
 932 *	@skb: current event.
 933 *
 934 *	This action sends an I-format PDU as acknowledge to received PDUs which
 935 *	have not been acknowledged, yet, if there is any. By using of this
 936 *	action number of acknowledgements decreases, this technic is called
 937 *	piggy backing. Returns 0 for success, 1 otherwise.
 938 */
 939int llc_conn_ac_send_i_as_ack(struct sock *sk, struct sk_buff *skb)
 940{
 941	struct llc_sock *llc = llc_sk(sk);
 942	int ret;
 943
 944	if (llc->ack_must_be_send) {
 945		ret = llc_conn_ac_send_i_rsp_f_set_ackpf(sk, skb);
 946		llc->ack_must_be_send = 0 ;
 947		llc->ack_pf = 0;
 948	} else {
 949		ret = llc_conn_ac_send_i_cmd_p_set_0(sk, skb);
 950	}
 951
 952	return ret;
 953}
 954
 955/**
 956 *	llc_conn_ac_send_rr_rsp_f_set_ackpf - ack all rx PDUs not yet acked
 957 *	@sk: current connection structure.
 958 *	@skb: current event.
 959 *
 960 *	This action sends an RR response with f-bit set to ack_pf flag as
 961 *	acknowledge to all received PDUs which have not been acknowledged, yet,
 962 *	if there is any. ack_pf flag indicates if a PDU has been received with
 963 *	p-bit set to one. Returns 0 for success, 1 otherwise.
 964 */
 965static int llc_conn_ac_send_rr_rsp_f_set_ackpf(struct sock *sk,
 966					       struct sk_buff *skb)
 967{
 968	int rc = -ENOBUFS;
 969	struct llc_sock *llc = llc_sk(sk);
 970	struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0);
 971
 972	if (nskb) {
 973		struct llc_sap *sap = llc->sap;
 974
 975		llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
 976				    llc->daddr.lsap, LLC_PDU_RSP);
 977		llc_pdu_init_as_rr_rsp(nskb, llc->ack_pf, llc->vR);
 978		rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
 979		if (unlikely(rc))
 980			goto free;
 981		llc_conn_send_pdu(sk, nskb);
 982	}
 983out:
 984	return rc;
 985free:
 986	kfree_skb(nskb);
 987	goto out;
 988}
 989
 990/**
 991 *	llc_conn_ac_inc_npta_value - tries to make value of npta greater
 992 *	@sk: current connection structure.
 993 *	@skb: current event.
 994 *
 995 *	After "inc_cntr" times calling of this action, "npta" increase by one.
 996 *	this action tries to make vale of "npta" greater as possible; number of
 997 *	acknowledgements decreases by increasing of "npta". Returns 0 for
 998 *	success, 1 otherwise.
 999 */
1000static int llc_conn_ac_inc_npta_value(struct sock *sk, struct sk_buff *skb)
1001{
1002	struct llc_sock *llc = llc_sk(sk);
1003
1004	if (!llc->inc_cntr) {
1005		llc->dec_step = 0;
1006		llc->dec_cntr = llc->inc_cntr = 2;
1007		++llc->npta;
1008		if (llc->npta > (u8) ~LLC_2_SEQ_NBR_MODULO)
1009			llc->npta = (u8) ~LLC_2_SEQ_NBR_MODULO;
1010	} else
1011		--llc->inc_cntr;
1012	return 0;
1013}
1014
1015/**
1016 *	llc_conn_ac_adjust_npta_by_rr - decreases "npta" by one
1017 *	@sk: current connection structure.
1018 *	@skb: current event.
1019 *
1020 *	After receiving "dec_cntr" times RR command, this action decreases
1021 *	"npta" by one. Returns 0 for success, 1 otherwise.
1022 */
1023int llc_conn_ac_adjust_npta_by_rr(struct sock *sk, struct sk_buff *skb)
1024{
1025	struct llc_sock *llc = llc_sk(sk);
1026
1027	if (!llc->connect_step && !llc->remote_busy_flag) {
1028		if (!llc->dec_step) {
1029			if (!llc->dec_cntr) {
1030				llc->inc_cntr = llc->dec_cntr = 2;
1031				if (llc->npta > 0)
1032					llc->npta = llc->npta - 1;
1033			} else
1034				llc->dec_cntr -=1;
1035		}
1036	} else
1037		llc->connect_step = 0 ;
1038	return 0;
1039}
1040
1041/**
1042 *	llc_conn_ac_adjust_npta_by_rnr - decreases "npta" by one
1043 *	@sk: current connection structure.
1044 *	@skb: current event.
1045 *
1046 *	After receiving "dec_cntr" times RNR command, this action decreases
1047 *	"npta" by one. Returns 0 for success, 1 otherwise.
1048 */
1049int llc_conn_ac_adjust_npta_by_rnr(struct sock *sk, struct sk_buff *skb)
1050{
1051	struct llc_sock *llc = llc_sk(sk);
1052
1053	if (llc->remote_busy_flag)
1054		if (!llc->dec_step) {
1055			if (!llc->dec_cntr) {
1056				llc->inc_cntr = llc->dec_cntr = 2;
1057				if (llc->npta > 0)
1058					--llc->npta;
1059			} else
1060				--llc->dec_cntr;
1061		}
1062	return 0;
1063}
1064
1065/**
1066 *	llc_conn_ac_dec_tx_win_size - decreases tx window size
1067 *	@sk: current connection structure.
1068 *	@skb: current event.
1069 *
1070 *	After receiving of a REJ command or response, transmit window size is
1071 *	decreased by number of PDUs which are outstanding yet. Returns 0 for
1072 *	success, 1 otherwise.
1073 */
1074int llc_conn_ac_dec_tx_win_size(struct sock *sk, struct sk_buff *skb)
1075{
1076	struct llc_sock *llc = llc_sk(sk);
1077	u8 unacked_pdu = skb_queue_len(&llc->pdu_unack_q);
1078
1079	if (llc->k - unacked_pdu < 1)
1080		llc->k = 1;
1081	else
1082		llc->k -= unacked_pdu;
1083	return 0;
1084}
1085
1086/**
1087 *	llc_conn_ac_inc_tx_win_size - tx window size is inc by 1
1088 *	@sk: current connection structure.
1089 *	@skb: current event.
1090 *
1091 *	After receiving an RR response with f-bit set to one, transmit window
1092 *	size is increased by one. Returns 0 for success, 1 otherwise.
1093 */
1094int llc_conn_ac_inc_tx_win_size(struct sock *sk, struct sk_buff *skb)
1095{
1096	struct llc_sock *llc = llc_sk(sk);
1097
1098	llc->k += 1;
1099	if (llc->k > (u8) ~LLC_2_SEQ_NBR_MODULO)
1100		llc->k = (u8) ~LLC_2_SEQ_NBR_MODULO;
1101	return 0;
1102}
1103
1104int llc_conn_ac_stop_all_timers(struct sock *sk, struct sk_buff *skb)
1105{
1106	llc_sk_stop_all_timers(sk, false);
 
 
 
 
 
 
 
1107	return 0;
1108}
1109
1110int llc_conn_ac_stop_other_timers(struct sock *sk, struct sk_buff *skb)
1111{
1112	struct llc_sock *llc = llc_sk(sk);
1113
1114	del_timer(&llc->rej_sent_timer.timer);
1115	del_timer(&llc->pf_cycle_timer.timer);
1116	del_timer(&llc->busy_state_timer.timer);
1117	llc->ack_must_be_send = 0;
1118	llc->ack_pf = 0;
1119	return 0;
1120}
1121
1122int llc_conn_ac_start_ack_timer(struct sock *sk, struct sk_buff *skb)
1123{
1124	struct llc_sock *llc = llc_sk(sk);
1125
1126	mod_timer(&llc->ack_timer.timer, jiffies + llc->ack_timer.expire);
1127	return 0;
1128}
1129
1130int llc_conn_ac_start_rej_timer(struct sock *sk, struct sk_buff *skb)
1131{
1132	struct llc_sock *llc = llc_sk(sk);
1133
1134	mod_timer(&llc->rej_sent_timer.timer,
1135		  jiffies + llc->rej_sent_timer.expire);
1136	return 0;
1137}
1138
1139int llc_conn_ac_start_ack_tmr_if_not_running(struct sock *sk,
1140					     struct sk_buff *skb)
1141{
1142	struct llc_sock *llc = llc_sk(sk);
1143
1144	if (!timer_pending(&llc->ack_timer.timer))
1145		mod_timer(&llc->ack_timer.timer,
1146			  jiffies + llc->ack_timer.expire);
1147	return 0;
1148}
1149
1150int llc_conn_ac_stop_ack_timer(struct sock *sk, struct sk_buff *skb)
1151{
1152	del_timer(&llc_sk(sk)->ack_timer.timer);
1153	return 0;
1154}
1155
1156int llc_conn_ac_stop_p_timer(struct sock *sk, struct sk_buff *skb)
1157{
1158	struct llc_sock *llc = llc_sk(sk);
1159
1160	del_timer(&llc->pf_cycle_timer.timer);
1161	llc_conn_set_p_flag(sk, 0);
1162	return 0;
1163}
1164
1165int llc_conn_ac_stop_rej_timer(struct sock *sk, struct sk_buff *skb)
1166{
1167	del_timer(&llc_sk(sk)->rej_sent_timer.timer);
1168	return 0;
1169}
1170
1171int llc_conn_ac_upd_nr_received(struct sock *sk, struct sk_buff *skb)
1172{
1173	int acked;
1174	u16 unacked = 0;
1175	struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
1176	struct llc_sock *llc = llc_sk(sk);
1177
1178	llc->last_nr = PDU_SUPV_GET_Nr(pdu);
1179	acked = llc_conn_remove_acked_pdus(sk, llc->last_nr, &unacked);
1180	/* On loopback we don't queue I frames in unack_pdu_q queue. */
1181	if (acked > 0 || (llc->dev->flags & IFF_LOOPBACK)) {
1182		llc->retry_count = 0;
1183		del_timer(&llc->ack_timer.timer);
1184		if (llc->failed_data_req) {
1185			/* already, we did not accept data from upper layer
1186			 * (tx_window full or unacceptable state). Now, we
1187			 * can send data and must inform to upper layer.
1188			 */
1189			llc->failed_data_req = 0;
1190			llc_conn_ac_data_confirm(sk, skb);
1191		}
1192		if (unacked)
1193			mod_timer(&llc->ack_timer.timer,
1194				  jiffies + llc->ack_timer.expire);
1195	} else if (llc->failed_data_req) {
1196		u8 f_bit;
1197
1198		llc_pdu_decode_pf_bit(skb, &f_bit);
1199		if (f_bit == 1) {
1200			llc->failed_data_req = 0;
1201			llc_conn_ac_data_confirm(sk, skb);
1202		}
1203	}
1204	return 0;
1205}
1206
1207int llc_conn_ac_upd_p_flag(struct sock *sk, struct sk_buff *skb)
1208{
1209	struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
1210
1211	if (LLC_PDU_IS_RSP(pdu)) {
1212		u8 f_bit;
1213
1214		llc_pdu_decode_pf_bit(skb, &f_bit);
1215		if (f_bit) {
1216			llc_conn_set_p_flag(sk, 0);
1217			llc_conn_ac_stop_p_timer(sk, skb);
1218		}
1219	}
1220	return 0;
1221}
1222
1223int llc_conn_ac_set_data_flag_2(struct sock *sk, struct sk_buff *skb)
1224{
1225	llc_sk(sk)->data_flag = 2;
1226	return 0;
1227}
1228
1229int llc_conn_ac_set_data_flag_0(struct sock *sk, struct sk_buff *skb)
1230{
1231	llc_sk(sk)->data_flag = 0;
1232	return 0;
1233}
1234
1235int llc_conn_ac_set_data_flag_1(struct sock *sk, struct sk_buff *skb)
1236{
1237	llc_sk(sk)->data_flag = 1;
1238	return 0;
1239}
1240
1241int llc_conn_ac_set_data_flag_1_if_data_flag_eq_0(struct sock *sk,
1242						  struct sk_buff *skb)
1243{
1244	if (!llc_sk(sk)->data_flag)
1245		llc_sk(sk)->data_flag = 1;
1246	return 0;
1247}
1248
1249int llc_conn_ac_set_p_flag_0(struct sock *sk, struct sk_buff *skb)
1250{
1251	llc_conn_set_p_flag(sk, 0);
1252	return 0;
1253}
1254
1255static int llc_conn_ac_set_p_flag_1(struct sock *sk, struct sk_buff *skb)
1256{
1257	llc_conn_set_p_flag(sk, 1);
1258	return 0;
1259}
1260
1261int llc_conn_ac_set_remote_busy_0(struct sock *sk, struct sk_buff *skb)
1262{
1263	llc_sk(sk)->remote_busy_flag = 0;
1264	return 0;
1265}
1266
1267int llc_conn_ac_set_cause_flag_0(struct sock *sk, struct sk_buff *skb)
1268{
1269	llc_sk(sk)->cause_flag = 0;
1270	return 0;
1271}
1272
1273int llc_conn_ac_set_cause_flag_1(struct sock *sk, struct sk_buff *skb)
1274{
1275	llc_sk(sk)->cause_flag = 1;
1276	return 0;
1277}
1278
1279int llc_conn_ac_set_retry_cnt_0(struct sock *sk, struct sk_buff *skb)
1280{
1281	llc_sk(sk)->retry_count = 0;
1282	return 0;
1283}
1284
1285int llc_conn_ac_inc_retry_cnt_by_1(struct sock *sk, struct sk_buff *skb)
1286{
1287	llc_sk(sk)->retry_count++;
1288	return 0;
1289}
1290
1291int llc_conn_ac_set_vr_0(struct sock *sk, struct sk_buff *skb)
1292{
1293	llc_sk(sk)->vR = 0;
1294	return 0;
1295}
1296
1297int llc_conn_ac_inc_vr_by_1(struct sock *sk, struct sk_buff *skb)
1298{
1299	llc_sk(sk)->vR = PDU_GET_NEXT_Vr(llc_sk(sk)->vR);
1300	return 0;
1301}
1302
1303int llc_conn_ac_set_vs_0(struct sock *sk, struct sk_buff *skb)
1304{
1305	llc_sk(sk)->vS = 0;
1306	return 0;
1307}
1308
1309int llc_conn_ac_set_vs_nr(struct sock *sk, struct sk_buff *skb)
1310{
1311	llc_sk(sk)->vS = llc_sk(sk)->last_nr;
1312	return 0;
1313}
1314
1315static int llc_conn_ac_inc_vs_by_1(struct sock *sk, struct sk_buff *skb)
1316{
1317	llc_sk(sk)->vS = (llc_sk(sk)->vS + 1) % LLC_2_SEQ_NBR_MODULO;
1318	return 0;
1319}
1320
1321static void llc_conn_tmr_common_cb(struct sock *sk, u8 type)
1322{
 
1323	struct sk_buff *skb = alloc_skb(0, GFP_ATOMIC);
1324
1325	bh_lock_sock(sk);
1326	if (skb) {
1327		struct llc_conn_state_ev *ev = llc_conn_ev(skb);
1328
1329		skb_set_owner_r(skb, sk);
1330		ev->type = type;
1331		llc_process_tmr_ev(sk, skb);
1332	}
1333	bh_unlock_sock(sk);
1334}
1335
1336void llc_conn_pf_cycle_tmr_cb(struct timer_list *t)
1337{
1338	struct llc_sock *llc = from_timer(llc, t, pf_cycle_timer.timer);
1339
1340	llc_conn_tmr_common_cb(&llc->sk, LLC_CONN_EV_TYPE_P_TMR);
1341}
1342
1343void llc_conn_busy_tmr_cb(struct timer_list *t)
1344{
1345	struct llc_sock *llc = from_timer(llc, t, busy_state_timer.timer);
1346
1347	llc_conn_tmr_common_cb(&llc->sk, LLC_CONN_EV_TYPE_BUSY_TMR);
1348}
1349
1350void llc_conn_ack_tmr_cb(struct timer_list *t)
1351{
1352	struct llc_sock *llc = from_timer(llc, t, ack_timer.timer);
1353
1354	llc_conn_tmr_common_cb(&llc->sk, LLC_CONN_EV_TYPE_ACK_TMR);
1355}
1356
1357void llc_conn_rej_tmr_cb(struct timer_list *t)
1358{
1359	struct llc_sock *llc = from_timer(llc, t, rej_sent_timer.timer);
1360
1361	llc_conn_tmr_common_cb(&llc->sk, LLC_CONN_EV_TYPE_REJ_TMR);
1362}
1363
1364int llc_conn_ac_rst_vs(struct sock *sk, struct sk_buff *skb)
1365{
1366	llc_sk(sk)->X = llc_sk(sk)->vS;
1367	llc_conn_ac_set_vs_nr(sk, skb);
1368	return 0;
1369}
1370
1371int llc_conn_ac_upd_vs(struct sock *sk, struct sk_buff *skb)
1372{
1373	struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
1374	u8 nr = PDU_SUPV_GET_Nr(pdu);
1375
1376	if (llc_circular_between(llc_sk(sk)->vS, nr, llc_sk(sk)->X))
1377		llc_conn_ac_set_vs_nr(sk, skb);
1378	return 0;
1379}
1380
1381/*
1382 * Non-standard actions; these not contained in IEEE specification; for
1383 * our own usage
1384 */
1385/**
1386 *	llc_conn_disc - removes connection from SAP list and frees it
1387 *	@sk: closed connection
1388 *	@skb: occurred event
1389 */
1390int llc_conn_disc(struct sock *sk, struct sk_buff *skb)
1391{
1392	/* FIXME: this thing seems to want to die */
1393	return 0;
1394}
1395
1396/**
1397 *	llc_conn_reset - resets connection
1398 *	@sk : reseting connection.
1399 *	@skb: occurred event.
1400 *
1401 *	Stop all timers, empty all queues and reset all flags.
1402 */
1403int llc_conn_reset(struct sock *sk, struct sk_buff *skb)
1404{
1405	llc_sk_reset(sk);
1406	return 0;
1407}
1408
1409/**
1410 *	llc_circular_between - designates that b is between a and c or not
1411 *	@a: lower bound
1412 *	@b: element to see if is between a and b
1413 *	@c: upper bound
1414 *
1415 *	This function designates that b is between a and c or not (for example,
1416 *	0 is between 127 and 1). Returns 1 if b is between a and c, 0
1417 *	otherwise.
1418 */
1419u8 llc_circular_between(u8 a, u8 b, u8 c)
1420{
1421	b = b - a;
1422	c = c - a;
1423	return b <= c;
1424}
1425
1426/**
1427 *	llc_process_tmr_ev - timer backend
1428 *	@sk: active connection
1429 *	@skb: occurred event
1430 *
1431 *	This function is called from timer callback functions. When connection
1432 *	is busy (during sending a data frame) timer expiration event must be
1433 *	queued. Otherwise this event can be sent to connection state machine.
1434 *	Queued events will process by llc_backlog_rcv function after sending
1435 *	data frame.
1436 */
1437static void llc_process_tmr_ev(struct sock *sk, struct sk_buff *skb)
1438{
1439	if (llc_sk(sk)->state == LLC_CONN_OUT_OF_SVC) {
1440		printk(KERN_WARNING "%s: timer called on closed connection\n",
1441		       __func__);
1442		kfree_skb(skb);
1443	} else {
1444		if (!sock_owned_by_user(sk))
1445			llc_conn_state_process(sk, skb);
1446		else {
1447			llc_set_backlog_type(skb, LLC_EVENT);
1448			__sk_add_backlog(sk, skb);
1449		}
1450	}
1451}