0001
0002
0003
0004
0005
0006
0007
0008
0009 #include <linux/mISDNif.h>
0010 #include <linux/slab.h>
0011 #include <linux/export.h>
0012 #include "core.h"
0013
0014 static u_int *debug;
0015
0016 static struct proto mISDN_proto = {
0017 .name = "misdn",
0018 .owner = THIS_MODULE,
0019 .obj_size = sizeof(struct mISDN_sock)
0020 };
0021
0022 #define _pms(sk) ((struct mISDN_sock *)sk)
0023
0024 static struct mISDN_sock_list data_sockets = {
0025 .lock = __RW_LOCK_UNLOCKED(data_sockets.lock)
0026 };
0027
0028 static struct mISDN_sock_list base_sockets = {
0029 .lock = __RW_LOCK_UNLOCKED(base_sockets.lock)
0030 };
0031
0032 #define L2_HEADER_LEN 4
0033
0034 static inline struct sk_buff *
0035 _l2_alloc_skb(unsigned int len, gfp_t gfp_mask)
0036 {
0037 struct sk_buff *skb;
0038
0039 skb = alloc_skb(len + L2_HEADER_LEN, gfp_mask);
0040 if (likely(skb))
0041 skb_reserve(skb, L2_HEADER_LEN);
0042 return skb;
0043 }
0044
0045 static void
0046 mISDN_sock_link(struct mISDN_sock_list *l, struct sock *sk)
0047 {
0048 write_lock_bh(&l->lock);
0049 sk_add_node(sk, &l->head);
0050 write_unlock_bh(&l->lock);
0051 }
0052
0053 static void mISDN_sock_unlink(struct mISDN_sock_list *l, struct sock *sk)
0054 {
0055 write_lock_bh(&l->lock);
0056 sk_del_node_init(sk);
0057 write_unlock_bh(&l->lock);
0058 }
0059
0060 static int
0061 mISDN_send(struct mISDNchannel *ch, struct sk_buff *skb)
0062 {
0063 struct mISDN_sock *msk;
0064 int err;
0065
0066 msk = container_of(ch, struct mISDN_sock, ch);
0067 if (*debug & DEBUG_SOCKET)
0068 printk(KERN_DEBUG "%s len %d %p\n", __func__, skb->len, skb);
0069 if (msk->sk.sk_state == MISDN_CLOSED)
0070 return -EUNATCH;
0071 __net_timestamp(skb);
0072 err = sock_queue_rcv_skb(&msk->sk, skb);
0073 if (err)
0074 printk(KERN_WARNING "%s: error %d\n", __func__, err);
0075 return err;
0076 }
0077
0078 static int
0079 mISDN_ctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
0080 {
0081 struct mISDN_sock *msk;
0082
0083 msk = container_of(ch, struct mISDN_sock, ch);
0084 if (*debug & DEBUG_SOCKET)
0085 printk(KERN_DEBUG "%s(%p, %x, %p)\n", __func__, ch, cmd, arg);
0086 switch (cmd) {
0087 case CLOSE_CHANNEL:
0088 msk->sk.sk_state = MISDN_CLOSED;
0089 break;
0090 }
0091 return 0;
0092 }
0093
0094 static inline void
0095 mISDN_sock_cmsg(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
0096 {
0097 struct __kernel_old_timeval tv;
0098
0099 if (_pms(sk)->cmask & MISDN_TIME_STAMP) {
0100 skb_get_timestamp(skb, &tv);
0101 put_cmsg(msg, SOL_MISDN, MISDN_TIME_STAMP, sizeof(tv), &tv);
0102 }
0103 }
0104
0105 static int
0106 mISDN_sock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
0107 int flags)
0108 {
0109 struct sk_buff *skb;
0110 struct sock *sk = sock->sk;
0111
0112 int copied, err;
0113
0114 if (*debug & DEBUG_SOCKET)
0115 printk(KERN_DEBUG "%s: len %d, flags %x ch.nr %d, proto %x\n",
0116 __func__, (int)len, flags, _pms(sk)->ch.nr,
0117 sk->sk_protocol);
0118 if (flags & (MSG_OOB))
0119 return -EOPNOTSUPP;
0120
0121 if (sk->sk_state == MISDN_CLOSED)
0122 return 0;
0123
0124 skb = skb_recv_datagram(sk, flags, &err);
0125 if (!skb)
0126 return err;
0127
0128 if (msg->msg_name) {
0129 DECLARE_SOCKADDR(struct sockaddr_mISDN *, maddr, msg->msg_name);
0130
0131 maddr->family = AF_ISDN;
0132 maddr->dev = _pms(sk)->dev->id;
0133 if ((sk->sk_protocol == ISDN_P_LAPD_TE) ||
0134 (sk->sk_protocol == ISDN_P_LAPD_NT)) {
0135 maddr->channel = (mISDN_HEAD_ID(skb) >> 16) & 0xff;
0136 maddr->tei = (mISDN_HEAD_ID(skb) >> 8) & 0xff;
0137 maddr->sapi = mISDN_HEAD_ID(skb) & 0xff;
0138 } else {
0139 maddr->channel = _pms(sk)->ch.nr;
0140 maddr->sapi = _pms(sk)->ch.addr & 0xFF;
0141 maddr->tei = (_pms(sk)->ch.addr >> 8) & 0xFF;
0142 }
0143 msg->msg_namelen = sizeof(*maddr);
0144 }
0145
0146 copied = skb->len + MISDN_HEADER_LEN;
0147 if (len < copied) {
0148 if (flags & MSG_PEEK)
0149 refcount_dec(&skb->users);
0150 else
0151 skb_queue_head(&sk->sk_receive_queue, skb);
0152 return -ENOSPC;
0153 }
0154 memcpy(skb_push(skb, MISDN_HEADER_LEN), mISDN_HEAD_P(skb),
0155 MISDN_HEADER_LEN);
0156
0157 err = skb_copy_datagram_msg(skb, 0, msg, copied);
0158
0159 mISDN_sock_cmsg(sk, msg, skb);
0160
0161 skb_free_datagram(sk, skb);
0162
0163 return err ? : copied;
0164 }
0165
0166 static int
0167 mISDN_sock_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
0168 {
0169 struct sock *sk = sock->sk;
0170 struct sk_buff *skb;
0171 int err = -ENOMEM;
0172
0173 if (*debug & DEBUG_SOCKET)
0174 printk(KERN_DEBUG "%s: len %d flags %x ch %d proto %x\n",
0175 __func__, (int)len, msg->msg_flags, _pms(sk)->ch.nr,
0176 sk->sk_protocol);
0177
0178 if (msg->msg_flags & MSG_OOB)
0179 return -EOPNOTSUPP;
0180
0181 if (msg->msg_flags & ~(MSG_DONTWAIT | MSG_NOSIGNAL | MSG_ERRQUEUE))
0182 return -EINVAL;
0183
0184 if (len < MISDN_HEADER_LEN)
0185 return -EINVAL;
0186
0187 if (sk->sk_state != MISDN_BOUND)
0188 return -EBADFD;
0189
0190 lock_sock(sk);
0191
0192 skb = _l2_alloc_skb(len, GFP_KERNEL);
0193 if (!skb)
0194 goto done;
0195
0196 if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
0197 err = -EFAULT;
0198 goto done;
0199 }
0200
0201 memcpy(mISDN_HEAD_P(skb), skb->data, MISDN_HEADER_LEN);
0202 skb_pull(skb, MISDN_HEADER_LEN);
0203
0204 if (msg->msg_namelen >= sizeof(struct sockaddr_mISDN)) {
0205
0206 DECLARE_SOCKADDR(struct sockaddr_mISDN *, maddr, msg->msg_name);
0207 mISDN_HEAD_ID(skb) = maddr->channel;
0208 } else {
0209 if ((sk->sk_protocol == ISDN_P_LAPD_TE) ||
0210 (sk->sk_protocol == ISDN_P_LAPD_NT))
0211 mISDN_HEAD_ID(skb) = _pms(sk)->ch.nr;
0212 }
0213
0214 if (*debug & DEBUG_SOCKET)
0215 printk(KERN_DEBUG "%s: ID:%x\n",
0216 __func__, mISDN_HEAD_ID(skb));
0217
0218 err = -ENODEV;
0219 if (!_pms(sk)->ch.peer)
0220 goto done;
0221 err = _pms(sk)->ch.recv(_pms(sk)->ch.peer, skb);
0222 if (err)
0223 goto done;
0224 else {
0225 skb = NULL;
0226 err = len;
0227 }
0228
0229 done:
0230 kfree_skb(skb);
0231 release_sock(sk);
0232 return err;
0233 }
0234
0235 static int
0236 data_sock_release(struct socket *sock)
0237 {
0238 struct sock *sk = sock->sk;
0239
0240 if (*debug & DEBUG_SOCKET)
0241 printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
0242 if (!sk)
0243 return 0;
0244 switch (sk->sk_protocol) {
0245 case ISDN_P_TE_S0:
0246 case ISDN_P_NT_S0:
0247 case ISDN_P_TE_E1:
0248 case ISDN_P_NT_E1:
0249 if (sk->sk_state == MISDN_BOUND)
0250 delete_channel(&_pms(sk)->ch);
0251 else
0252 mISDN_sock_unlink(&data_sockets, sk);
0253 break;
0254 case ISDN_P_LAPD_TE:
0255 case ISDN_P_LAPD_NT:
0256 case ISDN_P_B_RAW:
0257 case ISDN_P_B_HDLC:
0258 case ISDN_P_B_X75SLP:
0259 case ISDN_P_B_L2DTMF:
0260 case ISDN_P_B_L2DSP:
0261 case ISDN_P_B_L2DSPHDLC:
0262 delete_channel(&_pms(sk)->ch);
0263 mISDN_sock_unlink(&data_sockets, sk);
0264 break;
0265 }
0266
0267 lock_sock(sk);
0268
0269 sock_orphan(sk);
0270 skb_queue_purge(&sk->sk_receive_queue);
0271
0272 release_sock(sk);
0273 sock_put(sk);
0274
0275 return 0;
0276 }
0277
0278 static int
0279 data_sock_ioctl_bound(struct sock *sk, unsigned int cmd, void __user *p)
0280 {
0281 struct mISDN_ctrl_req cq;
0282 int err = -EINVAL, val[2];
0283 struct mISDNchannel *bchan, *next;
0284
0285 lock_sock(sk);
0286 if (!_pms(sk)->dev) {
0287 err = -ENODEV;
0288 goto done;
0289 }
0290 switch (cmd) {
0291 case IMCTRLREQ:
0292 if (copy_from_user(&cq, p, sizeof(cq))) {
0293 err = -EFAULT;
0294 break;
0295 }
0296 if ((sk->sk_protocol & ~ISDN_P_B_MASK) == ISDN_P_B_START) {
0297 list_for_each_entry_safe(bchan, next,
0298 &_pms(sk)->dev->bchannels, list) {
0299 if (bchan->nr == cq.channel) {
0300 err = bchan->ctrl(bchan,
0301 CONTROL_CHANNEL, &cq);
0302 break;
0303 }
0304 }
0305 } else
0306 err = _pms(sk)->dev->D.ctrl(&_pms(sk)->dev->D,
0307 CONTROL_CHANNEL, &cq);
0308 if (err)
0309 break;
0310 if (copy_to_user(p, &cq, sizeof(cq)))
0311 err = -EFAULT;
0312 break;
0313 case IMCLEAR_L2:
0314 if (sk->sk_protocol != ISDN_P_LAPD_NT) {
0315 err = -EINVAL;
0316 break;
0317 }
0318 val[0] = cmd;
0319 if (get_user(val[1], (int __user *)p)) {
0320 err = -EFAULT;
0321 break;
0322 }
0323 err = _pms(sk)->dev->teimgr->ctrl(_pms(sk)->dev->teimgr,
0324 CONTROL_CHANNEL, val);
0325 break;
0326 case IMHOLD_L1:
0327 if (sk->sk_protocol != ISDN_P_LAPD_NT
0328 && sk->sk_protocol != ISDN_P_LAPD_TE) {
0329 err = -EINVAL;
0330 break;
0331 }
0332 val[0] = cmd;
0333 if (get_user(val[1], (int __user *)p)) {
0334 err = -EFAULT;
0335 break;
0336 }
0337 err = _pms(sk)->dev->teimgr->ctrl(_pms(sk)->dev->teimgr,
0338 CONTROL_CHANNEL, val);
0339 break;
0340 default:
0341 err = -EINVAL;
0342 break;
0343 }
0344 done:
0345 release_sock(sk);
0346 return err;
0347 }
0348
0349 static int
0350 data_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
0351 {
0352 int err = 0, id;
0353 struct sock *sk = sock->sk;
0354 struct mISDNdevice *dev;
0355 struct mISDNversion ver;
0356
0357 switch (cmd) {
0358 case IMGETVERSION:
0359 ver.major = MISDN_MAJOR_VERSION;
0360 ver.minor = MISDN_MINOR_VERSION;
0361 ver.release = MISDN_RELEASE;
0362 if (copy_to_user((void __user *)arg, &ver, sizeof(ver)))
0363 err = -EFAULT;
0364 break;
0365 case IMGETCOUNT:
0366 id = get_mdevice_count();
0367 if (put_user(id, (int __user *)arg))
0368 err = -EFAULT;
0369 break;
0370 case IMGETDEVINFO:
0371 if (get_user(id, (int __user *)arg)) {
0372 err = -EFAULT;
0373 break;
0374 }
0375 dev = get_mdevice(id);
0376 if (dev) {
0377 struct mISDN_devinfo di;
0378
0379 memset(&di, 0, sizeof(di));
0380 di.id = dev->id;
0381 di.Dprotocols = dev->Dprotocols;
0382 di.Bprotocols = dev->Bprotocols | get_all_Bprotocols();
0383 di.protocol = dev->D.protocol;
0384 memcpy(di.channelmap, dev->channelmap,
0385 sizeof(di.channelmap));
0386 di.nrbchan = dev->nrbchan;
0387 strscpy(di.name, dev_name(&dev->dev), sizeof(di.name));
0388 if (copy_to_user((void __user *)arg, &di, sizeof(di)))
0389 err = -EFAULT;
0390 } else
0391 err = -ENODEV;
0392 break;
0393 default:
0394 if (sk->sk_state == MISDN_BOUND)
0395 err = data_sock_ioctl_bound(sk, cmd,
0396 (void __user *)arg);
0397 else
0398 err = -ENOTCONN;
0399 }
0400 return err;
0401 }
0402
0403 static int data_sock_setsockopt(struct socket *sock, int level, int optname,
0404 sockptr_t optval, unsigned int len)
0405 {
0406 struct sock *sk = sock->sk;
0407 int err = 0, opt = 0;
0408
0409 if (*debug & DEBUG_SOCKET)
0410 printk(KERN_DEBUG "%s(%p, %d, %x, optval, %d)\n", __func__, sock,
0411 level, optname, len);
0412
0413 lock_sock(sk);
0414
0415 switch (optname) {
0416 case MISDN_TIME_STAMP:
0417 if (copy_from_sockptr(&opt, optval, sizeof(int))) {
0418 err = -EFAULT;
0419 break;
0420 }
0421
0422 if (opt)
0423 _pms(sk)->cmask |= MISDN_TIME_STAMP;
0424 else
0425 _pms(sk)->cmask &= ~MISDN_TIME_STAMP;
0426 break;
0427 default:
0428 err = -ENOPROTOOPT;
0429 break;
0430 }
0431 release_sock(sk);
0432 return err;
0433 }
0434
0435 static int data_sock_getsockopt(struct socket *sock, int level, int optname,
0436 char __user *optval, int __user *optlen)
0437 {
0438 struct sock *sk = sock->sk;
0439 int len, opt;
0440
0441 if (get_user(len, optlen))
0442 return -EFAULT;
0443
0444 if (len != sizeof(char))
0445 return -EINVAL;
0446
0447 switch (optname) {
0448 case MISDN_TIME_STAMP:
0449 if (_pms(sk)->cmask & MISDN_TIME_STAMP)
0450 opt = 1;
0451 else
0452 opt = 0;
0453
0454 if (put_user(opt, optval))
0455 return -EFAULT;
0456 break;
0457 default:
0458 return -ENOPROTOOPT;
0459 }
0460
0461 return 0;
0462 }
0463
0464 static int
0465 data_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
0466 {
0467 struct sockaddr_mISDN *maddr = (struct sockaddr_mISDN *) addr;
0468 struct sock *sk = sock->sk;
0469 struct sock *csk;
0470 int err = 0;
0471
0472 if (*debug & DEBUG_SOCKET)
0473 printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
0474 if (addr_len != sizeof(struct sockaddr_mISDN))
0475 return -EINVAL;
0476 if (!maddr || maddr->family != AF_ISDN)
0477 return -EINVAL;
0478
0479 lock_sock(sk);
0480
0481 if (_pms(sk)->dev) {
0482 err = -EALREADY;
0483 goto done;
0484 }
0485 _pms(sk)->dev = get_mdevice(maddr->dev);
0486 if (!_pms(sk)->dev) {
0487 err = -ENODEV;
0488 goto done;
0489 }
0490
0491 if (sk->sk_protocol < ISDN_P_B_START) {
0492 read_lock_bh(&data_sockets.lock);
0493 sk_for_each(csk, &data_sockets.head) {
0494 if (sk == csk)
0495 continue;
0496 if (_pms(csk)->dev != _pms(sk)->dev)
0497 continue;
0498 if (csk->sk_protocol >= ISDN_P_B_START)
0499 continue;
0500 if (IS_ISDN_P_TE(csk->sk_protocol)
0501 == IS_ISDN_P_TE(sk->sk_protocol))
0502 continue;
0503 read_unlock_bh(&data_sockets.lock);
0504 err = -EBUSY;
0505 goto done;
0506 }
0507 read_unlock_bh(&data_sockets.lock);
0508 }
0509
0510 _pms(sk)->ch.send = mISDN_send;
0511 _pms(sk)->ch.ctrl = mISDN_ctrl;
0512
0513 switch (sk->sk_protocol) {
0514 case ISDN_P_TE_S0:
0515 case ISDN_P_NT_S0:
0516 case ISDN_P_TE_E1:
0517 case ISDN_P_NT_E1:
0518 mISDN_sock_unlink(&data_sockets, sk);
0519 err = connect_layer1(_pms(sk)->dev, &_pms(sk)->ch,
0520 sk->sk_protocol, maddr);
0521 if (err)
0522 mISDN_sock_link(&data_sockets, sk);
0523 break;
0524 case ISDN_P_LAPD_TE:
0525 case ISDN_P_LAPD_NT:
0526 err = create_l2entity(_pms(sk)->dev, &_pms(sk)->ch,
0527 sk->sk_protocol, maddr);
0528 break;
0529 case ISDN_P_B_RAW:
0530 case ISDN_P_B_HDLC:
0531 case ISDN_P_B_X75SLP:
0532 case ISDN_P_B_L2DTMF:
0533 case ISDN_P_B_L2DSP:
0534 case ISDN_P_B_L2DSPHDLC:
0535 err = connect_Bstack(_pms(sk)->dev, &_pms(sk)->ch,
0536 sk->sk_protocol, maddr);
0537 break;
0538 default:
0539 err = -EPROTONOSUPPORT;
0540 }
0541 if (err)
0542 goto done;
0543 sk->sk_state = MISDN_BOUND;
0544 _pms(sk)->ch.protocol = sk->sk_protocol;
0545
0546 done:
0547 release_sock(sk);
0548 return err;
0549 }
0550
0551 static int
0552 data_sock_getname(struct socket *sock, struct sockaddr *addr,
0553 int peer)
0554 {
0555 struct sockaddr_mISDN *maddr = (struct sockaddr_mISDN *) addr;
0556 struct sock *sk = sock->sk;
0557
0558 if (!_pms(sk)->dev)
0559 return -EBADFD;
0560
0561 lock_sock(sk);
0562
0563 maddr->family = AF_ISDN;
0564 maddr->dev = _pms(sk)->dev->id;
0565 maddr->channel = _pms(sk)->ch.nr;
0566 maddr->sapi = _pms(sk)->ch.addr & 0xff;
0567 maddr->tei = (_pms(sk)->ch.addr >> 8) & 0xff;
0568 release_sock(sk);
0569 return sizeof(*maddr);
0570 }
0571
0572 static const struct proto_ops data_sock_ops = {
0573 .family = PF_ISDN,
0574 .owner = THIS_MODULE,
0575 .release = data_sock_release,
0576 .ioctl = data_sock_ioctl,
0577 .bind = data_sock_bind,
0578 .getname = data_sock_getname,
0579 .sendmsg = mISDN_sock_sendmsg,
0580 .recvmsg = mISDN_sock_recvmsg,
0581 .poll = datagram_poll,
0582 .listen = sock_no_listen,
0583 .shutdown = sock_no_shutdown,
0584 .setsockopt = data_sock_setsockopt,
0585 .getsockopt = data_sock_getsockopt,
0586 .connect = sock_no_connect,
0587 .socketpair = sock_no_socketpair,
0588 .accept = sock_no_accept,
0589 .mmap = sock_no_mmap
0590 };
0591
0592 static int
0593 data_sock_create(struct net *net, struct socket *sock, int protocol, int kern)
0594 {
0595 struct sock *sk;
0596
0597 if (sock->type != SOCK_DGRAM)
0598 return -ESOCKTNOSUPPORT;
0599
0600 sk = sk_alloc(net, PF_ISDN, GFP_KERNEL, &mISDN_proto, kern);
0601 if (!sk)
0602 return -ENOMEM;
0603
0604 sock_init_data(sock, sk);
0605
0606 sock->ops = &data_sock_ops;
0607 sock->state = SS_UNCONNECTED;
0608 sock_reset_flag(sk, SOCK_ZAPPED);
0609
0610 sk->sk_protocol = protocol;
0611 sk->sk_state = MISDN_OPEN;
0612 mISDN_sock_link(&data_sockets, sk);
0613
0614 return 0;
0615 }
0616
0617 static int
0618 base_sock_release(struct socket *sock)
0619 {
0620 struct sock *sk = sock->sk;
0621
0622 printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
0623 if (!sk)
0624 return 0;
0625
0626 mISDN_sock_unlink(&base_sockets, sk);
0627 sock_orphan(sk);
0628 sock_put(sk);
0629
0630 return 0;
0631 }
0632
0633 static int
0634 base_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
0635 {
0636 int err = 0, id;
0637 struct mISDNdevice *dev;
0638 struct mISDNversion ver;
0639
0640 switch (cmd) {
0641 case IMGETVERSION:
0642 ver.major = MISDN_MAJOR_VERSION;
0643 ver.minor = MISDN_MINOR_VERSION;
0644 ver.release = MISDN_RELEASE;
0645 if (copy_to_user((void __user *)arg, &ver, sizeof(ver)))
0646 err = -EFAULT;
0647 break;
0648 case IMGETCOUNT:
0649 id = get_mdevice_count();
0650 if (put_user(id, (int __user *)arg))
0651 err = -EFAULT;
0652 break;
0653 case IMGETDEVINFO:
0654 if (get_user(id, (int __user *)arg)) {
0655 err = -EFAULT;
0656 break;
0657 }
0658 dev = get_mdevice(id);
0659 if (dev) {
0660 struct mISDN_devinfo di;
0661
0662 memset(&di, 0, sizeof(di));
0663 di.id = dev->id;
0664 di.Dprotocols = dev->Dprotocols;
0665 di.Bprotocols = dev->Bprotocols | get_all_Bprotocols();
0666 di.protocol = dev->D.protocol;
0667 memcpy(di.channelmap, dev->channelmap,
0668 sizeof(di.channelmap));
0669 di.nrbchan = dev->nrbchan;
0670 strscpy(di.name, dev_name(&dev->dev), sizeof(di.name));
0671 if (copy_to_user((void __user *)arg, &di, sizeof(di)))
0672 err = -EFAULT;
0673 } else
0674 err = -ENODEV;
0675 break;
0676 case IMSETDEVNAME:
0677 {
0678 struct mISDN_devrename dn;
0679 if (copy_from_user(&dn, (void __user *)arg,
0680 sizeof(dn))) {
0681 err = -EFAULT;
0682 break;
0683 }
0684 dn.name[sizeof(dn.name) - 1] = '\0';
0685 dev = get_mdevice(dn.id);
0686 if (dev)
0687 err = device_rename(&dev->dev, dn.name);
0688 else
0689 err = -ENODEV;
0690 }
0691 break;
0692 default:
0693 err = -EINVAL;
0694 }
0695 return err;
0696 }
0697
0698 static int
0699 base_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
0700 {
0701 struct sockaddr_mISDN *maddr = (struct sockaddr_mISDN *) addr;
0702 struct sock *sk = sock->sk;
0703 int err = 0;
0704
0705 if (addr_len < sizeof(struct sockaddr_mISDN))
0706 return -EINVAL;
0707
0708 if (!maddr || maddr->family != AF_ISDN)
0709 return -EINVAL;
0710
0711 lock_sock(sk);
0712
0713 if (_pms(sk)->dev) {
0714 err = -EALREADY;
0715 goto done;
0716 }
0717
0718 _pms(sk)->dev = get_mdevice(maddr->dev);
0719 if (!_pms(sk)->dev) {
0720 err = -ENODEV;
0721 goto done;
0722 }
0723 sk->sk_state = MISDN_BOUND;
0724
0725 done:
0726 release_sock(sk);
0727 return err;
0728 }
0729
0730 static const struct proto_ops base_sock_ops = {
0731 .family = PF_ISDN,
0732 .owner = THIS_MODULE,
0733 .release = base_sock_release,
0734 .ioctl = base_sock_ioctl,
0735 .bind = base_sock_bind,
0736 .getname = sock_no_getname,
0737 .sendmsg = sock_no_sendmsg,
0738 .recvmsg = sock_no_recvmsg,
0739 .listen = sock_no_listen,
0740 .shutdown = sock_no_shutdown,
0741 .connect = sock_no_connect,
0742 .socketpair = sock_no_socketpair,
0743 .accept = sock_no_accept,
0744 .mmap = sock_no_mmap
0745 };
0746
0747
0748 static int
0749 base_sock_create(struct net *net, struct socket *sock, int protocol, int kern)
0750 {
0751 struct sock *sk;
0752
0753 if (sock->type != SOCK_RAW)
0754 return -ESOCKTNOSUPPORT;
0755 if (!capable(CAP_NET_RAW))
0756 return -EPERM;
0757
0758 sk = sk_alloc(net, PF_ISDN, GFP_KERNEL, &mISDN_proto, kern);
0759 if (!sk)
0760 return -ENOMEM;
0761
0762 sock_init_data(sock, sk);
0763 sock->ops = &base_sock_ops;
0764 sock->state = SS_UNCONNECTED;
0765 sock_reset_flag(sk, SOCK_ZAPPED);
0766 sk->sk_protocol = protocol;
0767 sk->sk_state = MISDN_OPEN;
0768 mISDN_sock_link(&base_sockets, sk);
0769
0770 return 0;
0771 }
0772
0773 static int
0774 mISDN_sock_create(struct net *net, struct socket *sock, int proto, int kern)
0775 {
0776 int err = -EPROTONOSUPPORT;
0777
0778 switch (proto) {
0779 case ISDN_P_BASE:
0780 err = base_sock_create(net, sock, proto, kern);
0781 break;
0782 case ISDN_P_TE_S0:
0783 case ISDN_P_NT_S0:
0784 case ISDN_P_TE_E1:
0785 case ISDN_P_NT_E1:
0786 case ISDN_P_LAPD_TE:
0787 case ISDN_P_LAPD_NT:
0788 case ISDN_P_B_RAW:
0789 case ISDN_P_B_HDLC:
0790 case ISDN_P_B_X75SLP:
0791 case ISDN_P_B_L2DTMF:
0792 case ISDN_P_B_L2DSP:
0793 case ISDN_P_B_L2DSPHDLC:
0794 err = data_sock_create(net, sock, proto, kern);
0795 break;
0796 default:
0797 return err;
0798 }
0799
0800 return err;
0801 }
0802
0803 static const struct net_proto_family mISDN_sock_family_ops = {
0804 .owner = THIS_MODULE,
0805 .family = PF_ISDN,
0806 .create = mISDN_sock_create,
0807 };
0808
0809 int
0810 misdn_sock_init(u_int *deb)
0811 {
0812 int err;
0813
0814 debug = deb;
0815 err = sock_register(&mISDN_sock_family_ops);
0816 if (err)
0817 printk(KERN_ERR "%s: error(%d)\n", __func__, err);
0818 return err;
0819 }
0820
0821 void
0822 misdn_sock_cleanup(void)
0823 {
0824 sock_unregister(PF_ISDN);
0825 }
