net/irda/af_irda.c

   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
  65 static int irda_create(struct net *net, struct socket *sock, int protocol, int kern);
  66
  67 static const struct proto_ops irda_stream_ops;
  68 static const struct proto_ops irda_seqpacket_ops;
  69 static const struct proto_ops irda_dgram_ops;
  70
  71 #ifdef CONFIG_IRDA_ULTRA
  72 static 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  */
  84 static 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  */
 113 static 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  */
 176 static 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  */
 241 static 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  */
 303 static 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  */
 329 static 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  */
 368 static 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  */
 414 static 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  */
 443 static 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  */
 467 static 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(&notify);
 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                                      &notify);
 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
 507 static 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(&notify);
 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, &notify, 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  */
 543 static 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  */
 623 static 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  */
 712 static 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;
 743 out:
 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  */
 754 static 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         }
 772 out:
 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  */
 784 static 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;
 838 out:
 839         unlock_kernel();
 840         return err;
 841 }
 842
 843 /*
 844  * Function irda_accept (sock, newsock, flags)
 845  *
 846  *    Wait for incoming connection
 847  *
 848  */
 849 static 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;
 949 out:
 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  */
 974 static 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;
1086 out:
1087         unlock_kernel();
1088         return err;
1089 }
1090
1091 static 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  */
1103 static 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  */
1190 static 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  */
1225 static 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  */
1291 static 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
1368 out_err:
1369         err = sk_stream_error(sk, msg->msg_flags, err);
1370 out:
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  */
1382 static 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
1431 out:
1432         unlock_kernel();
1433         return err;
1434 }
1435
1436 /*
1437  * Function irda_recvmsg_stream (iocb, sock, msg, size, flags)
1438  */
1439 static 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
1556 out:
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  */
1568 static 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;
1635 out:
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
1647 static 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);
1734 out:
1735         unlock_kernel();
1736         return err ? : len;
1737 }
1738 #endif /* CONFIG_IRDA_ULTRA */
1739
1740 /*
1741  * Function irda_shutdown (sk, how)
1742  */
1743 static 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  */
1780 static 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
1841 static 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  */
1856 static 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  */
1915 static 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  */
1930 static 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                 /* Find the object we target.
1968                  * If the user gives us an empty string, we use the object
1969                  * associated with this socket. This will workaround
1970                  * duplicated class name - Jean II */
1971                 if(ias_opt->irda_class_name[0] == '\0') {
1972                         if(self->ias_obj == NULL) {
1973                                 kfree(ias_opt);
1974                                 return -EINVAL;
1975                         }
1976                         ias_obj = self->ias_obj;
1977                 } else
1978                         ias_obj = irias_find_object(ias_opt->irda_class_name);
1979
1980                 /* Only ROOT can mess with the global IAS database.
1981                  * Users can only add attributes to the object associated
1982                  * with the socket they own - Jean II */
1983                 if((!capable(CAP_NET_ADMIN)) &&
1984                    ((ias_obj == NULL) || (ias_obj != self->ias_obj))) {
1985                         kfree(ias_opt);
1986                         return -EPERM;
1987                 }
1988
1989                 /* If the object doesn't exist, create it */
1990                 if(ias_obj == (struct ias_object *) NULL) {
1991                         /* Create a new object */
1992                         ias_obj = irias_new_object(ias_opt->irda_class_name,
1993                                                    jiffies);
1994                         if (ias_obj == NULL) {
1995                                 kfree(ias_opt);
1996                                 return -ENOMEM;
1997                         }
1998                         free_ias = 1;
1999                 }
2000
2001                 /* Do we have the attribute already ? */
2002                 if(irias_find_attrib(ias_obj, ias_opt->irda_attrib_name)) {
2003                         kfree(ias_opt);
2004                         if (free_ias) {
2005                                 kfree(ias_obj->name);
2006                                 kfree(ias_obj);
2007                         }
2008                         return -EINVAL;
2009                 }
2010
2011                 /* Look at the type */
2012                 switch(ias_opt->irda_attrib_type) {
2013                 case IAS_INTEGER:
2014                         /* Add an integer attribute */
2015                         irias_add_integer_attrib(
2016                                 ias_obj,
2017                                 ias_opt->irda_attrib_name,
2018                                 ias_opt->attribute.irda_attrib_int,
2019                                 IAS_USER_ATTR);
2020                         break;
2021                 case IAS_OCT_SEQ:
2022                         /* Check length */
2023                         if(ias_opt->attribute.irda_attrib_octet_seq.len >
2024                            IAS_MAX_OCTET_STRING) {
2025                                 kfree(ias_opt);
2026                                 if (free_ias) {
2027                                         kfree(ias_obj->name);
2028                                         kfree(ias_obj);
2029                                 }
2030
2031                                 return -EINVAL;
2032                         }
2033                         /* Add an octet sequence attribute */
2034                         irias_add_octseq_attrib(
2035                               ias_obj,
2036                               ias_opt->irda_attrib_name,
2037                               ias_opt->attribute.irda_attrib_octet_seq.octet_seq,
2038                               ias_opt->attribute.irda_attrib_octet_seq.len,
2039                               IAS_USER_ATTR);
2040                         break;
2041                 case IAS_STRING:
2042                         /* Should check charset & co */
2043                         /* Check length */
2044                         /* The length is encoded in a __u8, and
2045                          * IAS_MAX_STRING == 256, so there is no way
2046                          * userspace can pass us a string too large.
2047                          * Jean II */
2048                         /* NULL terminate the string (avoid troubles) */
2049                         ias_opt->attribute.irda_attrib_string.string[ias_opt->attribute.irda_attrib_string.len] = '\0';
2050                         /* Add a string attribute */
2051                         irias_add_string_attrib(
2052                                 ias_obj,
2053                                 ias_opt->irda_attrib_name,
2054                                 ias_opt->attribute.irda_attrib_string.string,
2055                                 IAS_USER_ATTR);
2056                         break;
2057                 default :
2058                         kfree(ias_opt);
2059                         if (free_ias) {
2060                                 kfree(ias_obj->name);
2061                                 kfree(ias_obj);
2062                         }
2063                         return -EINVAL;
2064                 }
2065                 irias_insert_object(ias_obj);
2066                 kfree(ias_opt);
2067                 break;
2068         case IRLMP_IAS_DEL:
2069                 /* The user want to delete an object from our local IAS
2070                  * database. We just need to query the IAS, check is the
2071                  * object is not owned by the kernel and delete it.
2072                  */
2073
2074                 if (optlen != sizeof(struct irda_ias_set))
2075                         return -EINVAL;
2076
2077                 ias_opt = kmalloc(sizeof(struct irda_ias_set), GFP_ATOMIC);
2078                 if (ias_opt == NULL)
2079                         return -ENOMEM;
2080
2081                 /* Copy query to the driver. */
2082                 if (copy_from_user(ias_opt, optval, optlen)) {
2083                         kfree(ias_opt);
2084                         return -EFAULT;
2085                 }
2086
2087                 /* Find the object we target.
2088                  * If the user gives us an empty string, we use the object
2089                  * associated with this socket. This will workaround
2090                  * duplicated class name - Jean II */
2091                 if(ias_opt->irda_class_name[0] == '\0')
2092                         ias_obj = self->ias_obj;
2093                 else
2094                         ias_obj = irias_find_object(ias_opt->irda_class_name);
2095                 if(ias_obj == (struct ias_object *) NULL) {
2096                         kfree(ias_opt);
2097                         return -EINVAL;
2098                 }
2099
2100                 /* Only ROOT can mess with the global IAS database.
2101                  * Users can only del attributes from the object associated
2102                  * with the socket they own - Jean II */
2103                 if((!capable(CAP_NET_ADMIN)) &&
2104                    ((ias_obj == NULL) || (ias_obj != self->ias_obj))) {
2105                         kfree(ias_opt);
2106                         return -EPERM;
2107                 }
2108
2109                 /* Find the attribute (in the object) we target */
2110                 ias_attr = irias_find_attrib(ias_obj,
2111                                              ias_opt->irda_attrib_name);
2112                 if(ias_attr == (struct ias_attrib *) NULL) {
2113                         kfree(ias_opt);
2114                         return -EINVAL;
2115                 }
2116
2117                 /* Check is the user space own the object */
2118                 if(ias_attr->value->owner != IAS_USER_ATTR) {
2119                         IRDA_DEBUG(1, "%s(), attempting to delete a kernel attribute\n", __func__);
2120                         kfree(ias_opt);
2121                         return -EPERM;
2122                 }
2123
2124                 /* Remove the attribute (and maybe the object) */
2125                 irias_delete_attrib(ias_obj, ias_attr, 1);
2126                 kfree(ias_opt);
2127                 break;
2128         case IRLMP_MAX_SDU_SIZE:
2129                 if (optlen < sizeof(int))
2130                         return -EINVAL;
2131
2132                 if (get_user(opt, (int __user *)optval))
2133                         return -EFAULT;
2134
2135                 /* Only possible for a seqpacket service (TTP with SAR) */
2136                 if (sk->sk_type != SOCK_SEQPACKET) {
2137                         IRDA_DEBUG(2, "%s(), setting max_sdu_size = %d\n",
2138                                    __func__, opt);
2139                         self->max_sdu_size_rx = opt;
2140                 } else {
2141                         IRDA_WARNING("%s: not allowed to set MAXSDUSIZE for this socket type!\n",
2142                                      __func__);
2143                         return -ENOPROTOOPT;
2144                 }
2145                 break;
2146         case IRLMP_HINTS_SET:
2147                 if (optlen < sizeof(int))
2148                         return -EINVAL;
2149
2150                 /* The input is really a (__u8 hints[2]), easier as an int */
2151                 if (get_user(opt, (int __user *)optval))
2152                         return -EFAULT;
2153
2154                 /* Unregister any old registration */
2155                 if (self->skey)
2156                         irlmp_unregister_service(self->skey);
2157
2158                 self->skey = irlmp_register_service((__u16) opt);
2159                 break;
2160         case IRLMP_HINT_MASK_SET:
2161                 /* As opposed to the previous case which set the hint bits
2162                  * that we advertise, this one set the filter we use when
2163                  * making a discovery (nodes which don't match any hint
2164                  * bit in the mask are not reported).
2165                  */
2166                 if (optlen < sizeof(int))
2167                         return -EINVAL;
2168
2169                 /* The input is really a (__u8 hints[2]), easier as an int */
2170                 if (get_user(opt, (int __user *)optval))
2171                         return -EFAULT;
2172
2173                 /* Set the new hint mask */
2174                 self->mask.word = (__u16) opt;
2175                 /* Mask out extension bits */
2176                 self->mask.word &= 0x7f7f;
2177                 /* Check if no bits */
2178                 if(!self->mask.word)
2179                         self->mask.word = 0xFFFF;
2180
2181                 break;
2182         default:
2183                 return -ENOPROTOOPT;
2184         }
2185         return 0;
2186 }
2187
2188 static int irda_setsockopt(struct socket *sock, int level, int optname,
2189                            char __user *optval, unsigned int optlen)
2190 {
2191         int err;
2192
2193         lock_kernel();
2194         err = __irda_setsockopt(sock, level, optname, optval, optlen);
2195         unlock_kernel();
2196
2197         return err;
2198 }
2199
2200 /*
2201  * Function irda_extract_ias_value(ias_opt, ias_value)
2202  *
2203  *    Translate internal IAS value structure to the user space representation
2204  *
2205  * The external representation of IAS values, as we exchange them with
2206  * user space program is quite different from the internal representation,
2207  * as stored in the IAS database (because we need a flat structure for
2208  * crossing kernel boundary).
2209  * This function transform the former in the latter. We also check
2210  * that the value type is valid.
2211  */
2212 static int irda_extract_ias_value(struct irda_ias_set *ias_opt,
2213                                   struct ias_value *ias_value)
2214 {
2215         /* Look at the type */
2216         switch (ias_value->type) {
2217         case IAS_INTEGER:
2218                 /* Copy the integer */
2219                 ias_opt->attribute.irda_attrib_int = ias_value->t.integer;
2220                 break;
2221         case IAS_OCT_SEQ:
2222                 /* Set length */
2223                 ias_opt->attribute.irda_attrib_octet_seq.len = ias_value->len;
2224                 /* Copy over */
2225                 memcpy(ias_opt->attribute.irda_attrib_octet_seq.octet_seq,
2226                        ias_value->t.oct_seq, ias_value->len);
2227                 break;
2228         case IAS_STRING:
2229                 /* Set length */
2230                 ias_opt->attribute.irda_attrib_string.len = ias_value->len;
2231                 ias_opt->attribute.irda_attrib_string.charset = ias_value->charset;
2232                 /* Copy over */
2233                 memcpy(ias_opt->attribute.irda_attrib_string.string,
2234                        ias_value->t.string, ias_value->len);
2235                 /* NULL terminate the string (avoid troubles) */
2236                 ias_opt->attribute.irda_attrib_string.string[ias_value->len] = '\0';
2237                 break;
2238         case IAS_MISSING:
2239         default :
2240                 return -EINVAL;
2241         }
2242
2243         /* Copy type over */
2244         ias_opt->irda_attrib_type = ias_value->type;
2245
2246         return 0;
2247 }
2248
2249 /*
2250  * Function irda_getsockopt (sock, level, optname, optval, optlen)
2251  */
2252 static int __irda_getsockopt(struct socket *sock, int level, int optname,
2253                            char __user *optval, int __user *optlen)
2254 {
2255         struct sock *sk = sock->sk;
2256         struct irda_sock *self = irda_sk(sk);
2257         struct irda_device_list list;
2258         struct irda_device_info *discoveries;
2259         struct irda_ias_set *   ias_opt;        /* IAS get/query params */
2260         struct ias_object *     ias_obj;        /* Object in IAS */
2261         struct ias_attrib *     ias_attr;       /* Attribute in IAS object */
2262         int daddr = DEV_ADDR_ANY;       /* Dest address for IAS queries */
2263         int val = 0;
2264         int len = 0;
2265         int err;
2266         int offset, total;
2267
2268         IRDA_DEBUG(2, "%s(%p)\n", __func__, self);
2269
2270         if (level != SOL_IRLMP)
2271                 return -ENOPROTOOPT;
2272
2273         if (get_user(len, optlen))
2274                 return -EFAULT;
2275
2276         if(len < 0)
2277                 return -EINVAL;
2278
2279         switch (optname) {
2280         case IRLMP_ENUMDEVICES:
2281                 /* Ask lmp for the current discovery log */
2282                 discoveries = irlmp_get_discoveries(&list.len, self->mask.word,
2283                                                     self->nslots);
2284                 /* Check if the we got some results */
2285                 if (discoveries == NULL)
2286                         return -EAGAIN;         /* Didn't find any devices */
2287                 err = 0;
2288
2289                 /* Write total list length back to client */
2290                 if (copy_to_user(optval, &list,
2291                                  sizeof(struct irda_device_list) -
2292                                  sizeof(struct irda_device_info)))
2293                         err = -EFAULT;
2294
2295                 /* Offset to first device entry */
2296                 offset = sizeof(struct irda_device_list) -
2297                         sizeof(struct irda_device_info);
2298
2299                 /* Copy the list itself - watch for overflow */
2300                 if(list.len > 2048)
2301                 {
2302                         err = -EINVAL;
2303                         goto bed;
2304                 }
2305                 total = offset + (list.len * sizeof(struct irda_device_info));
2306                 if (total > len)
2307                         total = len;
2308                 if (copy_to_user(optval+offset, discoveries, total - offset))
2309                         err = -EFAULT;
2310
2311                 /* Write total number of bytes used back to client */
2312                 if (put_user(total, optlen))
2313                         err = -EFAULT;
2314 bed:
2315                 /* Free up our buffer */
2316                 kfree(discoveries);
2317                 if (err)
2318                         return err;
2319                 break;
2320         case IRLMP_MAX_SDU_SIZE:
2321                 val = self->max_data_size;
2322                 len = sizeof(int);
2323                 if (put_user(len, optlen))
2324                         return -EFAULT;
2325
2326                 if (copy_to_user(optval, &val, len))
2327                         return -EFAULT;
2328                 break;
2329         case IRLMP_IAS_GET:
2330                 /* The user want an object from our local IAS database.
2331                  * We just need to query the IAS and return the value
2332                  * that we found */
2333
2334                 /* Check that the user has allocated the right space for us */
2335                 if (len != sizeof(struct irda_ias_set))
2336                         return -EINVAL;
2337
2338                 ias_opt = kmalloc(sizeof(struct irda_ias_set), GFP_ATOMIC);
2339                 if (ias_opt == NULL)
2340                         return -ENOMEM;
2341
2342                 /* Copy query to the driver. */
2343                 if (copy_from_user(ias_opt, optval, len)) {
2344                         kfree(ias_opt);
2345                         return -EFAULT;
2346                 }
2347
2348                 /* Find the object we target.
2349                  * If the user gives us an empty string, we use the object
2350                  * associated with this socket. This will workaround
2351                  * duplicated class name - Jean II */
2352                 if(ias_opt->irda_class_name[0] == '\0')
2353                         ias_obj = self->ias_obj;
2354                 else
2355                         ias_obj = irias_find_object(ias_opt->irda_class_name);
2356                 if(ias_obj == (struct ias_object *) NULL) {
2357                         kfree(ias_opt);
2358                         return -EINVAL;
2359                 }
2360
2361                 /* Find the attribute (in the object) we target */
2362                 ias_attr = irias_find_attrib(ias_obj,
2363                                              ias_opt->irda_attrib_name);
2364                 if(ias_attr == (struct ias_attrib *) NULL) {
2365                         kfree(ias_opt);
2366                         return -EINVAL;
2367                 }
2368
2369                 /* Translate from internal to user structure */
2370                 err = irda_extract_ias_value(ias_opt, ias_attr->value);
2371                 if(err) {
2372                         kfree(ias_opt);
2373                         return err;
2374                 }
2375
2376                 /* Copy reply to the user */
2377                 if (copy_to_user(optval, ias_opt,
2378                                  sizeof(struct irda_ias_set))) {
2379                         kfree(ias_opt);
2380                         return -EFAULT;
2381                 }
2382                 /* Note : don't need to put optlen, we checked it */
2383                 kfree(ias_opt);
2384                 break;
2385         case IRLMP_IAS_QUERY:
2386                 /* The user want an object from a remote IAS database.
2387                  * We need to use IAP to query the remote database and
2388                  * then wait for the answer to come back. */
2389
2390                 /* Check that the user has allocated the right space for us */
2391                 if (len != sizeof(struct irda_ias_set))
2392                         return -EINVAL;
2393
2394                 ias_opt = kmalloc(sizeof(struct irda_ias_set), GFP_ATOMIC);
2395                 if (ias_opt == NULL)
2396                         return -ENOMEM;
2397
2398                 /* Copy query to the driver. */
2399                 if (copy_from_user(ias_opt, optval, len)) {
2400                         kfree(ias_opt);
2401                         return -EFAULT;
2402                 }
2403
2404                 /* At this point, there are two cases...
2405                  * 1) the socket is connected - that's the easy case, we
2406                  *      just query the device we are connected to...
2407                  * 2) the socket is not connected - the user doesn't want
2408                  *      to connect and/or may not have a valid service name
2409                  *      (so can't create a fake connection). In this case,
2410                  *      we assume that the user pass us a valid destination
2411                  *      address in the requesting structure...
2412                  */
2413                 if(self->daddr != DEV_ADDR_ANY) {
2414                         /* We are connected - reuse known daddr */
2415                         daddr = self->daddr;
2416                 } else {
2417                         /* We are not connected, we must specify a valid
2418                          * destination address */
2419                         daddr = ias_opt->daddr;
2420                         if((!daddr) || (daddr == DEV_ADDR_ANY)) {
2421                                 kfree(ias_opt);
2422                                 return -EINVAL;
2423                         }
2424                 }
2425
2426                 /* Check that we can proceed with IAP */
2427                 if (self->iriap) {
2428                         IRDA_WARNING("%s: busy with a previous query\n",
2429                                      __func__);
2430                         kfree(ias_opt);
2431                         return -EBUSY;
2432                 }
2433
2434                 self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self,
2435                                          irda_getvalue_confirm);
2436
2437                 if (self->iriap == NULL) {
2438                         kfree(ias_opt);
2439                         return -ENOMEM;
2440                 }
2441
2442                 /* Treat unexpected wakeup as disconnect */
2443                 self->errno = -EHOSTUNREACH;
2444
2445                 /* Query remote LM-IAS */
2446                 iriap_getvaluebyclass_request(self->iriap,
2447                                               self->saddr, daddr,
2448                                               ias_opt->irda_class_name,
2449                                               ias_opt->irda_attrib_name);
2450
2451                 /* Wait for answer, if not yet finished (or failed) */
2452                 if (wait_event_interruptible(self->query_wait,
2453                                              (self->iriap == NULL))) {
2454                         /* pending request uses copy of ias_opt-content
2455                          * we can free it regardless! */
2456                         kfree(ias_opt);
2457                         /* Treat signals as disconnect */
2458                         return -EHOSTUNREACH;
2459                 }
2460
2461                 /* Check what happened */
2462                 if (self->errno)
2463                 {
2464                         kfree(ias_opt);
2465                         /* Requested object/attribute doesn't exist */
2466                         if((self->errno == IAS_CLASS_UNKNOWN) ||
2467                            (self->errno == IAS_ATTRIB_UNKNOWN))
2468                                 return (-EADDRNOTAVAIL);
2469                         else
2470                                 return (-EHOSTUNREACH);
2471                 }
2472
2473                 /* Translate from internal to user structure */
2474                 err = irda_extract_ias_value(ias_opt, self->ias_result);
2475                 if (self->ias_result)
2476                         irias_delete_value(self->ias_result);
2477                 if (err) {
2478                         kfree(ias_opt);
2479                         return err;
2480                 }
2481
2482                 /* Copy reply to the user */
2483                 if (copy_to_user(optval, ias_opt,
2484                                  sizeof(struct irda_ias_set))) {
2485                         kfree(ias_opt);
2486                         return -EFAULT;
2487                 }
2488                 /* Note : don't need to put optlen, we checked it */
2489                 kfree(ias_opt);
2490                 break;
2491         case IRLMP_WAITDEVICE:
2492                 /* This function is just another way of seeing life ;-)
2493                  * IRLMP_ENUMDEVICES assumes that you have a static network,
2494                  * and that you just want to pick one of the devices present.
2495                  * On the other hand, in here we assume that no device is
2496                  * present and that at some point in the future a device will
2497                  * come into range. When this device arrive, we just wake
2498                  * up the caller, so that he has time to connect to it before
2499                  * the device goes away...
2500                  * Note : once the node has been discovered for more than a
2501                  * few second, it won't trigger this function, unless it
2502                  * goes away and come back changes its hint bits (so we
2503                  * might call it IRLMP_WAITNEWDEVICE).
2504                  */
2505
2506                 /* Check that the user is passing us an int */
2507                 if (len != sizeof(int))
2508                         return -EINVAL;
2509                 /* Get timeout in ms (max time we block the caller) */
2510                 if (get_user(val, (int __user *)optval))
2511                         return -EFAULT;
2512
2513                 /* Tell IrLMP we want to be notified */
2514                 irlmp_update_client(self->ckey, self->mask.word,
2515                                     irda_selective_discovery_indication,
2516                                     NULL, (void *) self);
2517
2518                 /* Do some discovery (and also return cached results) */
2519                 irlmp_discovery_request(self->nslots);
2520
2521                 /* Wait until a node is discovered */
2522                 if (!self->cachedaddr) {
2523                         int ret = 0;
2524
2525                         IRDA_DEBUG(1, "%s(), nothing discovered yet, going to sleep...\n", __func__);
2526
2527                         /* Set watchdog timer to expire in <val> ms. */
2528                         self->errno = 0;
2529                         setup_timer(&self->watchdog, irda_discovery_timeout,
2530                                         (unsigned long)self);
2531                         self->watchdog.expires = jiffies + (val * HZ/1000);
2532                         add_timer(&(self->watchdog));
2533
2534                         /* Wait for IR-LMP to call us back */
2535                         __wait_event_interruptible(self->query_wait,
2536                               (self->cachedaddr != 0 || self->errno == -ETIME),
2537                                                    ret);
2538
2539                         /* If watchdog is still activated, kill it! */
2540                         if(timer_pending(&(self->watchdog)))
2541                                 del_timer(&(self->watchdog));
2542
2543                         IRDA_DEBUG(1, "%s(), ...waking up !\n", __func__);
2544
2545                         if (ret != 0)
2546                                 return ret;
2547                 }
2548                 else
2549                         IRDA_DEBUG(1, "%s(), found immediately !\n",
2550                                    __func__);
2551
2552                 /* Tell IrLMP that we have been notified */
2553                 irlmp_update_client(self->ckey, self->mask.word,
2554                                     NULL, NULL, NULL);
2555
2556                 /* Check if the we got some results */
2557                 if (!self->cachedaddr)
2558                         return -EAGAIN;         /* Didn't find any devices */
2559                 daddr = self->cachedaddr;
2560                 /* Cleanup */
2561                 self->cachedaddr = 0;
2562
2563                 /* We return the daddr of the device that trigger the
2564                  * wakeup. As irlmp pass us only the new devices, we
2565                  * are sure that it's not an old device.
2566                  * If the user want more details, he should query
2567                  * the whole discovery log and pick one device...
2568                  */
2569                 if (put_user(daddr, (int __user *)optval))
2570                         return -EFAULT;
2571
2572                 break;
2573         default:
2574                 return -ENOPROTOOPT;
2575         }
2576
2577         return 0;
2578 }
2579
2580 static int irda_getsockopt(struct socket *sock, int level, int optname,
2581                            char __user *optval, int __user *optlen)
2582 {
2583         int err;
2584
2585         lock_kernel();
2586         err = __irda_getsockopt(sock, level, optname, optval, optlen);
2587         unlock_kernel();
2588
2589         return err;
2590 }
2591
2592 static const struct net_proto_family irda_family_ops = {
2593         .family = PF_IRDA,
2594         .create = irda_create,
2595         .owner  = THIS_MODULE,
2596 };
2597
2598 static const struct proto_ops irda_stream_ops = {
2599         .family =       PF_IRDA,
2600         .owner =        THIS_MODULE,
2601         .release =      irda_release,
2602         .bind =         irda_bind,
2603         .connect =      irda_connect,
2604         .socketpair =   sock_no_socketpair,
2605         .accept =       irda_accept,
2606         .getname =      irda_getname,
2607         .poll =         irda_poll,
2608         .ioctl =        irda_ioctl,
2609 #ifdef CONFIG_COMPAT
2610         .compat_ioctl = irda_compat_ioctl,
2611 #endif
2612         .listen =       irda_listen,
2613         .shutdown =     irda_shutdown,
2614         .setsockopt =   irda_setsockopt,
2615         .getsockopt =   irda_getsockopt,
2616         .sendmsg =      irda_sendmsg,
2617         .recvmsg =      irda_recvmsg_stream,
2618         .mmap =         sock_no_mmap,
2619         .sendpage =     sock_no_sendpage,
2620 };
2621
2622 static const struct proto_ops irda_seqpacket_ops = {
2623         .family =       PF_IRDA,
2624         .owner =        THIS_MODULE,
2625         .release =      irda_release,
2626         .bind =         irda_bind,
2627         .connect =      irda_connect,
2628         .socketpair =   sock_no_socketpair,
2629         .accept =       irda_accept,
2630         .getname =      irda_getname,
2631         .poll =         irda_datagram_poll,
2632         .ioctl =        irda_ioctl,
2633 #ifdef CONFIG_COMPAT
2634         .compat_ioctl = irda_compat_ioctl,
2635 #endif
2636         .listen =       irda_listen,
2637         .shutdown =     irda_shutdown,
2638         .setsockopt =   irda_setsockopt,
2639         .getsockopt =   irda_getsockopt,
2640         .sendmsg =      irda_sendmsg,
2641         .recvmsg =      irda_recvmsg_dgram,
2642         .mmap =         sock_no_mmap,
2643         .sendpage =     sock_no_sendpage,
2644 };
2645
2646 static const struct proto_ops irda_dgram_ops = {
2647         .family =       PF_IRDA,
2648         .owner =        THIS_MODULE,
2649         .release =      irda_release,
2650         .bind =         irda_bind,
2651         .connect =      irda_connect,
2652         .socketpair =   sock_no_socketpair,
2653         .accept =       irda_accept,
2654         .getname =      irda_getname,
2655         .poll =         irda_datagram_poll,
2656         .ioctl =        irda_ioctl,
2657 #ifdef CONFIG_COMPAT
2658         .compat_ioctl = irda_compat_ioctl,
2659 #endif
2660         .listen =       irda_listen,
2661         .shutdown =     irda_shutdown,
2662         .setsockopt =   irda_setsockopt,
2663         .getsockopt =   irda_getsockopt,
2664         .sendmsg =      irda_sendmsg_dgram,
2665         .recvmsg =      irda_recvmsg_dgram,
2666         .mmap =         sock_no_mmap,
2667         .sendpage =     sock_no_sendpage,
2668 };
2669
2670 #ifdef CONFIG_IRDA_ULTRA
2671 static const struct proto_ops irda_ultra_ops = {
2672         .family =       PF_IRDA,
2673         .owner =        THIS_MODULE,
2674         .release =      irda_release,
2675         .bind =         irda_bind,
2676         .connect =      sock_no_connect,
2677         .socketpair =   sock_no_socketpair,
2678         .accept =       sock_no_accept,
2679         .getname =      irda_getname,
2680         .poll =         irda_datagram_poll,
2681         .ioctl =        irda_ioctl,
2682 #ifdef CONFIG_COMPAT
2683         .compat_ioctl = irda_compat_ioctl,
2684 #endif
2685         .listen =       sock_no_listen,
2686         .shutdown =     irda_shutdown,
2687         .setsockopt =   irda_setsockopt,
2688         .getsockopt =   irda_getsockopt,
2689         .sendmsg =      irda_sendmsg_ultra,
2690         .recvmsg =      irda_recvmsg_dgram,
2691         .mmap =         sock_no_mmap,
2692         .sendpage =     sock_no_sendpage,
2693 };
2694 #endif /* CONFIG_IRDA_ULTRA */
2695
2696 /*
2697  * Function irsock_init (pro)
2698  *
2699  *    Initialize IrDA protocol
2700  *
2701  */
2702 int __init irsock_init(void)
2703 {
2704         int rc = proto_register(&irda_proto, 0);
2705
2706         if (rc == 0)
2707                 rc = sock_register(&irda_family_ops);
2708
2709         return rc;
2710 }
2711
2712 /*
2713  * Function irsock_cleanup (void)
2714  *
2715  *    Remove IrDA protocol
2716  *
2717  */
2718 void irsock_cleanup(void)
2719 {
2720         sock_unregister(PF_IRDA);
2721         proto_unregister(&irda_proto);
2722 }