drivers/net/lapbether.c

   1 /*
   2  *      "LAPB via ethernet" driver release 001
   3  *
   4  *      This code REQUIRES 2.1.15 or higher/ NET3.038
   5  *
   6  *      This module:
   7  *              This module is free software; you can redistribute it and/or
   8  *              modify it under the terms of the GNU General Public License
   9  *              as published by the Free Software Foundation; either version
  10  *              2 of the License, or (at your option) any later version.
  11  *
  12  *      This is a "pseudo" network driver to allow LAPB over Ethernet.
  13  *
  14  *      This driver can use any ethernet destination address, and can be
  15  *      limited to accept frames from one dedicated ethernet card only.
  16  *
  17  *      History
  18  *      LAPBETH 001     Jonathan Naylor         Cloned from bpqether.c
  19  */
  20
  21 #include <linux/errno.h>
  22 #include <linux/types.h>
  23 #include <linux/socket.h>
  24 #include <linux/in.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 <asm/segment.h>
  34 #include <asm/system.h>
  35 #include <asm/uaccess.h>
  36 #include <linux/mm.h>
  37 #include <linux/interrupt.h>
  38 #include <linux/notifier.h>
  39 #include <linux/proc_fs.h>
  40 #include <linux/stat.h>
  41 #include <linux/netfilter.h>
  42 #include <linux/module.h>
  43 #include <linux/lapb.h>
  44 #include <linux/init.h>
  45
  46 static char bcast_addr[6]={0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
  47
  48 static int lapbeth_rcv(struct sk_buff *, struct net_device *, struct packet_type *);
  49 static int lapbeth_device_event(struct notifier_block *, unsigned long, void *);
  50
  51 static struct packet_type lapbeth_packet_type = {
  52         0,              /* ntohs(ETH_P_DEC),*/
  53         0,              /* copy */
  54         lapbeth_rcv,
  55         NULL,
  56         NULL,
  57 };
  58
  59 static struct notifier_block lapbeth_dev_notifier = {
  60         lapbeth_device_event,
  61         0
  62 };
  63
  64
  65 #define MAXLAPBDEV 100
  66
  67 static struct lapbethdev {
  68         struct lapbethdev *next;
  69         char   ethname[14];             /* ether device name */
  70         struct net_device *ethdev;              /* link to ethernet device */
  71         struct net_device axdev;                /* lapbeth device (lapb#) */
  72         struct net_device_stats stats;  /* some statistics */
  73 } *lapbeth_devices = NULL;
  74
  75
  76 /* ------------------------------------------------------------------------ */
  77
  78
  79 /*
  80  *      Get the ethernet device for a LAPB device
  81  */
  82 static __inline__ struct net_device *lapbeth_get_ether_dev(struct net_device *dev)
  83 {
  84         struct lapbethdev *lapbeth;
  85
  86         lapbeth = (struct lapbethdev *)dev->priv;
  87
  88         return (lapbeth != NULL) ? lapbeth->ethdev : NULL;
  89 }
  90
  91 /*
  92  *      Get the LAPB device for the ethernet device
  93  */
  94 static __inline__ struct net_device *lapbeth_get_x25_dev(struct net_device *dev)
  95 {
  96         struct lapbethdev *lapbeth;
  97
  98         for (lapbeth = lapbeth_devices; lapbeth != NULL; lapbeth = lapbeth->next)
  99                 if (lapbeth->ethdev == dev)
 100                         return &lapbeth->axdev;
 101
 102         return NULL;
 103 }
 104
 105 static __inline__ int dev_is_ethdev(struct net_device *dev)
 106 {
 107         return (
 108                         dev->type == ARPHRD_ETHER
 109                         && strncmp(dev->name, "dummy", 5)
 110         );
 111 }
 112
 113 /*
 114  *      Sanity check: remove all devices that ceased to exists and
 115  *      return '1' if the given LAPB device was affected.
 116  */
 117 static int lapbeth_check_devices(struct net_device *dev)
 118 {
 119         struct lapbethdev *lapbeth, *lapbeth_prev;
 120         int result = 0;
 121         unsigned long flags;
 122
 123         save_flags(flags);
 124         cli();
 125
 126         lapbeth_prev = NULL;
 127
 128         for (lapbeth = lapbeth_devices; lapbeth != NULL; lapbeth = lapbeth->next) {
 129                 if (!dev_get(lapbeth->ethname)) {
 130                         if (lapbeth_prev)
 131                                 lapbeth_prev->next = lapbeth->next;
 132                         else
 133                                 lapbeth_devices = lapbeth->next;
 134
 135                         if (&lapbeth->axdev == dev)
 136                                 result = 1;
 137
 138                         unregister_netdev(&lapbeth->axdev);
 139                         kfree(lapbeth);
 140                 }
 141
 142                 lapbeth_prev = lapbeth;
 143         }
 144
 145         restore_flags(flags);
 146
 147         return result;
 148 }
 149
 150
 151 /* ------------------------------------------------------------------------ */
 152
 153
 154 /*
 155  *      Receive a LAPB frame via an ethernet interface.
 156  */
 157 static int lapbeth_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *ptype)
 158 {
 159         int len, err;
 160         struct lapbethdev *lapbeth;
 161
 162         skb->sk = NULL;         /* Initially we don't know who it's for */
 163
 164         dev = lapbeth_get_x25_dev(dev);
 165
 166         if (dev == NULL || dev->start == 0) {
 167                 kfree_skb(skb);
 168                 return 0;
 169         }
 170
 171         lapbeth = (struct lapbethdev *)dev->priv;
 172
 173         lapbeth->stats.rx_packets++;
 174
 175         len = skb->data[0] + skb->data[1] * 256;
 176
 177         skb_pull(skb, 2);       /* Remove the length bytes */
 178         skb_trim(skb, len);     /* Set the length of the data */
 179
 180         if ((err = lapb_data_received(lapbeth, skb)) != LAPB_OK) {
 181                 kfree_skb(skb);
 182                 printk(KERN_DEBUG "lapbether: lapb_data_received err - %d\n", err);
 183         }
 184
 185         return 0;
 186 }
 187
 188 static void lapbeth_data_indication(void *token, struct sk_buff *skb)
 189 {
 190         struct lapbethdev *lapbeth = (struct lapbethdev *)token;
 191         unsigned char *ptr;
 192
 193         ptr  = skb_push(skb, 1);
 194         *ptr = 0x00;
 195
 196         skb->dev      = &lapbeth->axdev;
 197         skb->protocol = htons(ETH_P_X25);
 198         skb->mac.raw  = skb->data;
 199         skb->pkt_type = PACKET_HOST;
 200
 201         netif_rx(skb);
 202 }
 203
 204 /*
 205  *      Send a LAPB frame via an ethernet interface
 206  */
 207 static int lapbeth_xmit(struct sk_buff *skb, struct net_device *dev)
 208 {
 209         struct lapbethdev *lapbeth;
 210         int err;
 211
 212         lapbeth = (struct lapbethdev *)dev->priv;
 213
 214         /*
 215          * Just to be *really* sure not to send anything if the interface
 216          * is down, the ethernet device may have gone.
 217          */
 218         if (!dev->start) {
 219                 lapbeth_check_devices(dev);
 220                 kfree_skb(skb);
 221                 return -ENODEV;
 222         }
 223
 224         switch (skb->data[0]) {
 225                 case 0x00:
 226                         break;
 227                 case 0x01:
 228                         if ((err = lapb_connect_request(lapbeth)) != LAPB_OK)
 229                                 printk(KERN_ERR "lapbeth: lapb_connect_request error - %d\n", err);
 230                         kfree_skb(skb);
 231                         return 0;
 232                 case 0x02:
 233                         if ((err = lapb_disconnect_request(lapbeth)) != LAPB_OK)
 234                                 printk(KERN_ERR "lapbeth: lapb_disconnect_request err - %d\n", err);
 235                         kfree_skb(skb);
 236                         return 0;
 237                 default:
 238                         kfree_skb(skb);
 239                         return 0;
 240         }
 241
 242         skb_pull(skb, 1);
 243
 244         if ((err = lapb_data_request(lapbeth, skb)) != LAPB_OK) {
 245                 printk(KERN_ERR "lapbeth: lapb_data_request error - %d\n", err);
 246                 kfree_skb(skb);
 247                 return -ENOMEM;
 248         }
 249
 250         return 0;
 251 }
 252
 253 static void lapbeth_data_transmit(void *token, struct sk_buff *skb)
 254 {
 255         struct lapbethdev *lapbeth = (struct lapbethdev *)token;
 256         unsigned char *ptr;
 257         struct net_device *dev;
 258         int size;
 259
 260         skb->protocol = htons(ETH_P_X25);
 261
 262         size = skb->len;
 263
 264         ptr = skb_push(skb, 2);
 265
 266         *ptr++ = size % 256;
 267         *ptr++ = size / 256;
 268
 269         lapbeth->stats.tx_packets++;
 270
 271         skb->dev = dev = lapbeth->ethdev;
 272
 273         dev->hard_header(skb, dev, ETH_P_DEC, bcast_addr, NULL, 0);
 274
 275         dev_queue_xmit(skb);
 276 }
 277
 278 static void lapbeth_connected(void *token, int reason)
 279 {
 280         struct lapbethdev *lapbeth = (struct lapbethdev *)token;
 281         struct sk_buff *skb;
 282         unsigned char *ptr;
 283
 284         if ((skb = dev_alloc_skb(1)) == NULL) {
 285                 printk(KERN_ERR "lapbeth: out of memory\n");
 286                 return;
 287         }
 288
 289         ptr  = skb_put(skb, 1);
 290         *ptr = 0x01;
 291
 292         skb->dev      = &lapbeth->axdev;
 293         skb->protocol = htons(ETH_P_X25);
 294         skb->mac.raw  = skb->data;
 295         skb->pkt_type = PACKET_HOST;
 296
 297         netif_rx(skb);
 298 }
 299
 300 static void lapbeth_disconnected(void *token, int reason)
 301 {
 302         struct lapbethdev *lapbeth = (struct lapbethdev *)token;
 303         struct sk_buff *skb;
 304         unsigned char *ptr;
 305
 306         if ((skb = dev_alloc_skb(1)) == NULL) {
 307                 printk(KERN_ERR "lapbeth: out of memory\n");
 308                 return;
 309         }
 310
 311         ptr  = skb_put(skb, 1);
 312         *ptr = 0x02;
 313
 314         skb->dev      = &lapbeth->axdev;
 315         skb->protocol = htons(ETH_P_X25);
 316         skb->mac.raw  = skb->data;
 317         skb->pkt_type = PACKET_HOST;
 318
 319         netif_rx(skb);
 320 }
 321
 322 /*
 323  *      Statistics
 324  */
 325 static struct net_device_stats *lapbeth_get_stats(struct net_device *dev)
 326 {
 327         struct lapbethdev *lapbeth;
 328
 329         lapbeth = (struct lapbethdev *)dev->priv;
 330
 331         return &lapbeth->stats;
 332 }
 333
 334 /*
 335  *      Set AX.25 callsign
 336  */
 337 static int lapbeth_set_mac_address(struct net_device *dev, void *addr)
 338 {
 339     struct sockaddr *sa = (struct sockaddr *)addr;
 340
 341     memcpy(dev->dev_addr, sa->sa_data, dev->addr_len);
 342
 343     return 0;
 344 }
 345
 346 static int lapbeth_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 347 {
 348         return -EINVAL;
 349 }
 350
 351 /*
 352  * open/close a device
 353  */
 354 static int lapbeth_open(struct net_device *dev)
 355 {
 356         struct lapb_register_struct lapbeth_callbacks;
 357         struct lapbethdev *lapbeth;
 358         int err;
 359
 360         if (lapbeth_check_devices(dev))
 361                 return -ENODEV;         /* oops, it's gone */
 362
 363         dev->tbusy = 0;
 364         dev->start = 1;
 365
 366         lapbeth = (struct lapbethdev *)dev->priv;
 367
 368         lapbeth_callbacks.connect_confirmation    = lapbeth_connected;
 369         lapbeth_callbacks.connect_indication      = lapbeth_connected;
 370         lapbeth_callbacks.disconnect_confirmation = lapbeth_disconnected;
 371         lapbeth_callbacks.disconnect_indication   = lapbeth_disconnected;
 372         lapbeth_callbacks.data_indication         = lapbeth_data_indication;
 373         lapbeth_callbacks.data_transmit           = lapbeth_data_transmit;
 374
 375         if ((err = lapb_register(lapbeth, &lapbeth_callbacks)) != LAPB_OK) {
 376                 printk(KERN_ERR "lapbeth: lapb_register error - %d\n", err);
 377                 dev->tbusy = 1;
 378                 dev->start = 0;
 379                 return -ENODEV;
 380         }
 381
 382         MOD_INC_USE_COUNT;
 383
 384         return 0;
 385 }
 386
 387 static int lapbeth_close(struct net_device *dev)
 388 {
 389         struct lapbethdev *lapbeth;
 390         int err;
 391
 392         dev->tbusy = 1;
 393         dev->start = 0;
 394
 395         lapbeth = (struct lapbethdev *)dev->priv;
 396
 397         if ((err = lapb_unregister(lapbeth)) != LAPB_OK)
 398                 printk(KERN_ERR "lapbeth: lapb_unregister error - %d\n", err);
 399
 400         MOD_DEC_USE_COUNT;
 401
 402         return 0;
 403 }
 404
 405 static int lapbeth_dev_init(struct net_device *dev)
 406 {
 407         return 0;
 408 }
 409
 410 /* ------------------------------------------------------------------------ */
 411
 412 /*
 413  *      Setup a new device.
 414  */
 415 static int lapbeth_new_device(struct net_device *dev)
 416 {
 417         int k;
 418         unsigned char *buf;
 419         struct lapbethdev *lapbeth, *lapbeth2;
 420
 421         if ((lapbeth = kmalloc(sizeof(struct lapbethdev), GFP_KERNEL)) == NULL)
 422                 return -ENOMEM;
 423
 424         memset(lapbeth, 0, sizeof(struct lapbethdev));
 425
 426         lapbeth->ethdev = dev;
 427
 428         lapbeth->ethname[sizeof(lapbeth->ethname)-1] = '\0';
 429         strncpy(lapbeth->ethname, dev->name, sizeof(lapbeth->ethname)-1);
 430
 431         dev = &lapbeth->axdev;
 432         buf = kmalloc(14, GFP_KERNEL);
 433
 434         for (k = 0; k < MAXLAPBDEV; k++) {
 435                 struct net_device *odev;
 436
 437                 sprintf(buf, "lapb%d", k);
 438
 439                 if ((odev = __dev_get_by_name(buf)) == NULL || lapbeth_check_devices(odev))
 440                         break;
 441         }
 442
 443         if (k == MAXLAPBDEV) {
 444                 kfree(lapbeth);
 445                 return -ENODEV;
 446         }
 447
 448         dev->priv = (void *)lapbeth;    /* pointer back */
 449         dev->name = buf;
 450         dev->init = lapbeth_dev_init;
 451
 452         if (register_netdev(dev) != 0) {
 453                 kfree(lapbeth);
 454                 return -EIO;
 455         }
 456
 457         dev_init_buffers(dev);
 458
 459         dev->hard_start_xmit = lapbeth_xmit;
 460         dev->open            = lapbeth_open;
 461         dev->stop            = lapbeth_close;
 462         dev->set_mac_address = lapbeth_set_mac_address;
 463         dev->get_stats       = lapbeth_get_stats;
 464         dev->do_ioctl        = lapbeth_ioctl;
 465
 466         dev->flags      = 0;
 467
 468         dev->type            = ARPHRD_X25;
 469         dev->hard_header_len = 3;
 470         dev->mtu             = 1000;
 471         dev->addr_len        = 0;
 472
 473         cli();
 474
 475         if (lapbeth_devices == NULL) {
 476                 lapbeth_devices = lapbeth;
 477         } else {
 478                 for (lapbeth2 = lapbeth_devices; lapbeth2->next != NULL; lapbeth2 = lapbeth2->next);
 479                 lapbeth2->next = lapbeth;
 480         }
 481
 482         sti();
 483
 484         return 0;
 485 }
 486
 487
 488 /*
 489  *      Handle device status changes.
 490  */
 491 static int lapbeth_device_event(struct notifier_block *this,unsigned long event, void *ptr)
 492 {
 493         struct net_device *dev = (struct net_device *)ptr;
 494
 495         if (!dev_is_ethdev(dev))
 496                 return NOTIFY_DONE;
 497
 498         lapbeth_check_devices(NULL);
 499
 500         switch (event) {
 501                 case NETDEV_UP:         /* new ethernet device -> new LAPB interface */
 502                         if (lapbeth_get_x25_dev(dev) == NULL)
 503                                 lapbeth_new_device(dev);
 504                         break;
 505
 506                 case NETDEV_DOWN:       /* ethernet device closed -> close LAPB interface */
 507                         if ((dev = lapbeth_get_x25_dev(dev)) != NULL)
 508                                 dev_close(dev);
 509                         break;
 510
 511                 default:
 512                         break;
 513         }
 514
 515         return NOTIFY_DONE;
 516 }
 517
 518
 519 /* ------------------------------------------------------------------------ */
 520
 521 /*
 522  * Initialize driver. To be called from af_ax25 if not compiled as a
 523  * module
 524  */
 525 int lapbeth_init(void)
 526 {
 527         struct net_device *dev;
 528
 529         lapbeth_packet_type.type  = htons(ETH_P_DEC);
 530         dev_add_pack(&lapbeth_packet_type);
 531
 532         register_netdevice_notifier(&lapbeth_dev_notifier);
 533
 534         printk(KERN_INFO "LAPB Ethernet driver version 0.01\n");
 535
 536         read_lock_bh(&dev_base_lock);
 537         for (dev = dev_base; dev != NULL; dev = dev->next) {
 538                 if (dev_is_ethdev(dev)) {
 539                         read_unlock_bh(&dev_base_lock);
 540                         lapbeth_new_device(dev);
 541                         read_lock_bh(&dev_base_lock);
 542                 }
 543         }
 544         read_unlock_bh(&dev_base_lock);
 545
 546         return 0;
 547 }
 548
 549 #ifdef MODULE
 550 EXPORT_NO_SYMBOLS;
 551
 552 MODULE_AUTHOR("Jonathan Naylor <g4klx@g4klx.demon.co.uk>");
 553 MODULE_DESCRIPTION("The unofficial LAPB over Ethernet driver");
 554
 555 int init_module(void)
 556 {
 557         return lapbeth_init();
 558 }
 559
 560 void cleanup_module(void)
 561 {
 562         struct lapbethdev *lapbeth;
 563
 564         dev_remove_pack(&lapbeth_packet_type);
 565
 566         unregister_netdevice_notifier(&lapbeth_dev_notifier);
 567
 568         for (lapbeth = lapbeth_devices; lapbeth != NULL; lapbeth = lapbeth->next)
 569                 unregister_netdev(&lapbeth->axdev);
 570 }
 571 #endif