1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
8 */
9#include <linux/errno.h>
10#include <linux/types.h>
11#include <linux/socket.h>
12#include <linux/in.h>
13#include <linux/kernel.h>
14#include <linux/module.h>
15#include <linux/timer.h>
16#include <linux/string.h>
17#include <linux/sockios.h>
18#include <linux/net.h>
19#include <linux/slab.h>
20#include <net/ax25.h>
21#include <linux/inet.h>
22#include <linux/netdevice.h>
23#include <linux/if_arp.h>
24#include <linux/skbuff.h>
25#include <net/sock.h>
26#include <asm/uaccess.h>
27#include <linux/fcntl.h>
28#include <linux/termios.h>	/* For TIOCINQ/OUTQ */
29#include <linux/mm.h>
30#include <linux/interrupt.h>
31#include <linux/notifier.h>
32#include <linux/proc_fs.h>
33#include <linux/stat.h>
34#include <linux/netfilter.h>
35#include <linux/sysctl.h>
36#include <net/ip.h>
37#include <net/arp.h>
38
39/*
40 *	IP over AX.25 encapsulation.
41 */
42
43/*
44 *	Shove an AX.25 UI header on an IP packet and handle ARP
45 */
46
47#ifdef CONFIG_INET
48
49static int ax25_hard_header(struct sk_buff *skb, struct net_device *dev,
50			    unsigned short type, const void *daddr,
51			    const void *saddr, unsigned int len)
52{
53	unsigned char *buff;
54
55	/* they sometimes come back to us... */
56	if (type == ETH_P_AX25)
57		return 0;
58
59	/* header is an AX.25 UI frame from us to them */
60	buff = skb_push(skb, AX25_HEADER_LEN);
61	*buff++ = 0x00;	/* KISS DATA */
62
63	if (daddr != NULL)
64		memcpy(buff, daddr, dev->addr_len);	/* Address specified */
65
66	buff[6] &= ~AX25_CBIT;
67	buff[6] &= ~AX25_EBIT;
68	buff[6] |= AX25_SSSID_SPARE;
69	buff    += AX25_ADDR_LEN;
70
71	if (saddr != NULL)
72		memcpy(buff, saddr, dev->addr_len);
73	else
74		memcpy(buff, dev->dev_addr, dev->addr_len);
75
76	buff[6] &= ~AX25_CBIT;
77	buff[6] |= AX25_EBIT;
78	buff[6] |= AX25_SSSID_SPARE;
79	buff    += AX25_ADDR_LEN;
80
81	*buff++  = AX25_UI;	/* UI */
82
83	/* Append a suitable AX.25 PID */
84	switch (type) {
85	case ETH_P_IP:
86		*buff++ = AX25_P_IP;
87		break;
88	case ETH_P_ARP:
89		*buff++ = AX25_P_ARP;
90		break;
91	default:
92		printk(KERN_ERR "AX.25: ax25_hard_header - wrong protocol type 0x%2.2x\n", type);
93		*buff++ = 0;
94		break;
95	}
96
97	if (daddr != NULL)
98		return AX25_HEADER_LEN;
99
100	return -AX25_HEADER_LEN;	/* Unfinished header */
101}
102
103netdev_tx_t ax25_ip_xmit(struct sk_buff *skb)
104{
105	struct sk_buff *ourskb;
106	unsigned char *bp  = skb->data;
107	ax25_route *route;
108	struct net_device *dev = NULL;
109	ax25_address *src, *dst;
110	ax25_digi *digipeat = NULL;
111	ax25_dev *ax25_dev;
112	ax25_cb *ax25;
113	char ip_mode = ' ';
114
115	dst = (ax25_address *)(bp + 1);
116	src = (ax25_address *)(bp + 8);
117
118	route = ax25_get_route(dst, NULL);
119	if (route) {
120		digipeat = route->digipeat;
121		dev = route->dev;
122		ip_mode = route->ip_mode;
123	}
124
125	if (dev == NULL)
126		dev = skb->dev;
127
128	if ((ax25_dev = ax25_dev_ax25dev(dev)) == NULL) {
129		kfree_skb(skb);
130		goto put;
131	}
132
133	if (bp[16] == AX25_P_IP) {
134		if (ip_mode == 'V' || (ip_mode == ' ' && ax25_dev->values[AX25_VALUES_IPDEFMODE])) {
135			/*
136			 *	We copy the buffer and release the original thereby
137			 *	keeping it straight
138			 *
139			 *	Note: we report 1 back so the caller will
140			 *	not feed the frame direct to the physical device
141			 *	We don't want that to happen. (It won't be upset
142			 *	as we have pulled the frame from the queue by
143			 *	freeing it).
144			 *
145			 *	NB: TCP modifies buffers that are still
146			 *	on a device queue, thus we use skb_copy()
147			 *      instead of using skb_clone() unless this
148			 *	gets fixed.
149			 */
150
151			ax25_address src_c;
152			ax25_address dst_c;
153
154			if ((ourskb = skb_copy(skb, GFP_ATOMIC)) == NULL) {
155				kfree_skb(skb);
156				goto put;
157			}
158
159			if (skb->sk != NULL)
160				skb_set_owner_w(ourskb, skb->sk);
161
162			kfree_skb(skb);
163			/* dl9sau: bugfix
164			 * after kfree_skb(), dst and src which were pointer
165			 * to bp which is part of skb->data would not be valid
166			 * anymore hope that after skb_pull(ourskb, ..) our
167			 * dsc_c and src_c will not become invalid
168			 */
169			bp  = ourskb->data;
170			dst_c = *(ax25_address *)(bp + 1);
171			src_c = *(ax25_address *)(bp + 8);
172
173			skb_pull(ourskb, AX25_HEADER_LEN - 1);	/* Keep PID */
174			skb_reset_network_header(ourskb);
175
176			ax25=ax25_send_frame(
177			    ourskb,
178			    ax25_dev->values[AX25_VALUES_PACLEN],
179			    &src_c,
180			    &dst_c, digipeat, dev);
181			if (ax25) {
182				ax25_cb_put(ax25);
183			}
184			goto put;
185		}
186	}
187
188	bp[7]  &= ~AX25_CBIT;
189	bp[7]  &= ~AX25_EBIT;
190	bp[7]  |= AX25_SSSID_SPARE;
191
192	bp[14] &= ~AX25_CBIT;
193	bp[14] |= AX25_EBIT;
194	bp[14] |= AX25_SSSID_SPARE;
195
196	skb_pull(skb, AX25_KISS_HEADER_LEN);
197
198	if (digipeat != NULL) {
199		if ((ourskb = ax25_rt_build_path(skb, src, dst, route->digipeat)) == NULL) {
200			kfree_skb(skb);
201			goto put;
202		}
203
204		skb = ourskb;
205	}
206
207	ax25_queue_xmit(skb, dev);
208
209put:
210	if (route)
211		ax25_put_route(route);
212
213	return NETDEV_TX_OK;
214}
215
216#else	/* INET */
217
218static int ax25_hard_header(struct sk_buff *skb, struct net_device *dev,
219			    unsigned short type, const void *daddr,
220			    const void *saddr, unsigned int len)
221{
222	return -AX25_HEADER_LEN;
223}
224
225netdev_tx_t ax25_ip_xmit(struct sk_buff *skb)
226{
227	kfree_skb(skb);
228	return NETDEV_TX_OK;
229}
230#endif
231
232const struct header_ops ax25_header_ops = {
233	.create = ax25_hard_header,
234};
235
236EXPORT_SYMBOL(ax25_header_ops);
237EXPORT_SYMBOL(ax25_ip_xmit);
238
239