irnet_ppp.c 32 KB

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