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