1/********************************************************************* 2 * 3 * Filename: af_irda.c 4 * Version: 0.9 5 * Description: IrDA sockets implementation 6 * Status: Stable 7 * Author: Dag Brattli <dagb@cs.uit.no> 8 * Created at: Sun May 31 10:12:43 1998 9 * Modified at: Sat Dec 25 21:10:23 1999 10 * Modified by: Dag Brattli <dag@brattli.net> 11 * Sources: af_netroom.c, af_ax25.c, af_rose.c, af_x25.c etc. 12 * 13 * Copyright (c) 1999 Dag Brattli <dagb@cs.uit.no> 14 * Copyright (c) 1999-2003 Jean Tourrilhes <jt@hpl.hp.com> 15 * All Rights Reserved. 16 * 17 * This program is free software; you can redistribute it and/or 18 * modify it under the terms of the GNU General Public License as 19 * published by the Free Software Foundation; either version 2 of 20 * the License, or (at your option) any later version. 21 * 22 * This program is distributed in the hope that it will be useful, 23 * but WITHOUT ANY WARRANTY; without even the implied warranty of 24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 25 * GNU General Public License for more details. 26 * 27 * You should have received a copy of the GNU General Public License 28 * along with this program; if not, write to the Free Software 29 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, 30 * MA 02111-1307 USA 31 * 32 * Linux-IrDA now supports four different types of IrDA sockets: 33 * 34 * o SOCK_STREAM: TinyTP connections with SAR disabled. The 35 * max SDU size is 0 for conn. of this type 36 * o SOCK_SEQPACKET: TinyTP connections with SAR enabled. TTP may 37 * fragment the messages, but will preserve 38 * the message boundaries 39 * o SOCK_DGRAM: IRDAPROTO_UNITDATA: TinyTP connections with Unitdata 40 * (unreliable) transfers 41 * IRDAPROTO_ULTRA: Connectionless and unreliable data 42 * 43 ********************************************************************/ 44 45#include <linux/capability.h> 46#include <linux/module.h> 47#include <linux/types.h> 48#include <linux/smp_lock.h> 49#include <linux/socket.h> 50#include <linux/sockios.h> 51#include <linux/slab.h> 52#include <linux/init.h> 53#include <linux/net.h> 54#include <linux/irda.h> 55#include <linux/poll.h> 56 57#include <asm/ioctls.h> /* TIOCOUTQ, TIOCINQ */ 58#include <asm/uaccess.h> 59 60#include <net/sock.h> 61#include <net/tcp_states.h> 62 63#include <net/irda/af_irda.h> 64 65static int irda_create(struct net *net, struct socket *sock, int protocol, int kern); 66 67static const struct proto_ops irda_stream_ops; 68static const struct proto_ops irda_seqpacket_ops; 69static const struct proto_ops irda_dgram_ops; 70 71#ifdef CONFIG_IRDA_ULTRA 72static const struct proto_ops irda_ultra_ops; 73#define ULTRA_MAX_DATA 382 74#endif /* CONFIG_IRDA_ULTRA */ 75 76#define IRDA_MAX_HEADER (TTP_MAX_HEADER) 77 78/* 79 * Function irda_data_indication (instance, sap, skb) 80 * 81 * Received some data from TinyTP. Just queue it on the receive queue 82 * 83 */ 84static int irda_data_indication(void *instance, void *sap, struct sk_buff *skb) 85{ 86 struct irda_sock *self; 87 struct sock *sk; 88 int err; 89 90 IRDA_DEBUG(3, "%s()\n", __func__); 91 92 self = instance; 93 sk = instance; 94 95 err = sock_queue_rcv_skb(sk, skb); 96 if (err) { 97 IRDA_DEBUG(1, "%s(), error: no more mem!\n", __func__); 98 self->rx_flow = FLOW_STOP; 99 100 /* When we return error, TTP will need to requeue the skb */ 101 return err; 102 } 103 104 return 0; 105} 106 107/* 108 * Function irda_disconnect_indication (instance, sap, reason, skb) 109 * 110 * Connection has been closed. Check reason to find out why 111 * 112 */ 113static void irda_disconnect_indication(void *instance, void *sap, 114 LM_REASON reason, struct sk_buff *skb) 115{ 116 struct irda_sock *self; 117 struct sock *sk; 118 119 self = instance; 120 121 IRDA_DEBUG(2, "%s(%p)\n", __func__, self); 122 123 /* Don't care about it, but let's not leak it */ 124 if(skb) 125 dev_kfree_skb(skb); 126 127 sk = instance; 128 if (sk == NULL) { 129 IRDA_DEBUG(0, "%s(%p) : BUG : sk is NULL\n", 130 __func__, self); 131 return; 132 } 133 134 /* Prevent race conditions with irda_release() and irda_shutdown() */ 135 bh_lock_sock(sk); 136 if (!sock_flag(sk, SOCK_DEAD) && sk->sk_state != TCP_CLOSE) { 137 sk->sk_state = TCP_CLOSE; 138 sk->sk_shutdown |= SEND_SHUTDOWN; 139 140 sk->sk_state_change(sk); 141 142 /* Close our TSAP. 143 * If we leave it open, IrLMP put it back into the list of 144 * unconnected LSAPs. The problem is that any incoming request 145 * can then be matched to this socket (and it will be, because 146 * it is at the head of the list). This would prevent any 147 * listening socket waiting on the same TSAP to get those 148 * requests. Some apps forget to close sockets, or hang to it 149 * a bit too long, so we may stay in this dead state long 150 * enough to be noticed... 151 * Note : all socket function do check sk->sk_state, so we are 152 * safe... 153 * Jean II 154 */ 155 if (self->tsap) { 156 irttp_close_tsap(self->tsap); 157 self->tsap = NULL; 158 } 159 } 160 bh_unlock_sock(sk); 161 162 /* Note : once we are there, there is not much you want to do 163 * with the socket anymore, apart from closing it. 164 * For example, bind() and connect() won't reset sk->sk_err, 165 * sk->sk_shutdown and sk->sk_flags to valid values... 166 * Jean II 167 */ 168} 169 170/* 171 * Function irda_connect_confirm (instance, sap, qos, max_sdu_size, skb) 172 * 173 * Connections has been confirmed by the remote device 174 * 175 */ 176static void irda_connect_confirm(void *instance, void *sap, 177 struct qos_info *qos, 178 __u32 max_sdu_size, __u8 max_header_size, 179 struct sk_buff *skb) 180{ 181 struct irda_sock *self; 182 struct sock *sk; 183 184 self = instance; 185 186 IRDA_DEBUG(2, "%s(%p)\n", __func__, self); 187 188 sk = instance; 189 if (sk == NULL) { 190 dev_kfree_skb(skb); 191 return; 192 } 193 194 dev_kfree_skb(skb); 195 // Should be ??? skb_queue_tail(&sk->sk_receive_queue, skb); 196 197 /* How much header space do we need to reserve */ 198 self->max_header_size = max_header_size; 199 200 /* IrTTP max SDU size in transmit direction */ 201 self->max_sdu_size_tx = max_sdu_size; 202 203 /* Find out what the largest chunk of data that we can transmit is */ 204 switch (sk->sk_type) { 205 case SOCK_STREAM: 206 if (max_sdu_size != 0) { 207 IRDA_ERROR("%s: max_sdu_size must be 0\n", 208 __func__); 209 return; 210 } 211 self->max_data_size = irttp_get_max_seg_size(self->tsap); 212 break; 213 case SOCK_SEQPACKET: 214 if (max_sdu_size == 0) { 215 IRDA_ERROR("%s: max_sdu_size cannot be 0\n", 216 __func__); 217 return; 218 } 219 self->max_data_size = max_sdu_size; 220 break; 221 default: 222 self->max_data_size = irttp_get_max_seg_size(self->tsap); 223 } 224 225 IRDA_DEBUG(2, "%s(), max_data_size=%d\n", __func__, 226 self->max_data_size); 227 228 memcpy(&self->qos_tx, qos, sizeof(struct qos_info)); 229 230 /* We are now connected! */ 231 sk->sk_state = TCP_ESTABLISHED; 232 sk->sk_state_change(sk); 233} 234 235/* 236 * Function irda_connect_indication(instance, sap, qos, max_sdu_size, userdata) 237 * 238 * Incoming connection 239 * 240 */ 241static void irda_connect_indication(void *instance, void *sap, 242 struct qos_info *qos, __u32 max_sdu_size, 243 __u8 max_header_size, struct sk_buff *skb) 244{ 245 struct irda_sock *self; 246 struct sock *sk; 247 248 self = instance; 249 250 IRDA_DEBUG(2, "%s(%p)\n", __func__, self); 251 252 sk = instance; 253 if (sk == NULL) { 254 dev_kfree_skb(skb); 255 return; 256 } 257 258 /* How much header space do we need to reserve */ 259 self->max_header_size = max_header_size; 260 261 /* IrTTP max SDU size in transmit direction */ 262 self->max_sdu_size_tx = max_sdu_size; 263 264 /* Find out what the largest chunk of data that we can transmit is */ 265 switch (sk->sk_type) { 266 case SOCK_STREAM: 267 if (max_sdu_size != 0) { 268 IRDA_ERROR("%s: max_sdu_size must be 0\n", 269 __func__); 270 kfree_skb(skb); 271 return; 272 } 273 self->max_data_size = irttp_get_max_seg_size(self->tsap); 274 break; 275 case SOCK_SEQPACKET: 276 if (max_sdu_size == 0) { 277 IRDA_ERROR("%s: max_sdu_size cannot be 0\n", 278 __func__); 279 kfree_skb(skb); 280 return; 281 } 282 self->max_data_size = max_sdu_size; 283 break; 284 default: 285 self->max_data_size = irttp_get_max_seg_size(self->tsap); 286 } 287 288 IRDA_DEBUG(2, "%s(), max_data_size=%d\n", __func__, 289 self->max_data_size); 290 291 memcpy(&self->qos_tx, qos, sizeof(struct qos_info)); 292 293 skb_queue_tail(&sk->sk_receive_queue, skb); 294 sk->sk_state_change(sk); 295} 296 297/* 298 * Function irda_connect_response (handle) 299 * 300 * Accept incoming connection 301 * 302 */ 303static void irda_connect_response(struct irda_sock *self) 304{ 305 struct sk_buff *skb; 306 307 IRDA_DEBUG(2, "%s()\n", __func__); 308 309 skb = alloc_skb(TTP_MAX_HEADER + TTP_SAR_HEADER, 310 GFP_ATOMIC); 311 if (skb == NULL) { 312 IRDA_DEBUG(0, "%s() Unable to allocate sk_buff!\n", 313 __func__); 314 return; 315 } 316 317 /* Reserve space for MUX_CONTROL and LAP header */ 318 skb_reserve(skb, IRDA_MAX_HEADER); 319 320 irttp_connect_response(self->tsap, self->max_sdu_size_rx, skb); 321} 322 323/* 324 * Function irda_flow_indication (instance, sap, flow) 325 * 326 * Used by TinyTP to tell us if it can accept more data or not 327 * 328 */ 329static void irda_flow_indication(void *instance, void *sap, LOCAL_FLOW flow) 330{ 331 struct irda_sock *self; 332 struct sock *sk; 333 334 IRDA_DEBUG(2, "%s()\n", __func__); 335 336 self = instance; 337 sk = instance; 338 BUG_ON(sk == NULL); 339 340 switch (flow) { 341 case FLOW_STOP: 342 IRDA_DEBUG(1, "%s(), IrTTP wants us to slow down\n", 343 __func__); 344 self->tx_flow = flow; 345 break; 346 case FLOW_START: 347 self->tx_flow = flow; 348 IRDA_DEBUG(1, "%s(), IrTTP wants us to start again\n", 349 __func__); 350 wake_up_interruptible(sk_sleep(sk)); 351 break; 352 default: 353 IRDA_DEBUG(0, "%s(), Unknown flow command!\n", __func__); 354 /* Unknown flow command, better stop */ 355 self->tx_flow = flow; 356 break; 357 } 358} 359 360/* 361 * Function irda_getvalue_confirm (obj_id, value, priv) 362 * 363 * Got answer from remote LM-IAS, just pass object to requester... 364 * 365 * Note : duplicate from above, but we need our own version that 366 * doesn't touch the dtsap_sel and save the full value structure... 367 */ 368static void irda_getvalue_confirm(int result, __u16 obj_id, 369 struct ias_value *value, void *priv) 370{ 371 struct irda_sock *self; 372 373 self = (struct irda_sock *) priv; 374 if (!self) { 375 IRDA_WARNING("%s: lost myself!\n", __func__); 376 return; 377 } 378 379 IRDA_DEBUG(2, "%s(%p)\n", __func__, self); 380 381 /* We probably don't need to make any more queries */ 382 iriap_close(self->iriap); 383 self->iriap = NULL; 384 385 /* Check if request succeeded */ 386 if (result != IAS_SUCCESS) { 387 IRDA_DEBUG(1, "%s(), IAS query failed! (%d)\n", __func__, 388 result); 389 390 self->errno = result; /* We really need it later */ 391 392 /* Wake up any processes waiting for result */ 393 wake_up_interruptible(&self->query_wait); 394 395 return; 396 } 397 398 /* Pass the object to the caller (so the caller must delete it) */ 399 self->ias_result = value; 400 self->errno = 0; 401 402 /* Wake up any processes waiting for result */ 403 wake_up_interruptible(&self->query_wait); 404} 405 406/* 407 * Function irda_selective_discovery_indication (discovery) 408 * 409 * Got a selective discovery indication from IrLMP. 410 * 411 * IrLMP is telling us that this node is new and matching our hint bit 412 * filter. Wake up any process waiting for answer... 413 */ 414static void irda_selective_discovery_indication(discinfo_t *discovery, 415 DISCOVERY_MODE mode, 416 void *priv) 417{ 418 struct irda_sock *self; 419 420 IRDA_DEBUG(2, "%s()\n", __func__); 421 422 self = (struct irda_sock *) priv; 423 if (!self) { 424 IRDA_WARNING("%s: lost myself!\n", __func__); 425 return; 426 } 427 428 /* Pass parameter to the caller */ 429 self->cachedaddr = discovery->daddr; 430 431 /* Wake up process if its waiting for device to be discovered */ 432 wake_up_interruptible(&self->query_wait); 433} 434 435/* 436 * Function irda_discovery_timeout (priv) 437 * 438 * Timeout in the selective discovery process 439 * 440 * We were waiting for a node to be discovered, but nothing has come up 441 * so far. Wake up the user and tell him that we failed... 442 */ 443static void irda_discovery_timeout(u_long priv) 444{ 445 struct irda_sock *self; 446 447 IRDA_DEBUG(2, "%s()\n", __func__); 448 449 self = (struct irda_sock *) priv; 450 BUG_ON(self == NULL); 451 452 /* Nothing for the caller */ 453 self->cachelog = NULL; 454 self->cachedaddr = 0; 455 self->errno = -ETIME; 456 457 /* Wake up process if its still waiting... */ 458 wake_up_interruptible(&self->query_wait); 459} 460 461/* 462 * Function irda_open_tsap (self) 463 * 464 * Open local Transport Service Access Point (TSAP) 465 * 466 */ 467static int irda_open_tsap(struct irda_sock *self, __u8 tsap_sel, char *name) 468{ 469 notify_t notify; 470 471 if (self->tsap) { 472 IRDA_WARNING("%s: busy!\n", __func__); 473 return -EBUSY; 474 } 475 476 /* Initialize callbacks to be used by the IrDA stack */ 477 irda_notify_init(¬ify); 478 notify.connect_confirm = irda_connect_confirm; 479 notify.connect_indication = irda_connect_indication; 480 notify.disconnect_indication = irda_disconnect_indication; 481 notify.data_indication = irda_data_indication; 482 notify.udata_indication = irda_data_indication; 483 notify.flow_indication = irda_flow_indication; 484 notify.instance = self; 485 strncpy(notify.name, name, NOTIFY_MAX_NAME); 486 487 self->tsap = irttp_open_tsap(tsap_sel, DEFAULT_INITIAL_CREDIT, 488 ¬ify); 489 if (self->tsap == NULL) { 490 IRDA_DEBUG(0, "%s(), Unable to allocate TSAP!\n", 491 __func__); 492 return -ENOMEM; 493 } 494 /* Remember which TSAP selector we actually got */ 495 self->stsap_sel = self->tsap->stsap_sel; 496 497 return 0; 498} 499 500/* 501 * Function irda_open_lsap (self) 502 * 503 * Open local Link Service Access Point (LSAP). Used for opening Ultra 504 * sockets 505 */ 506#ifdef CONFIG_IRDA_ULTRA 507static int irda_open_lsap(struct irda_sock *self, int pid) 508{ 509 notify_t notify; 510 511 if (self->lsap) { 512 IRDA_WARNING("%s(), busy!\n", __func__); 513 return -EBUSY; 514 } 515 516 /* Initialize callbacks to be used by the IrDA stack */ 517 irda_notify_init(¬ify); 518 notify.udata_indication = irda_data_indication; 519 notify.instance = self; 520 strncpy(notify.name, "Ultra", NOTIFY_MAX_NAME); 521 522 self->lsap = irlmp_open_lsap(LSAP_CONNLESS, ¬ify, pid); 523 if (self->lsap == NULL) { 524 IRDA_DEBUG( 0, "%s(), Unable to allocate LSAP!\n", __func__); 525 return -ENOMEM; 526 } 527 528 return 0; 529} 530#endif /* CONFIG_IRDA_ULTRA */ 531 532/* 533 * Function irda_find_lsap_sel (self, name) 534 * 535 * Try to lookup LSAP selector in remote LM-IAS 536 * 537 * Basically, we start a IAP query, and then go to sleep. When the query 538 * return, irda_getvalue_confirm will wake us up, and we can examine the 539 * result of the query... 540 * Note that in some case, the query fail even before we go to sleep, 541 * creating some races... 542 */ 543static int irda_find_lsap_sel(struct irda_sock *self, char *name) 544{ 545 IRDA_DEBUG(2, "%s(%p, %s)\n", __func__, self, name); 546 547 if (self->iriap) { 548 IRDA_WARNING("%s(): busy with a previous query\n", 549 __func__); 550 return -EBUSY; 551 } 552 553 self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self, 554 irda_getvalue_confirm); 555 if(self->iriap == NULL) 556 return -ENOMEM; 557 558 /* Treat unexpected wakeup as disconnect */ 559 self->errno = -EHOSTUNREACH; 560 561 /* Query remote LM-IAS */ 562 iriap_getvaluebyclass_request(self->iriap, self->saddr, self->daddr, 563 name, "IrDA:TinyTP:LsapSel"); 564 565 /* Wait for answer, if not yet finished (or failed) */ 566 if (wait_event_interruptible(self->query_wait, (self->iriap==NULL))) 567 /* Treat signals as disconnect */ 568 return -EHOSTUNREACH; 569 570 /* Check what happened */ 571 if (self->errno) 572 { 573 /* Requested object/attribute doesn't exist */ 574 if((self->errno == IAS_CLASS_UNKNOWN) || 575 (self->errno == IAS_ATTRIB_UNKNOWN)) 576 return (-EADDRNOTAVAIL); 577 else 578 return (-EHOSTUNREACH); 579 } 580 581 /* Get the remote TSAP selector */ 582 switch (self->ias_result->type) { 583 case IAS_INTEGER: 584 IRDA_DEBUG(4, "%s() int=%d\n", 585 __func__, self->ias_result->t.integer); 586 587 if (self->ias_result->t.integer != -1) 588 self->dtsap_sel = self->ias_result->t.integer; 589 else 590 self->dtsap_sel = 0; 591 break; 592 default: 593 self->dtsap_sel = 0; 594 IRDA_DEBUG(0, "%s(), bad type!\n", __func__); 595 break; 596 } 597 if (self->ias_result) 598 irias_delete_value(self->ias_result); 599 600 if (self->dtsap_sel) 601 return 0; 602 603 return -EADDRNOTAVAIL; 604} 605 606/* 607 * Function irda_discover_daddr_and_lsap_sel (self, name) 608 * 609 * This try to find a device with the requested service. 610 * 611 * It basically look into the discovery log. For each address in the list, 612 * it queries the LM-IAS of the device to find if this device offer 613 * the requested service. 614 * If there is more than one node supporting the service, we complain 615 * to the user (it should move devices around). 616 * The, we set both the destination address and the lsap selector to point 617 * on the service on the unique device we have found. 618 * 619 * Note : this function fails if there is more than one device in range, 620 * because IrLMP doesn't disconnect the LAP when the last LSAP is closed. 621 * Moreover, we would need to wait the LAP disconnection... 622 */ 623static int irda_discover_daddr_and_lsap_sel(struct irda_sock *self, char *name) 624{ 625 discinfo_t *discoveries; /* Copy of the discovery log */ 626 int number; /* Number of nodes in the log */ 627 int i; 628 int err = -ENETUNREACH; 629 __u32 daddr = DEV_ADDR_ANY; /* Address we found the service on */ 630 __u8 dtsap_sel = 0x0; /* TSAP associated with it */ 631 632 IRDA_DEBUG(2, "%s(), name=%s\n", __func__, name); 633 634 /* Ask lmp for the current discovery log 635 * Note : we have to use irlmp_get_discoveries(), as opposed 636 * to play with the cachelog directly, because while we are 637 * making our ias query, le log might change... */ 638 discoveries = irlmp_get_discoveries(&number, self->mask.word, 639 self->nslots); 640 /* Check if the we got some results */ 641 if (discoveries == NULL) 642 return -ENETUNREACH; /* No nodes discovered */ 643 644 /* 645 * Now, check all discovered devices (if any), and connect 646 * client only about the services that the client is 647 * interested in... 648 */ 649 for(i = 0; i < number; i++) { 650 /* Try the address in the log */ 651 self->daddr = discoveries[i].daddr; 652 self->saddr = 0x0; 653 IRDA_DEBUG(1, "%s(), trying daddr = %08x\n", 654 __func__, self->daddr); 655 656 /* Query remote LM-IAS for this service */ 657 err = irda_find_lsap_sel(self, name); 658 switch (err) { 659 case 0: 660 /* We found the requested service */ 661 if(daddr != DEV_ADDR_ANY) { 662 IRDA_DEBUG(1, "%s(), discovered service ''%s'' in two different devices !!!\n", 663 __func__, name); 664 self->daddr = DEV_ADDR_ANY; 665 kfree(discoveries); 666 return(-ENOTUNIQ); 667 } 668 /* First time we found that one, save it ! */ 669 daddr = self->daddr; 670 dtsap_sel = self->dtsap_sel; 671 break; 672 case -EADDRNOTAVAIL: 673 /* Requested service simply doesn't exist on this node */ 674 break; 675 default: 676 /* Something bad did happen :-( */ 677 IRDA_DEBUG(0, "%s(), unexpected IAS query failure\n", __func__); 678 self->daddr = DEV_ADDR_ANY; 679 kfree(discoveries); 680 return(-EHOSTUNREACH); 681 break; 682 } 683 } 684 /* Cleanup our copy of the discovery log */ 685 kfree(discoveries); 686 687 /* Check out what we found */ 688 if(daddr == DEV_ADDR_ANY) { 689 IRDA_DEBUG(1, "%s(), cannot discover service ''%s'' in any device !!!\n", 690 __func__, name); 691 self->daddr = DEV_ADDR_ANY; 692 return(-EADDRNOTAVAIL); 693 } 694 695 /* Revert back to discovered device & service */ 696 self->daddr = daddr; 697 self->saddr = 0x0; 698 self->dtsap_sel = dtsap_sel; 699 700 IRDA_DEBUG(1, "%s(), discovered requested service ''%s'' at address %08x\n", 701 __func__, name, self->daddr); 702 703 return 0; 704} 705 706/* 707 * Function irda_getname (sock, uaddr, uaddr_len, peer) 708 * 709 * Return the our own, or peers socket address (sockaddr_irda) 710 * 711 */ 712static int irda_getname(struct socket *sock, struct sockaddr *uaddr, 713 int *uaddr_len, int peer) 714{ 715 struct sockaddr_irda saddr; 716 struct sock *sk = sock->sk; 717 struct irda_sock *self = irda_sk(sk); 718 int err; 719 720 lock_kernel(); 721 memset(&saddr, 0, sizeof(saddr)); 722 if (peer) { 723 err = -ENOTCONN; 724 if (sk->sk_state != TCP_ESTABLISHED) 725 goto out; 726 727 saddr.sir_family = AF_IRDA; 728 saddr.sir_lsap_sel = self->dtsap_sel; 729 saddr.sir_addr = self->daddr; 730 } else { 731 saddr.sir_family = AF_IRDA; 732 saddr.sir_lsap_sel = self->stsap_sel; 733 saddr.sir_addr = self->saddr; 734 } 735 736 IRDA_DEBUG(1, "%s(), tsap_sel = %#x\n", __func__, saddr.sir_lsap_sel); 737 IRDA_DEBUG(1, "%s(), addr = %08x\n", __func__, saddr.sir_addr); 738 739 /* uaddr_len come to us uninitialised */ 740 *uaddr_len = sizeof (struct sockaddr_irda); 741 memcpy(uaddr, &saddr, *uaddr_len); 742 err = 0; 743out: 744 unlock_kernel(); 745 return err; 746} 747 748/* 749 * Function irda_listen (sock, backlog) 750 * 751 * Just move to the listen state 752 * 753 */ 754static int irda_listen(struct socket *sock, int backlog) 755{ 756 struct sock *sk = sock->sk; 757 int err = -EOPNOTSUPP; 758 759 IRDA_DEBUG(2, "%s()\n", __func__); 760 761 lock_kernel(); 762 if ((sk->sk_type != SOCK_STREAM) && (sk->sk_type != SOCK_SEQPACKET) && 763 (sk->sk_type != SOCK_DGRAM)) 764 goto out; 765 766 if (sk->sk_state != TCP_LISTEN) { 767 sk->sk_max_ack_backlog = backlog; 768 sk->sk_state = TCP_LISTEN; 769 770 err = 0; 771 } 772out: 773 unlock_kernel(); 774 775 return err; 776} 777 778/* 779 * Function irda_bind (sock, uaddr, addr_len) 780 * 781 * Used by servers to register their well known TSAP 782 * 783 */ 784static int irda_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) 785{ 786 struct sock *sk = sock->sk; 787 struct sockaddr_irda *addr = (struct sockaddr_irda *) uaddr; 788 struct irda_sock *self = irda_sk(sk); 789 int err; 790 791 IRDA_DEBUG(2, "%s(%p)\n", __func__, self); 792 793 if (addr_len != sizeof(struct sockaddr_irda)) 794 return -EINVAL; 795 796 lock_kernel(); 797#ifdef CONFIG_IRDA_ULTRA 798 /* Special care for Ultra sockets */ 799 if ((sk->sk_type == SOCK_DGRAM) && 800 (sk->sk_protocol == IRDAPROTO_ULTRA)) { 801 self->pid = addr->sir_lsap_sel; 802 err = -EOPNOTSUPP; 803 if (self->pid & 0x80) { 804 IRDA_DEBUG(0, "%s(), extension in PID not supp!\n", __func__); 805 goto out; 806 } 807 err = irda_open_lsap(self, self->pid); 808 if (err < 0) 809 goto out; 810 811 /* Pretend we are connected */ 812 sock->state = SS_CONNECTED; 813 sk->sk_state = TCP_ESTABLISHED; 814 err = 0; 815 816 goto out; 817 } 818#endif /* CONFIG_IRDA_ULTRA */ 819 820 self->ias_obj = irias_new_object(addr->sir_name, jiffies); 821 err = -ENOMEM; 822 if (self->ias_obj == NULL) 823 goto out; 824 825 err = irda_open_tsap(self, addr->sir_lsap_sel, addr->sir_name); 826 if (err < 0) { 827 irias_delete_object(self->ias_obj); 828 self->ias_obj = NULL; 829 goto out; 830 } 831 832 /* Register with LM-IAS */ 833 irias_add_integer_attrib(self->ias_obj, "IrDA:TinyTP:LsapSel", 834 self->stsap_sel, IAS_KERNEL_ATTR); 835 irias_insert_object(self->ias_obj); 836 837 err = 0; 838out: 839 unlock_kernel(); 840 return err; 841} 842 843/* 844 * Function irda_accept (sock, newsock, flags) 845 * 846 * Wait for incoming connection 847 * 848 */ 849static int irda_accept(struct socket *sock, struct socket *newsock, int flags) 850{ 851 struct sock *sk = sock->sk; 852 struct irda_sock *new, *self = irda_sk(sk); 853 struct sock *newsk; 854 struct sk_buff *skb; 855 int err; 856 857 IRDA_DEBUG(2, "%s()\n", __func__); 858 859 lock_kernel(); 860 err = irda_create(sock_net(sk), newsock, sk->sk_protocol, 0); 861 if (err) 862 goto out; 863 864 err = -EINVAL; 865 if (sock->state != SS_UNCONNECTED) 866 goto out; 867 868 if ((sk = sock->sk) == NULL) 869 goto out; 870 871 err = -EOPNOTSUPP; 872 if ((sk->sk_type != SOCK_STREAM) && (sk->sk_type != SOCK_SEQPACKET) && 873 (sk->sk_type != SOCK_DGRAM)) 874 goto out; 875 876 err = -EINVAL; 877 if (sk->sk_state != TCP_LISTEN) 878 goto out; 879 880 /* 881 * The read queue this time is holding sockets ready to use 882 * hooked into the SABM we saved 883 */ 884 885 /* 886 * We can perform the accept only if there is incoming data 887 * on the listening socket. 888 * So, we will block the caller until we receive any data. 889 * If the caller was waiting on select() or poll() before 890 * calling us, the data is waiting for us ;-) 891 * Jean II 892 */ 893 while (1) { 894 skb = skb_dequeue(&sk->sk_receive_queue); 895 if (skb) 896 break; 897 898 /* Non blocking operation */ 899 err = -EWOULDBLOCK; 900 if (flags & O_NONBLOCK) 901 goto out; 902 903 err = wait_event_interruptible(*(sk_sleep(sk)), 904 skb_peek(&sk->sk_receive_queue)); 905 if (err) 906 goto out; 907 } 908 909 newsk = newsock->sk; 910 err = -EIO; 911 if (newsk == NULL) 912 goto out; 913 914 newsk->sk_state = TCP_ESTABLISHED; 915 916 new = irda_sk(newsk); 917 918 /* Now attach up the new socket */ 919 new->tsap = irttp_dup(self->tsap, new); 920 err = -EPERM; /* value does not seem to make sense. -arnd */ 921 if (!new->tsap) { 922 IRDA_DEBUG(0, "%s(), dup failed!\n", __func__); 923 kfree_skb(skb); 924 goto out; 925 } 926 927 new->stsap_sel = new->tsap->stsap_sel; 928 new->dtsap_sel = new->tsap->dtsap_sel; 929 new->saddr = irttp_get_saddr(new->tsap); 930 new->daddr = irttp_get_daddr(new->tsap); 931 932 new->max_sdu_size_tx = self->max_sdu_size_tx; 933 new->max_sdu_size_rx = self->max_sdu_size_rx; 934 new->max_data_size = self->max_data_size; 935 new->max_header_size = self->max_header_size; 936 937 memcpy(&new->qos_tx, &self->qos_tx, sizeof(struct qos_info)); 938 939 /* Clean up the original one to keep it in listen state */ 940 irttp_listen(self->tsap); 941 942 kfree_skb(skb); 943 sk->sk_ack_backlog--; 944 945 newsock->state = SS_CONNECTED; 946 947 irda_connect_response(new); 948 err = 0; 949out: 950 unlock_kernel(); 951 return err; 952} 953 954/* 955 * Function irda_connect (sock, uaddr, addr_len, flags) 956 * 957 * Connect to a IrDA device 958 * 959 * The main difference with a "standard" connect is that with IrDA we need 960 * to resolve the service name into a TSAP selector (in TCP, port number 961 * doesn't have to be resolved). 962 * Because of this service name resoltion, we can offer "auto-connect", 963 * where we connect to a service without specifying a destination address. 964 * 965 * Note : by consulting "errno", the user space caller may learn the cause 966 * of the failure. Most of them are visible in the function, others may come 967 * from subroutines called and are listed here : 968 * o EBUSY : already processing a connect 969 * o EHOSTUNREACH : bad addr->sir_addr argument 970 * o EADDRNOTAVAIL : bad addr->sir_name argument 971 * o ENOTUNIQ : more than one node has addr->sir_name (auto-connect) 972 * o ENETUNREACH : no node found on the network (auto-connect) 973 */ 974static int irda_connect(struct socket *sock, struct sockaddr *uaddr, 975 int addr_len, int flags) 976{ 977 struct sock *sk = sock->sk; 978 struct sockaddr_irda *addr = (struct sockaddr_irda *) uaddr; 979 struct irda_sock *self = irda_sk(sk); 980 int err; 981 982 IRDA_DEBUG(2, "%s(%p)\n", __func__, self); 983 984 lock_kernel(); 985 /* Don't allow connect for Ultra sockets */ 986 err = -ESOCKTNOSUPPORT; 987 if ((sk->sk_type == SOCK_DGRAM) && (sk->sk_protocol == IRDAPROTO_ULTRA)) 988 goto out; 989 990 if (sk->sk_state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) { 991 sock->state = SS_CONNECTED; 992 err = 0; 993 goto out; /* Connect completed during a ERESTARTSYS event */ 994 } 995 996 if (sk->sk_state == TCP_CLOSE && sock->state == SS_CONNECTING) { 997 sock->state = SS_UNCONNECTED; 998 err = -ECONNREFUSED; 999 goto out; 1000 } 1001 1002 err = -EISCONN; /* No reconnect on a seqpacket socket */ 1003 if (sk->sk_state == TCP_ESTABLISHED) 1004 goto out; 1005 1006 sk->sk_state = TCP_CLOSE; 1007 sock->state = SS_UNCONNECTED; 1008 1009 err = -EINVAL; 1010 if (addr_len != sizeof(struct sockaddr_irda)) 1011 goto out; 1012 1013 /* Check if user supplied any destination device address */ 1014 if ((!addr->sir_addr) || (addr->sir_addr == DEV_ADDR_ANY)) { 1015 /* Try to find one suitable */ 1016 err = irda_discover_daddr_and_lsap_sel(self, addr->sir_name); 1017 if (err) { 1018 IRDA_DEBUG(0, "%s(), auto-connect failed!\n", __func__); 1019 goto out; 1020 } 1021 } else { 1022 /* Use the one provided by the user */ 1023 self->daddr = addr->sir_addr; 1024 IRDA_DEBUG(1, "%s(), daddr = %08x\n", __func__, self->daddr); 1025 1026 /* If we don't have a valid service name, we assume the 1027 * user want to connect on a specific LSAP. Prevent 1028 * the use of invalid LSAPs (IrLMP 1.1 p10). Jean II */ 1029 if((addr->sir_name[0] != '\0') || 1030 (addr->sir_lsap_sel >= 0x70)) { 1031 /* Query remote LM-IAS using service name */ 1032 err = irda_find_lsap_sel(self, addr->sir_name); 1033 if (err) { 1034 IRDA_DEBUG(0, "%s(), connect failed!\n", __func__); 1035 goto out; 1036 } 1037 } else { 1038 /* Directly connect to the remote LSAP 1039 * specified by the sir_lsap field. 1040 * Please use with caution, in IrDA LSAPs are 1041 * dynamic and there is no "well-known" LSAP. */ 1042 self->dtsap_sel = addr->sir_lsap_sel; 1043 } 1044 } 1045 1046 /* Check if we have opened a local TSAP */ 1047 if (!self->tsap) 1048 irda_open_tsap(self, LSAP_ANY, addr->sir_name); 1049 1050 /* Move to connecting socket, start sending Connect Requests */ 1051 sock->state = SS_CONNECTING; 1052 sk->sk_state = TCP_SYN_SENT; 1053 1054 /* Connect to remote device */ 1055 err = irttp_connect_request(self->tsap, self->dtsap_sel, 1056 self->saddr, self->daddr, NULL, 1057 self->max_sdu_size_rx, NULL); 1058 if (err) { 1059 IRDA_DEBUG(0, "%s(), connect failed!\n", __func__); 1060 goto out; 1061 } 1062 1063 /* Now the loop */ 1064 err = -EINPROGRESS; 1065 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) 1066 goto out; 1067 1068 err = -ERESTARTSYS; 1069 if (wait_event_interruptible(*(sk_sleep(sk)), 1070 (sk->sk_state != TCP_SYN_SENT))) 1071 goto out; 1072 1073 if (sk->sk_state != TCP_ESTABLISHED) { 1074 sock->state = SS_UNCONNECTED; 1075 err = sock_error(sk); 1076 if (!err) 1077 err = -ECONNRESET; 1078 goto out; 1079 } 1080 1081 sock->state = SS_CONNECTED; 1082 1083 /* At this point, IrLMP has assigned our source address */ 1084 self->saddr = irttp_get_saddr(self->tsap); 1085 err = 0; 1086out: 1087 unlock_kernel(); 1088 return err; 1089} 1090 1091static struct proto irda_proto = { 1092 .name = "IRDA", 1093 .owner = THIS_MODULE, 1094 .obj_size = sizeof(struct irda_sock), 1095}; 1096 1097/* 1098 * Function irda_create (sock, protocol) 1099 * 1100 * Create IrDA socket 1101 * 1102 */ 1103static int irda_create(struct net *net, struct socket *sock, int protocol, 1104 int kern) 1105{ 1106 struct sock *sk; 1107 struct irda_sock *self; 1108 1109 IRDA_DEBUG(2, "%s()\n", __func__); 1110 1111 if (net != &init_net) 1112 return -EAFNOSUPPORT; 1113 1114 /* Check for valid socket type */ 1115 switch (sock->type) { 1116 case SOCK_STREAM: /* For TTP connections with SAR disabled */ 1117 case SOCK_SEQPACKET: /* For TTP connections with SAR enabled */ 1118 case SOCK_DGRAM: /* For TTP Unitdata or LMP Ultra transfers */ 1119 break; 1120 default: 1121 return -ESOCKTNOSUPPORT; 1122 } 1123 1124 /* Allocate networking socket */ 1125 sk = sk_alloc(net, PF_IRDA, GFP_ATOMIC, &irda_proto); 1126 if (sk == NULL) 1127 return -ENOMEM; 1128 1129 self = irda_sk(sk); 1130 IRDA_DEBUG(2, "%s() : self is %p\n", __func__, self); 1131 1132 init_waitqueue_head(&self->query_wait); 1133 1134 switch (sock->type) { 1135 case SOCK_STREAM: 1136 sock->ops = &irda_stream_ops; 1137 self->max_sdu_size_rx = TTP_SAR_DISABLE; 1138 break; 1139 case SOCK_SEQPACKET: 1140 sock->ops = &irda_seqpacket_ops; 1141 self->max_sdu_size_rx = TTP_SAR_UNBOUND; 1142 break; 1143 case SOCK_DGRAM: 1144 switch (protocol) { 1145#ifdef CONFIG_IRDA_ULTRA 1146 case IRDAPROTO_ULTRA: 1147 sock->ops = &irda_ultra_ops; 1148 /* Initialise now, because we may send on unbound 1149 * sockets. Jean II */ 1150 self->max_data_size = ULTRA_MAX_DATA - LMP_PID_HEADER; 1151 self->max_header_size = IRDA_MAX_HEADER + LMP_PID_HEADER; 1152 break; 1153#endif /* CONFIG_IRDA_ULTRA */ 1154 case IRDAPROTO_UNITDATA: 1155 sock->ops = &irda_dgram_ops; 1156 /* We let Unitdata conn. be like seqpack conn. */ 1157 self->max_sdu_size_rx = TTP_SAR_UNBOUND; 1158 break; 1159 default: 1160 sk_free(sk); 1161 return -ESOCKTNOSUPPORT; 1162 } 1163 break; 1164 default: 1165 sk_free(sk); 1166 return -ESOCKTNOSUPPORT; 1167 } 1168 1169 /* Initialise networking socket struct */ 1170 sock_init_data(sock, sk); /* Note : set sk->sk_refcnt to 1 */ 1171 sk->sk_family = PF_IRDA; 1172 sk->sk_protocol = protocol; 1173 1174 /* Register as a client with IrLMP */ 1175 self->ckey = irlmp_register_client(0, NULL, NULL, NULL); 1176 self->mask.word = 0xffff; 1177 self->rx_flow = self->tx_flow = FLOW_START; 1178 self->nslots = DISCOVERY_DEFAULT_SLOTS; 1179 self->daddr = DEV_ADDR_ANY; /* Until we get connected */ 1180 self->saddr = 0x0; /* so IrLMP assign us any link */ 1181 return 0; 1182} 1183 1184/* 1185 * Function irda_destroy_socket (self) 1186 * 1187 * Destroy socket 1188 * 1189 */ 1190static void irda_destroy_socket(struct irda_sock *self) 1191{ 1192 IRDA_DEBUG(2, "%s(%p)\n", __func__, self); 1193 1194 /* Unregister with IrLMP */ 1195 irlmp_unregister_client(self->ckey); 1196 irlmp_unregister_service(self->skey); 1197 1198 /* Unregister with LM-IAS */ 1199 if (self->ias_obj) { 1200 irias_delete_object(self->ias_obj); 1201 self->ias_obj = NULL; 1202 } 1203 1204 if (self->iriap) { 1205 iriap_close(self->iriap); 1206 self->iriap = NULL; 1207 } 1208 1209 if (self->tsap) { 1210 irttp_disconnect_request(self->tsap, NULL, P_NORMAL); 1211 irttp_close_tsap(self->tsap); 1212 self->tsap = NULL; 1213 } 1214#ifdef CONFIG_IRDA_ULTRA 1215 if (self->lsap) { 1216 irlmp_close_lsap(self->lsap); 1217 self->lsap = NULL; 1218 } 1219#endif /* CONFIG_IRDA_ULTRA */ 1220} 1221 1222/* 1223 * Function irda_release (sock) 1224 */ 1225static int irda_release(struct socket *sock) 1226{ 1227 struct sock *sk = sock->sk; 1228 1229 IRDA_DEBUG(2, "%s()\n", __func__); 1230 1231 if (sk == NULL) 1232 return 0; 1233 1234 lock_kernel(); 1235 lock_sock(sk); 1236 sk->sk_state = TCP_CLOSE; 1237 sk->sk_shutdown |= SEND_SHUTDOWN; 1238 sk->sk_state_change(sk); 1239 1240 /* Destroy IrDA socket */ 1241 irda_destroy_socket(irda_sk(sk)); 1242 1243 sock_orphan(sk); 1244 sock->sk = NULL; 1245 release_sock(sk); 1246 1247 /* Purge queues (see sock_init_data()) */ 1248 skb_queue_purge(&sk->sk_receive_queue); 1249 1250 /* Destroy networking socket if we are the last reference on it, 1251 * i.e. if(sk->sk_refcnt == 0) -> sk_free(sk) */ 1252 sock_put(sk); 1253 unlock_kernel(); 1254 1255 /* Notes on socket locking and deallocation... - Jean II 1256 * In theory we should put pairs of sock_hold() / sock_put() to 1257 * prevent the socket to be destroyed whenever there is an 1258 * outstanding request or outstanding incoming packet or event. 1259 * 1260 * 1) This may include IAS request, both in connect and getsockopt. 1261 * Unfortunately, the situation is a bit more messy than it looks, 1262 * because we close iriap and kfree(self) above. 1263 * 1264 * 2) This may include selective discovery in getsockopt. 1265 * Same stuff as above, irlmp registration and self are gone. 1266 * 1267 * Probably 1 and 2 may not matter, because it's all triggered 1268 * by a process and the socket layer already prevent the 1269 * socket to go away while a process is holding it, through 1270 * sockfd_put() and fput()... 1271 * 1272 * 3) This may include deferred TSAP closure. In particular, 1273 * we may receive a late irda_disconnect_indication() 1274 * Fortunately, (tsap_cb *)->close_pend should protect us 1275 * from that. 1276 * 1277 * I did some testing on SMP, and it looks solid. And the socket 1278 * memory leak is now gone... - Jean II 1279 */ 1280 1281 return 0; 1282} 1283 1284/* 1285 * Function irda_sendmsg (iocb, sock, msg, len) 1286 * 1287 * Send message down to TinyTP. This function is used for both STREAM and 1288 * SEQPACK services. This is possible since it forces the client to 1289 * fragment the message if necessary 1290 */ 1291static int irda_sendmsg(struct kiocb *iocb, struct socket *sock, 1292 struct msghdr *msg, size_t len) 1293{ 1294 struct sock *sk = sock->sk; 1295 struct irda_sock *self; 1296 struct sk_buff *skb; 1297 int err = -EPIPE; 1298 1299 IRDA_DEBUG(4, "%s(), len=%zd\n", __func__, len); 1300 1301 lock_kernel(); 1302 /* Note : socket.c set MSG_EOR on SEQPACKET sockets */ 1303 if (msg->msg_flags & ~(MSG_DONTWAIT | MSG_EOR | MSG_CMSG_COMPAT | 1304 MSG_NOSIGNAL)) { 1305 err = -EINVAL; 1306 goto out; 1307 } 1308 1309 if (sk->sk_shutdown & SEND_SHUTDOWN) 1310 goto out_err; 1311 1312 if (sk->sk_state != TCP_ESTABLISHED) { 1313 err = -ENOTCONN; 1314 goto out; 1315 } 1316 1317 self = irda_sk(sk); 1318 1319 /* Check if IrTTP is wants us to slow down */ 1320 1321 if (wait_event_interruptible(*(sk_sleep(sk)), 1322 (self->tx_flow != FLOW_STOP || sk->sk_state != TCP_ESTABLISHED))) { 1323 err = -ERESTARTSYS; 1324 goto out; 1325 } 1326 1327 /* Check if we are still connected */ 1328 if (sk->sk_state != TCP_ESTABLISHED) { 1329 err = -ENOTCONN; 1330 goto out; 1331 } 1332 1333 /* Check that we don't send out too big frames */ 1334 if (len > self->max_data_size) { 1335 IRDA_DEBUG(2, "%s(), Chopping frame from %zd to %d bytes!\n", 1336 __func__, len, self->max_data_size); 1337 len = self->max_data_size; 1338 } 1339 1340 skb = sock_alloc_send_skb(sk, len + self->max_header_size + 16, 1341 msg->msg_flags & MSG_DONTWAIT, &err); 1342 if (!skb) 1343 goto out_err; 1344 1345 skb_reserve(skb, self->max_header_size + 16); 1346 skb_reset_transport_header(skb); 1347 skb_put(skb, len); 1348 err = memcpy_fromiovec(skb_transport_header(skb), msg->msg_iov, len); 1349 if (err) { 1350 kfree_skb(skb); 1351 goto out_err; 1352 } 1353 1354 /* 1355 * Just send the message to TinyTP, and let it deal with possible 1356 * errors. No need to duplicate all that here 1357 */ 1358 err = irttp_data_request(self->tsap, skb); 1359 if (err) { 1360 IRDA_DEBUG(0, "%s(), err=%d\n", __func__, err); 1361 goto out_err; 1362 } 1363 1364 unlock_kernel(); 1365 /* Tell client how much data we actually sent */ 1366 return len; 1367 1368out_err: 1369 err = sk_stream_error(sk, msg->msg_flags, err); 1370out: 1371 unlock_kernel(); 1372 return err; 1373 1374} 1375 1376/* 1377 * Function irda_recvmsg_dgram (iocb, sock, msg, size, flags) 1378 * 1379 * Try to receive message and copy it to user. The frame is discarded 1380 * after being read, regardless of how much the user actually read 1381 */ 1382static int irda_recvmsg_dgram(struct kiocb *iocb, struct socket *sock, 1383 struct msghdr *msg, size_t size, int flags) 1384{ 1385 struct sock *sk = sock->sk; 1386 struct irda_sock *self = irda_sk(sk); 1387 struct sk_buff *skb; 1388 size_t copied; 1389 int err; 1390 1391 IRDA_DEBUG(4, "%s()\n", __func__); 1392 1393 lock_kernel(); 1394 if ((err = sock_error(sk)) < 0) 1395 goto out; 1396 1397 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT, 1398 flags & MSG_DONTWAIT, &err); 1399 if (!skb) 1400 goto out; 1401 1402 skb_reset_transport_header(skb); 1403 copied = skb->len; 1404 1405 if (copied > size) { 1406 IRDA_DEBUG(2, "%s(), Received truncated frame (%zd < %zd)!\n", 1407 __func__, copied, size); 1408 copied = size; 1409 msg->msg_flags |= MSG_TRUNC; 1410 } 1411 skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied); 1412 1413 skb_free_datagram(sk, skb); 1414 1415 /* 1416 * Check if we have previously stopped IrTTP and we know 1417 * have more free space in our rx_queue. If so tell IrTTP 1418 * to start delivering frames again before our rx_queue gets 1419 * empty 1420 */ 1421 if (self->rx_flow == FLOW_STOP) { 1422 if ((atomic_read(&sk->sk_rmem_alloc) << 2) <= sk->sk_rcvbuf) { 1423 IRDA_DEBUG(2, "%s(), Starting IrTTP\n", __func__); 1424 self->rx_flow = FLOW_START; 1425 irttp_flow_request(self->tsap, FLOW_START); 1426 } 1427 } 1428 unlock_kernel(); 1429 return copied; 1430 1431out: 1432 unlock_kernel(); 1433 return err; 1434} 1435 1436/* 1437 * Function irda_recvmsg_stream (iocb, sock, msg, size, flags) 1438 */ 1439static int irda_recvmsg_stream(struct kiocb *iocb, struct socket *sock, 1440 struct msghdr *msg, size_t size, int flags) 1441{ 1442 struct sock *sk = sock->sk; 1443 struct irda_sock *self = irda_sk(sk); 1444 int noblock = flags & MSG_DONTWAIT; 1445 size_t copied = 0; 1446 int target, err; 1447 long timeo; 1448 1449 IRDA_DEBUG(3, "%s()\n", __func__); 1450 1451 lock_kernel(); 1452 if ((err = sock_error(sk)) < 0) 1453 goto out; 1454 1455 err = -EINVAL; 1456 if (sock->flags & __SO_ACCEPTCON) 1457 goto out; 1458 1459 err =-EOPNOTSUPP; 1460 if (flags & MSG_OOB) 1461 goto out; 1462 1463 err = 0; 1464 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size); 1465 timeo = sock_rcvtimeo(sk, noblock); 1466 1467 msg->msg_namelen = 0; 1468 1469 do { 1470 int chunk; 1471 struct sk_buff *skb = skb_dequeue(&sk->sk_receive_queue); 1472 1473 if (skb == NULL) { 1474 DEFINE_WAIT(wait); 1475 err = 0; 1476 1477 if (copied >= target) 1478 break; 1479 1480 prepare_to_wait_exclusive(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 1481 1482 /* 1483 * POSIX 1003.1g mandates this order. 1484 */ 1485 err = sock_error(sk); 1486 if (err) 1487 ; 1488 else if (sk->sk_shutdown & RCV_SHUTDOWN) 1489 ; 1490 else if (noblock) 1491 err = -EAGAIN; 1492 else if (signal_pending(current)) 1493 err = sock_intr_errno(timeo); 1494 else if (sk->sk_state != TCP_ESTABLISHED) 1495 err = -ENOTCONN; 1496 else if (skb_peek(&sk->sk_receive_queue) == NULL) 1497 /* Wait process until data arrives */ 1498 schedule(); 1499 1500 finish_wait(sk_sleep(sk), &wait); 1501 1502 if (err) 1503 goto out; 1504 if (sk->sk_shutdown & RCV_SHUTDOWN) 1505 break; 1506 1507 continue; 1508 } 1509 1510 chunk = min_t(unsigned int, skb->len, size); 1511 if (memcpy_toiovec(msg->msg_iov, skb->data, chunk)) { 1512 skb_queue_head(&sk->sk_receive_queue, skb); 1513 if (copied == 0) 1514 copied = -EFAULT; 1515 break; 1516 } 1517 copied += chunk; 1518 size -= chunk; 1519 1520 /* Mark read part of skb as used */ 1521 if (!(flags & MSG_PEEK)) { 1522 skb_pull(skb, chunk); 1523 1524 /* put the skb back if we didn't use it up.. */ 1525 if (skb->len) { 1526 IRDA_DEBUG(1, "%s(), back on q!\n", 1527 __func__); 1528 skb_queue_head(&sk->sk_receive_queue, skb); 1529 break; 1530 } 1531 1532 kfree_skb(skb); 1533 } else { 1534 IRDA_DEBUG(0, "%s() questionable!?\n", __func__); 1535 1536 /* put message back and return */ 1537 skb_queue_head(&sk->sk_receive_queue, skb); 1538 break; 1539 } 1540 } while (size); 1541 1542 /* 1543 * Check if we have previously stopped IrTTP and we know 1544 * have more free space in our rx_queue. If so tell IrTTP 1545 * to start delivering frames again before our rx_queue gets 1546 * empty 1547 */ 1548 if (self->rx_flow == FLOW_STOP) { 1549 if ((atomic_read(&sk->sk_rmem_alloc) << 2) <= sk->sk_rcvbuf) { 1550 IRDA_DEBUG(2, "%s(), Starting IrTTP\n", __func__); 1551 self->rx_flow = FLOW_START; 1552 irttp_flow_request(self->tsap, FLOW_START); 1553 } 1554 } 1555 1556out: 1557 unlock_kernel(); 1558 return err ? : copied; 1559} 1560 1561/* 1562 * Function irda_sendmsg_dgram (iocb, sock, msg, len) 1563 * 1564 * Send message down to TinyTP for the unreliable sequenced 1565 * packet service... 1566 * 1567 */ 1568static int irda_sendmsg_dgram(struct kiocb *iocb, struct socket *sock, 1569 struct msghdr *msg, size_t len) 1570{ 1571 struct sock *sk = sock->sk; 1572 struct irda_sock *self; 1573 struct sk_buff *skb; 1574 int err; 1575 1576 lock_kernel(); 1577 1578 IRDA_DEBUG(4, "%s(), len=%zd\n", __func__, len); 1579 1580 err = -EINVAL; 1581 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT)) 1582 goto out; 1583 1584 if (sk->sk_shutdown & SEND_SHUTDOWN) { 1585 send_sig(SIGPIPE, current, 0); 1586 err = -EPIPE; 1587 goto out; 1588 } 1589 1590 err = -ENOTCONN; 1591 if (sk->sk_state != TCP_ESTABLISHED) 1592 goto out; 1593 1594 self = irda_sk(sk); 1595 1596 /* 1597 * Check that we don't send out too big frames. This is an unreliable 1598 * service, so we have no fragmentation and no coalescence 1599 */ 1600 if (len > self->max_data_size) { 1601 IRDA_DEBUG(0, "%s(), Warning to much data! " 1602 "Chopping frame from %zd to %d bytes!\n", 1603 __func__, len, self->max_data_size); 1604 len = self->max_data_size; 1605 } 1606 1607 skb = sock_alloc_send_skb(sk, len + self->max_header_size, 1608 msg->msg_flags & MSG_DONTWAIT, &err); 1609 err = -ENOBUFS; 1610 if (!skb) 1611 goto out; 1612 1613 skb_reserve(skb, self->max_header_size); 1614 skb_reset_transport_header(skb); 1615 1616 IRDA_DEBUG(4, "%s(), appending user data\n", __func__); 1617 skb_put(skb, len); 1618 err = memcpy_fromiovec(skb_transport_header(skb), msg->msg_iov, len); 1619 if (err) { 1620 kfree_skb(skb); 1621 goto out; 1622 } 1623 1624 /* 1625 * Just send the message to TinyTP, and let it deal with possible 1626 * errors. No need to duplicate all that here 1627 */ 1628 err = irttp_udata_request(self->tsap, skb); 1629 if (err) { 1630 IRDA_DEBUG(0, "%s(), err=%d\n", __func__, err); 1631 goto out; 1632 } 1633 unlock_kernel(); 1634 return len; 1635out: 1636 unlock_kernel(); 1637 return err; 1638} 1639 1640/* 1641 * Function irda_sendmsg_ultra (iocb, sock, msg, len) 1642 * 1643 * Send message down to IrLMP for the unreliable Ultra 1644 * packet service... 1645 */ 1646#ifdef CONFIG_IRDA_ULTRA 1647static int irda_sendmsg_ultra(struct kiocb *iocb, struct socket *sock, 1648 struct msghdr *msg, size_t len) 1649{ 1650 struct sock *sk = sock->sk; 1651 struct irda_sock *self; 1652 __u8 pid = 0; 1653 int bound = 0; 1654 struct sk_buff *skb; 1655 int err; 1656 1657 IRDA_DEBUG(4, "%s(), len=%zd\n", __func__, len); 1658 1659 lock_kernel(); 1660 err = -EINVAL; 1661 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT)) 1662 goto out; 1663 1664 err = -EPIPE; 1665 if (sk->sk_shutdown & SEND_SHUTDOWN) { 1666 send_sig(SIGPIPE, current, 0); 1667 goto out; 1668 } 1669 1670 self = irda_sk(sk); 1671 1672 /* Check if an address was specified with sendto. Jean II */ 1673 if (msg->msg_name) { 1674 struct sockaddr_irda *addr = (struct sockaddr_irda *) msg->msg_name; 1675 err = -EINVAL; 1676 /* Check address, extract pid. Jean II */ 1677 if (msg->msg_namelen < sizeof(*addr)) 1678 goto out; 1679 if (addr->sir_family != AF_IRDA) 1680 goto out; 1681 1682 pid = addr->sir_lsap_sel; 1683 if (pid & 0x80) { 1684 IRDA_DEBUG(0, "%s(), extension in PID not supp!\n", __func__); 1685 err = -EOPNOTSUPP; 1686 goto out; 1687 } 1688 } else { 1689 /* Check that the socket is properly bound to an Ultra 1690 * port. Jean II */ 1691 if ((self->lsap == NULL) || 1692 (sk->sk_state != TCP_ESTABLISHED)) { 1693 IRDA_DEBUG(0, "%s(), socket not bound to Ultra PID.\n", 1694 __func__); 1695 err = -ENOTCONN; 1696 goto out; 1697 } 1698 /* Use PID from socket */ 1699 bound = 1; 1700 } 1701 1702 /* 1703 * Check that we don't send out too big frames. This is an unreliable 1704 * service, so we have no fragmentation and no coalescence 1705 */ 1706 if (len > self->max_data_size) { 1707 IRDA_DEBUG(0, "%s(), Warning to much data! " 1708 "Chopping frame from %zd to %d bytes!\n", 1709 __func__, len, self->max_data_size); 1710 len = self->max_data_size; 1711 } 1712 1713 skb = sock_alloc_send_skb(sk, len + self->max_header_size, 1714 msg->msg_flags & MSG_DONTWAIT, &err); 1715 err = -ENOBUFS; 1716 if (!skb) 1717 goto out; 1718 1719 skb_reserve(skb, self->max_header_size); 1720 skb_reset_transport_header(skb); 1721 1722 IRDA_DEBUG(4, "%s(), appending user data\n", __func__); 1723 skb_put(skb, len); 1724 err = memcpy_fromiovec(skb_transport_header(skb), msg->msg_iov, len); 1725 if (err) { 1726 kfree_skb(skb); 1727 goto out; 1728 } 1729 1730 err = irlmp_connless_data_request((bound ? self->lsap : NULL), 1731 skb, pid); 1732 if (err) 1733 IRDA_DEBUG(0, "%s(), err=%d\n", __func__, err); 1734out: 1735 unlock_kernel(); 1736 return err ? : len; 1737} 1738#endif /* CONFIG_IRDA_ULTRA */ 1739 1740/* 1741 * Function irda_shutdown (sk, how) 1742 */ 1743static int irda_shutdown(struct socket *sock, int how) 1744{ 1745 struct sock *sk = sock->sk; 1746 struct irda_sock *self = irda_sk(sk); 1747 1748 IRDA_DEBUG(1, "%s(%p)\n", __func__, self); 1749 1750 lock_kernel(); 1751 1752 sk->sk_state = TCP_CLOSE; 1753 sk->sk_shutdown |= SEND_SHUTDOWN; 1754 sk->sk_state_change(sk); 1755 1756 if (self->iriap) { 1757 iriap_close(self->iriap); 1758 self->iriap = NULL; 1759 } 1760 1761 if (self->tsap) { 1762 irttp_disconnect_request(self->tsap, NULL, P_NORMAL); 1763 irttp_close_tsap(self->tsap); 1764 self->tsap = NULL; 1765 } 1766 1767 /* A few cleanup so the socket look as good as new... */ 1768 self->rx_flow = self->tx_flow = FLOW_START; /* needed ??? */ 1769 self->daddr = DEV_ADDR_ANY; /* Until we get re-connected */ 1770 self->saddr = 0x0; /* so IrLMP assign us any link */ 1771 1772 unlock_kernel(); 1773 1774 return 0; 1775} 1776 1777/* 1778 * Function irda_poll (file, sock, wait) 1779 */ 1780static unsigned int irda_poll(struct file * file, struct socket *sock, 1781 poll_table *wait) 1782{ 1783 struct sock *sk = sock->sk; 1784 struct irda_sock *self = irda_sk(sk); 1785 unsigned int mask; 1786 1787 IRDA_DEBUG(4, "%s()\n", __func__); 1788 1789 lock_kernel(); 1790 poll_wait(file, sk_sleep(sk), wait); 1791 mask = 0; 1792 1793 /* Exceptional events? */ 1794 if (sk->sk_err) 1795 mask |= POLLERR; 1796 if (sk->sk_shutdown & RCV_SHUTDOWN) { 1797 IRDA_DEBUG(0, "%s(), POLLHUP\n", __func__); 1798 mask |= POLLHUP; 1799 } 1800 1801 /* Readable? */ 1802 if (!skb_queue_empty(&sk->sk_receive_queue)) { 1803 IRDA_DEBUG(4, "Socket is readable\n"); 1804 mask |= POLLIN | POLLRDNORM; 1805 } 1806 1807 /* Connection-based need to check for termination and startup */ 1808 switch (sk->sk_type) { 1809 case SOCK_STREAM: 1810 if (sk->sk_state == TCP_CLOSE) { 1811 IRDA_DEBUG(0, "%s(), POLLHUP\n", __func__); 1812 mask |= POLLHUP; 1813 } 1814 1815 if (sk->sk_state == TCP_ESTABLISHED) { 1816 if ((self->tx_flow == FLOW_START) && 1817 sock_writeable(sk)) 1818 { 1819 mask |= POLLOUT | POLLWRNORM | POLLWRBAND; 1820 } 1821 } 1822 break; 1823 case SOCK_SEQPACKET: 1824 if ((self->tx_flow == FLOW_START) && 1825 sock_writeable(sk)) 1826 { 1827 mask |= POLLOUT | POLLWRNORM | POLLWRBAND; 1828 } 1829 break; 1830 case SOCK_DGRAM: 1831 if (sock_writeable(sk)) 1832 mask |= POLLOUT | POLLWRNORM | POLLWRBAND; 1833 break; 1834 default: 1835 break; 1836 } 1837 unlock_kernel(); 1838 return mask; 1839} 1840 1841static unsigned int irda_datagram_poll(struct file *file, struct socket *sock, 1842 poll_table *wait) 1843{ 1844 int err; 1845 1846 lock_kernel(); 1847 err = datagram_poll(file, sock, wait); 1848 unlock_kernel(); 1849 1850 return err; 1851} 1852 1853/* 1854 * Function irda_ioctl (sock, cmd, arg) 1855 */ 1856static int irda_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 1857{ 1858 struct sock *sk = sock->sk; 1859 int err; 1860 1861 IRDA_DEBUG(4, "%s(), cmd=%#x\n", __func__, cmd); 1862 1863 lock_kernel(); 1864 err = -EINVAL; 1865 switch (cmd) { 1866 case TIOCOUTQ: { 1867 long amount; 1868 1869 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk); 1870 if (amount < 0) 1871 amount = 0; 1872 err = put_user(amount, (unsigned int __user *)arg); 1873 break; 1874 } 1875 1876 case TIOCINQ: { 1877 struct sk_buff *skb; 1878 long amount = 0L; 1879 /* These two are safe on a single CPU system as only user tasks fiddle here */ 1880 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL) 1881 amount = skb->len; 1882 err = put_user(amount, (unsigned int __user *)arg); 1883 break; 1884 } 1885 1886 case SIOCGSTAMP: 1887 if (sk != NULL) 1888 err = sock_get_timestamp(sk, (struct timeval __user *)arg); 1889 break; 1890 1891 case SIOCGIFADDR: 1892 case SIOCSIFADDR: 1893 case SIOCGIFDSTADDR: 1894 case SIOCSIFDSTADDR: 1895 case SIOCGIFBRDADDR: 1896 case SIOCSIFBRDADDR: 1897 case SIOCGIFNETMASK: 1898 case SIOCSIFNETMASK: 1899 case SIOCGIFMETRIC: 1900 case SIOCSIFMETRIC: 1901 break; 1902 default: 1903 IRDA_DEBUG(1, "%s(), doing device ioctl!\n", __func__); 1904 err = -ENOIOCTLCMD; 1905 } 1906 unlock_kernel(); 1907 1908 return err; 1909} 1910 1911#ifdef CONFIG_COMPAT 1912/* 1913 * Function irda_ioctl (sock, cmd, arg) 1914 */ 1915static int irda_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 1916{ 1917 /* 1918 * All IRDA's ioctl are standard ones. 1919 */ 1920 return -ENOIOCTLCMD; 1921} 1922#endif 1923 1924/* 1925 * Function irda_setsockopt (sock, level, optname, optval, optlen) 1926 * 1927 * Set some options for the socket 1928 * 1929 */ 1930static int __irda_setsockopt(struct socket *sock, int level, int optname, 1931 char __user *optval, unsigned int optlen) 1932{ 1933 struct sock *sk = sock->sk; 1934 struct irda_sock *self = irda_sk(sk); 1935 struct irda_ias_set *ias_opt; 1936 struct ias_object *ias_obj; 1937 struct ias_attrib * ias_attr; /* Attribute in IAS object */ 1938 int opt, free_ias = 0; 1939 1940 IRDA_DEBUG(2, "%s(%p)\n", __func__, self); 1941 1942 if (level != SOL_IRLMP) 1943 return -ENOPROTOOPT; 1944 1945 switch (optname) { 1946 case IRLMP_IAS_SET: 1947 /* The user want to add an attribute to an existing IAS object 1948 * (in the IAS database) or to create a new object with this 1949 * attribute. 1950 * We first query IAS to know if the object exist, and then 1951 * create the right attribute... 1952 */ 1953 1954 if (optlen != sizeof(struct irda_ias_set)) 1955 return -EINVAL; 1956 1957 ias_opt = kmalloc(sizeof(struct irda_ias_set), GFP_ATOMIC); 1958 if (ias_opt == NULL) 1959 return -ENOMEM; 1960 1961 /* Copy query to the driver. */ 1962 if (copy_from_user(ias_opt, optval, optlen)) { 1963 kfree(ias_opt); 1964 return -EFAULT; 1965 } 1966 1967 if(ias_opt->irda_class_name[0] == '\0') { 1968 if(self->ias_obj == NULL) { 1969 kfree(ias_opt); 1970 return -EINVAL; 1971 } 1972 ias_obj = self->ias_obj; 1973 } else 1974 ias_obj = irias_find_object(ias_opt->irda_class_name); 1975 1976 /* Only ROOT can mess with the global IAS database. 1977 * Users can only add attributes to the object associated 1978 * with the socket they own - Jean II */ 1979 if((!capable(CAP_NET_ADMIN)) && 1980 ((ias_obj == NULL) || (ias_obj != self->ias_obj))) { 1981 kfree(ias_opt); 1982 return -EPERM; 1983 } 1984 1985 /* If the object doesn't exist, create it */ 1986 if(ias_obj == (struct ias_object *) NULL) { 1987 /* Create a new object */ 1988 ias_obj = irias_new_object(ias_opt->irda_class_name, 1989 jiffies); 1990 if (ias_obj == NULL) { 1991 kfree(ias_opt); 1992 return -ENOMEM; 1993 } 1994 free_ias = 1; 1995 } 1996 1997 /* Do we have the attribute already ? */ 1998 if(irias_find_attrib(ias_obj, ias_opt->irda_attrib_name)) { 1999 kfree(ias_opt); 2000 if (free_ias) { 2001 kfree(ias_obj->name); 2002 kfree(ias_obj); 2003 } 2004 return -EINVAL; 2005 } 2006 2007 /* Look at the type */ 2008 switch(ias_opt->irda_attrib_type) { 2009 case IAS_INTEGER: 2010 /* Add an integer attribute */ 2011 irias_add_integer_attrib( 2012 ias_obj, 2013 ias_opt->irda_attrib_name, 2014 ias_opt->attribute.irda_attrib_int, 2015 IAS_USER_ATTR); 2016 break; 2017 case IAS_OCT_SEQ: 2018 /* Check length */ 2019 if(ias_opt->attribute.irda_attrib_octet_seq.len > 2020 IAS_MAX_OCTET_STRING) { 2021 kfree(ias_opt); 2022 if (free_ias) { 2023 kfree(ias_obj->name); 2024 kfree(ias_obj); 2025 } 2026 2027 return -EINVAL; 2028 } 2029 /* Add an octet sequence attribute */ 2030 irias_add_octseq_attrib( 2031 ias_obj, 2032 ias_opt->irda_attrib_name, 2033 ias_opt->attribute.irda_attrib_octet_seq.octet_seq, 2034 ias_opt->attribute.irda_attrib_octet_seq.len, 2035 IAS_USER_ATTR); 2036 break; 2037 case IAS_STRING: 2038 /* Should check charset & co */ 2039 /* Check length */ 2040 /* The length is encoded in a __u8, and 2041 * IAS_MAX_STRING == 256, so there is no way 2042 * userspace can pass us a string too large. 2043 * Jean II */ 2044 /* NULL terminate the string (avoid troubles) */ 2045 ias_opt->attribute.irda_attrib_string.string[ias_opt->attribute.irda_attrib_string.len] = '\0'; 2046 /* Add a string attribute */ 2047 irias_add_string_attrib( 2048 ias_obj, 2049 ias_opt->irda_attrib_name, 2050 ias_opt->attribute.irda_attrib_string.string, 2051 IAS_USER_ATTR); 2052 break; 2053 default : 2054 kfree(ias_opt); 2055 if (free_ias) { 2056 kfree(ias_obj->name); 2057 kfree(ias_obj); 2058 } 2059 return -EINVAL; 2060 } 2061 irias_insert_object(ias_obj); 2062 kfree(ias_opt); 2063 break; 2064 case IRLMP_IAS_DEL: 2065 /* The user want to delete an object from our local IAS 2066 * database. We just need to query the IAS, check is the 2067 * object is not owned by the kernel and delete it. 2068 */ 2069 2070 if (optlen != sizeof(struct irda_ias_set)) 2071 return -EINVAL; 2072 2073 ias_opt = kmalloc(sizeof(struct irda_ias_set), GFP_ATOMIC); 2074 if (ias_opt == NULL) 2075 return -ENOMEM; 2076 2077 /* Copy query to the driver. */ 2078 if (copy_from_user(ias_opt, optval, optlen)) { 2079 kfree(ias_opt); 2080 return -EFAULT; 2081 } 2082 2083 if(ias_opt->irda_class_name[0] == '\0') 2084 ias_obj = self->ias_obj; 2085 else 2086 ias_obj = irias_find_object(ias_opt->irda_class_name); 2087 if(ias_obj == (struct ias_object *) NULL) { 2088 kfree(ias_opt); 2089 return -EINVAL; 2090 } 2091 2092 /* Only ROOT can mess with the global IAS database. 2093 * Users can only del attributes from the object associated 2094 * with the socket they own - Jean II */ 2095 if((!capable(CAP_NET_ADMIN)) && 2096 ((ias_obj == NULL) || (ias_obj != self->ias_obj))) { 2097 kfree(ias_opt); 2098 return -EPERM; 2099 } 2100 2101 /* Find the attribute (in the object) we target */ 2102 ias_attr = irias_find_attrib(ias_obj, 2103 ias_opt->irda_attrib_name); 2104 if(ias_attr == (struct ias_attrib *) NULL) { 2105 kfree(ias_opt); 2106 return -EINVAL; 2107 } 2108 2109 /* Check is the user space own the object */ 2110 if(ias_attr->value->owner != IAS_USER_ATTR) { 2111 IRDA_DEBUG(1, "%s(), attempting to delete a kernel attribute\n", __func__); 2112 kfree(ias_opt); 2113 return -EPERM; 2114 } 2115 2116 /* Remove the attribute (and maybe the object) */ 2117 irias_delete_attrib(ias_obj, ias_attr, 1); 2118 kfree(ias_opt); 2119 break; 2120 case IRLMP_MAX_SDU_SIZE: 2121 if (optlen < sizeof(int)) 2122 return -EINVAL; 2123 2124 if (get_user(opt, (int __user *)optval)) 2125 return -EFAULT; 2126 2127 /* Only possible for a seqpacket service (TTP with SAR) */ 2128 if (sk->sk_type != SOCK_SEQPACKET) { 2129 IRDA_DEBUG(2, "%s(), setting max_sdu_size = %d\n", 2130 __func__, opt); 2131 self->max_sdu_size_rx = opt; 2132 } else { 2133 IRDA_WARNING("%s: not allowed to set MAXSDUSIZE for this socket type!\n", 2134 __func__); 2135 return -ENOPROTOOPT; 2136 } 2137 break; 2138 case IRLMP_HINTS_SET: 2139 if (optlen < sizeof(int)) 2140 return -EINVAL; 2141 2142 /* The input is really a (__u8 hints[2]), easier as an int */ 2143 if (get_user(opt, (int __user *)optval)) 2144 return -EFAULT; 2145 2146 /* Unregister any old registration */ 2147 if (self->skey) 2148 irlmp_unregister_service(self->skey); 2149 2150 self->skey = irlmp_register_service((__u16) opt); 2151 break; 2152 case IRLMP_HINT_MASK_SET: 2153 /* As opposed to the previous case which set the hint bits 2154 * that we advertise, this one set the filter we use when 2155 * making a discovery (nodes which don't match any hint 2156 * bit in the mask are not reported). 2157 */ 2158 if (optlen < sizeof(int)) 2159 return -EINVAL; 2160 2161 /* The input is really a (__u8 hints[2]), easier as an int */ 2162 if (get_user(opt, (int __user *)optval)) 2163 return -EFAULT; 2164 2165 /* Set the new hint mask */ 2166 self->mask.word = (__u16) opt; 2167 /* Mask out extension bits */ 2168 self->mask.word &= 0x7f7f; 2169 /* Check if no bits */ 2170 if(!self->mask.word) 2171 self->mask.word = 0xFFFF; 2172 2173 break; 2174 default: 2175 return -ENOPROTOOPT; 2176 } 2177 return 0; 2178} 2179 2180static int irda_setsockopt(struct socket *sock, int level, int optname, 2181 char __user *optval, unsigned int optlen) 2182{ 2183 int err; 2184 2185 lock_kernel(); 2186 err = __irda_setsockopt(sock, level, optname, optval, optlen); 2187 unlock_kernel(); 2188 2189 return err; 2190} 2191 2192/* 2193 * Function irda_extract_ias_value(ias_opt, ias_value) 2194 * 2195 * Translate internal IAS value structure to the user space representation 2196 * 2197 * The external representation of IAS values, as we exchange them with 2198 * user space program is quite different from the internal representation, 2199 * as stored in the IAS database (because we need a flat structure for 2200 * crossing kernel boundary). 2201 * This function transform the former in the latter. We also check 2202 * that the value type is valid. 2203 */ 2204static int irda_extract_ias_value(struct irda_ias_set *ias_opt, 2205 struct ias_value *ias_value) 2206{ 2207 /* Look at the type */ 2208 switch (ias_value->type) { 2209 case IAS_INTEGER: 2210 /* Copy the integer */ 2211 ias_opt->attribute.irda_attrib_int = ias_value->t.integer; 2212 break; 2213 case IAS_OCT_SEQ: 2214 /* Set length */ 2215 ias_opt->attribute.irda_attrib_octet_seq.len = ias_value->len; 2216 /* Copy over */ 2217 memcpy(ias_opt->attribute.irda_attrib_octet_seq.octet_seq, 2218 ias_value->t.oct_seq, ias_value->len); 2219 break; 2220 case IAS_STRING: 2221 /* Set length */ 2222 ias_opt->attribute.irda_attrib_string.len = ias_value->len; 2223 ias_opt->attribute.irda_attrib_string.charset = ias_value->charset; 2224 /* Copy over */ 2225 memcpy(ias_opt->attribute.irda_attrib_string.string, 2226 ias_value->t.string, ias_value->len); 2227 /* NULL terminate the string (avoid troubles) */ 2228 ias_opt->attribute.irda_attrib_string.string[ias_value->len] = '\0'; 2229 break; 2230 case IAS_MISSING: 2231 default : 2232 return -EINVAL; 2233 } 2234 2235 /* Copy type over */ 2236 ias_opt->irda_attrib_type = ias_value->type; 2237 2238 return 0; 2239} 2240 2241/* 2242 * Function irda_getsockopt (sock, level, optname, optval, optlen) 2243 */ 2244static int __irda_getsockopt(struct socket *sock, int level, int optname, 2245 char __user *optval, int __user *optlen) 2246{ 2247 struct sock *sk = sock->sk; 2248 struct irda_sock *self = irda_sk(sk); 2249 struct irda_device_list list; 2250 struct irda_device_info *discoveries; 2251 struct irda_ias_set * ias_opt; /* IAS get/query params */ 2252 struct ias_object * ias_obj; /* Object in IAS */ 2253 struct ias_attrib * ias_attr; /* Attribute in IAS object */ 2254 int daddr = DEV_ADDR_ANY; /* Dest address for IAS queries */ 2255 int val = 0; 2256 int len = 0; 2257 int err; 2258 int offset, total; 2259 2260 IRDA_DEBUG(2, "%s(%p)\n", __func__, self); 2261 2262 if (level != SOL_IRLMP) 2263 return -ENOPROTOOPT; 2264 2265 if (get_user(len, optlen)) 2266 return -EFAULT; 2267 2268 if(len < 0) 2269 return -EINVAL; 2270 2271 switch (optname) { 2272 case IRLMP_ENUMDEVICES: 2273 /* Ask lmp for the current discovery log */ 2274 discoveries = irlmp_get_discoveries(&list.len, self->mask.word, 2275 self->nslots); 2276 /* Check if the we got some results */ 2277 if (discoveries == NULL) 2278 return -EAGAIN; /* Didn't find any devices */ 2279 err = 0; 2280 2281 /* Write total list length back to client */ 2282 if (copy_to_user(optval, &list, 2283 sizeof(struct irda_device_list) - 2284 sizeof(struct irda_device_info))) 2285 err = -EFAULT; 2286 2287 /* Offset to first device entry */ 2288 offset = sizeof(struct irda_device_list) - 2289 sizeof(struct irda_device_info); 2290 2291 /* Copy the list itself - watch for overflow */ 2292 if(list.len > 2048) 2293 { 2294 err = -EINVAL; 2295 goto bed; 2296 } 2297 total = offset + (list.len * sizeof(struct irda_device_info)); 2298 if (total > len) 2299 total = len; 2300 if (copy_to_user(optval+offset, discoveries, total - offset)) 2301 err = -EFAULT; 2302 2303 /* Write total number of bytes used back to client */ 2304 if (put_user(total, optlen)) 2305 err = -EFAULT; 2306bed: 2307 /* Free up our buffer */ 2308 kfree(discoveries); 2309 if (err) 2310 return err; 2311 break; 2312 case IRLMP_MAX_SDU_SIZE: 2313 val = self->max_data_size; 2314 len = sizeof(int); 2315 if (put_user(len, optlen)) 2316 return -EFAULT; 2317 2318 if (copy_to_user(optval, &val, len)) 2319 return -EFAULT; 2320 break; 2321 case IRLMP_IAS_GET: 2322 /* The user want an object from our local IAS database. 2323 * We just need to query the IAS and return the value 2324 * that we found */ 2325 2326 /* Check that the user has allocated the right space for us */ 2327 if (len != sizeof(struct irda_ias_set)) 2328 return -EINVAL; 2329 2330 ias_opt = kmalloc(sizeof(struct irda_ias_set), GFP_ATOMIC); 2331 if (ias_opt == NULL) 2332 return -ENOMEM; 2333 2334 /* Copy query to the driver. */ 2335 if (copy_from_user(ias_opt, optval, len)) { 2336 kfree(ias_opt); 2337 return -EFAULT; 2338 } 2339 2340 if(ias_opt->irda_class_name[0] == '\0') 2341 ias_obj = self->ias_obj; 2342 else 2343 ias_obj = irias_find_object(ias_opt->irda_class_name); 2344 if(ias_obj == (struct ias_object *) NULL) { 2345 kfree(ias_opt); 2346 return -EINVAL; 2347 } 2348 2349 /* Find the attribute (in the object) we target */ 2350 ias_attr = irias_find_attrib(ias_obj, 2351 ias_opt->irda_attrib_name); 2352 if(ias_attr == (struct ias_attrib *) NULL) { 2353 kfree(ias_opt); 2354 return -EINVAL; 2355 } 2356 2357 /* Translate from internal to user structure */ 2358 err = irda_extract_ias_value(ias_opt, ias_attr->value); 2359 if(err) { 2360 kfree(ias_opt); 2361 return err; 2362 } 2363 2364 /* Copy reply to the user */ 2365 if (copy_to_user(optval, ias_opt, 2366 sizeof(struct irda_ias_set))) { 2367 kfree(ias_opt); 2368 return -EFAULT; 2369 } 2370 /* Note : don't need to put optlen, we checked it */ 2371 kfree(ias_opt); 2372 break; 2373 case IRLMP_IAS_QUERY: 2374 /* The user want an object from a remote IAS database. 2375 * We need to use IAP to query the remote database and 2376 * then wait for the answer to come back. */ 2377 2378 /* Check that the user has allocated the right space for us */ 2379 if (len != sizeof(struct irda_ias_set)) 2380 return -EINVAL; 2381 2382 ias_opt = kmalloc(sizeof(struct irda_ias_set), GFP_ATOMIC); 2383 if (ias_opt == NULL) 2384 return -ENOMEM; 2385 2386 /* Copy query to the driver. */ 2387 if (copy_from_user(ias_opt, optval, len)) { 2388 kfree(ias_opt); 2389 return -EFAULT; 2390 } 2391 2392 /* At this point, there are two cases... 2393 * 1) the socket is connected - that's the easy case, we 2394 * just query the device we are connected to... 2395 * 2) the socket is not connected - the user doesn't want 2396 * to connect and/or may not have a valid service name 2397 * (so can't create a fake connection). In this case, 2398 * we assume that the user pass us a valid destination 2399 * address in the requesting structure... 2400 */ 2401 if(self->daddr != DEV_ADDR_ANY) { 2402 /* We are connected - reuse known daddr */ 2403 daddr = self->daddr; 2404 } else { 2405 /* We are not connected, we must specify a valid 2406 * destination address */ 2407 daddr = ias_opt->daddr; 2408 if((!daddr) || (daddr == DEV_ADDR_ANY)) { 2409 kfree(ias_opt); 2410 return -EINVAL; 2411 } 2412 } 2413 2414 /* Check that we can proceed with IAP */ 2415 if (self->iriap) { 2416 IRDA_WARNING("%s: busy with a previous query\n", 2417 __func__); 2418 kfree(ias_opt); 2419 return -EBUSY; 2420 } 2421 2422 self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self, 2423 irda_getvalue_confirm); 2424 2425 if (self->iriap == NULL) { 2426 kfree(ias_opt); 2427 return -ENOMEM; 2428 } 2429 2430 /* Treat unexpected wakeup as disconnect */ 2431 self->errno = -EHOSTUNREACH; 2432 2433 /* Query remote LM-IAS */ 2434 iriap_getvaluebyclass_request(self->iriap, 2435 self->saddr, daddr, 2436 ias_opt->irda_class_name, 2437 ias_opt->irda_attrib_name); 2438 2439 /* Wait for answer, if not yet finished (or failed) */ 2440 if (wait_event_interruptible(self->query_wait, 2441 (self->iriap == NULL))) { 2442 /* pending request uses copy of ias_opt-content 2443 * we can free it regardless! */ 2444 kfree(ias_opt); 2445 /* Treat signals as disconnect */ 2446 return -EHOSTUNREACH; 2447 } 2448 2449 /* Check what happened */ 2450 if (self->errno) 2451 { 2452 kfree(ias_opt); 2453 /* Requested object/attribute doesn't exist */ 2454 if((self->errno == IAS_CLASS_UNKNOWN) || 2455 (self->errno == IAS_ATTRIB_UNKNOWN)) 2456 return (-EADDRNOTAVAIL); 2457 else 2458 return (-EHOSTUNREACH); 2459 } 2460 2461 /* Translate from internal to user structure */ 2462 err = irda_extract_ias_value(ias_opt, self->ias_result); 2463 if (self->ias_result) 2464 irias_delete_value(self->ias_result); 2465 if (err) { 2466 kfree(ias_opt); 2467 return err; 2468 } 2469 2470 /* Copy reply to the user */ 2471 if (copy_to_user(optval, ias_opt, 2472 sizeof(struct irda_ias_set))) { 2473 kfree(ias_opt); 2474 return -EFAULT; 2475 } 2476 /* Note : don't need to put optlen, we checked it */ 2477 kfree(ias_opt); 2478 break; 2479 case IRLMP_WAITDEVICE: 2480 /* This function is just another way of seeing life ;-) 2481 * IRLMP_ENUMDEVICES assumes that you have a static network, 2482 * and that you just want to pick one of the devices present. 2483 * On the other hand, in here we assume that no device is 2484 * present and that at some point in the future a device will 2485 * come into range. When this device arrive, we just wake 2486 * up the caller, so that he has time to connect to it before 2487 * the device goes away... 2488 * Note : once the node has been discovered for more than a 2489 * few second, it won't trigger this function, unless it 2490 * goes away and come back changes its hint bits (so we 2491 * might call it IRLMP_WAITNEWDEVICE). 2492 */ 2493 2494 /* Check that the user is passing us an int */ 2495 if (len != sizeof(int)) 2496 return -EINVAL; 2497 /* Get timeout in ms (max time we block the caller) */ 2498 if (get_user(val, (int __user *)optval)) 2499 return -EFAULT; 2500 2501 /* Tell IrLMP we want to be notified */ 2502 irlmp_update_client(self->ckey, self->mask.word, 2503 irda_selective_discovery_indication, 2504 NULL, (void *) self); 2505 2506 /* Do some discovery (and also return cached results) */ 2507 irlmp_discovery_request(self->nslots); 2508 2509 /* Wait until a node is discovered */ 2510 if (!self->cachedaddr) { 2511 int ret = 0; 2512 2513 IRDA_DEBUG(1, "%s(), nothing discovered yet, going to sleep...\n", __func__); 2514 2515 /* Set watchdog timer to expire in <val> ms. */ 2516 self->errno = 0; 2517 setup_timer(&self->watchdog, irda_discovery_timeout, 2518 (unsigned long)self); 2519 self->watchdog.expires = jiffies + (val * HZ/1000); 2520 add_timer(&(self->watchdog)); 2521 2522 /* Wait for IR-LMP to call us back */ 2523 __wait_event_interruptible(self->query_wait, 2524 (self->cachedaddr != 0 || self->errno == -ETIME), 2525 ret); 2526 2527 /* If watchdog is still activated, kill it! */ 2528 if(timer_pending(&(self->watchdog))) 2529 del_timer(&(self->watchdog)); 2530 2531 IRDA_DEBUG(1, "%s(), ...waking up !\n", __func__); 2532 2533 if (ret != 0) 2534 return ret; 2535 } 2536 else 2537 IRDA_DEBUG(1, "%s(), found immediately !\n", 2538 __func__); 2539 2540 /* Tell IrLMP that we have been notified */ 2541 irlmp_update_client(self->ckey, self->mask.word, 2542 NULL, NULL, NULL); 2543 2544 /* Check if the we got some results */ 2545 if (!self->cachedaddr) 2546 return -EAGAIN; /* Didn't find any devices */ 2547 daddr = self->cachedaddr; 2548 /* Cleanup */ 2549 self->cachedaddr = 0; 2550 2551 /* We return the daddr of the device that trigger the 2552 * wakeup. As irlmp pass us only the new devices, we 2553 * are sure that it's not an old device. 2554 * If the user want more details, he should query 2555 * the whole discovery log and pick one device... 2556 */ 2557 if (put_user(daddr, (int __user *)optval)) 2558 return -EFAULT; 2559 2560 break; 2561 default: 2562 return -ENOPROTOOPT; 2563 } 2564 2565 return 0; 2566} 2567 2568static int irda_getsockopt(struct socket *sock, int level, int optname, 2569 char __user *optval, int __user *optlen) 2570{ 2571 int err; 2572 2573 lock_kernel(); 2574 err = __irda_getsockopt(sock, level, optname, optval, optlen); 2575 unlock_kernel(); 2576 2577 return err; 2578} 2579 2580static const struct net_proto_family irda_family_ops = { 2581 .family = PF_IRDA, 2582 .create = irda_create, 2583 .owner = THIS_MODULE, 2584}; 2585 2586static const struct proto_ops irda_stream_ops = { 2587 .family = PF_IRDA, 2588 .owner = THIS_MODULE, 2589 .release = irda_release, 2590 .bind = irda_bind, 2591 .connect = irda_connect, 2592 .socketpair = sock_no_socketpair, 2593 .accept = irda_accept, 2594 .getname = irda_getname, 2595 .poll = irda_poll, 2596 .ioctl = irda_ioctl, 2597#ifdef CONFIG_COMPAT 2598 .compat_ioctl = irda_compat_ioctl, 2599#endif 2600 .listen = irda_listen, 2601 .shutdown = irda_shutdown, 2602 .setsockopt = irda_setsockopt, 2603 .getsockopt = irda_getsockopt, 2604 .sendmsg = irda_sendmsg, 2605 .recvmsg = irda_recvmsg_stream, 2606 .mmap = sock_no_mmap, 2607 .sendpage = sock_no_sendpage, 2608}; 2609 2610static const struct proto_ops irda_seqpacket_ops = { 2611 .family = PF_IRDA, 2612 .owner = THIS_MODULE, 2613 .release = irda_release, 2614 .bind = irda_bind, 2615 .connect = irda_connect, 2616 .socketpair = sock_no_socketpair, 2617 .accept = irda_accept, 2618 .getname = irda_getname, 2619 .poll = irda_datagram_poll, 2620 .ioctl = irda_ioctl, 2621#ifdef CONFIG_COMPAT 2622 .compat_ioctl = irda_compat_ioctl, 2623#endif 2624 .listen = irda_listen, 2625 .shutdown = irda_shutdown, 2626 .setsockopt = irda_setsockopt, 2627 .getsockopt = irda_getsockopt, 2628 .sendmsg = irda_sendmsg, 2629 .recvmsg = irda_recvmsg_dgram, 2630 .mmap = sock_no_mmap, 2631 .sendpage = sock_no_sendpage, 2632}; 2633 2634static const struct proto_ops irda_dgram_ops = { 2635 .family = PF_IRDA, 2636 .owner = THIS_MODULE, 2637 .release = irda_release, 2638 .bind = irda_bind, 2639 .connect = irda_connect, 2640 .socketpair = sock_no_socketpair, 2641 .accept = irda_accept, 2642 .getname = irda_getname, 2643 .poll = irda_datagram_poll, 2644 .ioctl = irda_ioctl, 2645#ifdef CONFIG_COMPAT 2646 .compat_ioctl = irda_compat_ioctl, 2647#endif 2648 .listen = irda_listen, 2649 .shutdown = irda_shutdown, 2650 .setsockopt = irda_setsockopt, 2651 .getsockopt = irda_getsockopt, 2652 .sendmsg = irda_sendmsg_dgram, 2653 .recvmsg = irda_recvmsg_dgram, 2654 .mmap = sock_no_mmap, 2655 .sendpage = sock_no_sendpage, 2656}; 2657 2658#ifdef CONFIG_IRDA_ULTRA 2659static const struct proto_ops irda_ultra_ops = { 2660 .family = PF_IRDA, 2661 .owner = THIS_MODULE, 2662 .release = irda_release, 2663 .bind = irda_bind, 2664 .connect = sock_no_connect, 2665 .socketpair = sock_no_socketpair, 2666 .accept = sock_no_accept, 2667 .getname = irda_getname, 2668 .poll = irda_datagram_poll, 2669 .ioctl = irda_ioctl, 2670#ifdef CONFIG_COMPAT 2671 .compat_ioctl = irda_compat_ioctl, 2672#endif 2673 .listen = sock_no_listen, 2674 .shutdown = irda_shutdown, 2675 .setsockopt = irda_setsockopt, 2676 .getsockopt = irda_getsockopt, 2677 .sendmsg = irda_sendmsg_ultra, 2678 .recvmsg = irda_recvmsg_dgram, 2679 .mmap = sock_no_mmap, 2680 .sendpage = sock_no_sendpage, 2681}; 2682#endif /* CONFIG_IRDA_ULTRA */ 2683 2684/* 2685 * Function irsock_init (pro) 2686 * 2687 * Initialize IrDA protocol 2688 * 2689 */ 2690int __init irsock_init(void) 2691{ 2692 int rc = proto_register(&irda_proto, 0); 2693 2694 if (rc == 0) 2695 rc = sock_register(&irda_family_ops); 2696 2697 return rc; 2698} 2699 2700/* 2701 * Function irsock_cleanup (void) 2702 * 2703 * Remove IrDA protocol 2704 * 2705 */ 2706void irsock_cleanup(void) 2707{ 2708 sock_unregister(PF_IRDA); 2709 proto_unregister(&irda_proto); 2710} 2711