Linux Audio

Check our new training course

Yocto / OpenEmbedded training

Feb 10-13, 2025
Register
Loading...
v3.1
 
   1/*
   2 * Generic HDLC support routines for Linux
   3 * Frame Relay support
   4 *
   5 * Copyright (C) 1999 - 2006 Krzysztof Halasa <khc@pm.waw.pl>
   6 *
   7 * This program is free software; you can redistribute it and/or modify it
   8 * under the terms of version 2 of the GNU General Public License
   9 * as published by the Free Software Foundation.
  10 *
  11
  12            Theory of PVC state
  13
  14 DCE mode:
  15
  16 (exist,new) -> 0,0 when "PVC create" or if "link unreliable"
  17         0,x -> 1,1 if "link reliable" when sending FULL STATUS
  18         1,1 -> 1,0 if received FULL STATUS ACK
  19
  20 (active)    -> 0 when "ifconfig PVC down" or "link unreliable" or "PVC create"
  21             -> 1 when "PVC up" and (exist,new) = 1,0
  22
  23 DTE mode:
  24 (exist,new,active) = FULL STATUS if "link reliable"
  25		    = 0, 0, 0 if "link unreliable"
  26 No LMI:
  27 active = open and "link reliable"
  28 exist = new = not used
  29
  30 CCITT LMI: ITU-T Q.933 Annex A
  31 ANSI LMI: ANSI T1.617 Annex D
  32 CISCO LMI: the original, aka "Gang of Four" LMI
  33
  34*/
  35
  36#include <linux/errno.h>
  37#include <linux/etherdevice.h>
  38#include <linux/hdlc.h>
  39#include <linux/if_arp.h>
  40#include <linux/inetdevice.h>
  41#include <linux/init.h>
  42#include <linux/kernel.h>
  43#include <linux/module.h>
  44#include <linux/pkt_sched.h>
  45#include <linux/poll.h>
  46#include <linux/rtnetlink.h>
  47#include <linux/skbuff.h>
  48#include <linux/slab.h>
  49
  50#undef DEBUG_PKT
  51#undef DEBUG_ECN
  52#undef DEBUG_LINK
  53#undef DEBUG_PROTO
  54#undef DEBUG_PVC
  55
  56#define FR_UI			0x03
  57#define FR_PAD			0x00
  58
  59#define NLPID_IP		0xCC
  60#define NLPID_IPV6		0x8E
  61#define NLPID_SNAP		0x80
  62#define NLPID_PAD		0x00
  63#define NLPID_CCITT_ANSI_LMI	0x08
  64#define NLPID_CISCO_LMI		0x09
  65
  66
  67#define LMI_CCITT_ANSI_DLCI	   0 /* LMI DLCI */
  68#define LMI_CISCO_DLCI		1023
  69
  70#define LMI_CALLREF		0x00 /* Call Reference */
  71#define LMI_ANSI_LOCKSHIFT	0x95 /* ANSI locking shift */
  72#define LMI_ANSI_CISCO_REPTYPE	0x01 /* report type */
  73#define LMI_CCITT_REPTYPE	0x51
  74#define LMI_ANSI_CISCO_ALIVE	0x03 /* keep alive */
  75#define LMI_CCITT_ALIVE		0x53
  76#define LMI_ANSI_CISCO_PVCSTAT	0x07 /* PVC status */
  77#define LMI_CCITT_PVCSTAT	0x57
  78
  79#define LMI_FULLREP		0x00 /* full report  */
  80#define LMI_INTEGRITY		0x01 /* link integrity report */
  81#define LMI_SINGLE		0x02 /* single PVC report */
  82
  83#define LMI_STATUS_ENQUIRY      0x75
  84#define LMI_STATUS              0x7D /* reply */
  85
  86#define LMI_REPT_LEN               1 /* report type element length */
  87#define LMI_INTEG_LEN              2 /* link integrity element length */
  88
  89#define LMI_CCITT_CISCO_LENGTH	  13 /* LMI frame lengths */
  90#define LMI_ANSI_LENGTH		  14
  91
  92
  93typedef struct {
  94#if defined(__LITTLE_ENDIAN_BITFIELD)
  95	unsigned ea1:	1;
  96	unsigned cr:	1;
  97	unsigned dlcih:	6;
  98
  99	unsigned ea2:	1;
 100	unsigned de:	1;
 101	unsigned becn:	1;
 102	unsigned fecn:	1;
 103	unsigned dlcil:	4;
 104#else
 105	unsigned dlcih:	6;
 106	unsigned cr:	1;
 107	unsigned ea1:	1;
 108
 109	unsigned dlcil:	4;
 110	unsigned fecn:	1;
 111	unsigned becn:	1;
 112	unsigned de:	1;
 113	unsigned ea2:	1;
 114#endif
 115}__packed fr_hdr;
 116
 117
 118typedef struct pvc_device_struct {
 119	struct net_device *frad;
 120	struct net_device *main;
 121	struct net_device *ether;	/* bridged Ethernet interface	*/
 122	struct pvc_device_struct *next;	/* Sorted in ascending DLCI order */
 123	int dlci;
 124	int open_count;
 125
 126	struct {
 127		unsigned int new: 1;
 128		unsigned int active: 1;
 129		unsigned int exist: 1;
 130		unsigned int deleted: 1;
 131		unsigned int fecn: 1;
 132		unsigned int becn: 1;
 133		unsigned int bandwidth;	/* Cisco LMI reporting only */
 134	}state;
 135}pvc_device;
 136
 137struct frad_state {
 138	fr_proto settings;
 139	pvc_device *first_pvc;
 140	int dce_pvc_count;
 141
 142	struct timer_list timer;
 
 143	unsigned long last_poll;
 144	int reliable;
 145	int dce_changed;
 146	int request;
 147	int fullrep_sent;
 148	u32 last_errors; /* last errors bit list */
 149	u8 n391cnt;
 150	u8 txseq; /* TX sequence number */
 151	u8 rxseq; /* RX sequence number */
 152};
 153
 154
 155static int fr_ioctl(struct net_device *dev, struct ifreq *ifr);
 156
 157
 158static inline u16 q922_to_dlci(u8 *hdr)
 159{
 160	return ((hdr[0] & 0xFC) << 2) | ((hdr[1] & 0xF0) >> 4);
 161}
 162
 163
 164static inline void dlci_to_q922(u8 *hdr, u16 dlci)
 165{
 166	hdr[0] = (dlci >> 2) & 0xFC;
 167	hdr[1] = ((dlci << 4) & 0xF0) | 0x01;
 168}
 169
 170
 171static inline struct frad_state* state(hdlc_device *hdlc)
 172{
 173	return(struct frad_state *)(hdlc->state);
 174}
 175
 176
 177static inline pvc_device* find_pvc(hdlc_device *hdlc, u16 dlci)
 178{
 179	pvc_device *pvc = state(hdlc)->first_pvc;
 180
 181	while (pvc) {
 182		if (pvc->dlci == dlci)
 183			return pvc;
 184		if (pvc->dlci > dlci)
 185			return NULL; /* the list is sorted */
 186		pvc = pvc->next;
 187	}
 188
 189	return NULL;
 190}
 191
 192
 193static pvc_device* add_pvc(struct net_device *dev, u16 dlci)
 194{
 195	hdlc_device *hdlc = dev_to_hdlc(dev);
 196	pvc_device *pvc, **pvc_p = &state(hdlc)->first_pvc;
 197
 198	while (*pvc_p) {
 199		if ((*pvc_p)->dlci == dlci)
 200			return *pvc_p;
 201		if ((*pvc_p)->dlci > dlci)
 202			break;	/* the list is sorted */
 203		pvc_p = &(*pvc_p)->next;
 204	}
 205
 206	pvc = kzalloc(sizeof(pvc_device), GFP_ATOMIC);
 207#ifdef DEBUG_PVC
 208	printk(KERN_DEBUG "add_pvc: allocated pvc %p, frad %p\n", pvc, dev);
 209#endif
 210	if (!pvc)
 211		return NULL;
 212
 213	pvc->dlci = dlci;
 214	pvc->frad = dev;
 215	pvc->next = *pvc_p;	/* Put it in the chain */
 216	*pvc_p = pvc;
 217	return pvc;
 218}
 219
 220
 221static inline int pvc_is_used(pvc_device *pvc)
 222{
 223	return pvc->main || pvc->ether;
 224}
 225
 226
 227static inline void pvc_carrier(int on, pvc_device *pvc)
 228{
 229	if (on) {
 230		if (pvc->main)
 231			if (!netif_carrier_ok(pvc->main))
 232				netif_carrier_on(pvc->main);
 233		if (pvc->ether)
 234			if (!netif_carrier_ok(pvc->ether))
 235				netif_carrier_on(pvc->ether);
 236	} else {
 237		if (pvc->main)
 238			if (netif_carrier_ok(pvc->main))
 239				netif_carrier_off(pvc->main);
 240		if (pvc->ether)
 241			if (netif_carrier_ok(pvc->ether))
 242				netif_carrier_off(pvc->ether);
 243	}
 244}
 245
 246
 247static inline void delete_unused_pvcs(hdlc_device *hdlc)
 248{
 249	pvc_device **pvc_p = &state(hdlc)->first_pvc;
 250
 251	while (*pvc_p) {
 252		if (!pvc_is_used(*pvc_p)) {
 253			pvc_device *pvc = *pvc_p;
 254#ifdef DEBUG_PVC
 255			printk(KERN_DEBUG "freeing unused pvc: %p\n", pvc);
 256#endif
 257			*pvc_p = pvc->next;
 258			kfree(pvc);
 259			continue;
 260		}
 261		pvc_p = &(*pvc_p)->next;
 262	}
 263}
 264
 265
 266static inline struct net_device** get_dev_p(pvc_device *pvc, int type)
 267{
 268	if (type == ARPHRD_ETHER)
 269		return &pvc->ether;
 270	else
 271		return &pvc->main;
 272}
 273
 274
 275static int fr_hard_header(struct sk_buff **skb_p, u16 dlci)
 276{
 277	u16 head_len;
 278	struct sk_buff *skb = *skb_p;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 279
 280	switch (skb->protocol) {
 281	case cpu_to_be16(NLPID_CCITT_ANSI_LMI):
 282		head_len = 4;
 283		skb_push(skb, head_len);
 284		skb->data[3] = NLPID_CCITT_ANSI_LMI;
 285		break;
 286
 287	case cpu_to_be16(NLPID_CISCO_LMI):
 288		head_len = 4;
 289		skb_push(skb, head_len);
 290		skb->data[3] = NLPID_CISCO_LMI;
 291		break;
 292
 293	case cpu_to_be16(ETH_P_IP):
 294		head_len = 4;
 295		skb_push(skb, head_len);
 296		skb->data[3] = NLPID_IP;
 297		break;
 298
 299	case cpu_to_be16(ETH_P_IPV6):
 300		head_len = 4;
 301		skb_push(skb, head_len);
 302		skb->data[3] = NLPID_IPV6;
 303		break;
 304
 305	case cpu_to_be16(ETH_P_802_3):
 306		head_len = 10;
 307		if (skb_headroom(skb) < head_len) {
 308			struct sk_buff *skb2 = skb_realloc_headroom(skb,
 309								    head_len);
 310			if (!skb2)
 311				return -ENOBUFS;
 312			dev_kfree_skb(skb);
 313			skb = *skb_p = skb2;
 314		}
 315		skb_push(skb, head_len);
 
 
 316		skb->data[3] = FR_PAD;
 317		skb->data[4] = NLPID_SNAP;
 318		skb->data[5] = FR_PAD;
 
 319		skb->data[6] = 0x80;
 320		skb->data[7] = 0xC2;
 
 321		skb->data[8] = 0x00;
 322		skb->data[9] = 0x07; /* bridged Ethernet frame w/out FCS */
 323		break;
 324
 325	default:
 326		head_len = 10;
 327		skb_push(skb, head_len);
 328		skb->data[3] = FR_PAD;
 329		skb->data[4] = NLPID_SNAP;
 330		skb->data[5] = FR_PAD;
 331		skb->data[6] = FR_PAD;
 332		skb->data[7] = FR_PAD;
 333		*(__be16*)(skb->data + 8) = skb->protocol;
 334	}
 335
 336	dlci_to_q922(skb->data, dlci);
 337	skb->data[2] = FR_UI;
 338	return 0;
 339}
 340
 341
 342
 343static int pvc_open(struct net_device *dev)
 344{
 345	pvc_device *pvc = dev->ml_priv;
 346
 347	if ((pvc->frad->flags & IFF_UP) == 0)
 348		return -EIO;  /* Frad must be UP in order to activate PVC */
 349
 350	if (pvc->open_count++ == 0) {
 351		hdlc_device *hdlc = dev_to_hdlc(pvc->frad);
 
 352		if (state(hdlc)->settings.lmi == LMI_NONE)
 353			pvc->state.active = netif_carrier_ok(pvc->frad);
 354
 355		pvc_carrier(pvc->state.active, pvc);
 356		state(hdlc)->dce_changed = 1;
 357	}
 358	return 0;
 359}
 360
 361
 362
 363static int pvc_close(struct net_device *dev)
 364{
 365	pvc_device *pvc = dev->ml_priv;
 366
 367	if (--pvc->open_count == 0) {
 368		hdlc_device *hdlc = dev_to_hdlc(pvc->frad);
 
 369		if (state(hdlc)->settings.lmi == LMI_NONE)
 370			pvc->state.active = 0;
 371
 372		if (state(hdlc)->settings.dce) {
 373			state(hdlc)->dce_changed = 1;
 374			pvc->state.active = 0;
 375		}
 376	}
 377	return 0;
 378}
 379
 380
 381
 382static int pvc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 383{
 384	pvc_device *pvc = dev->ml_priv;
 385	fr_proto_pvc_info info;
 386
 387	if (ifr->ifr_settings.type == IF_GET_PROTO) {
 388		if (dev->type == ARPHRD_ETHER)
 389			ifr->ifr_settings.type = IF_PROTO_FR_ETH_PVC;
 390		else
 391			ifr->ifr_settings.type = IF_PROTO_FR_PVC;
 392
 393		if (ifr->ifr_settings.size < sizeof(info)) {
 394			/* data size wanted */
 395			ifr->ifr_settings.size = sizeof(info);
 396			return -ENOBUFS;
 397		}
 398
 399		info.dlci = pvc->dlci;
 400		memcpy(info.master, pvc->frad->name, IFNAMSIZ);
 401		if (copy_to_user(ifr->ifr_settings.ifs_ifsu.fr_pvc_info,
 402				 &info, sizeof(info)))
 403			return -EFAULT;
 404		return 0;
 405	}
 406
 407	return -EINVAL;
 408}
 409
 410static netdev_tx_t pvc_xmit(struct sk_buff *skb, struct net_device *dev)
 411{
 412	pvc_device *pvc = dev->ml_priv;
 413
 414	if (pvc->state.active) {
 415		if (dev->type == ARPHRD_ETHER) {
 416			int pad = ETH_ZLEN - skb->len;
 417			if (pad > 0) { /* Pad the frame with zeros */
 418				int len = skb->len;
 419				if (skb_tailroom(skb) < pad)
 420					if (pskb_expand_head(skb, 0, pad,
 421							     GFP_ATOMIC)) {
 422						dev->stats.tx_dropped++;
 423						dev_kfree_skb(skb);
 424						return NETDEV_TX_OK;
 425					}
 426				skb_put(skb, pad);
 427				memset(skb->data + len, 0, pad);
 428			}
 429			skb->protocol = cpu_to_be16(ETH_P_802_3);
 430		}
 431		if (!fr_hard_header(&skb, pvc->dlci)) {
 432			dev->stats.tx_bytes += skb->len;
 433			dev->stats.tx_packets++;
 434			if (pvc->state.fecn) /* TX Congestion counter */
 435				dev->stats.tx_compressed++;
 436			skb->dev = pvc->frad;
 437			dev_queue_xmit(skb);
 438			return NETDEV_TX_OK;
 439		}
 440	}
 441
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 442	dev->stats.tx_dropped++;
 443	dev_kfree_skb(skb);
 444	return NETDEV_TX_OK;
 445}
 446
 447static inline void fr_log_dlci_active(pvc_device *pvc)
 448{
 449	netdev_info(pvc->frad, "DLCI %d [%s%s%s]%s %s\n",
 450		    pvc->dlci,
 451		    pvc->main ? pvc->main->name : "",
 452		    pvc->main && pvc->ether ? " " : "",
 453		    pvc->ether ? pvc->ether->name : "",
 454		    pvc->state.new ? " new" : "",
 455		    !pvc->state.exist ? "deleted" :
 456		    pvc->state.active ? "active" : "inactive");
 457}
 458
 459
 460
 461static inline u8 fr_lmi_nextseq(u8 x)
 462{
 463	x++;
 464	return x ? x : 1;
 465}
 466
 467
 468static void fr_lmi_send(struct net_device *dev, int fullrep)
 469{
 470	hdlc_device *hdlc = dev_to_hdlc(dev);
 471	struct sk_buff *skb;
 472	pvc_device *pvc = state(hdlc)->first_pvc;
 473	int lmi = state(hdlc)->settings.lmi;
 474	int dce = state(hdlc)->settings.dce;
 475	int len = lmi == LMI_ANSI ? LMI_ANSI_LENGTH : LMI_CCITT_CISCO_LENGTH;
 476	int stat_len = (lmi == LMI_CISCO) ? 6 : 3;
 477	u8 *data;
 478	int i = 0;
 479
 480	if (dce && fullrep) {
 481		len += state(hdlc)->dce_pvc_count * (2 + stat_len);
 482		if (len > HDLC_MAX_MRU) {
 483			netdev_warn(dev, "Too many PVCs while sending LMI full report\n");
 484			return;
 485		}
 486	}
 487
 488	skb = dev_alloc_skb(len);
 489	if (!skb) {
 490		netdev_warn(dev, "Memory squeeze on fr_lmi_send()\n");
 491		return;
 492	}
 493	memset(skb->data, 0, len);
 494	skb_reserve(skb, 4);
 495	if (lmi == LMI_CISCO) {
 496		skb->protocol = cpu_to_be16(NLPID_CISCO_LMI);
 497		fr_hard_header(&skb, LMI_CISCO_DLCI);
 498	} else {
 499		skb->protocol = cpu_to_be16(NLPID_CCITT_ANSI_LMI);
 500		fr_hard_header(&skb, LMI_CCITT_ANSI_DLCI);
 501	}
 502	data = skb_tail_pointer(skb);
 503	data[i++] = LMI_CALLREF;
 504	data[i++] = dce ? LMI_STATUS : LMI_STATUS_ENQUIRY;
 505	if (lmi == LMI_ANSI)
 506		data[i++] = LMI_ANSI_LOCKSHIFT;
 507	data[i++] = lmi == LMI_CCITT ? LMI_CCITT_REPTYPE :
 508		LMI_ANSI_CISCO_REPTYPE;
 509	data[i++] = LMI_REPT_LEN;
 510	data[i++] = fullrep ? LMI_FULLREP : LMI_INTEGRITY;
 511	data[i++] = lmi == LMI_CCITT ? LMI_CCITT_ALIVE : LMI_ANSI_CISCO_ALIVE;
 512	data[i++] = LMI_INTEG_LEN;
 513	data[i++] = state(hdlc)->txseq =
 514		fr_lmi_nextseq(state(hdlc)->txseq);
 515	data[i++] = state(hdlc)->rxseq;
 516
 517	if (dce && fullrep) {
 518		while (pvc) {
 519			data[i++] = lmi == LMI_CCITT ? LMI_CCITT_PVCSTAT :
 520				LMI_ANSI_CISCO_PVCSTAT;
 521			data[i++] = stat_len;
 522
 523			/* LMI start/restart */
 524			if (state(hdlc)->reliable && !pvc->state.exist) {
 525				pvc->state.exist = pvc->state.new = 1;
 526				fr_log_dlci_active(pvc);
 527			}
 528
 529			/* ifconfig PVC up */
 530			if (pvc->open_count && !pvc->state.active &&
 531			    pvc->state.exist && !pvc->state.new) {
 532				pvc_carrier(1, pvc);
 533				pvc->state.active = 1;
 534				fr_log_dlci_active(pvc);
 535			}
 536
 537			if (lmi == LMI_CISCO) {
 538				data[i] = pvc->dlci >> 8;
 539				data[i + 1] = pvc->dlci & 0xFF;
 540			} else {
 541				data[i] = (pvc->dlci >> 4) & 0x3F;
 542				data[i + 1] = ((pvc->dlci << 3) & 0x78) | 0x80;
 543				data[i + 2] = 0x80;
 544			}
 545
 546			if (pvc->state.new)
 547				data[i + 2] |= 0x08;
 548			else if (pvc->state.active)
 549				data[i + 2] |= 0x02;
 550
 551			i += stat_len;
 552			pvc = pvc->next;
 553		}
 554	}
 555
 556	skb_put(skb, i);
 557	skb->priority = TC_PRIO_CONTROL;
 558	skb->dev = dev;
 
 559	skb_reset_network_header(skb);
 560
 561	dev_queue_xmit(skb);
 562}
 563
 564
 565
 566static void fr_set_link_state(int reliable, struct net_device *dev)
 567{
 568	hdlc_device *hdlc = dev_to_hdlc(dev);
 569	pvc_device *pvc = state(hdlc)->first_pvc;
 570
 571	state(hdlc)->reliable = reliable;
 572	if (reliable) {
 573		netif_dormant_off(dev);
 574		state(hdlc)->n391cnt = 0; /* Request full status */
 575		state(hdlc)->dce_changed = 1;
 576
 577		if (state(hdlc)->settings.lmi == LMI_NONE) {
 578			while (pvc) {	/* Activate all PVCs */
 579				pvc_carrier(1, pvc);
 580				pvc->state.exist = pvc->state.active = 1;
 581				pvc->state.new = 0;
 582				pvc = pvc->next;
 583			}
 584		}
 585	} else {
 586		netif_dormant_on(dev);
 587		while (pvc) {		/* Deactivate all PVCs */
 588			pvc_carrier(0, pvc);
 589			pvc->state.exist = pvc->state.active = 0;
 590			pvc->state.new = 0;
 591			if (!state(hdlc)->settings.dce)
 592				pvc->state.bandwidth = 0;
 593			pvc = pvc->next;
 594		}
 595	}
 596}
 597
 598
 599static void fr_timer(unsigned long arg)
 600{
 601	struct net_device *dev = (struct net_device *)arg;
 
 602	hdlc_device *hdlc = dev_to_hdlc(dev);
 603	int i, cnt = 0, reliable;
 604	u32 list;
 605
 606	if (state(hdlc)->settings.dce) {
 607		reliable = state(hdlc)->request &&
 608			time_before(jiffies, state(hdlc)->last_poll +
 609				    state(hdlc)->settings.t392 * HZ);
 610		state(hdlc)->request = 0;
 611	} else {
 612		state(hdlc)->last_errors <<= 1; /* Shift the list */
 613		if (state(hdlc)->request) {
 614			if (state(hdlc)->reliable)
 615				netdev_info(dev, "No LMI status reply received\n");
 616			state(hdlc)->last_errors |= 1;
 617		}
 618
 619		list = state(hdlc)->last_errors;
 620		for (i = 0; i < state(hdlc)->settings.n393; i++, list >>= 1)
 621			cnt += (list & 1);	/* errors count */
 622
 623		reliable = (cnt < state(hdlc)->settings.n392);
 624	}
 625
 626	if (state(hdlc)->reliable != reliable) {
 627		netdev_info(dev, "Link %sreliable\n", reliable ? "" : "un");
 628		fr_set_link_state(reliable, dev);
 629	}
 630
 631	if (state(hdlc)->settings.dce)
 632		state(hdlc)->timer.expires = jiffies +
 633			state(hdlc)->settings.t392 * HZ;
 634	else {
 635		if (state(hdlc)->n391cnt)
 636			state(hdlc)->n391cnt--;
 637
 638		fr_lmi_send(dev, state(hdlc)->n391cnt == 0);
 639
 640		state(hdlc)->last_poll = jiffies;
 641		state(hdlc)->request = 1;
 642		state(hdlc)->timer.expires = jiffies +
 643			state(hdlc)->settings.t391 * HZ;
 644	}
 645
 646	state(hdlc)->timer.function = fr_timer;
 647	state(hdlc)->timer.data = arg;
 648	add_timer(&state(hdlc)->timer);
 649}
 650
 651
 652static int fr_lmi_recv(struct net_device *dev, struct sk_buff *skb)
 653{
 654	hdlc_device *hdlc = dev_to_hdlc(dev);
 655	pvc_device *pvc;
 656	u8 rxseq, txseq;
 657	int lmi = state(hdlc)->settings.lmi;
 658	int dce = state(hdlc)->settings.dce;
 659	int stat_len = (lmi == LMI_CISCO) ? 6 : 3, reptype, error, no_ram, i;
 660
 661	if (skb->len < (lmi == LMI_ANSI ? LMI_ANSI_LENGTH :
 662			LMI_CCITT_CISCO_LENGTH)) {
 663		netdev_info(dev, "Short LMI frame\n");
 664		return 1;
 665	}
 666
 667	if (skb->data[3] != (lmi == LMI_CISCO ? NLPID_CISCO_LMI :
 668			     NLPID_CCITT_ANSI_LMI)) {
 669		netdev_info(dev, "Received non-LMI frame with LMI DLCI\n");
 670		return 1;
 671	}
 672
 673	if (skb->data[4] != LMI_CALLREF) {
 674		netdev_info(dev, "Invalid LMI Call reference (0x%02X)\n",
 675			    skb->data[4]);
 676		return 1;
 677	}
 678
 679	if (skb->data[5] != (dce ? LMI_STATUS_ENQUIRY : LMI_STATUS)) {
 680		netdev_info(dev, "Invalid LMI Message type (0x%02X)\n",
 681			    skb->data[5]);
 682		return 1;
 683	}
 684
 685	if (lmi == LMI_ANSI) {
 686		if (skb->data[6] != LMI_ANSI_LOCKSHIFT) {
 687			netdev_info(dev, "Not ANSI locking shift in LMI message (0x%02X)\n",
 688				    skb->data[6]);
 689			return 1;
 690		}
 691		i = 7;
 692	} else
 693		i = 6;
 
 694
 695	if (skb->data[i] != (lmi == LMI_CCITT ? LMI_CCITT_REPTYPE :
 696			     LMI_ANSI_CISCO_REPTYPE)) {
 697		netdev_info(dev, "Not an LMI Report type IE (0x%02X)\n",
 698			    skb->data[i]);
 699		return 1;
 700	}
 701
 702	if (skb->data[++i] != LMI_REPT_LEN) {
 703		netdev_info(dev, "Invalid LMI Report type IE length (%u)\n",
 704			    skb->data[i]);
 705		return 1;
 706	}
 707
 708	reptype = skb->data[++i];
 709	if (reptype != LMI_INTEGRITY && reptype != LMI_FULLREP) {
 710		netdev_info(dev, "Unsupported LMI Report type (0x%02X)\n",
 711			    reptype);
 712		return 1;
 713	}
 714
 715	if (skb->data[++i] != (lmi == LMI_CCITT ? LMI_CCITT_ALIVE :
 716			       LMI_ANSI_CISCO_ALIVE)) {
 717		netdev_info(dev, "Not an LMI Link integrity verification IE (0x%02X)\n",
 718			    skb->data[i]);
 719		return 1;
 720	}
 721
 722	if (skb->data[++i] != LMI_INTEG_LEN) {
 723		netdev_info(dev, "Invalid LMI Link integrity verification IE length (%u)\n",
 724			    skb->data[i]);
 725		return 1;
 726	}
 727	i++;
 728
 729	state(hdlc)->rxseq = skb->data[i++]; /* TX sequence from peer */
 730	rxseq = skb->data[i++];	/* Should confirm our sequence */
 731
 732	txseq = state(hdlc)->txseq;
 733
 734	if (dce)
 735		state(hdlc)->last_poll = jiffies;
 736
 737	error = 0;
 738	if (!state(hdlc)->reliable)
 739		error = 1;
 740
 741	if (rxseq == 0 || rxseq != txseq) { /* Ask for full report next time */
 742		state(hdlc)->n391cnt = 0;
 743		error = 1;
 744	}
 745
 746	if (dce) {
 747		if (state(hdlc)->fullrep_sent && !error) {
 748/* Stop sending full report - the last one has been confirmed by DTE */
 749			state(hdlc)->fullrep_sent = 0;
 750			pvc = state(hdlc)->first_pvc;
 751			while (pvc) {
 752				if (pvc->state.new) {
 753					pvc->state.new = 0;
 754
 755/* Tell DTE that new PVC is now active */
 756					state(hdlc)->dce_changed = 1;
 757				}
 758				pvc = pvc->next;
 759			}
 760		}
 761
 762		if (state(hdlc)->dce_changed) {
 763			reptype = LMI_FULLREP;
 764			state(hdlc)->fullrep_sent = 1;
 765			state(hdlc)->dce_changed = 0;
 766		}
 767
 768		state(hdlc)->request = 1; /* got request */
 769		fr_lmi_send(dev, reptype == LMI_FULLREP ? 1 : 0);
 770		return 0;
 771	}
 772
 773	/* DTE */
 774
 775	state(hdlc)->request = 0; /* got response, no request pending */
 776
 777	if (error)
 778		return 0;
 779
 780	if (reptype != LMI_FULLREP)
 781		return 0;
 782
 783	pvc = state(hdlc)->first_pvc;
 784
 785	while (pvc) {
 786		pvc->state.deleted = 1;
 787		pvc = pvc->next;
 788	}
 789
 790	no_ram = 0;
 791	while (skb->len >= i + 2 + stat_len) {
 792		u16 dlci;
 793		u32 bw;
 794		unsigned int active, new;
 795
 796		if (skb->data[i] != (lmi == LMI_CCITT ? LMI_CCITT_PVCSTAT :
 797				       LMI_ANSI_CISCO_PVCSTAT)) {
 798			netdev_info(dev, "Not an LMI PVC status IE (0x%02X)\n",
 799				    skb->data[i]);
 800			return 1;
 801		}
 802
 803		if (skb->data[++i] != stat_len) {
 804			netdev_info(dev, "Invalid LMI PVC status IE length (%u)\n",
 805				    skb->data[i]);
 806			return 1;
 807		}
 808		i++;
 809
 810		new = !! (skb->data[i + 2] & 0x08);
 811		active = !! (skb->data[i + 2] & 0x02);
 812		if (lmi == LMI_CISCO) {
 813			dlci = (skb->data[i] << 8) | skb->data[i + 1];
 814			bw = (skb->data[i + 3] << 16) |
 815				(skb->data[i + 4] << 8) |
 816				(skb->data[i + 5]);
 817		} else {
 818			dlci = ((skb->data[i] & 0x3F) << 4) |
 819				((skb->data[i + 1] & 0x78) >> 3);
 820			bw = 0;
 821		}
 822
 823		pvc = add_pvc(dev, dlci);
 824
 825		if (!pvc && !no_ram) {
 826			netdev_warn(dev, "Memory squeeze on fr_lmi_recv()\n");
 827			no_ram = 1;
 828		}
 829
 830		if (pvc) {
 831			pvc->state.exist = 1;
 832			pvc->state.deleted = 0;
 833			if (active != pvc->state.active ||
 834			    new != pvc->state.new ||
 835			    bw != pvc->state.bandwidth ||
 836			    !pvc->state.exist) {
 837				pvc->state.new = new;
 838				pvc->state.active = active;
 839				pvc->state.bandwidth = bw;
 840				pvc_carrier(active, pvc);
 841				fr_log_dlci_active(pvc);
 842			}
 843		}
 844
 845		i += stat_len;
 846	}
 847
 848	pvc = state(hdlc)->first_pvc;
 849
 850	while (pvc) {
 851		if (pvc->state.deleted && pvc->state.exist) {
 852			pvc_carrier(0, pvc);
 853			pvc->state.active = pvc->state.new = 0;
 854			pvc->state.exist = 0;
 855			pvc->state.bandwidth = 0;
 856			fr_log_dlci_active(pvc);
 857		}
 858		pvc = pvc->next;
 859	}
 860
 861	/* Next full report after N391 polls */
 862	state(hdlc)->n391cnt = state(hdlc)->settings.n391;
 863
 864	return 0;
 865}
 866
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 867
 868static int fr_rx(struct sk_buff *skb)
 869{
 870	struct net_device *frad = skb->dev;
 871	hdlc_device *hdlc = dev_to_hdlc(frad);
 872	fr_hdr *fh = (fr_hdr*)skb->data;
 873	u8 *data = skb->data;
 874	u16 dlci;
 875	pvc_device *pvc;
 876	struct net_device *dev = NULL;
 877
 878	if (skb->len <= 4 || fh->ea1 || data[2] != FR_UI)
 879		goto rx_error;
 880
 881	dlci = q922_to_dlci(skb->data);
 882
 883	if ((dlci == LMI_CCITT_ANSI_DLCI &&
 884	     (state(hdlc)->settings.lmi == LMI_ANSI ||
 885	      state(hdlc)->settings.lmi == LMI_CCITT)) ||
 886	    (dlci == LMI_CISCO_DLCI &&
 887	     state(hdlc)->settings.lmi == LMI_CISCO)) {
 888		if (fr_lmi_recv(frad, skb))
 889			goto rx_error;
 890		dev_kfree_skb_any(skb);
 891		return NET_RX_SUCCESS;
 892	}
 893
 894	pvc = find_pvc(hdlc, dlci);
 895	if (!pvc) {
 896#ifdef DEBUG_PKT
 897		netdev_info(frad, "No PVC for received frame's DLCI %d\n",
 898			    dlci);
 899#endif
 900		dev_kfree_skb_any(skb);
 901		return NET_RX_DROP;
 902	}
 903
 904	if (pvc->state.fecn != fh->fecn) {
 905#ifdef DEBUG_ECN
 906		printk(KERN_DEBUG "%s: DLCI %d FECN O%s\n", frad->name,
 907		       dlci, fh->fecn ? "N" : "FF");
 908#endif
 909		pvc->state.fecn ^= 1;
 910	}
 911
 912	if (pvc->state.becn != fh->becn) {
 913#ifdef DEBUG_ECN
 914		printk(KERN_DEBUG "%s: DLCI %d BECN O%s\n", frad->name,
 915		       dlci, fh->becn ? "N" : "FF");
 916#endif
 917		pvc->state.becn ^= 1;
 918	}
 919
 920
 921	if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL) {
 922		frad->stats.rx_dropped++;
 923		return NET_RX_DROP;
 924	}
 925
 926	if (data[3] == NLPID_IP) {
 
 
 927		skb_pull(skb, 4); /* Remove 4-byte header (hdr, UI, NLPID) */
 928		dev = pvc->main;
 929		skb->protocol = htons(ETH_P_IP);
 
 930
 931	} else if (data[3] == NLPID_IPV6) {
 
 
 932		skb_pull(skb, 4); /* Remove 4-byte header (hdr, UI, NLPID) */
 933		dev = pvc->main;
 934		skb->protocol = htons(ETH_P_IPV6);
 
 935
 936	} else if (skb->len > 10 && data[3] == FR_PAD &&
 937		   data[4] == NLPID_SNAP && data[5] == FR_PAD) {
 938		u16 oui = ntohs(*(__be16*)(data + 6));
 939		u16 pid = ntohs(*(__be16*)(data + 8));
 940		skb_pull(skb, 10);
 941
 942		switch ((((u32)oui) << 16) | pid) {
 943		case ETH_P_ARP: /* routed frame with SNAP */
 944		case ETH_P_IPX:
 945		case ETH_P_IP:	/* a long variant */
 946		case ETH_P_IPV6:
 947			dev = pvc->main;
 948			skb->protocol = htons(pid);
 949			break;
 950
 951		case 0x80C20007: /* bridged Ethernet frame */
 952			if ((dev = pvc->ether) != NULL)
 953				skb->protocol = eth_type_trans(skb, dev);
 954			break;
 955
 956		default:
 957			netdev_info(frad, "Unsupported protocol, OUI=%x PID=%x\n",
 958				    oui, pid);
 959			dev_kfree_skb_any(skb);
 960			return NET_RX_DROP;
 961		}
 
 962	} else {
 963		netdev_info(frad, "Unsupported protocol, NLPID=%x length=%i\n",
 964			    data[3], skb->len);
 965		dev_kfree_skb_any(skb);
 966		return NET_RX_DROP;
 967	}
 968
 969	if (dev) {
 970		dev->stats.rx_packets++; /* PVC traffic */
 971		dev->stats.rx_bytes += skb->len;
 972		if (pvc->state.becn)
 973			dev->stats.rx_compressed++;
 974		skb->dev = dev;
 975		netif_rx(skb);
 976		return NET_RX_SUCCESS;
 977	} else {
 978		dev_kfree_skb_any(skb);
 979		return NET_RX_DROP;
 980	}
 981
 982 rx_error:
 983	frad->stats.rx_errors++; /* Mark error */
 
 984	dev_kfree_skb_any(skb);
 985	return NET_RX_DROP;
 986}
 987
 988
 989
 990static void fr_start(struct net_device *dev)
 991{
 992	hdlc_device *hdlc = dev_to_hdlc(dev);
 993#ifdef DEBUG_LINK
 994	printk(KERN_DEBUG "fr_start\n");
 995#endif
 996	if (state(hdlc)->settings.lmi != LMI_NONE) {
 997		state(hdlc)->reliable = 0;
 998		state(hdlc)->dce_changed = 1;
 999		state(hdlc)->request = 0;
1000		state(hdlc)->fullrep_sent = 0;
1001		state(hdlc)->last_errors = 0xFFFFFFFF;
1002		state(hdlc)->n391cnt = 0;
1003		state(hdlc)->txseq = state(hdlc)->rxseq = 0;
1004
1005		init_timer(&state(hdlc)->timer);
 
1006		/* First poll after 1 s */
1007		state(hdlc)->timer.expires = jiffies + HZ;
1008		state(hdlc)->timer.function = fr_timer;
1009		state(hdlc)->timer.data = (unsigned long)dev;
1010		add_timer(&state(hdlc)->timer);
1011	} else
1012		fr_set_link_state(1, dev);
 
1013}
1014
1015
1016static void fr_stop(struct net_device *dev)
1017{
1018	hdlc_device *hdlc = dev_to_hdlc(dev);
1019#ifdef DEBUG_LINK
1020	printk(KERN_DEBUG "fr_stop\n");
1021#endif
1022	if (state(hdlc)->settings.lmi != LMI_NONE)
1023		del_timer_sync(&state(hdlc)->timer);
1024	fr_set_link_state(0, dev);
1025}
1026
1027
1028static void fr_close(struct net_device *dev)
1029{
1030	hdlc_device *hdlc = dev_to_hdlc(dev);
1031	pvc_device *pvc = state(hdlc)->first_pvc;
1032
1033	while (pvc) {		/* Shutdown all PVCs for this FRAD */
1034		if (pvc->main)
1035			dev_close(pvc->main);
1036		if (pvc->ether)
1037			dev_close(pvc->ether);
1038		pvc = pvc->next;
1039	}
1040}
1041
1042
1043static void pvc_setup(struct net_device *dev)
1044{
1045	dev->type = ARPHRD_DLCI;
1046	dev->flags = IFF_POINTOPOINT;
1047	dev->hard_header_len = 10;
1048	dev->addr_len = 2;
1049	dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
1050}
1051
1052static const struct net_device_ops pvc_ops = {
1053	.ndo_open       = pvc_open,
1054	.ndo_stop       = pvc_close,
1055	.ndo_change_mtu = hdlc_change_mtu,
1056	.ndo_start_xmit = pvc_xmit,
1057	.ndo_do_ioctl   = pvc_ioctl,
1058};
1059
1060static int fr_add_pvc(struct net_device *frad, unsigned int dlci, int type)
1061{
1062	hdlc_device *hdlc = dev_to_hdlc(frad);
1063	pvc_device *pvc;
1064	struct net_device *dev;
1065	int used;
1066
1067	if ((pvc = add_pvc(frad, dlci)) == NULL) {
 
1068		netdev_warn(frad, "Memory squeeze on fr_add_pvc()\n");
1069		return -ENOBUFS;
1070	}
1071
1072	if (*get_dev_p(pvc, type))
1073		return -EEXIST;
1074
1075	used = pvc_is_used(pvc);
1076
1077	if (type == ARPHRD_ETHER) {
1078		dev = alloc_netdev(0, "pvceth%d", ether_setup);
1079		dev->priv_flags &= ~IFF_TX_SKB_SHARING;
1080	} else
1081		dev = alloc_netdev(0, "pvc%d", pvc_setup);
1082
1083	if (!dev) {
1084		netdev_warn(frad, "Memory squeeze on fr_pvc()\n");
1085		delete_unused_pvcs(hdlc);
1086		return -ENOBUFS;
1087	}
1088
1089	if (type == ARPHRD_ETHER)
1090		random_ether_addr(dev->dev_addr);
1091	else {
1092		*(__be16*)dev->dev_addr = htons(dlci);
 
 
 
1093		dlci_to_q922(dev->broadcast, dlci);
1094	}
1095	dev->netdev_ops = &pvc_ops;
1096	dev->mtu = HDLC_MAX_MTU;
1097	dev->tx_queue_len = 0;
 
 
 
1098	dev->ml_priv = pvc;
1099
1100	if (register_netdevice(dev) != 0) {
1101		free_netdev(dev);
1102		delete_unused_pvcs(hdlc);
1103		return -EIO;
1104	}
1105
1106	dev->destructor = free_netdev;
1107	*get_dev_p(pvc, type) = dev;
1108	if (!used) {
1109		state(hdlc)->dce_changed = 1;
1110		state(hdlc)->dce_pvc_count++;
1111	}
1112	return 0;
1113}
1114
1115
1116
1117static int fr_del_pvc(hdlc_device *hdlc, unsigned int dlci, int type)
1118{
1119	pvc_device *pvc;
1120	struct net_device *dev;
1121
1122	if ((pvc = find_pvc(hdlc, dlci)) == NULL)
 
1123		return -ENOENT;
1124
1125	if ((dev = *get_dev_p(pvc, type)) == NULL)
 
1126		return -ENOENT;
1127
1128	if (dev->flags & IFF_UP)
1129		return -EBUSY;		/* PVC in use */
1130
1131	unregister_netdevice(dev); /* the destructor will free_netdev(dev) */
1132	*get_dev_p(pvc, type) = NULL;
1133
1134	if (!pvc_is_used(pvc)) {
1135		state(hdlc)->dce_pvc_count--;
1136		state(hdlc)->dce_changed = 1;
1137	}
1138	delete_unused_pvcs(hdlc);
1139	return 0;
1140}
1141
1142
1143
1144static void fr_destroy(struct net_device *frad)
1145{
1146	hdlc_device *hdlc = dev_to_hdlc(frad);
1147	pvc_device *pvc = state(hdlc)->first_pvc;
 
1148	state(hdlc)->first_pvc = NULL; /* All PVCs destroyed */
1149	state(hdlc)->dce_pvc_count = 0;
1150	state(hdlc)->dce_changed = 1;
1151
1152	while (pvc) {
1153		pvc_device *next = pvc->next;
1154		/* destructors will free_netdev() main and ether */
1155		if (pvc->main)
1156			unregister_netdevice(pvc->main);
1157
1158		if (pvc->ether)
1159			unregister_netdevice(pvc->ether);
1160
1161		kfree(pvc);
1162		pvc = next;
1163	}
1164}
1165
1166
1167static struct hdlc_proto proto = {
1168	.close		= fr_close,
1169	.start		= fr_start,
1170	.stop		= fr_stop,
1171	.detach		= fr_destroy,
1172	.ioctl		= fr_ioctl,
1173	.netif_rx	= fr_rx,
1174	.module		= THIS_MODULE,
1175};
1176
1177
1178static int fr_ioctl(struct net_device *dev, struct ifreq *ifr)
1179{
1180	fr_proto __user *fr_s = ifr->ifr_settings.ifs_ifsu.fr;
1181	const size_t size = sizeof(fr_proto);
1182	fr_proto new_settings;
1183	hdlc_device *hdlc = dev_to_hdlc(dev);
1184	fr_proto_pvc pvc;
1185	int result;
1186
1187	switch (ifr->ifr_settings.type) {
1188	case IF_GET_PROTO:
1189		if (dev_to_hdlc(dev)->proto != &proto) /* Different proto */
1190			return -EINVAL;
1191		ifr->ifr_settings.type = IF_PROTO_FR;
1192		if (ifr->ifr_settings.size < size) {
1193			ifr->ifr_settings.size = size; /* data size wanted */
1194			return -ENOBUFS;
1195		}
1196		if (copy_to_user(fr_s, &state(hdlc)->settings, size))
1197			return -EFAULT;
1198		return 0;
1199
1200	case IF_PROTO_FR:
1201		if (!capable(CAP_NET_ADMIN))
1202			return -EPERM;
1203
1204		if (dev->flags & IFF_UP)
1205			return -EBUSY;
1206
1207		if (copy_from_user(&new_settings, fr_s, size))
1208			return -EFAULT;
1209
1210		if (new_settings.lmi == LMI_DEFAULT)
1211			new_settings.lmi = LMI_ANSI;
1212
1213		if ((new_settings.lmi != LMI_NONE &&
1214		     new_settings.lmi != LMI_ANSI &&
1215		     new_settings.lmi != LMI_CCITT &&
1216		     new_settings.lmi != LMI_CISCO) ||
1217		    new_settings.t391 < 1 ||
1218		    new_settings.t392 < 2 ||
1219		    new_settings.n391 < 1 ||
1220		    new_settings.n392 < 1 ||
1221		    new_settings.n393 < new_settings.n392 ||
1222		    new_settings.n393 > 32 ||
1223		    (new_settings.dce != 0 &&
1224		     new_settings.dce != 1))
1225			return -EINVAL;
1226
1227		result=hdlc->attach(dev, ENCODING_NRZ,PARITY_CRC16_PR1_CCITT);
 
1228		if (result)
1229			return result;
1230
1231		if (dev_to_hdlc(dev)->proto != &proto) { /* Different proto */
1232			result = attach_hdlc_protocol(dev, &proto,
1233						      sizeof(struct frad_state));
1234			if (result)
1235				return result;
1236			state(hdlc)->first_pvc = NULL;
1237			state(hdlc)->dce_pvc_count = 0;
1238		}
1239		memcpy(&state(hdlc)->settings, &new_settings, size);
1240		dev->type = ARPHRD_FRAD;
 
1241		return 0;
1242
1243	case IF_PROTO_FR_ADD_PVC:
1244	case IF_PROTO_FR_DEL_PVC:
1245	case IF_PROTO_FR_ADD_ETH_PVC:
1246	case IF_PROTO_FR_DEL_ETH_PVC:
1247		if (dev_to_hdlc(dev)->proto != &proto) /* Different proto */
1248			return -EINVAL;
1249
1250		if (!capable(CAP_NET_ADMIN))
1251			return -EPERM;
1252
1253		if (copy_from_user(&pvc, ifr->ifr_settings.ifs_ifsu.fr_pvc,
1254				   sizeof(fr_proto_pvc)))
1255			return -EFAULT;
1256
1257		if (pvc.dlci <= 0 || pvc.dlci >= 1024)
1258			return -EINVAL;	/* Only 10 bits, DLCI 0 reserved */
1259
1260		if (ifr->ifr_settings.type == IF_PROTO_FR_ADD_ETH_PVC ||
1261		    ifr->ifr_settings.type == IF_PROTO_FR_DEL_ETH_PVC)
1262			result = ARPHRD_ETHER; /* bridged Ethernet device */
1263		else
1264			result = ARPHRD_DLCI;
1265
1266		if (ifr->ifr_settings.type == IF_PROTO_FR_ADD_PVC ||
1267		    ifr->ifr_settings.type == IF_PROTO_FR_ADD_ETH_PVC)
1268			return fr_add_pvc(dev, pvc.dlci, result);
1269		else
1270			return fr_del_pvc(hdlc, pvc.dlci, result);
1271	}
1272
1273	return -EINVAL;
1274}
1275
1276
1277static int __init mod_init(void)
1278{
1279	register_hdlc_protocol(&proto);
1280	return 0;
1281}
1282
1283
1284static void __exit mod_exit(void)
1285{
1286	unregister_hdlc_protocol(&proto);
1287}
1288
1289
1290module_init(mod_init);
1291module_exit(mod_exit);
1292
1293MODULE_AUTHOR("Krzysztof Halasa <khc@pm.waw.pl>");
1294MODULE_DESCRIPTION("Frame-Relay protocol support for generic HDLC");
1295MODULE_LICENSE("GPL v2");
v6.8
   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Generic HDLC support routines for Linux
   4 * Frame Relay support
   5 *
   6 * Copyright (C) 1999 - 2006 Krzysztof Halasa <khc@pm.waw.pl>
   7 *
 
 
 
 
   8
   9	Theory of PVC state
  10
  11 DCE mode:
  12
  13 (exist,new) -> 0,0 when "PVC create" or if "link unreliable"
  14	 0,x -> 1,1 if "link reliable" when sending FULL STATUS
  15	 1,1 -> 1,0 if received FULL STATUS ACK
  16
  17 (active)    -> 0 when "ifconfig PVC down" or "link unreliable" or "PVC create"
  18	     -> 1 when "PVC up" and (exist,new) = 1,0
  19
  20 DTE mode:
  21 (exist,new,active) = FULL STATUS if "link reliable"
  22		    = 0, 0, 0 if "link unreliable"
  23 No LMI:
  24 active = open and "link reliable"
  25 exist = new = not used
  26
  27 CCITT LMI: ITU-T Q.933 Annex A
  28 ANSI LMI: ANSI T1.617 Annex D
  29 CISCO LMI: the original, aka "Gang of Four" LMI
  30
  31*/
  32
  33#include <linux/errno.h>
  34#include <linux/etherdevice.h>
  35#include <linux/hdlc.h>
  36#include <linux/if_arp.h>
  37#include <linux/inetdevice.h>
  38#include <linux/init.h>
  39#include <linux/kernel.h>
  40#include <linux/module.h>
  41#include <linux/pkt_sched.h>
  42#include <linux/poll.h>
  43#include <linux/rtnetlink.h>
  44#include <linux/skbuff.h>
  45#include <linux/slab.h>
  46
  47#undef DEBUG_PKT
  48#undef DEBUG_ECN
  49#undef DEBUG_LINK
  50#undef DEBUG_PROTO
  51#undef DEBUG_PVC
  52
  53#define FR_UI			0x03
  54#define FR_PAD			0x00
  55
  56#define NLPID_IP		0xCC
  57#define NLPID_IPV6		0x8E
  58#define NLPID_SNAP		0x80
  59#define NLPID_PAD		0x00
  60#define NLPID_CCITT_ANSI_LMI	0x08
  61#define NLPID_CISCO_LMI		0x09
  62
 
  63#define LMI_CCITT_ANSI_DLCI	   0 /* LMI DLCI */
  64#define LMI_CISCO_DLCI		1023
  65
  66#define LMI_CALLREF		0x00 /* Call Reference */
  67#define LMI_ANSI_LOCKSHIFT	0x95 /* ANSI locking shift */
  68#define LMI_ANSI_CISCO_REPTYPE	0x01 /* report type */
  69#define LMI_CCITT_REPTYPE	0x51
  70#define LMI_ANSI_CISCO_ALIVE	0x03 /* keep alive */
  71#define LMI_CCITT_ALIVE		0x53
  72#define LMI_ANSI_CISCO_PVCSTAT	0x07 /* PVC status */
  73#define LMI_CCITT_PVCSTAT	0x57
  74
  75#define LMI_FULLREP		0x00 /* full report  */
  76#define LMI_INTEGRITY		0x01 /* link integrity report */
  77#define LMI_SINGLE		0x02 /* single PVC report */
  78
  79#define LMI_STATUS_ENQUIRY      0x75
  80#define LMI_STATUS              0x7D /* reply */
  81
  82#define LMI_REPT_LEN               1 /* report type element length */
  83#define LMI_INTEG_LEN              2 /* link integrity element length */
  84
  85#define LMI_CCITT_CISCO_LENGTH	  13 /* LMI frame lengths */
  86#define LMI_ANSI_LENGTH		  14
  87
  88struct fr_hdr {
 
  89#if defined(__LITTLE_ENDIAN_BITFIELD)
  90	unsigned ea1:	1;
  91	unsigned cr:	1;
  92	unsigned dlcih:	6;
  93
  94	unsigned ea2:	1;
  95	unsigned de:	1;
  96	unsigned becn:	1;
  97	unsigned fecn:	1;
  98	unsigned dlcil:	4;
  99#else
 100	unsigned dlcih:	6;
 101	unsigned cr:	1;
 102	unsigned ea1:	1;
 103
 104	unsigned dlcil:	4;
 105	unsigned fecn:	1;
 106	unsigned becn:	1;
 107	unsigned de:	1;
 108	unsigned ea2:	1;
 109#endif
 110} __packed;
 111
 112struct pvc_device {
 
 113	struct net_device *frad;
 114	struct net_device *main;
 115	struct net_device *ether;	/* bridged Ethernet interface	*/
 116	struct pvc_device *next;	/* Sorted in ascending DLCI order */
 117	int dlci;
 118	int open_count;
 119
 120	struct {
 121		unsigned int new: 1;
 122		unsigned int active: 1;
 123		unsigned int exist: 1;
 124		unsigned int deleted: 1;
 125		unsigned int fecn: 1;
 126		unsigned int becn: 1;
 127		unsigned int bandwidth;	/* Cisco LMI reporting only */
 128	} state;
 129};
 130
 131struct frad_state {
 132	fr_proto settings;
 133	struct pvc_device *first_pvc;
 134	int dce_pvc_count;
 135
 136	struct timer_list timer;
 137	struct net_device *dev;
 138	unsigned long last_poll;
 139	int reliable;
 140	int dce_changed;
 141	int request;
 142	int fullrep_sent;
 143	u32 last_errors; /* last errors bit list */
 144	u8 n391cnt;
 145	u8 txseq; /* TX sequence number */
 146	u8 rxseq; /* RX sequence number */
 147};
 148
 149static int fr_ioctl(struct net_device *dev, struct if_settings *ifs);
 
 
 150
 151static inline u16 q922_to_dlci(u8 *hdr)
 152{
 153	return ((hdr[0] & 0xFC) << 2) | ((hdr[1] & 0xF0) >> 4);
 154}
 155
 
 156static inline void dlci_to_q922(u8 *hdr, u16 dlci)
 157{
 158	hdr[0] = (dlci >> 2) & 0xFC;
 159	hdr[1] = ((dlci << 4) & 0xF0) | 0x01;
 160}
 161
 162static inline struct frad_state *state(hdlc_device *hdlc)
 
 163{
 164	return (struct frad_state *)(hdlc->state);
 165}
 166
 167static inline struct pvc_device *find_pvc(hdlc_device *hdlc, u16 dlci)
 
 168{
 169	struct pvc_device *pvc = state(hdlc)->first_pvc;
 170
 171	while (pvc) {
 172		if (pvc->dlci == dlci)
 173			return pvc;
 174		if (pvc->dlci > dlci)
 175			return NULL; /* the list is sorted */
 176		pvc = pvc->next;
 177	}
 178
 179	return NULL;
 180}
 181
 182static struct pvc_device *add_pvc(struct net_device *dev, u16 dlci)
 
 183{
 184	hdlc_device *hdlc = dev_to_hdlc(dev);
 185	struct pvc_device *pvc, **pvc_p = &state(hdlc)->first_pvc;
 186
 187	while (*pvc_p) {
 188		if ((*pvc_p)->dlci == dlci)
 189			return *pvc_p;
 190		if ((*pvc_p)->dlci > dlci)
 191			break;	/* the list is sorted */
 192		pvc_p = &(*pvc_p)->next;
 193	}
 194
 195	pvc = kzalloc(sizeof(*pvc), GFP_ATOMIC);
 196#ifdef DEBUG_PVC
 197	printk(KERN_DEBUG "add_pvc: allocated pvc %p, frad %p\n", pvc, dev);
 198#endif
 199	if (!pvc)
 200		return NULL;
 201
 202	pvc->dlci = dlci;
 203	pvc->frad = dev;
 204	pvc->next = *pvc_p;	/* Put it in the chain */
 205	*pvc_p = pvc;
 206	return pvc;
 207}
 208
 209static inline int pvc_is_used(struct pvc_device *pvc)
 
 210{
 211	return pvc->main || pvc->ether;
 212}
 213
 214static inline void pvc_carrier(int on, struct pvc_device *pvc)
 
 215{
 216	if (on) {
 217		if (pvc->main)
 218			if (!netif_carrier_ok(pvc->main))
 219				netif_carrier_on(pvc->main);
 220		if (pvc->ether)
 221			if (!netif_carrier_ok(pvc->ether))
 222				netif_carrier_on(pvc->ether);
 223	} else {
 224		if (pvc->main)
 225			if (netif_carrier_ok(pvc->main))
 226				netif_carrier_off(pvc->main);
 227		if (pvc->ether)
 228			if (netif_carrier_ok(pvc->ether))
 229				netif_carrier_off(pvc->ether);
 230	}
 231}
 232
 
 233static inline void delete_unused_pvcs(hdlc_device *hdlc)
 234{
 235	struct pvc_device **pvc_p = &state(hdlc)->first_pvc;
 236
 237	while (*pvc_p) {
 238		if (!pvc_is_used(*pvc_p)) {
 239			struct pvc_device *pvc = *pvc_p;
 240#ifdef DEBUG_PVC
 241			printk(KERN_DEBUG "freeing unused pvc: %p\n", pvc);
 242#endif
 243			*pvc_p = pvc->next;
 244			kfree(pvc);
 245			continue;
 246		}
 247		pvc_p = &(*pvc_p)->next;
 248	}
 249}
 250
 251static inline struct net_device **get_dev_p(struct pvc_device *pvc,
 252					    int type)
 253{
 254	if (type == ARPHRD_ETHER)
 255		return &pvc->ether;
 256	else
 257		return &pvc->main;
 258}
 259
 260static int fr_hard_header(struct sk_buff *skb, u16 dlci)
 
 261{
 262	if (!skb->dev) { /* Control packets */
 263		switch (dlci) {
 264		case LMI_CCITT_ANSI_DLCI:
 265			skb_push(skb, 4);
 266			skb->data[3] = NLPID_CCITT_ANSI_LMI;
 267			break;
 268
 269		case LMI_CISCO_DLCI:
 270			skb_push(skb, 4);
 271			skb->data[3] = NLPID_CISCO_LMI;
 272			break;
 273
 274		default:
 275			return -EINVAL;
 276		}
 277
 278	} else if (skb->dev->type == ARPHRD_DLCI) {
 279		switch (skb->protocol) {
 280		case htons(ETH_P_IP):
 281			skb_push(skb, 4);
 282			skb->data[3] = NLPID_IP;
 283			break;
 284
 285		case htons(ETH_P_IPV6):
 286			skb_push(skb, 4);
 287			skb->data[3] = NLPID_IPV6;
 288			break;
 289
 290		default:
 291			skb_push(skb, 10);
 292			skb->data[3] = FR_PAD;
 293			skb->data[4] = NLPID_SNAP;
 294			/* OUI 00-00-00 indicates an Ethertype follows */
 295			skb->data[5] = 0x00;
 296			skb->data[6] = 0x00;
 297			skb->data[7] = 0x00;
 298			/* This should be an Ethertype: */
 299			*(__be16 *)(skb->data + 8) = skb->protocol;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 300		}
 301
 302	} else if (skb->dev->type == ARPHRD_ETHER) {
 303		skb_push(skb, 10);
 304		skb->data[3] = FR_PAD;
 305		skb->data[4] = NLPID_SNAP;
 306		/* OUI 00-80-C2 stands for the 802.1 organization */
 307		skb->data[5] = 0x00;
 308		skb->data[6] = 0x80;
 309		skb->data[7] = 0xC2;
 310		/* PID 00-07 stands for Ethernet frames without FCS */
 311		skb->data[8] = 0x00;
 312		skb->data[9] = 0x07;
 
 313
 314	} else {
 315		return -EINVAL;
 
 
 
 
 
 
 
 316	}
 317
 318	dlci_to_q922(skb->data, dlci);
 319	skb->data[2] = FR_UI;
 320	return 0;
 321}
 322
 
 
 323static int pvc_open(struct net_device *dev)
 324{
 325	struct pvc_device *pvc = dev->ml_priv;
 326
 327	if ((pvc->frad->flags & IFF_UP) == 0)
 328		return -EIO;  /* Frad must be UP in order to activate PVC */
 329
 330	if (pvc->open_count++ == 0) {
 331		hdlc_device *hdlc = dev_to_hdlc(pvc->frad);
 332
 333		if (state(hdlc)->settings.lmi == LMI_NONE)
 334			pvc->state.active = netif_carrier_ok(pvc->frad);
 335
 336		pvc_carrier(pvc->state.active, pvc);
 337		state(hdlc)->dce_changed = 1;
 338	}
 339	return 0;
 340}
 341
 
 
 342static int pvc_close(struct net_device *dev)
 343{
 344	struct pvc_device *pvc = dev->ml_priv;
 345
 346	if (--pvc->open_count == 0) {
 347		hdlc_device *hdlc = dev_to_hdlc(pvc->frad);
 348
 349		if (state(hdlc)->settings.lmi == LMI_NONE)
 350			pvc->state.active = 0;
 351
 352		if (state(hdlc)->settings.dce) {
 353			state(hdlc)->dce_changed = 1;
 354			pvc->state.active = 0;
 355		}
 356	}
 357	return 0;
 358}
 359
 360static int pvc_ioctl(struct net_device *dev, struct if_settings *ifs)
 
 
 361{
 362	struct pvc_device *pvc = dev->ml_priv;
 363	fr_proto_pvc_info info;
 364
 365	if (ifs->type == IF_GET_PROTO) {
 366		if (dev->type == ARPHRD_ETHER)
 367			ifs->type = IF_PROTO_FR_ETH_PVC;
 368		else
 369			ifs->type = IF_PROTO_FR_PVC;
 370
 371		if (ifs->size < sizeof(info)) {
 372			/* data size wanted */
 373			ifs->size = sizeof(info);
 374			return -ENOBUFS;
 375		}
 376
 377		info.dlci = pvc->dlci;
 378		memcpy(info.master, pvc->frad->name, IFNAMSIZ);
 379		if (copy_to_user(ifs->ifs_ifsu.fr_pvc_info,
 380				 &info, sizeof(info)))
 381			return -EFAULT;
 382		return 0;
 383	}
 384
 385	return -EINVAL;
 386}
 387
 388static netdev_tx_t pvc_xmit(struct sk_buff *skb, struct net_device *dev)
 389{
 390	struct pvc_device *pvc = dev->ml_priv;
 391
 392	if (!pvc->state.active)
 393		goto drop;
 394
 395	if (dev->type == ARPHRD_ETHER) {
 396		int pad = ETH_ZLEN - skb->len;
 397
 398		if (pad > 0) { /* Pad the frame with zeros */
 399			if (__skb_pad(skb, pad, false))
 400				goto drop;
 401			skb_put(skb, pad);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 402		}
 403	}
 404
 405	/* We already requested the header space with dev->needed_headroom.
 406	 * So this is just a protection in case the upper layer didn't take
 407	 * dev->needed_headroom into consideration.
 408	 */
 409	if (skb_headroom(skb) < 10) {
 410		struct sk_buff *skb2 = skb_realloc_headroom(skb, 10);
 411
 412		if (!skb2)
 413			goto drop;
 414		dev_kfree_skb(skb);
 415		skb = skb2;
 416	}
 417
 418	skb->dev = dev;
 419	if (fr_hard_header(skb, pvc->dlci))
 420		goto drop;
 421
 422	dev->stats.tx_bytes += skb->len;
 423	dev->stats.tx_packets++;
 424	if (pvc->state.fecn) /* TX Congestion counter */
 425		dev->stats.tx_compressed++;
 426	skb->dev = pvc->frad;
 427	skb->protocol = htons(ETH_P_HDLC);
 428	skb_reset_network_header(skb);
 429	dev_queue_xmit(skb);
 430	return NETDEV_TX_OK;
 431
 432drop:
 433	dev->stats.tx_dropped++;
 434	kfree_skb(skb);
 435	return NETDEV_TX_OK;
 436}
 437
 438static inline void fr_log_dlci_active(struct pvc_device *pvc)
 439{
 440	netdev_info(pvc->frad, "DLCI %d [%s%s%s]%s %s\n",
 441		    pvc->dlci,
 442		    pvc->main ? pvc->main->name : "",
 443		    pvc->main && pvc->ether ? " " : "",
 444		    pvc->ether ? pvc->ether->name : "",
 445		    pvc->state.new ? " new" : "",
 446		    !pvc->state.exist ? "deleted" :
 447		    pvc->state.active ? "active" : "inactive");
 448}
 449
 
 
 450static inline u8 fr_lmi_nextseq(u8 x)
 451{
 452	x++;
 453	return x ? x : 1;
 454}
 455
 
 456static void fr_lmi_send(struct net_device *dev, int fullrep)
 457{
 458	hdlc_device *hdlc = dev_to_hdlc(dev);
 459	struct sk_buff *skb;
 460	struct pvc_device *pvc = state(hdlc)->first_pvc;
 461	int lmi = state(hdlc)->settings.lmi;
 462	int dce = state(hdlc)->settings.dce;
 463	int len = lmi == LMI_ANSI ? LMI_ANSI_LENGTH : LMI_CCITT_CISCO_LENGTH;
 464	int stat_len = (lmi == LMI_CISCO) ? 6 : 3;
 465	u8 *data;
 466	int i = 0;
 467
 468	if (dce && fullrep) {
 469		len += state(hdlc)->dce_pvc_count * (2 + stat_len);
 470		if (len > HDLC_MAX_MRU) {
 471			netdev_warn(dev, "Too many PVCs while sending LMI full report\n");
 472			return;
 473		}
 474	}
 475
 476	skb = dev_alloc_skb(len);
 477	if (!skb)
 
 478		return;
 479
 480	memset(skb->data, 0, len);
 481	skb_reserve(skb, 4);
 482	if (lmi == LMI_CISCO)
 483		fr_hard_header(skb, LMI_CISCO_DLCI);
 484	else
 485		fr_hard_header(skb, LMI_CCITT_ANSI_DLCI);
 486
 
 
 487	data = skb_tail_pointer(skb);
 488	data[i++] = LMI_CALLREF;
 489	data[i++] = dce ? LMI_STATUS : LMI_STATUS_ENQUIRY;
 490	if (lmi == LMI_ANSI)
 491		data[i++] = LMI_ANSI_LOCKSHIFT;
 492	data[i++] = lmi == LMI_CCITT ? LMI_CCITT_REPTYPE :
 493		LMI_ANSI_CISCO_REPTYPE;
 494	data[i++] = LMI_REPT_LEN;
 495	data[i++] = fullrep ? LMI_FULLREP : LMI_INTEGRITY;
 496	data[i++] = lmi == LMI_CCITT ? LMI_CCITT_ALIVE : LMI_ANSI_CISCO_ALIVE;
 497	data[i++] = LMI_INTEG_LEN;
 498	data[i++] = state(hdlc)->txseq =
 499		fr_lmi_nextseq(state(hdlc)->txseq);
 500	data[i++] = state(hdlc)->rxseq;
 501
 502	if (dce && fullrep) {
 503		while (pvc) {
 504			data[i++] = lmi == LMI_CCITT ? LMI_CCITT_PVCSTAT :
 505				LMI_ANSI_CISCO_PVCSTAT;
 506			data[i++] = stat_len;
 507
 508			/* LMI start/restart */
 509			if (state(hdlc)->reliable && !pvc->state.exist) {
 510				pvc->state.exist = pvc->state.new = 1;
 511				fr_log_dlci_active(pvc);
 512			}
 513
 514			/* ifconfig PVC up */
 515			if (pvc->open_count && !pvc->state.active &&
 516			    pvc->state.exist && !pvc->state.new) {
 517				pvc_carrier(1, pvc);
 518				pvc->state.active = 1;
 519				fr_log_dlci_active(pvc);
 520			}
 521
 522			if (lmi == LMI_CISCO) {
 523				data[i] = pvc->dlci >> 8;
 524				data[i + 1] = pvc->dlci & 0xFF;
 525			} else {
 526				data[i] = (pvc->dlci >> 4) & 0x3F;
 527				data[i + 1] = ((pvc->dlci << 3) & 0x78) | 0x80;
 528				data[i + 2] = 0x80;
 529			}
 530
 531			if (pvc->state.new)
 532				data[i + 2] |= 0x08;
 533			else if (pvc->state.active)
 534				data[i + 2] |= 0x02;
 535
 536			i += stat_len;
 537			pvc = pvc->next;
 538		}
 539	}
 540
 541	skb_put(skb, i);
 542	skb->priority = TC_PRIO_CONTROL;
 543	skb->dev = dev;
 544	skb->protocol = htons(ETH_P_HDLC);
 545	skb_reset_network_header(skb);
 546
 547	dev_queue_xmit(skb);
 548}
 549
 
 
 550static void fr_set_link_state(int reliable, struct net_device *dev)
 551{
 552	hdlc_device *hdlc = dev_to_hdlc(dev);
 553	struct pvc_device *pvc = state(hdlc)->first_pvc;
 554
 555	state(hdlc)->reliable = reliable;
 556	if (reliable) {
 557		netif_dormant_off(dev);
 558		state(hdlc)->n391cnt = 0; /* Request full status */
 559		state(hdlc)->dce_changed = 1;
 560
 561		if (state(hdlc)->settings.lmi == LMI_NONE) {
 562			while (pvc) {	/* Activate all PVCs */
 563				pvc_carrier(1, pvc);
 564				pvc->state.exist = pvc->state.active = 1;
 565				pvc->state.new = 0;
 566				pvc = pvc->next;
 567			}
 568		}
 569	} else {
 570		netif_dormant_on(dev);
 571		while (pvc) {		/* Deactivate all PVCs */
 572			pvc_carrier(0, pvc);
 573			pvc->state.exist = pvc->state.active = 0;
 574			pvc->state.new = 0;
 575			if (!state(hdlc)->settings.dce)
 576				pvc->state.bandwidth = 0;
 577			pvc = pvc->next;
 578		}
 579	}
 580}
 581
 582static void fr_timer(struct timer_list *t)
 
 583{
 584	struct frad_state *st = from_timer(st, t, timer);
 585	struct net_device *dev = st->dev;
 586	hdlc_device *hdlc = dev_to_hdlc(dev);
 587	int i, cnt = 0, reliable;
 588	u32 list;
 589
 590	if (state(hdlc)->settings.dce) {
 591		reliable = state(hdlc)->request &&
 592			time_before(jiffies, state(hdlc)->last_poll +
 593				    state(hdlc)->settings.t392 * HZ);
 594		state(hdlc)->request = 0;
 595	} else {
 596		state(hdlc)->last_errors <<= 1; /* Shift the list */
 597		if (state(hdlc)->request) {
 598			if (state(hdlc)->reliable)
 599				netdev_info(dev, "No LMI status reply received\n");
 600			state(hdlc)->last_errors |= 1;
 601		}
 602
 603		list = state(hdlc)->last_errors;
 604		for (i = 0; i < state(hdlc)->settings.n393; i++, list >>= 1)
 605			cnt += (list & 1);	/* errors count */
 606
 607		reliable = (cnt < state(hdlc)->settings.n392);
 608	}
 609
 610	if (state(hdlc)->reliable != reliable) {
 611		netdev_info(dev, "Link %sreliable\n", reliable ? "" : "un");
 612		fr_set_link_state(reliable, dev);
 613	}
 614
 615	if (state(hdlc)->settings.dce) {
 616		state(hdlc)->timer.expires = jiffies +
 617			state(hdlc)->settings.t392 * HZ;
 618	} else {
 619		if (state(hdlc)->n391cnt)
 620			state(hdlc)->n391cnt--;
 621
 622		fr_lmi_send(dev, state(hdlc)->n391cnt == 0);
 623
 624		state(hdlc)->last_poll = jiffies;
 625		state(hdlc)->request = 1;
 626		state(hdlc)->timer.expires = jiffies +
 627			state(hdlc)->settings.t391 * HZ;
 628	}
 629
 
 
 630	add_timer(&state(hdlc)->timer);
 631}
 632
 
 633static int fr_lmi_recv(struct net_device *dev, struct sk_buff *skb)
 634{
 635	hdlc_device *hdlc = dev_to_hdlc(dev);
 636	struct pvc_device *pvc;
 637	u8 rxseq, txseq;
 638	int lmi = state(hdlc)->settings.lmi;
 639	int dce = state(hdlc)->settings.dce;
 640	int stat_len = (lmi == LMI_CISCO) ? 6 : 3, reptype, error, no_ram, i;
 641
 642	if (skb->len < (lmi == LMI_ANSI ? LMI_ANSI_LENGTH :
 643			LMI_CCITT_CISCO_LENGTH)) {
 644		netdev_info(dev, "Short LMI frame\n");
 645		return 1;
 646	}
 647
 648	if (skb->data[3] != (lmi == LMI_CISCO ? NLPID_CISCO_LMI :
 649			     NLPID_CCITT_ANSI_LMI)) {
 650		netdev_info(dev, "Received non-LMI frame with LMI DLCI\n");
 651		return 1;
 652	}
 653
 654	if (skb->data[4] != LMI_CALLREF) {
 655		netdev_info(dev, "Invalid LMI Call reference (0x%02X)\n",
 656			    skb->data[4]);
 657		return 1;
 658	}
 659
 660	if (skb->data[5] != (dce ? LMI_STATUS_ENQUIRY : LMI_STATUS)) {
 661		netdev_info(dev, "Invalid LMI Message type (0x%02X)\n",
 662			    skb->data[5]);
 663		return 1;
 664	}
 665
 666	if (lmi == LMI_ANSI) {
 667		if (skb->data[6] != LMI_ANSI_LOCKSHIFT) {
 668			netdev_info(dev, "Not ANSI locking shift in LMI message (0x%02X)\n",
 669				    skb->data[6]);
 670			return 1;
 671		}
 672		i = 7;
 673	} else {
 674		i = 6;
 675	}
 676
 677	if (skb->data[i] != (lmi == LMI_CCITT ? LMI_CCITT_REPTYPE :
 678			     LMI_ANSI_CISCO_REPTYPE)) {
 679		netdev_info(dev, "Not an LMI Report type IE (0x%02X)\n",
 680			    skb->data[i]);
 681		return 1;
 682	}
 683
 684	if (skb->data[++i] != LMI_REPT_LEN) {
 685		netdev_info(dev, "Invalid LMI Report type IE length (%u)\n",
 686			    skb->data[i]);
 687		return 1;
 688	}
 689
 690	reptype = skb->data[++i];
 691	if (reptype != LMI_INTEGRITY && reptype != LMI_FULLREP) {
 692		netdev_info(dev, "Unsupported LMI Report type (0x%02X)\n",
 693			    reptype);
 694		return 1;
 695	}
 696
 697	if (skb->data[++i] != (lmi == LMI_CCITT ? LMI_CCITT_ALIVE :
 698			       LMI_ANSI_CISCO_ALIVE)) {
 699		netdev_info(dev, "Not an LMI Link integrity verification IE (0x%02X)\n",
 700			    skb->data[i]);
 701		return 1;
 702	}
 703
 704	if (skb->data[++i] != LMI_INTEG_LEN) {
 705		netdev_info(dev, "Invalid LMI Link integrity verification IE length (%u)\n",
 706			    skb->data[i]);
 707		return 1;
 708	}
 709	i++;
 710
 711	state(hdlc)->rxseq = skb->data[i++]; /* TX sequence from peer */
 712	rxseq = skb->data[i++];	/* Should confirm our sequence */
 713
 714	txseq = state(hdlc)->txseq;
 715
 716	if (dce)
 717		state(hdlc)->last_poll = jiffies;
 718
 719	error = 0;
 720	if (!state(hdlc)->reliable)
 721		error = 1;
 722
 723	if (rxseq == 0 || rxseq != txseq) { /* Ask for full report next time */
 724		state(hdlc)->n391cnt = 0;
 725		error = 1;
 726	}
 727
 728	if (dce) {
 729		if (state(hdlc)->fullrep_sent && !error) {
 730/* Stop sending full report - the last one has been confirmed by DTE */
 731			state(hdlc)->fullrep_sent = 0;
 732			pvc = state(hdlc)->first_pvc;
 733			while (pvc) {
 734				if (pvc->state.new) {
 735					pvc->state.new = 0;
 736
 737/* Tell DTE that new PVC is now active */
 738					state(hdlc)->dce_changed = 1;
 739				}
 740				pvc = pvc->next;
 741			}
 742		}
 743
 744		if (state(hdlc)->dce_changed) {
 745			reptype = LMI_FULLREP;
 746			state(hdlc)->fullrep_sent = 1;
 747			state(hdlc)->dce_changed = 0;
 748		}
 749
 750		state(hdlc)->request = 1; /* got request */
 751		fr_lmi_send(dev, reptype == LMI_FULLREP ? 1 : 0);
 752		return 0;
 753	}
 754
 755	/* DTE */
 756
 757	state(hdlc)->request = 0; /* got response, no request pending */
 758
 759	if (error)
 760		return 0;
 761
 762	if (reptype != LMI_FULLREP)
 763		return 0;
 764
 765	pvc = state(hdlc)->first_pvc;
 766
 767	while (pvc) {
 768		pvc->state.deleted = 1;
 769		pvc = pvc->next;
 770	}
 771
 772	no_ram = 0;
 773	while (skb->len >= i + 2 + stat_len) {
 774		u16 dlci;
 775		u32 bw;
 776		unsigned int active, new;
 777
 778		if (skb->data[i] != (lmi == LMI_CCITT ? LMI_CCITT_PVCSTAT :
 779				       LMI_ANSI_CISCO_PVCSTAT)) {
 780			netdev_info(dev, "Not an LMI PVC status IE (0x%02X)\n",
 781				    skb->data[i]);
 782			return 1;
 783		}
 784
 785		if (skb->data[++i] != stat_len) {
 786			netdev_info(dev, "Invalid LMI PVC status IE length (%u)\n",
 787				    skb->data[i]);
 788			return 1;
 789		}
 790		i++;
 791
 792		new = !!(skb->data[i + 2] & 0x08);
 793		active = !!(skb->data[i + 2] & 0x02);
 794		if (lmi == LMI_CISCO) {
 795			dlci = (skb->data[i] << 8) | skb->data[i + 1];
 796			bw = (skb->data[i + 3] << 16) |
 797				(skb->data[i + 4] << 8) |
 798				(skb->data[i + 5]);
 799		} else {
 800			dlci = ((skb->data[i] & 0x3F) << 4) |
 801				((skb->data[i + 1] & 0x78) >> 3);
 802			bw = 0;
 803		}
 804
 805		pvc = add_pvc(dev, dlci);
 806
 807		if (!pvc && !no_ram) {
 808			netdev_warn(dev, "Memory squeeze on fr_lmi_recv()\n");
 809			no_ram = 1;
 810		}
 811
 812		if (pvc) {
 813			pvc->state.exist = 1;
 814			pvc->state.deleted = 0;
 815			if (active != pvc->state.active ||
 816			    new != pvc->state.new ||
 817			    bw != pvc->state.bandwidth ||
 818			    !pvc->state.exist) {
 819				pvc->state.new = new;
 820				pvc->state.active = active;
 821				pvc->state.bandwidth = bw;
 822				pvc_carrier(active, pvc);
 823				fr_log_dlci_active(pvc);
 824			}
 825		}
 826
 827		i += stat_len;
 828	}
 829
 830	pvc = state(hdlc)->first_pvc;
 831
 832	while (pvc) {
 833		if (pvc->state.deleted && pvc->state.exist) {
 834			pvc_carrier(0, pvc);
 835			pvc->state.active = pvc->state.new = 0;
 836			pvc->state.exist = 0;
 837			pvc->state.bandwidth = 0;
 838			fr_log_dlci_active(pvc);
 839		}
 840		pvc = pvc->next;
 841	}
 842
 843	/* Next full report after N391 polls */
 844	state(hdlc)->n391cnt = state(hdlc)->settings.n391;
 845
 846	return 0;
 847}
 848
 849static int fr_snap_parse(struct sk_buff *skb, struct pvc_device *pvc)
 850{
 851	/* OUI 00-00-00 indicates an Ethertype follows */
 852	if (skb->data[0] == 0x00 &&
 853	    skb->data[1] == 0x00 &&
 854	    skb->data[2] == 0x00) {
 855		if (!pvc->main)
 856			return -1;
 857		skb->dev = pvc->main;
 858		skb->protocol = *(__be16 *)(skb->data + 3); /* Ethertype */
 859		skb_pull(skb, 5);
 860		skb_reset_mac_header(skb);
 861		return 0;
 862
 863	/* OUI 00-80-C2 stands for the 802.1 organization */
 864	} else if (skb->data[0] == 0x00 &&
 865		   skb->data[1] == 0x80 &&
 866		   skb->data[2] == 0xC2) {
 867		/* PID 00-07 stands for Ethernet frames without FCS */
 868		if (skb->data[3] == 0x00 &&
 869		    skb->data[4] == 0x07) {
 870			if (!pvc->ether)
 871				return -1;
 872			skb_pull(skb, 5);
 873			if (skb->len < ETH_HLEN)
 874				return -1;
 875			skb->protocol = eth_type_trans(skb, pvc->ether);
 876			return 0;
 877
 878		/* PID unsupported */
 879		} else {
 880			return -1;
 881		}
 882
 883	/* OUI unsupported */
 884	} else {
 885		return -1;
 886	}
 887}
 888
 889static int fr_rx(struct sk_buff *skb)
 890{
 891	struct net_device *frad = skb->dev;
 892	hdlc_device *hdlc = dev_to_hdlc(frad);
 893	struct fr_hdr *fh = (struct fr_hdr *)skb->data;
 894	u8 *data = skb->data;
 895	u16 dlci;
 896	struct pvc_device *pvc;
 897	struct net_device *dev;
 898
 899	if (skb->len < 4 || fh->ea1 || !fh->ea2 || data[2] != FR_UI)
 900		goto rx_error;
 901
 902	dlci = q922_to_dlci(skb->data);
 903
 904	if ((dlci == LMI_CCITT_ANSI_DLCI &&
 905	     (state(hdlc)->settings.lmi == LMI_ANSI ||
 906	      state(hdlc)->settings.lmi == LMI_CCITT)) ||
 907	    (dlci == LMI_CISCO_DLCI &&
 908	     state(hdlc)->settings.lmi == LMI_CISCO)) {
 909		if (fr_lmi_recv(frad, skb))
 910			goto rx_error;
 911		dev_kfree_skb_any(skb);
 912		return NET_RX_SUCCESS;
 913	}
 914
 915	pvc = find_pvc(hdlc, dlci);
 916	if (!pvc) {
 917#ifdef DEBUG_PKT
 918		netdev_info(frad, "No PVC for received frame's DLCI %d\n",
 919			    dlci);
 920#endif
 921		goto rx_drop;
 
 922	}
 923
 924	if (pvc->state.fecn != fh->fecn) {
 925#ifdef DEBUG_ECN
 926		printk(KERN_DEBUG "%s: DLCI %d FECN O%s\n", frad->name,
 927		       dlci, fh->fecn ? "N" : "FF");
 928#endif
 929		pvc->state.fecn ^= 1;
 930	}
 931
 932	if (pvc->state.becn != fh->becn) {
 933#ifdef DEBUG_ECN
 934		printk(KERN_DEBUG "%s: DLCI %d BECN O%s\n", frad->name,
 935		       dlci, fh->becn ? "N" : "FF");
 936#endif
 937		pvc->state.becn ^= 1;
 938	}
 939
 940	skb = skb_share_check(skb, GFP_ATOMIC);
 941	if (!skb) {
 942		frad->stats.rx_dropped++;
 943		return NET_RX_DROP;
 944	}
 945
 946	if (data[3] == NLPID_IP) {
 947		if (!pvc->main)
 948			goto rx_drop;
 949		skb_pull(skb, 4); /* Remove 4-byte header (hdr, UI, NLPID) */
 950		skb->dev = pvc->main;
 951		skb->protocol = htons(ETH_P_IP);
 952		skb_reset_mac_header(skb);
 953
 954	} else if (data[3] == NLPID_IPV6) {
 955		if (!pvc->main)
 956			goto rx_drop;
 957		skb_pull(skb, 4); /* Remove 4-byte header (hdr, UI, NLPID) */
 958		skb->dev = pvc->main;
 959		skb->protocol = htons(ETH_P_IPV6);
 960		skb_reset_mac_header(skb);
 961
 962	} else if (data[3] == FR_PAD) {
 963		if (skb->len < 5)
 964			goto rx_error;
 965		if (data[4] == NLPID_SNAP) { /* A SNAP header follows */
 966			skb_pull(skb, 5);
 967			if (skb->len < 5) /* Incomplete SNAP header */
 968				goto rx_error;
 969			if (fr_snap_parse(skb, pvc))
 970				goto rx_drop;
 971		} else {
 972			goto rx_drop;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 973		}
 974
 975	} else {
 976		netdev_info(frad, "Unsupported protocol, NLPID=%x length=%i\n",
 977			    data[3], skb->len);
 978		goto rx_drop;
 
 979	}
 980
 981	dev = skb->dev;
 982	dev->stats.rx_packets++; /* PVC traffic */
 983	dev->stats.rx_bytes += skb->len;
 984	if (pvc->state.becn)
 985		dev->stats.rx_compressed++;
 986	netif_rx(skb);
 987	return NET_RX_SUCCESS;
 
 
 
 
 
 988
 989rx_error:
 990	frad->stats.rx_errors++; /* Mark error */
 991rx_drop:
 992	dev_kfree_skb_any(skb);
 993	return NET_RX_DROP;
 994}
 995
 
 
 996static void fr_start(struct net_device *dev)
 997{
 998	hdlc_device *hdlc = dev_to_hdlc(dev);
 999#ifdef DEBUG_LINK
1000	printk(KERN_DEBUG "fr_start\n");
1001#endif
1002	if (state(hdlc)->settings.lmi != LMI_NONE) {
1003		state(hdlc)->reliable = 0;
1004		state(hdlc)->dce_changed = 1;
1005		state(hdlc)->request = 0;
1006		state(hdlc)->fullrep_sent = 0;
1007		state(hdlc)->last_errors = 0xFFFFFFFF;
1008		state(hdlc)->n391cnt = 0;
1009		state(hdlc)->txseq = state(hdlc)->rxseq = 0;
1010
1011		state(hdlc)->dev = dev;
1012		timer_setup(&state(hdlc)->timer, fr_timer, 0);
1013		/* First poll after 1 s */
1014		state(hdlc)->timer.expires = jiffies + HZ;
 
 
1015		add_timer(&state(hdlc)->timer);
1016	} else {
1017		fr_set_link_state(1, dev);
1018	}
1019}
1020
 
1021static void fr_stop(struct net_device *dev)
1022{
1023	hdlc_device *hdlc = dev_to_hdlc(dev);
1024#ifdef DEBUG_LINK
1025	printk(KERN_DEBUG "fr_stop\n");
1026#endif
1027	if (state(hdlc)->settings.lmi != LMI_NONE)
1028		del_timer_sync(&state(hdlc)->timer);
1029	fr_set_link_state(0, dev);
1030}
1031
 
1032static void fr_close(struct net_device *dev)
1033{
1034	hdlc_device *hdlc = dev_to_hdlc(dev);
1035	struct pvc_device *pvc = state(hdlc)->first_pvc;
1036
1037	while (pvc) {		/* Shutdown all PVCs for this FRAD */
1038		if (pvc->main)
1039			dev_close(pvc->main);
1040		if (pvc->ether)
1041			dev_close(pvc->ether);
1042		pvc = pvc->next;
1043	}
1044}
1045
 
1046static void pvc_setup(struct net_device *dev)
1047{
1048	dev->type = ARPHRD_DLCI;
1049	dev->flags = IFF_POINTOPOINT;
1050	dev->hard_header_len = 0;
1051	dev->addr_len = 2;
1052	netif_keep_dst(dev);
1053}
1054
1055static const struct net_device_ops pvc_ops = {
1056	.ndo_open       = pvc_open,
1057	.ndo_stop       = pvc_close,
 
1058	.ndo_start_xmit = pvc_xmit,
1059	.ndo_siocwandev = pvc_ioctl,
1060};
1061
1062static int fr_add_pvc(struct net_device *frad, unsigned int dlci, int type)
1063{
1064	hdlc_device *hdlc = dev_to_hdlc(frad);
1065	struct pvc_device *pvc;
1066	struct net_device *dev;
1067	int used;
1068
1069	pvc = add_pvc(frad, dlci);
1070	if (!pvc) {
1071		netdev_warn(frad, "Memory squeeze on fr_add_pvc()\n");
1072		return -ENOBUFS;
1073	}
1074
1075	if (*get_dev_p(pvc, type))
1076		return -EEXIST;
1077
1078	used = pvc_is_used(pvc);
1079
1080	if (type == ARPHRD_ETHER)
1081		dev = alloc_netdev(0, "pvceth%d", NET_NAME_UNKNOWN,
1082				   ether_setup);
1083	else
1084		dev = alloc_netdev(0, "pvc%d", NET_NAME_UNKNOWN, pvc_setup);
1085
1086	if (!dev) {
1087		netdev_warn(frad, "Memory squeeze on fr_pvc()\n");
1088		delete_unused_pvcs(hdlc);
1089		return -ENOBUFS;
1090	}
1091
1092	if (type == ARPHRD_ETHER) {
1093		dev->priv_flags &= ~IFF_TX_SKB_SHARING;
1094		eth_hw_addr_random(dev);
1095	} else {
1096		__be16 addr = htons(dlci);
1097
1098		dev_addr_set(dev, (u8 *)&addr);
1099		dlci_to_q922(dev->broadcast, dlci);
1100	}
1101	dev->netdev_ops = &pvc_ops;
1102	dev->mtu = HDLC_MAX_MTU;
1103	dev->min_mtu = 68;
1104	dev->max_mtu = HDLC_MAX_MTU;
1105	dev->needed_headroom = 10;
1106	dev->priv_flags |= IFF_NO_QUEUE;
1107	dev->ml_priv = pvc;
1108
1109	if (register_netdevice(dev) != 0) {
1110		free_netdev(dev);
1111		delete_unused_pvcs(hdlc);
1112		return -EIO;
1113	}
1114
1115	dev->needs_free_netdev = true;
1116	*get_dev_p(pvc, type) = dev;
1117	if (!used) {
1118		state(hdlc)->dce_changed = 1;
1119		state(hdlc)->dce_pvc_count++;
1120	}
1121	return 0;
1122}
1123
 
 
1124static int fr_del_pvc(hdlc_device *hdlc, unsigned int dlci, int type)
1125{
1126	struct pvc_device *pvc;
1127	struct net_device *dev;
1128
1129	pvc = find_pvc(hdlc, dlci);
1130	if (!pvc)
1131		return -ENOENT;
1132
1133	dev = *get_dev_p(pvc, type);
1134	if (!dev)
1135		return -ENOENT;
1136
1137	if (dev->flags & IFF_UP)
1138		return -EBUSY;		/* PVC in use */
1139
1140	unregister_netdevice(dev); /* the destructor will free_netdev(dev) */
1141	*get_dev_p(pvc, type) = NULL;
1142
1143	if (!pvc_is_used(pvc)) {
1144		state(hdlc)->dce_pvc_count--;
1145		state(hdlc)->dce_changed = 1;
1146	}
1147	delete_unused_pvcs(hdlc);
1148	return 0;
1149}
1150
 
 
1151static void fr_destroy(struct net_device *frad)
1152{
1153	hdlc_device *hdlc = dev_to_hdlc(frad);
1154	struct pvc_device *pvc = state(hdlc)->first_pvc;
1155
1156	state(hdlc)->first_pvc = NULL; /* All PVCs destroyed */
1157	state(hdlc)->dce_pvc_count = 0;
1158	state(hdlc)->dce_changed = 1;
1159
1160	while (pvc) {
1161		struct pvc_device *next = pvc->next;
1162		/* destructors will free_netdev() main and ether */
1163		if (pvc->main)
1164			unregister_netdevice(pvc->main);
1165
1166		if (pvc->ether)
1167			unregister_netdevice(pvc->ether);
1168
1169		kfree(pvc);
1170		pvc = next;
1171	}
1172}
1173
 
1174static struct hdlc_proto proto = {
1175	.close		= fr_close,
1176	.start		= fr_start,
1177	.stop		= fr_stop,
1178	.detach		= fr_destroy,
1179	.ioctl		= fr_ioctl,
1180	.netif_rx	= fr_rx,
1181	.module		= THIS_MODULE,
1182};
1183
1184static int fr_ioctl(struct net_device *dev, struct if_settings *ifs)
 
1185{
1186	fr_proto __user *fr_s = ifs->ifs_ifsu.fr;
1187	const size_t size = sizeof(fr_proto);
1188	fr_proto new_settings;
1189	hdlc_device *hdlc = dev_to_hdlc(dev);
1190	fr_proto_pvc pvc;
1191	int result;
1192
1193	switch (ifs->type) {
1194	case IF_GET_PROTO:
1195		if (dev_to_hdlc(dev)->proto != &proto) /* Different proto */
1196			return -EINVAL;
1197		ifs->type = IF_PROTO_FR;
1198		if (ifs->size < size) {
1199			ifs->size = size; /* data size wanted */
1200			return -ENOBUFS;
1201		}
1202		if (copy_to_user(fr_s, &state(hdlc)->settings, size))
1203			return -EFAULT;
1204		return 0;
1205
1206	case IF_PROTO_FR:
1207		if (!capable(CAP_NET_ADMIN))
1208			return -EPERM;
1209
1210		if (dev->flags & IFF_UP)
1211			return -EBUSY;
1212
1213		if (copy_from_user(&new_settings, fr_s, size))
1214			return -EFAULT;
1215
1216		if (new_settings.lmi == LMI_DEFAULT)
1217			new_settings.lmi = LMI_ANSI;
1218
1219		if ((new_settings.lmi != LMI_NONE &&
1220		     new_settings.lmi != LMI_ANSI &&
1221		     new_settings.lmi != LMI_CCITT &&
1222		     new_settings.lmi != LMI_CISCO) ||
1223		    new_settings.t391 < 1 ||
1224		    new_settings.t392 < 2 ||
1225		    new_settings.n391 < 1 ||
1226		    new_settings.n392 < 1 ||
1227		    new_settings.n393 < new_settings.n392 ||
1228		    new_settings.n393 > 32 ||
1229		    (new_settings.dce != 0 &&
1230		     new_settings.dce != 1))
1231			return -EINVAL;
1232
1233		result = hdlc->attach(dev, ENCODING_NRZ,
1234				      PARITY_CRC16_PR1_CCITT);
1235		if (result)
1236			return result;
1237
1238		if (dev_to_hdlc(dev)->proto != &proto) { /* Different proto */
1239			result = attach_hdlc_protocol(dev, &proto,
1240						      sizeof(struct frad_state));
1241			if (result)
1242				return result;
1243			state(hdlc)->first_pvc = NULL;
1244			state(hdlc)->dce_pvc_count = 0;
1245		}
1246		memcpy(&state(hdlc)->settings, &new_settings, size);
1247		dev->type = ARPHRD_FRAD;
1248		call_netdevice_notifiers(NETDEV_POST_TYPE_CHANGE, dev);
1249		return 0;
1250
1251	case IF_PROTO_FR_ADD_PVC:
1252	case IF_PROTO_FR_DEL_PVC:
1253	case IF_PROTO_FR_ADD_ETH_PVC:
1254	case IF_PROTO_FR_DEL_ETH_PVC:
1255		if (dev_to_hdlc(dev)->proto != &proto) /* Different proto */
1256			return -EINVAL;
1257
1258		if (!capable(CAP_NET_ADMIN))
1259			return -EPERM;
1260
1261		if (copy_from_user(&pvc, ifs->ifs_ifsu.fr_pvc,
1262				   sizeof(fr_proto_pvc)))
1263			return -EFAULT;
1264
1265		if (pvc.dlci <= 0 || pvc.dlci >= 1024)
1266			return -EINVAL;	/* Only 10 bits, DLCI 0 reserved */
1267
1268		if (ifs->type == IF_PROTO_FR_ADD_ETH_PVC ||
1269		    ifs->type == IF_PROTO_FR_DEL_ETH_PVC)
1270			result = ARPHRD_ETHER; /* bridged Ethernet device */
1271		else
1272			result = ARPHRD_DLCI;
1273
1274		if (ifs->type == IF_PROTO_FR_ADD_PVC ||
1275		    ifs->type == IF_PROTO_FR_ADD_ETH_PVC)
1276			return fr_add_pvc(dev, pvc.dlci, result);
1277		else
1278			return fr_del_pvc(hdlc, pvc.dlci, result);
1279	}
1280
1281	return -EINVAL;
1282}
1283
1284static int __init hdlc_fr_init(void)
 
1285{
1286	register_hdlc_protocol(&proto);
1287	return 0;
1288}
1289
1290static void __exit hdlc_fr_exit(void)
 
1291{
1292	unregister_hdlc_protocol(&proto);
1293}
1294
1295module_init(hdlc_fr_init);
1296module_exit(hdlc_fr_exit);
 
1297
1298MODULE_AUTHOR("Krzysztof Halasa <khc@pm.waw.pl>");
1299MODULE_DESCRIPTION("Frame-Relay protocol support for generic HDLC");
1300MODULE_LICENSE("GPL v2");