chiark - git - mdw - unet/blob - unet.c

   1 /* -*-c-*-
   2  *
   3  * $Id: unet.c,v 1.1 2001/01/25 22:03:39 mdw Exp $
   4  *
   5  * User-space network device support.
   6  *
   7  * (c) 1998 Mark Wooding
   8  */
   9
  10 /*----- Licensing notice --------------------------------------------------*
  11  *
  12  * This file is part of Usernet.
  13  *
  14  * Usernet is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 2 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * Usernet is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with Usernet; if not, write to the Free Software Foundation,
  26  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  27  */
  28
  29 /*----- Revision history --------------------------------------------------*
  30  *
  31  * $Log: unet.c,v $
  32  * Revision 1.1  2001/01/25 22:03:39  mdw
  33  * Initial check-in (somewhat belated).
  34  *
  35  */
  36
  37 /*----- Include files -----------------------------------------------------*/
  38
  39 #include <linux/module.h>
  40
  41 #include <asm/byteorder.h>
  42 #include <asm/segment.h>
  43
  44 #include <linux/types.h>
  45 #include <linux/kernel.h>
  46 #include <linux/wait.h>
  47 #include <linux/sched.h>
  48 #include <linux/fs.h>
  49 #include <linux/poll.h>
  50 #include <linux/netdevice.h>
  51 #include <linux/etherdevice.h>
  52 #include <linux/if_arp.h>
  53 #include <linux/malloc.h>
  54 #include <linux/errno.h>
  55 #include <linux/init.h>
  56
  57 #include "unetconf.h"
  58 #include "unet.h"
  59
  60 MODULE_AUTHOR("Mark Wooding");
  61 MODULE_DESCRIPTION("Allows userland handling of a network interface");
  62
  63 /*----- Debugging macros --------------------------------------------------*/
  64
  65 #define UNET_DEBUGALWAYS 1
  66 #define UNET_DEBUGRUNTIME 0
  67 #define UNET_DEBUGNEVER -1
  68
  69 /* --- If the macro isn't defined then be switchable at runtime --- */
  70
  71 #ifndef UNET_DEBUG
  72 #  define UNET_DEBUG UNET_DEBUGRUNTIME
  73 #endif
  74
  75 /* --- Define the base macro @D@ according to the debug setting --- */
  76
  77 #if UNET_DEBUG == UNET_DEBUGALWAYS
  78 #  define D(x) { x }
  79 #  define DIF(u, x) if ((u)->f & UNIF_DEBUG) { x }
  80 #elif UNET_DEBUG == UNET_DEBUGRUNTIME
  81 #  define D(x) if (unet_debug) { x }
  82 #  define DIF(u, x) if ((u)->f & UNIF_DEBUG) { x }
  83 #elif UNET_DEBUG == UNET_DEBUGNEVER
  84 #  define D(x)
  85 #  define DIF(u, x)
  86 #elif
  87 #  error UNET_DEBUG set to invalid value (bug in configure script?)
  88 #endif
  89
  90 /*----- Type definitions --------------------------------------------------*/
  91
  92 /* --- Unet connection status --- *
  93  *
  94  * Records are stored in a slightly strange doubly linked list.  The list
  95  * exists so that I can find the next unused sequence number when creating
  96  * new connections.  It's odd because of the type of the @prev@ node;
  97  * rather than being the address of the previous item, it's the address of
  98  * the previous item's pointer to me, which among other good things means
  99  * that it works on the list head too.
 100  */
 101
 102 struct unet {
 103   struct unet *next, **prev;            /* List of unet blocks */
 104   struct device nif;                    /* Network interface block */
 105   int seq;                              /* Sequence number for connection */
 106   char name[UNET_NAMEMAX];              /* Buffer for my interface name */
 107   struct wait_queue *q;                 /* Wait list for device reads */
 108   struct sk_buff_head skbq;             /* Queue of packets waiting */
 109   struct enet_statistics e;             /* Pointer to statistics block */
 110   unsigned short protocol;              /* Protocol for outgoing packets */
 111   unsigned f;                           /* Userful flags */
 112 };
 113
 114 /*----- Static variables --------------------------------------------------*/
 115
 116 #if UNET_DEBUG == UNET_DEBUGRUNTIME
 117 static int unet_debug = 0;
 118 MODULE_PARM(unet_debug, "i");
 119 #endif
 120
 121 static int unet_npersist = UNET_NPERSIST;
 122 static int unet_maxif = UNET_MAXIF;
 123 static struct unet *unet_persistent;
 124 static struct unet *unet_list = 0;
 125
 126 MODULE_PARM(unet_npersist, "i");
 127 MODULE_PARM(unet_maxif, "i");
 128
 129 /*----- Debugging code ----------------------------------------------------*/
 130
 131 #if UNET_DEBUG != UNET_DEBUGNEVER
 132
 133 /* --- @unet_dumpBlock@ --- *
 134  *
 135  * Arguments:   @struct unet *u@ = pointer to block to dump
 136  *
 137  * Returns:     ---
 138  *
 139  * Use:         Dumps a unet object to syslogd.
 140  */
 141
 142 static void unet_dumpBlock(struct unet *u)
 143 {
 144   printk(KERN_DEBUG "unet: dumping unet block at %p\n", u);
 145   printk(KERN_DEBUG "      sequence number = %d\n", u->seq);
 146   printk(KERN_DEBUG "      interface name = `%s'\n", u->name);
 147   printk(KERN_DEBUG "      flags =%s%s%s\n",
 148          u->f & UNIF_TRANS ? " TRANS" : "",
 149          u->f & UNIF_OPEN ? " OPEN" : "",
 150          u->f & UNIF_DEBUG ? " DEBUG" : "");
 151   printk(KERN_DEBUG "      interface type = %d\n", u->nif.type);
 152   printk(KERN_DEBUG "      header len = %d\n", u->nif.hard_header_len);
 153   printk(KERN_DEBUG "      mtu = %d\n", u->nif.mtu);
 154   printk(KERN_DEBUG "      protocol = %d\n", ntohs(u->protocol));
 155   printk(KERN_DEBUG "      address len = %d\n", u->nif.addr_len);
 156 }
 157
 158 /* --- @unet_dump@ --- *
 159  *
 160  * Arguments:   ---
 161  *
 162  * Returns:     ---
 163  *
 164  * Use:         Dumps the entire unet state to syslogd.
 165  */
 166
 167 static void unet_dump(void)
 168 {
 169   int i;
 170   struct unet *u;
 171
 172   for (i = 0; i < unet_npersist; i++)
 173     unet_dumpBlock(&unet_persistent[i]);
 174   for (u = unet_list; u; u = u->next)
 175     unet_dumpBlock(u);
 176 }
 177
 178 /* --- @unet_hexdump@ --- *
 179  *
 180  * Arguments:   @const char *prefix@ = prefix to print on output lines
 181  *              @const void *b@ = pointer to block to dump
 182  *              @size_t sz@ = size of block to dump
 183  *
 184  * Returns:     ---
 185  *
 186  * Use:         Dumps a hex block to the kernel log.
 187  */
 188
 189 #define UNET_HEXROWSZ 16
 190
 191 static void unet_hexdump(const char *prefix, const char *b, size_t sz)
 192 {
 193   const unsigned char *p = b;
 194   size_t i;
 195   unsigned long o = 0;
 196   size_t c;
 197
 198   char buf[256], *q;
 199
 200   /* --- Now start work --- */
 201
 202   while (sz) {
 203     q = buf;
 204     q += sprintf(q, "%s%08lx : ", prefix, o);
 205     for (i = 0; i < UNET_HEXROWSZ; i++) {
 206       if (i < sz)
 207         q += sprintf(q, "%02x ", p[i]);
 208       else
 209         q += sprintf(q, "** ");
 210     }
 211     *q++ = ':'; *q++ = ' ';
 212     for (i = 0; i < UNET_HEXROWSZ; i++) {
 213       if (i < sz)
 214         *q++ = (p[i] >= 32 && p[i] < 127) ? p[i] : '.';
 215       else
 216         *q++ = '*';
 217     }
 218     *q++ = '\n';
 219     *q++ = 0;
 220     printk("%s", buf);
 221     c = (sz >= UNET_HEXROWSZ) ? UNET_HEXROWSZ : sz;
 222     sz -= c, p += c, o += c;
 223   }
 224 }
 225
 226 #endif
 227
 228 /*----- The unet network interfaces ---------------------------------------*/
 229
 230 /* --- @unet_ifopen@ --- *
 231  *
 232  * Arguments:   @struct device *nif@ = pointer to network interface
 233  *
 234  * Returns:     Zero or error condition.
 235  *
 236  * Use:         Turns on the network interface ready for action.  Oh, yes.
 237  */
 238
 239 static int unet_ifopen(struct device *nif)
 240 {
 241   D( struct unet *u = nif->priv;
 242      if (u->f & UNIF_DEBUG)
 243        printk(KERN_DEBUG "unet: opening interface %s\n", u->name); )
 244   MOD_INC_USE_COUNT;
 245   return (0);
 246 }
 247
 248 /* --- @unet_ifclose@ --- *
 249  *
 250  * Arguments:   @struct device *nif@ = pointer to network interface
 251  *
 252  * Returns:     Zero or error condition.
 253  *
 254  * Use:         Turns off the network interface.
 255  */
 256
 257 static int unet_ifclose(struct device *nif)
 258 {
 259   D( struct unet *u = nif->priv;
 260      if (u->f & UNIF_DEBUG)
 261        printk(KERN_DEBUG "unet: closing interface %d\n", u->seq); )
 262   MOD_DEC_USE_COUNT;
 263   return (0);
 264 }
 265
 266 /* --- @unet_iftx@ --- *
 267  *
 268  * Arguments:   @struct sk_buff *skb@ = incoming network packet
 269  *              @struct device *nif@ = pointer to network interface
 270  *
 271  * Returns:     Zero or error condition.
 272  *
 273  * Use:         Queues a network packet ready for collection by the user
 274  *              end of the business.
 275  */
 276
 277 static int unet_iftx(struct sk_buff *skb, struct device *nif)
 278 {
 279   struct unet *u = nif->priv;
 280   int qed;
 281
 282   DIF(u,
 283       printk(KERN_DEBUG "unet: packet received on if %s\n", u->name);
 284       unet_hexdump(KERN_DEBUG "      ", skb->data, skb->len); )
 285
 286   /* --- Discard packets when nobody's listening --- */
 287
 288   if ((u->f & UNIF_OPEN) == 0) {
 289     DIF(u, printk(KERN_DEBUG "unet: dropped packet: nobody's listening\n"); )
 290     dev_kfree_skb(skb);
 291     u->e.tx_dropped++;
 292     return (0);
 293   }
 294
 295   /* --- Discard packets when the queue's too long --- */
 296
 297   if (u->skbq.qlen >= UNET_QMAXLEN) {
 298     DIF(u, printk(KERN_DEBUG "unet: refused packet: queue overflow\n"); )
 299     return (-1);
 300   }
 301
 302   /* --- Attach the buffer to the waiting list --- */
 303
 304   qed = u->skbq.qlen;
 305   skb_queue_tail(&u->skbq, skb);
 306   u->e.tx_packets++;
 307   DIF(u, printk(KERN_DEBUG "unet: queued packet OK\n"); )
 308
 309   /* --- If there are waiting processes, give 'em a kick --- */
 310
 311   if (qed == 0) {
 312     DIF(u, printk(KERN_DEBUG "unet: waking up sleeping listeners\n"); )
 313     wake_up_interruptible(&u->q);
 314   }
 315   return (0);
 316 }
 317
 318 /* --- @unet_ifgetstats@ --- *
 319  *
 320  * Arguments:   @struct device *nif@ = pointer to network interface
 321  *
 322  * Returns:     Pointer to a statistics buffer.
 323  *
 324  * Use:         Returns a block of interface statistics.
 325  */
 326
 327 static struct enet_statistics *unet_ifgetstats(struct device *nif)
 328 {
 329   struct unet *u = nif->priv;
 330   DIF(u, printk(KERN_DEBUG "unet: stats request for if %s\n", u->name); )
 331   return (&u->e);
 332 }
 333
 334 /* --- @unet_ifinit@ --- *
 335  *
 336  * Arguments:   @struct device *nif@ = pointer to network interface
 337  *
 338  * Returns:     Zero or error condition.
 339  *
 340  * Use:         Initialises a unet network interface.
 341  */
 342
 343 static int unet_ifinit(struct device *nif)
 344 {
 345   struct unet *u = nif->priv;
 346
 347   DIF(u, printk(KERN_DEBUG "unet: initialise interface %s\n", u->name); )
 348
 349   /* --- Initialise statistics gathering --- */
 350
 351   memset(&u->e, 0, sizeof(u->e));
 352   u->nif.get_stats = unet_ifgetstats;
 353
 354   /* --- Opening and closing interfaces --- */
 355
 356   u->nif.open = unet_ifopen;
 357   u->nif.stop = unet_ifclose;
 358
 359   /* --- Sending packets to the `outside world' --- */
 360
 361   u->nif.hard_start_xmit = unet_iftx;
 362
 363   /* --- Some initialisation magic --- */
 364
 365 #ifdef notdef
 366   for (i = 0; i < DEV_NUMBUFFS; i++)
 367     skb_queue_head_init(&u->nif.buffs[i]);
 368 #endif
 369
 370   /* --- Configure other grotty bits of the interface --- */
 371
 372   u->nif.hard_header = 0;
 373   u->nif.rebuild_header = 0;
 374   u->nif.set_mac_address = 0;
 375
 376   u->nif.type = ARPHRD_LOOPBACK;        /* Got a better idea? */
 377   u->nif.hard_header_len = 0;
 378   u->nif.mtu = 1500 - MAX_HEADER;
 379   u->nif.addr_len = 0;
 380   u->nif.tx_queue_len = 16;             /* I keep my own queue */
 381
 382   memset(u->nif.broadcast, 0xFFu, MAX_ADDR_LEN);
 383
 384   u->nif.flags = IFF_NOARP;
 385
 386   /* --- Finished! --- */
 387
 388   return (0);
 389 }
 390
 391 /*----- Attachment management ---------------------------------------------*/
 392
 393 /* --- @unet_setup@ --- *
 394  *
 395  * Arguments:   @struct unet *u@ = pointer to a unet block
 396  *              @int seq@ = sequence number to allocate
 397  *
 398  * Returns:     Zero or error condition.
 399  *
 400  * Use:         Initialises a unet block ready for action.
 401  */
 402
 403 static int unet_setup(struct unet *u, int seq)
 404 {
 405   static struct device tpl;
 406   int e;
 407
 408   D( printk(KERN_DEBUG "unet: setting up unet block %d\n", seq); )
 409
 410   /* --- A little bit of initialisation --- */
 411
 412   u->seq = seq;
 413   u->f = 0;
 414   u->q = 0;
 415
 416   /* --- Inherit device debug flag from global flag --- */
 417
 418 #if UNET_DEBUG == UNET_DEBUGRUNTIME
 419   if (unet_debug)
 420     u->f |= UNIF_DEBUG;
 421 #elif UNET_DEBUG == UNET_DEBUGALWAYS
 422   u->f |= UNIF_DEBUG;
 423 #endif
 424
 425   /* --- Set up the network device --- */
 426
 427   u->nif = tpl;
 428   sprintf(u->name, "unet%d", seq);
 429   u->nif.name = u->name;
 430   u->nif.priv = u;
 431   u->nif.init = unet_ifinit;
 432   u->protocol = htons(ETH_P_IP);
 433
 434   if ((e = register_netdev(&u->nif)) != 0) {
 435     printk(KERN_ERR "unet: couldn't register net interface\n");
 436     return (e);
 437   }
 438
 439   /* --- Empty the skbuff list --- */
 440
 441   skb_queue_head_init(&u->skbq);
 442
 443   /* --- We're only finished, that's all --- */
 444
 445   return (0);
 446 }
 447
 448 /* --- @unet_flush@ --- *
 449  *
 450  * Arguments:   @struct unet *u@ = pointer to a unet block
 451  *
 452  * Returns:     ---
 453  *
 454  * Use:         Releases all the packets waiting for transmission.
 455  */
 456
 457 static void unet_flush(struct unet *u)
 458 {
 459   struct sk_buff *skb;
 460
 461 #if UNET_DEBUG != UNET_DEBUGNEVER
 462   int i = 0;
 463 #endif
 464
 465   DIF(u, printk(KERN_DEBUG "unet: flushing packets on %s\n", u->name); )
 466
 467   while ((skb = skb_dequeue(&u->skbq)) != 0) {
 468     dev_kfree_skb(skb);
 469     D( i++; )
 470   }
 471   DIF(u, printk(KERN_DEBUG "unet: released %d waiting packets\n", i); )
 472 }
 473
 474 /* --- @unet_kill@ --- *
 475  *
 476  * Arguments:   @struct unet *u@ = pointer to a unet block
 477  *
 478  * Returns:     ---
 479  *
 480  * Use:         Kills and decommissions a Usernet block.
 481  */
 482
 483 static void unet_kill(struct unet *u)
 484 {
 485   unet_flush(u);
 486   unregister_netdev(&u->nif);
 487 }
 488
 489 /*----- Handling the unet device ------------------------------------------*/
 490
 491 /* --- @unet_devopen@ --- *
 492  *
 493  * Arguments:   @struct inode *ino@ = inode block to open
 494  *              @struct file *f@ = file block to play with
 495  *
 496  * Returns:     Zero or error condition.
 497  *
 498  * Use:         Handles the opening of a unet device.
 499  */
 500
 501 static int unet_devopen(struct inode *ino, struct file *f)
 502 {
 503   struct unet *u, **up;
 504   int seq;
 505   int e = 0;
 506
 507   D( printk(KERN_DEBUG "unet: device open request\n"); )
 508
 509   /* --- Decide whether this is a persistent unet --- */
 510
 511   if ((seq = MINOR(ino->i_rdev)) < unet_npersist) {
 512     u = &unet_persistent[seq];
 513     if (u->f & UNIF_OPEN) {
 514       e = -EBUSY;
 515       goto tidy_0;
 516     }
 517     D( printk(KERN_DEBUG "unet: opened persistent %s\n", u->name); )
 518   }
 519
 520   /* --- Otherwise we've got to create a new one --- */
 521
 522   else {
 523
 524     /* --- Try to find a spare sequence number --- */
 525
 526     for (seq = unet_npersist, up = &unet_list; *up != 0;
 527          seq++, up = &(*up)->next) {
 528       if ((*up)->seq > seq)
 529         break;
 530       if (seq >= unet_maxif) {
 531         printk("unet: all unets are occupied\n");
 532         e = -ENFILE;
 533         goto tidy_0;
 534       }
 535     }
 536
 537     D( printk(KERN_DEBUG "unet: allocated sequence number %d\n", seq); )
 538
 539     /* --- Allocate a new block --- */
 540
 541     if ((u = kmalloc(sizeof(*u), GFP_KERNEL)) == 0) {
 542       printk(KERN_ERR "unet: couldn't allocate a unet block\n");
 543       e = -ENOMEM;
 544       goto tidy_0;
 545     }
 546
 547     /* --- Initialise the block --- */
 548
 549     if ((e = unet_setup(u, seq)) != 0)
 550       goto tidy_1;
 551     u->f |= UNIF_TRANS;
 552
 553     /* --- Link the block into the list --- */
 554
 555     u->next = *up;
 556     u->prev = up;
 557     if (*up)
 558       (*up)->prev = &u->next;
 559     *up = u;
 560
 561     D( printk(KERN_DEBUG "unet: opened transient %d\n", seq);
 562        unet_dumpBlock(u); )
 563   }
 564
 565   /* --- Done --- */
 566
 567   u->f |= UNIF_OPEN;
 568   f->private_data = u;
 569   MOD_INC_USE_COUNT;
 570   return (0);
 571
 572   /* --- Tidy up after little disasters --- */
 573
 574 tidy_1:
 575   kfree(u);
 576 tidy_0:
 577   return (e);
 578 }
 579
 580 /* --- @unet_devclose@ --- *
 581  *
 582  * Arguments:   @struct inode *ino@ = pointer to inode block
 583  *              @struct file *f@ = pointer to file block
 584  *
 585  * Returns:     ---
 586  *
 587  * Use:         Frees up a unet connection.
 588  */
 589
 590 static int unet_devclose(struct inode *ino, struct file *f)
 591 {
 592   struct unet *u = f->private_data;
 593
 594   DIF(u, printk(KERN_DEBUG "unet: closing %s\n", u->name); )
 595
 596   /* --- A transient unet needs to be destroyed --- */
 597
 598   if (u->f & UNIF_TRANS) {
 599     *u->prev = u->next;
 600     if (u->next)
 601       u->next->prev = u->prev;
 602     unet_kill(u);
 603     kfree(u);
 604     D( printk(KERN_DEBUG "unet: released transient unet\n"); )
 605   }
 606
 607   /* --- A persistent unet needs to be shutdown --- */
 608
 609   else {
 610     u->f &= ~UNIF_OPEN;
 611     unet_flush(u);
 612     DIF(u, printk(KERN_DEBUG "unet: unblocked persistent unet\n"); )
 613   }
 614
 615   MOD_DEC_USE_COUNT;
 616   return (0);
 617 }
 618
 619 /* --- @unet_devpoll@ --- *
 620  *
 621  * Arguments:   @struct file *f@ = pointer to my file block
 622  *              @struct poll_table_struct *p@ = poll table to wait on
 623  *
 624  * Returns:     Nonzero if OK to continue, zero if waiting.
 625  *
 626  * Use:         Plays a unet device's part in a @poll@(2) call.
 627  */
 628
 629 static unsigned unet_devpoll(struct file *f, struct poll_table_struct *p)
 630 {
 631   struct unet *u = f->private_data;
 632   unsigned m = 0;
 633
 634   DIF(u, printk(KERN_DEBUG "unet: poll request for %s\n", u->name); )
 635
 636   poll_wait(f, &u->q, p);
 637   if (skb_peek(&u->skbq))
 638     m |= POLLIN | POLLRDNORM;
 639   m |= POLLOUT | POLLWRNORM;
 640   return (m);
 641 }
 642
 643 /* --- @unet_devwrite@ --- *
 644  *
 645  * Arguments:   @struct file *f@ = pointer to the file block
 646  *              @char *buf@ = pointer to caller's buffer
 647  *              @size_t sz@ = size of data to send
 648  *              @loff_t *off@ = offset to set (ignored)
 649  *
 650  * Returns:     Number of bytes written, or error condition.
 651  *
 652  * Use:         Sends a packet of data.  No buffering is done.
 653  */
 654
 655 static ssize_t unet_devwrite(struct file *f, const char *buf, size_t sz,
 656                              loff_t *off)
 657 {
 658   struct unet *u = f->private_data;
 659   struct sk_buff *skb;
 660
 661   DIF(u, printk(KERN_DEBUG "unet: write request for %s\n", u->name); )
 662
 663   /* --- Dump the packet we're meant to send --- */
 664
 665 #ifdef UNET_DEBUG
 666   if (u->f & UNIF_DEBUG) {
 667     void *b = kmalloc(sz, GFP_KERNEL);
 668     if (b) {
 669       copy_from_user(b, buf, sz);
 670       unet_hexdump(KERN_DEBUG "      ", b, sz);
 671       kfree(b);
 672     } else
 673       printk(KERN_NOTICE "unet: not enough memory to dump block");
 674   }
 675 #endif
 676
 677   /* --- Allocate an skbuff for the block --- */
 678
 679   if ((skb = dev_alloc_skb(sz)) == 0) {
 680     printk(KERN_ERR "unet: failed to allocate skbuff\n");
 681     u->e.rx_dropped++;
 682     return (-ENOSR);
 683   }
 684
 685   /* --- Copy my data into the skbuff --- */
 686
 687   copy_from_user(skb_put(skb, sz), buf, sz);
 688   skb->dev = &u->nif;
 689   skb->mac.raw = skb->data;
 690   skb->protocol = u->protocol;
 691   netif_rx(skb);
 692   u->e.rx_packets++;
 693   return (sz);
 694 }
 695
 696 /* --- @unet_devread@ --- *
 697  *
 698  * Arguments:   @struct file *f@ = pointer to the file block
 699  *              @char *buf@ = pointer to caller's buffer
 700  *              @size_t sz@ = size of caller's buffer
 701  *              @loff_t *off@ = offset to set (ignored)
 702  *
 703  * Returns:     Number of bytes read, or error condition.
 704  *
 705  * Use:         Reads the next packet waiting for the device.
 706  */
 707
 708 static ssize_t unet_devread(struct file *f, char *buf, size_t sz,
 709                             loff_t *off)
 710 {
 711   struct unet *u = f->private_data;
 712   struct sk_buff *skb;
 713
 714   DIF(u, printk(KERN_DEBUG "unet: read request for %s\n", u->name); )
 715
 716   /* --- Is the user sane? --- *
 717    *
 718    * The UDP protocol returns immediately in response to a zero-length read,
 719    * and following this behaviour seems to cause `least surprise'.
 720    */
 721
 722   if (!sz)
 723     return (0);
 724
 725   /* --- Make sure there's a packet waiting for me --- */
 726
 727   if ((skb = skb_dequeue(&u->skbq)) == 0) {
 728     struct wait_queue wq = { current, 0 };
 729
 730     DIF(u, printk(KERN_DEBUG "unet: no packets waiting\n"); )
 731
 732     /* --- Check for nonblocking I/O --- */
 733
 734     if (f->f_flags & O_NONBLOCK) {
 735       DIF(u, printk(KERN_DEBUG "unet: nonblocking read: fail\n"); )
 736       return (-EWOULDBLOCK);
 737     }
 738
 739     /* --- Otherwise block until there's a packet --- */
 740
 741     current->state = TASK_INTERRUPTIBLE;
 742     add_wait_queue(&u->q, &wq);
 743
 744     do {
 745
 746       if (signal_pending(current)) {
 747
 748         DIF(u, printk(KERN_DEBUG "unet: interrupted by signal\n"); )
 749
 750         remove_wait_queue(&u->q, &wq);
 751         current->state = TASK_RUNNING;
 752         return (-ERESTARTSYS);
 753       }
 754
 755       DIF(u, printk(KERN_DEBUG "unet: blocking until packet arrives\n"); )
 756
 757       schedule();
 758
 759     } while ((skb = skb_dequeue(&u->skbq)) == 0);
 760
 761     remove_wait_queue(&u->q, &wq);
 762     current->state = TASK_RUNNING;
 763   }
 764
 765   DIF(u, printk(KERN_DEBUG "unet: found a packet\n"); )
 766
 767   /* --- There is now a packet waiting --- */
 768
 769   if (sz > skb->len)
 770     sz = skb->len;
 771   copy_to_user(buf, skb->data, sz);
 772   dev_kfree_skb(skb);
 773
 774   DIF(u, printk(KERN_DEBUG "unet: passed packet on to user\n"); )
 775
 776   return (sz);
 777 }
 778
 779 /* --- @unet_devioctl@ --- *
 780  *
 781  * Arguments:   @struct inode *ino@ = pointer to inode block
 782  *              @struct file *f@ = pointer to file block
 783  *              @unsigned int c@ = command code to execute
 784  *              @unsigned long arg@ = argument passed to me
 785  *
 786  * Returns:     Positive return value, or negative error condition.
 787  *
 788  * Use:         Performs miscellaneous operations on a unet device.
 789  */
 790
 791 static int unet_devioctl(struct inode *ino,
 792                          struct file *f,
 793                          unsigned int c,
 794                          unsigned long arg)
 795 {
 796   struct unet *u = f->private_data;
 797   int e = 0;
 798
 799   DIF(u, printk(KERN_DEBUG "unet: ioctl request for %s\n", u->name); )
 800
 801   switch (c) {
 802
 803     /* --- @FIONREAD@ --- *
 804      *
 805      * Caller wants to know how big the next packet will be.  Don't
 806      * disappoint.
 807      */
 808
 809     case FIONREAD: {
 810       struct sk_buff *skb = skb_peek(&u->skbq);
 811
 812       DIF(u, printk(KERN_DEBUG "unet: FIONREAD found %d bytes\n",
 813                     skb ? skb->len : 0); )
 814
 815       if (skb)
 816         e = skb->len;
 817     } break;
 818
 819     /* --- @UNIOCGINFO@ --- *
 820      *
 821      * Caller wants information about me.
 822      */
 823
 824     case UNIOCGINFO: {
 825       struct unet_info uni, *unip;
 826
 827       DIF(u, printk(KERN_DEBUG "unet: UNIOCGINFO called\n"); )
 828
 829       unip = (struct unet_info *)arg;
 830
 831       /* --- Special case --- *
 832        *
 833        * If the pointer is null, this call means `are you there?' and can
 834        * be used to check for a Usernet attachment.
 835        */
 836
 837       if (!unip)
 838         break;
 839
 840       /* --- Ensure that the area can be written to --- */
 841
 842       if ((e = verify_area(VERIFY_WRITE, unip, sizeof(*unip))) != 0)
 843         return (e);
 844
 845       /* --- Build the information block in memory --- */
 846
 847       memset(&uni, 0, sizeof(uni));     /* Paranoia */
 848       strncpy(uni.uni_ifname, u->name, UNET_NAMEMAX);
 849       uni.uni_mtu = u->nif.mtu;
 850       uni.uni_family = AF_INET;
 851       uni.uni_proto = ntohs(u->protocol);
 852       uni.uni_flags = u->f;
 853
 854       /* --- Copy it to the user and return --- */
 855
 856       copy_to_user(unip, &uni, sizeof(uni));
 857     } break;
 858
 859     /* --- @UNIOCSDEBUG@ --- */
 860
 861 #if UNET_DEBUG != UNET_DEBUGNEVER
 862     case UNIOCSDEBUG: {
 863       int n = !!arg;
 864       int o = !!(u->f & UNIF_DEBUG);
 865
 866       if (n || o) {
 867         printk(KERN_DEBUG "unet: UNIOCSDEBUG on %s: %s\n", u->name,
 868                (o && n) ? "debugging still on" :
 869                (!o && n) ? "debugging turned on" :
 870                (o && !n) ? "debugging turned off" :
 871                (!o && !n) ? "you can't see this message" :
 872                "Logic failure: universe exploding");
 873       }
 874       if (n)
 875         u->f |= UNIF_DEBUG;
 876       else
 877         u->f &= ~UNIF_DEBUG;
 878     } break;
 879 #endif
 880
 881     /* --- @UNIOCGPROTO@ and @UNIOCSPROTO@ --- */
 882
 883     case UNIOCGPROTO:
 884       D( printk(KERN_DEBUG "unet: UNIOCGPROTO on %s: read protocol: %d\n",
 885                 u->name, ntohs(u->protocol)); )
 886       e = ntohs(u->protocol);
 887       break;
 888     case UNIOCSPROTO:
 889       D( printk(KERN_DEBUG "unet: UNIOCSPROTO on %s: set protocol: %d\n",
 890                 u->name, (int)arg); )
 891       u->protocol = htons(arg);
 892       break;
 893
 894     /* --- @UNIOCGGDEBUG@ and @UNIOCSGDEBUG@ --- */
 895
 896     case UNIOCGGDEBUG:
 897       D( printk(KERN_DEBUG "unet: UNIOCGGDEBUG: get global debug: on\n"); )
 898 #if UNET_DEBUG == UNET_DEBUGRUNTIME
 899       e = unet_debug;
 900 #elif UNET_DEBUG == UNET_DEBUGALWAYS
 901       e = 1;
 902 #elif UNET_DEBUG == UNET_DEBUGNEVER
 903       e = 0;
 904 #endif
 905       break;
 906
 907 #if UNET_DEBUG == UNET_DEBUGRUNTIME
 908     case UNIOCSGDEBUG:
 909       printk(KERN_DEBUG "unet: UNIOCSGDEBUG: set global debug: %s\n",
 910              (arg && unet_debug) ? "debugging still on" :
 911              (!arg && unet_debug) ? "debugging turned off" :
 912              (arg && !unet_debug) ? "debugging turned on" :
 913              (!arg && !unet_debug) ? "you can't see this message" :
 914              "Logic failure: universe exploding");
 915       unet_debug = !!arg;
 916       break;
 917 #endif
 918
 919     /* --- @UNIOCDUMP@ --- */
 920
 921 #if UNET_DEBUG != UNET_DEBUGNEVER
 922     case UNIOCDUMP:
 923       D( unet_dumpBlock(u); )
 924       break;
 925 #endif
 926
 927     /* --- @UNIOCGMAXIF@ --- */
 928
 929     case UNIOCGMAXIF:
 930       D( printk(KERN_DEBUG "unet: UNIOCGMAXIF: unet_maxif = %d\n",
 931                 unet_maxif); )
 932       e = unet_maxif;
 933       break;
 934
 935     /* --- @UNIOCSMAXIF@ --- */
 936
 937     case UNIOCSMAXIF:
 938       e = -EINVAL;
 939       if (arg < unet_npersist || arg > INT_MAX)
 940         return (-EINVAL);
 941       for (u = unet_list; u; u = u->next) {
 942         if (u->seq >= unet_npersist)
 943           return (-EBUSY);
 944       }
 945       unet_maxif = arg;
 946       D( printk(KERN_DEBUG "unet: UNIOCSMAXIF: unet_maxif = %d\n",
 947                 unet_maxif); )
 948       break;
 949
 950     /* --- Everything else --- *
 951      *
 952      * You lose.
 953      */
 954
 955     default:
 956       D( printk(KERN_DEBUG "unet: unknown ioctl %08x\n", c); )
 957       e = -EINVAL;
 958   }
 959
 960   return (e);
 961 }
 962
 963 /*----- The unet device ---------------------------------------------------*/
 964
 965 /* --- Device operations --- */
 966
 967 struct file_operations unet_fops = {
 968   0,                                    /* unet_devlseek */
 969   unet_devread,
 970   unet_devwrite,
 971   0,                                    /* unet_devreaddir */
 972   unet_devpoll,
 973   unet_devioctl,
 974   0,                                    /* unet_devmmap */
 975   unet_devopen,
 976   0,                                    /* unet_flush */
 977   unet_devclose
 978 };
 979
 980 /*----- Initaliseation and shutdown ---------------------------------------*/
 981
 982 /* --- @unet_init@ --- *
 983  *
 984  * Arguments:   ---
 985  *
 986  * Returns:     Zero or error condition.
 987  *
 988  * Use:         Registers the unet device.
 989  */
 990
 991 __initfunc(int unet_init(void))
 992 {
 993   int e = 0;
 994   int i = 0;
 995
 996   /* --- Register my character device --- */
 997
 998   if ((e = register_chrdev(UNET_MAJOR, "unet", &unet_fops)) != 0) {
 999     printk(KERN_ERR "unet: can't claim major device %d\n", UNET_MAJOR);
1000     goto tidy_0;
1001   }
1002
1003   /* --- Make the persistent unet devices --- */
1004
1005   if ((unet_persistent = kmalloc(unet_npersist * sizeof(struct unet),
1006                                  GFP_KERNEL)) == 0) {
1007     printk(KERN_ERR "unet: can't allocate %i persistent unet blocks",
1008            unet_npersist);
1009     e = -ENOMEM;
1010     goto tidy_1;
1011   }
1012
1013   for (i = 0; i < unet_npersist; i++) {
1014     if ((e = unet_setup(&unet_persistent[i], i)) != 0) {
1015       printk(KERN_ERR "unet: can't create persistent unet %d\n", i);
1016       goto tidy_2;
1017     }
1018   }
1019
1020   /* --- Done --- */
1021
1022   D( unet_dump(); )
1023   return (0);
1024
1025   /* --- Some bad stuff happened --- */
1026
1027 tidy_2:
1028   while (i > 0) {
1029     i--;
1030     unregister_netdev(&unet_persistent[i].nif);
1031   }
1032   kfree(unet_persistent);
1033
1034 tidy_1:
1035   unregister_chrdev(UNET_MAJOR, "unet");
1036
1037 tidy_0:
1038   return (e);
1039 }
1040
1041 #ifdef MODULE
1042
1043 /* --- @init_module@ --- *
1044  *
1045  * Arguments:   ---
1046  *
1047  * Returns:     Zero or error condition.
1048  *
1049  * Use:         Initialises the unet kernel module.
1050  */
1051
1052 int init_module(void)
1053 {
1054   if (unet_npersist < 0 || unet_maxif < unet_npersist
1055 #if UNET_DEBUG == UNET_DEBUGRUNTIME
1056       || (unet_debug != 0 && unet_debug != 1)
1057 #endif
1058     )
1059     return (-EINVAL);
1060   return (unet_init());
1061 }
1062
1063 /* --- @cleanup_module@ --- *
1064  *
1065  * Arguments:   ---
1066  *
1067  * Returns:     ---
1068  *
1069  * Use:         Tidies up the unet module ready for it to be killed.
1070  */
1071
1072 void cleanup_module(void)
1073 {
1074   int i;
1075
1076   for (i = 0; i < unet_npersist; i++) {
1077     D( printk(KERN_DEBUG "unet: releasing persistent unet %d\n", i); )
1078     unet_kill(&unet_persistent[i]);
1079   }
1080   kfree(unet_persistent);
1081
1082   unregister_chrdev(UNET_MAJOR, "unet");
1083 }
1084
1085 #endif
1086
1087 /*----- That's all, folks -------------------------------------------------*/