1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61#include <linux/mm.h>
62#include <linux/socket.h>
63#include <linux/file.h>
64#include <linux/net.h>
65#include <linux/interrupt.h>
66#include <linux/thread_info.h>
67#include <linux/rcupdate.h>
68#include <linux/netdevice.h>
69#include <linux/proc_fs.h>
70#include <linux/seq_file.h>
71#include <linux/mutex.h>
72#include <linux/if_bridge.h>
73#include <linux/if_frad.h>
74#include <linux/if_vlan.h>
75#include <linux/ptp_classify.h>
76#include <linux/init.h>
77#include <linux/poll.h>
78#include <linux/cache.h>
79#include <linux/module.h>
80#include <linux/highmem.h>
81#include <linux/mount.h>
82#include <linux/security.h>
83#include <linux/syscalls.h>
84#include <linux/compat.h>
85#include <linux/kmod.h>
86#include <linux/audit.h>
87#include <linux/wireless.h>
88#include <linux/nsproxy.h>
89#include <linux/magic.h>
90#include <linux/slab.h>
91#include <linux/xattr.h>
92
93#include <asm/uaccess.h>
94#include <asm/unistd.h>
95
96#include <net/compat.h>
97#include <net/wext.h>
98#include <net/cls_cgroup.h>
99
100#include <net/sock.h>
101#include <linux/netfilter.h>
102
103#include <linux/if_tun.h>
104#include <linux/ipv6_route.h>
105#include <linux/route.h>
106#include <linux/sockios.h>
107#include <linux/atalk.h>
108#include <net/busy_poll.h>
109#include <linux/errqueue.h>
110
111#ifdef CONFIG_NET_RX_BUSY_POLL
112unsigned int sysctl_net_busy_read __read_mostly;
113unsigned int sysctl_net_busy_poll __read_mostly;
114#endif
115
116static ssize_t sock_read_iter(struct kiocb *iocb, struct iov_iter *to);
117static ssize_t sock_write_iter(struct kiocb *iocb, struct iov_iter *from);
118static int sock_mmap(struct file *file, struct vm_area_struct *vma);
119
120static int sock_close(struct inode *inode, struct file *file);
121static unsigned int sock_poll(struct file *file,
122 struct poll_table_struct *wait);
123static long sock_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
124#ifdef CONFIG_COMPAT
125static long compat_sock_ioctl(struct file *file,
126 unsigned int cmd, unsigned long arg);
127#endif
128static int sock_fasync(int fd, struct file *filp, int on);
129static ssize_t sock_sendpage(struct file *file, struct page *page,
130 int offset, size_t size, loff_t *ppos, int more);
131static ssize_t sock_splice_read(struct file *file, loff_t *ppos,
132 struct pipe_inode_info *pipe, size_t len,
133 unsigned int flags);
134
135
136
137
138
139
140static const struct file_operations socket_file_ops = {
141 .owner = THIS_MODULE,
142 .llseek = no_llseek,
143 .read_iter = sock_read_iter,
144 .write_iter = sock_write_iter,
145 .poll = sock_poll,
146 .unlocked_ioctl = sock_ioctl,
147#ifdef CONFIG_COMPAT
148 .compat_ioctl = compat_sock_ioctl,
149#endif
150 .mmap = sock_mmap,
151 .release = sock_close,
152 .fasync = sock_fasync,
153 .sendpage = sock_sendpage,
154 .splice_write = generic_splice_sendpage,
155 .splice_read = sock_splice_read,
156};
157
158
159
160
161
162static DEFINE_SPINLOCK(net_family_lock);
163static const struct net_proto_family __rcu *net_families[NPROTO] __read_mostly;
164
165
166
167
168
169static DEFINE_PER_CPU(int, sockets_in_use);
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188int move_addr_to_kernel(void __user *uaddr, int ulen, struct sockaddr_storage *kaddr)
189{
190 if (ulen < 0 || ulen > sizeof(struct sockaddr_storage))
191 return -EINVAL;
192 if (ulen == 0)
193 return 0;
194 if (copy_from_user(kaddr, uaddr, ulen))
195 return -EFAULT;
196 return audit_sockaddr(ulen, kaddr);
197}
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216static int move_addr_to_user(struct sockaddr_storage *kaddr, int klen,
217 void __user *uaddr, int __user *ulen)
218{
219 int err;
220 int len;
221
222 BUG_ON(klen > sizeof(struct sockaddr_storage));
223 err = get_user(len, ulen);
224 if (err)
225 return err;
226 if (len > klen)
227 len = klen;
228 if (len < 0)
229 return -EINVAL;
230 if (len) {
231 if (audit_sockaddr(klen, kaddr))
232 return -ENOMEM;
233 if (copy_to_user(uaddr, kaddr, len))
234 return -EFAULT;
235 }
236
237
238
239
240 return __put_user(klen, ulen);
241}
242
243static struct kmem_cache *sock_inode_cachep __read_mostly;
244
245static struct inode *sock_alloc_inode(struct super_block *sb)
246{
247 struct socket_alloc *ei;
248 struct socket_wq *wq;
249
250 ei = kmem_cache_alloc(sock_inode_cachep, GFP_KERNEL);
251 if (!ei)
252 return NULL;
253 wq = kmalloc(sizeof(*wq), GFP_KERNEL);
254 if (!wq) {
255 kmem_cache_free(sock_inode_cachep, ei);
256 return NULL;
257 }
258 init_waitqueue_head(&wq->wait);
259 wq->fasync_list = NULL;
260 wq->flags = 0;
261 RCU_INIT_POINTER(ei->socket.wq, wq);
262
263 ei->socket.state = SS_UNCONNECTED;
264 ei->socket.flags = 0;
265 ei->socket.ops = NULL;
266 ei->socket.sk = NULL;
267 ei->socket.file = NULL;
268
269 return &ei->vfs_inode;
270}
271
272static void sock_destroy_inode(struct inode *inode)
273{
274 struct socket_alloc *ei;
275 struct socket_wq *wq;
276
277 ei = container_of(inode, struct socket_alloc, vfs_inode);
278 wq = rcu_dereference_protected(ei->socket.wq, 1);
279 kfree_rcu(wq, rcu);
280 kmem_cache_free(sock_inode_cachep, ei);
281}
282
283static void init_once(void *foo)
284{
285 struct socket_alloc *ei = (struct socket_alloc *)foo;
286
287 inode_init_once(&ei->vfs_inode);
288}
289
290static int init_inodecache(void)
291{
292 sock_inode_cachep = kmem_cache_create("sock_inode_cache",
293 sizeof(struct socket_alloc),
294 0,
295 (SLAB_HWCACHE_ALIGN |
296 SLAB_RECLAIM_ACCOUNT |
297 SLAB_MEM_SPREAD | SLAB_ACCOUNT),
298 init_once);
299 if (sock_inode_cachep == NULL)
300 return -ENOMEM;
301 return 0;
302}
303
304static const struct super_operations sockfs_ops = {
305 .alloc_inode = sock_alloc_inode,
306 .destroy_inode = sock_destroy_inode,
307 .statfs = simple_statfs,
308};
309
310
311
312
313static char *sockfs_dname(struct dentry *dentry, char *buffer, int buflen)
314{
315 return dynamic_dname(dentry, buffer, buflen, "socket:[%lu]",
316 d_inode(dentry)->i_ino);
317}
318
319static const struct dentry_operations sockfs_dentry_operations = {
320 .d_dname = sockfs_dname,
321};
322
323static int sockfs_xattr_get(const struct xattr_handler *handler,
324 struct dentry *dentry, struct inode *inode,
325 const char *suffix, void *value, size_t size)
326{
327 if (value) {
328 if (dentry->d_name.len + 1 > size)
329 return -ERANGE;
330 memcpy(value, dentry->d_name.name, dentry->d_name.len + 1);
331 }
332 return dentry->d_name.len + 1;
333}
334
335#define XATTR_SOCKPROTONAME_SUFFIX "sockprotoname"
336#define XATTR_NAME_SOCKPROTONAME (XATTR_SYSTEM_PREFIX XATTR_SOCKPROTONAME_SUFFIX)
337#define XATTR_NAME_SOCKPROTONAME_LEN (sizeof(XATTR_NAME_SOCKPROTONAME)-1)
338
339static const struct xattr_handler sockfs_xattr_handler = {
340 .name = XATTR_NAME_SOCKPROTONAME,
341 .get = sockfs_xattr_get,
342};
343
344static int sockfs_security_xattr_set(const struct xattr_handler *handler,
345 struct dentry *dentry, struct inode *inode,
346 const char *suffix, const void *value,
347 size_t size, int flags)
348{
349
350 return -EAGAIN;
351}
352
353static const struct xattr_handler sockfs_security_xattr_handler = {
354 .prefix = XATTR_SECURITY_PREFIX,
355 .set = sockfs_security_xattr_set,
356};
357
358static const struct xattr_handler *sockfs_xattr_handlers[] = {
359 &sockfs_xattr_handler,
360 &sockfs_security_xattr_handler,
361 NULL
362};
363
364static struct dentry *sockfs_mount(struct file_system_type *fs_type,
365 int flags, const char *dev_name, void *data)
366{
367 return mount_pseudo_xattr(fs_type, "socket:", &sockfs_ops,
368 sockfs_xattr_handlers,
369 &sockfs_dentry_operations, SOCKFS_MAGIC);
370}
371
372static struct vfsmount *sock_mnt __read_mostly;
373
374static struct file_system_type sock_fs_type = {
375 .name = "sockfs",
376 .mount = sockfs_mount,
377 .kill_sb = kill_anon_super,
378};
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397struct file *sock_alloc_file(struct socket *sock, int flags, const char *dname)
398{
399 struct qstr name = { .name = "" };
400 struct path path;
401 struct file *file;
402
403 if (dname) {
404 name.name = dname;
405 name.len = strlen(name.name);
406 } else if (sock->sk) {
407 name.name = sock->sk->sk_prot_creator->name;
408 name.len = strlen(name.name);
409 }
410 path.dentry = d_alloc_pseudo(sock_mnt->mnt_sb, &name);
411 if (unlikely(!path.dentry))
412 return ERR_PTR(-ENOMEM);
413 path.mnt = mntget(sock_mnt);
414
415 d_instantiate(path.dentry, SOCK_INODE(sock));
416
417 file = alloc_file(&path, FMODE_READ | FMODE_WRITE,
418 &socket_file_ops);
419 if (IS_ERR(file)) {
420
421 ihold(d_inode(path.dentry));
422 path_put(&path);
423 return file;
424 }
425
426 sock->file = file;
427 file->f_flags = O_RDWR | (flags & O_NONBLOCK);
428 file->private_data = sock;
429 return file;
430}
431EXPORT_SYMBOL(sock_alloc_file);
432
433static int sock_map_fd(struct socket *sock, int flags)
434{
435 struct file *newfile;
436 int fd = get_unused_fd_flags(flags);
437 if (unlikely(fd < 0))
438 return fd;
439
440 newfile = sock_alloc_file(sock, flags, NULL);
441 if (likely(!IS_ERR(newfile))) {
442 fd_install(fd, newfile);
443 return fd;
444 }
445
446 put_unused_fd(fd);
447 return PTR_ERR(newfile);
448}
449
450struct socket *sock_from_file(struct file *file, int *err)
451{
452 if (file->f_op == &socket_file_ops)
453 return file->private_data;
454
455 *err = -ENOTSOCK;
456 return NULL;
457}
458EXPORT_SYMBOL(sock_from_file);
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473struct socket *sockfd_lookup(int fd, int *err)
474{
475 struct file *file;
476 struct socket *sock;
477
478 file = fget(fd);
479 if (!file) {
480 *err = -EBADF;
481 return NULL;
482 }
483
484 sock = sock_from_file(file, err);
485 if (!sock)
486 fput(file);
487 return sock;
488}
489EXPORT_SYMBOL(sockfd_lookup);
490
491static struct socket *sockfd_lookup_light(int fd, int *err, int *fput_needed)
492{
493 struct fd f = fdget(fd);
494 struct socket *sock;
495
496 *err = -EBADF;
497 if (f.file) {
498 sock = sock_from_file(f.file, err);
499 if (likely(sock)) {
500 *fput_needed = f.flags;
501 return sock;
502 }
503 fdput(f);
504 }
505 return NULL;
506}
507
508static ssize_t sockfs_listxattr(struct dentry *dentry, char *buffer,
509 size_t size)
510{
511 ssize_t len;
512 ssize_t used = 0;
513
514 len = security_inode_listsecurity(d_inode(dentry), buffer, size);
515 if (len < 0)
516 return len;
517 used += len;
518 if (buffer) {
519 if (size < used)
520 return -ERANGE;
521 buffer += len;
522 }
523
524 len = (XATTR_NAME_SOCKPROTONAME_LEN + 1);
525 used += len;
526 if (buffer) {
527 if (size < used)
528 return -ERANGE;
529 memcpy(buffer, XATTR_NAME_SOCKPROTONAME, len);
530 buffer += len;
531 }
532
533 return used;
534}
535
536static const struct inode_operations sockfs_inode_ops = {
537 .listxattr = sockfs_listxattr,
538};
539
540
541
542
543
544
545
546
547
548struct socket *sock_alloc(void)
549{
550 struct inode *inode;
551 struct socket *sock;
552
553 inode = new_inode_pseudo(sock_mnt->mnt_sb);
554 if (!inode)
555 return NULL;
556
557 sock = SOCKET_I(inode);
558
559 kmemcheck_annotate_bitfield(sock, type);
560 inode->i_ino = get_next_ino();
561 inode->i_mode = S_IFSOCK | S_IRWXUGO;
562 inode->i_uid = current_fsuid();
563 inode->i_gid = current_fsgid();
564 inode->i_op = &sockfs_inode_ops;
565
566 this_cpu_add(sockets_in_use, 1);
567 return sock;
568}
569EXPORT_SYMBOL(sock_alloc);
570
571
572
573
574
575
576
577
578
579
580void sock_release(struct socket *sock)
581{
582 if (sock->ops) {
583 struct module *owner = sock->ops->owner;
584
585 sock->ops->release(sock);
586 sock->ops = NULL;
587 module_put(owner);
588 }
589
590 if (rcu_dereference_protected(sock->wq, 1)->fasync_list)
591 pr_err("%s: fasync list not empty!\n", __func__);
592
593 this_cpu_sub(sockets_in_use, 1);
594 if (!sock->file) {
595 iput(SOCK_INODE(sock));
596 return;
597 }
598 sock->file = NULL;
599}
600EXPORT_SYMBOL(sock_release);
601
602void __sock_tx_timestamp(__u16 tsflags, __u8 *tx_flags)
603{
604 u8 flags = *tx_flags;
605
606 if (tsflags & SOF_TIMESTAMPING_TX_HARDWARE)
607 flags |= SKBTX_HW_TSTAMP;
608
609 if (tsflags & SOF_TIMESTAMPING_TX_SOFTWARE)
610 flags |= SKBTX_SW_TSTAMP;
611
612 if (tsflags & SOF_TIMESTAMPING_TX_SCHED)
613 flags |= SKBTX_SCHED_TSTAMP;
614
615 *tx_flags = flags;
616}
617EXPORT_SYMBOL(__sock_tx_timestamp);
618
619static inline int sock_sendmsg_nosec(struct socket *sock, struct msghdr *msg)
620{
621 int ret = sock->ops->sendmsg(sock, msg, msg_data_left(msg));
622 BUG_ON(ret == -EIOCBQUEUED);
623 return ret;
624}
625
626int sock_sendmsg(struct socket *sock, struct msghdr *msg)
627{
628 int err = security_socket_sendmsg(sock, msg,
629 msg_data_left(msg));
630
631 return err ?: sock_sendmsg_nosec(sock, msg);
632}
633EXPORT_SYMBOL(sock_sendmsg);
634
635int kernel_sendmsg(struct socket *sock, struct msghdr *msg,
636 struct kvec *vec, size_t num, size_t size)
637{
638 iov_iter_kvec(&msg->msg_iter, WRITE | ITER_KVEC, vec, num, size);
639 return sock_sendmsg(sock, msg);
640}
641EXPORT_SYMBOL(kernel_sendmsg);
642
643
644
645
646void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
647 struct sk_buff *skb)
648{
649 int need_software_tstamp = sock_flag(sk, SOCK_RCVTSTAMP);
650 struct scm_timestamping tss;
651 int empty = 1;
652 struct skb_shared_hwtstamps *shhwtstamps =
653 skb_hwtstamps(skb);
654
655
656
657 if (need_software_tstamp && skb->tstamp.tv64 == 0)
658 __net_timestamp(skb);
659
660 if (need_software_tstamp) {
661 if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) {
662 struct timeval tv;
663 skb_get_timestamp(skb, &tv);
664 put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMP,
665 sizeof(tv), &tv);
666 } else {
667 struct timespec ts;
668 skb_get_timestampns(skb, &ts);
669 put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPNS,
670 sizeof(ts), &ts);
671 }
672 }
673
674 memset(&tss, 0, sizeof(tss));
675 if ((sk->sk_tsflags & SOF_TIMESTAMPING_SOFTWARE) &&
676 ktime_to_timespec_cond(skb->tstamp, tss.ts + 0))
677 empty = 0;
678 if (shhwtstamps &&
679 (sk->sk_tsflags & SOF_TIMESTAMPING_RAW_HARDWARE) &&
680 ktime_to_timespec_cond(shhwtstamps->hwtstamp, tss.ts + 2))
681 empty = 0;
682 if (!empty)
683 put_cmsg(msg, SOL_SOCKET,
684 SCM_TIMESTAMPING, sizeof(tss), &tss);
685}
686EXPORT_SYMBOL_GPL(__sock_recv_timestamp);
687
688void __sock_recv_wifi_status(struct msghdr *msg, struct sock *sk,
689 struct sk_buff *skb)
690{
691 int ack;
692
693 if (!sock_flag(sk, SOCK_WIFI_STATUS))
694 return;
695 if (!skb->wifi_acked_valid)
696 return;
697
698 ack = skb->wifi_acked;
699
700 put_cmsg(msg, SOL_SOCKET, SCM_WIFI_STATUS, sizeof(ack), &ack);
701}
702EXPORT_SYMBOL_GPL(__sock_recv_wifi_status);
703
704static inline void sock_recv_drops(struct msghdr *msg, struct sock *sk,
705 struct sk_buff *skb)
706{
707 if (sock_flag(sk, SOCK_RXQ_OVFL) && skb && SOCK_SKB_CB(skb)->dropcount)
708 put_cmsg(msg, SOL_SOCKET, SO_RXQ_OVFL,
709 sizeof(__u32), &SOCK_SKB_CB(skb)->dropcount);
710}
711
712void __sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk,
713 struct sk_buff *skb)
714{
715 sock_recv_timestamp(msg, sk, skb);
716 sock_recv_drops(msg, sk, skb);
717}
718EXPORT_SYMBOL_GPL(__sock_recv_ts_and_drops);
719
720static inline int sock_recvmsg_nosec(struct socket *sock, struct msghdr *msg,
721 int flags)
722{
723 return sock->ops->recvmsg(sock, msg, msg_data_left(msg), flags);
724}
725
726int sock_recvmsg(struct socket *sock, struct msghdr *msg, int flags)
727{
728 int err = security_socket_recvmsg(sock, msg, msg_data_left(msg), flags);
729
730 return err ?: sock_recvmsg_nosec(sock, msg, flags);
731}
732EXPORT_SYMBOL(sock_recvmsg);
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749int kernel_recvmsg(struct socket *sock, struct msghdr *msg,
750 struct kvec *vec, size_t num, size_t size, int flags)
751{
752 mm_segment_t oldfs = get_fs();
753 int result;
754
755 iov_iter_kvec(&msg->msg_iter, READ | ITER_KVEC, vec, num, size);
756 set_fs(KERNEL_DS);
757 result = sock_recvmsg(sock, msg, flags);
758 set_fs(oldfs);
759 return result;
760}
761EXPORT_SYMBOL(kernel_recvmsg);
762
763static ssize_t sock_sendpage(struct file *file, struct page *page,
764 int offset, size_t size, loff_t *ppos, int more)
765{
766 struct socket *sock;
767 int flags;
768
769 sock = file->private_data;
770
771 flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;
772
773 flags |= more;
774
775 return kernel_sendpage(sock, page, offset, size, flags);
776}
777
778static ssize_t sock_splice_read(struct file *file, loff_t *ppos,
779 struct pipe_inode_info *pipe, size_t len,
780 unsigned int flags)
781{
782 struct socket *sock = file->private_data;
783
784 if (unlikely(!sock->ops->splice_read))
785 return -EINVAL;
786
787 return sock->ops->splice_read(sock, ppos, pipe, len, flags);
788}
789
790static ssize_t sock_read_iter(struct kiocb *iocb, struct iov_iter *to)
791{
792 struct file *file = iocb->ki_filp;
793 struct socket *sock = file->private_data;
794 struct msghdr msg = {.msg_iter = *to,
795 .msg_iocb = iocb};
796 ssize_t res;
797
798 if (file->f_flags & O_NONBLOCK)
799 msg.msg_flags = MSG_DONTWAIT;
800
801 if (iocb->ki_pos != 0)
802 return -ESPIPE;
803
804 if (!iov_iter_count(to))
805 return 0;
806
807 res = sock_recvmsg(sock, &msg, msg.msg_flags);
808 *to = msg.msg_iter;
809 return res;
810}
811
812static ssize_t sock_write_iter(struct kiocb *iocb, struct iov_iter *from)
813{
814 struct file *file = iocb->ki_filp;
815 struct socket *sock = file->private_data;
816 struct msghdr msg = {.msg_iter = *from,
817 .msg_iocb = iocb};
818 ssize_t res;
819
820 if (iocb->ki_pos != 0)
821 return -ESPIPE;
822
823 if (file->f_flags & O_NONBLOCK)
824 msg.msg_flags = MSG_DONTWAIT;
825
826 if (sock->type == SOCK_SEQPACKET)
827 msg.msg_flags |= MSG_EOR;
828
829 res = sock_sendmsg(sock, &msg);
830 *from = msg.msg_iter;
831 return res;
832}
833
834
835
836
837
838
839static DEFINE_MUTEX(br_ioctl_mutex);
840static int (*br_ioctl_hook) (struct net *, unsigned int cmd, void __user *arg);
841
842void brioctl_set(int (*hook) (struct net *, unsigned int, void __user *))
843{
844 mutex_lock(&br_ioctl_mutex);
845 br_ioctl_hook = hook;
846 mutex_unlock(&br_ioctl_mutex);
847}
848EXPORT_SYMBOL(brioctl_set);
849
850static DEFINE_MUTEX(vlan_ioctl_mutex);
851static int (*vlan_ioctl_hook) (struct net *, void __user *arg);
852
853void vlan_ioctl_set(int (*hook) (struct net *, void __user *))
854{
855 mutex_lock(&vlan_ioctl_mutex);
856 vlan_ioctl_hook = hook;
857 mutex_unlock(&vlan_ioctl_mutex);
858}
859EXPORT_SYMBOL(vlan_ioctl_set);
860
861static DEFINE_MUTEX(dlci_ioctl_mutex);
862static int (*dlci_ioctl_hook) (unsigned int, void __user *);
863
864void dlci_ioctl_set(int (*hook) (unsigned int, void __user *))
865{
866 mutex_lock(&dlci_ioctl_mutex);
867 dlci_ioctl_hook = hook;
868 mutex_unlock(&dlci_ioctl_mutex);
869}
870EXPORT_SYMBOL(dlci_ioctl_set);
871
872static long sock_do_ioctl(struct net *net, struct socket *sock,
873 unsigned int cmd, unsigned long arg)
874{
875 int err;
876 void __user *argp = (void __user *)arg;
877
878 err = sock->ops->ioctl(sock, cmd, arg);
879
880
881
882
883
884 if (err == -ENOIOCTLCMD)
885 err = dev_ioctl(net, cmd, argp);
886
887 return err;
888}
889
890
891
892
893
894
895static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg)
896{
897 struct socket *sock;
898 struct sock *sk;
899 void __user *argp = (void __user *)arg;
900 int pid, err;
901 struct net *net;
902
903 sock = file->private_data;
904 sk = sock->sk;
905 net = sock_net(sk);
906 if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) {
907 err = dev_ioctl(net, cmd, argp);
908 } else
909#ifdef CONFIG_WEXT_CORE
910 if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) {
911 err = dev_ioctl(net, cmd, argp);
912 } else
913#endif
914 switch (cmd) {
915 case FIOSETOWN:
916 case SIOCSPGRP:
917 err = -EFAULT;
918 if (get_user(pid, (int __user *)argp))
919 break;
920 f_setown(sock->file, pid, 1);
921 err = 0;
922 break;
923 case FIOGETOWN:
924 case SIOCGPGRP:
925 err = put_user(f_getown(sock->file),
926 (int __user *)argp);
927 break;
928 case SIOCGIFBR:
929 case SIOCSIFBR:
930 case SIOCBRADDBR:
931 case SIOCBRDELBR:
932 err = -ENOPKG;
933 if (!br_ioctl_hook)
934 request_module("bridge");
935
936 mutex_lock(&br_ioctl_mutex);
937 if (br_ioctl_hook)
938 err = br_ioctl_hook(net, cmd, argp);
939 mutex_unlock(&br_ioctl_mutex);
940 break;
941 case SIOCGIFVLAN:
942 case SIOCSIFVLAN:
943 err = -ENOPKG;
944 if (!vlan_ioctl_hook)
945 request_module("8021q");
946
947 mutex_lock(&vlan_ioctl_mutex);
948 if (vlan_ioctl_hook)
949 err = vlan_ioctl_hook(net, argp);
950 mutex_unlock(&vlan_ioctl_mutex);
951 break;
952 case SIOCADDDLCI:
953 case SIOCDELDLCI:
954 err = -ENOPKG;
955 if (!dlci_ioctl_hook)
956 request_module("dlci");
957
958 mutex_lock(&dlci_ioctl_mutex);
959 if (dlci_ioctl_hook)
960 err = dlci_ioctl_hook(cmd, argp);
961 mutex_unlock(&dlci_ioctl_mutex);
962 break;
963 default:
964 err = sock_do_ioctl(net, sock, cmd, arg);
965 break;
966 }
967 return err;
968}
969
970int sock_create_lite(int family, int type, int protocol, struct socket **res)
971{
972 int err;
973 struct socket *sock = NULL;
974
975 err = security_socket_create(family, type, protocol, 1);
976 if (err)
977 goto out;
978
979 sock = sock_alloc();
980 if (!sock) {
981 err = -ENOMEM;
982 goto out;
983 }
984
985 sock->type = type;
986 err = security_socket_post_create(sock, family, type, protocol, 1);
987 if (err)
988 goto out_release;
989
990out:
991 *res = sock;
992 return err;
993out_release:
994 sock_release(sock);
995 sock = NULL;
996 goto out;
997}
998EXPORT_SYMBOL(sock_create_lite);
999
1000
1001static unsigned int sock_poll(struct file *file, poll_table *wait)
1002{
1003 unsigned int busy_flag = 0;
1004 struct socket *sock;
1005
1006
1007
1008
1009 sock = file->private_data;
1010
1011 if (sk_can_busy_loop(sock->sk)) {
1012
1013 busy_flag = POLL_BUSY_LOOP;
1014
1015
1016 if (wait && (wait->_key & POLL_BUSY_LOOP))
1017 sk_busy_loop(sock->sk, 1);
1018 }
1019
1020 return busy_flag | sock->ops->poll(file, sock, wait);
1021}
1022
1023static int sock_mmap(struct file *file, struct vm_area_struct *vma)
1024{
1025 struct socket *sock = file->private_data;
1026
1027 return sock->ops->mmap(file, sock, vma);
1028}
1029
1030static int sock_close(struct inode *inode, struct file *filp)
1031{
1032 sock_release(SOCKET_I(inode));
1033 return 0;
1034}
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047static int sock_fasync(int fd, struct file *filp, int on)
1048{
1049 struct socket *sock = filp->private_data;
1050 struct sock *sk = sock->sk;
1051 struct socket_wq *wq;
1052
1053 if (sk == NULL)
1054 return -EINVAL;
1055
1056 lock_sock(sk);
1057 wq = rcu_dereference_protected(sock->wq, lockdep_sock_is_held(sk));
1058 fasync_helper(fd, filp, on, &wq->fasync_list);
1059
1060 if (!wq->fasync_list)
1061 sock_reset_flag(sk, SOCK_FASYNC);
1062 else
1063 sock_set_flag(sk, SOCK_FASYNC);
1064
1065 release_sock(sk);
1066 return 0;
1067}
1068
1069
1070
1071int sock_wake_async(struct socket_wq *wq, int how, int band)
1072{
1073 if (!wq || !wq->fasync_list)
1074 return -1;
1075
1076 switch (how) {
1077 case SOCK_WAKE_WAITD:
1078 if (test_bit(SOCKWQ_ASYNC_WAITDATA, &wq->flags))
1079 break;
1080 goto call_kill;
1081 case SOCK_WAKE_SPACE:
1082 if (!test_and_clear_bit(SOCKWQ_ASYNC_NOSPACE, &wq->flags))
1083 break;
1084
1085 case SOCK_WAKE_IO:
1086call_kill:
1087 kill_fasync(&wq->fasync_list, SIGIO, band);
1088 break;
1089 case SOCK_WAKE_URG:
1090 kill_fasync(&wq->fasync_list, SIGURG, band);
1091 }
1092
1093 return 0;
1094}
1095EXPORT_SYMBOL(sock_wake_async);
1096
1097int __sock_create(struct net *net, int family, int type, int protocol,
1098 struct socket **res, int kern)
1099{
1100 int err;
1101 struct socket *sock;
1102 const struct net_proto_family *pf;
1103
1104
1105
1106
1107 if (family < 0 || family >= NPROTO)
1108 return -EAFNOSUPPORT;
1109 if (type < 0 || type >= SOCK_MAX)
1110 return -EINVAL;
1111
1112
1113
1114
1115
1116
1117 if (family == PF_INET && type == SOCK_PACKET) {
1118 pr_info_once("%s uses obsolete (PF_INET,SOCK_PACKET)\n",
1119 current->comm);
1120 family = PF_PACKET;
1121 }
1122
1123 err = security_socket_create(family, type, protocol, kern);
1124 if (err)
1125 return err;
1126
1127
1128
1129
1130
1131
1132 sock = sock_alloc();
1133 if (!sock) {
1134 net_warn_ratelimited("socket: no more sockets\n");
1135 return -ENFILE;
1136
1137 }
1138
1139 sock->type = type;
1140
1141#ifdef CONFIG_MODULES
1142
1143
1144
1145
1146
1147
1148 if (rcu_access_pointer(net_families[family]) == NULL)
1149 request_module("net-pf-%d", family);
1150#endif
1151
1152 rcu_read_lock();
1153 pf = rcu_dereference(net_families[family]);
1154 err = -EAFNOSUPPORT;
1155 if (!pf)
1156 goto out_release;
1157
1158
1159
1160
1161
1162 if (!try_module_get(pf->owner))
1163 goto out_release;
1164
1165
1166 rcu_read_unlock();
1167
1168 err = pf->create(net, sock, protocol, kern);
1169 if (err < 0)
1170 goto out_module_put;
1171
1172
1173
1174
1175
1176 if (!try_module_get(sock->ops->owner))
1177 goto out_module_busy;
1178
1179
1180
1181
1182
1183 module_put(pf->owner);
1184 err = security_socket_post_create(sock, family, type, protocol, kern);
1185 if (err)
1186 goto out_sock_release;
1187 *res = sock;
1188
1189 return 0;
1190
1191out_module_busy:
1192 err = -EAFNOSUPPORT;
1193out_module_put:
1194 sock->ops = NULL;
1195 module_put(pf->owner);
1196out_sock_release:
1197 sock_release(sock);
1198 return err;
1199
1200out_release:
1201 rcu_read_unlock();
1202 goto out_sock_release;
1203}
1204EXPORT_SYMBOL(__sock_create);
1205
1206int sock_create(int family, int type, int protocol, struct socket **res)
1207{
1208 return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0);
1209}
1210EXPORT_SYMBOL(sock_create);
1211
1212int sock_create_kern(struct net *net, int family, int type, int protocol, struct socket **res)
1213{
1214 return __sock_create(net, family, type, protocol, res, 1);
1215}
1216EXPORT_SYMBOL(sock_create_kern);
1217
1218SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol)
1219{
1220 int retval;
1221 struct socket *sock;
1222 int flags;
1223
1224
1225 BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC);
1226 BUILD_BUG_ON((SOCK_MAX | SOCK_TYPE_MASK) != SOCK_TYPE_MASK);
1227 BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK);
1228 BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK);
1229
1230 flags = type & ~SOCK_TYPE_MASK;
1231 if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
1232 return -EINVAL;
1233 type &= SOCK_TYPE_MASK;
1234
1235 if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1236 flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1237
1238 retval = sock_create(family, type, protocol, &sock);
1239 if (retval < 0)
1240 goto out;
1241
1242 retval = sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK));
1243 if (retval < 0)
1244 goto out_release;
1245
1246out:
1247
1248 return retval;
1249
1250out_release:
1251 sock_release(sock);
1252 return retval;
1253}
1254
1255
1256
1257
1258
1259SYSCALL_DEFINE4(socketpair, int, family, int, type, int, protocol,
1260 int __user *, usockvec)
1261{
1262 struct socket *sock1, *sock2;
1263 int fd1, fd2, err;
1264 struct file *newfile1, *newfile2;
1265 int flags;
1266
1267 flags = type & ~SOCK_TYPE_MASK;
1268 if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
1269 return -EINVAL;
1270 type &= SOCK_TYPE_MASK;
1271
1272 if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1273 flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1274
1275
1276
1277
1278
1279
1280 err = sock_create(family, type, protocol, &sock1);
1281 if (err < 0)
1282 goto out;
1283
1284 err = sock_create(family, type, protocol, &sock2);
1285 if (err < 0)
1286 goto out_release_1;
1287
1288 err = sock1->ops->socketpair(sock1, sock2);
1289 if (err < 0)
1290 goto out_release_both;
1291
1292 fd1 = get_unused_fd_flags(flags);
1293 if (unlikely(fd1 < 0)) {
1294 err = fd1;
1295 goto out_release_both;
1296 }
1297
1298 fd2 = get_unused_fd_flags(flags);
1299 if (unlikely(fd2 < 0)) {
1300 err = fd2;
1301 goto out_put_unused_1;
1302 }
1303
1304 newfile1 = sock_alloc_file(sock1, flags, NULL);
1305 if (IS_ERR(newfile1)) {
1306 err = PTR_ERR(newfile1);
1307 goto out_put_unused_both;
1308 }
1309
1310 newfile2 = sock_alloc_file(sock2, flags, NULL);
1311 if (IS_ERR(newfile2)) {
1312 err = PTR_ERR(newfile2);
1313 goto out_fput_1;
1314 }
1315
1316 err = put_user(fd1, &usockvec[0]);
1317 if (err)
1318 goto out_fput_both;
1319
1320 err = put_user(fd2, &usockvec[1]);
1321 if (err)
1322 goto out_fput_both;
1323
1324 audit_fd_pair(fd1, fd2);
1325
1326 fd_install(fd1, newfile1);
1327 fd_install(fd2, newfile2);
1328
1329
1330
1331
1332 return 0;
1333
1334out_fput_both:
1335 fput(newfile2);
1336 fput(newfile1);
1337 put_unused_fd(fd2);
1338 put_unused_fd(fd1);
1339 goto out;
1340
1341out_fput_1:
1342 fput(newfile1);
1343 put_unused_fd(fd2);
1344 put_unused_fd(fd1);
1345 sock_release(sock2);
1346 goto out;
1347
1348out_put_unused_both:
1349 put_unused_fd(fd2);
1350out_put_unused_1:
1351 put_unused_fd(fd1);
1352out_release_both:
1353 sock_release(sock2);
1354out_release_1:
1355 sock_release(sock1);
1356out:
1357 return err;
1358}
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368SYSCALL_DEFINE3(bind, int, fd, struct sockaddr __user *, umyaddr, int, addrlen)
1369{
1370 struct socket *sock;
1371 struct sockaddr_storage address;
1372 int err, fput_needed;
1373
1374 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1375 if (sock) {
1376 err = move_addr_to_kernel(umyaddr, addrlen, &address);
1377 if (err >= 0) {
1378 err = security_socket_bind(sock,
1379 (struct sockaddr *)&address,
1380 addrlen);
1381 if (!err)
1382 err = sock->ops->bind(sock,
1383 (struct sockaddr *)
1384 &address, addrlen);
1385 }
1386 fput_light(sock->file, fput_needed);
1387 }
1388 return err;
1389}
1390
1391
1392
1393
1394
1395
1396
1397SYSCALL_DEFINE2(listen, int, fd, int, backlog)
1398{
1399 struct socket *sock;
1400 int err, fput_needed;
1401 int somaxconn;
1402
1403 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1404 if (sock) {
1405 somaxconn = sock_net(sock->sk)->core.sysctl_somaxconn;
1406 if ((unsigned int)backlog > somaxconn)
1407 backlog = somaxconn;
1408
1409 err = security_socket_listen(sock, backlog);
1410 if (!err)
1411 err = sock->ops->listen(sock, backlog);
1412
1413 fput_light(sock->file, fput_needed);
1414 }
1415 return err;
1416}
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430SYSCALL_DEFINE4(accept4, int, fd, struct sockaddr __user *, upeer_sockaddr,
1431 int __user *, upeer_addrlen, int, flags)
1432{
1433 struct socket *sock, *newsock;
1434 struct file *newfile;
1435 int err, len, newfd, fput_needed;
1436 struct sockaddr_storage address;
1437
1438 if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
1439 return -EINVAL;
1440
1441 if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1442 flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1443
1444 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1445 if (!sock)
1446 goto out;
1447
1448 err = -ENFILE;
1449 newsock = sock_alloc();
1450 if (!newsock)
1451 goto out_put;
1452
1453 newsock->type = sock->type;
1454 newsock->ops = sock->ops;
1455
1456
1457
1458
1459
1460 __module_get(newsock->ops->owner);
1461
1462 newfd = get_unused_fd_flags(flags);
1463 if (unlikely(newfd < 0)) {
1464 err = newfd;
1465 sock_release(newsock);
1466 goto out_put;
1467 }
1468 newfile = sock_alloc_file(newsock, flags, sock->sk->sk_prot_creator->name);
1469 if (IS_ERR(newfile)) {
1470 err = PTR_ERR(newfile);
1471 put_unused_fd(newfd);
1472 sock_release(newsock);
1473 goto out_put;
1474 }
1475
1476 err = security_socket_accept(sock, newsock);
1477 if (err)
1478 goto out_fd;
1479
1480 err = sock->ops->accept(sock, newsock, sock->file->f_flags);
1481 if (err < 0)
1482 goto out_fd;
1483
1484 if (upeer_sockaddr) {
1485 if (newsock->ops->getname(newsock, (struct sockaddr *)&address,
1486 &len, 2) < 0) {
1487 err = -ECONNABORTED;
1488 goto out_fd;
1489 }
1490 err = move_addr_to_user(&address,
1491 len, upeer_sockaddr, upeer_addrlen);
1492 if (err < 0)
1493 goto out_fd;
1494 }
1495
1496
1497
1498 fd_install(newfd, newfile);
1499 err = newfd;
1500
1501out_put:
1502 fput_light(sock->file, fput_needed);
1503out:
1504 return err;
1505out_fd:
1506 fput(newfile);
1507 put_unused_fd(newfd);
1508 goto out_put;
1509}
1510
1511SYSCALL_DEFINE3(accept, int, fd, struct sockaddr __user *, upeer_sockaddr,
1512 int __user *, upeer_addrlen)
1513{
1514 return sys_accept4(fd, upeer_sockaddr, upeer_addrlen, 0);
1515}
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529SYSCALL_DEFINE3(connect, int, fd, struct sockaddr __user *, uservaddr,
1530 int, addrlen)
1531{
1532 struct socket *sock;
1533 struct sockaddr_storage address;
1534 int err, fput_needed;
1535
1536 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1537 if (!sock)
1538 goto out;
1539 err = move_addr_to_kernel(uservaddr, addrlen, &address);
1540 if (err < 0)
1541 goto out_put;
1542
1543 err =
1544 security_socket_connect(sock, (struct sockaddr *)&address, addrlen);
1545 if (err)
1546 goto out_put;
1547
1548 err = sock->ops->connect(sock, (struct sockaddr *)&address, addrlen,
1549 sock->file->f_flags);
1550out_put:
1551 fput_light(sock->file, fput_needed);
1552out:
1553 return err;
1554}
1555
1556
1557
1558
1559
1560
1561SYSCALL_DEFINE3(getsockname, int, fd, struct sockaddr __user *, usockaddr,
1562 int __user *, usockaddr_len)
1563{
1564 struct socket *sock;
1565 struct sockaddr_storage address;
1566 int len, err, fput_needed;
1567
1568 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1569 if (!sock)
1570 goto out;
1571
1572 err = security_socket_getsockname(sock);
1573 if (err)
1574 goto out_put;
1575
1576 err = sock->ops->getname(sock, (struct sockaddr *)&address, &len, 0);
1577 if (err)
1578 goto out_put;
1579 err = move_addr_to_user(&address, len, usockaddr, usockaddr_len);
1580
1581out_put:
1582 fput_light(sock->file, fput_needed);
1583out:
1584 return err;
1585}
1586
1587
1588
1589
1590
1591
1592SYSCALL_DEFINE3(getpeername, int, fd, struct sockaddr __user *, usockaddr,
1593 int __user *, usockaddr_len)
1594{
1595 struct socket *sock;
1596 struct sockaddr_storage address;
1597 int len, err, fput_needed;
1598
1599 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1600 if (sock != NULL) {
1601 err = security_socket_getpeername(sock);
1602 if (err) {
1603 fput_light(sock->file, fput_needed);
1604 return err;
1605 }
1606
1607 err =
1608 sock->ops->getname(sock, (struct sockaddr *)&address, &len,
1609 1);
1610 if (!err)
1611 err = move_addr_to_user(&address, len, usockaddr,
1612 usockaddr_len);
1613 fput_light(sock->file, fput_needed);
1614 }
1615 return err;
1616}
1617
1618
1619
1620
1621
1622
1623
1624SYSCALL_DEFINE6(sendto, int, fd, void __user *, buff, size_t, len,
1625 unsigned int, flags, struct sockaddr __user *, addr,
1626 int, addr_len)
1627{
1628 struct socket *sock;
1629 struct sockaddr_storage address;
1630 int err;
1631 struct msghdr msg;
1632 struct iovec iov;
1633 int fput_needed;
1634
1635 err = import_single_range(WRITE, buff, len, &iov, &msg.msg_iter);
1636 if (unlikely(err))
1637 return err;
1638 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1639 if (!sock)
1640 goto out;
1641
1642 msg.msg_name = NULL;
1643 msg.msg_control = NULL;
1644 msg.msg_controllen = 0;
1645 msg.msg_namelen = 0;
1646 if (addr) {
1647 err = move_addr_to_kernel(addr, addr_len, &address);
1648 if (err < 0)
1649 goto out_put;
1650 msg.msg_name = (struct sockaddr *)&address;
1651 msg.msg_namelen = addr_len;
1652 }
1653 if (sock->file->f_flags & O_NONBLOCK)
1654 flags |= MSG_DONTWAIT;
1655 msg.msg_flags = flags;
1656 err = sock_sendmsg(sock, &msg);
1657
1658out_put:
1659 fput_light(sock->file, fput_needed);
1660out:
1661 return err;
1662}
1663
1664
1665
1666
1667
1668SYSCALL_DEFINE4(send, int, fd, void __user *, buff, size_t, len,
1669 unsigned int, flags)
1670{
1671 return sys_sendto(fd, buff, len, flags, NULL, 0);
1672}
1673
1674
1675
1676
1677
1678
1679
1680SYSCALL_DEFINE6(recvfrom, int, fd, void __user *, ubuf, size_t, size,
1681 unsigned int, flags, struct sockaddr __user *, addr,
1682 int __user *, addr_len)
1683{
1684 struct socket *sock;
1685 struct iovec iov;
1686 struct msghdr msg;
1687 struct sockaddr_storage address;
1688 int err, err2;
1689 int fput_needed;
1690
1691 err = import_single_range(READ, ubuf, size, &iov, &msg.msg_iter);
1692 if (unlikely(err))
1693 return err;
1694 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1695 if (!sock)
1696 goto out;
1697
1698 msg.msg_control = NULL;
1699 msg.msg_controllen = 0;
1700
1701 msg.msg_name = addr ? (struct sockaddr *)&address : NULL;
1702
1703 msg.msg_namelen = 0;
1704 msg.msg_iocb = NULL;
1705 if (sock->file->f_flags & O_NONBLOCK)
1706 flags |= MSG_DONTWAIT;
1707 err = sock_recvmsg(sock, &msg, flags);
1708
1709 if (err >= 0 && addr != NULL) {
1710 err2 = move_addr_to_user(&address,
1711 msg.msg_namelen, addr, addr_len);
1712 if (err2 < 0)
1713 err = err2;
1714 }
1715
1716 fput_light(sock->file, fput_needed);
1717out:
1718 return err;
1719}
1720
1721
1722
1723
1724
1725SYSCALL_DEFINE4(recv, int, fd, void __user *, ubuf, size_t, size,
1726 unsigned int, flags)
1727{
1728 return sys_recvfrom(fd, ubuf, size, flags, NULL, NULL);
1729}
1730
1731
1732
1733
1734
1735
1736SYSCALL_DEFINE5(setsockopt, int, fd, int, level, int, optname,
1737 char __user *, optval, int, optlen)
1738{
1739 int err, fput_needed;
1740 struct socket *sock;
1741
1742 if (optlen < 0)
1743 return -EINVAL;
1744
1745 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1746 if (sock != NULL) {
1747 err = security_socket_setsockopt(sock, level, optname);
1748 if (err)
1749 goto out_put;
1750
1751 if (level == SOL_SOCKET)
1752 err =
1753 sock_setsockopt(sock, level, optname, optval,
1754 optlen);
1755 else
1756 err =
1757 sock->ops->setsockopt(sock, level, optname, optval,
1758 optlen);
1759out_put:
1760 fput_light(sock->file, fput_needed);
1761 }
1762 return err;
1763}
1764
1765
1766
1767
1768
1769
1770SYSCALL_DEFINE5(getsockopt, int, fd, int, level, int, optname,
1771 char __user *, optval, int __user *, optlen)
1772{
1773 int err, fput_needed;
1774 struct socket *sock;
1775
1776 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1777 if (sock != NULL) {
1778 err = security_socket_getsockopt(sock, level, optname);
1779 if (err)
1780 goto out_put;
1781
1782 if (level == SOL_SOCKET)
1783 err =
1784 sock_getsockopt(sock, level, optname, optval,
1785 optlen);
1786 else
1787 err =
1788 sock->ops->getsockopt(sock, level, optname, optval,
1789 optlen);
1790out_put:
1791 fput_light(sock->file, fput_needed);
1792 }
1793 return err;
1794}
1795
1796
1797
1798
1799
1800SYSCALL_DEFINE2(shutdown, int, fd, int, how)
1801{
1802 int err, fput_needed;
1803 struct socket *sock;
1804
1805 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1806 if (sock != NULL) {
1807 err = security_socket_shutdown(sock, how);
1808 if (!err)
1809 err = sock->ops->shutdown(sock, how);
1810 fput_light(sock->file, fput_needed);
1811 }
1812 return err;
1813}
1814
1815
1816
1817
1818#define COMPAT_MSG(msg, member) ((MSG_CMSG_COMPAT & flags) ? &msg##_compat->member : &msg->member)
1819#define COMPAT_NAMELEN(msg) COMPAT_MSG(msg, msg_namelen)
1820#define COMPAT_FLAGS(msg) COMPAT_MSG(msg, msg_flags)
1821
1822struct used_address {
1823 struct sockaddr_storage name;
1824 unsigned int name_len;
1825};
1826
1827static int copy_msghdr_from_user(struct msghdr *kmsg,
1828 struct user_msghdr __user *umsg,
1829 struct sockaddr __user **save_addr,
1830 struct iovec **iov)
1831{
1832 struct sockaddr __user *uaddr;
1833 struct iovec __user *uiov;
1834 size_t nr_segs;
1835 ssize_t err;
1836
1837 if (!access_ok(VERIFY_READ, umsg, sizeof(*umsg)) ||
1838 __get_user(uaddr, &umsg->msg_name) ||
1839 __get_user(kmsg->msg_namelen, &umsg->msg_namelen) ||
1840 __get_user(uiov, &umsg->msg_iov) ||
1841 __get_user(nr_segs, &umsg->msg_iovlen) ||
1842 __get_user(kmsg->msg_control, &umsg->msg_control) ||
1843 __get_user(kmsg->msg_controllen, &umsg->msg_controllen) ||
1844 __get_user(kmsg->msg_flags, &umsg->msg_flags))
1845 return -EFAULT;
1846
1847 if (!uaddr)
1848 kmsg->msg_namelen = 0;
1849
1850 if (kmsg->msg_namelen < 0)
1851 return -EINVAL;
1852
1853 if (kmsg->msg_namelen > sizeof(struct sockaddr_storage))
1854 kmsg->msg_namelen = sizeof(struct sockaddr_storage);
1855
1856 if (save_addr)
1857 *save_addr = uaddr;
1858
1859 if (uaddr && kmsg->msg_namelen) {
1860 if (!save_addr) {
1861 err = move_addr_to_kernel(uaddr, kmsg->msg_namelen,
1862 kmsg->msg_name);
1863 if (err < 0)
1864 return err;
1865 }
1866 } else {
1867 kmsg->msg_name = NULL;
1868 kmsg->msg_namelen = 0;
1869 }
1870
1871 if (nr_segs > UIO_MAXIOV)
1872 return -EMSGSIZE;
1873
1874 kmsg->msg_iocb = NULL;
1875
1876 return import_iovec(save_addr ? READ : WRITE, uiov, nr_segs,
1877 UIO_FASTIOV, iov, &kmsg->msg_iter);
1878}
1879
1880static int ___sys_sendmsg(struct socket *sock, struct user_msghdr __user *msg,
1881 struct msghdr *msg_sys, unsigned int flags,
1882 struct used_address *used_address,
1883 unsigned int allowed_msghdr_flags)
1884{
1885 struct compat_msghdr __user *msg_compat =
1886 (struct compat_msghdr __user *)msg;
1887 struct sockaddr_storage address;
1888 struct iovec iovstack[UIO_FASTIOV], *iov = iovstack;
1889 unsigned char ctl[sizeof(struct cmsghdr) + 20]
1890 __attribute__ ((aligned(sizeof(__kernel_size_t))));
1891
1892 unsigned char *ctl_buf = ctl;
1893 int ctl_len;
1894 ssize_t err;
1895
1896 msg_sys->msg_name = &address;
1897
1898 if (MSG_CMSG_COMPAT & flags)
1899 err = get_compat_msghdr(msg_sys, msg_compat, NULL, &iov);
1900 else
1901 err = copy_msghdr_from_user(msg_sys, msg, NULL, &iov);
1902 if (err < 0)
1903 return err;
1904
1905 err = -ENOBUFS;
1906
1907 if (msg_sys->msg_controllen > INT_MAX)
1908 goto out_freeiov;
1909 flags |= (msg_sys->msg_flags & allowed_msghdr_flags);
1910 ctl_len = msg_sys->msg_controllen;
1911 if ((MSG_CMSG_COMPAT & flags) && ctl_len) {
1912 err =
1913 cmsghdr_from_user_compat_to_kern(msg_sys, sock->sk, ctl,
1914 sizeof(ctl));
1915 if (err)
1916 goto out_freeiov;
1917 ctl_buf = msg_sys->msg_control;
1918 ctl_len = msg_sys->msg_controllen;
1919 } else if (ctl_len) {
1920 if (ctl_len > sizeof(ctl)) {
1921 ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL);
1922 if (ctl_buf == NULL)
1923 goto out_freeiov;
1924 }
1925 err = -EFAULT;
1926
1927
1928
1929
1930
1931 if (copy_from_user(ctl_buf,
1932 (void __user __force *)msg_sys->msg_control,
1933 ctl_len))
1934 goto out_freectl;
1935 msg_sys->msg_control = ctl_buf;
1936 }
1937 msg_sys->msg_flags = flags;
1938
1939 if (sock->file->f_flags & O_NONBLOCK)
1940 msg_sys->msg_flags |= MSG_DONTWAIT;
1941
1942
1943
1944
1945
1946
1947 if (used_address && msg_sys->msg_name &&
1948 used_address->name_len == msg_sys->msg_namelen &&
1949 !memcmp(&used_address->name, msg_sys->msg_name,
1950 used_address->name_len)) {
1951 err = sock_sendmsg_nosec(sock, msg_sys);
1952 goto out_freectl;
1953 }
1954 err = sock_sendmsg(sock, msg_sys);
1955
1956
1957
1958
1959 if (used_address && err >= 0) {
1960 used_address->name_len = msg_sys->msg_namelen;
1961 if (msg_sys->msg_name)
1962 memcpy(&used_address->name, msg_sys->msg_name,
1963 used_address->name_len);
1964 }
1965
1966out_freectl:
1967 if (ctl_buf != ctl)
1968 sock_kfree_s(sock->sk, ctl_buf, ctl_len);
1969out_freeiov:
1970 kfree(iov);
1971 return err;
1972}
1973
1974
1975
1976
1977
1978long __sys_sendmsg(int fd, struct user_msghdr __user *msg, unsigned flags)
1979{
1980 int fput_needed, err;
1981 struct msghdr msg_sys;
1982 struct socket *sock;
1983
1984 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1985 if (!sock)
1986 goto out;
1987
1988 err = ___sys_sendmsg(sock, msg, &msg_sys, flags, NULL, 0);
1989
1990 fput_light(sock->file, fput_needed);
1991out:
1992 return err;
1993}
1994
1995SYSCALL_DEFINE3(sendmsg, int, fd, struct user_msghdr __user *, msg, unsigned int, flags)
1996{
1997 if (flags & MSG_CMSG_COMPAT)
1998 return -EINVAL;
1999 return __sys_sendmsg(fd, msg, flags);
2000}
2001
2002
2003
2004
2005
2006int __sys_sendmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen,
2007 unsigned int flags)
2008{
2009 int fput_needed, err, datagrams;
2010 struct socket *sock;
2011 struct mmsghdr __user *entry;
2012 struct compat_mmsghdr __user *compat_entry;
2013 struct msghdr msg_sys;
2014 struct used_address used_address;
2015 unsigned int oflags = flags;
2016
2017 if (vlen > UIO_MAXIOV)
2018 vlen = UIO_MAXIOV;
2019
2020 datagrams = 0;
2021
2022 sock = sockfd_lookup_light(fd, &err, &fput_needed);
2023 if (!sock)
2024 return err;
2025
2026 used_address.name_len = UINT_MAX;
2027 entry = mmsg;
2028 compat_entry = (struct compat_mmsghdr __user *)mmsg;
2029 err = 0;
2030 flags |= MSG_BATCH;
2031
2032 while (datagrams < vlen) {
2033 if (datagrams == vlen - 1)
2034 flags = oflags;
2035
2036 if (MSG_CMSG_COMPAT & flags) {
2037 err = ___sys_sendmsg(sock, (struct user_msghdr __user *)compat_entry,
2038 &msg_sys, flags, &used_address, MSG_EOR);
2039 if (err < 0)
2040 break;
2041 err = __put_user(err, &compat_entry->msg_len);
2042 ++compat_entry;
2043 } else {
2044 err = ___sys_sendmsg(sock,
2045 (struct user_msghdr __user *)entry,
2046 &msg_sys, flags, &used_address, MSG_EOR);
2047 if (err < 0)
2048 break;
2049 err = put_user(err, &entry->msg_len);
2050 ++entry;
2051 }
2052
2053 if (err)
2054 break;
2055 ++datagrams;
2056 if (msg_data_left(&msg_sys))
2057 break;
2058 cond_resched();
2059 }
2060
2061 fput_light(sock->file, fput_needed);
2062
2063
2064 if (datagrams != 0)
2065 return datagrams;
2066
2067 return err;
2068}
2069
2070SYSCALL_DEFINE4(sendmmsg, int, fd, struct mmsghdr __user *, mmsg,
2071 unsigned int, vlen, unsigned int, flags)
2072{
2073 if (flags & MSG_CMSG_COMPAT)
2074 return -EINVAL;
2075 return __sys_sendmmsg(fd, mmsg, vlen, flags);
2076}
2077
2078static int ___sys_recvmsg(struct socket *sock, struct user_msghdr __user *msg,
2079 struct msghdr *msg_sys, unsigned int flags, int nosec)
2080{
2081 struct compat_msghdr __user *msg_compat =
2082 (struct compat_msghdr __user *)msg;
2083 struct iovec iovstack[UIO_FASTIOV];
2084 struct iovec *iov = iovstack;
2085 unsigned long cmsg_ptr;
2086 int len;
2087 ssize_t err;
2088
2089
2090 struct sockaddr_storage addr;
2091
2092
2093 struct sockaddr __user *uaddr;
2094 int __user *uaddr_len = COMPAT_NAMELEN(msg);
2095
2096 msg_sys->msg_name = &addr;
2097
2098 if (MSG_CMSG_COMPAT & flags)
2099 err = get_compat_msghdr(msg_sys, msg_compat, &uaddr, &iov);
2100 else
2101 err = copy_msghdr_from_user(msg_sys, msg, &uaddr, &iov);
2102 if (err < 0)
2103 return err;
2104
2105 cmsg_ptr = (unsigned long)msg_sys->msg_control;
2106 msg_sys->msg_flags = flags & (MSG_CMSG_CLOEXEC|MSG_CMSG_COMPAT);
2107
2108
2109 msg_sys->msg_namelen = 0;
2110
2111 if (sock->file->f_flags & O_NONBLOCK)
2112 flags |= MSG_DONTWAIT;
2113 err = (nosec ? sock_recvmsg_nosec : sock_recvmsg)(sock, msg_sys, flags);
2114 if (err < 0)
2115 goto out_freeiov;
2116 len = err;
2117
2118 if (uaddr != NULL) {
2119 err = move_addr_to_user(&addr,
2120 msg_sys->msg_namelen, uaddr,
2121 uaddr_len);
2122 if (err < 0)
2123 goto out_freeiov;
2124 }
2125 err = __put_user((msg_sys->msg_flags & ~MSG_CMSG_COMPAT),
2126 COMPAT_FLAGS(msg));
2127 if (err)
2128 goto out_freeiov;
2129 if (MSG_CMSG_COMPAT & flags)
2130 err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr,
2131 &msg_compat->msg_controllen);
2132 else
2133 err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr,
2134 &msg->msg_controllen);
2135 if (err)
2136 goto out_freeiov;
2137 err = len;
2138
2139out_freeiov:
2140 kfree(iov);
2141 return err;
2142}
2143
2144
2145
2146
2147
2148long __sys_recvmsg(int fd, struct user_msghdr __user *msg, unsigned flags)
2149{
2150 int fput_needed, err;
2151 struct msghdr msg_sys;
2152 struct socket *sock;
2153
2154 sock = sockfd_lookup_light(fd, &err, &fput_needed);
2155 if (!sock)
2156 goto out;
2157
2158 err = ___sys_recvmsg(sock, msg, &msg_sys, flags, 0);
2159
2160 fput_light(sock->file, fput_needed);
2161out:
2162 return err;
2163}
2164
2165SYSCALL_DEFINE3(recvmsg, int, fd, struct user_msghdr __user *, msg,
2166 unsigned int, flags)
2167{
2168 if (flags & MSG_CMSG_COMPAT)
2169 return -EINVAL;
2170 return __sys_recvmsg(fd, msg, flags);
2171}
2172
2173
2174
2175
2176
2177int __sys_recvmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen,
2178 unsigned int flags, struct timespec *timeout)
2179{
2180 int fput_needed, err, datagrams;
2181 struct socket *sock;
2182 struct mmsghdr __user *entry;
2183 struct compat_mmsghdr __user *compat_entry;
2184 struct msghdr msg_sys;
2185 struct timespec64 end_time;
2186 struct timespec64 timeout64;
2187
2188 if (timeout &&
2189 poll_select_set_timeout(&end_time, timeout->tv_sec,
2190 timeout->tv_nsec))
2191 return -EINVAL;
2192
2193 datagrams = 0;
2194
2195 sock = sockfd_lookup_light(fd, &err, &fput_needed);
2196 if (!sock)
2197 return err;
2198
2199 err = sock_error(sock->sk);
2200 if (err)
2201 goto out_put;
2202
2203 entry = mmsg;
2204 compat_entry = (struct compat_mmsghdr __user *)mmsg;
2205
2206 while (datagrams < vlen) {
2207
2208
2209
2210 if (MSG_CMSG_COMPAT & flags) {
2211 err = ___sys_recvmsg(sock, (struct user_msghdr __user *)compat_entry,
2212 &msg_sys, flags & ~MSG_WAITFORONE,
2213 datagrams);
2214 if (err < 0)
2215 break;
2216 err = __put_user(err, &compat_entry->msg_len);
2217 ++compat_entry;
2218 } else {
2219 err = ___sys_recvmsg(sock,
2220 (struct user_msghdr __user *)entry,
2221 &msg_sys, flags & ~MSG_WAITFORONE,
2222 datagrams);
2223 if (err < 0)
2224 break;
2225 err = put_user(err, &entry->msg_len);
2226 ++entry;
2227 }
2228
2229 if (err)
2230 break;
2231 ++datagrams;
2232
2233
2234 if (flags & MSG_WAITFORONE)
2235 flags |= MSG_DONTWAIT;
2236
2237 if (timeout) {
2238 ktime_get_ts64(&timeout64);
2239 *timeout = timespec64_to_timespec(
2240 timespec64_sub(end_time, timeout64));
2241 if (timeout->tv_sec < 0) {
2242 timeout->tv_sec = timeout->tv_nsec = 0;
2243 break;
2244 }
2245
2246
2247 if (timeout->tv_nsec == 0 && timeout->tv_sec == 0)
2248 break;
2249 }
2250
2251
2252 if (msg_sys.msg_flags & MSG_OOB)
2253 break;
2254 cond_resched();
2255 }
2256
2257 if (err == 0)
2258 goto out_put;
2259
2260 if (datagrams == 0) {
2261 datagrams = err;
2262 goto out_put;
2263 }
2264
2265
2266
2267
2268
2269 if (err != -EAGAIN) {
2270
2271
2272
2273
2274
2275
2276 sock->sk->sk_err = -err;
2277 }
2278out_put:
2279 fput_light(sock->file, fput_needed);
2280
2281 return datagrams;
2282}
2283
2284SYSCALL_DEFINE5(recvmmsg, int, fd, struct mmsghdr __user *, mmsg,
2285 unsigned int, vlen, unsigned int, flags,
2286 struct timespec __user *, timeout)
2287{
2288 int datagrams;
2289 struct timespec timeout_sys;
2290
2291 if (flags & MSG_CMSG_COMPAT)
2292 return -EINVAL;
2293
2294 if (!timeout)
2295 return __sys_recvmmsg(fd, mmsg, vlen, flags, NULL);
2296
2297 if (copy_from_user(&timeout_sys, timeout, sizeof(timeout_sys)))
2298 return -EFAULT;
2299
2300 datagrams = __sys_recvmmsg(fd, mmsg, vlen, flags, &timeout_sys);
2301
2302 if (datagrams > 0 &&
2303 copy_to_user(timeout, &timeout_sys, sizeof(timeout_sys)))
2304 datagrams = -EFAULT;
2305
2306 return datagrams;
2307}
2308
2309#ifdef __ARCH_WANT_SYS_SOCKETCALL
2310
2311#define AL(x) ((x) * sizeof(unsigned long))
2312static const unsigned char nargs[21] = {
2313 AL(0), AL(3), AL(3), AL(3), AL(2), AL(3),
2314 AL(3), AL(3), AL(4), AL(4), AL(4), AL(6),
2315 AL(6), AL(2), AL(5), AL(5), AL(3), AL(3),
2316 AL(4), AL(5), AL(4)
2317};
2318
2319#undef AL
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329SYSCALL_DEFINE2(socketcall, int, call, unsigned long __user *, args)
2330{
2331 unsigned long a[AUDITSC_ARGS];
2332 unsigned long a0, a1;
2333 int err;
2334 unsigned int len;
2335
2336 if (call < 1 || call > SYS_SENDMMSG)
2337 return -EINVAL;
2338
2339 len = nargs[call];
2340 if (len > sizeof(a))
2341 return -EINVAL;
2342
2343
2344 if (copy_from_user(a, args, len))
2345 return -EFAULT;
2346
2347 err = audit_socketcall(nargs[call] / sizeof(unsigned long), a);
2348 if (err)
2349 return err;
2350
2351 a0 = a[0];
2352 a1 = a[1];
2353
2354 switch (call) {
2355 case SYS_SOCKET:
2356 err = sys_socket(a0, a1, a[2]);
2357 break;
2358 case SYS_BIND:
2359 err = sys_bind(a0, (struct sockaddr __user *)a1, a[2]);
2360 break;
2361 case SYS_CONNECT:
2362 err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]);
2363 break;
2364 case SYS_LISTEN:
2365 err = sys_listen(a0, a1);
2366 break;
2367 case SYS_ACCEPT:
2368 err = sys_accept4(a0, (struct sockaddr __user *)a1,
2369 (int __user *)a[2], 0);
2370 break;
2371 case SYS_GETSOCKNAME:
2372 err =
2373 sys_getsockname(a0, (struct sockaddr __user *)a1,
2374 (int __user *)a[2]);
2375 break;
2376 case SYS_GETPEERNAME:
2377 err =
2378 sys_getpeername(a0, (struct sockaddr __user *)a1,
2379 (int __user *)a[2]);
2380 break;
2381 case SYS_SOCKETPAIR:
2382 err = sys_socketpair(a0, a1, a[2], (int __user *)a[3]);
2383 break;
2384 case SYS_SEND:
2385 err = sys_send(a0, (void __user *)a1, a[2], a[3]);
2386 break;
2387 case SYS_SENDTO:
2388 err = sys_sendto(a0, (void __user *)a1, a[2], a[3],
2389 (struct sockaddr __user *)a[4], a[5]);
2390 break;
2391 case SYS_RECV:
2392 err = sys_recv(a0, (void __user *)a1, a[2], a[3]);
2393 break;
2394 case SYS_RECVFROM:
2395 err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3],
2396 (struct sockaddr __user *)a[4],
2397 (int __user *)a[5]);
2398 break;
2399 case SYS_SHUTDOWN:
2400 err = sys_shutdown(a0, a1);
2401 break;
2402 case SYS_SETSOCKOPT:
2403 err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]);
2404 break;
2405 case SYS_GETSOCKOPT:
2406 err =
2407 sys_getsockopt(a0, a1, a[2], (char __user *)a[3],
2408 (int __user *)a[4]);
2409 break;
2410 case SYS_SENDMSG:
2411 err = sys_sendmsg(a0, (struct user_msghdr __user *)a1, a[2]);
2412 break;
2413 case SYS_SENDMMSG:
2414 err = sys_sendmmsg(a0, (struct mmsghdr __user *)a1, a[2], a[3]);
2415 break;
2416 case SYS_RECVMSG:
2417 err = sys_recvmsg(a0, (struct user_msghdr __user *)a1, a[2]);
2418 break;
2419 case SYS_RECVMMSG:
2420 err = sys_recvmmsg(a0, (struct mmsghdr __user *)a1, a[2], a[3],
2421 (struct timespec __user *)a[4]);
2422 break;
2423 case SYS_ACCEPT4:
2424 err = sys_accept4(a0, (struct sockaddr __user *)a1,
2425 (int __user *)a[2], a[3]);
2426 break;
2427 default:
2428 err = -EINVAL;
2429 break;
2430 }
2431 return err;
2432}
2433
2434#endif
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444
2445int sock_register(const struct net_proto_family *ops)
2446{
2447 int err;
2448
2449 if (ops->family >= NPROTO) {
2450 pr_crit("protocol %d >= NPROTO(%d)\n", ops->family, NPROTO);
2451 return -ENOBUFS;
2452 }
2453
2454 spin_lock(&net_family_lock);
2455 if (rcu_dereference_protected(net_families[ops->family],
2456 lockdep_is_held(&net_family_lock)))
2457 err = -EEXIST;
2458 else {
2459 rcu_assign_pointer(net_families[ops->family], ops);
2460 err = 0;
2461 }
2462 spin_unlock(&net_family_lock);
2463
2464 pr_info("NET: Registered protocol family %d\n", ops->family);
2465 return err;
2466}
2467EXPORT_SYMBOL(sock_register);
2468
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482void sock_unregister(int family)
2483{
2484 BUG_ON(family < 0 || family >= NPROTO);
2485
2486 spin_lock(&net_family_lock);
2487 RCU_INIT_POINTER(net_families[family], NULL);
2488 spin_unlock(&net_family_lock);
2489
2490 synchronize_rcu();
2491
2492 pr_info("NET: Unregistered protocol family %d\n", family);
2493}
2494EXPORT_SYMBOL(sock_unregister);
2495
2496static int __init sock_init(void)
2497{
2498 int err;
2499
2500
2501
2502 err = net_sysctl_init();
2503 if (err)
2504 goto out;
2505
2506
2507
2508
2509 skb_init();
2510
2511
2512
2513
2514
2515 init_inodecache();
2516
2517 err = register_filesystem(&sock_fs_type);
2518 if (err)
2519 goto out_fs;
2520 sock_mnt = kern_mount(&sock_fs_type);
2521 if (IS_ERR(sock_mnt)) {
2522 err = PTR_ERR(sock_mnt);
2523 goto out_mount;
2524 }
2525
2526
2527
2528
2529#ifdef CONFIG_NETFILTER
2530 err = netfilter_init();
2531 if (err)
2532 goto out;
2533#endif
2534
2535 ptp_classifier_init();
2536
2537out:
2538 return err;
2539
2540out_mount:
2541 unregister_filesystem(&sock_fs_type);
2542out_fs:
2543 goto out;
2544}
2545
2546core_initcall(sock_init);
2547
2548#ifdef CONFIG_PROC_FS
2549void socket_seq_show(struct seq_file *seq)
2550{
2551 int cpu;
2552 int counter = 0;
2553
2554 for_each_possible_cpu(cpu)
2555 counter += per_cpu(sockets_in_use, cpu);
2556
2557
2558 if (counter < 0)
2559 counter = 0;
2560
2561 seq_printf(seq, "sockets: used %d\n", counter);
2562}
2563#endif
2564
2565#ifdef CONFIG_COMPAT
2566static int do_siocgstamp(struct net *net, struct socket *sock,
2567 unsigned int cmd, void __user *up)
2568{
2569 mm_segment_t old_fs = get_fs();
2570 struct timeval ktv;
2571 int err;
2572
2573 set_fs(KERNEL_DS);
2574 err = sock_do_ioctl(net, sock, cmd, (unsigned long)&ktv);
2575 set_fs(old_fs);
2576 if (!err)
2577 err = compat_put_timeval(&ktv, up);
2578
2579 return err;
2580}
2581
2582static int do_siocgstampns(struct net *net, struct socket *sock,
2583 unsigned int cmd, void __user *up)
2584{
2585 mm_segment_t old_fs = get_fs();
2586 struct timespec kts;
2587 int err;
2588
2589 set_fs(KERNEL_DS);
2590 err = sock_do_ioctl(net, sock, cmd, (unsigned long)&kts);
2591 set_fs(old_fs);
2592 if (!err)
2593 err = compat_put_timespec(&kts, up);
2594
2595 return err;
2596}
2597
2598static int dev_ifname32(struct net *net, struct compat_ifreq __user *uifr32)
2599{
2600 struct ifreq __user *uifr;
2601 int err;
2602
2603 uifr = compat_alloc_user_space(sizeof(struct ifreq));
2604 if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq)))
2605 return -EFAULT;
2606
2607 err = dev_ioctl(net, SIOCGIFNAME, uifr);
2608 if (err)
2609 return err;
2610
2611 if (copy_in_user(uifr32, uifr, sizeof(struct compat_ifreq)))
2612 return -EFAULT;
2613
2614 return 0;
2615}
2616
2617static int dev_ifconf(struct net *net, struct compat_ifconf __user *uifc32)
2618{
2619 struct compat_ifconf ifc32;
2620 struct ifconf ifc;
2621 struct ifconf __user *uifc;
2622 struct compat_ifreq __user *ifr32;
2623 struct ifreq __user *ifr;
2624 unsigned int i, j;
2625 int err;
2626
2627 if (copy_from_user(&ifc32, uifc32, sizeof(struct compat_ifconf)))
2628 return -EFAULT;
2629
2630 memset(&ifc, 0, sizeof(ifc));
2631 if (ifc32.ifcbuf == 0) {
2632 ifc32.ifc_len = 0;
2633 ifc.ifc_len = 0;
2634 ifc.ifc_req = NULL;
2635 uifc = compat_alloc_user_space(sizeof(struct ifconf));
2636 } else {
2637 size_t len = ((ifc32.ifc_len / sizeof(struct compat_ifreq)) + 1) *
2638 sizeof(struct ifreq);
2639 uifc = compat_alloc_user_space(sizeof(struct ifconf) + len);
2640 ifc.ifc_len = len;
2641 ifr = ifc.ifc_req = (void __user *)(uifc + 1);
2642 ifr32 = compat_ptr(ifc32.ifcbuf);
2643 for (i = 0; i < ifc32.ifc_len; i += sizeof(struct compat_ifreq)) {
2644 if (copy_in_user(ifr, ifr32, sizeof(struct compat_ifreq)))
2645 return -EFAULT;
2646 ifr++;
2647 ifr32++;
2648 }
2649 }
2650 if (copy_to_user(uifc, &ifc, sizeof(struct ifconf)))
2651 return -EFAULT;
2652
2653 err = dev_ioctl(net, SIOCGIFCONF, uifc);
2654 if (err)
2655 return err;
2656
2657 if (copy_from_user(&ifc, uifc, sizeof(struct ifconf)))
2658 return -EFAULT;
2659
2660 ifr = ifc.ifc_req;
2661 ifr32 = compat_ptr(ifc32.ifcbuf);
2662 for (i = 0, j = 0;
2663 i + sizeof(struct compat_ifreq) <= ifc32.ifc_len && j < ifc.ifc_len;
2664 i += sizeof(struct compat_ifreq), j += sizeof(struct ifreq)) {
2665 if (copy_in_user(ifr32, ifr, sizeof(struct compat_ifreq)))
2666 return -EFAULT;
2667 ifr32++;
2668 ifr++;
2669 }
2670
2671 if (ifc32.ifcbuf == 0) {
2672
2673
2674
2675 i = ifc.ifc_len;
2676 i = ((i / sizeof(struct ifreq)) * sizeof(struct compat_ifreq));
2677 ifc32.ifc_len = i;
2678 } else {
2679 ifc32.ifc_len = i;
2680 }
2681 if (copy_to_user(uifc32, &ifc32, sizeof(struct compat_ifconf)))
2682 return -EFAULT;
2683
2684 return 0;
2685}
2686
2687static int ethtool_ioctl(struct net *net, struct compat_ifreq __user *ifr32)
2688{
2689 struct compat_ethtool_rxnfc __user *compat_rxnfc;
2690 bool convert_in = false, convert_out = false;
2691 size_t buf_size = ALIGN(sizeof(struct ifreq), 8);
2692 struct ethtool_rxnfc __user *rxnfc;
2693 struct ifreq __user *ifr;
2694 u32 rule_cnt = 0, actual_rule_cnt;
2695 u32 ethcmd;
2696 u32 data;
2697 int ret;
2698
2699 if (get_user(data, &ifr32->ifr_ifru.ifru_data))
2700 return -EFAULT;
2701
2702 compat_rxnfc = compat_ptr(data);
2703
2704 if (get_user(ethcmd, &compat_rxnfc->cmd))
2705 return -EFAULT;
2706
2707
2708
2709
2710 switch (ethcmd) {
2711 default:
2712 break;
2713 case ETHTOOL_GRXCLSRLALL:
2714
2715 if (get_user(rule_cnt, &compat_rxnfc->rule_cnt))
2716 return -EFAULT;
2717 if (rule_cnt > KMALLOC_MAX_SIZE / sizeof(u32))
2718 return -ENOMEM;
2719 buf_size += rule_cnt * sizeof(u32);
2720
2721 case ETHTOOL_GRXRINGS:
2722 case ETHTOOL_GRXCLSRLCNT:
2723 case ETHTOOL_GRXCLSRULE:
2724 case ETHTOOL_SRXCLSRLINS:
2725 convert_out = true;
2726
2727 case ETHTOOL_SRXCLSRLDEL:
2728 buf_size += sizeof(struct ethtool_rxnfc);
2729 convert_in = true;
2730 break;
2731 }
2732
2733 ifr = compat_alloc_user_space(buf_size);
2734 rxnfc = (void __user *)ifr + ALIGN(sizeof(struct ifreq), 8);
2735
2736 if (copy_in_user(&ifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ))
2737 return -EFAULT;
2738
2739 if (put_user(convert_in ? rxnfc : compat_ptr(data),
2740 &ifr->ifr_ifru.ifru_data))
2741 return -EFAULT;
2742
2743 if (convert_in) {
2744
2745
2746
2747 BUILD_BUG_ON(offsetof(struct compat_ethtool_rxnfc, fs.m_ext) +
2748 sizeof(compat_rxnfc->fs.m_ext) !=
2749 offsetof(struct ethtool_rxnfc, fs.m_ext) +
2750 sizeof(rxnfc->fs.m_ext));
2751 BUILD_BUG_ON(
2752 offsetof(struct compat_ethtool_rxnfc, fs.location) -
2753 offsetof(struct compat_ethtool_rxnfc, fs.ring_cookie) !=
2754 offsetof(struct ethtool_rxnfc, fs.location) -
2755 offsetof(struct ethtool_rxnfc, fs.ring_cookie));
2756
2757 if (copy_in_user(rxnfc, compat_rxnfc,
2758 (void __user *)(&rxnfc->fs.m_ext + 1) -
2759 (void __user *)rxnfc) ||
2760 copy_in_user(&rxnfc->fs.ring_cookie,
2761 &compat_rxnfc->fs.ring_cookie,
2762 (void __user *)(&rxnfc->fs.location + 1) -
2763 (void __user *)&rxnfc->fs.ring_cookie) ||
2764 copy_in_user(&rxnfc->rule_cnt, &compat_rxnfc->rule_cnt,
2765 sizeof(rxnfc->rule_cnt)))
2766 return -EFAULT;
2767 }
2768
2769 ret = dev_ioctl(net, SIOCETHTOOL, ifr);
2770 if (ret)
2771 return ret;
2772
2773 if (convert_out) {
2774 if (copy_in_user(compat_rxnfc, rxnfc,
2775 (const void __user *)(&rxnfc->fs.m_ext + 1) -
2776 (const void __user *)rxnfc) ||
2777 copy_in_user(&compat_rxnfc->fs.ring_cookie,
2778 &rxnfc->fs.ring_cookie,
2779 (const void __user *)(&rxnfc->fs.location + 1) -
2780 (const void __user *)&rxnfc->fs.ring_cookie) ||
2781 copy_in_user(&compat_rxnfc->rule_cnt, &rxnfc->rule_cnt,
2782 sizeof(rxnfc->rule_cnt)))
2783 return -EFAULT;
2784
2785 if (ethcmd == ETHTOOL_GRXCLSRLALL) {
2786
2787
2788
2789
2790
2791
2792
2793
2794 if (get_user(actual_rule_cnt, &rxnfc->rule_cnt))
2795 return -EFAULT;
2796 if (actual_rule_cnt < rule_cnt)
2797 rule_cnt = actual_rule_cnt;
2798 if (copy_in_user(&compat_rxnfc->rule_locs[0],
2799 &rxnfc->rule_locs[0],
2800 rule_cnt * sizeof(u32)))
2801 return -EFAULT;
2802 }
2803 }
2804
2805 return 0;
2806}
2807
2808static int compat_siocwandev(struct net *net, struct compat_ifreq __user *uifr32)
2809{
2810 void __user *uptr;
2811 compat_uptr_t uptr32;
2812 struct ifreq __user *uifr;
2813
2814 uifr = compat_alloc_user_space(sizeof(*uifr));
2815 if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq)))
2816 return -EFAULT;
2817
2818 if (get_user(uptr32, &uifr32->ifr_settings.ifs_ifsu))
2819 return -EFAULT;
2820
2821 uptr = compat_ptr(uptr32);
2822
2823 if (put_user(uptr, &uifr->ifr_settings.ifs_ifsu.raw_hdlc))
2824 return -EFAULT;
2825
2826 return dev_ioctl(net, SIOCWANDEV, uifr);
2827}
2828
2829static int bond_ioctl(struct net *net, unsigned int cmd,
2830 struct compat_ifreq __user *ifr32)
2831{
2832 struct ifreq kifr;
2833 mm_segment_t old_fs;
2834 int err;
2835
2836 switch (cmd) {
2837 case SIOCBONDENSLAVE:
2838 case SIOCBONDRELEASE:
2839 case SIOCBONDSETHWADDR:
2840 case SIOCBONDCHANGEACTIVE:
2841 if (copy_from_user(&kifr, ifr32, sizeof(struct compat_ifreq)))
2842 return -EFAULT;
2843
2844 old_fs = get_fs();
2845 set_fs(KERNEL_DS);
2846 err = dev_ioctl(net, cmd,
2847 (struct ifreq __user __force *) &kifr);
2848 set_fs(old_fs);
2849
2850 return err;
2851 default:
2852 return -ENOIOCTLCMD;
2853 }
2854}
2855
2856
2857static int compat_ifr_data_ioctl(struct net *net, unsigned int cmd,
2858 struct compat_ifreq __user *u_ifreq32)
2859{
2860 struct ifreq __user *u_ifreq64;
2861 char tmp_buf[IFNAMSIZ];
2862 void __user *data64;
2863 u32 data32;
2864
2865 if (copy_from_user(&tmp_buf[0], &(u_ifreq32->ifr_ifrn.ifrn_name[0]),
2866 IFNAMSIZ))
2867 return -EFAULT;
2868 if (get_user(data32, &u_ifreq32->ifr_ifru.ifru_data))
2869 return -EFAULT;
2870 data64 = compat_ptr(data32);
2871
2872 u_ifreq64 = compat_alloc_user_space(sizeof(*u_ifreq64));
2873
2874 if (copy_to_user(&u_ifreq64->ifr_ifrn.ifrn_name[0], &tmp_buf[0],
2875 IFNAMSIZ))
2876 return -EFAULT;
2877 if (put_user(data64, &u_ifreq64->ifr_ifru.ifru_data))
2878 return -EFAULT;
2879
2880 return dev_ioctl(net, cmd, u_ifreq64);
2881}
2882
2883static int dev_ifsioc(struct net *net, struct socket *sock,
2884 unsigned int cmd, struct compat_ifreq __user *uifr32)
2885{
2886 struct ifreq __user *uifr;
2887 int err;
2888
2889 uifr = compat_alloc_user_space(sizeof(*uifr));
2890 if (copy_in_user(uifr, uifr32, sizeof(*uifr32)))
2891 return -EFAULT;
2892
2893 err = sock_do_ioctl(net, sock, cmd, (unsigned long)uifr);
2894
2895 if (!err) {
2896 switch (cmd) {
2897 case SIOCGIFFLAGS:
2898 case SIOCGIFMETRIC:
2899 case SIOCGIFMTU:
2900 case SIOCGIFMEM:
2901 case SIOCGIFHWADDR:
2902 case SIOCGIFINDEX:
2903 case SIOCGIFADDR:
2904 case SIOCGIFBRDADDR:
2905 case SIOCGIFDSTADDR:
2906 case SIOCGIFNETMASK:
2907 case SIOCGIFPFLAGS:
2908 case SIOCGIFTXQLEN:
2909 case SIOCGMIIPHY:
2910 case SIOCGMIIREG:
2911 if (copy_in_user(uifr32, uifr, sizeof(*uifr32)))
2912 err = -EFAULT;
2913 break;
2914 }
2915 }
2916 return err;
2917}
2918
2919static int compat_sioc_ifmap(struct net *net, unsigned int cmd,
2920 struct compat_ifreq __user *uifr32)
2921{
2922 struct ifreq ifr;
2923 struct compat_ifmap __user *uifmap32;
2924 mm_segment_t old_fs;
2925 int err;
2926
2927 uifmap32 = &uifr32->ifr_ifru.ifru_map;
2928 err = copy_from_user(&ifr, uifr32, sizeof(ifr.ifr_name));
2929 err |= get_user(ifr.ifr_map.mem_start, &uifmap32->mem_start);
2930 err |= get_user(ifr.ifr_map.mem_end, &uifmap32->mem_end);
2931 err |= get_user(ifr.ifr_map.base_addr, &uifmap32->base_addr);
2932 err |= get_user(ifr.ifr_map.irq, &uifmap32->irq);
2933 err |= get_user(ifr.ifr_map.dma, &uifmap32->dma);
2934 err |= get_user(ifr.ifr_map.port, &uifmap32->port);
2935 if (err)
2936 return -EFAULT;
2937
2938 old_fs = get_fs();
2939 set_fs(KERNEL_DS);
2940 err = dev_ioctl(net, cmd, (void __user __force *)&ifr);
2941 set_fs(old_fs);
2942
2943 if (cmd == SIOCGIFMAP && !err) {
2944 err = copy_to_user(uifr32, &ifr, sizeof(ifr.ifr_name));
2945 err |= put_user(ifr.ifr_map.mem_start, &uifmap32->mem_start);
2946 err |= put_user(ifr.ifr_map.mem_end, &uifmap32->mem_end);
2947 err |= put_user(ifr.ifr_map.base_addr, &uifmap32->base_addr);
2948 err |= put_user(ifr.ifr_map.irq, &uifmap32->irq);
2949 err |= put_user(ifr.ifr_map.dma, &uifmap32->dma);
2950 err |= put_user(ifr.ifr_map.port, &uifmap32->port);
2951 if (err)
2952 err = -EFAULT;
2953 }
2954 return err;
2955}
2956
2957struct rtentry32 {
2958 u32 rt_pad1;
2959 struct sockaddr rt_dst;
2960 struct sockaddr rt_gateway;
2961 struct sockaddr rt_genmask;
2962 unsigned short rt_flags;
2963 short rt_pad2;
2964 u32 rt_pad3;
2965 unsigned char rt_tos;
2966 unsigned char rt_class;
2967 short rt_pad4;
2968 short rt_metric;
2969 u32 rt_dev;
2970 u32 rt_mtu;
2971 u32 rt_window;
2972 unsigned short rt_irtt;
2973};
2974
2975struct in6_rtmsg32 {
2976 struct in6_addr rtmsg_dst;
2977 struct in6_addr rtmsg_src;
2978 struct in6_addr rtmsg_gateway;
2979 u32 rtmsg_type;
2980 u16 rtmsg_dst_len;
2981 u16 rtmsg_src_len;
2982 u32 rtmsg_metric;
2983 u32 rtmsg_info;
2984 u32 rtmsg_flags;
2985 s32 rtmsg_ifindex;
2986};
2987
2988static int routing_ioctl(struct net *net, struct socket *sock,
2989 unsigned int cmd, void __user *argp)
2990{
2991 int ret;
2992 void *r = NULL;
2993 struct in6_rtmsg r6;
2994 struct rtentry r4;
2995 char devname[16];
2996 u32 rtdev;
2997 mm_segment_t old_fs = get_fs();
2998
2999 if (sock && sock->sk && sock->sk->sk_family == AF_INET6) {
3000 struct in6_rtmsg32 __user *ur6 = argp;
3001 ret = copy_from_user(&r6.rtmsg_dst, &(ur6->rtmsg_dst),
3002 3 * sizeof(struct in6_addr));
3003 ret |= get_user(r6.rtmsg_type, &(ur6->rtmsg_type));
3004 ret |= get_user(r6.rtmsg_dst_len, &(ur6->rtmsg_dst_len));
3005 ret |= get_user(r6.rtmsg_src_len, &(ur6->rtmsg_src_len));
3006 ret |= get_user(r6.rtmsg_metric, &(ur6->rtmsg_metric));
3007 ret |= get_user(r6.rtmsg_info, &(ur6->rtmsg_info));
3008 ret |= get_user(r6.rtmsg_flags, &(ur6->rtmsg_flags));
3009 ret |= get_user(r6.rtmsg_ifindex, &(ur6->rtmsg_ifindex));
3010
3011 r = (void *) &r6;
3012 } else {
3013 struct rtentry32 __user *ur4 = argp;
3014 ret = copy_from_user(&r4.rt_dst, &(ur4->rt_dst),
3015 3 * sizeof(struct sockaddr));
3016 ret |= get_user(r4.rt_flags, &(ur4->rt_flags));
3017 ret |= get_user(r4.rt_metric, &(ur4->rt_metric));
3018 ret |= get_user(r4.rt_mtu, &(ur4->rt_mtu));
3019 ret |= get_user(r4.rt_window, &(ur4->rt_window));
3020 ret |= get_user(r4.rt_irtt, &(ur4->rt_irtt));
3021 ret |= get_user(rtdev, &(ur4->rt_dev));
3022 if (rtdev) {
3023 ret |= copy_from_user(devname, compat_ptr(rtdev), 15);
3024 r4.rt_dev = (char __user __force *)devname;
3025 devname[15] = 0;
3026 } else
3027 r4.rt_dev = NULL;
3028
3029 r = (void *) &r4;
3030 }
3031
3032 if (ret) {
3033 ret = -EFAULT;
3034 goto out;
3035 }
3036
3037 set_fs(KERNEL_DS);
3038 ret = sock_do_ioctl(net, sock, cmd, (unsigned long) r);
3039 set_fs(old_fs);
3040
3041out:
3042 return ret;
3043}
3044
3045
3046
3047
3048
3049static int old_bridge_ioctl(compat_ulong_t __user *argp)
3050{
3051 compat_ulong_t tmp;
3052
3053 if (get_user(tmp, argp))
3054 return -EFAULT;
3055 if (tmp == BRCTL_GET_VERSION)
3056 return BRCTL_VERSION + 1;
3057 return -EINVAL;
3058}
3059
3060static int compat_sock_ioctl_trans(struct file *file, struct socket *sock,
3061 unsigned int cmd, unsigned long arg)
3062{
3063 void __user *argp = compat_ptr(arg);
3064 struct sock *sk = sock->sk;
3065 struct net *net = sock_net(sk);
3066
3067 if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15))
3068 return compat_ifr_data_ioctl(net, cmd, argp);
3069
3070 switch (cmd) {
3071 case SIOCSIFBR:
3072 case SIOCGIFBR:
3073 return old_bridge_ioctl(argp);
3074 case SIOCGIFNAME:
3075 return dev_ifname32(net, argp);
3076 case SIOCGIFCONF:
3077 return dev_ifconf(net, argp);
3078 case SIOCETHTOOL:
3079 return ethtool_ioctl(net, argp);
3080 case SIOCWANDEV:
3081 return compat_siocwandev(net, argp);
3082 case SIOCGIFMAP:
3083 case SIOCSIFMAP:
3084 return compat_sioc_ifmap(net, cmd, argp);
3085 case SIOCBONDENSLAVE:
3086 case SIOCBONDRELEASE:
3087 case SIOCBONDSETHWADDR:
3088 case SIOCBONDCHANGEACTIVE:
3089 return bond_ioctl(net, cmd, argp);
3090 case SIOCADDRT:
3091 case SIOCDELRT:
3092 return routing_ioctl(net, sock, cmd, argp);
3093 case SIOCGSTAMP:
3094 return do_siocgstamp(net, sock, cmd, argp);
3095 case SIOCGSTAMPNS:
3096 return do_siocgstampns(net, sock, cmd, argp);
3097 case SIOCBONDSLAVEINFOQUERY:
3098 case SIOCBONDINFOQUERY:
3099 case SIOCSHWTSTAMP:
3100 case SIOCGHWTSTAMP:
3101 return compat_ifr_data_ioctl(net, cmd, argp);
3102
3103 case FIOSETOWN:
3104 case SIOCSPGRP:
3105 case FIOGETOWN:
3106 case SIOCGPGRP:
3107 case SIOCBRADDBR:
3108 case SIOCBRDELBR:
3109 case SIOCGIFVLAN:
3110 case SIOCSIFVLAN:
3111 case SIOCADDDLCI:
3112 case SIOCDELDLCI:
3113 return sock_ioctl(file, cmd, arg);
3114
3115 case SIOCGIFFLAGS:
3116 case SIOCSIFFLAGS:
3117 case SIOCGIFMETRIC:
3118 case SIOCSIFMETRIC:
3119 case SIOCGIFMTU:
3120 case SIOCSIFMTU:
3121 case SIOCGIFMEM:
3122 case SIOCSIFMEM:
3123 case SIOCGIFHWADDR:
3124 case SIOCSIFHWADDR:
3125 case SIOCADDMULTI:
3126 case SIOCDELMULTI:
3127 case SIOCGIFINDEX:
3128 case SIOCGIFADDR:
3129 case SIOCSIFADDR:
3130 case SIOCSIFHWBROADCAST:
3131 case SIOCDIFADDR:
3132 case SIOCGIFBRDADDR:
3133 case SIOCSIFBRDADDR:
3134 case SIOCGIFDSTADDR:
3135 case SIOCSIFDSTADDR:
3136 case SIOCGIFNETMASK:
3137 case SIOCSIFNETMASK:
3138 case SIOCSIFPFLAGS:
3139 case SIOCGIFPFLAGS:
3140 case SIOCGIFTXQLEN:
3141 case SIOCSIFTXQLEN:
3142 case SIOCBRADDIF:
3143 case SIOCBRDELIF:
3144 case SIOCSIFNAME:
3145 case SIOCGMIIPHY:
3146 case SIOCGMIIREG:
3147 case SIOCSMIIREG:
3148 return dev_ifsioc(net, sock, cmd, argp);
3149
3150 case SIOCSARP:
3151 case SIOCGARP:
3152 case SIOCDARP:
3153 case SIOCATMARK:
3154 return sock_do_ioctl(net, sock, cmd, arg);
3155 }
3156
3157 return -ENOIOCTLCMD;
3158}
3159
3160static long compat_sock_ioctl(struct file *file, unsigned int cmd,
3161 unsigned long arg)
3162{
3163 struct socket *sock = file->private_data;
3164 int ret = -ENOIOCTLCMD;
3165 struct sock *sk;
3166 struct net *net;
3167
3168 sk = sock->sk;
3169 net = sock_net(sk);
3170
3171 if (sock->ops->compat_ioctl)
3172 ret = sock->ops->compat_ioctl(sock, cmd, arg);
3173
3174 if (ret == -ENOIOCTLCMD &&
3175 (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST))
3176 ret = compat_wext_handle_ioctl(net, cmd, arg);
3177
3178 if (ret == -ENOIOCTLCMD)
3179 ret = compat_sock_ioctl_trans(file, sock, cmd, arg);
3180
3181 return ret;
3182}
3183#endif
3184
3185int kernel_bind(struct socket *sock, struct sockaddr *addr, int addrlen)
3186{
3187 return sock->ops->bind(sock, addr, addrlen);
3188}
3189EXPORT_SYMBOL(kernel_bind);
3190
3191int kernel_listen(struct socket *sock, int backlog)
3192{
3193 return sock->ops->listen(sock, backlog);
3194}
3195EXPORT_SYMBOL(kernel_listen);
3196
3197int kernel_accept(struct socket *sock, struct socket **newsock, int flags)
3198{
3199 struct sock *sk = sock->sk;
3200 int err;
3201
3202 err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol,
3203 newsock);
3204 if (err < 0)
3205 goto done;
3206
3207 err = sock->ops->accept(sock, *newsock, flags);
3208 if (err < 0) {
3209 sock_release(*newsock);
3210 *newsock = NULL;
3211 goto done;
3212 }
3213
3214 (*newsock)->ops = sock->ops;
3215 __module_get((*newsock)->ops->owner);
3216
3217done:
3218 return err;
3219}
3220EXPORT_SYMBOL(kernel_accept);
3221
3222int kernel_connect(struct socket *sock, struct sockaddr *addr, int addrlen,
3223 int flags)
3224{
3225 return sock->ops->connect(sock, addr, addrlen, flags);
3226}
3227EXPORT_SYMBOL(kernel_connect);
3228
3229int kernel_getsockname(struct socket *sock, struct sockaddr *addr,
3230 int *addrlen)
3231{
3232 return sock->ops->getname(sock, addr, addrlen, 0);
3233}
3234EXPORT_SYMBOL(kernel_getsockname);
3235
3236int kernel_getpeername(struct socket *sock, struct sockaddr *addr,
3237 int *addrlen)
3238{
3239 return sock->ops->getname(sock, addr, addrlen, 1);
3240}
3241EXPORT_SYMBOL(kernel_getpeername);
3242
3243int kernel_getsockopt(struct socket *sock, int level, int optname,
3244 char *optval, int *optlen)
3245{
3246 mm_segment_t oldfs = get_fs();
3247 char __user *uoptval;
3248 int __user *uoptlen;
3249 int err;
3250
3251 uoptval = (char __user __force *) optval;
3252 uoptlen = (int __user __force *) optlen;
3253
3254 set_fs(KERNEL_DS);
3255 if (level == SOL_SOCKET)
3256 err = sock_getsockopt(sock, level, optname, uoptval, uoptlen);
3257 else
3258 err = sock->ops->getsockopt(sock, level, optname, uoptval,
3259 uoptlen);
3260 set_fs(oldfs);
3261 return err;
3262}
3263EXPORT_SYMBOL(kernel_getsockopt);
3264
3265int kernel_setsockopt(struct socket *sock, int level, int optname,
3266 char *optval, unsigned int optlen)
3267{
3268 mm_segment_t oldfs = get_fs();
3269 char __user *uoptval;
3270 int err;
3271
3272 uoptval = (char __user __force *) optval;
3273
3274 set_fs(KERNEL_DS);
3275 if (level == SOL_SOCKET)
3276 err = sock_setsockopt(sock, level, optname, uoptval, optlen);
3277 else
3278 err = sock->ops->setsockopt(sock, level, optname, uoptval,
3279 optlen);
3280 set_fs(oldfs);
3281 return err;
3282}
3283EXPORT_SYMBOL(kernel_setsockopt);
3284
3285int kernel_sendpage(struct socket *sock, struct page *page, int offset,
3286 size_t size, int flags)
3287{
3288 if (sock->ops->sendpage)
3289 return sock->ops->sendpage(sock, page, offset, size, flags);
3290
3291 return sock_no_sendpage(sock, page, offset, size, flags);
3292}
3293EXPORT_SYMBOL(kernel_sendpage);
3294
3295int kernel_sock_ioctl(struct socket *sock, int cmd, unsigned long arg)
3296{
3297 mm_segment_t oldfs = get_fs();
3298 int err;
3299
3300 set_fs(KERNEL_DS);
3301 err = sock->ops->ioctl(sock, cmd, arg);
3302 set_fs(oldfs);
3303
3304 return err;
3305}
3306EXPORT_SYMBOL(kernel_sock_ioctl);
3307
3308int kernel_sock_shutdown(struct socket *sock, enum sock_shutdown_cmd how)
3309{
3310 return sock->ops->shutdown(sock, how);
3311}
3312EXPORT_SYMBOL(kernel_sock_shutdown);
3313