drivers/isdn/mISDN/socket.c

   1 /*
   2  *
   3  * Author       Karsten Keil <kkeil@novell.com>
   4  *
   5  * Copyright 2008  by Karsten Keil <kkeil@novell.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  */
  17
  18 #include <linux/mISDNif.h>
  19 #include <linux/slab.h>
  20 #include <linux/export.h>
  21 #include "core.h"
  22
  23 static u_int    *debug;
  24
  25 static struct proto mISDN_proto = {
  26         .name           = "misdn",
  27         .owner          = THIS_MODULE,
  28         .obj_size       = sizeof(struct mISDN_sock)
  29 };
  30
  31 #define _pms(sk)        ((struct mISDN_sock *)sk)
  32
  33 static struct mISDN_sock_list   data_sockets = {
  34         .lock = __RW_LOCK_UNLOCKED(data_sockets.lock)
  35 };
  36
  37 static struct mISDN_sock_list   base_sockets = {
  38         .lock = __RW_LOCK_UNLOCKED(base_sockets.lock)
  39 };
  40
  41 #define L2_HEADER_LEN   4
  42
  43 static inline struct sk_buff *
  44 _l2_alloc_skb(unsigned int len, gfp_t gfp_mask)
  45 {
  46         struct sk_buff  *skb;
  47
  48         skb = alloc_skb(len + L2_HEADER_LEN, gfp_mask);
  49         if (likely(skb))
  50                 skb_reserve(skb, L2_HEADER_LEN);
  51         return skb;
  52 }
  53
  54 static void
  55 mISDN_sock_link(struct mISDN_sock_list *l, struct sock *sk)
  56 {
  57         write_lock_bh(&l->lock);
  58         sk_add_node(sk, &l->head);
  59         write_unlock_bh(&l->lock);
  60 }
  61
  62 static void mISDN_sock_unlink(struct mISDN_sock_list *l, struct sock *sk)
  63 {
  64         write_lock_bh(&l->lock);
  65         sk_del_node_init(sk);
  66         write_unlock_bh(&l->lock);
  67 }
  68
  69 static int
  70 mISDN_send(struct mISDNchannel *ch, struct sk_buff *skb)
  71 {
  72         struct mISDN_sock *msk;
  73         int     err;
  74
  75         msk = container_of(ch, struct mISDN_sock, ch);
  76         if (*debug & DEBUG_SOCKET)
  77                 printk(KERN_DEBUG "%s len %d %p\n", __func__, skb->len, skb);
  78         if (msk->sk.sk_state == MISDN_CLOSED)
  79                 return -EUNATCH;
  80         __net_timestamp(skb);
  81         err = sock_queue_rcv_skb(&msk->sk, skb);
  82         if (err)
  83                 printk(KERN_WARNING "%s: error %d\n", __func__, err);
  84         return err;
  85 }
  86
  87 static int
  88 mISDN_ctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
  89 {
  90         struct mISDN_sock *msk;
  91
  92         msk = container_of(ch, struct mISDN_sock, ch);
  93         if (*debug & DEBUG_SOCKET)
  94                 printk(KERN_DEBUG "%s(%p, %x, %p)\n", __func__, ch, cmd, arg);
  95         switch (cmd) {
  96         case CLOSE_CHANNEL:
  97                 msk->sk.sk_state = MISDN_CLOSED;
  98                 break;
  99         }
 100         return 0;
 101 }
 102
 103 static inline void
 104 mISDN_sock_cmsg(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
 105 {
 106         struct timeval  tv;
 107
 108         if (_pms(sk)->cmask & MISDN_TIME_STAMP) {
 109                 skb_get_timestamp(skb, &tv);
 110                 put_cmsg(msg, SOL_MISDN, MISDN_TIME_STAMP, sizeof(tv), &tv);
 111         }
 112 }
 113
 114 static int
 115 mISDN_sock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
 116                    int flags)
 117 {
 118         struct sk_buff          *skb;
 119         struct sock             *sk = sock->sk;
 120
 121         int             copied, err;
 122
 123         if (*debug & DEBUG_SOCKET)
 124                 printk(KERN_DEBUG "%s: len %d, flags %x ch.nr %d, proto %x\n",
 125                        __func__, (int)len, flags, _pms(sk)->ch.nr,
 126                        sk->sk_protocol);
 127         if (flags & (MSG_OOB))
 128                 return -EOPNOTSUPP;
 129
 130         if (sk->sk_state == MISDN_CLOSED)
 131                 return 0;
 132
 133         skb = skb_recv_datagram(sk, flags, flags & MSG_DONTWAIT, &err);
 134         if (!skb)
 135                 return err;
 136
 137         if (msg->msg_name) {
 138                 DECLARE_SOCKADDR(struct sockaddr_mISDN *, maddr, msg->msg_name);
 139
 140                 maddr->family = AF_ISDN;
 141                 maddr->dev = _pms(sk)->dev->id;
 142                 if ((sk->sk_protocol == ISDN_P_LAPD_TE) ||
 143                     (sk->sk_protocol == ISDN_P_LAPD_NT)) {
 144                         maddr->channel = (mISDN_HEAD_ID(skb) >> 16) & 0xff;
 145                         maddr->tei =  (mISDN_HEAD_ID(skb) >> 8) & 0xff;
 146                         maddr->sapi = mISDN_HEAD_ID(skb) & 0xff;
 147                 } else {
 148                         maddr->channel = _pms(sk)->ch.nr;
 149                         maddr->sapi = _pms(sk)->ch.addr & 0xFF;
 150                         maddr->tei =  (_pms(sk)->ch.addr >> 8) & 0xFF;
 151                 }
 152                 msg->msg_namelen = sizeof(*maddr);
 153         }
 154
 155         copied = skb->len + MISDN_HEADER_LEN;
 156         if (len < copied) {
 157                 if (flags & MSG_PEEK)
 158                         refcount_dec(&skb->users);
 159                 else
 160                         skb_queue_head(&sk->sk_receive_queue, skb);
 161                 return -ENOSPC;
 162         }
 163         memcpy(skb_push(skb, MISDN_HEADER_LEN), mISDN_HEAD_P(skb),
 164                MISDN_HEADER_LEN);
 165
 166         err = skb_copy_datagram_msg(skb, 0, msg, copied);
 167
 168         mISDN_sock_cmsg(sk, msg, skb);
 169
 170         skb_free_datagram(sk, skb);
 171
 172         return err ? : copied;
 173 }
 174
 175 static int
 176 mISDN_sock_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
 177 {
 178         struct sock             *sk = sock->sk;
 179         struct sk_buff          *skb;
 180         int                     err = -ENOMEM;
 181
 182         if (*debug & DEBUG_SOCKET)
 183                 printk(KERN_DEBUG "%s: len %d flags %x ch %d proto %x\n",
 184                        __func__, (int)len, msg->msg_flags, _pms(sk)->ch.nr,
 185                        sk->sk_protocol);
 186
 187         if (msg->msg_flags & MSG_OOB)
 188                 return -EOPNOTSUPP;
 189
 190         if (msg->msg_flags & ~(MSG_DONTWAIT | MSG_NOSIGNAL | MSG_ERRQUEUE))
 191                 return -EINVAL;
 192
 193         if (len < MISDN_HEADER_LEN)
 194                 return -EINVAL;
 195
 196         if (sk->sk_state != MISDN_BOUND)
 197                 return -EBADFD;
 198
 199         lock_sock(sk);
 200
 201         skb = _l2_alloc_skb(len, GFP_KERNEL);
 202         if (!skb)
 203                 goto done;
 204
 205         if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
 206                 err = -EFAULT;
 207                 goto done;
 208         }
 209
 210         memcpy(mISDN_HEAD_P(skb), skb->data, MISDN_HEADER_LEN);
 211         skb_pull(skb, MISDN_HEADER_LEN);
 212
 213         if (msg->msg_namelen >= sizeof(struct sockaddr_mISDN)) {
 214                 /* if we have a address, we use it */
 215                 DECLARE_SOCKADDR(struct sockaddr_mISDN *, maddr, msg->msg_name);
 216                 mISDN_HEAD_ID(skb) = maddr->channel;
 217         } else { /* use default for L2 messages */
 218                 if ((sk->sk_protocol == ISDN_P_LAPD_TE) ||
 219                     (sk->sk_protocol == ISDN_P_LAPD_NT))
 220                         mISDN_HEAD_ID(skb) = _pms(sk)->ch.nr;
 221         }
 222
 223         if (*debug & DEBUG_SOCKET)
 224                 printk(KERN_DEBUG "%s: ID:%x\n",
 225                        __func__, mISDN_HEAD_ID(skb));
 226
 227         err = -ENODEV;
 228         if (!_pms(sk)->ch.peer)
 229                 goto done;
 230         err = _pms(sk)->ch.recv(_pms(sk)->ch.peer, skb);
 231         if (err)
 232                 goto done;
 233         else {
 234                 skb = NULL;
 235                 err = len;
 236         }
 237
 238 done:
 239         if (skb)
 240                 kfree_skb(skb);
 241         release_sock(sk);
 242         return err;
 243 }
 244
 245 static int
 246 data_sock_release(struct socket *sock)
 247 {
 248         struct sock *sk = sock->sk;
 249
 250         if (*debug & DEBUG_SOCKET)
 251                 printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
 252         if (!sk)
 253                 return 0;
 254         switch (sk->sk_protocol) {
 255         case ISDN_P_TE_S0:
 256         case ISDN_P_NT_S0:
 257         case ISDN_P_TE_E1:
 258         case ISDN_P_NT_E1:
 259                 if (sk->sk_state == MISDN_BOUND)
 260                         delete_channel(&_pms(sk)->ch);
 261                 else
 262                         mISDN_sock_unlink(&data_sockets, sk);
 263                 break;
 264         case ISDN_P_LAPD_TE:
 265         case ISDN_P_LAPD_NT:
 266         case ISDN_P_B_RAW:
 267         case ISDN_P_B_HDLC:
 268         case ISDN_P_B_X75SLP:
 269         case ISDN_P_B_L2DTMF:
 270         case ISDN_P_B_L2DSP:
 271         case ISDN_P_B_L2DSPHDLC:
 272                 delete_channel(&_pms(sk)->ch);
 273                 mISDN_sock_unlink(&data_sockets, sk);
 274                 break;
 275         }
 276
 277         lock_sock(sk);
 278
 279         sock_orphan(sk);
 280         skb_queue_purge(&sk->sk_receive_queue);
 281
 282         release_sock(sk);
 283         sock_put(sk);
 284
 285         return 0;
 286 }
 287
 288 static int
 289 data_sock_ioctl_bound(struct sock *sk, unsigned int cmd, void __user *p)
 290 {
 291         struct mISDN_ctrl_req   cq;
 292         int                     err = -EINVAL, val[2];
 293         struct mISDNchannel     *bchan, *next;
 294
 295         lock_sock(sk);
 296         if (!_pms(sk)->dev) {
 297                 err = -ENODEV;
 298                 goto done;
 299         }
 300         switch (cmd) {
 301         case IMCTRLREQ:
 302                 if (copy_from_user(&cq, p, sizeof(cq))) {
 303                         err = -EFAULT;
 304                         break;
 305                 }
 306                 if ((sk->sk_protocol & ~ISDN_P_B_MASK) == ISDN_P_B_START) {
 307                         list_for_each_entry_safe(bchan, next,
 308                                                  &_pms(sk)->dev->bchannels, list) {
 309                                 if (bchan->nr == cq.channel) {
 310                                         err = bchan->ctrl(bchan,
 311                                                           CONTROL_CHANNEL, &cq);
 312                                         break;
 313                                 }
 314                         }
 315                 } else
 316                         err = _pms(sk)->dev->D.ctrl(&_pms(sk)->dev->D,
 317                                                     CONTROL_CHANNEL, &cq);
 318                 if (err)
 319                         break;
 320                 if (copy_to_user(p, &cq, sizeof(cq)))
 321                         err = -EFAULT;
 322                 break;
 323         case IMCLEAR_L2:
 324                 if (sk->sk_protocol != ISDN_P_LAPD_NT) {
 325                         err = -EINVAL;
 326                         break;
 327                 }
 328                 val[0] = cmd;
 329                 if (get_user(val[1], (int __user *)p)) {
 330                         err = -EFAULT;
 331                         break;
 332                 }
 333                 err = _pms(sk)->dev->teimgr->ctrl(_pms(sk)->dev->teimgr,
 334                                                   CONTROL_CHANNEL, val);
 335                 break;
 336         case IMHOLD_L1:
 337                 if (sk->sk_protocol != ISDN_P_LAPD_NT
 338                     && sk->sk_protocol != ISDN_P_LAPD_TE) {
 339                         err = -EINVAL;
 340                         break;
 341                 }
 342                 val[0] = cmd;
 343                 if (get_user(val[1], (int __user *)p)) {
 344                         err = -EFAULT;
 345                         break;
 346                 }
 347                 err = _pms(sk)->dev->teimgr->ctrl(_pms(sk)->dev->teimgr,
 348                                                   CONTROL_CHANNEL, val);
 349                 break;
 350         default:
 351                 err = -EINVAL;
 352                 break;
 353         }
 354 done:
 355         release_sock(sk);
 356         return err;
 357 }
 358
 359 static int
 360 data_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 361 {
 362         int                     err = 0, id;
 363         struct sock             *sk = sock->sk;
 364         struct mISDNdevice      *dev;
 365         struct mISDNversion     ver;
 366
 367         switch (cmd) {
 368         case IMGETVERSION:
 369                 ver.major = MISDN_MAJOR_VERSION;
 370                 ver.minor = MISDN_MINOR_VERSION;
 371                 ver.release = MISDN_RELEASE;
 372                 if (copy_to_user((void __user *)arg, &ver, sizeof(ver)))
 373                         err = -EFAULT;
 374                 break;
 375         case IMGETCOUNT:
 376                 id = get_mdevice_count();
 377                 if (put_user(id, (int __user *)arg))
 378                         err = -EFAULT;
 379                 break;
 380         case IMGETDEVINFO:
 381                 if (get_user(id, (int __user *)arg)) {
 382                         err = -EFAULT;
 383                         break;
 384                 }
 385                 dev = get_mdevice(id);
 386                 if (dev) {
 387                         struct mISDN_devinfo di;
 388
 389                         memset(&di, 0, sizeof(di));
 390                         di.id = dev->id;
 391                         di.Dprotocols = dev->Dprotocols;
 392                         di.Bprotocols = dev->Bprotocols | get_all_Bprotocols();
 393                         di.protocol = dev->D.protocol;
 394                         memcpy(di.channelmap, dev->channelmap,
 395                                sizeof(di.channelmap));
 396                         di.nrbchan = dev->nrbchan;
 397                         strscpy(di.name, dev_name(&dev->dev), sizeof(di.name));
 398                         if (copy_to_user((void __user *)arg, &di, sizeof(di)))
 399                                 err = -EFAULT;
 400                 } else
 401                         err = -ENODEV;
 402                 break;
 403         default:
 404                 if (sk->sk_state == MISDN_BOUND)
 405                         err = data_sock_ioctl_bound(sk, cmd,
 406                                                     (void __user *)arg);
 407                 else
 408                         err = -ENOTCONN;
 409         }
 410         return err;
 411 }
 412
 413 static int data_sock_setsockopt(struct socket *sock, int level, int optname,
 414                                 char __user *optval, unsigned int len)
 415 {
 416         struct sock *sk = sock->sk;
 417         int err = 0, opt = 0;
 418
 419         if (*debug & DEBUG_SOCKET)
 420                 printk(KERN_DEBUG "%s(%p, %d, %x, %p, %d)\n", __func__, sock,
 421                        level, optname, optval, len);
 422
 423         lock_sock(sk);
 424
 425         switch (optname) {
 426         case MISDN_TIME_STAMP:
 427                 if (get_user(opt, (int __user *)optval)) {
 428                         err = -EFAULT;
 429                         break;
 430                 }
 431
 432                 if (opt)
 433                         _pms(sk)->cmask |= MISDN_TIME_STAMP;
 434                 else
 435                         _pms(sk)->cmask &= ~MISDN_TIME_STAMP;
 436                 break;
 437         default:
 438                 err = -ENOPROTOOPT;
 439                 break;
 440         }
 441         release_sock(sk);
 442         return err;
 443 }
 444
 445 static int data_sock_getsockopt(struct socket *sock, int level, int optname,
 446                                 char __user *optval, int __user *optlen)
 447 {
 448         struct sock *sk = sock->sk;
 449         int len, opt;
 450
 451         if (get_user(len, optlen))
 452                 return -EFAULT;
 453
 454         if (len != sizeof(char))
 455                 return -EINVAL;
 456
 457         switch (optname) {
 458         case MISDN_TIME_STAMP:
 459                 if (_pms(sk)->cmask & MISDN_TIME_STAMP)
 460                         opt = 1;
 461                 else
 462                         opt = 0;
 463
 464                 if (put_user(opt, optval))
 465                         return -EFAULT;
 466                 break;
 467         default:
 468                 return -ENOPROTOOPT;
 469         }
 470
 471         return 0;
 472 }
 473
 474 static int
 475 data_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
 476 {
 477         struct sockaddr_mISDN *maddr = (struct sockaddr_mISDN *) addr;
 478         struct sock *sk = sock->sk;
 479         struct sock *csk;
 480         int err = 0;
 481
 482         if (*debug & DEBUG_SOCKET)
 483                 printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
 484         if (addr_len != sizeof(struct sockaddr_mISDN))
 485                 return -EINVAL;
 486         if (!maddr || maddr->family != AF_ISDN)
 487                 return -EINVAL;
 488
 489         lock_sock(sk);
 490
 491         if (_pms(sk)->dev) {
 492                 err = -EALREADY;
 493                 goto done;
 494         }
 495         _pms(sk)->dev = get_mdevice(maddr->dev);
 496         if (!_pms(sk)->dev) {
 497                 err = -ENODEV;
 498                 goto done;
 499         }
 500
 501         if (sk->sk_protocol < ISDN_P_B_START) {
 502                 read_lock_bh(&data_sockets.lock);
 503                 sk_for_each(csk, &data_sockets.head) {
 504                         if (sk == csk)
 505                                 continue;
 506                         if (_pms(csk)->dev != _pms(sk)->dev)
 507                                 continue;
 508                         if (csk->sk_protocol >= ISDN_P_B_START)
 509                                 continue;
 510                         if (IS_ISDN_P_TE(csk->sk_protocol)
 511                             == IS_ISDN_P_TE(sk->sk_protocol))
 512                                 continue;
 513                         read_unlock_bh(&data_sockets.lock);
 514                         err = -EBUSY;
 515                         goto done;
 516                 }
 517                 read_unlock_bh(&data_sockets.lock);
 518         }
 519
 520         _pms(sk)->ch.send = mISDN_send;
 521         _pms(sk)->ch.ctrl = mISDN_ctrl;
 522
 523         switch (sk->sk_protocol) {
 524         case ISDN_P_TE_S0:
 525         case ISDN_P_NT_S0:
 526         case ISDN_P_TE_E1:
 527         case ISDN_P_NT_E1:
 528                 mISDN_sock_unlink(&data_sockets, sk);
 529                 err = connect_layer1(_pms(sk)->dev, &_pms(sk)->ch,
 530                                      sk->sk_protocol, maddr);
 531                 if (err)
 532                         mISDN_sock_link(&data_sockets, sk);
 533                 break;
 534         case ISDN_P_LAPD_TE:
 535         case ISDN_P_LAPD_NT:
 536                 err = create_l2entity(_pms(sk)->dev, &_pms(sk)->ch,
 537                                       sk->sk_protocol, maddr);
 538                 break;
 539         case ISDN_P_B_RAW:
 540         case ISDN_P_B_HDLC:
 541         case ISDN_P_B_X75SLP:
 542         case ISDN_P_B_L2DTMF:
 543         case ISDN_P_B_L2DSP:
 544         case ISDN_P_B_L2DSPHDLC:
 545                 err = connect_Bstack(_pms(sk)->dev, &_pms(sk)->ch,
 546                                      sk->sk_protocol, maddr);
 547                 break;
 548         default:
 549                 err = -EPROTONOSUPPORT;
 550         }
 551         if (err)
 552                 goto done;
 553         sk->sk_state = MISDN_BOUND;
 554         _pms(sk)->ch.protocol = sk->sk_protocol;
 555
 556 done:
 557         release_sock(sk);
 558         return err;
 559 }
 560
 561 static int
 562 data_sock_getname(struct socket *sock, struct sockaddr *addr,
 563                   int peer)
 564 {
 565         struct sockaddr_mISDN   *maddr = (struct sockaddr_mISDN *) addr;
 566         struct sock             *sk = sock->sk;
 567
 568         if (!_pms(sk)->dev)
 569                 return -EBADFD;
 570
 571         lock_sock(sk);
 572
 573         maddr->family = AF_ISDN;
 574         maddr->dev = _pms(sk)->dev->id;
 575         maddr->channel = _pms(sk)->ch.nr;
 576         maddr->sapi = _pms(sk)->ch.addr & 0xff;
 577         maddr->tei = (_pms(sk)->ch.addr >> 8) & 0xff;
 578         release_sock(sk);
 579         return sizeof(*maddr);
 580 }
 581
 582 static const struct proto_ops data_sock_ops = {
 583         .family         = PF_ISDN,
 584         .owner          = THIS_MODULE,
 585         .release        = data_sock_release,
 586         .ioctl          = data_sock_ioctl,
 587         .bind           = data_sock_bind,
 588         .getname        = data_sock_getname,
 589         .sendmsg        = mISDN_sock_sendmsg,
 590         .recvmsg        = mISDN_sock_recvmsg,
 591         .poll           = datagram_poll,
 592         .listen         = sock_no_listen,
 593         .shutdown       = sock_no_shutdown,
 594         .setsockopt     = data_sock_setsockopt,
 595         .getsockopt     = data_sock_getsockopt,
 596         .connect        = sock_no_connect,
 597         .socketpair     = sock_no_socketpair,
 598         .accept         = sock_no_accept,
 599         .mmap           = sock_no_mmap
 600 };
 601
 602 static int
 603 data_sock_create(struct net *net, struct socket *sock, int protocol, int kern)
 604 {
 605         struct sock *sk;
 606
 607         if (sock->type != SOCK_DGRAM)
 608                 return -ESOCKTNOSUPPORT;
 609
 610         sk = sk_alloc(net, PF_ISDN, GFP_KERNEL, &mISDN_proto, kern);
 611         if (!sk)
 612                 return -ENOMEM;
 613
 614         sock_init_data(sock, sk);
 615
 616         sock->ops = &data_sock_ops;
 617         sock->state = SS_UNCONNECTED;
 618         sock_reset_flag(sk, SOCK_ZAPPED);
 619
 620         sk->sk_protocol = protocol;
 621         sk->sk_state    = MISDN_OPEN;
 622         mISDN_sock_link(&data_sockets, sk);
 623
 624         return 0;
 625 }
 626
 627 static int
 628 base_sock_release(struct socket *sock)
 629 {
 630         struct sock *sk = sock->sk;
 631
 632         printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
 633         if (!sk)
 634                 return 0;
 635
 636         mISDN_sock_unlink(&base_sockets, sk);
 637         sock_orphan(sk);
 638         sock_put(sk);
 639
 640         return 0;
 641 }
 642
 643 static int
 644 base_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 645 {
 646         int                     err = 0, id;
 647         struct mISDNdevice      *dev;
 648         struct mISDNversion     ver;
 649
 650         switch (cmd) {
 651         case IMGETVERSION:
 652                 ver.major = MISDN_MAJOR_VERSION;
 653                 ver.minor = MISDN_MINOR_VERSION;
 654                 ver.release = MISDN_RELEASE;
 655                 if (copy_to_user((void __user *)arg, &ver, sizeof(ver)))
 656                         err = -EFAULT;
 657                 break;
 658         case IMGETCOUNT:
 659                 id = get_mdevice_count();
 660                 if (put_user(id, (int __user *)arg))
 661                         err = -EFAULT;
 662                 break;
 663         case IMGETDEVINFO:
 664                 if (get_user(id, (int __user *)arg)) {
 665                         err = -EFAULT;
 666                         break;
 667                 }
 668                 dev = get_mdevice(id);
 669                 if (dev) {
 670                         struct mISDN_devinfo di;
 671
 672                         memset(&di, 0, sizeof(di));
 673                         di.id = dev->id;
 674                         di.Dprotocols = dev->Dprotocols;
 675                         di.Bprotocols = dev->Bprotocols | get_all_Bprotocols();
 676                         di.protocol = dev->D.protocol;
 677                         memcpy(di.channelmap, dev->channelmap,
 678                                sizeof(di.channelmap));
 679                         di.nrbchan = dev->nrbchan;
 680                         strscpy(di.name, dev_name(&dev->dev), sizeof(di.name));
 681                         if (copy_to_user((void __user *)arg, &di, sizeof(di)))
 682                                 err = -EFAULT;
 683                 } else
 684                         err = -ENODEV;
 685                 break;
 686         case IMSETDEVNAME:
 687         {
 688                 struct mISDN_devrename dn;
 689                 if (copy_from_user(&dn, (void __user *)arg,
 690                                    sizeof(dn))) {
 691                         err = -EFAULT;
 692                         break;
 693                 }
 694                 dn.name[sizeof(dn.name) - 1] = '\0';
 695                 dev = get_mdevice(dn.id);
 696                 if (dev)
 697                         err = device_rename(&dev->dev, dn.name);
 698                 else
 699                         err = -ENODEV;
 700         }
 701         break;
 702         default:
 703                 err = -EINVAL;
 704         }
 705         return err;
 706 }
 707
 708 static int
 709 base_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
 710 {
 711         struct sockaddr_mISDN *maddr = (struct sockaddr_mISDN *) addr;
 712         struct sock *sk = sock->sk;
 713         int err = 0;
 714
 715         if (addr_len < sizeof(struct sockaddr_mISDN))
 716                 return -EINVAL;
 717
 718         if (!maddr || maddr->family != AF_ISDN)
 719                 return -EINVAL;
 720
 721         lock_sock(sk);
 722
 723         if (_pms(sk)->dev) {
 724                 err = -EALREADY;
 725                 goto done;
 726         }
 727
 728         _pms(sk)->dev = get_mdevice(maddr->dev);
 729         if (!_pms(sk)->dev) {
 730                 err = -ENODEV;
 731                 goto done;
 732         }
 733         sk->sk_state = MISDN_BOUND;
 734
 735 done:
 736         release_sock(sk);
 737         return err;
 738 }
 739
 740 static const struct proto_ops base_sock_ops = {
 741         .family         = PF_ISDN,
 742         .owner          = THIS_MODULE,
 743         .release        = base_sock_release,
 744         .ioctl          = base_sock_ioctl,
 745         .bind           = base_sock_bind,
 746         .getname        = sock_no_getname,
 747         .sendmsg        = sock_no_sendmsg,
 748         .recvmsg        = sock_no_recvmsg,
 749         .listen         = sock_no_listen,
 750         .shutdown       = sock_no_shutdown,
 751         .setsockopt     = sock_no_setsockopt,
 752         .getsockopt     = sock_no_getsockopt,
 753         .connect        = sock_no_connect,
 754         .socketpair     = sock_no_socketpair,
 755         .accept         = sock_no_accept,
 756         .mmap           = sock_no_mmap
 757 };
 758
 759
 760 static int
 761 base_sock_create(struct net *net, struct socket *sock, int protocol, int kern)
 762 {
 763         struct sock *sk;
 764
 765         if (sock->type != SOCK_RAW)
 766                 return -ESOCKTNOSUPPORT;
 767         if (!capable(CAP_NET_RAW))
 768                 return -EPERM;
 769
 770         sk = sk_alloc(net, PF_ISDN, GFP_KERNEL, &mISDN_proto, kern);
 771         if (!sk)
 772                 return -ENOMEM;
 773
 774         sock_init_data(sock, sk);
 775         sock->ops = &base_sock_ops;
 776         sock->state = SS_UNCONNECTED;
 777         sock_reset_flag(sk, SOCK_ZAPPED);
 778         sk->sk_protocol = protocol;
 779         sk->sk_state    = MISDN_OPEN;
 780         mISDN_sock_link(&base_sockets, sk);
 781
 782         return 0;
 783 }
 784
 785 static int
 786 mISDN_sock_create(struct net *net, struct socket *sock, int proto, int kern)
 787 {
 788         int err = -EPROTONOSUPPORT;
 789
 790         switch (proto) {
 791         case ISDN_P_BASE:
 792                 err = base_sock_create(net, sock, proto, kern);
 793                 break;
 794         case ISDN_P_TE_S0:
 795         case ISDN_P_NT_S0:
 796         case ISDN_P_TE_E1:
 797         case ISDN_P_NT_E1:
 798         case ISDN_P_LAPD_TE:
 799         case ISDN_P_LAPD_NT:
 800         case ISDN_P_B_RAW:
 801         case ISDN_P_B_HDLC:
 802         case ISDN_P_B_X75SLP:
 803         case ISDN_P_B_L2DTMF:
 804         case ISDN_P_B_L2DSP:
 805         case ISDN_P_B_L2DSPHDLC:
 806                 err = data_sock_create(net, sock, proto, kern);
 807                 break;
 808         default:
 809                 return err;
 810         }
 811
 812         return err;
 813 }
 814
 815 static const struct net_proto_family mISDN_sock_family_ops = {
 816         .owner  = THIS_MODULE,
 817         .family = PF_ISDN,
 818         .create = mISDN_sock_create,
 819 };
 820
 821 int
 822 misdn_sock_init(u_int *deb)
 823 {
 824         int err;
 825
 826         debug = deb;
 827         err = sock_register(&mISDN_sock_family_ops);
 828         if (err)
 829                 printk(KERN_ERR "%s: error(%d)\n", __func__, err);
 830         return err;
 831 }
 832
 833 void
 834 misdn_sock_cleanup(void)
 835 {
 836         sock_unregister(PF_ISDN);
 837 }