blob: 156020d138b507685633feda14fa747d11c90538 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Alexey Dobriyand43c36d2009-10-07 17:09:06 +040016#include <linux/sched.h>
Alexey Dobriyan405f5572009-07-11 22:08:37 +040017#include <linux/smp_lock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include "irnet_ppp.h" /* Private header */
19/* Please put other headers in irnet.h - Thanks */
20
21/* Generic PPP callbacks (to call us) */
22static 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 */
44static inline ssize_t
45irnet_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
André Goddard Rosae7d28602009-12-14 18:01:06 -080079 /* Scrap whitespaces before the command */
80 start = skip_spaces(start);
Linus Torvalds1da177e2005-04-16 15:20:36 -070081
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" */
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +090097
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 /* 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 */
André Goddard Rosae7d28602009-12-14 18:01:06 -0800135 begp = skip_spaces(begp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136
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 */
181static void
182irnet_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 */
213static inline int
214irnet_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 */
275static inline ssize_t
276irnet_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 */
419static inline unsigned int
420irnet_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 */
463static int
464dev_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 */
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700479 ap = kzalloc(sizeof(*ap), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 DABORT(ap == NULL, -ENOMEM, FS_ERROR, "Can't allocate struct irnet...\n");
481
Arnd Bergmanncddf63d2008-05-20 19:16:06 +0200482 lock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 /* initialize the irnet structure */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 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);
Arnd Bergmanncddf63d2008-05-20 19:16:06 +0200504 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 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);
Arnd Bergmanncddf63d2008-05-20 19:16:06 +0200515 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 return 0;
517}
518
519
520/*------------------------------------------------------------------*/
521/*
522 * Close : when somebody close /dev/irnet
523 * Destroy the instance of /dev/irnet
524 */
525static int
526dev_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 */
560static ssize_t
561dev_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 */
584static ssize_t
585dev_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 */
607static unsigned int
608dev_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 */
Alan Cox54064602008-05-25 23:43:11 -0700634static long
635dev_irnet_ioctl(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 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())*/
Alan Cox54064602008-05-25 23:43:11 -0700666 lock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 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");
Alan Cox54064602008-05-25 23:43:11 -0700679 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 }
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 */
Alan Cox54064602008-05-25 23:43:11 -0700686 lock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 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;
Alan Cox54064602008-05-25 23:43:11 -0700695 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 }
697 break;
698
699 /* Query PPP channel and unit number */
700 case PPPIOCGCHAN:
Alan Cox54064602008-05-25 23:43:11 -0700701 if(ap->ppp_open && !put_user(ppp_channel_index(&ap->chan),
702 (int __user *)argp))
703 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 break;
705 case PPPIOCGUNIT:
Alan Cox54064602008-05-25 23:43:11 -0700706 lock_kernel();
707 if(ap->ppp_open && !put_user(ppp_unit_number(&ap->chan),
708 (int __user *)argp))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 err = 0;
710 break;
711
712 /* All these ioctls can be passed both directly and from ppp_generic,
713 * so we just deal with them in one place...
714 */
715 case PPPIOCGFLAGS:
716 case PPPIOCSFLAGS:
717 case PPPIOCGASYNCMAP:
718 case PPPIOCSASYNCMAP:
719 case PPPIOCGRASYNCMAP:
720 case PPPIOCSRASYNCMAP:
721 case PPPIOCGXASYNCMAP:
722 case PPPIOCSXASYNCMAP:
723 case PPPIOCGMRU:
724 case PPPIOCSMRU:
725 DEBUG(FS_INFO, "Standard PPP ioctl.\n");
726 if(!capable(CAP_NET_ADMIN))
727 err = -EPERM;
Alan Cox54064602008-05-25 23:43:11 -0700728 else {
729 lock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 err = ppp_irnet_ioctl(&ap->chan, cmd, arg);
Alan Cox54064602008-05-25 23:43:11 -0700731 unlock_kernel();
732 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 break;
734
735 /* TTY IOCTLs : Pretend that we are a tty, to keep pppd happy */
736 /* Get termios */
737 case TCGETS:
738 DEBUG(FS_INFO, "Get termios.\n");
Alan Cox54064602008-05-25 23:43:11 -0700739 lock_kernel();
David S. Miller49259d32007-11-01 02:26:38 -0700740#ifndef TCGETS2
Alan Cox54064602008-05-25 23:43:11 -0700741 if(!kernel_termios_to_user_termios((struct termios __user *)argp, &ap->termios))
742 err = 0;
David S. Miller49259d32007-11-01 02:26:38 -0700743#else
744 if(kernel_termios_to_user_termios_1((struct termios __user *)argp, &ap->termios))
Alan Cox54064602008-05-25 23:43:11 -0700745 err = 0;
David S. Miller49259d32007-11-01 02:26:38 -0700746#endif
Alan Cox54064602008-05-25 23:43:11 -0700747 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 break;
749 /* Set termios */
750 case TCSETSF:
751 DEBUG(FS_INFO, "Set termios.\n");
Alan Cox54064602008-05-25 23:43:11 -0700752 lock_kernel();
David S. Miller49259d32007-11-01 02:26:38 -0700753#ifndef TCGETS2
Alan Cox54064602008-05-25 23:43:11 -0700754 if(!user_termios_to_kernel_termios(&ap->termios, (struct termios __user *)argp))
755 err = 0;
David S. Miller49259d32007-11-01 02:26:38 -0700756#else
Alan Cox54064602008-05-25 23:43:11 -0700757 if(!user_termios_to_kernel_termios_1(&ap->termios, (struct termios __user *)argp))
758 err = 0;
David S. Miller49259d32007-11-01 02:26:38 -0700759#endif
Alan Cox54064602008-05-25 23:43:11 -0700760 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 break;
762
763 /* Set DTR/RTS */
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900764 case TIOCMBIS:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 case TIOCMBIC:
766 /* Set exclusive/non-exclusive mode */
767 case TIOCEXCL:
768 case TIOCNXCL:
769 DEBUG(FS_INFO, "TTY compatibility.\n");
770 err = 0;
771 break;
772
773 case TCGETA:
774 DEBUG(FS_INFO, "TCGETA\n");
775 break;
776
777 case TCFLSH:
778 DEBUG(FS_INFO, "TCFLSH\n");
779 /* Note : this will flush buffers in PPP, so it *must* be done
780 * We should also worry that we don't accept junk here and that
781 * we get rid of our own buffers */
782#ifdef FLUSH_TO_PPP
Alan Cox54064602008-05-25 23:43:11 -0700783 lock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 ppp_output_wakeup(&ap->chan);
Alan Cox54064602008-05-25 23:43:11 -0700785 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786#endif /* FLUSH_TO_PPP */
787 err = 0;
788 break;
789
790 case FIONREAD:
791 DEBUG(FS_INFO, "FIONREAD\n");
792 val = 0;
793 if(put_user(val, (int __user *)argp))
794 break;
795 err = 0;
796 break;
797
798 default:
799 DERROR(FS_ERROR, "Unsupported ioctl (0x%X)\n", cmd);
Alan Cox54064602008-05-25 23:43:11 -0700800 err = -ENOTTY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 }
802
803 DEXIT(FS_TRACE, " - err = 0x%X\n", err);
804 return err;
805}
806
807/************************** PPP CALLBACKS **************************/
808/*
809 * This are the functions that the generic PPP driver in the kernel
810 * will call to communicate to us.
811 */
812
813/*------------------------------------------------------------------*/
814/*
815 * Prepare the ppp frame for transmission over the IrDA socket.
816 * We make sure that the header space is enough, and we change ppp header
817 * according to flags passed by pppd.
818 * This is not a callback, but just a helper function used in ppp_irnet_send()
819 */
820static inline struct sk_buff *
821irnet_prepare_skb(irnet_socket * ap,
822 struct sk_buff * skb)
823{
824 unsigned char * data;
825 int proto; /* PPP protocol */
826 int islcp; /* Protocol == LCP */
827 int needaddr; /* Need PPP address */
828
829 DENTER(PPP_TRACE, "(ap=0x%p, skb=0x%p)\n",
830 ap, skb);
831
832 /* Extract PPP protocol from the frame */
833 data = skb->data;
834 proto = (data[0] << 8) + data[1];
835
836 /* LCP packets with codes between 1 (configure-request)
837 * and 7 (code-reject) must be sent as though no options
838 * have been negotiated. */
839 islcp = (proto == PPP_LCP) && (1 <= data[2]) && (data[2] <= 7);
840
841 /* compress protocol field if option enabled */
842 if((data[0] == 0) && (ap->flags & SC_COMP_PROT) && (!islcp))
843 skb_pull(skb,1);
844
845 /* Check if we need address/control fields */
846 needaddr = 2*((ap->flags & SC_COMP_AC) == 0 || islcp);
847
848 /* Is the skb headroom large enough to contain all IrDA-headers? */
849 if((skb_headroom(skb) < (ap->max_header_size + needaddr)) ||
850 (skb_shared(skb)))
851 {
852 struct sk_buff * new_skb;
853
854 DEBUG(PPP_INFO, "Reallocating skb\n");
855
856 /* Create a new skb */
857 new_skb = skb_realloc_headroom(skb, ap->max_header_size + needaddr);
858
859 /* We have to free the original skb anyway */
860 dev_kfree_skb(skb);
861
862 /* Did the realloc succeed ? */
863 DABORT(new_skb == NULL, NULL, PPP_ERROR, "Could not realloc skb\n");
864
865 /* Use the new skb instead */
866 skb = new_skb;
867 }
868
869 /* prepend address/control fields if necessary */
870 if(needaddr)
871 {
872 skb_push(skb, 2);
873 skb->data[0] = PPP_ALLSTATIONS;
874 skb->data[1] = PPP_UI;
875 }
876
877 DEXIT(PPP_TRACE, "\n");
878
879 return skb;
880}
881
882/*------------------------------------------------------------------*/
883/*
884 * Send a packet to the peer over the IrTTP connection.
885 * Returns 1 iff the packet was accepted.
886 * Returns 0 iff packet was not consumed.
887 * If the packet was not accepted, we will call ppp_output_wakeup
888 * at some later time to reactivate flow control in ppp_generic.
889 */
890static int
891ppp_irnet_send(struct ppp_channel * chan,
892 struct sk_buff * skb)
893{
894 irnet_socket * self = (struct irnet_socket *) chan->private;
895 int ret;
896
897 DENTER(PPP_TRACE, "(channel=0x%p, ap/self=0x%p)\n",
898 chan, self);
899
900 /* Check if things are somewhat valid... */
901 DASSERT(self != NULL, 0, PPP_ERROR, "Self is NULL !!!\n");
902
903 /* Check if we are connected */
904 if(!(test_bit(0, &self->ttp_open)))
905 {
906#ifdef CONNECT_IN_SEND
907 /* Let's try to connect one more time... */
908 /* Note : we won't be connected after this call, but we should be
909 * ready for next packet... */
910 /* If we are already connecting, this will fail */
911 irda_irnet_connect(self);
912#endif /* CONNECT_IN_SEND */
913
914 DEBUG(PPP_INFO, "IrTTP not ready ! (%ld-%ld)\n",
915 self->ttp_open, self->ttp_connect);
916
917 /* Note : we can either drop the packet or block the packet.
918 *
919 * Blocking the packet allow us a better connection time,
920 * because by calling ppp_output_wakeup() we can have
921 * ppp_generic resending the LCP request immediately to us,
922 * rather than waiting for one of pppd periodic transmission of
923 * LCP request.
924 *
925 * On the other hand, if we block all packet, all those periodic
926 * transmissions of pppd accumulate in ppp_generic, creating a
927 * backlog of LCP request. When we eventually connect later on,
928 * we have to transmit all this backlog before we can connect
929 * proper (if we don't timeout before).
930 *
931 * The current strategy is as follow :
932 * While we are attempting to connect, we block packets to get
933 * a better connection time.
934 * If we fail to connect, we drain the queue and start dropping packets
935 */
936#ifdef BLOCK_WHEN_CONNECT
937 /* If we are attempting to connect */
938 if(test_bit(0, &self->ttp_connect))
939 {
940 /* Blocking packet, ppp_generic will retry later */
941 return 0;
942 }
943#endif /* BLOCK_WHEN_CONNECT */
944
945 /* Dropping packet, pppd will retry later */
946 dev_kfree_skb(skb);
947 return 1;
948 }
949
950 /* Check if the queue can accept any packet, otherwise block */
951 if(self->tx_flow != FLOW_START)
952 DRETURN(0, PPP_INFO, "IrTTP queue full (%d skbs)...\n",
953 skb_queue_len(&self->tsap->tx_queue));
954
955 /* Prepare ppp frame for transmission */
956 skb = irnet_prepare_skb(self, skb);
957 DABORT(skb == NULL, 1, PPP_ERROR, "Prepare skb for Tx failed.\n");
958
959 /* Send the packet to IrTTP */
960 ret = irttp_data_request(self->tsap, skb);
961 if(ret < 0)
962 {
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900963 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 * > IrTTPs tx queue is full, so we just have to
965 * > drop the frame! You might think that we should
966 * > just return -1 and don't deallocate the frame,
967 * > but that is dangerous since it's possible that
968 * > we have replaced the original skb with a new
969 * > one with larger headroom, and that would really
970 * > confuse do_dev_queue_xmit() in dev.c! I have
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900971 * > tried :-) DB
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 * Correction : we verify the flow control above (self->tx_flow),
973 * so we come here only if IrTTP doesn't like the packet (empty,
974 * too large, IrTTP not connected). In those rare cases, it's ok
975 * to drop it, we don't want to see it here again...
976 * Jean II
977 */
978 DERROR(PPP_ERROR, "IrTTP doesn't like this packet !!! (0x%X)\n", ret);
979 /* irttp_data_request already free the packet */
980 }
981
982 DEXIT(PPP_TRACE, "\n");
983 return 1; /* Packet has been consumed */
984}
985
986/*------------------------------------------------------------------*/
987/*
988 * Take care of the ioctls that ppp_generic doesn't want to deal with...
989 * Note : we are also called from dev_irnet_ioctl().
990 */
991static int
992ppp_irnet_ioctl(struct ppp_channel * chan,
993 unsigned int cmd,
994 unsigned long arg)
995{
996 irnet_socket * ap = (struct irnet_socket *) chan->private;
997 int err;
998 int val;
999 u32 accm[8];
1000 void __user *argp = (void __user *)arg;
1001
1002 DENTER(PPP_TRACE, "(channel=0x%p, ap=0x%p, cmd=0x%X)\n",
1003 chan, ap, cmd);
1004
1005 /* Basic checks... */
1006 DASSERT(ap != NULL, -ENXIO, PPP_ERROR, "ap is NULL...\n");
1007
1008 err = -EFAULT;
1009 switch(cmd)
1010 {
1011 /* PPP flags */
1012 case PPPIOCGFLAGS:
1013 val = ap->flags | ap->rbits;
1014 if(put_user(val, (int __user *) argp))
1015 break;
1016 err = 0;
1017 break;
1018 case PPPIOCSFLAGS:
1019 if(get_user(val, (int __user *) argp))
1020 break;
1021 ap->flags = val & ~SC_RCV_BITS;
1022 ap->rbits = val & SC_RCV_BITS;
1023 err = 0;
1024 break;
1025
1026 /* Async map stuff - all dummy to please pppd */
1027 case PPPIOCGASYNCMAP:
1028 if(put_user(ap->xaccm[0], (u32 __user *) argp))
1029 break;
1030 err = 0;
1031 break;
1032 case PPPIOCSASYNCMAP:
1033 if(get_user(ap->xaccm[0], (u32 __user *) argp))
1034 break;
1035 err = 0;
1036 break;
1037 case PPPIOCGRASYNCMAP:
1038 if(put_user(ap->raccm, (u32 __user *) argp))
1039 break;
1040 err = 0;
1041 break;
1042 case PPPIOCSRASYNCMAP:
1043 if(get_user(ap->raccm, (u32 __user *) argp))
1044 break;
1045 err = 0;
1046 break;
1047 case PPPIOCGXASYNCMAP:
1048 if(copy_to_user(argp, ap->xaccm, sizeof(ap->xaccm)))
1049 break;
1050 err = 0;
1051 break;
1052 case PPPIOCSXASYNCMAP:
1053 if(copy_from_user(accm, argp, sizeof(accm)))
1054 break;
1055 accm[2] &= ~0x40000000U; /* can't escape 0x5e */
1056 accm[3] |= 0x60000000U; /* must escape 0x7d, 0x7e */
1057 memcpy(ap->xaccm, accm, sizeof(ap->xaccm));
1058 err = 0;
1059 break;
1060
1061 /* Max PPP frame size */
1062 case PPPIOCGMRU:
1063 if(put_user(ap->mru, (int __user *) argp))
1064 break;
1065 err = 0;
1066 break;
1067 case PPPIOCSMRU:
1068 if(get_user(val, (int __user *) argp))
1069 break;
1070 if(val < PPP_MRU)
1071 val = PPP_MRU;
1072 ap->mru = val;
1073 err = 0;
1074 break;
1075
1076 default:
1077 DEBUG(PPP_INFO, "Unsupported ioctl (0x%X)\n", cmd);
1078 err = -ENOIOCTLCMD;
1079 }
1080
1081 DEXIT(PPP_TRACE, " - err = 0x%X\n", err);
1082 return err;
1083}
1084
1085/************************** INITIALISATION **************************/
1086/*
1087 * Module initialisation and all that jazz...
1088 */
1089
1090/*------------------------------------------------------------------*/
1091/*
1092 * Hook our device callbacks in the filesystem, to connect our code
1093 * to /dev/irnet
1094 */
1095static inline int __init
1096ppp_irnet_init(void)
1097{
1098 int err = 0;
1099
1100 DENTER(MODULE_TRACE, "()\n");
1101
1102 /* Allocate ourselves as a minor in the misc range */
1103 err = misc_register(&irnet_misc_device);
1104
1105 DEXIT(MODULE_TRACE, "\n");
1106 return err;
1107}
1108
1109/*------------------------------------------------------------------*/
1110/*
1111 * Cleanup at exit...
1112 */
1113static inline void __exit
1114ppp_irnet_cleanup(void)
1115{
1116 DENTER(MODULE_TRACE, "()\n");
1117
1118 /* De-allocate /dev/irnet minor in misc range */
1119 misc_deregister(&irnet_misc_device);
1120
1121 DEXIT(MODULE_TRACE, "\n");
1122}
1123
1124/*------------------------------------------------------------------*/
1125/*
1126 * Module main entry point
1127 */
Adrian Bunkbf73d1c2005-08-16 20:45:45 -07001128static int __init
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129irnet_init(void)
1130{
1131 int err;
1132
1133 /* Initialise both parts... */
1134 err = irda_irnet_init();
1135 if(!err)
1136 err = ppp_irnet_init();
1137 return err;
1138}
1139
1140/*------------------------------------------------------------------*/
1141/*
1142 * Module exit
1143 */
1144static void __exit
1145irnet_cleanup(void)
1146{
1147 irda_irnet_cleanup();
1148 ppp_irnet_cleanup();
1149}
1150
1151/*------------------------------------------------------------------*/
1152/*
1153 * Module magic
1154 */
1155module_init(irnet_init);
1156module_exit(irnet_cleanup);
1157MODULE_AUTHOR("Jean Tourrilhes <jt@hpl.hp.com>");
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +09001158MODULE_DESCRIPTION("IrNET : Synchronous PPP over IrDA");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159MODULE_LICENSE("GPL");
1160MODULE_ALIAS_CHARDEV(10, 187);