net/irda/irnet/irnet_ppp.c

   1 /*
   2  *      IrNET protocol module : Synchronous PPP over an IrDA socket.
   3  *
   4  *              Jean II - HPL `00 - <jt@hpl.hp.com>
   5  *
   6  * This file implement the PPP interface and /dev/irnet character device.
   7  * The PPP interface hook to the ppp_generic module, handle all our
   8  *      relationship to the PPP code in the kernel (and by extension to pppd),
   9  *      and exchange PPP frames with this module (send/receive).
  10  * The /dev/irnet device is used primarily for 2 functions :
  11  *      1) as a stub for pppd (the ppp daemon), so that we can appropriately
  12  *      generate PPP sessions (we pretend we are a tty).
  13  *      2) as a control channel (write commands, read events)
  14  */
  15
  16 #include <linux/sched.h>
  17 #include <linux/smp_lock.h>
  18 #include "irnet_ppp.h"          /* Private header */
  19 /* Please put other headers in irnet.h - Thanks */
  20
  21 /* Generic PPP callbacks (to call us) */
  22 static struct ppp_channel_ops irnet_ppp_ops = {
  23         .start_xmit = ppp_irnet_send,
  24         .ioctl = ppp_irnet_ioctl
  25 };
  26
  27 /************************* CONTROL CHANNEL *************************/
  28 /*
  29  * When a pppd instance is not active on /dev/irnet, it acts as a control
  30  * channel.
  31  * Writing allow to set up the IrDA destination of the IrNET channel,
  32  * and any application may be read events happening in IrNET...
  33  */
  34
  35 /*------------------------------------------------------------------*/
  36 /*
  37  * Write is used to send a command to configure a IrNET channel
  38  * before it is open by pppd. The syntax is : "command argument"
  39  * Currently there is only two defined commands :
  40  *      o name : set the requested IrDA nickname of the IrNET peer.
  41  *      o addr : set the requested IrDA address of the IrNET peer.
  42  * Note : the code is crude, but effective...
  43  */
  44 static inline ssize_t
  45 irnet_ctrl_write(irnet_socket * ap,
  46                  const char __user *buf,
  47                  size_t         count)
  48 {
  49   char          command[IRNET_MAX_COMMAND];
  50   char *        start;          /* Current command being processed */
  51   char *        next;           /* Next command to process */
  52   int           length;         /* Length of current command */
  53
  54   DENTER(CTRL_TRACE, "(ap=0x%p, count=%Zd)\n", ap, count);
  55
  56   /* Check for overflow... */
  57   DABORT(count >= IRNET_MAX_COMMAND, -ENOMEM,
  58          CTRL_ERROR, "Too much data !!!\n");
  59
  60   /* Get the data in the driver */
  61   if(copy_from_user(command, buf, count))
  62     {
  63       DERROR(CTRL_ERROR, "Invalid user space pointer.\n");
  64       return -EFAULT;
  65     }
  66
  67   /* Safe terminate the string */
  68   command[count] = '\0';
  69   DEBUG(CTRL_INFO, "Command line received is ``%s'' (%Zd).\n",
  70         command, count);
  71
  72   /* Check every commands in the command line */
  73   next = command;
  74   while(next != NULL)
  75     {
  76       /* Look at the next command */
  77       start = next;
  78
  79         /* Scrap whitespaces before the command */
  80         start = skip_spaces(start);
  81
  82       /* ',' is our command separator */
  83       next = strchr(start, ',');
  84       if(next)
  85         {
  86           *next = '\0';                 /* Terminate command */
  87           length = next - start;        /* Length */
  88           next++;                       /* Skip the '\0' */
  89         }
  90       else
  91         length = strlen(start);
  92
  93       DEBUG(CTRL_INFO, "Found command ``%s'' (%d).\n", start, length);
  94
  95       /* Check if we recognised one of the known command
  96        * We can't use "switch" with strings, so hack with "continue" */
  97
  98       /* First command : name -> Requested IrDA nickname */
  99       if(!strncmp(start, "name", 4))
 100         {
 101           /* Copy the name only if is included and not "any" */
 102           if((length > 5) && (strcmp(start + 5, "any")))
 103             {
 104               /* Strip out trailing whitespaces */
 105               while(isspace(start[length - 1]))
 106                 length--;
 107
 108               /* Copy the name for later reuse */
 109               memcpy(ap->rname, start + 5, length - 5);
 110               ap->rname[length - 5] = '\0';
 111             }
 112           else
 113             ap->rname[0] = '\0';
 114           DEBUG(CTRL_INFO, "Got rname = ``%s''\n", ap->rname);
 115
 116           /* Restart the loop */
 117           continue;
 118         }
 119
 120       /* Second command : addr, daddr -> Requested IrDA destination address
 121        * Also process : saddr -> Requested IrDA source address */
 122       if((!strncmp(start, "addr", 4)) ||
 123          (!strncmp(start, "daddr", 5)) ||
 124          (!strncmp(start, "saddr", 5)))
 125         {
 126           __u32         addr = DEV_ADDR_ANY;
 127
 128           /* Copy the address only if is included and not "any" */
 129           if((length > 5) && (strcmp(start + 5, "any")))
 130             {
 131               char *    begp = start + 5;
 132               char *    endp;
 133
 134               /* Scrap whitespaces before the command */
 135               begp = skip_spaces(begp);
 136
 137               /* Convert argument to a number (last arg is the base) */
 138               addr = simple_strtoul(begp, &endp, 16);
 139               /* Has it worked  ? (endp should be start + length) */
 140               DABORT(endp <= (start + 5), -EINVAL,
 141                      CTRL_ERROR, "Invalid address.\n");
 142             }
 143           /* Which type of address ? */
 144           if(start[0] == 's')
 145             {
 146               /* Save it */
 147               ap->rsaddr = addr;
 148               DEBUG(CTRL_INFO, "Got rsaddr = %08x\n", ap->rsaddr);
 149             }
 150           else
 151             {
 152               /* Save it */
 153               ap->rdaddr = addr;
 154               DEBUG(CTRL_INFO, "Got rdaddr = %08x\n", ap->rdaddr);
 155             }
 156
 157           /* Restart the loop */
 158           continue;
 159         }
 160
 161       /* Other possible command : connect N (number of retries) */
 162
 163       /* No command matched -> Failed... */
 164       DABORT(1, -EINVAL, CTRL_ERROR, "Not a recognised IrNET command.\n");
 165     }
 166
 167   /* Success : we have parsed all commands successfully */
 168   return(count);
 169 }
 170
 171 #ifdef INITIAL_DISCOVERY
 172 /*------------------------------------------------------------------*/
 173 /*
 174  * Function irnet_get_discovery_log (self)
 175  *
 176  *    Query the content on the discovery log if not done
 177  *
 178  * This function query the current content of the discovery log
 179  * at the startup of the event channel and save it in the internal struct.
 180  */
 181 static void
 182 irnet_get_discovery_log(irnet_socket *  ap)
 183 {
 184   __u16         mask = irlmp_service_to_hint(S_LAN);
 185
 186   /* Ask IrLMP for the current discovery log */
 187   ap->discoveries = irlmp_get_discoveries(&ap->disco_number, mask,
 188                                           DISCOVERY_DEFAULT_SLOTS);
 189
 190   /* Check if the we got some results */
 191   if(ap->discoveries == NULL)
 192     ap->disco_number = -1;
 193
 194   DEBUG(CTRL_INFO, "Got the log (0x%p), size is %d\n",
 195         ap->discoveries, ap->disco_number);
 196 }
 197
 198 /*------------------------------------------------------------------*/
 199 /*
 200  * Function irnet_read_discovery_log (self, event)
 201  *
 202  *    Read the content on the discovery log
 203  *
 204  * This function dump the current content of the discovery log
 205  * at the startup of the event channel.
 206  * Return 1 if wrote an event on the control channel...
 207  *
 208  * State of the ap->disco_XXX variables :
 209  * Socket creation :  discoveries = NULL ; disco_index = 0 ; disco_number = 0
 210  * While reading :    discoveries = ptr  ; disco_index = X ; disco_number = Y
 211  * After reading :    discoveries = NULL ; disco_index = Y ; disco_number = -1
 212  */
 213 static inline int
 214 irnet_read_discovery_log(irnet_socket * ap,
 215                          char *         event)
 216 {
 217   int           done_event = 0;
 218
 219   DENTER(CTRL_TRACE, "(ap=0x%p, event=0x%p)\n",
 220          ap, event);
 221
 222   /* Test if we have some work to do or we have already finished */
 223   if(ap->disco_number == -1)
 224     {
 225       DEBUG(CTRL_INFO, "Already done\n");
 226       return 0;
 227     }
 228
 229   /* Test if it's the first time and therefore we need to get the log */
 230   if(ap->discoveries == NULL)
 231     irnet_get_discovery_log(ap);
 232
 233   /* Check if we have more item to dump */
 234   if(ap->disco_index < ap->disco_number)
 235     {
 236       /* Write an event */
 237       sprintf(event, "Found %08x (%s) behind %08x {hints %02X-%02X}\n",
 238               ap->discoveries[ap->disco_index].daddr,
 239               ap->discoveries[ap->disco_index].info,
 240               ap->discoveries[ap->disco_index].saddr,
 241               ap->discoveries[ap->disco_index].hints[0],
 242               ap->discoveries[ap->disco_index].hints[1]);
 243       DEBUG(CTRL_INFO, "Writing discovery %d : %s\n",
 244             ap->disco_index, ap->discoveries[ap->disco_index].info);
 245
 246       /* We have an event */
 247       done_event = 1;
 248       /* Next discovery */
 249       ap->disco_index++;
 250     }
 251
 252   /* Check if we have done the last item */
 253   if(ap->disco_index >= ap->disco_number)
 254     {
 255       /* No more items : remove the log and signal termination */
 256       DEBUG(CTRL_INFO, "Cleaning up log (0x%p)\n",
 257             ap->discoveries);
 258       if(ap->discoveries != NULL)
 259         {
 260           /* Cleanup our copy of the discovery log */
 261           kfree(ap->discoveries);
 262           ap->discoveries = NULL;
 263         }
 264       ap->disco_number = -1;
 265     }
 266
 267   return done_event;
 268 }
 269 #endif /* INITIAL_DISCOVERY */
 270
 271 /*------------------------------------------------------------------*/
 272 /*
 273  * Read is used to get IrNET events
 274  */
 275 static inline ssize_t
 276 irnet_ctrl_read(irnet_socket *  ap,
 277                 struct file *   file,
 278                 char __user *   buf,
 279                 size_t          count)
 280 {
 281   DECLARE_WAITQUEUE(wait, current);
 282   char          event[64];      /* Max event is 61 char */
 283   ssize_t       ret = 0;
 284
 285   DENTER(CTRL_TRACE, "(ap=0x%p, count=%Zd)\n", ap, count);
 286
 287   /* Check if we can write an event out in one go */
 288   DABORT(count < sizeof(event), -EOVERFLOW, CTRL_ERROR, "Buffer to small.\n");
 289
 290 #ifdef INITIAL_DISCOVERY
 291   /* Check if we have read the log */
 292   if(irnet_read_discovery_log(ap, event))
 293     {
 294       /* We have an event !!! Copy it to the user */
 295       if(copy_to_user(buf, event, strlen(event)))
 296         {
 297           DERROR(CTRL_ERROR, "Invalid user space pointer.\n");
 298           return -EFAULT;
 299         }
 300
 301       DEXIT(CTRL_TRACE, "\n");
 302       return(strlen(event));
 303     }
 304 #endif /* INITIAL_DISCOVERY */
 305
 306   /* Put ourselves on the wait queue to be woken up */
 307   add_wait_queue(&irnet_events.rwait, &wait);
 308   current->state = TASK_INTERRUPTIBLE;
 309   for(;;)
 310     {
 311       /* If there is unread events */
 312       ret = 0;
 313       if(ap->event_index != irnet_events.index)
 314         break;
 315       ret = -EAGAIN;
 316       if(file->f_flags & O_NONBLOCK)
 317         break;
 318       ret = -ERESTARTSYS;
 319       if(signal_pending(current))
 320         break;
 321       /* Yield and wait to be woken up */
 322       schedule();
 323     }
 324   current->state = TASK_RUNNING;
 325   remove_wait_queue(&irnet_events.rwait, &wait);
 326
 327   /* Did we got it ? */
 328   if(ret != 0)
 329     {
 330       /* No, return the error code */
 331       DEXIT(CTRL_TRACE, " - ret %Zd\n", ret);
 332       return ret;
 333     }
 334
 335   /* Which event is it ? */
 336   switch(irnet_events.log[ap->event_index].event)
 337     {
 338     case IRNET_DISCOVER:
 339       sprintf(event, "Discovered %08x (%s) behind %08x {hints %02X-%02X}\n",
 340               irnet_events.log[ap->event_index].daddr,
 341               irnet_events.log[ap->event_index].name,
 342               irnet_events.log[ap->event_index].saddr,
 343               irnet_events.log[ap->event_index].hints.byte[0],
 344               irnet_events.log[ap->event_index].hints.byte[1]);
 345       break;
 346     case IRNET_EXPIRE:
 347       sprintf(event, "Expired %08x (%s) behind %08x {hints %02X-%02X}\n",
 348               irnet_events.log[ap->event_index].daddr,
 349               irnet_events.log[ap->event_index].name,
 350               irnet_events.log[ap->event_index].saddr,
 351               irnet_events.log[ap->event_index].hints.byte[0],
 352               irnet_events.log[ap->event_index].hints.byte[1]);
 353       break;
 354     case IRNET_CONNECT_TO:
 355       sprintf(event, "Connected to %08x (%s) on ppp%d\n",
 356               irnet_events.log[ap->event_index].daddr,
 357               irnet_events.log[ap->event_index].name,
 358               irnet_events.log[ap->event_index].unit);
 359       break;
 360     case IRNET_CONNECT_FROM:
 361       sprintf(event, "Connection from %08x (%s) on ppp%d\n",
 362               irnet_events.log[ap->event_index].daddr,
 363               irnet_events.log[ap->event_index].name,
 364               irnet_events.log[ap->event_index].unit);
 365       break;
 366     case IRNET_REQUEST_FROM:
 367       sprintf(event, "Request from %08x (%s) behind %08x\n",
 368               irnet_events.log[ap->event_index].daddr,
 369               irnet_events.log[ap->event_index].name,
 370               irnet_events.log[ap->event_index].saddr);
 371       break;
 372     case IRNET_NOANSWER_FROM:
 373       sprintf(event, "No-answer from %08x (%s) on ppp%d\n",
 374               irnet_events.log[ap->event_index].daddr,
 375               irnet_events.log[ap->event_index].name,
 376               irnet_events.log[ap->event_index].unit);
 377       break;
 378     case IRNET_BLOCKED_LINK:
 379       sprintf(event, "Blocked link with %08x (%s) on ppp%d\n",
 380               irnet_events.log[ap->event_index].daddr,
 381               irnet_events.log[ap->event_index].name,
 382               irnet_events.log[ap->event_index].unit);
 383       break;
 384     case IRNET_DISCONNECT_FROM:
 385       sprintf(event, "Disconnection from %08x (%s) on ppp%d\n",
 386               irnet_events.log[ap->event_index].daddr,
 387               irnet_events.log[ap->event_index].name,
 388               irnet_events.log[ap->event_index].unit);
 389       break;
 390     case IRNET_DISCONNECT_TO:
 391       sprintf(event, "Disconnected to %08x (%s)\n",
 392               irnet_events.log[ap->event_index].daddr,
 393               irnet_events.log[ap->event_index].name);
 394       break;
 395     default:
 396       sprintf(event, "Bug\n");
 397     }
 398   /* Increment our event index */
 399   ap->event_index = (ap->event_index + 1) % IRNET_MAX_EVENTS;
 400
 401   DEBUG(CTRL_INFO, "Event is :%s", event);
 402
 403   /* Copy it to the user */
 404   if(copy_to_user(buf, event, strlen(event)))
 405     {
 406       DERROR(CTRL_ERROR, "Invalid user space pointer.\n");
 407       return -EFAULT;
 408     }
 409
 410   DEXIT(CTRL_TRACE, "\n");
 411   return(strlen(event));
 412 }
 413
 414 /*------------------------------------------------------------------*/
 415 /*
 416  * Poll : called when someone do a select on /dev/irnet.
 417  * Just check if there are new events...
 418  */
 419 static inline unsigned int
 420 irnet_ctrl_poll(irnet_socket *  ap,
 421                 struct file *   file,
 422                 poll_table *    wait)
 423 {
 424   unsigned int mask;
 425
 426   DENTER(CTRL_TRACE, "(ap=0x%p)\n", ap);
 427
 428   poll_wait(file, &irnet_events.rwait, wait);
 429   mask = POLLOUT | POLLWRNORM;
 430   /* If there is unread events */
 431   if(ap->event_index != irnet_events.index)
 432     mask |= POLLIN | POLLRDNORM;
 433 #ifdef INITIAL_DISCOVERY
 434   if(ap->disco_number != -1)
 435     {
 436       /* Test if it's the first time and therefore we need to get the log */
 437       if(ap->discoveries == NULL)
 438         irnet_get_discovery_log(ap);
 439       /* Recheck */
 440       if(ap->disco_number != -1)
 441         mask |= POLLIN | POLLRDNORM;
 442     }
 443 #endif /* INITIAL_DISCOVERY */
 444
 445   DEXIT(CTRL_TRACE, " - mask=0x%X\n", mask);
 446   return mask;
 447 }
 448
 449
 450 /*********************** FILESYSTEM CALLBACKS ***********************/
 451 /*
 452  * Implement the usual open, read, write functions that will be called
 453  * by the file system when some action is performed on /dev/irnet.
 454  * Most of those actions will in fact be performed by "pppd" or
 455  * the control channel, we just act as a redirector...
 456  */
 457
 458 /*------------------------------------------------------------------*/
 459 /*
 460  * Open : when somebody open /dev/irnet
 461  * We basically create a new instance of irnet and initialise it.
 462  */
 463 static int
 464 dev_irnet_open(struct inode *   inode,
 465                struct file *    file)
 466 {
 467   struct irnet_socket * ap;
 468   int                   err;
 469
 470   DENTER(FS_TRACE, "(file=0x%p)\n", file);
 471
 472 #ifdef SECURE_DEVIRNET
 473   /* This could (should?) be enforced by the permissions on /dev/irnet. */
 474   if(!capable(CAP_NET_ADMIN))
 475     return -EPERM;
 476 #endif /* SECURE_DEVIRNET */
 477
 478   /* Allocate a private structure for this IrNET instance */
 479   ap = kzalloc(sizeof(*ap), GFP_KERNEL);
 480   DABORT(ap == NULL, -ENOMEM, FS_ERROR, "Can't allocate struct irnet...\n");
 481
 482   lock_kernel();
 483   /* initialize the irnet structure */
 484   ap->file = file;
 485
 486   /* PPP channel setup */
 487   ap->ppp_open = 0;
 488   ap->chan.private = ap;
 489   ap->chan.ops = &irnet_ppp_ops;
 490   ap->chan.mtu = (2048 - TTP_MAX_HEADER - 2 - PPP_HDRLEN);
 491   ap->chan.hdrlen = 2 + TTP_MAX_HEADER;         /* for A/C + Max IrDA hdr */
 492   /* PPP parameters */
 493   ap->mru = (2048 - TTP_MAX_HEADER - 2 - PPP_HDRLEN);
 494   ap->xaccm[0] = ~0U;
 495   ap->xaccm[3] = 0x60000000U;
 496   ap->raccm = ~0U;
 497
 498   /* Setup the IrDA part... */
 499   err = irda_irnet_create(ap);
 500   if(err)
 501     {
 502       DERROR(FS_ERROR, "Can't setup IrDA link...\n");
 503       kfree(ap);
 504       unlock_kernel();
 505       return err;
 506     }
 507
 508   /* For the control channel */
 509   ap->event_index = irnet_events.index; /* Cancel all past events */
 510
 511   /* Put our stuff where we will be able to find it later */
 512   file->private_data = ap;
 513
 514   DEXIT(FS_TRACE, " - ap=0x%p\n", ap);
 515   unlock_kernel();
 516   return 0;
 517 }
 518
 519
 520 /*------------------------------------------------------------------*/
 521 /*
 522  * Close : when somebody close /dev/irnet
 523  * Destroy the instance of /dev/irnet
 524  */
 525 static int
 526 dev_irnet_close(struct inode *  inode,
 527                 struct file *   file)
 528 {
 529   irnet_socket *        ap = (struct irnet_socket *) file->private_data;
 530
 531   DENTER(FS_TRACE, "(file=0x%p, ap=0x%p)\n",
 532          file, ap);
 533   DABORT(ap == NULL, 0, FS_ERROR, "ap is NULL !!!\n");
 534
 535   /* Detach ourselves */
 536   file->private_data = NULL;
 537
 538   /* Close IrDA stuff */
 539   irda_irnet_destroy(ap);
 540
 541   /* Disconnect from the generic PPP layer if not already done */
 542   if(ap->ppp_open)
 543     {
 544       DERROR(FS_ERROR, "Channel still registered - deregistering !\n");
 545       ap->ppp_open = 0;
 546       ppp_unregister_channel(&ap->chan);
 547     }
 548
 549   kfree(ap);
 550
 551   DEXIT(FS_TRACE, "\n");
 552   return 0;
 553 }
 554
 555 /*------------------------------------------------------------------*/
 556 /*
 557  * Write does nothing.
 558  * (we receive packet from ppp_generic through ppp_irnet_send())
 559  */
 560 static ssize_t
 561 dev_irnet_write(struct file *   file,
 562                 const char __user *buf,
 563                 size_t          count,
 564                 loff_t *        ppos)
 565 {
 566   irnet_socket *        ap = (struct irnet_socket *) file->private_data;
 567
 568   DPASS(FS_TRACE, "(file=0x%p, ap=0x%p, count=%Zd)\n",
 569         file, ap, count);
 570   DABORT(ap == NULL, -ENXIO, FS_ERROR, "ap is NULL !!!\n");
 571
 572   /* If we are connected to ppp_generic, let it handle the job */
 573   if(ap->ppp_open)
 574     return -EAGAIN;
 575   else
 576     return irnet_ctrl_write(ap, buf, count);
 577 }
 578
 579 /*------------------------------------------------------------------*/
 580 /*
 581  * Read doesn't do much either.
 582  * (pppd poll us, but ultimately reads through /dev/ppp)
 583  */
 584 static ssize_t
 585 dev_irnet_read(struct file *    file,
 586                char __user *    buf,
 587                size_t           count,
 588                loff_t *         ppos)
 589 {
 590   irnet_socket *        ap = (struct irnet_socket *) file->private_data;
 591
 592   DPASS(FS_TRACE, "(file=0x%p, ap=0x%p, count=%Zd)\n",
 593         file, ap, count);
 594   DABORT(ap == NULL, -ENXIO, FS_ERROR, "ap is NULL !!!\n");
 595
 596   /* If we are connected to ppp_generic, let it handle the job */
 597   if(ap->ppp_open)
 598     return -EAGAIN;
 599   else
 600     return irnet_ctrl_read(ap, file, buf, count);
 601 }
 602
 603 /*------------------------------------------------------------------*/
 604 /*
 605  * Poll : called when someone do a select on /dev/irnet
 606  */
 607 static unsigned int
 608 dev_irnet_poll(struct file *    file,
 609                poll_table *     wait)
 610 {
 611   irnet_socket *        ap = (struct irnet_socket *) file->private_data;
 612   unsigned int          mask;
 613
 614   DENTER(FS_TRACE, "(file=0x%p, ap=0x%p)\n",
 615          file, ap);
 616
 617   mask = POLLOUT | POLLWRNORM;
 618   DABORT(ap == NULL, mask, FS_ERROR, "ap is NULL !!!\n");
 619
 620   /* If we are connected to ppp_generic, let it handle the job */
 621   if(!ap->ppp_open)
 622     mask |= irnet_ctrl_poll(ap, file, wait);
 623
 624   DEXIT(FS_TRACE, " - mask=0x%X\n", mask);
 625   return(mask);
 626 }
 627
 628 /*------------------------------------------------------------------*/
 629 /*
 630  * IOCtl : Called when someone does some ioctls on /dev/irnet
 631  * This is the way pppd configure us and control us while the PPP
 632  * instance is active.
 633  */
 634 static long
 635 dev_irnet_ioctl(
 636                 struct file *   file,
 637                 unsigned int    cmd,
 638                 unsigned long   arg)
 639 {
 640   irnet_socket *        ap = (struct irnet_socket *) file->private_data;
 641   int                   err;
 642   int                   val;
 643   void __user *argp = (void __user *)arg;
 644
 645   DENTER(FS_TRACE, "(file=0x%p, ap=0x%p, cmd=0x%X)\n",
 646          file, ap, cmd);
 647
 648   /* Basic checks... */
 649   DASSERT(ap != NULL, -ENXIO, PPP_ERROR, "ap is NULL...\n");
 650 #ifdef SECURE_DEVIRNET
 651   if(!capable(CAP_NET_ADMIN))
 652     return -EPERM;
 653 #endif /* SECURE_DEVIRNET */
 654
 655   err = -EFAULT;
 656   switch(cmd)
 657     {
 658       /* Set discipline (should be N_SYNC_PPP or N_TTY) */
 659     case TIOCSETD:
 660       if(get_user(val, (int __user *)argp))
 661         break;
 662       if((val == N_SYNC_PPP) || (val == N_PPP))
 663         {
 664           DEBUG(FS_INFO, "Entering PPP discipline.\n");
 665           /* PPP channel setup (ap->chan in configued in dev_irnet_open())*/
 666           lock_kernel();
 667           err = ppp_register_channel(&ap->chan);
 668           if(err == 0)
 669             {
 670               /* Our ppp side is active */
 671               ap->ppp_open = 1;
 672
 673               DEBUG(FS_INFO, "Trying to establish a connection.\n");
 674               /* Setup the IrDA link now - may fail... */
 675               irda_irnet_connect(ap);
 676             }
 677           else
 678             DERROR(FS_ERROR, "Can't setup PPP channel...\n");
 679           unlock_kernel();
 680         }
 681       else
 682         {
 683           /* In theory, should be N_TTY */
 684           DEBUG(FS_INFO, "Exiting PPP discipline.\n");
 685           /* Disconnect from the generic PPP layer */
 686           lock_kernel();
 687           if(ap->ppp_open)
 688             {
 689               ap->ppp_open = 0;
 690               ppp_unregister_channel(&ap->chan);
 691             }
 692           else
 693             DERROR(FS_ERROR, "Channel not registered !\n");
 694           err = 0;
 695           unlock_kernel();
 696         }
 697       break;
 698
 699       /* Query PPP channel and unit number */
 700     case PPPIOCGCHAN:
 701       lock_kernel();
 702       if(ap->ppp_open && !put_user(ppp_channel_index(&ap->chan),
 703                                                 (int __user *)argp))
 704         err = 0;
 705       unlock_kernel();
 706       break;
 707     case PPPIOCGUNIT:
 708       lock_kernel();
 709       if(ap->ppp_open && !put_user(ppp_unit_number(&ap->chan),
 710                                                 (int __user *)argp))
 711         err = 0;
 712       unlock_kernel();
 713       break;
 714
 715       /* All these ioctls can be passed both directly and from ppp_generic,
 716        * so we just deal with them in one place...
 717        */
 718     case PPPIOCGFLAGS:
 719     case PPPIOCSFLAGS:
 720     case PPPIOCGASYNCMAP:
 721     case PPPIOCSASYNCMAP:
 722     case PPPIOCGRASYNCMAP:
 723     case PPPIOCSRASYNCMAP:
 724     case PPPIOCGXASYNCMAP:
 725     case PPPIOCSXASYNCMAP:
 726     case PPPIOCGMRU:
 727     case PPPIOCSMRU:
 728       DEBUG(FS_INFO, "Standard PPP ioctl.\n");
 729       if(!capable(CAP_NET_ADMIN))
 730         err = -EPERM;
 731       else {
 732         lock_kernel();
 733         err = ppp_irnet_ioctl(&ap->chan, cmd, arg);
 734         unlock_kernel();
 735       }
 736       break;
 737
 738       /* TTY IOCTLs : Pretend that we are a tty, to keep pppd happy */
 739       /* Get termios */
 740     case TCGETS:
 741       DEBUG(FS_INFO, "Get termios.\n");
 742       lock_kernel();
 743 #ifndef TCGETS2
 744       if(!kernel_termios_to_user_termios((struct termios __user *)argp, &ap->termios))
 745         err = 0;
 746 #else
 747       if(kernel_termios_to_user_termios_1((struct termios __user *)argp, &ap->termios))
 748         err = 0;
 749 #endif
 750       unlock_kernel();
 751       break;
 752       /* Set termios */
 753     case TCSETSF:
 754       DEBUG(FS_INFO, "Set termios.\n");
 755       lock_kernel();
 756 #ifndef TCGETS2
 757       if(!user_termios_to_kernel_termios(&ap->termios, (struct termios __user *)argp))
 758         err = 0;
 759 #else
 760       if(!user_termios_to_kernel_termios_1(&ap->termios, (struct termios __user *)argp))
 761         err = 0;
 762 #endif
 763       unlock_kernel();
 764       break;
 765
 766       /* Set DTR/RTS */
 767     case TIOCMBIS:
 768     case TIOCMBIC:
 769       /* Set exclusive/non-exclusive mode */
 770     case TIOCEXCL:
 771     case TIOCNXCL:
 772       DEBUG(FS_INFO, "TTY compatibility.\n");
 773       err = 0;
 774       break;
 775
 776     case TCGETA:
 777       DEBUG(FS_INFO, "TCGETA\n");
 778       break;
 779
 780     case TCFLSH:
 781       DEBUG(FS_INFO, "TCFLSH\n");
 782       /* Note : this will flush buffers in PPP, so it *must* be done
 783        * We should also worry that we don't accept junk here and that
 784        * we get rid of our own buffers */
 785 #ifdef FLUSH_TO_PPP
 786       lock_kernel();
 787       ppp_output_wakeup(&ap->chan);
 788       unlock_kernel();
 789 #endif /* FLUSH_TO_PPP */
 790       err = 0;
 791       break;
 792
 793     case FIONREAD:
 794       DEBUG(FS_INFO, "FIONREAD\n");
 795       val = 0;
 796       if(put_user(val, (int __user *)argp))
 797         break;
 798       err = 0;
 799       break;
 800
 801     default:
 802       DERROR(FS_ERROR, "Unsupported ioctl (0x%X)\n", cmd);
 803       err = -ENOTTY;
 804     }
 805
 806   DEXIT(FS_TRACE, " - err = 0x%X\n", err);
 807   return err;
 808 }
 809
 810 /************************** PPP CALLBACKS **************************/
 811 /*
 812  * This are the functions that the generic PPP driver in the kernel
 813  * will call to communicate to us.
 814  */
 815
 816 /*------------------------------------------------------------------*/
 817 /*
 818  * Prepare the ppp frame for transmission over the IrDA socket.
 819  * We make sure that the header space is enough, and we change ppp header
 820  * according to flags passed by pppd.
 821  * This is not a callback, but just a helper function used in ppp_irnet_send()
 822  */
 823 static inline struct sk_buff *
 824 irnet_prepare_skb(irnet_socket *        ap,
 825                   struct sk_buff *      skb)
 826 {
 827   unsigned char *       data;
 828   int                   proto;          /* PPP protocol */
 829   int                   islcp;          /* Protocol == LCP */
 830   int                   needaddr;       /* Need PPP address */
 831
 832   DENTER(PPP_TRACE, "(ap=0x%p, skb=0x%p)\n",
 833          ap, skb);
 834
 835   /* Extract PPP protocol from the frame */
 836   data  = skb->data;
 837   proto = (data[0] << 8) + data[1];
 838
 839   /* LCP packets with codes between 1 (configure-request)
 840    * and 7 (code-reject) must be sent as though no options
 841    * have been negotiated. */
 842   islcp = (proto == PPP_LCP) && (1 <= data[2]) && (data[2] <= 7);
 843
 844   /* compress protocol field if option enabled */
 845   if((data[0] == 0) && (ap->flags & SC_COMP_PROT) && (!islcp))
 846     skb_pull(skb,1);
 847
 848   /* Check if we need address/control fields */
 849   needaddr = 2*((ap->flags & SC_COMP_AC) == 0 || islcp);
 850
 851   /* Is the skb headroom large enough to contain all IrDA-headers? */
 852   if((skb_headroom(skb) < (ap->max_header_size + needaddr)) ||
 853       (skb_shared(skb)))
 854     {
 855       struct sk_buff *  new_skb;
 856
 857       DEBUG(PPP_INFO, "Reallocating skb\n");
 858
 859       /* Create a new skb */
 860       new_skb = skb_realloc_headroom(skb, ap->max_header_size + needaddr);
 861
 862       /* We have to free the original skb anyway */
 863       dev_kfree_skb(skb);
 864
 865       /* Did the realloc succeed ? */
 866       DABORT(new_skb == NULL, NULL, PPP_ERROR, "Could not realloc skb\n");
 867
 868       /* Use the new skb instead */
 869       skb = new_skb;
 870     }
 871
 872   /* prepend address/control fields if necessary */
 873   if(needaddr)
 874     {
 875       skb_push(skb, 2);
 876       skb->data[0] = PPP_ALLSTATIONS;
 877       skb->data[1] = PPP_UI;
 878     }
 879
 880   DEXIT(PPP_TRACE, "\n");
 881
 882   return skb;
 883 }
 884
 885 /*------------------------------------------------------------------*/
 886 /*
 887  * Send a packet to the peer over the IrTTP connection.
 888  * Returns 1 iff the packet was accepted.
 889  * Returns 0 iff packet was not consumed.
 890  * If the packet was not accepted, we will call ppp_output_wakeup
 891  * at some later time to reactivate flow control in ppp_generic.
 892  */
 893 static int
 894 ppp_irnet_send(struct ppp_channel *     chan,
 895                struct sk_buff *         skb)
 896 {
 897   irnet_socket *        self = (struct irnet_socket *) chan->private;
 898   int                   ret;
 899
 900   DENTER(PPP_TRACE, "(channel=0x%p, ap/self=0x%p)\n",
 901          chan, self);
 902
 903   /* Check if things are somewhat valid... */
 904   DASSERT(self != NULL, 0, PPP_ERROR, "Self is NULL !!!\n");
 905
 906   /* Check if we are connected */
 907   if(!(test_bit(0, &self->ttp_open)))
 908     {
 909 #ifdef CONNECT_IN_SEND
 910       /* Let's try to connect one more time... */
 911       /* Note : we won't be connected after this call, but we should be
 912        * ready for next packet... */
 913       /* If we are already connecting, this will fail */
 914       irda_irnet_connect(self);
 915 #endif /* CONNECT_IN_SEND */
 916
 917       DEBUG(PPP_INFO, "IrTTP not ready ! (%ld-%ld)\n",
 918             self->ttp_open, self->ttp_connect);
 919
 920       /* Note : we can either drop the packet or block the packet.
 921        *
 922        * Blocking the packet allow us a better connection time,
 923        * because by calling ppp_output_wakeup() we can have
 924        * ppp_generic resending the LCP request immediately to us,
 925        * rather than waiting for one of pppd periodic transmission of
 926        * LCP request.
 927        *
 928        * On the other hand, if we block all packet, all those periodic
 929        * transmissions of pppd accumulate in ppp_generic, creating a
 930        * backlog of LCP request. When we eventually connect later on,
 931        * we have to transmit all this backlog before we can connect
 932        * proper (if we don't timeout before).
 933        *
 934        * The current strategy is as follow :
 935        * While we are attempting to connect, we block packets to get
 936        * a better connection time.
 937        * If we fail to connect, we drain the queue and start dropping packets
 938        */
 939 #ifdef BLOCK_WHEN_CONNECT
 940       /* If we are attempting to connect */
 941       if(test_bit(0, &self->ttp_connect))
 942         {
 943           /* Blocking packet, ppp_generic will retry later */
 944           return 0;
 945         }
 946 #endif /* BLOCK_WHEN_CONNECT */
 947
 948       /* Dropping packet, pppd will retry later */
 949       dev_kfree_skb(skb);
 950       return 1;
 951     }
 952
 953   /* Check if the queue can accept any packet, otherwise block */
 954   if(self->tx_flow != FLOW_START)
 955     DRETURN(0, PPP_INFO, "IrTTP queue full (%d skbs)...\n",
 956             skb_queue_len(&self->tsap->tx_queue));
 957
 958   /* Prepare ppp frame for transmission */
 959   skb = irnet_prepare_skb(self, skb);
 960   DABORT(skb == NULL, 1, PPP_ERROR, "Prepare skb for Tx failed.\n");
 961
 962   /* Send the packet to IrTTP */
 963   ret = irttp_data_request(self->tsap, skb);
 964   if(ret < 0)
 965     {
 966       /*
 967        * > IrTTPs tx queue is full, so we just have to
 968        * > drop the frame! You might think that we should
 969        * > just return -1 and don't deallocate the frame,
 970        * > but that is dangerous since it's possible that
 971        * > we have replaced the original skb with a new
 972        * > one with larger headroom, and that would really
 973        * > confuse do_dev_queue_xmit() in dev.c! I have
 974        * > tried :-) DB
 975        * Correction : we verify the flow control above (self->tx_flow),
 976        * so we come here only if IrTTP doesn't like the packet (empty,
 977        * too large, IrTTP not connected). In those rare cases, it's ok
 978        * to drop it, we don't want to see it here again...
 979        * Jean II
 980        */
 981       DERROR(PPP_ERROR, "IrTTP doesn't like this packet !!! (0x%X)\n", ret);
 982       /* irttp_data_request already free the packet */
 983     }
 984
 985   DEXIT(PPP_TRACE, "\n");
 986   return 1;     /* Packet has been consumed */
 987 }
 988
 989 /*------------------------------------------------------------------*/
 990 /*
 991  * Take care of the ioctls that ppp_generic doesn't want to deal with...
 992  * Note : we are also called from dev_irnet_ioctl().
 993  */
 994 static int
 995 ppp_irnet_ioctl(struct ppp_channel *    chan,
 996                 unsigned int            cmd,
 997                 unsigned long           arg)
 998 {
 999   irnet_socket *        ap = (struct irnet_socket *) chan->private;
1000   int                   err;
1001   int                   val;
1002   u32                   accm[8];
1003   void __user *argp = (void __user *)arg;
1004
1005   DENTER(PPP_TRACE, "(channel=0x%p, ap=0x%p, cmd=0x%X)\n",
1006          chan, ap, cmd);
1007
1008   /* Basic checks... */
1009   DASSERT(ap != NULL, -ENXIO, PPP_ERROR, "ap is NULL...\n");
1010
1011   err = -EFAULT;
1012   switch(cmd)
1013     {
1014       /* PPP flags */
1015     case PPPIOCGFLAGS:
1016       val = ap->flags | ap->rbits;
1017       if(put_user(val, (int __user *) argp))
1018         break;
1019       err = 0;
1020       break;
1021     case PPPIOCSFLAGS:
1022       if(get_user(val, (int __user *) argp))
1023         break;
1024       ap->flags = val & ~SC_RCV_BITS;
1025       ap->rbits = val & SC_RCV_BITS;
1026       err = 0;
1027       break;
1028
1029       /* Async map stuff - all dummy to please pppd */
1030     case PPPIOCGASYNCMAP:
1031       if(put_user(ap->xaccm[0], (u32 __user *) argp))
1032         break;
1033       err = 0;
1034       break;
1035     case PPPIOCSASYNCMAP:
1036       if(get_user(ap->xaccm[0], (u32 __user *) argp))
1037         break;
1038       err = 0;
1039       break;
1040     case PPPIOCGRASYNCMAP:
1041       if(put_user(ap->raccm, (u32 __user *) argp))
1042         break;
1043       err = 0;
1044       break;
1045     case PPPIOCSRASYNCMAP:
1046       if(get_user(ap->raccm, (u32 __user *) argp))
1047         break;
1048       err = 0;
1049       break;
1050     case PPPIOCGXASYNCMAP:
1051       if(copy_to_user(argp, ap->xaccm, sizeof(ap->xaccm)))
1052         break;
1053       err = 0;
1054       break;
1055     case PPPIOCSXASYNCMAP:
1056       if(copy_from_user(accm, argp, sizeof(accm)))
1057         break;
1058       accm[2] &= ~0x40000000U;          /* can't escape 0x5e */
1059       accm[3] |= 0x60000000U;           /* must escape 0x7d, 0x7e */
1060       memcpy(ap->xaccm, accm, sizeof(ap->xaccm));
1061       err = 0;
1062       break;
1063
1064       /* Max PPP frame size */
1065     case PPPIOCGMRU:
1066       if(put_user(ap->mru, (int __user *) argp))
1067         break;
1068       err = 0;
1069       break;
1070     case PPPIOCSMRU:
1071       if(get_user(val, (int __user *) argp))
1072         break;
1073       if(val < PPP_MRU)
1074         val = PPP_MRU;
1075       ap->mru = val;
1076       err = 0;
1077       break;
1078
1079     default:
1080       DEBUG(PPP_INFO, "Unsupported ioctl (0x%X)\n", cmd);
1081       err = -ENOIOCTLCMD;
1082     }
1083
1084   DEXIT(PPP_TRACE, " - err = 0x%X\n", err);
1085   return err;
1086 }
1087
1088 /************************** INITIALISATION **************************/
1089 /*
1090  * Module initialisation and all that jazz...
1091  */
1092
1093 /*------------------------------------------------------------------*/
1094 /*
1095  * Hook our device callbacks in the filesystem, to connect our code
1096  * to /dev/irnet
1097  */
1098 static inline int __init
1099 ppp_irnet_init(void)
1100 {
1101   int err = 0;
1102
1103   DENTER(MODULE_TRACE, "()\n");
1104
1105   /* Allocate ourselves as a minor in the misc range */
1106   err = misc_register(&irnet_misc_device);
1107
1108   DEXIT(MODULE_TRACE, "\n");
1109   return err;
1110 }
1111
1112 /*------------------------------------------------------------------*/
1113 /*
1114  * Cleanup at exit...
1115  */
1116 static inline void __exit
1117 ppp_irnet_cleanup(void)
1118 {
1119   DENTER(MODULE_TRACE, "()\n");
1120
1121   /* De-allocate /dev/irnet minor in misc range */
1122   misc_deregister(&irnet_misc_device);
1123
1124   DEXIT(MODULE_TRACE, "\n");
1125 }
1126
1127 /*------------------------------------------------------------------*/
1128 /*
1129  * Module main entry point
1130  */
1131 static int __init
1132 irnet_init(void)
1133 {
1134   int err;
1135
1136   /* Initialise both parts... */
1137   err = irda_irnet_init();
1138   if(!err)
1139     err = ppp_irnet_init();
1140   return err;
1141 }
1142
1143 /*------------------------------------------------------------------*/
1144 /*
1145  * Module exit
1146  */
1147 static void __exit
1148 irnet_cleanup(void)
1149 {
1150   irda_irnet_cleanup();
1151   ppp_irnet_cleanup();
1152 }
1153
1154 /*------------------------------------------------------------------*/
1155 /*
1156  * Module magic
1157  */
1158 module_init(irnet_init);
1159 module_exit(irnet_cleanup);
1160 MODULE_AUTHOR("Jean Tourrilhes <jt@hpl.hp.com>");
1161 MODULE_DESCRIPTION("IrNET : Synchronous PPP over IrDA");
1162 MODULE_LICENSE("GPL");
1163 MODULE_ALIAS_CHARDEV(10, 187);