12874c5fdSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
21da177e4SLinus Torvalds /*
31da177e4SLinus Torvalds *
41da177e4SLinus Torvalds * Copyright (C) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
51da177e4SLinus Torvalds * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
61da177e4SLinus Torvalds * Copyright (C) Joerg Reuter DL1BKE (jreuter@yaina.de)
71da177e4SLinus Torvalds * Copyright (C) Hans-Joachim Hetscher DD8NE (dd8ne@bnv-bamberg.de)
81da177e4SLinus Torvalds */
91da177e4SLinus Torvalds #include <linux/errno.h>
101da177e4SLinus Torvalds #include <linux/types.h>
111da177e4SLinus Torvalds #include <linux/socket.h>
121da177e4SLinus Torvalds #include <linux/in.h>
131da177e4SLinus Torvalds #include <linux/kernel.h>
141da177e4SLinus Torvalds #include <linux/timer.h>
151da177e4SLinus Torvalds #include <linux/string.h>
161da177e4SLinus Torvalds #include <linux/sockios.h>
171da177e4SLinus Torvalds #include <linux/net.h>
185a0e3ad6STejun Heo #include <linux/slab.h>
191da177e4SLinus Torvalds #include <net/ax25.h>
201da177e4SLinus Torvalds #include <linux/inet.h>
211da177e4SLinus Torvalds #include <linux/netdevice.h>
221da177e4SLinus Torvalds #include <linux/skbuff.h>
231da177e4SLinus Torvalds #include <net/sock.h>
24c752f073SArnaldo Carvalho de Melo #include <net/tcp_states.h>
257c0f6ba6SLinus Torvalds #include <linux/uaccess.h>
261da177e4SLinus Torvalds #include <linux/fcntl.h>
271da177e4SLinus Torvalds #include <linux/mm.h>
281da177e4SLinus Torvalds #include <linux/interrupt.h>
291da177e4SLinus Torvalds
301da177e4SLinus Torvalds /*
311da177e4SLinus Torvalds * Given a fragment, queue it on the fragment queue and if the fragment
321da177e4SLinus Torvalds * is complete, send it back to ax25_rx_iframe.
331da177e4SLinus Torvalds */
ax25_rx_fragment(ax25_cb * ax25,struct sk_buff * skb)341da177e4SLinus Torvalds static int ax25_rx_fragment(ax25_cb *ax25, struct sk_buff *skb)
351da177e4SLinus Torvalds {
361da177e4SLinus Torvalds struct sk_buff *skbn, *skbo;
371da177e4SLinus Torvalds
381da177e4SLinus Torvalds if (ax25->fragno != 0) {
391da177e4SLinus Torvalds if (!(*skb->data & AX25_SEG_FIRST)) {
401da177e4SLinus Torvalds if ((ax25->fragno - 1) == (*skb->data & AX25_SEG_REM)) {
411da177e4SLinus Torvalds /* Enqueue fragment */
421da177e4SLinus Torvalds ax25->fragno = *skb->data & AX25_SEG_REM;
431da177e4SLinus Torvalds skb_pull(skb, 1); /* skip fragno */
441da177e4SLinus Torvalds ax25->fraglen += skb->len;
451da177e4SLinus Torvalds skb_queue_tail(&ax25->frag_queue, skb);
461da177e4SLinus Torvalds
471da177e4SLinus Torvalds /* Last fragment received ? */
481da177e4SLinus Torvalds if (ax25->fragno == 0) {
491da177e4SLinus Torvalds skbn = alloc_skb(AX25_MAX_HEADER_LEN +
501da177e4SLinus Torvalds ax25->fraglen,
511da177e4SLinus Torvalds GFP_ATOMIC);
521da177e4SLinus Torvalds if (!skbn) {
531da177e4SLinus Torvalds skb_queue_purge(&ax25->frag_queue);
541da177e4SLinus Torvalds return 1;
551da177e4SLinus Torvalds }
561da177e4SLinus Torvalds
571da177e4SLinus Torvalds skb_reserve(skbn, AX25_MAX_HEADER_LEN);
581da177e4SLinus Torvalds
591da177e4SLinus Torvalds skbn->dev = ax25->ax25_dev->dev;
60c1d2bbe1SArnaldo Carvalho de Melo skb_reset_network_header(skbn);
61badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skbn);
621da177e4SLinus Torvalds
631da177e4SLinus Torvalds /* Copy data from the fragments */
641da177e4SLinus Torvalds while ((skbo = skb_dequeue(&ax25->frag_queue)) != NULL) {
651a4e2d09SArnaldo Carvalho de Melo skb_copy_from_linear_data(skbo,
661a4e2d09SArnaldo Carvalho de Melo skb_put(skbn, skbo->len),
671a4e2d09SArnaldo Carvalho de Melo skbo->len);
681da177e4SLinus Torvalds kfree_skb(skbo);
691da177e4SLinus Torvalds }
701da177e4SLinus Torvalds
711da177e4SLinus Torvalds ax25->fraglen = 0;
721da177e4SLinus Torvalds
731da177e4SLinus Torvalds if (ax25_rx_iframe(ax25, skbn) == 0)
741da177e4SLinus Torvalds kfree_skb(skbn);
751da177e4SLinus Torvalds }
761da177e4SLinus Torvalds
771da177e4SLinus Torvalds return 1;
781da177e4SLinus Torvalds }
791da177e4SLinus Torvalds }
801da177e4SLinus Torvalds } else {
811da177e4SLinus Torvalds /* First fragment received */
821da177e4SLinus Torvalds if (*skb->data & AX25_SEG_FIRST) {
831da177e4SLinus Torvalds skb_queue_purge(&ax25->frag_queue);
841da177e4SLinus Torvalds ax25->fragno = *skb->data & AX25_SEG_REM;
851da177e4SLinus Torvalds skb_pull(skb, 1); /* skip fragno */
861da177e4SLinus Torvalds ax25->fraglen = skb->len;
871da177e4SLinus Torvalds skb_queue_tail(&ax25->frag_queue, skb);
881da177e4SLinus Torvalds return 1;
891da177e4SLinus Torvalds }
901da177e4SLinus Torvalds }
911da177e4SLinus Torvalds
921da177e4SLinus Torvalds return 0;
931da177e4SLinus Torvalds }
941da177e4SLinus Torvalds
951da177e4SLinus Torvalds /*
961da177e4SLinus Torvalds * This is where all valid I frames are sent to, to be dispatched to
971da177e4SLinus Torvalds * whichever protocol requires them.
981da177e4SLinus Torvalds */
ax25_rx_iframe(ax25_cb * ax25,struct sk_buff * skb)991da177e4SLinus Torvalds int ax25_rx_iframe(ax25_cb *ax25, struct sk_buff *skb)
1001da177e4SLinus Torvalds {
1011da177e4SLinus Torvalds int (*func)(struct sk_buff *, ax25_cb *);
1021da177e4SLinus Torvalds unsigned char pid;
103bde3445cSRalf Baechle int queued = 0;
1041da177e4SLinus Torvalds
1051da177e4SLinus Torvalds if (skb == NULL) return 0;
1061da177e4SLinus Torvalds
1071da177e4SLinus Torvalds ax25_start_idletimer(ax25);
1081da177e4SLinus Torvalds
1091da177e4SLinus Torvalds pid = *skb->data;
1101da177e4SLinus Torvalds
1111da177e4SLinus Torvalds if (pid == AX25_P_IP) {
1121da177e4SLinus Torvalds /* working around a TCP bug to keep additional listeners
1131da177e4SLinus Torvalds * happy. TCP re-uses the buffer and destroys the original
1141da177e4SLinus Torvalds * content.
1151da177e4SLinus Torvalds */
1161da177e4SLinus Torvalds struct sk_buff *skbn = skb_copy(skb, GFP_ATOMIC);
1171da177e4SLinus Torvalds if (skbn != NULL) {
1181da177e4SLinus Torvalds kfree_skb(skb);
1191da177e4SLinus Torvalds skb = skbn;
1201da177e4SLinus Torvalds }
1211da177e4SLinus Torvalds
1221da177e4SLinus Torvalds skb_pull(skb, 1); /* Remove PID */
123c6e6ca71SDavid S. Miller skb->mac_header = skb->network_header;
124c1d2bbe1SArnaldo Carvalho de Melo skb_reset_network_header(skb);
1251da177e4SLinus Torvalds skb->dev = ax25->ax25_dev->dev;
1261da177e4SLinus Torvalds skb->pkt_type = PACKET_HOST;
1271da177e4SLinus Torvalds skb->protocol = htons(ETH_P_IP);
12898a82febSRalf Baechle netif_rx(skb);
1291da177e4SLinus Torvalds return 1;
1301da177e4SLinus Torvalds }
1311da177e4SLinus Torvalds if (pid == AX25_P_SEGMENT) {
1321da177e4SLinus Torvalds skb_pull(skb, 1); /* Remove PID */
1331da177e4SLinus Torvalds return ax25_rx_fragment(ax25, skb);
1341da177e4SLinus Torvalds }
1351da177e4SLinus Torvalds
1361da177e4SLinus Torvalds if ((func = ax25_protocol_function(pid)) != NULL) {
1371da177e4SLinus Torvalds skb_pull(skb, 1); /* Remove PID */
1381da177e4SLinus Torvalds return (*func)(skb, ax25);
1391da177e4SLinus Torvalds }
1401da177e4SLinus Torvalds
1411da177e4SLinus Torvalds if (ax25->sk != NULL && ax25->ax25_dev->values[AX25_VALUES_CONMODE] == 2) {
1421da177e4SLinus Torvalds if ((!ax25->pidincl && ax25->sk->sk_protocol == pid) ||
1431da177e4SLinus Torvalds ax25->pidincl) {
1441da177e4SLinus Torvalds if (sock_queue_rcv_skb(ax25->sk, skb) == 0)
1451da177e4SLinus Torvalds queued = 1;
1461da177e4SLinus Torvalds else
1471da177e4SLinus Torvalds ax25->condition |= AX25_COND_OWN_RX_BUSY;
1481da177e4SLinus Torvalds }
1491da177e4SLinus Torvalds }
1501da177e4SLinus Torvalds
1511da177e4SLinus Torvalds return queued;
1521da177e4SLinus Torvalds }
1531da177e4SLinus Torvalds
1541da177e4SLinus Torvalds /*
1551da177e4SLinus Torvalds * Higher level upcall for a LAPB frame
1561da177e4SLinus Torvalds */
ax25_process_rx_frame(ax25_cb * ax25,struct sk_buff * skb,int type,int dama)1571da177e4SLinus Torvalds static int ax25_process_rx_frame(ax25_cb *ax25, struct sk_buff *skb, int type, int dama)
1581da177e4SLinus Torvalds {
1591da177e4SLinus Torvalds int queued = 0;
1601da177e4SLinus Torvalds
1611da177e4SLinus Torvalds if (ax25->state == AX25_STATE_0)
1621da177e4SLinus Torvalds return 0;
1631da177e4SLinus Torvalds
1641da177e4SLinus Torvalds switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1651da177e4SLinus Torvalds case AX25_PROTO_STD_SIMPLEX:
1661da177e4SLinus Torvalds case AX25_PROTO_STD_DUPLEX:
1671da177e4SLinus Torvalds queued = ax25_std_frame_in(ax25, skb, type);
1681da177e4SLinus Torvalds break;
1691da177e4SLinus Torvalds
1701da177e4SLinus Torvalds #ifdef CONFIG_AX25_DAMA_SLAVE
1711da177e4SLinus Torvalds case AX25_PROTO_DAMA_SLAVE:
1721da177e4SLinus Torvalds if (dama || ax25->ax25_dev->dama.slave)
1731da177e4SLinus Torvalds queued = ax25_ds_frame_in(ax25, skb, type);
1741da177e4SLinus Torvalds else
1751da177e4SLinus Torvalds queued = ax25_std_frame_in(ax25, skb, type);
1761da177e4SLinus Torvalds break;
1771da177e4SLinus Torvalds #endif
1781da177e4SLinus Torvalds }
1791da177e4SLinus Torvalds
1801da177e4SLinus Torvalds return queued;
1811da177e4SLinus Torvalds }
1821da177e4SLinus Torvalds
ax25_rcv(struct sk_buff * skb,struct net_device * dev,const ax25_address * dev_addr,struct packet_type * ptype)1831da177e4SLinus Torvalds static int ax25_rcv(struct sk_buff *skb, struct net_device *dev,
184*c045ad2cSJakub Kicinski const ax25_address *dev_addr, struct packet_type *ptype)
1851da177e4SLinus Torvalds {
1861da177e4SLinus Torvalds ax25_address src, dest, *next_digi = NULL;
1871da177e4SLinus Torvalds int type = 0, mine = 0, dama;
1881da177e4SLinus Torvalds struct sock *make, *sk;
1891da177e4SLinus Torvalds ax25_digi dp, reverse_dp;
1901da177e4SLinus Torvalds ax25_cb *ax25;
1911da177e4SLinus Torvalds ax25_dev *ax25_dev;
1921da177e4SLinus Torvalds
1931da177e4SLinus Torvalds /*
1941da177e4SLinus Torvalds * Process the AX.25/LAPB frame.
1951da177e4SLinus Torvalds */
1961da177e4SLinus Torvalds
197badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb);
1981da177e4SLinus Torvalds
1990eae1b98SIlpo Järvinen if ((ax25_dev = ax25_dev_ax25dev(dev)) == NULL)
2000eae1b98SIlpo Järvinen goto free;
2011da177e4SLinus Torvalds
2021da177e4SLinus Torvalds /*
2031da177e4SLinus Torvalds * Parse the address header.
2041da177e4SLinus Torvalds */
2051da177e4SLinus Torvalds
2060eae1b98SIlpo Järvinen if (ax25_addr_parse(skb->data, skb->len, &src, &dest, &dp, &type, &dama) == NULL)
2070eae1b98SIlpo Järvinen goto free;
2081da177e4SLinus Torvalds
2091da177e4SLinus Torvalds /*
2101da177e4SLinus Torvalds * Ours perhaps ?
2111da177e4SLinus Torvalds */
2121da177e4SLinus Torvalds if (dp.lastrepeat + 1 < dp.ndigi) /* Not yet digipeated completely */
2131da177e4SLinus Torvalds next_digi = &dp.calls[dp.lastrepeat + 1];
2141da177e4SLinus Torvalds
2151da177e4SLinus Torvalds /*
2161da177e4SLinus Torvalds * Pull of the AX.25 headers leaving the CTRL/PID bytes
2171da177e4SLinus Torvalds */
2181da177e4SLinus Torvalds skb_pull(skb, ax25_addr_size(&dp));
2191da177e4SLinus Torvalds
2201da177e4SLinus Torvalds /* For our port addresses ? */
2211da177e4SLinus Torvalds if (ax25cmp(&dest, dev_addr) == 0 && dp.lastrepeat + 1 == dp.ndigi)
2221da177e4SLinus Torvalds mine = 1;
2231da177e4SLinus Torvalds
2241da177e4SLinus Torvalds /* Also match on any registered callsign from L3/4 */
2251da177e4SLinus Torvalds if (!mine && ax25_listen_mine(&dest, dev) && dp.lastrepeat + 1 == dp.ndigi)
2261da177e4SLinus Torvalds mine = 1;
2271da177e4SLinus Torvalds
2281da177e4SLinus Torvalds /* UI frame - bypass LAPB processing */
2291da177e4SLinus Torvalds if ((*skb->data & ~0x10) == AX25_UI && dp.lastrepeat + 1 == dp.ndigi) {
230967b05f6SArnaldo Carvalho de Melo skb_set_transport_header(skb, 2); /* skip control and pid */
2311da177e4SLinus Torvalds
2321da177e4SLinus Torvalds ax25_send_to_raw(&dest, skb, skb->data[1]);
2331da177e4SLinus Torvalds
2340eae1b98SIlpo Järvinen if (!mine && ax25cmp(&dest, (ax25_address *)dev->broadcast) != 0)
2350eae1b98SIlpo Järvinen goto free;
2361da177e4SLinus Torvalds
2371da177e4SLinus Torvalds /* Now we are pointing at the pid byte */
2381da177e4SLinus Torvalds switch (skb->data[1]) {
2391da177e4SLinus Torvalds case AX25_P_IP:
2401da177e4SLinus Torvalds skb_pull(skb,2); /* drop PID/CTRL */
241badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb);
242c1d2bbe1SArnaldo Carvalho de Melo skb_reset_network_header(skb);
2431da177e4SLinus Torvalds skb->dev = dev;
2441da177e4SLinus Torvalds skb->pkt_type = PACKET_HOST;
2451da177e4SLinus Torvalds skb->protocol = htons(ETH_P_IP);
24698a82febSRalf Baechle netif_rx(skb);
2471da177e4SLinus Torvalds break;
2481da177e4SLinus Torvalds
2491da177e4SLinus Torvalds case AX25_P_ARP:
2501da177e4SLinus Torvalds skb_pull(skb,2);
251badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb);
252c1d2bbe1SArnaldo Carvalho de Melo skb_reset_network_header(skb);
2531da177e4SLinus Torvalds skb->dev = dev;
2541da177e4SLinus Torvalds skb->pkt_type = PACKET_HOST;
2551da177e4SLinus Torvalds skb->protocol = htons(ETH_P_ARP);
25698a82febSRalf Baechle netif_rx(skb);
2571da177e4SLinus Torvalds break;
2581da177e4SLinus Torvalds case AX25_P_TEXT:
2591da177e4SLinus Torvalds /* Now find a suitable dgram socket */
2601da177e4SLinus Torvalds sk = ax25_get_socket(&dest, &src, SOCK_DGRAM);
2611da177e4SLinus Torvalds if (sk != NULL) {
2621da177e4SLinus Torvalds bh_lock_sock(sk);
2631da177e4SLinus Torvalds if (atomic_read(&sk->sk_rmem_alloc) >=
2641da177e4SLinus Torvalds sk->sk_rcvbuf) {
2651da177e4SLinus Torvalds kfree_skb(skb);
2661da177e4SLinus Torvalds } else {
2671da177e4SLinus Torvalds /*
2681da177e4SLinus Torvalds * Remove the control and PID.
2691da177e4SLinus Torvalds */
2701da177e4SLinus Torvalds skb_pull(skb, 2);
2711da177e4SLinus Torvalds if (sock_queue_rcv_skb(sk, skb) != 0)
2721da177e4SLinus Torvalds kfree_skb(skb);
2731da177e4SLinus Torvalds }
2741da177e4SLinus Torvalds bh_unlock_sock(sk);
2751da177e4SLinus Torvalds sock_put(sk);
2761da177e4SLinus Torvalds } else {
2771da177e4SLinus Torvalds kfree_skb(skb);
2781da177e4SLinus Torvalds }
2791da177e4SLinus Torvalds break;
2801da177e4SLinus Torvalds
2811da177e4SLinus Torvalds default:
2821da177e4SLinus Torvalds kfree_skb(skb); /* Will scan SOCK_AX25 RAW sockets */
2831da177e4SLinus Torvalds break;
2841da177e4SLinus Torvalds }
2851da177e4SLinus Torvalds
2861da177e4SLinus Torvalds return 0;
2871da177e4SLinus Torvalds }
2881da177e4SLinus Torvalds
2891da177e4SLinus Torvalds /*
2901da177e4SLinus Torvalds * Is connected mode supported on this device ?
2911da177e4SLinus Torvalds * If not, should we DM the incoming frame (except DMs) or
2921da177e4SLinus Torvalds * silently ignore them. For now we stay quiet.
2931da177e4SLinus Torvalds */
2940eae1b98SIlpo Järvinen if (ax25_dev->values[AX25_VALUES_CONMODE] == 0)
2950eae1b98SIlpo Järvinen goto free;
2961da177e4SLinus Torvalds
2971da177e4SLinus Torvalds /* LAPB */
2981da177e4SLinus Torvalds
2991da177e4SLinus Torvalds /* AX.25 state 1-4 */
3001da177e4SLinus Torvalds
3011da177e4SLinus Torvalds ax25_digi_invert(&dp, &reverse_dp);
3021da177e4SLinus Torvalds
3031da177e4SLinus Torvalds if ((ax25 = ax25_find_cb(&dest, &src, &reverse_dp, dev)) != NULL) {
3041da177e4SLinus Torvalds /*
3051da177e4SLinus Torvalds * Process the frame. If it is queued up internally it
3061da177e4SLinus Torvalds * returns one otherwise we free it immediately. This
3071da177e4SLinus Torvalds * routine itself wakes the user context layers so we do
3081da177e4SLinus Torvalds * no further work
3091da177e4SLinus Torvalds */
3101da177e4SLinus Torvalds if (ax25_process_rx_frame(ax25, skb, type, dama) == 0)
3111da177e4SLinus Torvalds kfree_skb(skb);
3121da177e4SLinus Torvalds
3131da177e4SLinus Torvalds ax25_cb_put(ax25);
3141da177e4SLinus Torvalds return 0;
3151da177e4SLinus Torvalds }
3161da177e4SLinus Torvalds
3171da177e4SLinus Torvalds /* AX.25 state 0 (disconnected) */
3181da177e4SLinus Torvalds
3191da177e4SLinus Torvalds /* a) received not a SABM(E) */
3201da177e4SLinus Torvalds
3211da177e4SLinus Torvalds if ((*skb->data & ~AX25_PF) != AX25_SABM &&
3221da177e4SLinus Torvalds (*skb->data & ~AX25_PF) != AX25_SABME) {
3231da177e4SLinus Torvalds /*
3241da177e4SLinus Torvalds * Never reply to a DM. Also ignore any connects for
3251da177e4SLinus Torvalds * addresses that are not our interfaces and not a socket.
3261da177e4SLinus Torvalds */
3271da177e4SLinus Torvalds if ((*skb->data & ~AX25_PF) != AX25_DM && mine)
3281da177e4SLinus Torvalds ax25_return_dm(dev, &src, &dest, &dp);
3291da177e4SLinus Torvalds
3300eae1b98SIlpo Järvinen goto free;
3311da177e4SLinus Torvalds }
3321da177e4SLinus Torvalds
3331da177e4SLinus Torvalds /* b) received SABM(E) */
3341da177e4SLinus Torvalds
3351da177e4SLinus Torvalds if (dp.lastrepeat + 1 == dp.ndigi)
3361da177e4SLinus Torvalds sk = ax25_find_listener(&dest, 0, dev, SOCK_SEQPACKET);
3371da177e4SLinus Torvalds else
3381da177e4SLinus Torvalds sk = ax25_find_listener(next_digi, 1, dev, SOCK_SEQPACKET);
3391da177e4SLinus Torvalds
3401da177e4SLinus Torvalds if (sk != NULL) {
3411da177e4SLinus Torvalds bh_lock_sock(sk);
3421da177e4SLinus Torvalds if (sk_acceptq_is_full(sk) ||
3431da177e4SLinus Torvalds (make = ax25_make_new(sk, ax25_dev)) == NULL) {
3441da177e4SLinus Torvalds if (mine)
3451da177e4SLinus Torvalds ax25_return_dm(dev, &src, &dest, &dp);
3461da177e4SLinus Torvalds kfree_skb(skb);
3471da177e4SLinus Torvalds bh_unlock_sock(sk);
3481da177e4SLinus Torvalds sock_put(sk);
3491da177e4SLinus Torvalds
3501da177e4SLinus Torvalds return 0;
3511da177e4SLinus Torvalds }
3521da177e4SLinus Torvalds
3533200392bSDavid Miller ax25 = sk_to_ax25(make);
3541da177e4SLinus Torvalds skb_set_owner_r(skb, make);
3551da177e4SLinus Torvalds skb_queue_head(&sk->sk_receive_queue, skb);
3561da177e4SLinus Torvalds
3571da177e4SLinus Torvalds make->sk_state = TCP_ESTABLISHED;
3581da177e4SLinus Torvalds
3597976a11bSEric Dumazet sk_acceptq_added(sk);
3601da177e4SLinus Torvalds bh_unlock_sock(sk);
3611da177e4SLinus Torvalds } else {
3620eae1b98SIlpo Järvinen if (!mine)
3630eae1b98SIlpo Järvinen goto free;
3641da177e4SLinus Torvalds
3651da177e4SLinus Torvalds if ((ax25 = ax25_create_cb()) == NULL) {
3661da177e4SLinus Torvalds ax25_return_dm(dev, &src, &dest, &dp);
3670eae1b98SIlpo Järvinen goto free;
3681da177e4SLinus Torvalds }
3691da177e4SLinus Torvalds
3701da177e4SLinus Torvalds ax25_fillin_cb(ax25, ax25_dev);
3711da177e4SLinus Torvalds }
3721da177e4SLinus Torvalds
3731da177e4SLinus Torvalds ax25->source_addr = dest;
3741da177e4SLinus Torvalds ax25->dest_addr = src;
3751da177e4SLinus Torvalds
3761da177e4SLinus Torvalds /*
3771da177e4SLinus Torvalds * Sort out any digipeated paths.
3781da177e4SLinus Torvalds */
3791da177e4SLinus Torvalds if (dp.ndigi && !ax25->digipeat &&
3801da177e4SLinus Torvalds (ax25->digipeat = kmalloc(sizeof(ax25_digi), GFP_ATOMIC)) == NULL) {
3811da177e4SLinus Torvalds kfree_skb(skb);
3821da177e4SLinus Torvalds ax25_destroy_socket(ax25);
3831da177e4SLinus Torvalds if (sk)
3841da177e4SLinus Torvalds sock_put(sk);
3851da177e4SLinus Torvalds return 0;
3861da177e4SLinus Torvalds }
3871da177e4SLinus Torvalds
3881da177e4SLinus Torvalds if (dp.ndigi == 0) {
3891da177e4SLinus Torvalds kfree(ax25->digipeat);
3901da177e4SLinus Torvalds ax25->digipeat = NULL;
3911da177e4SLinus Torvalds } else {
3921da177e4SLinus Torvalds /* Reverse the source SABM's path */
3931da177e4SLinus Torvalds memcpy(ax25->digipeat, &reverse_dp, sizeof(ax25_digi));
3941da177e4SLinus Torvalds }
3951da177e4SLinus Torvalds
3961da177e4SLinus Torvalds if ((*skb->data & ~AX25_PF) == AX25_SABME) {
3971da177e4SLinus Torvalds ax25->modulus = AX25_EMODULUS;
3981da177e4SLinus Torvalds ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW];
3991da177e4SLinus Torvalds } else {
4001da177e4SLinus Torvalds ax25->modulus = AX25_MODULUS;
4011da177e4SLinus Torvalds ax25->window = ax25_dev->values[AX25_VALUES_WINDOW];
4021da177e4SLinus Torvalds }
4031da177e4SLinus Torvalds
4041da177e4SLinus Torvalds ax25_send_control(ax25, AX25_UA, AX25_POLLON, AX25_RESPONSE);
4051da177e4SLinus Torvalds
4061da177e4SLinus Torvalds #ifdef CONFIG_AX25_DAMA_SLAVE
4071da177e4SLinus Torvalds if (dama && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
4081da177e4SLinus Torvalds ax25_dama_on(ax25);
4091da177e4SLinus Torvalds #endif
4101da177e4SLinus Torvalds
4111da177e4SLinus Torvalds ax25->state = AX25_STATE_3;
4121da177e4SLinus Torvalds
4131da177e4SLinus Torvalds ax25_cb_add(ax25);
4141da177e4SLinus Torvalds
4151da177e4SLinus Torvalds ax25_start_heartbeat(ax25);
4161da177e4SLinus Torvalds ax25_start_t3timer(ax25);
4171da177e4SLinus Torvalds ax25_start_idletimer(ax25);
4181da177e4SLinus Torvalds
4191da177e4SLinus Torvalds if (sk) {
4201da177e4SLinus Torvalds if (!sock_flag(sk, SOCK_DEAD))
421676d2369SDavid S. Miller sk->sk_data_ready(sk);
4221da177e4SLinus Torvalds sock_put(sk);
4230eae1b98SIlpo Järvinen } else {
4240eae1b98SIlpo Järvinen free:
4251da177e4SLinus Torvalds kfree_skb(skb);
4260eae1b98SIlpo Järvinen }
4271da177e4SLinus Torvalds return 0;
4281da177e4SLinus Torvalds }
4291da177e4SLinus Torvalds
4301da177e4SLinus Torvalds /*
4311da177e4SLinus Torvalds * Receive an AX.25 frame via a SLIP interface.
4321da177e4SLinus Torvalds */
ax25_kiss_rcv(struct sk_buff * skb,struct net_device * dev,struct packet_type * ptype,struct net_device * orig_dev)4331da177e4SLinus Torvalds int ax25_kiss_rcv(struct sk_buff *skb, struct net_device *dev,
434f2ccd8faSDavid S. Miller struct packet_type *ptype, struct net_device *orig_dev)
4351da177e4SLinus Torvalds {
436d55d87fdSHerbert Xu skb_orphan(skb);
4371da177e4SLinus Torvalds
438721499e8SYOSHIFUJI Hideaki if (!net_eq(dev_net(dev), &init_net)) {
439e730c155SEric W. Biederman kfree_skb(skb);
440e730c155SEric W. Biederman return 0;
441e730c155SEric W. Biederman }
442e730c155SEric W. Biederman
4431da177e4SLinus Torvalds if ((*skb->data & 0x0F) != 0) {
4441da177e4SLinus Torvalds kfree_skb(skb); /* Not a KISS data frame */
4451da177e4SLinus Torvalds return 0;
4461da177e4SLinus Torvalds }
4471da177e4SLinus Torvalds
4481da177e4SLinus Torvalds skb_pull(skb, AX25_KISS_HEADER_LEN); /* Remove the KISS byte */
4491da177e4SLinus Torvalds
450*c045ad2cSJakub Kicinski return ax25_rcv(skb, dev, (const ax25_address *)dev->dev_addr, ptype);
4511da177e4SLinus Torvalds }
452