net/x25/x25_dev.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  X.25 Packet Layer release 002
0004  *
0005  *  This is ALPHA test software. This code may break your machine, randomly fail to work with new
0006  *  releases, misbehave and/or generally screw up. It might even work.
0007  *
0008  *  This code REQUIRES 2.1.15 or higher
0009  *
0010  *  History
0011  *  X.25 001    Jonathan Naylor Started coding.
0012  *      2000-09-04  Henner Eisen    Prevent freeing a dangling skb.
0013  */
0014
0015 #define pr_fmt(fmt) "X25: " fmt
0016
0017 #include <linux/kernel.h>
0018 #include <linux/netdevice.h>
0019 #include <linux/skbuff.h>
0020 #include <linux/slab.h>
0021 #include <net/sock.h>
0022 #include <linux/if_arp.h>
0023 #include <net/x25.h>
0024 #include <net/x25device.h>
0025
0026 static int x25_receive_data(struct sk_buff *skb, struct x25_neigh *nb)
0027 {
0028     struct sock *sk;
0029     unsigned short frametype;
0030     unsigned int lci;
0031
0032     if (!pskb_may_pull(skb, X25_STD_MIN_LEN))
0033         return 0;
0034
0035     frametype = skb->data[2];
0036     lci = ((skb->data[0] << 8) & 0xF00) + ((skb->data[1] << 0) & 0x0FF);
0037
0038     /*
0039      *  LCI of zero is always for us, and its always a link control
0040      *  frame.
0041      */
0042     if (lci == 0) {
0043         x25_link_control(skb, nb, frametype);
0044         return 0;
0045     }
0046
0047     /*
0048      *  Find an existing socket.
0049      */
0050     if ((sk = x25_find_socket(lci, nb)) != NULL) {
0051         int queued = 1;
0052
0053         skb_reset_transport_header(skb);
0054         bh_lock_sock(sk);
0055         if (!sock_owned_by_user(sk)) {
0056             queued = x25_process_rx_frame(sk, skb);
0057         } else {
0058             queued = !sk_add_backlog(sk, skb, READ_ONCE(sk->sk_rcvbuf));
0059         }
0060         bh_unlock_sock(sk);
0061         sock_put(sk);
0062         return queued;
0063     }
0064
0065     /*
0066      *  Is is a Call Request ? if so process it.
0067      */
0068     if (frametype == X25_CALL_REQUEST)
0069         return x25_rx_call_request(skb, nb, lci);
0070
0071     /*
0072      *  Its not a Call Request, nor is it a control frame.
0073      *  Can we forward it?
0074      */
0075
0076     if (x25_forward_data(lci, nb, skb)) {
0077         if (frametype == X25_CLEAR_CONFIRMATION) {
0078             x25_clear_forward_by_lci(lci);
0079         }
0080         kfree_skb(skb);
0081         return 1;
0082     }
0083
0084 /*
0085     x25_transmit_clear_request(nb, lci, 0x0D);
0086 */
0087
0088     if (frametype != X25_CLEAR_CONFIRMATION)
0089         pr_debug("x25_receive_data(): unknown frame type %2x\n",frametype);
0090
0091     return 0;
0092 }
0093
0094 int x25_lapb_receive_frame(struct sk_buff *skb, struct net_device *dev,
0095                struct packet_type *ptype, struct net_device *orig_dev)
0096 {
0097     struct sk_buff *nskb;
0098     struct x25_neigh *nb;
0099
0100     if (!net_eq(dev_net(dev), &init_net))
0101         goto drop;
0102
0103     nskb = skb_copy(skb, GFP_ATOMIC);
0104     if (!nskb)
0105         goto drop;
0106     kfree_skb(skb);
0107     skb = nskb;
0108
0109     /*
0110      * Packet received from unrecognised device, throw it away.
0111      */
0112     nb = x25_get_neigh(dev);
0113     if (!nb) {
0114         pr_debug("unknown neighbour - %s\n", dev->name);
0115         goto drop;
0116     }
0117
0118     if (!pskb_may_pull(skb, 1)) {
0119         x25_neigh_put(nb);
0120         return 0;
0121     }
0122
0123     switch (skb->data[0]) {
0124
0125     case X25_IFACE_DATA:
0126         skb_pull(skb, 1);
0127         if (x25_receive_data(skb, nb)) {
0128             x25_neigh_put(nb);
0129             goto out;
0130         }
0131         break;
0132
0133     case X25_IFACE_CONNECT:
0134         x25_link_established(nb);
0135         break;
0136
0137     case X25_IFACE_DISCONNECT:
0138         x25_link_terminated(nb);
0139         break;
0140     }
0141     x25_neigh_put(nb);
0142 drop:
0143     kfree_skb(skb);
0144 out:
0145     return 0;
0146 }
0147
0148 void x25_establish_link(struct x25_neigh *nb)
0149 {
0150     struct sk_buff *skb;
0151     unsigned char *ptr;
0152
0153     switch (nb->dev->type) {
0154     case ARPHRD_X25:
0155         if ((skb = alloc_skb(1, GFP_ATOMIC)) == NULL) {
0156             pr_err("x25_dev: out of memory\n");
0157             return;
0158         }
0159         ptr  = skb_put(skb, 1);
0160         *ptr = X25_IFACE_CONNECT;
0161         break;
0162
0163     default:
0164         return;
0165     }
0166
0167     skb->protocol = htons(ETH_P_X25);
0168     skb->dev      = nb->dev;
0169
0170     dev_queue_xmit(skb);
0171 }
0172
0173 void x25_terminate_link(struct x25_neigh *nb)
0174 {
0175     struct sk_buff *skb;
0176     unsigned char *ptr;
0177
0178     if (nb->dev->type != ARPHRD_X25)
0179         return;
0180
0181     skb = alloc_skb(1, GFP_ATOMIC);
0182     if (!skb) {
0183         pr_err("x25_dev: out of memory\n");
0184         return;
0185     }
0186
0187     ptr  = skb_put(skb, 1);
0188     *ptr = X25_IFACE_DISCONNECT;
0189
0190     skb->protocol = htons(ETH_P_X25);
0191     skb->dev      = nb->dev;
0192     dev_queue_xmit(skb);
0193 }
0194
0195 void x25_send_frame(struct sk_buff *skb, struct x25_neigh *nb)
0196 {
0197     unsigned char *dptr;
0198
0199     skb_reset_network_header(skb);
0200
0201     switch (nb->dev->type) {
0202     case ARPHRD_X25:
0203         dptr  = skb_push(skb, 1);
0204         *dptr = X25_IFACE_DATA;
0205         break;
0206
0207     default:
0208         kfree_skb(skb);
0209         return;
0210     }
0211
0212     skb->protocol = htons(ETH_P_X25);
0213     skb->dev      = nb->dev;
0214
0215     dev_queue_xmit(skb);
0216 }