xref: /openbmc/linux/net/x25/x25_dev.c (revision d5cb9783536a41df9f9cba5b0a1d78047ed787f7)
1 /*
2  *	X.25 Packet Layer release 002
3  *
4  *	This is ALPHA test software. This code may break your machine, randomly fail to work with new
5  *	releases, misbehave and/or generally screw up. It might even work.
6  *
7  *	This code REQUIRES 2.1.15 or higher
8  *
9  *	This module:
10  *		This module is free software; you can redistribute it and/or
11  *		modify it under the terms of the GNU General Public License
12  *		as published by the Free Software Foundation; either version
13  *		2 of the License, or (at your option) any later version.
14  *
15  *	History
16  *	X.25 001	Jonathan Naylor	Started coding.
17  *      2000-09-04	Henner Eisen	Prevent freeing a dangling skb.
18  */
19 
20 #include <linux/config.h>
21 #include <linux/kernel.h>
22 #include <linux/netdevice.h>
23 #include <linux/skbuff.h>
24 #include <net/sock.h>
25 #include <linux/if_arp.h>
26 #include <net/x25.h>
27 
28 static int x25_receive_data(struct sk_buff *skb, struct x25_neigh *nb)
29 {
30 	struct sock *sk;
31 	unsigned short frametype;
32 	unsigned int lci;
33 
34 	frametype = skb->data[2];
35         lci = ((skb->data[0] << 8) & 0xF00) + ((skb->data[1] << 0) & 0x0FF);
36 
37 	/*
38 	 *	LCI of zero is always for us, and its always a link control
39 	 *	frame.
40 	 */
41 	if (lci == 0) {
42 		x25_link_control(skb, nb, frametype);
43 		return 0;
44 	}
45 
46 	/*
47 	 *	Find an existing socket.
48 	 */
49 	if ((sk = x25_find_socket(lci, nb)) != NULL) {
50 		int queued = 1;
51 
52 		skb->h.raw = skb->data;
53 		bh_lock_sock(sk);
54 		if (!sock_owned_by_user(sk)) {
55 			queued = x25_process_rx_frame(sk, skb);
56 		} else {
57 			sk_add_backlog(sk, skb);
58 		}
59 		bh_unlock_sock(sk);
60 		return queued;
61 	}
62 
63 	/*
64 	 *	Is is a Call Request ? if so process it.
65 	 */
66 	if (frametype == X25_CALL_REQUEST)
67 		return x25_rx_call_request(skb, nb, lci);
68 
69 	/*
70 	 *	Its not a Call Request, nor is it a control frame.
71 	 *      Let caller throw it away.
72 	 */
73 /*
74 	x25_transmit_clear_request(nb, lci, 0x0D);
75 */
76 
77 	if (frametype != X25_CLEAR_CONFIRMATION)
78 		printk(KERN_DEBUG "x25_receive_data(): unknown frame type %2x\n",frametype);
79 
80 	return 0;
81 }
82 
83 int x25_lapb_receive_frame(struct sk_buff *skb, struct net_device *dev,
84 			   struct packet_type *ptype, struct net_device *orig_dev)
85 {
86 	struct sk_buff *nskb;
87 	struct x25_neigh *nb;
88 
89 	nskb = skb_copy(skb, GFP_ATOMIC);
90 	if (!nskb)
91 		goto drop;
92 	kfree_skb(skb);
93 	skb = nskb;
94 
95 	/*
96 	 * Packet received from unrecognised device, throw it away.
97 	 */
98 	nb = x25_get_neigh(dev);
99 	if (!nb) {
100 		printk(KERN_DEBUG "X.25: unknown neighbour - %s\n", dev->name);
101 		goto drop;
102 	}
103 
104 	switch (skb->data[0]) {
105 		case 0x00:
106 			skb_pull(skb, 1);
107 			if (x25_receive_data(skb, nb)) {
108 				x25_neigh_put(nb);
109 				goto out;
110 			}
111 			break;
112 		case 0x01:
113 			x25_link_established(nb);
114 			break;
115 		case 0x02:
116 			x25_link_terminated(nb);
117 			break;
118 	}
119 	x25_neigh_put(nb);
120 drop:
121 	kfree_skb(skb);
122 out:
123 	return 0;
124 }
125 
126 void x25_establish_link(struct x25_neigh *nb)
127 {
128 	struct sk_buff *skb;
129 	unsigned char *ptr;
130 
131 	switch (nb->dev->type) {
132 		case ARPHRD_X25:
133 			if ((skb = alloc_skb(1, GFP_ATOMIC)) == NULL) {
134 				printk(KERN_ERR "x25_dev: out of memory\n");
135 				return;
136 			}
137 			ptr  = skb_put(skb, 1);
138 			*ptr = 0x01;
139 			break;
140 
141 #if defined(CONFIG_LLC) || defined(CONFIG_LLC_MODULE)
142 		case ARPHRD_ETHER:
143 			return;
144 #endif
145 		default:
146 			return;
147 	}
148 
149 	skb->protocol = htons(ETH_P_X25);
150 	skb->dev      = nb->dev;
151 
152 	dev_queue_xmit(skb);
153 }
154 
155 void x25_terminate_link(struct x25_neigh *nb)
156 {
157 	struct sk_buff *skb;
158 	unsigned char *ptr;
159 
160 #if defined(CONFIG_LLC) || defined(CONFIG_LLC_MODULE)
161 	if (nb->dev->type == ARPHRD_ETHER)
162 		return;
163 #endif
164 	if (nb->dev->type != ARPHRD_X25)
165 		return;
166 
167 	skb = alloc_skb(1, GFP_ATOMIC);
168 	if (!skb) {
169 		printk(KERN_ERR "x25_dev: out of memory\n");
170 		return;
171 	}
172 
173 	ptr  = skb_put(skb, 1);
174 	*ptr = 0x02;
175 
176 	skb->protocol = htons(ETH_P_X25);
177 	skb->dev      = nb->dev;
178 	dev_queue_xmit(skb);
179 }
180 
181 void x25_send_frame(struct sk_buff *skb, struct x25_neigh *nb)
182 {
183 	unsigned char *dptr;
184 
185 	skb->nh.raw = skb->data;
186 
187 	switch (nb->dev->type) {
188 		case ARPHRD_X25:
189 			dptr  = skb_push(skb, 1);
190 			*dptr = 0x00;
191 			break;
192 
193 #if defined(CONFIG_LLC) || defined(CONFIG_LLC_MODULE)
194 		case ARPHRD_ETHER:
195 			kfree_skb(skb);
196 			return;
197 #endif
198 		default:
199 			kfree_skb(skb);
200 			return;
201 	}
202 
203 	skb->protocol = htons(ETH_P_X25);
204 	skb->dev      = nb->dev;
205 
206 	dev_queue_xmit(skb);
207 }
208