527 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * "LAPB via ethernet" driver release 0014 *5 * This code REQUIRES 2.1.15 or higher/ NET3.0386 *7 * This is a "pseudo" network driver to allow LAPB over Ethernet.8 *9 * This driver can use any ethernet destination address, and can be10 * limited to accept frames from one dedicated ethernet card only.11 *12 * History13 * LAPBETH 001 Jonathan Naylor Cloned from bpqether.c14 * 2000-10-29 Henner Eisen lapb_data_indication() return status.15 * 2000-11-14 Henner Eisen dev_hold/put, NETDEV_GOING_DOWN support16 */17 18#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt19 20#include <linux/errno.h>21#include <linux/types.h>22#include <linux/socket.h>23#include <linux/in.h>24#include <linux/slab.h>25#include <linux/kernel.h>26#include <linux/string.h>27#include <linux/net.h>28#include <linux/inet.h>29#include <linux/netdevice.h>30#include <linux/if_arp.h>31#include <linux/skbuff.h>32#include <net/sock.h>33#include <linux/uaccess.h>34#include <linux/mm.h>35#include <linux/interrupt.h>36#include <linux/notifier.h>37#include <linux/stat.h>38#include <linux/module.h>39#include <linux/lapb.h>40#include <linux/init.h>41 42#include <net/x25device.h>43 44static const u8 bcast_addr[6] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };45 46/* If this number is made larger, check that the temporary string buffer47 * in lapbeth_new_device is large enough to store the probe device name.48 */49#define MAXLAPBDEV 10050 51struct lapbethdev {52 struct list_head node;53 struct net_device *ethdev; /* link to ethernet device */54 struct net_device *axdev; /* lapbeth device (lapb#) */55 bool up;56 spinlock_t up_lock; /* Protects "up" */57 struct sk_buff_head rx_queue;58 struct napi_struct napi;59};60 61static LIST_HEAD(lapbeth_devices);62 63static void lapbeth_connected(struct net_device *dev, int reason);64static void lapbeth_disconnected(struct net_device *dev, int reason);65 66/* ------------------------------------------------------------------------ */67 68/* Get the LAPB device for the ethernet device69 */70static struct lapbethdev *lapbeth_get_x25_dev(struct net_device *dev)71{72 struct lapbethdev *lapbeth;73 74 list_for_each_entry_rcu(lapbeth, &lapbeth_devices, node, lockdep_rtnl_is_held()) {75 if (lapbeth->ethdev == dev)76 return lapbeth;77 }78 return NULL;79}80 81static __inline__ int dev_is_ethdev(struct net_device *dev)82{83 return dev->type == ARPHRD_ETHER && strncmp(dev->name, "dummy", 5);84}85 86/* ------------------------------------------------------------------------ */87 88static int lapbeth_napi_poll(struct napi_struct *napi, int budget)89{90 struct lapbethdev *lapbeth = container_of(napi, struct lapbethdev,91 napi);92 struct sk_buff *skb;93 int processed = 0;94 95 for (; processed < budget; ++processed) {96 skb = skb_dequeue(&lapbeth->rx_queue);97 if (!skb)98 break;99 netif_receive_skb_core(skb);100 }101 102 if (processed < budget)103 napi_complete(napi);104 105 return processed;106}107 108/* Receive a LAPB frame via an ethernet interface.109 */110static int lapbeth_rcv(struct sk_buff *skb, struct net_device *dev,111 struct packet_type *ptype, struct net_device *orig_dev)112{113 int len, err;114 struct lapbethdev *lapbeth;115 116 if (dev_net(dev) != &init_net)117 goto drop;118 119 skb = skb_share_check(skb, GFP_ATOMIC);120 if (!skb)121 return NET_RX_DROP;122 123 if (!pskb_may_pull(skb, 2))124 goto drop;125 126 rcu_read_lock();127 lapbeth = lapbeth_get_x25_dev(dev);128 if (!lapbeth)129 goto drop_unlock_rcu;130 spin_lock_bh(&lapbeth->up_lock);131 if (!lapbeth->up)132 goto drop_unlock;133 134 len = skb->data[0] + skb->data[1] * 256;135 dev->stats.rx_packets++;136 dev->stats.rx_bytes += len;137 138 skb_pull(skb, 2); /* Remove the length bytes */139 skb_trim(skb, len); /* Set the length of the data */140 141 err = lapb_data_received(lapbeth->axdev, skb);142 if (err != LAPB_OK) {143 printk(KERN_DEBUG "lapbether: lapb_data_received err - %d\n", err);144 goto drop_unlock;145 }146out:147 spin_unlock_bh(&lapbeth->up_lock);148 rcu_read_unlock();149 return 0;150drop_unlock:151 kfree_skb(skb);152 goto out;153drop_unlock_rcu:154 rcu_read_unlock();155drop:156 kfree_skb(skb);157 return 0;158}159 160static int lapbeth_data_indication(struct net_device *dev, struct sk_buff *skb)161{162 struct lapbethdev *lapbeth = netdev_priv(dev);163 unsigned char *ptr;164 165 if (skb_cow(skb, 1)) {166 kfree_skb(skb);167 return NET_RX_DROP;168 }169 170 skb_push(skb, 1);171 172 ptr = skb->data;173 *ptr = X25_IFACE_DATA;174 175 skb->protocol = x25_type_trans(skb, dev);176 177 skb_queue_tail(&lapbeth->rx_queue, skb);178 napi_schedule(&lapbeth->napi);179 return NET_RX_SUCCESS;180}181 182/* Send a LAPB frame via an ethernet interface183 */184static netdev_tx_t lapbeth_xmit(struct sk_buff *skb,185 struct net_device *dev)186{187 struct lapbethdev *lapbeth = netdev_priv(dev);188 int err;189 190 spin_lock_bh(&lapbeth->up_lock);191 if (!lapbeth->up)192 goto drop;193 194 /* There should be a pseudo header of 1 byte added by upper layers.195 * Check to make sure it is there before reading it.196 */197 if (skb->len < 1)198 goto drop;199 200 switch (skb->data[0]) {201 case X25_IFACE_DATA:202 break;203 case X25_IFACE_CONNECT:204 err = lapb_connect_request(dev);205 if (err == LAPB_CONNECTED)206 lapbeth_connected(dev, LAPB_OK);207 else if (err != LAPB_OK)208 pr_err("lapb_connect_request error: %d\n", err);209 goto drop;210 case X25_IFACE_DISCONNECT:211 err = lapb_disconnect_request(dev);212 if (err == LAPB_NOTCONNECTED)213 lapbeth_disconnected(dev, LAPB_OK);214 else if (err != LAPB_OK)215 pr_err("lapb_disconnect_request err: %d\n", err);216 fallthrough;217 default:218 goto drop;219 }220 221 skb_pull(skb, 1);222 223 err = lapb_data_request(dev, skb);224 if (err != LAPB_OK) {225 pr_err("lapb_data_request error - %d\n", err);226 goto drop;227 }228out:229 spin_unlock_bh(&lapbeth->up_lock);230 return NETDEV_TX_OK;231drop:232 kfree_skb(skb);233 goto out;234}235 236static void lapbeth_data_transmit(struct net_device *ndev, struct sk_buff *skb)237{238 struct lapbethdev *lapbeth = netdev_priv(ndev);239 unsigned char *ptr;240 struct net_device *dev;241 int size = skb->len;242 243 ptr = skb_push(skb, 2);244 245 *ptr++ = size % 256;246 *ptr++ = size / 256;247 248 ndev->stats.tx_packets++;249 ndev->stats.tx_bytes += size;250 251 skb->dev = dev = lapbeth->ethdev;252 253 skb->protocol = htons(ETH_P_DEC);254 255 skb_reset_network_header(skb);256 257 dev_hard_header(skb, dev, ETH_P_DEC, bcast_addr, NULL, 0);258 259 dev_queue_xmit(skb);260}261 262static void lapbeth_connected(struct net_device *dev, int reason)263{264 struct lapbethdev *lapbeth = netdev_priv(dev);265 unsigned char *ptr;266 struct sk_buff *skb = __dev_alloc_skb(1, GFP_ATOMIC | __GFP_NOMEMALLOC);267 268 if (!skb)269 return;270 271 ptr = skb_put(skb, 1);272 *ptr = X25_IFACE_CONNECT;273 274 skb->protocol = x25_type_trans(skb, dev);275 276 skb_queue_tail(&lapbeth->rx_queue, skb);277 napi_schedule(&lapbeth->napi);278}279 280static void lapbeth_disconnected(struct net_device *dev, int reason)281{282 struct lapbethdev *lapbeth = netdev_priv(dev);283 unsigned char *ptr;284 struct sk_buff *skb = __dev_alloc_skb(1, GFP_ATOMIC | __GFP_NOMEMALLOC);285 286 if (!skb)287 return;288 289 ptr = skb_put(skb, 1);290 *ptr = X25_IFACE_DISCONNECT;291 292 skb->protocol = x25_type_trans(skb, dev);293 294 skb_queue_tail(&lapbeth->rx_queue, skb);295 napi_schedule(&lapbeth->napi);296}297 298/* Set AX.25 callsign299 */300static int lapbeth_set_mac_address(struct net_device *dev, void *addr)301{302 struct sockaddr *sa = addr;303 304 dev_addr_set(dev, sa->sa_data);305 return 0;306}307 308static const struct lapb_register_struct lapbeth_callbacks = {309 .connect_confirmation = lapbeth_connected,310 .connect_indication = lapbeth_connected,311 .disconnect_confirmation = lapbeth_disconnected,312 .disconnect_indication = lapbeth_disconnected,313 .data_indication = lapbeth_data_indication,314 .data_transmit = lapbeth_data_transmit,315};316 317/* open/close a device318 */319static int lapbeth_open(struct net_device *dev)320{321 struct lapbethdev *lapbeth = netdev_priv(dev);322 int err;323 324 napi_enable(&lapbeth->napi);325 326 err = lapb_register(dev, &lapbeth_callbacks);327 if (err != LAPB_OK) {328 napi_disable(&lapbeth->napi);329 pr_err("lapb_register error: %d\n", err);330 return -ENODEV;331 }332 333 spin_lock_bh(&lapbeth->up_lock);334 lapbeth->up = true;335 spin_unlock_bh(&lapbeth->up_lock);336 337 return 0;338}339 340static int lapbeth_close(struct net_device *dev)341{342 struct lapbethdev *lapbeth = netdev_priv(dev);343 int err;344 345 spin_lock_bh(&lapbeth->up_lock);346 lapbeth->up = false;347 spin_unlock_bh(&lapbeth->up_lock);348 349 err = lapb_unregister(dev);350 if (err != LAPB_OK)351 pr_err("lapb_unregister error: %d\n", err);352 353 napi_disable(&lapbeth->napi);354 355 return 0;356}357 358/* ------------------------------------------------------------------------ */359 360static const struct net_device_ops lapbeth_netdev_ops = {361 .ndo_open = lapbeth_open,362 .ndo_stop = lapbeth_close,363 .ndo_start_xmit = lapbeth_xmit,364 .ndo_set_mac_address = lapbeth_set_mac_address,365};366 367static void lapbeth_setup(struct net_device *dev)368{369 dev->netdev_ops = &lapbeth_netdev_ops;370 dev->needs_free_netdev = true;371 dev->type = ARPHRD_X25;372 dev->hard_header_len = 0;373 dev->mtu = 1000;374 dev->addr_len = 0;375}376 377/* Setup a new device.378 */379static int lapbeth_new_device(struct net_device *dev)380{381 struct net_device *ndev;382 struct lapbethdev *lapbeth;383 int rc = -ENOMEM;384 385 ASSERT_RTNL();386 387 if (dev->type != ARPHRD_ETHER)388 return -EINVAL;389 390 ndev = alloc_netdev(sizeof(*lapbeth), "lapb%d", NET_NAME_UNKNOWN,391 lapbeth_setup);392 if (!ndev)393 goto out;394 395 /* When transmitting data:396 * first this driver removes a pseudo header of 1 byte,397 * then the lapb module prepends an LAPB header of at most 3 bytes,398 * then this driver prepends a length field of 2 bytes,399 * then the underlying Ethernet device prepends its own header.400 */401 ndev->needed_headroom = -1 + 3 + 2 + dev->hard_header_len402 + dev->needed_headroom;403 ndev->needed_tailroom = dev->needed_tailroom;404 405 lapbeth = netdev_priv(ndev);406 lapbeth->axdev = ndev;407 408 dev_hold(dev);409 lapbeth->ethdev = dev;410 411 lapbeth->up = false;412 spin_lock_init(&lapbeth->up_lock);413 414 skb_queue_head_init(&lapbeth->rx_queue);415 netif_napi_add_weight(ndev, &lapbeth->napi, lapbeth_napi_poll, 16);416 417 rc = -EIO;418 if (register_netdevice(ndev))419 goto fail;420 421 list_add_rcu(&lapbeth->node, &lapbeth_devices);422 rc = 0;423out:424 return rc;425fail:426 dev_put(dev);427 free_netdev(ndev);428 goto out;429}430 431/* Free a lapb network device.432 */433static void lapbeth_free_device(struct lapbethdev *lapbeth)434{435 dev_put(lapbeth->ethdev);436 list_del_rcu(&lapbeth->node);437 unregister_netdevice(lapbeth->axdev);438}439 440/* Handle device status changes.441 *442 * Called from notifier with RTNL held.443 */444static int lapbeth_device_event(struct notifier_block *this,445 unsigned long event, void *ptr)446{447 struct lapbethdev *lapbeth;448 struct net_device *dev = netdev_notifier_info_to_dev(ptr);449 450 if (dev_net(dev) != &init_net)451 return NOTIFY_DONE;452 453 if (!dev_is_ethdev(dev) && !lapbeth_get_x25_dev(dev))454 return NOTIFY_DONE;455 456 switch (event) {457 case NETDEV_UP:458 /* New ethernet device -> new LAPB interface */459 if (!lapbeth_get_x25_dev(dev))460 lapbeth_new_device(dev);461 break;462 case NETDEV_GOING_DOWN:463 /* ethernet device closes -> close LAPB interface */464 lapbeth = lapbeth_get_x25_dev(dev);465 if (lapbeth)466 dev_close(lapbeth->axdev);467 break;468 case NETDEV_UNREGISTER:469 /* ethernet device disappears -> remove LAPB interface */470 lapbeth = lapbeth_get_x25_dev(dev);471 if (lapbeth)472 lapbeth_free_device(lapbeth);473 break;474 }475 476 return NOTIFY_DONE;477}478 479/* ------------------------------------------------------------------------ */480 481static struct packet_type lapbeth_packet_type __read_mostly = {482 .type = cpu_to_be16(ETH_P_DEC),483 .func = lapbeth_rcv,484};485 486static struct notifier_block lapbeth_dev_notifier = {487 .notifier_call = lapbeth_device_event,488};489 490static const char banner[] __initconst =491 KERN_INFO "LAPB Ethernet driver version 0.02\n";492 493static int __init lapbeth_init_driver(void)494{495 dev_add_pack(&lapbeth_packet_type);496 497 register_netdevice_notifier(&lapbeth_dev_notifier);498 499 printk(banner);500 501 return 0;502}503module_init(lapbeth_init_driver);504 505static void __exit lapbeth_cleanup_driver(void)506{507 struct lapbethdev *lapbeth;508 struct list_head *entry, *tmp;509 510 dev_remove_pack(&lapbeth_packet_type);511 unregister_netdevice_notifier(&lapbeth_dev_notifier);512 513 rtnl_lock();514 list_for_each_safe(entry, tmp, &lapbeth_devices) {515 lapbeth = list_entry(entry, struct lapbethdev, node);516 517 dev_put(lapbeth->ethdev);518 unregister_netdevice(lapbeth->axdev);519 }520 rtnl_unlock();521}522module_exit(lapbeth_cleanup_driver);523 524MODULE_AUTHOR("Jonathan Naylor <g4klx@g4klx.demon.co.uk>");525MODULE_DESCRIPTION("The unofficial LAPB over Ethernet driver");526MODULE_LICENSE("GPL");527