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