drivers/net/wan/hdlc_x25.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Generic HDLC support routines for Linux
   4  * X.25 support
   5  *
   6  * Copyright (C) 1999 - 2006 Krzysztof Halasa <khc@pm.waw.pl>
   7  */
   8
   9 #include <linux/errno.h>
  10 #include <linux/gfp.h>
  11 #include <linux/hdlc.h>
  12 #include <linux/if_arp.h>
  13 #include <linux/inetdevice.h>
  14 #include <linux/init.h>
  15 #include <linux/kernel.h>
  16 #include <linux/lapb.h>
  17 #include <linux/module.h>
  18 #include <linux/pkt_sched.h>
  19 #include <linux/poll.h>
  20 #include <linux/rtnetlink.h>
  21 #include <linux/skbuff.h>
  22 #include <net/x25device.h>
  23
  24 static int x25_ioctl(struct net_device *dev, struct ifreq *ifr);
  25
  26 /* These functions are callbacks called by LAPB layer */
  27
  28 static void x25_connect_disconnect(struct net_device *dev, int reason, int code)
  29 {
  30         struct sk_buff *skb;
  31         unsigned char *ptr;
  32
  33         if ((skb = dev_alloc_skb(1)) == NULL) {
  34                 netdev_err(dev, "out of memory\n");
  35                 return;
  36         }
  37
  38         ptr = skb_put(skb, 1);
  39         *ptr = code;
  40
  41         skb->protocol = x25_type_trans(skb, dev);
  42         netif_rx(skb);
  43 }
  44
  45
  46
  47 static void x25_connected(struct net_device *dev, int reason)
  48 {
  49         x25_connect_disconnect(dev, reason, X25_IFACE_CONNECT);
  50 }
  51
  52
  53
  54 static void x25_disconnected(struct net_device *dev, int reason)
  55 {
  56         x25_connect_disconnect(dev, reason, X25_IFACE_DISCONNECT);
  57 }
  58
  59
  60
  61 static int x25_data_indication(struct net_device *dev, struct sk_buff *skb)
  62 {
  63         unsigned char *ptr;
  64
  65         skb_push(skb, 1);
  66
  67         if (skb_cow(skb, 1))
  68                 return NET_RX_DROP;
  69
  70         ptr  = skb->data;
  71         *ptr = X25_IFACE_DATA;
  72
  73         skb->protocol = x25_type_trans(skb, dev);
  74         return netif_rx(skb);
  75 }
  76
  77
  78
  79 static void x25_data_transmit(struct net_device *dev, struct sk_buff *skb)
  80 {
  81         hdlc_device *hdlc = dev_to_hdlc(dev);
  82         hdlc->xmit(skb, dev); /* Ignore return value :-( */
  83 }
  84
  85
  86
  87 static netdev_tx_t x25_xmit(struct sk_buff *skb, struct net_device *dev)
  88 {
  89         int result;
  90
  91
  92         /* X.25 to LAPB */
  93         switch (skb->data[0]) {
  94         case X25_IFACE_DATA:    /* Data to be transmitted */
  95                 skb_pull(skb, 1);
  96                 if ((result = lapb_data_request(dev, skb)) != LAPB_OK)
  97                         dev_kfree_skb(skb);
  98                 return NETDEV_TX_OK;
  99
 100         case X25_IFACE_CONNECT:
 101                 if ((result = lapb_connect_request(dev))!= LAPB_OK) {
 102                         if (result == LAPB_CONNECTED)
 103                                 /* Send connect confirm. msg to level 3 */
 104                                 x25_connected(dev, 0);
 105                         else
 106                                 netdev_err(dev, "LAPB connect request failed, error code = %i\n",
 107                                            result);
 108                 }
 109                 break;
 110
 111         case X25_IFACE_DISCONNECT:
 112                 if ((result = lapb_disconnect_request(dev)) != LAPB_OK) {
 113                         if (result == LAPB_NOTCONNECTED)
 114                                 /* Send disconnect confirm. msg to level 3 */
 115                                 x25_disconnected(dev, 0);
 116                         else
 117                                 netdev_err(dev, "LAPB disconnect request failed, error code = %i\n",
 118                                            result);
 119                 }
 120                 break;
 121
 122         default:                /* to be defined */
 123                 break;
 124         }
 125
 126         dev_kfree_skb(skb);
 127         return NETDEV_TX_OK;
 128 }
 129
 130
 131
 132 static int x25_open(struct net_device *dev)
 133 {
 134         int result;
 135         static const struct lapb_register_struct cb = {
 136                 .connect_confirmation = x25_connected,
 137                 .connect_indication = x25_connected,
 138                 .disconnect_confirmation = x25_disconnected,
 139                 .disconnect_indication = x25_disconnected,
 140                 .data_indication = x25_data_indication,
 141                 .data_transmit = x25_data_transmit,
 142         };
 143
 144         result = lapb_register(dev, &cb);
 145         if (result != LAPB_OK)
 146                 return result;
 147         return 0;
 148 }
 149
 150
 151
 152 static void x25_close(struct net_device *dev)
 153 {
 154         lapb_unregister(dev);
 155 }
 156
 157
 158
 159 static int x25_rx(struct sk_buff *skb)
 160 {
 161         struct net_device *dev = skb->dev;
 162
 163         if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL) {
 164                 dev->stats.rx_dropped++;
 165                 return NET_RX_DROP;
 166         }
 167
 168         if (lapb_data_received(dev, skb) == LAPB_OK)
 169                 return NET_RX_SUCCESS;
 170
 171         dev->stats.rx_errors++;
 172         dev_kfree_skb_any(skb);
 173         return NET_RX_DROP;
 174 }
 175
 176
 177 static struct hdlc_proto proto = {
 178         .open           = x25_open,
 179         .close          = x25_close,
 180         .ioctl          = x25_ioctl,
 181         .netif_rx       = x25_rx,
 182         .xmit           = x25_xmit,
 183         .module         = THIS_MODULE,
 184 };
 185
 186
 187 static int x25_ioctl(struct net_device *dev, struct ifreq *ifr)
 188 {
 189         hdlc_device *hdlc = dev_to_hdlc(dev);
 190         int result;
 191
 192         switch (ifr->ifr_settings.type) {
 193         case IF_GET_PROTO:
 194                 if (dev_to_hdlc(dev)->proto != &proto)
 195                         return -EINVAL;
 196                 ifr->ifr_settings.type = IF_PROTO_X25;
 197                 return 0; /* return protocol only, no settable parameters */
 198
 199         case IF_PROTO_X25:
 200                 if (!capable(CAP_NET_ADMIN))
 201                         return -EPERM;
 202
 203                 if (dev->flags & IFF_UP)
 204                         return -EBUSY;
 205
 206                 result=hdlc->attach(dev, ENCODING_NRZ,PARITY_CRC16_PR1_CCITT);
 207                 if (result)
 208                         return result;
 209
 210                 if ((result = attach_hdlc_protocol(dev, &proto, 0)))
 211                         return result;
 212                 dev->type = ARPHRD_X25;
 213                 call_netdevice_notifiers(NETDEV_POST_TYPE_CHANGE, dev);
 214                 netif_dormant_off(dev);
 215                 return 0;
 216         }
 217
 218         return -EINVAL;
 219 }
 220
 221
 222 static int __init mod_init(void)
 223 {
 224         register_hdlc_protocol(&proto);
 225         return 0;
 226 }
 227
 228
 229
 230 static void __exit mod_exit(void)
 231 {
 232         unregister_hdlc_protocol(&proto);
 233 }
 234
 235
 236 module_init(mod_init);
 237 module_exit(mod_exit);
 238
 239 MODULE_AUTHOR("Krzysztof Halasa <khc@pm.waw.pl>");
 240 MODULE_DESCRIPTION("X.25 protocol support for generic HDLC");
 241 MODULE_LICENSE("GPL v2");