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