1/* 2 * DLCI Implementation of Frame Relay protocol for Linux, according to 3 * RFC 1490. This generic device provides en/decapsulation for an 4 * underlying hardware driver. Routes & IPs are assigned to these 5 * interfaces. Requires 'dlcicfg' program to create usable 6 * interfaces, the initial one, 'dlci' is for IOCTL use only. 7 * 8 * Version: @(#)dlci.c 0.35 4 Jan 1997 9 * 10 * Author: Mike McLagan <mike.mclagan@linux.org> 11 * 12 * Changes: 13 * 14 * 0.15 Mike Mclagan Packet freeing, bug in kmalloc call 15 * DLCI_RET handling 16 * 0.20 Mike McLagan More conservative on which packets 17 * are returned for retry and which are 18 * are dropped. If DLCI_RET_DROP is 19 * returned from the FRAD, the packet is 20 * sent back to Linux for re-transmission 21 * 0.25 Mike McLagan Converted to use SIOC IOCTL calls 22 * 0.30 Jim Freeman Fixed to allow IPX traffic 23 * 0.35 Michael Elizabeth Fixed incorrect memcpy_fromfs 24 * 25 * This program is free software; you can redistribute it and/or 26 * modify it under the terms of the GNU General Public License 27 * as published by the Free Software Foundation; either version 28 * 2 of the License, or (at your option) any later version. 29 */ 30 31#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 32 33#include <linux/module.h> 34#include <linux/kernel.h> 35#include <linux/types.h> 36#include <linux/fcntl.h> 37#include <linux/interrupt.h> 38#include <linux/ptrace.h> 39#include <linux/ioport.h> 40#include <linux/in.h> 41#include <linux/init.h> 42#include <linux/slab.h> 43#include <linux/string.h> 44#include <linux/errno.h> 45#include <linux/netdevice.h> 46#include <linux/skbuff.h> 47#include <linux/if_arp.h> 48#include <linux/if_frad.h> 49#include <linux/bitops.h> 50 51#include <net/sock.h> 52 53#include <asm/io.h> 54#include <asm/dma.h> 55#include <asm/uaccess.h> 56 57static const char version[] = "DLCI driver v0.35, 4 Jan 1997, mike.mclagan@linux.org"; 58 59static LIST_HEAD(dlci_devs); 60 61static void dlci_setup(struct net_device *); 62 63/* 64 * these encapsulate the RFC 1490 requirements as well as 65 * deal with packet transmission and reception, working with 66 * the upper network layers 67 */ 68 69static int dlci_header(struct sk_buff *skb, struct net_device *dev, 70 unsigned short type, const void *daddr, 71 const void *saddr, unsigned len) 72{ 73 struct frhdr hdr; 74 unsigned int hlen; 75 char *dest; 76 77 hdr.control = FRAD_I_UI; 78 switch (type) 79 { 80 case ETH_P_IP: 81 hdr.IP_NLPID = FRAD_P_IP; 82 hlen = sizeof(hdr.control) + sizeof(hdr.IP_NLPID); 83 break; 84 85 /* feel free to add other types, if necessary */ 86 87 default: 88 hdr.pad = FRAD_P_PADDING; 89 hdr.NLPID = FRAD_P_SNAP; 90 memset(hdr.OUI, 0, sizeof(hdr.OUI)); 91 hdr.PID = htons(type); 92 hlen = sizeof(hdr); 93 break; 94 } 95 96 dest = skb_push(skb, hlen); 97 if (!dest) 98 return 0; 99 100 memcpy(dest, &hdr, hlen); 101 102 return hlen; 103} 104 105static void dlci_receive(struct sk_buff *skb, struct net_device *dev) 106{ 107 struct frhdr *hdr; 108 int process, header; 109 110 if (!pskb_may_pull(skb, sizeof(*hdr))) { 111 netdev_notice(dev, "invalid data no header\n"); 112 dev->stats.rx_errors++; 113 kfree_skb(skb); 114 return; 115 } 116 117 hdr = (struct frhdr *) skb->data; 118 process = 0; 119 header = 0; 120 skb->dev = dev; 121 122 if (hdr->control != FRAD_I_UI) 123 { 124 netdev_notice(dev, "Invalid header flag 0x%02X\n", 125 hdr->control); 126 dev->stats.rx_errors++; 127 } 128 else 129 switch (hdr->IP_NLPID) 130 { 131 case FRAD_P_PADDING: 132 if (hdr->NLPID != FRAD_P_SNAP) 133 { 134 netdev_notice(dev, "Unsupported NLPID 0x%02X\n", 135 hdr->NLPID); 136 dev->stats.rx_errors++; 137 break; 138 } 139 140 if (hdr->OUI[0] + hdr->OUI[1] + hdr->OUI[2] != 0) 141 { 142 netdev_notice(dev, "Unsupported organizationally unique identifier 0x%02X-%02X-%02X\n", 143 hdr->OUI[0], 144 hdr->OUI[1], 145 hdr->OUI[2]); 146 dev->stats.rx_errors++; 147 break; 148 } 149 150 /* at this point, it's an EtherType frame */ 151 header = sizeof(struct frhdr); 152 /* Already in network order ! */ 153 skb->protocol = hdr->PID; 154 process = 1; 155 break; 156 157 case FRAD_P_IP: 158 header = sizeof(hdr->control) + sizeof(hdr->IP_NLPID); 159 skb->protocol = htons(ETH_P_IP); 160 process = 1; 161 break; 162 163 case FRAD_P_SNAP: 164 case FRAD_P_Q933: 165 case FRAD_P_CLNP: 166 netdev_notice(dev, "Unsupported NLPID 0x%02X\n", 167 hdr->pad); 168 dev->stats.rx_errors++; 169 break; 170 171 default: 172 netdev_notice(dev, "Invalid pad byte 0x%02X\n", 173 hdr->pad); 174 dev->stats.rx_errors++; 175 break; 176 } 177 178 if (process) 179 { 180 /* we've set up the protocol, so discard the header */ 181 skb_reset_mac_header(skb); 182 skb_pull(skb, header); 183 dev->stats.rx_bytes += skb->len; 184 netif_rx(skb); 185 dev->stats.rx_packets++; 186 } 187 else 188 dev_kfree_skb(skb); 189} 190 191static netdev_tx_t dlci_transmit(struct sk_buff *skb, struct net_device *dev) 192{ 193 struct dlci_local *dlp = netdev_priv(dev); 194 195 if (skb) { 196 struct netdev_queue *txq = skb_get_tx_queue(dev, skb); 197 netdev_start_xmit(skb, dlp->slave, txq, false); 198 } 199 return NETDEV_TX_OK; 200} 201 202static int dlci_config(struct net_device *dev, struct dlci_conf __user *conf, int get) 203{ 204 struct dlci_conf config; 205 struct dlci_local *dlp; 206 struct frad_local *flp; 207 int err; 208 209 dlp = netdev_priv(dev); 210 211 flp = netdev_priv(dlp->slave); 212 213 if (!get) 214 { 215 if (copy_from_user(&config, conf, sizeof(struct dlci_conf))) 216 return -EFAULT; 217 if (config.flags & ~DLCI_VALID_FLAGS) 218 return -EINVAL; 219 memcpy(&dlp->config, &config, sizeof(struct dlci_conf)); 220 dlp->configured = 1; 221 } 222 223 err = (*flp->dlci_conf)(dlp->slave, dev, get); 224 if (err) 225 return err; 226 227 if (get) 228 { 229 if (copy_to_user(conf, &dlp->config, sizeof(struct dlci_conf))) 230 return -EFAULT; 231 } 232 233 return 0; 234} 235 236static int dlci_dev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 237{ 238 struct dlci_local *dlp; 239 240 if (!capable(CAP_NET_ADMIN)) 241 return -EPERM; 242 243 dlp = netdev_priv(dev); 244 245 switch (cmd) 246 { 247 case DLCI_GET_SLAVE: 248 if (!*(short *)(dev->dev_addr)) 249 return -EINVAL; 250 251 strncpy(ifr->ifr_slave, dlp->slave->name, sizeof(ifr->ifr_slave)); 252 break; 253 254 case DLCI_GET_CONF: 255 case DLCI_SET_CONF: 256 if (!*(short *)(dev->dev_addr)) 257 return -EINVAL; 258 259 return dlci_config(dev, ifr->ifr_data, cmd == DLCI_GET_CONF); 260 261 default: 262 return -EOPNOTSUPP; 263 } 264 return 0; 265} 266 267static int dlci_change_mtu(struct net_device *dev, int new_mtu) 268{ 269 struct dlci_local *dlp = netdev_priv(dev); 270 271 return dev_set_mtu(dlp->slave, new_mtu); 272} 273 274static int dlci_open(struct net_device *dev) 275{ 276 struct dlci_local *dlp; 277 struct frad_local *flp; 278 int err; 279 280 dlp = netdev_priv(dev); 281 282 if (!*(short *)(dev->dev_addr)) 283 return -EINVAL; 284 285 if (!netif_running(dlp->slave)) 286 return -ENOTCONN; 287 288 flp = netdev_priv(dlp->slave); 289 err = (*flp->activate)(dlp->slave, dev); 290 if (err) 291 return err; 292 293 netif_start_queue(dev); 294 295 return 0; 296} 297 298static int dlci_close(struct net_device *dev) 299{ 300 struct dlci_local *dlp; 301 struct frad_local *flp; 302 int err; 303 304 netif_stop_queue(dev); 305 306 dlp = netdev_priv(dev); 307 308 flp = netdev_priv(dlp->slave); 309 err = (*flp->deactivate)(dlp->slave, dev); 310 311 return 0; 312} 313 314static int dlci_add(struct dlci_add *dlci) 315{ 316 struct net_device *master, *slave; 317 struct dlci_local *dlp; 318 struct frad_local *flp; 319 int err = -EINVAL; 320 321 322 /* validate slave device */ 323 slave = dev_get_by_name(&init_net, dlci->devname); 324 if (!slave) 325 return -ENODEV; 326 327 if (slave->type != ARPHRD_FRAD || netdev_priv(slave) == NULL) 328 goto err1; 329 330 /* create device name */ 331 master = alloc_netdev(sizeof(struct dlci_local), "dlci%d", 332 NET_NAME_UNKNOWN, dlci_setup); 333 if (!master) { 334 err = -ENOMEM; 335 goto err1; 336 } 337 338 /* make sure same slave not already registered */ 339 rtnl_lock(); 340 list_for_each_entry(dlp, &dlci_devs, list) { 341 if (dlp->slave == slave) { 342 err = -EBUSY; 343 goto err2; 344 } 345 } 346 347 *(short *)(master->dev_addr) = dlci->dlci; 348 349 dlp = netdev_priv(master); 350 dlp->slave = slave; 351 dlp->master = master; 352 353 flp = netdev_priv(slave); 354 err = (*flp->assoc)(slave, master); 355 if (err < 0) 356 goto err2; 357 358 err = register_netdevice(master); 359 if (err < 0) 360 goto err2; 361 362 strcpy(dlci->devname, master->name); 363 364 list_add(&dlp->list, &dlci_devs); 365 rtnl_unlock(); 366 367 return 0; 368 369 err2: 370 rtnl_unlock(); 371 free_netdev(master); 372 err1: 373 dev_put(slave); 374 return err; 375} 376 377static int dlci_del(struct dlci_add *dlci) 378{ 379 struct dlci_local *dlp; 380 struct frad_local *flp; 381 struct net_device *master, *slave; 382 int err; 383 bool found = false; 384 385 rtnl_lock(); 386 387 /* validate slave device */ 388 master = __dev_get_by_name(&init_net, dlci->devname); 389 if (!master) { 390 err = -ENODEV; 391 goto out; 392 } 393 394 list_for_each_entry(dlp, &dlci_devs, list) { 395 if (dlp->master == master) { 396 found = true; 397 break; 398 } 399 } 400 if (!found) { 401 err = -ENODEV; 402 goto out; 403 } 404 405 if (netif_running(master)) { 406 err = -EBUSY; 407 goto out; 408 } 409 410 dlp = netdev_priv(master); 411 slave = dlp->slave; 412 flp = netdev_priv(slave); 413 414 err = (*flp->deassoc)(slave, master); 415 if (!err) { 416 list_del(&dlp->list); 417 418 unregister_netdevice(master); 419 420 dev_put(slave); 421 } 422out: 423 rtnl_unlock(); 424 return err; 425} 426 427static int dlci_ioctl(unsigned int cmd, void __user *arg) 428{ 429 struct dlci_add add; 430 int err; 431 432 if (!capable(CAP_NET_ADMIN)) 433 return -EPERM; 434 435 if (copy_from_user(&add, arg, sizeof(struct dlci_add))) 436 return -EFAULT; 437 438 switch (cmd) 439 { 440 case SIOCADDDLCI: 441 err = dlci_add(&add); 442 443 if (!err) 444 if (copy_to_user(arg, &add, sizeof(struct dlci_add))) 445 return -EFAULT; 446 break; 447 448 case SIOCDELDLCI: 449 err = dlci_del(&add); 450 break; 451 452 default: 453 err = -EINVAL; 454 } 455 456 return err; 457} 458 459static const struct header_ops dlci_header_ops = { 460 .create = dlci_header, 461}; 462 463static const struct net_device_ops dlci_netdev_ops = { 464 .ndo_open = dlci_open, 465 .ndo_stop = dlci_close, 466 .ndo_do_ioctl = dlci_dev_ioctl, 467 .ndo_start_xmit = dlci_transmit, 468 .ndo_change_mtu = dlci_change_mtu, 469}; 470 471static void dlci_setup(struct net_device *dev) 472{ 473 struct dlci_local *dlp = netdev_priv(dev); 474 475 dev->flags = 0; 476 dev->header_ops = &dlci_header_ops; 477 dev->netdev_ops = &dlci_netdev_ops; 478 dev->destructor = free_netdev; 479 480 dlp->receive = dlci_receive; 481 482 dev->type = ARPHRD_DLCI; 483 dev->hard_header_len = sizeof(struct frhdr); 484 dev->addr_len = sizeof(short); 485 486} 487 488/* if slave is unregistering, then cleanup master */ 489static int dlci_dev_event(struct notifier_block *unused, 490 unsigned long event, void *ptr) 491{ 492 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 493 494 if (dev_net(dev) != &init_net) 495 return NOTIFY_DONE; 496 497 if (event == NETDEV_UNREGISTER) { 498 struct dlci_local *dlp; 499 500 list_for_each_entry(dlp, &dlci_devs, list) { 501 if (dlp->slave == dev) { 502 list_del(&dlp->list); 503 unregister_netdevice(dlp->master); 504 dev_put(dlp->slave); 505 break; 506 } 507 } 508 } 509 return NOTIFY_DONE; 510} 511 512static struct notifier_block dlci_notifier = { 513 .notifier_call = dlci_dev_event, 514}; 515 516static int __init init_dlci(void) 517{ 518 dlci_ioctl_set(dlci_ioctl); 519 register_netdevice_notifier(&dlci_notifier); 520 521 printk("%s.\n", version); 522 523 return 0; 524} 525 526static void __exit dlci_exit(void) 527{ 528 struct dlci_local *dlp, *nxt; 529 530 dlci_ioctl_set(NULL); 531 unregister_netdevice_notifier(&dlci_notifier); 532 533 rtnl_lock(); 534 list_for_each_entry_safe(dlp, nxt, &dlci_devs, list) { 535 unregister_netdevice(dlp->master); 536 dev_put(dlp->slave); 537 } 538 rtnl_unlock(); 539} 540 541module_init(init_dlci); 542module_exit(dlci_exit); 543 544MODULE_AUTHOR("Mike McLagan"); 545MODULE_DESCRIPTION("Frame Relay DLCI layer"); 546MODULE_LICENSE("GPL"); 547