1 /*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * The IP to API glue.
7 *
8 * Authors: see ip.c
9 *
10 * Fixes:
11 * Many : Split from ip.c , see ip.c for history.
12 * Martin Mares : TOS setting fixed.
13 * Alan Cox : Fixed a couple of oopses in Martin's
14 * TOS tweaks.
15 * Mike McLagan : Routing by source
16 */
17
18 #include <linux/module.h>
19 #include <linux/types.h>
20 #include <linux/mm.h>
21 #include <linux/skbuff.h>
22 #include <linux/ip.h>
23 #include <linux/icmp.h>
24 #include <linux/inetdevice.h>
25 #include <linux/netdevice.h>
26 #include <linux/slab.h>
27 #include <net/sock.h>
28 #include <net/ip.h>
29 #include <net/icmp.h>
30 #include <net/tcp_states.h>
31 #include <linux/udp.h>
32 #include <linux/igmp.h>
33 #include <linux/netfilter.h>
34 #include <linux/route.h>
35 #include <linux/mroute.h>
36 #include <net/inet_ecn.h>
37 #include <net/route.h>
38 #include <net/xfrm.h>
39 #include <net/compat.h>
40 #if IS_ENABLED(CONFIG_IPV6)
41 #include <net/transp_v6.h>
42 #endif
43
44 #include <linux/errqueue.h>
45 #include <asm/uaccess.h>
46
47 #define IP_CMSG_PKTINFO 1
48 #define IP_CMSG_TTL 2
49 #define IP_CMSG_TOS 4
50 #define IP_CMSG_RECVOPTS 8
51 #define IP_CMSG_RETOPTS 16
52 #define IP_CMSG_PASSSEC 32
53 #define IP_CMSG_ORIGDSTADDR 64
54
55 /*
56 * SOL_IP control messages.
57 */
58 #define PKTINFO_SKB_CB(__skb) ((struct in_pktinfo *)((__skb)->cb))
59
ip_cmsg_recv_pktinfo(struct msghdr * msg,struct sk_buff * skb)60 static void ip_cmsg_recv_pktinfo(struct msghdr *msg, struct sk_buff *skb)
61 {
62 struct in_pktinfo info = *PKTINFO_SKB_CB(skb);
63
64 info.ipi_addr.s_addr = ip_hdr(skb)->daddr;
65
66 put_cmsg(msg, SOL_IP, IP_PKTINFO, sizeof(info), &info);
67 }
68
ip_cmsg_recv_ttl(struct msghdr * msg,struct sk_buff * skb)69 static void ip_cmsg_recv_ttl(struct msghdr *msg, struct sk_buff *skb)
70 {
71 int ttl = ip_hdr(skb)->ttl;
72 put_cmsg(msg, SOL_IP, IP_TTL, sizeof(int), &ttl);
73 }
74
ip_cmsg_recv_tos(struct msghdr * msg,struct sk_buff * skb)75 static void ip_cmsg_recv_tos(struct msghdr *msg, struct sk_buff *skb)
76 {
77 put_cmsg(msg, SOL_IP, IP_TOS, 1, &ip_hdr(skb)->tos);
78 }
79
ip_cmsg_recv_opts(struct msghdr * msg,struct sk_buff * skb)80 static void ip_cmsg_recv_opts(struct msghdr *msg, struct sk_buff *skb)
81 {
82 if (IPCB(skb)->opt.optlen == 0)
83 return;
84
85 put_cmsg(msg, SOL_IP, IP_RECVOPTS, IPCB(skb)->opt.optlen,
86 ip_hdr(skb) + 1);
87 }
88
89
ip_cmsg_recv_retopts(struct msghdr * msg,struct sk_buff * skb)90 static void ip_cmsg_recv_retopts(struct msghdr *msg, struct sk_buff *skb)
91 {
92 unsigned char optbuf[sizeof(struct ip_options) + 40];
93 struct ip_options * opt = (struct ip_options *)optbuf;
94
95 if (IPCB(skb)->opt.optlen == 0)
96 return;
97
98 if (ip_options_echo(opt, skb)) {
99 msg->msg_flags |= MSG_CTRUNC;
100 return;
101 }
102 ip_options_undo(opt);
103
104 put_cmsg(msg, SOL_IP, IP_RETOPTS, opt->optlen, opt->__data);
105 }
106
ip_cmsg_recv_security(struct msghdr * msg,struct sk_buff * skb)107 static void ip_cmsg_recv_security(struct msghdr *msg, struct sk_buff *skb)
108 {
109 char *secdata;
110 u32 seclen, secid;
111 int err;
112
113 err = security_socket_getpeersec_dgram(NULL, skb, &secid);
114 if (err)
115 return;
116
117 err = security_secid_to_secctx(secid, &secdata, &seclen);
118 if (err)
119 return;
120
121 put_cmsg(msg, SOL_IP, SCM_SECURITY, seclen, secdata);
122 security_release_secctx(secdata, seclen);
123 }
124
ip_cmsg_recv_dstaddr(struct msghdr * msg,struct sk_buff * skb)125 static void ip_cmsg_recv_dstaddr(struct msghdr *msg, struct sk_buff *skb)
126 {
127 struct sockaddr_in sin;
128 const struct iphdr *iph = ip_hdr(skb);
129 __be16 *ports = (__be16 *)skb_transport_header(skb);
130
131 if (skb_transport_offset(skb) + 4 > skb->len)
132 return;
133
134 /* All current transport protocols have the port numbers in the
135 * first four bytes of the transport header and this function is
136 * written with this assumption in mind.
137 */
138
139 sin.sin_family = AF_INET;
140 sin.sin_addr.s_addr = iph->daddr;
141 sin.sin_port = ports[1];
142 memset(sin.sin_zero, 0, sizeof(sin.sin_zero));
143
144 put_cmsg(msg, SOL_IP, IP_ORIGDSTADDR, sizeof(sin), &sin);
145 }
146
ip_cmsg_recv(struct msghdr * msg,struct sk_buff * skb)147 void ip_cmsg_recv(struct msghdr *msg, struct sk_buff *skb)
148 {
149 struct inet_sock *inet = inet_sk(skb->sk);
150 unsigned flags = inet->cmsg_flags;
151
152 /* Ordered by supposed usage frequency */
153 if (flags & 1)
154 ip_cmsg_recv_pktinfo(msg, skb);
155 if ((flags >>= 1) == 0)
156 return;
157
158 if (flags & 1)
159 ip_cmsg_recv_ttl(msg, skb);
160 if ((flags >>= 1) == 0)
161 return;
162
163 if (flags & 1)
164 ip_cmsg_recv_tos(msg, skb);
165 if ((flags >>= 1) == 0)
166 return;
167
168 if (flags & 1)
169 ip_cmsg_recv_opts(msg, skb);
170 if ((flags >>= 1) == 0)
171 return;
172
173 if (flags & 1)
174 ip_cmsg_recv_retopts(msg, skb);
175 if ((flags >>= 1) == 0)
176 return;
177
178 if (flags & 1)
179 ip_cmsg_recv_security(msg, skb);
180
181 if ((flags >>= 1) == 0)
182 return;
183 if (flags & 1)
184 ip_cmsg_recv_dstaddr(msg, skb);
185
186 }
187 EXPORT_SYMBOL(ip_cmsg_recv);
188
ip_cmsg_send(struct net * net,struct msghdr * msg,struct ipcm_cookie * ipc)189 int ip_cmsg_send(struct net *net, struct msghdr *msg, struct ipcm_cookie *ipc)
190 {
191 int err;
192 struct cmsghdr *cmsg;
193
194 for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
195 if (!CMSG_OK(msg, cmsg))
196 return -EINVAL;
197 if (cmsg->cmsg_level != SOL_IP)
198 continue;
199 switch (cmsg->cmsg_type) {
200 case IP_RETOPTS:
201 err = cmsg->cmsg_len - CMSG_ALIGN(sizeof(struct cmsghdr));
202 err = ip_options_get(net, &ipc->opt, CMSG_DATA(cmsg),
203 err < 40 ? err : 40);
204 if (err)
205 return err;
206 break;
207 case IP_PKTINFO:
208 {
209 struct in_pktinfo *info;
210 if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct in_pktinfo)))
211 return -EINVAL;
212 info = (struct in_pktinfo *)CMSG_DATA(cmsg);
213 ipc->oif = info->ipi_ifindex;
214 ipc->addr = info->ipi_spec_dst.s_addr;
215 break;
216 }
217 default:
218 return -EINVAL;
219 }
220 }
221 return 0;
222 }
223
224
225 /* Special input handler for packets caught by router alert option.
226 They are selected only by protocol field, and then processed likely
227 local ones; but only if someone wants them! Otherwise, router
228 not running rsvpd will kill RSVP.
229
230 It is user level problem, what it will make with them.
231 I have no idea, how it will masquearde or NAT them (it is joke, joke :-)),
232 but receiver should be enough clever f.e. to forward mtrace requests,
233 sent to multicast group to reach destination designated router.
234 */
235 struct ip_ra_chain __rcu *ip_ra_chain;
236 static DEFINE_SPINLOCK(ip_ra_lock);
237
238
ip_ra_destroy_rcu(struct rcu_head * head)239 static void ip_ra_destroy_rcu(struct rcu_head *head)
240 {
241 struct ip_ra_chain *ra = container_of(head, struct ip_ra_chain, rcu);
242
243 sock_put(ra->saved_sk);
244 kfree(ra);
245 }
246
ip_ra_control(struct sock * sk,unsigned char on,void (* destructor)(struct sock *))247 int ip_ra_control(struct sock *sk, unsigned char on,
248 void (*destructor)(struct sock *))
249 {
250 struct ip_ra_chain *ra, *new_ra;
251 struct ip_ra_chain __rcu **rap;
252
253 if (sk->sk_type != SOCK_RAW || inet_sk(sk)->inet_num == IPPROTO_RAW)
254 return -EINVAL;
255
256 new_ra = on ? kmalloc(sizeof(*new_ra), GFP_KERNEL) : NULL;
257
258 spin_lock_bh(&ip_ra_lock);
259 for (rap = &ip_ra_chain;
260 (ra = rcu_dereference_protected(*rap,
261 lockdep_is_held(&ip_ra_lock))) != NULL;
262 rap = &ra->next) {
263 if (ra->sk == sk) {
264 if (on) {
265 spin_unlock_bh(&ip_ra_lock);
266 kfree(new_ra);
267 return -EADDRINUSE;
268 }
269 /* dont let ip_call_ra_chain() use sk again */
270 ra->sk = NULL;
271 rcu_assign_pointer(*rap, ra->next);
272 spin_unlock_bh(&ip_ra_lock);
273
274 if (ra->destructor)
275 ra->destructor(sk);
276 /*
277 * Delay sock_put(sk) and kfree(ra) after one rcu grace
278 * period. This guarantee ip_call_ra_chain() dont need
279 * to mess with socket refcounts.
280 */
281 ra->saved_sk = sk;
282 call_rcu(&ra->rcu, ip_ra_destroy_rcu);
283 return 0;
284 }
285 }
286 if (new_ra == NULL) {
287 spin_unlock_bh(&ip_ra_lock);
288 return -ENOBUFS;
289 }
290 new_ra->sk = sk;
291 new_ra->destructor = destructor;
292
293 new_ra->next = ra;
294 rcu_assign_pointer(*rap, new_ra);
295 sock_hold(sk);
296 spin_unlock_bh(&ip_ra_lock);
297
298 return 0;
299 }
300
ip_icmp_error(struct sock * sk,struct sk_buff * skb,int err,__be16 port,u32 info,u8 * payload)301 void ip_icmp_error(struct sock *sk, struct sk_buff *skb, int err,
302 __be16 port, u32 info, u8 *payload)
303 {
304 struct sock_exterr_skb *serr;
305
306 skb = skb_clone(skb, GFP_ATOMIC);
307 if (!skb)
308 return;
309
310 serr = SKB_EXT_ERR(skb);
311 serr->ee.ee_errno = err;
312 serr->ee.ee_origin = SO_EE_ORIGIN_ICMP;
313 serr->ee.ee_type = icmp_hdr(skb)->type;
314 serr->ee.ee_code = icmp_hdr(skb)->code;
315 serr->ee.ee_pad = 0;
316 serr->ee.ee_info = info;
317 serr->ee.ee_data = 0;
318 serr->addr_offset = (u8 *)&(((struct iphdr *)(icmp_hdr(skb) + 1))->daddr) -
319 skb_network_header(skb);
320 serr->port = port;
321
322 if (skb_pull(skb, payload - skb->data) != NULL) {
323 skb_reset_transport_header(skb);
324 if (sock_queue_err_skb(sk, skb) == 0)
325 return;
326 }
327 kfree_skb(skb);
328 }
329
ip_local_error(struct sock * sk,int err,__be32 daddr,__be16 port,u32 info)330 void ip_local_error(struct sock *sk, int err, __be32 daddr, __be16 port, u32 info)
331 {
332 struct inet_sock *inet = inet_sk(sk);
333 struct sock_exterr_skb *serr;
334 struct iphdr *iph;
335 struct sk_buff *skb;
336
337 if (!inet->recverr)
338 return;
339
340 skb = alloc_skb(sizeof(struct iphdr), GFP_ATOMIC);
341 if (!skb)
342 return;
343
344 skb_put(skb, sizeof(struct iphdr));
345 skb_reset_network_header(skb);
346 iph = ip_hdr(skb);
347 iph->daddr = daddr;
348
349 serr = SKB_EXT_ERR(skb);
350 serr->ee.ee_errno = err;
351 serr->ee.ee_origin = SO_EE_ORIGIN_LOCAL;
352 serr->ee.ee_type = 0;
353 serr->ee.ee_code = 0;
354 serr->ee.ee_pad = 0;
355 serr->ee.ee_info = info;
356 serr->ee.ee_data = 0;
357 serr->addr_offset = (u8 *)&iph->daddr - skb_network_header(skb);
358 serr->port = port;
359
360 __skb_pull(skb, skb_tail_pointer(skb) - skb->data);
361 skb_reset_transport_header(skb);
362
363 if (sock_queue_err_skb(sk, skb))
364 kfree_skb(skb);
365 }
366
367 /*
368 * Handle MSG_ERRQUEUE
369 */
ip_recv_error(struct sock * sk,struct msghdr * msg,int len,int * addr_len)370 int ip_recv_error(struct sock *sk, struct msghdr *msg, int len, int *addr_len)
371 {
372 struct sock_exterr_skb *serr;
373 struct sk_buff *skb, *skb2;
374 struct sockaddr_in *sin;
375 struct {
376 struct sock_extended_err ee;
377 struct sockaddr_in offender;
378 } errhdr;
379 int err;
380 int copied;
381
382 err = -EAGAIN;
383 skb = skb_dequeue(&sk->sk_error_queue);
384 if (skb == NULL)
385 goto out;
386
387 copied = skb->len;
388 if (copied > len) {
389 msg->msg_flags |= MSG_TRUNC;
390 copied = len;
391 }
392 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
393 if (err)
394 goto out_free_skb;
395
396 sock_recv_timestamp(msg, sk, skb);
397
398 serr = SKB_EXT_ERR(skb);
399
400 sin = (struct sockaddr_in *)msg->msg_name;
401 if (sin) {
402 sin->sin_family = AF_INET;
403 sin->sin_addr.s_addr = *(__be32 *)(skb_network_header(skb) +
404 serr->addr_offset);
405 sin->sin_port = serr->port;
406 memset(&sin->sin_zero, 0, sizeof(sin->sin_zero));
407 *addr_len = sizeof(*sin);
408 }
409
410 memcpy(&errhdr.ee, &serr->ee, sizeof(struct sock_extended_err));
411 sin = &errhdr.offender;
412 sin->sin_family = AF_UNSPEC;
413 if (serr->ee.ee_origin == SO_EE_ORIGIN_ICMP) {
414 struct inet_sock *inet = inet_sk(sk);
415
416 sin->sin_family = AF_INET;
417 sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
418 sin->sin_port = 0;
419 memset(&sin->sin_zero, 0, sizeof(sin->sin_zero));
420 if (inet->cmsg_flags)
421 ip_cmsg_recv(msg, skb);
422 }
423
424 put_cmsg(msg, SOL_IP, IP_RECVERR, sizeof(errhdr), &errhdr);
425
426 /* Now we could try to dump offended packet options */
427
428 msg->msg_flags |= MSG_ERRQUEUE;
429 err = copied;
430
431 /* Reset and regenerate socket error */
432 spin_lock_bh(&sk->sk_error_queue.lock);
433 sk->sk_err = 0;
434 skb2 = skb_peek(&sk->sk_error_queue);
435 if (skb2 != NULL) {
436 sk->sk_err = SKB_EXT_ERR(skb2)->ee.ee_errno;
437 spin_unlock_bh(&sk->sk_error_queue.lock);
438 sk->sk_error_report(sk);
439 } else
440 spin_unlock_bh(&sk->sk_error_queue.lock);
441
442 out_free_skb:
443 kfree_skb(skb);
444 out:
445 return err;
446 }
447
448
449 /*
450 * Socket option code for IP. This is the end of the line after any
451 * TCP,UDP etc options on an IP socket.
452 */
453
do_ip_setsockopt(struct sock * sk,int level,int optname,char __user * optval,unsigned int optlen)454 static int do_ip_setsockopt(struct sock *sk, int level,
455 int optname, char __user *optval, unsigned int optlen)
456 {
457 struct inet_sock *inet = inet_sk(sk);
458 int val = 0, err;
459
460 switch (optname) {
461 case IP_PKTINFO:
462 case IP_RECVTTL:
463 case IP_RECVOPTS:
464 case IP_RECVTOS:
465 case IP_RETOPTS:
466 case IP_TOS:
467 case IP_TTL:
468 case IP_HDRINCL:
469 case IP_MTU_DISCOVER:
470 case IP_RECVERR:
471 case IP_ROUTER_ALERT:
472 case IP_FREEBIND:
473 case IP_PASSSEC:
474 case IP_TRANSPARENT:
475 case IP_MINTTL:
476 case IP_NODEFRAG:
477 case IP_UNICAST_IF:
478 case IP_MULTICAST_TTL:
479 case IP_MULTICAST_ALL:
480 case IP_MULTICAST_LOOP:
481 case IP_RECVORIGDSTADDR:
482 if (optlen >= sizeof(int)) {
483 if (get_user(val, (int __user *) optval))
484 return -EFAULT;
485 } else if (optlen >= sizeof(char)) {
486 unsigned char ucval;
487
488 if (get_user(ucval, (unsigned char __user *) optval))
489 return -EFAULT;
490 val = (int) ucval;
491 }
492 }
493
494 /* If optlen==0, it is equivalent to val == 0 */
495
496 if (ip_mroute_opt(optname))
497 return ip_mroute_setsockopt(sk, optname, optval, optlen);
498
499 err = 0;
500 lock_sock(sk);
501
502 switch (optname) {
503 case IP_OPTIONS:
504 {
505 struct ip_options_rcu *old, *opt = NULL;
506
507 if (optlen > 40)
508 goto e_inval;
509 err = ip_options_get_from_user(sock_net(sk), &opt,
510 optval, optlen);
511 if (err)
512 break;
513 old = rcu_dereference_protected(inet->inet_opt,
514 sock_owned_by_user(sk));
515 if (inet->is_icsk) {
516 struct inet_connection_sock *icsk = inet_csk(sk);
517 #if IS_ENABLED(CONFIG_IPV6)
518 if (sk->sk_family == PF_INET ||
519 (!((1 << sk->sk_state) &
520 (TCPF_LISTEN | TCPF_CLOSE)) &&
521 inet->inet_daddr != LOOPBACK4_IPV6)) {
522 #endif
523 if (old)
524 icsk->icsk_ext_hdr_len -= old->opt.optlen;
525 if (opt)
526 icsk->icsk_ext_hdr_len += opt->opt.optlen;
527 icsk->icsk_sync_mss(sk, icsk->icsk_pmtu_cookie);
528 #if IS_ENABLED(CONFIG_IPV6)
529 }
530 #endif
531 }
532 rcu_assign_pointer(inet->inet_opt, opt);
533 if (old)
534 kfree_rcu(old, rcu);
535 break;
536 }
537 case IP_PKTINFO:
538 if (val)
539 inet->cmsg_flags |= IP_CMSG_PKTINFO;
540 else
541 inet->cmsg_flags &= ~IP_CMSG_PKTINFO;
542 break;
543 case IP_RECVTTL:
544 if (val)
545 inet->cmsg_flags |= IP_CMSG_TTL;
546 else
547 inet->cmsg_flags &= ~IP_CMSG_TTL;
548 break;
549 case IP_RECVTOS:
550 if (val)
551 inet->cmsg_flags |= IP_CMSG_TOS;
552 else
553 inet->cmsg_flags &= ~IP_CMSG_TOS;
554 break;
555 case IP_RECVOPTS:
556 if (val)
557 inet->cmsg_flags |= IP_CMSG_RECVOPTS;
558 else
559 inet->cmsg_flags &= ~IP_CMSG_RECVOPTS;
560 break;
561 case IP_RETOPTS:
562 if (val)
563 inet->cmsg_flags |= IP_CMSG_RETOPTS;
564 else
565 inet->cmsg_flags &= ~IP_CMSG_RETOPTS;
566 break;
567 case IP_PASSSEC:
568 if (val)
569 inet->cmsg_flags |= IP_CMSG_PASSSEC;
570 else
571 inet->cmsg_flags &= ~IP_CMSG_PASSSEC;
572 break;
573 case IP_RECVORIGDSTADDR:
574 if (val)
575 inet->cmsg_flags |= IP_CMSG_ORIGDSTADDR;
576 else
577 inet->cmsg_flags &= ~IP_CMSG_ORIGDSTADDR;
578 break;
579 case IP_TOS: /* This sets both TOS and Precedence */
580 if (sk->sk_type == SOCK_STREAM) {
581 val &= ~INET_ECN_MASK;
582 val |= inet->tos & INET_ECN_MASK;
583 }
584 if (inet->tos != val) {
585 inet->tos = val;
586 sk->sk_priority = rt_tos2priority(val);
587 sk_dst_reset(sk);
588 }
589 break;
590 case IP_TTL:
591 if (optlen < 1)
592 goto e_inval;
593 if (val != -1 && (val < 1 || val > 255))
594 goto e_inval;
595 inet->uc_ttl = val;
596 break;
597 case IP_HDRINCL:
598 if (sk->sk_type != SOCK_RAW) {
599 err = -ENOPROTOOPT;
600 break;
601 }
602 inet->hdrincl = val ? 1 : 0;
603 break;
604 case IP_NODEFRAG:
605 if (sk->sk_type != SOCK_RAW) {
606 err = -ENOPROTOOPT;
607 break;
608 }
609 inet->nodefrag = val ? 1 : 0;
610 break;
611 case IP_MTU_DISCOVER:
612 if (val < IP_PMTUDISC_DONT || val > IP_PMTUDISC_PROBE)
613 goto e_inval;
614 inet->pmtudisc = val;
615 break;
616 case IP_RECVERR:
617 inet->recverr = !!val;
618 if (!val)
619 skb_queue_purge(&sk->sk_error_queue);
620 break;
621 case IP_MULTICAST_TTL:
622 if (sk->sk_type == SOCK_STREAM)
623 goto e_inval;
624 if (optlen < 1)
625 goto e_inval;
626 if (val == -1)
627 val = 1;
628 if (val < 0 || val > 255)
629 goto e_inval;
630 inet->mc_ttl = val;
631 break;
632 case IP_MULTICAST_LOOP:
633 if (optlen < 1)
634 goto e_inval;
635 inet->mc_loop = !!val;
636 break;
637 case IP_UNICAST_IF:
638 {
639 struct net_device *dev = NULL;
640 int ifindex;
641
642 if (optlen != sizeof(int))
643 goto e_inval;
644
645 ifindex = (__force int)ntohl((__force __be32)val);
646 if (ifindex == 0) {
647 inet->uc_index = 0;
648 err = 0;
649 break;
650 }
651
652 dev = dev_get_by_index(sock_net(sk), ifindex);
653 err = -EADDRNOTAVAIL;
654 if (!dev)
655 break;
656 dev_put(dev);
657
658 err = -EINVAL;
659 if (sk->sk_bound_dev_if)
660 break;
661
662 inet->uc_index = ifindex;
663 err = 0;
664 break;
665 }
666 case IP_MULTICAST_IF:
667 {
668 struct ip_mreqn mreq;
669 struct net_device *dev = NULL;
670
671 if (sk->sk_type == SOCK_STREAM)
672 goto e_inval;
673 /*
674 * Check the arguments are allowable
675 */
676
677 if (optlen < sizeof(struct in_addr))
678 goto e_inval;
679
680 err = -EFAULT;
681 if (optlen >= sizeof(struct ip_mreqn)) {
682 if (copy_from_user(&mreq, optval, sizeof(mreq)))
683 break;
684 } else {
685 memset(&mreq, 0, sizeof(mreq));
686 if (optlen >= sizeof(struct in_addr) &&
687 copy_from_user(&mreq.imr_address, optval,
688 sizeof(struct in_addr)))
689 break;
690 }
691
692 if (!mreq.imr_ifindex) {
693 if (mreq.imr_address.s_addr == htonl(INADDR_ANY)) {
694 inet->mc_index = 0;
695 inet->mc_addr = 0;
696 err = 0;
697 break;
698 }
699 dev = ip_dev_find(sock_net(sk), mreq.imr_address.s_addr);
700 if (dev)
701 mreq.imr_ifindex = dev->ifindex;
702 } else
703 dev = dev_get_by_index(sock_net(sk), mreq.imr_ifindex);
704
705
706 err = -EADDRNOTAVAIL;
707 if (!dev)
708 break;
709 dev_put(dev);
710
711 err = -EINVAL;
712 if (sk->sk_bound_dev_if &&
713 mreq.imr_ifindex != sk->sk_bound_dev_if)
714 break;
715
716 inet->mc_index = mreq.imr_ifindex;
717 inet->mc_addr = mreq.imr_address.s_addr;
718 err = 0;
719 break;
720 }
721
722 case IP_ADD_MEMBERSHIP:
723 case IP_DROP_MEMBERSHIP:
724 {
725 struct ip_mreqn mreq;
726
727 err = -EPROTO;
728 if (inet_sk(sk)->is_icsk)
729 break;
730
731 if (optlen < sizeof(struct ip_mreq))
732 goto e_inval;
733 err = -EFAULT;
734 if (optlen >= sizeof(struct ip_mreqn)) {
735 if (copy_from_user(&mreq, optval, sizeof(mreq)))
736 break;
737 } else {
738 memset(&mreq, 0, sizeof(mreq));
739 if (copy_from_user(&mreq, optval, sizeof(struct ip_mreq)))
740 break;
741 }
742
743 if (optname == IP_ADD_MEMBERSHIP)
744 err = ip_mc_join_group(sk, &mreq);
745 else
746 err = ip_mc_leave_group(sk, &mreq);
747 break;
748 }
749 case IP_MSFILTER:
750 {
751 struct ip_msfilter *msf;
752
753 if (optlen < IP_MSFILTER_SIZE(0))
754 goto e_inval;
755 if (optlen > sysctl_optmem_max) {
756 err = -ENOBUFS;
757 break;
758 }
759 msf = kmalloc(optlen, GFP_KERNEL);
760 if (!msf) {
761 err = -ENOBUFS;
762 break;
763 }
764 err = -EFAULT;
765 if (copy_from_user(msf, optval, optlen)) {
766 kfree(msf);
767 break;
768 }
769 /* numsrc >= (1G-4) overflow in 32 bits */
770 if (msf->imsf_numsrc >= 0x3ffffffcU ||
771 msf->imsf_numsrc > sysctl_igmp_max_msf) {
772 kfree(msf);
773 err = -ENOBUFS;
774 break;
775 }
776 if (IP_MSFILTER_SIZE(msf->imsf_numsrc) > optlen) {
777 kfree(msf);
778 err = -EINVAL;
779 break;
780 }
781 err = ip_mc_msfilter(sk, msf, 0);
782 kfree(msf);
783 break;
784 }
785 case IP_BLOCK_SOURCE:
786 case IP_UNBLOCK_SOURCE:
787 case IP_ADD_SOURCE_MEMBERSHIP:
788 case IP_DROP_SOURCE_MEMBERSHIP:
789 {
790 struct ip_mreq_source mreqs;
791 int omode, add;
792
793 if (optlen != sizeof(struct ip_mreq_source))
794 goto e_inval;
795 if (copy_from_user(&mreqs, optval, sizeof(mreqs))) {
796 err = -EFAULT;
797 break;
798 }
799 if (optname == IP_BLOCK_SOURCE) {
800 omode = MCAST_EXCLUDE;
801 add = 1;
802 } else if (optname == IP_UNBLOCK_SOURCE) {
803 omode = MCAST_EXCLUDE;
804 add = 0;
805 } else if (optname == IP_ADD_SOURCE_MEMBERSHIP) {
806 struct ip_mreqn mreq;
807
808 mreq.imr_multiaddr.s_addr = mreqs.imr_multiaddr;
809 mreq.imr_address.s_addr = mreqs.imr_interface;
810 mreq.imr_ifindex = 0;
811 err = ip_mc_join_group(sk, &mreq);
812 if (err && err != -EADDRINUSE)
813 break;
814 omode = MCAST_INCLUDE;
815 add = 1;
816 } else /* IP_DROP_SOURCE_MEMBERSHIP */ {
817 omode = MCAST_INCLUDE;
818 add = 0;
819 }
820 err = ip_mc_source(add, omode, sk, &mreqs, 0);
821 break;
822 }
823 case MCAST_JOIN_GROUP:
824 case MCAST_LEAVE_GROUP:
825 {
826 struct group_req greq;
827 struct sockaddr_in *psin;
828 struct ip_mreqn mreq;
829
830 if (optlen < sizeof(struct group_req))
831 goto e_inval;
832 err = -EFAULT;
833 if (copy_from_user(&greq, optval, sizeof(greq)))
834 break;
835 psin = (struct sockaddr_in *)&greq.gr_group;
836 if (psin->sin_family != AF_INET)
837 goto e_inval;
838 memset(&mreq, 0, sizeof(mreq));
839 mreq.imr_multiaddr = psin->sin_addr;
840 mreq.imr_ifindex = greq.gr_interface;
841
842 if (optname == MCAST_JOIN_GROUP)
843 err = ip_mc_join_group(sk, &mreq);
844 else
845 err = ip_mc_leave_group(sk, &mreq);
846 break;
847 }
848 case MCAST_JOIN_SOURCE_GROUP:
849 case MCAST_LEAVE_SOURCE_GROUP:
850 case MCAST_BLOCK_SOURCE:
851 case MCAST_UNBLOCK_SOURCE:
852 {
853 struct group_source_req greqs;
854 struct ip_mreq_source mreqs;
855 struct sockaddr_in *psin;
856 int omode, add;
857
858 if (optlen != sizeof(struct group_source_req))
859 goto e_inval;
860 if (copy_from_user(&greqs, optval, sizeof(greqs))) {
861 err = -EFAULT;
862 break;
863 }
864 if (greqs.gsr_group.ss_family != AF_INET ||
865 greqs.gsr_source.ss_family != AF_INET) {
866 err = -EADDRNOTAVAIL;
867 break;
868 }
869 psin = (struct sockaddr_in *)&greqs.gsr_group;
870 mreqs.imr_multiaddr = psin->sin_addr.s_addr;
871 psin = (struct sockaddr_in *)&greqs.gsr_source;
872 mreqs.imr_sourceaddr = psin->sin_addr.s_addr;
873 mreqs.imr_interface = 0; /* use index for mc_source */
874
875 if (optname == MCAST_BLOCK_SOURCE) {
876 omode = MCAST_EXCLUDE;
877 add = 1;
878 } else if (optname == MCAST_UNBLOCK_SOURCE) {
879 omode = MCAST_EXCLUDE;
880 add = 0;
881 } else if (optname == MCAST_JOIN_SOURCE_GROUP) {
882 struct ip_mreqn mreq;
883
884 psin = (struct sockaddr_in *)&greqs.gsr_group;
885 mreq.imr_multiaddr = psin->sin_addr;
886 mreq.imr_address.s_addr = 0;
887 mreq.imr_ifindex = greqs.gsr_interface;
888 err = ip_mc_join_group(sk, &mreq);
889 if (err && err != -EADDRINUSE)
890 break;
891 greqs.gsr_interface = mreq.imr_ifindex;
892 omode = MCAST_INCLUDE;
893 add = 1;
894 } else /* MCAST_LEAVE_SOURCE_GROUP */ {
895 omode = MCAST_INCLUDE;
896 add = 0;
897 }
898 err = ip_mc_source(add, omode, sk, &mreqs,
899 greqs.gsr_interface);
900 break;
901 }
902 case MCAST_MSFILTER:
903 {
904 struct sockaddr_in *psin;
905 struct ip_msfilter *msf = NULL;
906 struct group_filter *gsf = NULL;
907 int msize, i, ifindex;
908
909 if (optlen < GROUP_FILTER_SIZE(0))
910 goto e_inval;
911 if (optlen > sysctl_optmem_max) {
912 err = -ENOBUFS;
913 break;
914 }
915 gsf = kmalloc(optlen, GFP_KERNEL);
916 if (!gsf) {
917 err = -ENOBUFS;
918 break;
919 }
920 err = -EFAULT;
921 if (copy_from_user(gsf, optval, optlen))
922 goto mc_msf_out;
923
924 /* numsrc >= (4G-140)/128 overflow in 32 bits */
925 if (gsf->gf_numsrc >= 0x1ffffff ||
926 gsf->gf_numsrc > sysctl_igmp_max_msf) {
927 err = -ENOBUFS;
928 goto mc_msf_out;
929 }
930 if (GROUP_FILTER_SIZE(gsf->gf_numsrc) > optlen) {
931 err = -EINVAL;
932 goto mc_msf_out;
933 }
934 msize = IP_MSFILTER_SIZE(gsf->gf_numsrc);
935 msf = kmalloc(msize, GFP_KERNEL);
936 if (!msf) {
937 err = -ENOBUFS;
938 goto mc_msf_out;
939 }
940 ifindex = gsf->gf_interface;
941 psin = (struct sockaddr_in *)&gsf->gf_group;
942 if (psin->sin_family != AF_INET) {
943 err = -EADDRNOTAVAIL;
944 goto mc_msf_out;
945 }
946 msf->imsf_multiaddr = psin->sin_addr.s_addr;
947 msf->imsf_interface = 0;
948 msf->imsf_fmode = gsf->gf_fmode;
949 msf->imsf_numsrc = gsf->gf_numsrc;
950 err = -EADDRNOTAVAIL;
951 for (i = 0; i < gsf->gf_numsrc; ++i) {
952 psin = (struct sockaddr_in *)&gsf->gf_slist[i];
953
954 if (psin->sin_family != AF_INET)
955 goto mc_msf_out;
956 msf->imsf_slist[i] = psin->sin_addr.s_addr;
957 }
958 kfree(gsf);
959 gsf = NULL;
960
961 err = ip_mc_msfilter(sk, msf, ifindex);
962 mc_msf_out:
963 kfree(msf);
964 kfree(gsf);
965 break;
966 }
967 case IP_MULTICAST_ALL:
968 if (optlen < 1)
969 goto e_inval;
970 if (val != 0 && val != 1)
971 goto e_inval;
972 inet->mc_all = val;
973 break;
974 case IP_ROUTER_ALERT:
975 err = ip_ra_control(sk, val ? 1 : 0, NULL);
976 break;
977
978 case IP_FREEBIND:
979 if (optlen < 1)
980 goto e_inval;
981 inet->freebind = !!val;
982 break;
983
984 case IP_IPSEC_POLICY:
985 case IP_XFRM_POLICY:
986 err = -EPERM;
987 if (!capable(CAP_NET_ADMIN))
988 break;
989 err = xfrm_user_policy(sk, optname, optval, optlen);
990 break;
991
992 case IP_TRANSPARENT:
993 if (!!val && !capable(CAP_NET_RAW) && !capable(CAP_NET_ADMIN)) {
994 err = -EPERM;
995 break;
996 }
997 if (optlen < 1)
998 goto e_inval;
999 inet->transparent = !!val;
1000 break;
1001
1002 case IP_MINTTL:
1003 if (optlen < 1)
1004 goto e_inval;
1005 if (val < 0 || val > 255)
1006 goto e_inval;
1007 inet->min_ttl = val;
1008 break;
1009
1010 default:
1011 err = -ENOPROTOOPT;
1012 break;
1013 }
1014 release_sock(sk);
1015 return err;
1016
1017 e_inval:
1018 release_sock(sk);
1019 return -EINVAL;
1020 }
1021
1022 /**
1023 * ipv4_pktinfo_prepare - transfert some info from rtable to skb
1024 * @sk: socket
1025 * @skb: buffer
1026 *
1027 * To support IP_CMSG_PKTINFO option, we store rt_iif and rt_spec_dst
1028 * in skb->cb[] before dst drop.
1029 * This way, receiver doesnt make cache line misses to read rtable.
1030 */
ipv4_pktinfo_prepare(struct sk_buff * skb)1031 void ipv4_pktinfo_prepare(struct sk_buff *skb)
1032 {
1033 struct in_pktinfo *pktinfo = PKTINFO_SKB_CB(skb);
1034 const struct rtable *rt = skb_rtable(skb);
1035
1036 if (rt) {
1037 pktinfo->ipi_ifindex = rt->rt_iif;
1038 pktinfo->ipi_spec_dst.s_addr = rt->rt_spec_dst;
1039 } else {
1040 pktinfo->ipi_ifindex = 0;
1041 pktinfo->ipi_spec_dst.s_addr = 0;
1042 }
1043 skb_dst_drop(skb);
1044 }
1045
ip_setsockopt(struct sock * sk,int level,int optname,char __user * optval,unsigned int optlen)1046 int ip_setsockopt(struct sock *sk, int level,
1047 int optname, char __user *optval, unsigned int optlen)
1048 {
1049 int err;
1050
1051 if (level != SOL_IP)
1052 return -ENOPROTOOPT;
1053
1054 err = do_ip_setsockopt(sk, level, optname, optval, optlen);
1055 #ifdef CONFIG_NETFILTER
1056 /* we need to exclude all possible ENOPROTOOPTs except default case */
1057 if (err == -ENOPROTOOPT && optname != IP_HDRINCL &&
1058 optname != IP_IPSEC_POLICY &&
1059 optname != IP_XFRM_POLICY &&
1060 !ip_mroute_opt(optname)) {
1061 lock_sock(sk);
1062 err = nf_setsockopt(sk, PF_INET, optname, optval, optlen);
1063 release_sock(sk);
1064 }
1065 #endif
1066 return err;
1067 }
1068 EXPORT_SYMBOL(ip_setsockopt);
1069
1070 #ifdef CONFIG_COMPAT
compat_ip_setsockopt(struct sock * sk,int level,int optname,char __user * optval,unsigned int optlen)1071 int compat_ip_setsockopt(struct sock *sk, int level, int optname,
1072 char __user *optval, unsigned int optlen)
1073 {
1074 int err;
1075
1076 if (level != SOL_IP)
1077 return -ENOPROTOOPT;
1078
1079 if (optname >= MCAST_JOIN_GROUP && optname <= MCAST_MSFILTER)
1080 return compat_mc_setsockopt(sk, level, optname, optval, optlen,
1081 ip_setsockopt);
1082
1083 err = do_ip_setsockopt(sk, level, optname, optval, optlen);
1084 #ifdef CONFIG_NETFILTER
1085 /* we need to exclude all possible ENOPROTOOPTs except default case */
1086 if (err == -ENOPROTOOPT && optname != IP_HDRINCL &&
1087 optname != IP_IPSEC_POLICY &&
1088 optname != IP_XFRM_POLICY &&
1089 !ip_mroute_opt(optname)) {
1090 lock_sock(sk);
1091 err = compat_nf_setsockopt(sk, PF_INET, optname,
1092 optval, optlen);
1093 release_sock(sk);
1094 }
1095 #endif
1096 return err;
1097 }
1098 EXPORT_SYMBOL(compat_ip_setsockopt);
1099 #endif
1100
1101 /*
1102 * Get the options. Note for future reference. The GET of IP options gets
1103 * the _received_ ones. The set sets the _sent_ ones.
1104 */
1105
do_ip_getsockopt(struct sock * sk,int level,int optname,char __user * optval,int __user * optlen,unsigned flags)1106 static int do_ip_getsockopt(struct sock *sk, int level, int optname,
1107 char __user *optval, int __user *optlen, unsigned flags)
1108 {
1109 struct inet_sock *inet = inet_sk(sk);
1110 int val;
1111 int len;
1112
1113 if (level != SOL_IP)
1114 return -EOPNOTSUPP;
1115
1116 if (ip_mroute_opt(optname))
1117 return ip_mroute_getsockopt(sk, optname, optval, optlen);
1118
1119 if (get_user(len, optlen))
1120 return -EFAULT;
1121 if (len < 0)
1122 return -EINVAL;
1123
1124 lock_sock(sk);
1125
1126 switch (optname) {
1127 case IP_OPTIONS:
1128 {
1129 unsigned char optbuf[sizeof(struct ip_options)+40];
1130 struct ip_options *opt = (struct ip_options *)optbuf;
1131 struct ip_options_rcu *inet_opt;
1132
1133 inet_opt = rcu_dereference_protected(inet->inet_opt,
1134 sock_owned_by_user(sk));
1135 opt->optlen = 0;
1136 if (inet_opt)
1137 memcpy(optbuf, &inet_opt->opt,
1138 sizeof(struct ip_options) +
1139 inet_opt->opt.optlen);
1140 release_sock(sk);
1141
1142 if (opt->optlen == 0)
1143 return put_user(0, optlen);
1144
1145 ip_options_undo(opt);
1146
1147 len = min_t(unsigned int, len, opt->optlen);
1148 if (put_user(len, optlen))
1149 return -EFAULT;
1150 if (copy_to_user(optval, opt->__data, len))
1151 return -EFAULT;
1152 return 0;
1153 }
1154 case IP_PKTINFO:
1155 val = (inet->cmsg_flags & IP_CMSG_PKTINFO) != 0;
1156 break;
1157 case IP_RECVTTL:
1158 val = (inet->cmsg_flags & IP_CMSG_TTL) != 0;
1159 break;
1160 case IP_RECVTOS:
1161 val = (inet->cmsg_flags & IP_CMSG_TOS) != 0;
1162 break;
1163 case IP_RECVOPTS:
1164 val = (inet->cmsg_flags & IP_CMSG_RECVOPTS) != 0;
1165 break;
1166 case IP_RETOPTS:
1167 val = (inet->cmsg_flags & IP_CMSG_RETOPTS) != 0;
1168 break;
1169 case IP_PASSSEC:
1170 val = (inet->cmsg_flags & IP_CMSG_PASSSEC) != 0;
1171 break;
1172 case IP_RECVORIGDSTADDR:
1173 val = (inet->cmsg_flags & IP_CMSG_ORIGDSTADDR) != 0;
1174 break;
1175 case IP_TOS:
1176 val = inet->tos;
1177 break;
1178 case IP_TTL:
1179 val = (inet->uc_ttl == -1 ?
1180 sysctl_ip_default_ttl :
1181 inet->uc_ttl);
1182 break;
1183 case IP_HDRINCL:
1184 val = inet->hdrincl;
1185 break;
1186 case IP_NODEFRAG:
1187 val = inet->nodefrag;
1188 break;
1189 case IP_MTU_DISCOVER:
1190 val = inet->pmtudisc;
1191 break;
1192 case IP_MTU:
1193 {
1194 struct dst_entry *dst;
1195 val = 0;
1196 dst = sk_dst_get(sk);
1197 if (dst) {
1198 val = dst_mtu(dst);
1199 dst_release(dst);
1200 }
1201 if (!val) {
1202 release_sock(sk);
1203 return -ENOTCONN;
1204 }
1205 break;
1206 }
1207 case IP_RECVERR:
1208 val = inet->recverr;
1209 break;
1210 case IP_MULTICAST_TTL:
1211 val = inet->mc_ttl;
1212 break;
1213 case IP_MULTICAST_LOOP:
1214 val = inet->mc_loop;
1215 break;
1216 case IP_UNICAST_IF:
1217 val = (__force int)htonl((__u32) inet->uc_index);
1218 break;
1219 case IP_MULTICAST_IF:
1220 {
1221 struct in_addr addr;
1222 len = min_t(unsigned int, len, sizeof(struct in_addr));
1223 addr.s_addr = inet->mc_addr;
1224 release_sock(sk);
1225
1226 if (put_user(len, optlen))
1227 return -EFAULT;
1228 if (copy_to_user(optval, &addr, len))
1229 return -EFAULT;
1230 return 0;
1231 }
1232 case IP_MSFILTER:
1233 {
1234 struct ip_msfilter msf;
1235 int err;
1236
1237 if (len < IP_MSFILTER_SIZE(0)) {
1238 release_sock(sk);
1239 return -EINVAL;
1240 }
1241 if (copy_from_user(&msf, optval, IP_MSFILTER_SIZE(0))) {
1242 release_sock(sk);
1243 return -EFAULT;
1244 }
1245 err = ip_mc_msfget(sk, &msf,
1246 (struct ip_msfilter __user *)optval, optlen);
1247 release_sock(sk);
1248 return err;
1249 }
1250 case MCAST_MSFILTER:
1251 {
1252 struct group_filter gsf;
1253 int err;
1254
1255 if (len < GROUP_FILTER_SIZE(0)) {
1256 release_sock(sk);
1257 return -EINVAL;
1258 }
1259 if (copy_from_user(&gsf, optval, GROUP_FILTER_SIZE(0))) {
1260 release_sock(sk);
1261 return -EFAULT;
1262 }
1263 err = ip_mc_gsfget(sk, &gsf,
1264 (struct group_filter __user *)optval,
1265 optlen);
1266 release_sock(sk);
1267 return err;
1268 }
1269 case IP_MULTICAST_ALL:
1270 val = inet->mc_all;
1271 break;
1272 case IP_PKTOPTIONS:
1273 {
1274 struct msghdr msg;
1275
1276 release_sock(sk);
1277
1278 if (sk->sk_type != SOCK_STREAM)
1279 return -ENOPROTOOPT;
1280
1281 msg.msg_control = optval;
1282 msg.msg_controllen = len;
1283 msg.msg_flags = flags;
1284
1285 if (inet->cmsg_flags & IP_CMSG_PKTINFO) {
1286 struct in_pktinfo info;
1287
1288 info.ipi_addr.s_addr = inet->inet_rcv_saddr;
1289 info.ipi_spec_dst.s_addr = inet->inet_rcv_saddr;
1290 info.ipi_ifindex = inet->mc_index;
1291 put_cmsg(&msg, SOL_IP, IP_PKTINFO, sizeof(info), &info);
1292 }
1293 if (inet->cmsg_flags & IP_CMSG_TTL) {
1294 int hlim = inet->mc_ttl;
1295 put_cmsg(&msg, SOL_IP, IP_TTL, sizeof(hlim), &hlim);
1296 }
1297 if (inet->cmsg_flags & IP_CMSG_TOS) {
1298 int tos = inet->rcv_tos;
1299 put_cmsg(&msg, SOL_IP, IP_TOS, sizeof(tos), &tos);
1300 }
1301 len -= msg.msg_controllen;
1302 return put_user(len, optlen);
1303 }
1304 case IP_FREEBIND:
1305 val = inet->freebind;
1306 break;
1307 case IP_TRANSPARENT:
1308 val = inet->transparent;
1309 break;
1310 case IP_MINTTL:
1311 val = inet->min_ttl;
1312 break;
1313 default:
1314 release_sock(sk);
1315 return -ENOPROTOOPT;
1316 }
1317 release_sock(sk);
1318
1319 if (len < sizeof(int) && len > 0 && val >= 0 && val <= 255) {
1320 unsigned char ucval = (unsigned char)val;
1321 len = 1;
1322 if (put_user(len, optlen))
1323 return -EFAULT;
1324 if (copy_to_user(optval, &ucval, 1))
1325 return -EFAULT;
1326 } else {
1327 len = min_t(unsigned int, sizeof(int), len);
1328 if (put_user(len, optlen))
1329 return -EFAULT;
1330 if (copy_to_user(optval, &val, len))
1331 return -EFAULT;
1332 }
1333 return 0;
1334 }
1335
ip_getsockopt(struct sock * sk,int level,int optname,char __user * optval,int __user * optlen)1336 int ip_getsockopt(struct sock *sk, int level,
1337 int optname, char __user *optval, int __user *optlen)
1338 {
1339 int err;
1340
1341 err = do_ip_getsockopt(sk, level, optname, optval, optlen, 0);
1342 #ifdef CONFIG_NETFILTER
1343 /* we need to exclude all possible ENOPROTOOPTs except default case */
1344 if (err == -ENOPROTOOPT && optname != IP_PKTOPTIONS &&
1345 !ip_mroute_opt(optname)) {
1346 int len;
1347
1348 if (get_user(len, optlen))
1349 return -EFAULT;
1350
1351 lock_sock(sk);
1352 err = nf_getsockopt(sk, PF_INET, optname, optval,
1353 &len);
1354 release_sock(sk);
1355 if (err >= 0)
1356 err = put_user(len, optlen);
1357 return err;
1358 }
1359 #endif
1360 return err;
1361 }
1362 EXPORT_SYMBOL(ip_getsockopt);
1363
1364 #ifdef CONFIG_COMPAT
compat_ip_getsockopt(struct sock * sk,int level,int optname,char __user * optval,int __user * optlen)1365 int compat_ip_getsockopt(struct sock *sk, int level, int optname,
1366 char __user *optval, int __user *optlen)
1367 {
1368 int err;
1369
1370 if (optname == MCAST_MSFILTER)
1371 return compat_mc_getsockopt(sk, level, optname, optval, optlen,
1372 ip_getsockopt);
1373
1374 err = do_ip_getsockopt(sk, level, optname, optval, optlen,
1375 MSG_CMSG_COMPAT);
1376
1377 #ifdef CONFIG_NETFILTER
1378 /* we need to exclude all possible ENOPROTOOPTs except default case */
1379 if (err == -ENOPROTOOPT && optname != IP_PKTOPTIONS &&
1380 !ip_mroute_opt(optname)) {
1381 int len;
1382
1383 if (get_user(len, optlen))
1384 return -EFAULT;
1385
1386 lock_sock(sk);
1387 err = compat_nf_getsockopt(sk, PF_INET, optname, optval, &len);
1388 release_sock(sk);
1389 if (err >= 0)
1390 err = put_user(len, optlen);
1391 return err;
1392 }
1393 #endif
1394 return err;
1395 }
1396 EXPORT_SYMBOL(compat_ip_getsockopt);
1397 #endif
1398