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