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 kiocb *iocb, struct socket *sock,
 116                    struct msghdr *msg, size_t len, 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                 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                         atomic_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_iovec(skb, 0, msg->msg_iov, 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 kiocb *iocb, struct socket *sock,
 177                    struct msghdr *msg, size_t len)
 178 {
 179         struct sock             *sk = sock->sk;
 180         struct sk_buff          *skb;
 181         int                     err = -ENOMEM;
 182         struct sockaddr_mISDN   *maddr;
 183
 184         if (*debug & DEBUG_SOCKET)
 185                 printk(KERN_DEBUG "%s: len %d flags %x ch %d proto %x\n",
 186                        __func__, (int)len, msg->msg_flags, _pms(sk)->ch.nr,
 187                        sk->sk_protocol);
 188
 189         if (msg->msg_flags & MSG_OOB)
 190                 return -EOPNOTSUPP;
 191
 192         if (msg->msg_flags & ~(MSG_DONTWAIT | MSG_NOSIGNAL | MSG_ERRQUEUE))
 193                 return -EINVAL;
 194
 195         if (len < MISDN_HEADER_LEN)
 196                 return -EINVAL;
 197
 198         if (sk->sk_state != MISDN_BOUND)
 199                 return -EBADFD;
 200
 201         lock_sock(sk);
 202
 203         skb = _l2_alloc_skb(len, GFP_KERNEL);
 204         if (!skb)
 205                 goto done;
 206
 207         if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
 208                 err = -EFAULT;
 209                 goto done;
 210         }
 211
 212         memcpy(mISDN_HEAD_P(skb), skb->data, MISDN_HEADER_LEN);
 213         skb_pull(skb, MISDN_HEADER_LEN);
 214
 215         if (msg->msg_namelen >= sizeof(struct sockaddr_mISDN)) {
 216                 /* if we have a address, we use it */
 217                 maddr = (struct sockaddr_mISDN *)msg->msg_name;
 218                 mISDN_HEAD_ID(skb) = maddr->channel;
 219         } else { /* use default for L2 messages */
 220                 if ((sk->sk_protocol == ISDN_P_LAPD_TE) ||
 221                     (sk->sk_protocol == ISDN_P_LAPD_NT))
 222                         mISDN_HEAD_ID(skb) = _pms(sk)->ch.nr;
 223         }
 224
 225         if (*debug & DEBUG_SOCKET)
 226                 printk(KERN_DEBUG "%s: ID:%x\n",
 227                        __func__, mISDN_HEAD_ID(skb));
 228
 229         err = -ENODEV;
 230         if (!_pms(sk)->ch.peer)
 231                 goto done;
 232         err = _pms(sk)->ch.recv(_pms(sk)->ch.peer, skb);
 233         if (err)
 234                 goto done;
 235         else {
 236                 skb = NULL;
 237                 err = len;
 238         }
 239
 240 done:
 241         if (skb)
 242                 kfree_skb(skb);
 243         release_sock(sk);
 244         return err;
 245 }
 246
 247 static int
 248 data_sock_release(struct socket *sock)
 249 {
 250         struct sock *sk = sock->sk;
 251
 252         if (*debug & DEBUG_SOCKET)
 253                 printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
 254         if (!sk)
 255                 return 0;
 256         switch (sk->sk_protocol) {
 257         case ISDN_P_TE_S0:
 258         case ISDN_P_NT_S0:
 259         case ISDN_P_TE_E1:
 260         case ISDN_P_NT_E1:
 261                 if (sk->sk_state == MISDN_BOUND)
 262                         delete_channel(&_pms(sk)->ch);
 263                 else
 264                         mISDN_sock_unlink(&data_sockets, sk);
 265                 break;
 266         case ISDN_P_LAPD_TE:
 267         case ISDN_P_LAPD_NT:
 268         case ISDN_P_B_RAW:
 269         case ISDN_P_B_HDLC:
 270         case ISDN_P_B_X75SLP:
 271         case ISDN_P_B_L2DTMF:
 272         case ISDN_P_B_L2DSP:
 273         case ISDN_P_B_L2DSPHDLC:
 274                 delete_channel(&_pms(sk)->ch);
 275                 mISDN_sock_unlink(&data_sockets, sk);
 276                 break;
 277         }
 278
 279         lock_sock(sk);
 280
 281         sock_orphan(sk);
 282         skb_queue_purge(&sk->sk_receive_queue);
 283
 284         release_sock(sk);
 285         sock_put(sk);
 286
 287         return 0;
 288 }
 289
 290 static int
 291 data_sock_ioctl_bound(struct sock *sk, unsigned int cmd, void __user *p)
 292 {
 293         struct mISDN_ctrl_req   cq;
 294         int                     err = -EINVAL, val[2];
 295         struct mISDNchannel     *bchan, *next;
 296
 297         lock_sock(sk);
 298         if (!_pms(sk)->dev) {
 299                 err = -ENODEV;
 300                 goto done;
 301         }
 302         switch (cmd) {
 303         case IMCTRLREQ:
 304                 if (copy_from_user(&cq, p, sizeof(cq))) {
 305                         err = -EFAULT;
 306                         break;
 307                 }
 308                 if ((sk->sk_protocol & ~ISDN_P_B_MASK) == ISDN_P_B_START) {
 309                         list_for_each_entry_safe(bchan, next,
 310                                                  &_pms(sk)->dev->bchannels, list) {
 311                                 if (bchan->nr == cq.channel) {
 312                                         err = bchan->ctrl(bchan,
 313                                                           CONTROL_CHANNEL, &cq);
 314                                         break;
 315                                 }
 316                         }
 317                 } else
 318                         err = _pms(sk)->dev->D.ctrl(&_pms(sk)->dev->D,
 319                                                     CONTROL_CHANNEL, &cq);
 320                 if (err)
 321                         break;
 322                 if (copy_to_user(p, &cq, sizeof(cq)))
 323                         err = -EFAULT;
 324                 break;
 325         case IMCLEAR_L2:
 326                 if (sk->sk_protocol != ISDN_P_LAPD_NT) {
 327                         err = -EINVAL;
 328                         break;
 329                 }
 330                 val[0] = cmd;
 331                 if (get_user(val[1], (int __user *)p)) {
 332                         err = -EFAULT;
 333                         break;
 334                 }
 335                 err = _pms(sk)->dev->teimgr->ctrl(_pms(sk)->dev->teimgr,
 336                                                   CONTROL_CHANNEL, val);
 337                 break;
 338         case IMHOLD_L1:
 339                 if (sk->sk_protocol != ISDN_P_LAPD_NT
 340                     && sk->sk_protocol != ISDN_P_LAPD_TE) {
 341                         err = -EINVAL;
 342                         break;
 343                 }
 344                 val[0] = cmd;
 345                 if (get_user(val[1], (int __user *)p)) {
 346                         err = -EFAULT;
 347                         break;
 348                 }
 349                 err = _pms(sk)->dev->teimgr->ctrl(_pms(sk)->dev->teimgr,
 350                                                   CONTROL_CHANNEL, val);
 351                 break;
 352         default:
 353                 err = -EINVAL;
 354                 break;
 355         }
 356 done:
 357         release_sock(sk);
 358         return err;
 359 }
 360
 361 static int
 362 data_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 363 {
 364         int                     err = 0, id;
 365         struct sock             *sk = sock->sk;
 366         struct mISDNdevice      *dev;
 367         struct mISDNversion     ver;
 368
 369         switch (cmd) {
 370         case IMGETVERSION:
 371                 ver.major = MISDN_MAJOR_VERSION;
 372                 ver.minor = MISDN_MINOR_VERSION;
 373                 ver.release = MISDN_RELEASE;
 374                 if (copy_to_user((void __user *)arg, &ver, sizeof(ver)))
 375                         err = -EFAULT;
 376                 break;
 377         case IMGETCOUNT:
 378                 id = get_mdevice_count();
 379                 if (put_user(id, (int __user *)arg))
 380                         err = -EFAULT;
 381                 break;
 382         case IMGETDEVINFO:
 383                 if (get_user(id, (int __user *)arg)) {
 384                         err = -EFAULT;
 385                         break;
 386                 }
 387                 dev = get_mdevice(id);
 388                 if (dev) {
 389                         struct mISDN_devinfo di;
 390
 391                         memset(&di, 0, sizeof(di));
 392                         di.id = dev->id;
 393                         di.Dprotocols = dev->Dprotocols;
 394                         di.Bprotocols = dev->Bprotocols | get_all_Bprotocols();
 395                         di.protocol = dev->D.protocol;
 396                         memcpy(di.channelmap, dev->channelmap,
 397                                sizeof(di.channelmap));
 398                         di.nrbchan = dev->nrbchan;
 399                         strcpy(di.name, dev_name(&dev->dev));
 400                         if (copy_to_user((void __user *)arg, &di, sizeof(di)))
 401                                 err = -EFAULT;
 402                 } else
 403                         err = -ENODEV;
 404                 break;
 405         default:
 406                 if (sk->sk_state == MISDN_BOUND)
 407                         err = data_sock_ioctl_bound(sk, cmd,
 408                                                     (void __user *)arg);
 409                 else
 410                         err = -ENOTCONN;
 411         }
 412         return err;
 413 }
 414
 415 static int data_sock_setsockopt(struct socket *sock, int level, int optname,
 416                                 char __user *optval, unsigned int len)
 417 {
 418         struct sock *sk = sock->sk;
 419         int err = 0, opt = 0;
 420
 421         if (*debug & DEBUG_SOCKET)
 422                 printk(KERN_DEBUG "%s(%p, %d, %x, %p, %d)\n", __func__, sock,
 423                        level, optname, optval, len);
 424
 425         lock_sock(sk);
 426
 427         switch (optname) {
 428         case MISDN_TIME_STAMP:
 429                 if (get_user(opt, (int __user *)optval)) {
 430                         err = -EFAULT;
 431                         break;
 432                 }
 433
 434                 if (opt)
 435                         _pms(sk)->cmask |= MISDN_TIME_STAMP;
 436                 else
 437                         _pms(sk)->cmask &= ~MISDN_TIME_STAMP;
 438                 break;
 439         default:
 440                 err = -ENOPROTOOPT;
 441                 break;
 442         }
 443         release_sock(sk);
 444         return err;
 445 }
 446
 447 static int data_sock_getsockopt(struct socket *sock, int level, int optname,
 448                                 char __user *optval, int __user *optlen)
 449 {
 450         struct sock *sk = sock->sk;
 451         int len, opt;
 452
 453         if (get_user(len, optlen))
 454                 return -EFAULT;
 455
 456         if (len != sizeof(char))
 457                 return -EINVAL;
 458
 459         switch (optname) {
 460         case MISDN_TIME_STAMP:
 461                 if (_pms(sk)->cmask & MISDN_TIME_STAMP)
 462                         opt = 1;
 463                 else
 464                         opt = 0;
 465
 466                 if (put_user(opt, optval))
 467                         return -EFAULT;
 468                 break;
 469         default:
 470                 return -ENOPROTOOPT;
 471         }
 472
 473         return 0;
 474 }
 475
 476 static int
 477 data_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
 478 {
 479         struct sockaddr_mISDN *maddr = (struct sockaddr_mISDN *) addr;
 480         struct sock *sk = sock->sk;
 481         struct sock *csk;
 482         int err = 0;
 483
 484         if (*debug & DEBUG_SOCKET)
 485                 printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
 486         if (addr_len != sizeof(struct sockaddr_mISDN))
 487                 return -EINVAL;
 488         if (!maddr || maddr->family != AF_ISDN)
 489                 return -EINVAL;
 490
 491         lock_sock(sk);
 492
 493         if (_pms(sk)->dev) {
 494                 err = -EALREADY;
 495                 goto done;
 496         }
 497         _pms(sk)->dev = get_mdevice(maddr->dev);
 498         if (!_pms(sk)->dev) {
 499                 err = -ENODEV;
 500                 goto done;
 501         }
 502
 503         if (sk->sk_protocol < ISDN_P_B_START) {
 504                 read_lock_bh(&data_sockets.lock);
 505                 sk_for_each(csk, &data_sockets.head) {
 506                         if (sk == csk)
 507                                 continue;
 508                         if (_pms(csk)->dev != _pms(sk)->dev)
 509                                 continue;
 510                         if (csk->sk_protocol >= ISDN_P_B_START)
 511                                 continue;
 512                         if (IS_ISDN_P_TE(csk->sk_protocol)
 513                             == IS_ISDN_P_TE(sk->sk_protocol))
 514                                 continue;
 515                         read_unlock_bh(&data_sockets.lock);
 516                         err = -EBUSY;
 517                         goto done;
 518                 }
 519                 read_unlock_bh(&data_sockets.lock);
 520         }
 521
 522         _pms(sk)->ch.send = mISDN_send;
 523         _pms(sk)->ch.ctrl = mISDN_ctrl;
 524
 525         switch (sk->sk_protocol) {
 526         case ISDN_P_TE_S0:
 527         case ISDN_P_NT_S0:
 528         case ISDN_P_TE_E1:
 529         case ISDN_P_NT_E1:
 530                 mISDN_sock_unlink(&data_sockets, sk);
 531                 err = connect_layer1(_pms(sk)->dev, &_pms(sk)->ch,
 532                                      sk->sk_protocol, maddr);
 533                 if (err)
 534                         mISDN_sock_link(&data_sockets, sk);
 535                 break;
 536         case ISDN_P_LAPD_TE:
 537         case ISDN_P_LAPD_NT:
 538                 err = create_l2entity(_pms(sk)->dev, &_pms(sk)->ch,
 539                                       sk->sk_protocol, maddr);
 540                 break;
 541         case ISDN_P_B_RAW:
 542         case ISDN_P_B_HDLC:
 543         case ISDN_P_B_X75SLP:
 544         case ISDN_P_B_L2DTMF:
 545         case ISDN_P_B_L2DSP:
 546         case ISDN_P_B_L2DSPHDLC:
 547                 err = connect_Bstack(_pms(sk)->dev, &_pms(sk)->ch,
 548                                      sk->sk_protocol, maddr);
 549                 break;
 550         default:
 551                 err = -EPROTONOSUPPORT;
 552         }
 553         if (err)
 554                 goto done;
 555         sk->sk_state = MISDN_BOUND;
 556         _pms(sk)->ch.protocol = sk->sk_protocol;
 557
 558 done:
 559         release_sock(sk);
 560         return err;
 561 }
 562
 563 static int
 564 data_sock_getname(struct socket *sock, struct sockaddr *addr,
 565                   int *addr_len, int peer)
 566 {
 567         struct sockaddr_mISDN   *maddr = (struct sockaddr_mISDN *) addr;
 568         struct sock             *sk = sock->sk;
 569
 570         if (!_pms(sk)->dev)
 571                 return -EBADFD;
 572
 573         lock_sock(sk);
 574
 575         *addr_len = sizeof(*maddr);
 576         maddr->family = AF_ISDN;
 577         maddr->dev = _pms(sk)->dev->id;
 578         maddr->channel = _pms(sk)->ch.nr;
 579         maddr->sapi = _pms(sk)->ch.addr & 0xff;
 580         maddr->tei = (_pms(sk)->ch.addr >> 8) & 0xff;
 581         release_sock(sk);
 582         return 0;
 583 }
 584
 585 static const struct proto_ops data_sock_ops = {
 586         .family         = PF_ISDN,
 587         .owner          = THIS_MODULE,
 588         .release        = data_sock_release,
 589         .ioctl          = data_sock_ioctl,
 590         .bind           = data_sock_bind,
 591         .getname        = data_sock_getname,
 592         .sendmsg        = mISDN_sock_sendmsg,
 593         .recvmsg        = mISDN_sock_recvmsg,
 594         .poll           = datagram_poll,
 595         .listen         = sock_no_listen,
 596         .shutdown       = sock_no_shutdown,
 597         .setsockopt     = data_sock_setsockopt,
 598         .getsockopt     = data_sock_getsockopt,
 599         .connect        = sock_no_connect,
 600         .socketpair     = sock_no_socketpair,
 601         .accept         = sock_no_accept,
 602         .mmap           = sock_no_mmap
 603 };
 604
 605 static int
 606 data_sock_create(struct net *net, struct socket *sock, int protocol)
 607 {
 608         struct sock *sk;
 609
 610         if (sock->type != SOCK_DGRAM)
 611                 return -ESOCKTNOSUPPORT;
 612
 613         sk = sk_alloc(net, PF_ISDN, GFP_KERNEL, &mISDN_proto);
 614         if (!sk)
 615                 return -ENOMEM;
 616
 617         sock_init_data(sock, sk);
 618
 619         sock->ops = &data_sock_ops;
 620         sock->state = SS_UNCONNECTED;
 621         sock_reset_flag(sk, SOCK_ZAPPED);
 622
 623         sk->sk_protocol = protocol;
 624         sk->sk_state    = MISDN_OPEN;
 625         mISDN_sock_link(&data_sockets, sk);
 626
 627         return 0;
 628 }
 629
 630 static int
 631 base_sock_release(struct socket *sock)
 632 {
 633         struct sock *sk = sock->sk;
 634
 635         printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
 636         if (!sk)
 637                 return 0;
 638
 639         mISDN_sock_unlink(&base_sockets, sk);
 640         sock_orphan(sk);
 641         sock_put(sk);
 642
 643         return 0;
 644 }
 645
 646 static int
 647 base_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 648 {
 649         int                     err = 0, id;
 650         struct mISDNdevice      *dev;
 651         struct mISDNversion     ver;
 652
 653         switch (cmd) {
 654         case IMGETVERSION:
 655                 ver.major = MISDN_MAJOR_VERSION;
 656                 ver.minor = MISDN_MINOR_VERSION;
 657                 ver.release = MISDN_RELEASE;
 658                 if (copy_to_user((void __user *)arg, &ver, sizeof(ver)))
 659                         err = -EFAULT;
 660                 break;
 661         case IMGETCOUNT:
 662                 id = get_mdevice_count();
 663                 if (put_user(id, (int __user *)arg))
 664                         err = -EFAULT;
 665                 break;
 666         case IMGETDEVINFO:
 667                 if (get_user(id, (int __user *)arg)) {
 668                         err = -EFAULT;
 669                         break;
 670                 }
 671                 dev = get_mdevice(id);
 672                 if (dev) {
 673                         struct mISDN_devinfo di;
 674
 675                         memset(&di, 0, sizeof(di));
 676                         di.id = dev->id;
 677                         di.Dprotocols = dev->Dprotocols;
 678                         di.Bprotocols = dev->Bprotocols | get_all_Bprotocols();
 679                         di.protocol = dev->D.protocol;
 680                         memcpy(di.channelmap, dev->channelmap,
 681                                sizeof(di.channelmap));
 682                         di.nrbchan = dev->nrbchan;
 683                         strcpy(di.name, dev_name(&dev->dev));
 684                         if (copy_to_user((void __user *)arg, &di, sizeof(di)))
 685                                 err = -EFAULT;
 686                 } else
 687                         err = -ENODEV;
 688                 break;
 689         case IMSETDEVNAME:
 690         {
 691                 struct mISDN_devrename dn;
 692                 if (copy_from_user(&dn, (void __user *)arg,
 693                                    sizeof(dn))) {
 694                         err = -EFAULT;
 695                         break;
 696                 }
 697                 dev = get_mdevice(dn.id);
 698                 if (dev)
 699                         err = device_rename(&dev->dev, dn.name);
 700                 else
 701                         err = -ENODEV;
 702         }
 703         break;
 704         default:
 705                 err = -EINVAL;
 706         }
 707         return err;
 708 }
 709
 710 static int
 711 base_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
 712 {
 713         struct sockaddr_mISDN *maddr = (struct sockaddr_mISDN *) addr;
 714         struct sock *sk = sock->sk;
 715         int err = 0;
 716
 717         if (!maddr || maddr->family != AF_ISDN)
 718                 return -EINVAL;
 719
 720         lock_sock(sk);
 721
 722         if (_pms(sk)->dev) {
 723                 err = -EALREADY;
 724                 goto done;
 725         }
 726
 727         _pms(sk)->dev = get_mdevice(maddr->dev);
 728         if (!_pms(sk)->dev) {
 729                 err = -ENODEV;
 730                 goto done;
 731         }
 732         sk->sk_state = MISDN_BOUND;
 733
 734 done:
 735         release_sock(sk);
 736         return err;
 737 }
 738
 739 static const struct proto_ops base_sock_ops = {
 740         .family         = PF_ISDN,
 741         .owner          = THIS_MODULE,
 742         .release        = base_sock_release,
 743         .ioctl          = base_sock_ioctl,
 744         .bind           = base_sock_bind,
 745         .getname        = sock_no_getname,
 746         .sendmsg        = sock_no_sendmsg,
 747         .recvmsg        = sock_no_recvmsg,
 748         .poll           = sock_no_poll,
 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)
 762 {
 763         struct sock *sk;
 764
 765         if (sock->type != SOCK_RAW)
 766                 return -ESOCKTNOSUPPORT;
 767
 768         sk = sk_alloc(net, PF_ISDN, GFP_KERNEL, &mISDN_proto);
 769         if (!sk)
 770                 return -ENOMEM;
 771
 772         sock_init_data(sock, sk);
 773         sock->ops = &base_sock_ops;
 774         sock->state = SS_UNCONNECTED;
 775         sock_reset_flag(sk, SOCK_ZAPPED);
 776         sk->sk_protocol = protocol;
 777         sk->sk_state    = MISDN_OPEN;
 778         mISDN_sock_link(&base_sockets, sk);
 779
 780         return 0;
 781 }
 782
 783 static int
 784 mISDN_sock_create(struct net *net, struct socket *sock, int proto, int kern)
 785 {
 786         int err = -EPROTONOSUPPORT;
 787
 788         switch (proto) {
 789         case ISDN_P_BASE:
 790                 err = base_sock_create(net, sock, proto);
 791                 break;
 792         case ISDN_P_TE_S0:
 793         case ISDN_P_NT_S0:
 794         case ISDN_P_TE_E1:
 795         case ISDN_P_NT_E1:
 796         case ISDN_P_LAPD_TE:
 797         case ISDN_P_LAPD_NT:
 798         case ISDN_P_B_RAW:
 799         case ISDN_P_B_HDLC:
 800         case ISDN_P_B_X75SLP:
 801         case ISDN_P_B_L2DTMF:
 802         case ISDN_P_B_L2DSP:
 803         case ISDN_P_B_L2DSPHDLC:
 804                 err = data_sock_create(net, sock, proto);
 805                 break;
 806         default:
 807                 return err;
 808         }
 809
 810         return err;
 811 }
 812
 813 static const struct net_proto_family mISDN_sock_family_ops = {
 814         .owner  = THIS_MODULE,
 815         .family = PF_ISDN,
 816         .create = mISDN_sock_create,
 817 };
 818
 819 int
 820 misdn_sock_init(u_int *deb)
 821 {
 822         int err;
 823
 824         debug = deb;
 825         err = sock_register(&mISDN_sock_family_ops);
 826         if (err)
 827                 printk(KERN_ERR "%s: error(%d)\n", __func__, err);
 828         return err;
 829 }
 830
 831 void
 832 misdn_sock_cleanup(void)
 833 {
 834         sock_unregister(PF_ISDN);
 835 }