net/wanrouter/wanmain.c

   1 /*****************************************************************************
   2 * wanmain.c     WAN Multiprotocol Router Module. Main code.
   3 *
   4 *               This module is completely hardware-independent and provides
   5 *               the following common services for the WAN Link Drivers:
   6 *                o WAN device managenment (registering, unregistering)
   7 *                o Network interface management
   8 *                o Physical connection management (dial-up, incomming calls)
   9 *                o Logical connection management (switched virtual circuits)
  10 *                o Protocol encapsulation/decapsulation
  11 *
  12 * Author:       Gene Kozin      <genek@compuserve.com>
  13 *
  14 * Copyright:    (c) 1995-1997 Sangoma Technologies Inc.
  15 *
  16 *               This program is free software; you can redistribute it and/or
  17 *               modify it under the terms of the GNU General Public License
  18 *               as published by the Free Software Foundation; either version
  19 *               2 of the License, or (at your option) any later version.
  20 * ============================================================================
  21 * Dec 27, 1996  Gene Kozin      Initial version (based on Sangoma's WANPIPE)
  22 * Jan 16, 1997  Gene Kozin      router_devlist made public
  23 * Jan 31, 1997  Alan Cox        Hacked it about a bit for 2.1
  24 * Jun 27, 1997  Alan Cox        realigned with vendor code
  25 * Oct 15, 1997  Farhan Thawar   changed wan_encapsulate to add a pad byte of 0
  26 * Apr 20, 1998  Alan Cox        Fixed 2.1 symbols
  27 * May 17, 1998  K. Baranowski   Fixed SNAP encapsulation in wan_encapsulate
  28 * Dec 15, 1998  Arnaldo Melo    support for firmwares of up to 128000 bytes
  29 *                               check wandev->setup return value
  30 * Dec 22, 1998  Arnaldo Melo    vmalloc/vfree used in device_setup to allocate
  31 *                               kernel memory and copy configuration data to
  32 *                               kernel space (for big firmwares)
  33 *****************************************************************************/
  34
  35 #include <linux/config.h>
  36 #include <linux/stddef.h>       /* offsetof(), etc. */
  37 #include <linux/errno.h>        /* return codes */
  38 #include <linux/kernel.h>
  39 #include <linux/module.h>       /* support for loadable modules */
  40 #include <linux/malloc.h>       /* kmalloc(), kfree() */
  41 #include <linux/mm.h>           /* verify_area(), etc. */
  42 #include <linux/string.h>       /* inline mem*, str* functions */
  43 #include <linux/vmalloc.h>      /* vmalloc, vfree */
  44 #include <asm/segment.h>        /* kernel <-> user copy */
  45 #include <asm/byteorder.h>      /* htons(), etc. */
  46 #include <asm/uaccess.h>        /* copy_to/from_user */
  47 #include <linux/wanrouter.h>    /* WAN router API definitions */
  48 #include <linux/init.h>         /* __initfunc et al. */
  49
  50 /****** Defines and Macros **************************************************/
  51
  52 #ifndef min
  53 #define min(a,b) (((a)<(b))?(a):(b))
  54 #endif
  55 #ifndef max
  56 #define max(a,b) (((a)>(b))?(a):(b))
  57 #endif
  58
  59 /****** Function Prototypes *************************************************/
  60
  61 /*
  62  *      Kernel loadable module interface.
  63  */
  64
  65 #ifdef MODULE
  66 int init_module (void);
  67 void cleanup_module (void);
  68 #endif
  69
  70 /*
  71  *      WAN device IOCTL handlers
  72  */
  73
  74 static int device_setup (wan_device_t* wandev, wandev_conf_t* u_conf);
  75 static int device_stat (wan_device_t* wandev, wandev_stat_t* u_stat);
  76 static int device_shutdown (wan_device_t* wandev);
  77 static int device_new_if (wan_device_t* wandev, wanif_conf_t* u_conf);
  78 static int device_del_if (wan_device_t* wandev, char* u_name);
  79
  80 /*
  81  *      Miscellaneous
  82  */
  83
  84 static wan_device_t* find_device (char* name);
  85 static int delete_interface (wan_device_t* wandev, char* name, int forse);
  86
  87 /*
  88  *      Global Data
  89  */
  90
  91 static char fullname[]          = "WAN Router";
  92 static char copyright[]         = "(c) 1995-1997 Sangoma Technologies Inc.";
  93 static char modname[]           = ROUTER_NAME;  /* short module name */
  94 wan_device_t * router_devlist   = NULL; /* list of registered devices */
  95 static int devcnt               = 0;
  96
  97 /*
  98  *      Organizationally Unique Identifiers for encapsulation/decapsulation
  99  */
 100
 101 static unsigned char oui_ether[] = { 0x00, 0x00, 0x00 };
 102 #if 0
 103 static unsigned char oui_802_2[] = { 0x00, 0x80, 0xC2 };
 104 #endif
 105
 106 #ifndef MODULE
 107
 108 int wanrouter_init(void)
 109 {
 110         int err;
 111         extern void wanpipe_init(void);
 112
 113         printk(KERN_INFO "%s v%u.%u %s\n",
 114                 fullname, ROUTER_VERSION, ROUTER_RELEASE, copyright);
 115         err = wanrouter_proc_init();
 116         if (err)
 117                 printk(KERN_ERR "%s: can't create entry in proc filesystem!\n", modname);
 118
 119         /*
 120          *      Initialise compiled in boards
 121          */
 122
 123 #ifdef CONFIG_VENDOR_SANGOMA
 124         wanpipe_init();
 125 #endif
 126         return err;
 127 }
 128
 129 #else
 130
 131 /*
 132  *      Kernel Loadable Module Entry Points
 133  */
 134
 135 /*
 136  *      Module 'insert' entry point.
 137  *      o print announcement
 138  *      o initialize static data
 139  *      o create /proc/net/router directory and static entries
 140  *
 141  *      Return: 0       Ok
 142  *              < 0     error.
 143  *      Context:        process
 144  */
 145
 146 int init_module (void)
 147 {
 148         int err;
 149
 150         printk(KERN_INFO "%s v%u.%u %s\n",
 151                 fullname, ROUTER_VERSION, ROUTER_RELEASE, copyright);
 152         err = wanrouter_proc_init();
 153         if (err) printk(KERN_ERR
 154                 "%s: can't create entry in proc filesystem!\n", modname);
 155         return err;
 156 }
 157
 158 /*
 159  *      Module 'remove' entry point.
 160  *      o delete /proc/net/router directory and static entries.
 161  */
 162
 163 void cleanup_module (void)
 164 {
 165         wanrouter_proc_cleanup();
 166 }
 167
 168 #endif
 169
 170 /*
 171  *      Kernel APIs
 172  */
 173
 174 /*
 175  *      Register WAN device.
 176  *      o verify device credentials
 177  *      o create an entry for the device in the /proc/net/router directory
 178  *      o initialize internally maintained fields of the wan_device structure
 179  *      o link device data space to a singly-linked list
 180  *      o if it's the first device, then start kernel 'thread'
 181  *      o increment module use count
 182  *
 183  *       Return:
 184  *              0       Ok
 185  *              < 0     error.
 186  *
 187  *      Context:        process
 188  */
 189
 190
 191 int register_wan_device(wan_device_t* wandev)
 192 {
 193         int err, namelen;
 194
 195         if ((wandev == NULL) || (wandev->magic != ROUTER_MAGIC) ||
 196             (wandev->name == NULL))
 197                 return -EINVAL;
 198
 199         namelen = strlen(wandev->name);
 200         if (!namelen || (namelen > WAN_DRVNAME_SZ))
 201                 return -EINVAL;
 202
 203         if (find_device(wandev->name) != NULL)
 204                 return -EEXIST;
 205
 206 #ifdef WANDEBUG
 207         printk(KERN_INFO "%s: registering WAN device %s\n",
 208                 modname, wandev->name);
 209 #endif
 210
 211         /*
 212          *      Register /proc directory entry
 213          */
 214         err = wanrouter_proc_add(wandev);
 215         if (err)
 216         {
 217                 printk(KERN_ERR
 218                         "%s: can't create /proc/net/router/%s entry!\n",
 219                         modname, wandev->name)
 220                 ;
 221                 return err;
 222         }
 223
 224         /*
 225          *      Initialize fields of the wan_device structure maintained by the
 226          *      router and update local data.
 227          */
 228
 229         wandev->ndev = 0;
 230         wandev->dev  = NULL;
 231         wandev->next = router_devlist;
 232         router_devlist = wandev;
 233         ++devcnt;
 234         MOD_INC_USE_COUNT;      /* prevent module from unloading */
 235         return 0;
 236 }
 237
 238 /*
 239  *      Unregister WAN device.
 240  *      o shut down device
 241  *      o unlink device data space from the linked list
 242  *      o delete device entry in the /proc/net/router directory
 243  *      o decrement module use count
 244  *
 245  *      Return:         0       Ok
 246  *                      <0      error.
 247  *      Context:        process
 248  */
 249
 250
 251 int unregister_wan_device(char* name)
 252 {
 253         wan_device_t *wandev, *prev;
 254
 255         if (name == NULL)
 256                 return -EINVAL;
 257
 258         for (wandev = router_devlist, prev = NULL;
 259                 wandev && strcmp(wandev->name, name);
 260                 prev = wandev, wandev = wandev->next)
 261                 ;
 262         if (wandev == NULL)
 263                 return -ENODEV;
 264
 265 #ifdef WANDEBUG
 266         printk(KERN_INFO "%s: unregistering WAN device %s\n", modname, name);
 267 #endif
 268
 269         if (wandev->state != WAN_UNCONFIGURED)
 270         {
 271                 while(wandev->dev)
 272                         delete_interface(wandev, wandev->dev->name, 1);
 273                 if (wandev->shutdown)
 274                         wandev->shutdown(wandev);
 275         }
 276         if (prev)
 277                 prev->next = wandev->next;
 278         else
 279                 router_devlist = wandev->next;
 280         --devcnt;
 281         wanrouter_proc_delete(wandev);
 282         MOD_DEC_USE_COUNT;
 283         return 0;
 284 }
 285
 286 /*
 287  *      Encapsulate packet.
 288  *
 289  *      Return: encapsulation header size
 290  *              < 0     - unsupported Ethertype
 291  *
 292  *      Notes:
 293  *      1. This function may be called on interrupt context.
 294  */
 295
 296
 297 int wanrouter_encapsulate (struct sk_buff* skb, struct device* dev)
 298 {
 299         int hdr_len = 0;
 300
 301         switch (skb->protocol)
 302         {
 303         case ETH_P_IP:          /* IP datagram encapsulation */
 304                 hdr_len += 1;
 305                 skb_push(skb, 1);
 306                 skb->data[0] = NLPID_IP;
 307                 break;
 308
 309         case ETH_P_IPX:         /* SNAP encapsulation */
 310         case ETH_P_ARP:
 311                 hdr_len += 7;
 312                 skb_push(skb, 7);
 313                 skb->data[0] = 0;
 314                 skb->data[1] = NLPID_SNAP;
 315                 memcpy(&skb->data[2], oui_ether, sizeof(oui_ether));
 316                 *((unsigned short*)&skb->data[5]) = htons(skb->protocol);
 317                 break;
 318
 319         default:                /* Unknown packet type */
 320                 printk(KERN_INFO
 321                         "%s: unsupported Ethertype 0x%04X on interface %s!\n",
 322                         modname, skb->protocol, dev->name);
 323                 hdr_len = -EINVAL;
 324         }
 325         return hdr_len;
 326 }
 327
 328 /*
 329  *      Decapsulate packet.
 330  *
 331  *      Return: Ethertype (in network order)
 332  *                      0       unknown encapsulation
 333  *
 334  *      Notes:
 335  *      1. This function may be called on interrupt context.
 336  */
 337
 338
 339 unsigned short wanrouter_type_trans (struct sk_buff* skb, struct device* dev)
 340 {
 341         int cnt = skb->data[0] ? 0 : 1; /* there may be a pad present */
 342         unsigned short ethertype;
 343
 344         switch (skb->data[cnt])
 345         {
 346         case NLPID_IP:          /* IP datagramm */
 347                 ethertype = htons(ETH_P_IP);
 348                 cnt += 1;
 349                 break;
 350
 351         case NLPID_SNAP:        /* SNAP encapsulation */
 352                 if (memcmp(&skb->data[cnt + 1], oui_ether, sizeof(oui_ether)))
 353                 {
 354                         printk(KERN_INFO
 355                                 "%s: unsupported SNAP OUI %02X-%02X-%02X "
 356                                 "on interface %s!\n", modname,
 357                                 skb->data[cnt+1], skb->data[cnt+2],
 358                                 skb->data[cnt+3], dev->name);
 359                         ;
 360                         return 0;
 361                 }
 362                 ethertype = *((unsigned short*)&skb->data[cnt+4]);
 363                 cnt += 6;
 364                 break;
 365
 366         /* add other protocols, e.g. CLNP, ESIS, ISIS, if needed */
 367
 368         default:
 369                 printk(KERN_INFO
 370                         "%s: unsupported NLPID 0x%02X on interface %s!\n",
 371                         modname, skb->data[cnt], dev->name)
 372                 ;
 373                 return 0;
 374         }
 375         skb->protocol = ethertype;
 376         skb->pkt_type = PACKET_HOST;    /*      Physically point to point */
 377         skb->mac.raw  = skb->data;
 378         skb_pull(skb, cnt);
 379         return ethertype;
 380 }
 381
 382 /*
 383  *      WAN device IOCTL.
 384  *      o find WAN device associated with this node
 385  *      o execute requested action or pass command to the device driver
 386  */
 387
 388 int wanrouter_ioctl(struct inode* inode, struct file* file,
 389                 unsigned int cmd, unsigned long arg)
 390 {
 391         int err = 0;
 392         struct proc_dir_entry* dent;
 393         wan_device_t* wandev;
 394
 395         if (!capable(CAP_NET_ADMIN)){
 396                 return -EPERM;
 397         }
 398
 399         if ((cmd >> 8) != ROUTER_IOCTL)
 400                 return -EINVAL;
 401
 402         dent = inode->u.generic_ip;
 403         if ((dent == NULL) || (dent->data == NULL))
 404                 return -EINVAL;
 405
 406         wandev = dent->data;
 407         if (wandev->magic != ROUTER_MAGIC)
 408                 return -EINVAL;
 409
 410         switch (cmd)
 411         {
 412         case ROUTER_SETUP:
 413                 err = device_setup(wandev, (void*)arg);
 414                 break;
 415
 416         case ROUTER_DOWN:
 417                 err = device_shutdown(wandev);
 418                 break;
 419
 420         case ROUTER_STAT:
 421                 err = device_stat(wandev, (void*)arg);
 422                 break;
 423
 424         case ROUTER_IFNEW:
 425                 err = device_new_if(wandev, (void*)arg);
 426                 break;
 427
 428         case ROUTER_IFDEL:
 429                 err = device_del_if(wandev, (void*)arg);
 430                 break;
 431
 432         case ROUTER_IFSTAT:
 433                 break;
 434
 435         default:
 436                 if ((cmd >= ROUTER_USER) &&
 437                     (cmd <= ROUTER_USER_MAX) &&
 438                     wandev->ioctl)
 439                         err = wandev->ioctl(wandev, cmd, arg)
 440                 ;
 441                 else err = -EINVAL;
 442         }
 443         return err;
 444 }
 445
 446 /*
 447  *      WAN Driver IOCTL Handlers
 448  */
 449
 450 /*
 451  *      Setup WAN link device.
 452  *      o verify user address space
 453  *      o allocate kernel memory and copy configuration data to kernel space
 454  *      o if configuration data includes extension, copy it to kernel space too
 455  *      o call driver's setup() entry point
 456  */
 457
 458 static int device_setup (wan_device_t* wandev, wandev_conf_t* u_conf)
 459 {
 460         void* data;
 461         wandev_conf_t *conf;
 462         int err= -EINVAL;
 463
 464         if (wandev->setup == NULL)      /* Nothing to do ? */
 465                 return 0;
 466
 467         conf = kmalloc(sizeof(wandev_conf_t), GFP_KERNEL);
 468         if (conf == NULL)
 469                 return -ENOBUFS;
 470
 471         if(copy_from_user(conf, u_conf, sizeof(wandev_conf_t)))
 472         {
 473                 kfree(conf);
 474                 return -EFAULT;
 475         }
 476
 477         if (conf->magic != ROUTER_MAGIC)
 478                 goto bail;
 479
 480         if (conf->data_size && conf->data)
 481         {
 482                 if(conf->data_size > 128000 || conf->data_size < 0){
 483                         goto bail;
 484                 }
 485                 data = vmalloc(conf->data_size);
 486                 if (data)
 487                 {
 488                         if(!copy_from_user(data, conf->data, conf->data_size))
 489                         {
 490                                 conf->data=data;
 491                                 err = wandev->setup(wandev,conf);
 492                         }
 493                         else
 494                                 err = -EFAULT;
 495                 }
 496                 else
 497                         err = -ENOBUFS;
 498
 499                 if (data)
 500                         vfree(data);
 501         }
 502 bail:
 503         kfree(conf);
 504         return err;
 505 }
 506
 507 /*
 508  *      Shutdown WAN device.
 509  *      o delete all not opened logical channels for this device
 510  *      o call driver's shutdown() entry point
 511  */
 512
 513 static int device_shutdown (wan_device_t* wandev)
 514 {
 515         struct device* dev;
 516
 517         if (wandev->state == WAN_UNCONFIGURED)
 518                 return 0;
 519
 520         for (dev = wandev->dev; dev;)
 521         {
 522                 if (delete_interface(wandev, dev->name, 0))
 523                         dev = dev->slave;
 524         }
 525         if (wandev->ndev)
 526                 return -EBUSY;  /* there are opened interfaces  */
 527
 528         if (wandev->shutdown)
 529                 return wandev->shutdown(wandev);
 530         return 0;
 531 }
 532
 533 /*
 534  *      Get WAN device status & statistics.
 535  */
 536
 537 static int device_stat (wan_device_t* wandev, wandev_stat_t* u_stat)
 538 {
 539         wandev_stat_t stat;
 540
 541         memset(&stat, 0, sizeof(stat));
 542
 543         /* Ask device driver to update device statistics */
 544         if ((wandev->state != WAN_UNCONFIGURED) && wandev->update)
 545                 wandev->update(wandev);
 546
 547         /* Fill out structure */
 548         stat.ndev  = wandev->ndev;
 549         stat.state = wandev->state;
 550
 551         if(copy_to_user(u_stat, &stat, sizeof(stat)))
 552                 return -EFAULT;
 553         return 0;
 554 }
 555
 556 /*
 557  *      Create new WAN interface.
 558  *      o verify user address space
 559  *      o copy configuration data to kernel address space
 560  *      o allocate network interface data space
 561  *      o call driver's new_if() entry point
 562  *      o make sure there is no interface name conflict
 563  *      o register network interface
 564  */
 565
 566 static int device_new_if (wan_device_t* wandev, wanif_conf_t* u_conf)
 567 {
 568         wanif_conf_t conf;
 569         struct device* dev;
 570         int err;
 571
 572         if ((wandev->state == WAN_UNCONFIGURED) || (wandev->new_if == NULL))
 573                 return -ENODEV;
 574
 575         if(copy_from_user(&conf, u_conf, sizeof(wanif_conf_t)))
 576                 return -EFAULT;
 577
 578         if (conf.magic != ROUTER_MAGIC)
 579                 return -EINVAL;
 580
 581         dev = kmalloc(sizeof(struct device), GFP_KERNEL);
 582         if (dev == NULL)
 583                 return -ENOBUFS;
 584
 585         memset(dev, 0, sizeof(struct device));
 586         err = wandev->new_if(wandev, dev, &conf);
 587         if (!err)
 588         {
 589                 /* Register network interface. This will invoke init()
 590                  * function supplied by the driver.  If device registered
 591                  * successfully, add it to the interface list.
 592                  */
 593                 if (dev->name == NULL)
 594                         err = -EINVAL;
 595
 596                 else if (dev_get(dev->name))
 597                         err = -EEXIST;  /* name already exists */
 598                 else
 599                 {
 600 #ifdef WANDEBUG
 601                         printk(KERN_INFO "%s: registering interface %s...\n",
 602                                 modname, dev->name);
 603 #endif
 604                         err = register_netdev(dev);
 605                         if (!err)
 606                         {
 607                                 cli();  /***** critical section start *****/
 608                                 dev->slave = wandev->dev;
 609                                 wandev->dev = dev;
 610                                 ++wandev->ndev;
 611                                 sti();  /****** critical section end ******/
 612                                 return 0;       /* done !!! */
 613                         }
 614                 }
 615                 if (wandev->del_if)
 616                         wandev->del_if(wandev, dev);
 617         }
 618         kfree(dev);
 619         return err;
 620 }
 621
 622 /*
 623  *      Delete WAN logical channel.
 624  *       o verify user address space
 625  *       o copy configuration data to kernel address space
 626  */
 627
 628 static int device_del_if (wan_device_t* wandev, char* u_name)
 629 {
 630         char name[WAN_IFNAME_SZ + 1];
 631
 632         if (wandev->state == WAN_UNCONFIGURED)
 633                 return -ENODEV;
 634
 635         memset(name, 0, sizeof(name));
 636         if(copy_from_user(name, u_name, WAN_IFNAME_SZ))
 637                 return -EFAULT;
 638         return delete_interface(wandev, name, 0);
 639 }
 640
 641 /*
 642  *      Miscellaneous Functions
 643  */
 644
 645 /*
 646  *      Find WAN device by name.
 647  *      Return pointer to the WAN device data space or NULL if device not found.
 648  */
 649
 650 static wan_device_t* find_device (char* name)
 651 {
 652         wan_device_t* wandev;
 653
 654         for (wandev = router_devlist;wandev && strcmp(wandev->name, name);
 655                 wandev = wandev->next);
 656         return wandev;
 657 }
 658
 659 /*
 660  *      Delete WAN logical channel identified by its name.
 661  *      o find logical channel by its name
 662  *      o call driver's del_if() entry point
 663  *      o unregister network interface
 664  *      o unlink channel data space from linked list of channels
 665  *      o release channel data space
 666  *
 667  *      Return: 0               success
 668  *              -ENODEV         channel not found.
 669  *              -EBUSY          interface is open
 670  *
 671  *      Note: If (force != 0), then device will be destroyed even if interface
 672  *      associated with it is open. It's caller's responsibility to make
 673  *      sure that opened interfaces are not removed!
 674  */
 675
 676 static int delete_interface (wan_device_t* wandev, char* name, int force)
 677 {
 678         struct device *dev, *prev;
 679
 680         for (dev = wandev->dev, prev = NULL;
 681                 dev && strcmp(name, dev->name);
 682                 prev = dev, dev = dev->slave);
 683
 684         if (dev == NULL)
 685                 return -ENODEV; /* interface not found */
 686
 687         if (dev->start)
 688         {
 689                 if (force)
 690                 {
 691                         printk(KERN_WARNING
 692                                 "%s: deleting opened interface %s!\n",modname, name);
 693                 }
 694                 else
 695                         return -EBUSY;  /* interface in use */
 696         }
 697         if (wandev->del_if)
 698                 wandev->del_if(wandev, dev);
 699
 700         cli();                  /***** critical section start *****/
 701         if (prev)
 702                 prev->slave = dev->slave;
 703         else
 704                 wandev->dev = dev->slave;
 705         --wandev->ndev;
 706         sti();                  /****** critical section end ******/
 707
 708         printk("Unregistering '%s'\n", dev->name);
 709         unregister_netdev(dev);
 710         kfree(dev);
 711         return 0;
 712 }
 713
 714 EXPORT_SYMBOL(register_wan_device);
 715 EXPORT_SYMBOL(unregister_wan_device);
 716 EXPORT_SYMBOL(wanrouter_encapsulate);
 717 EXPORT_SYMBOL(wanrouter_type_trans);
 718
 719 /*
 720  *      End
 721  */
 722