~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/ipv4/raw.c

Version: ~ [ linux-5.13-rc5 ] ~ [ linux-5.12.9 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.42 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.124 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.193 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.235 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.271 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.271 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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  *              RAW - implementation of IP "raw" sockets.
  7  *
  8  * Authors:     Ross Biro
  9  *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
 10  *
 11  * Fixes:
 12  *              Alan Cox        :       verify_area() fixed up
 13  *              Alan Cox        :       ICMP error handling
 14  *              Alan Cox        :       EMSGSIZE if you send too big a packet
 15  *              Alan Cox        :       Now uses generic datagrams and shared
 16  *                                      skbuff library. No more peek crashes,
 17  *                                      no more backlogs
 18  *              Alan Cox        :       Checks sk->broadcast.
 19  *              Alan Cox        :       Uses skb_free_datagram/skb_copy_datagram
 20  *              Alan Cox        :       Raw passes ip options too
 21  *              Alan Cox        :       Setsocketopt added
 22  *              Alan Cox        :       Fixed error return for broadcasts
 23  *              Alan Cox        :       Removed wake_up calls
 24  *              Alan Cox        :       Use ttl/tos
 25  *              Alan Cox        :       Cleaned up old debugging
 26  *              Alan Cox        :       Use new kernel side addresses
 27  *      Arnt Gulbrandsen        :       Fixed MSG_DONTROUTE in raw sockets.
 28  *              Alan Cox        :       BSD style RAW socket demultiplexing.
 29  *              Alan Cox        :       Beginnings of mrouted support.
 30  *              Alan Cox        :       Added IP_HDRINCL option.
 31  *              Alan Cox        :       Skip broadcast check if BSDism set.
 32  *              David S. Miller :       New socket lookup architecture.
 33  *
 34  *              This program is free software; you can redistribute it and/or
 35  *              modify it under the terms of the GNU General Public License
 36  *              as published by the Free Software Foundation; either version
 37  *              2 of the License, or (at your option) any later version.
 38  */
 39 
 40 #include <linux/types.h>
 41 #include <linux/atomic.h>
 42 #include <asm/byteorder.h>
 43 #include <asm/current.h>
 44 #include <asm/uaccess.h>
 45 #include <asm/ioctls.h>
 46 #include <linux/stddef.h>
 47 #include <linux/slab.h>
 48 #include <linux/errno.h>
 49 #include <linux/kernel.h>
 50 #include <linux/export.h>
 51 #include <linux/spinlock.h>
 52 #include <linux/sockios.h>
 53 #include <linux/socket.h>
 54 #include <linux/in.h>
 55 #include <linux/mroute.h>
 56 #include <linux/netdevice.h>
 57 #include <linux/in_route.h>
 58 #include <linux/route.h>
 59 #include <linux/skbuff.h>
 60 #include <linux/igmp.h>
 61 #include <net/net_namespace.h>
 62 #include <net/dst.h>
 63 #include <net/sock.h>
 64 #include <linux/ip.h>
 65 #include <linux/net.h>
 66 #include <net/ip.h>
 67 #include <net/icmp.h>
 68 #include <net/udp.h>
 69 #include <net/raw.h>
 70 #include <net/snmp.h>
 71 #include <net/tcp_states.h>
 72 #include <net/inet_common.h>
 73 #include <net/checksum.h>
 74 #include <net/xfrm.h>
 75 #include <linux/rtnetlink.h>
 76 #include <linux/proc_fs.h>
 77 #include <linux/seq_file.h>
 78 #include <linux/netfilter.h>
 79 #include <linux/netfilter_ipv4.h>
 80 #include <linux/compat.h>
 81 #include <linux/uio.h>
 82 
 83 struct raw_frag_vec {
 84         struct msghdr *msg;
 85         union {
 86                 struct icmphdr icmph;
 87                 char c[1];
 88         } hdr;
 89         int hlen;
 90 };
 91 
 92 static struct raw_hashinfo raw_v4_hashinfo = {
 93         .lock = __RW_LOCK_UNLOCKED(raw_v4_hashinfo.lock),
 94 };
 95 
 96 void raw_hash_sk(struct sock *sk)
 97 {
 98         struct raw_hashinfo *h = sk->sk_prot->h.raw_hash;
 99         struct hlist_head *head;
100 
101         head = &h->ht[inet_sk(sk)->inet_num & (RAW_HTABLE_SIZE - 1)];
102 
103         write_lock_bh(&h->lock);
104         sk_add_node(sk, head);
105         sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
106         write_unlock_bh(&h->lock);
107 }
108 EXPORT_SYMBOL_GPL(raw_hash_sk);
109 
110 void raw_unhash_sk(struct sock *sk)
111 {
112         struct raw_hashinfo *h = sk->sk_prot->h.raw_hash;
113 
114         write_lock_bh(&h->lock);
115         if (sk_del_node_init(sk))
116                 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
117         write_unlock_bh(&h->lock);
118 }
119 EXPORT_SYMBOL_GPL(raw_unhash_sk);
120 
121 static struct sock *__raw_v4_lookup(struct net *net, struct sock *sk,
122                 unsigned short num, __be32 raddr, __be32 laddr, int dif)
123 {
124         sk_for_each_from(sk) {
125                 struct inet_sock *inet = inet_sk(sk);
126 
127                 if (net_eq(sock_net(sk), net) && inet->inet_num == num  &&
128                     !(inet->inet_daddr && inet->inet_daddr != raddr)    &&
129                     !(inet->inet_rcv_saddr && inet->inet_rcv_saddr != laddr) &&
130                     !(sk->sk_bound_dev_if && sk->sk_bound_dev_if != dif))
131                         goto found; /* gotcha */
132         }
133         sk = NULL;
134 found:
135         return sk;
136 }
137 
138 /*
139  *      0 - deliver
140  *      1 - block
141  */
142 static int icmp_filter(const struct sock *sk, const struct sk_buff *skb)
143 {
144         struct icmphdr _hdr;
145         const struct icmphdr *hdr;
146 
147         hdr = skb_header_pointer(skb, skb_transport_offset(skb),
148                                  sizeof(_hdr), &_hdr);
149         if (!hdr)
150                 return 1;
151 
152         if (hdr->type < 32) {
153                 __u32 data = raw_sk(sk)->filter.data;
154 
155                 return ((1U << hdr->type) & data) != 0;
156         }
157 
158         /* Do not block unknown ICMP types */
159         return 0;
160 }
161 
162 /* IP input processing comes here for RAW socket delivery.
163  * Caller owns SKB, so we must make clones.
164  *
165  * RFC 1122: SHOULD pass TOS value up to the transport layer.
166  * -> It does. And not only TOS, but all IP header.
167  */
168 static int raw_v4_input(struct sk_buff *skb, const struct iphdr *iph, int hash)
169 {
170         struct sock *sk;
171         struct hlist_head *head;
172         int delivered = 0;
173         struct net *net;
174 
175         read_lock(&raw_v4_hashinfo.lock);
176         head = &raw_v4_hashinfo.ht[hash];
177         if (hlist_empty(head))
178                 goto out;
179 
180         net = dev_net(skb->dev);
181         sk = __raw_v4_lookup(net, __sk_head(head), iph->protocol,
182                              iph->saddr, iph->daddr,
183                              skb->dev->ifindex);
184 
185         while (sk) {
186                 delivered = 1;
187                 if ((iph->protocol != IPPROTO_ICMP || !icmp_filter(sk, skb)) &&
188                     ip_mc_sf_allow(sk, iph->daddr, iph->saddr,
189                                    skb->dev->ifindex)) {
190                         struct sk_buff *clone = skb_clone(skb, GFP_ATOMIC);
191 
192                         /* Not releasing hash table! */
193                         if (clone)
194                                 raw_rcv(sk, clone);
195                 }
196                 sk = __raw_v4_lookup(net, sk_next(sk), iph->protocol,
197                                      iph->saddr, iph->daddr,
198                                      skb->dev->ifindex);
199         }
200 out:
201         read_unlock(&raw_v4_hashinfo.lock);
202         return delivered;
203 }
204 
205 int raw_local_deliver(struct sk_buff *skb, int protocol)
206 {
207         int hash;
208         struct sock *raw_sk;
209 
210         hash = protocol & (RAW_HTABLE_SIZE - 1);
211         raw_sk = sk_head(&raw_v4_hashinfo.ht[hash]);
212 
213         /* If there maybe a raw socket we must check - if not we
214          * don't care less
215          */
216         if (raw_sk && !raw_v4_input(skb, ip_hdr(skb), hash))
217                 raw_sk = NULL;
218 
219         return raw_sk != NULL;
220 
221 }
222 
223 static void raw_err(struct sock *sk, struct sk_buff *skb, u32 info)
224 {
225         struct inet_sock *inet = inet_sk(sk);
226         const int type = icmp_hdr(skb)->type;
227         const int code = icmp_hdr(skb)->code;
228         int err = 0;
229         int harderr = 0;
230 
231         if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED)
232                 ipv4_sk_update_pmtu(skb, sk, info);
233         else if (type == ICMP_REDIRECT) {
234                 ipv4_sk_redirect(skb, sk);
235                 return;
236         }
237 
238         /* Report error on raw socket, if:
239            1. User requested ip_recverr.
240            2. Socket is connected (otherwise the error indication
241               is useless without ip_recverr and error is hard.
242          */
243         if (!inet->recverr && sk->sk_state != TCP_ESTABLISHED)
244                 return;
245 
246         switch (type) {
247         default:
248         case ICMP_TIME_EXCEEDED:
249                 err = EHOSTUNREACH;
250                 break;
251         case ICMP_SOURCE_QUENCH:
252                 return;
253         case ICMP_PARAMETERPROB:
254                 err = EPROTO;
255                 harderr = 1;
256                 break;
257         case ICMP_DEST_UNREACH:
258                 err = EHOSTUNREACH;
259                 if (code > NR_ICMP_UNREACH)
260                         break;
261                 err = icmp_err_convert[code].errno;
262                 harderr = icmp_err_convert[code].fatal;
263                 if (code == ICMP_FRAG_NEEDED) {
264                         harderr = inet->pmtudisc != IP_PMTUDISC_DONT;
265                         err = EMSGSIZE;
266                 }
267         }
268 
269         if (inet->recverr) {
270                 const struct iphdr *iph = (const struct iphdr *)skb->data;
271                 u8 *payload = skb->data + (iph->ihl << 2);
272 
273                 if (inet->hdrincl)
274                         payload = skb->data;
275                 ip_icmp_error(sk, skb, err, 0, info, payload);
276         }
277 
278         if (inet->recverr || harderr) {
279                 sk->sk_err = err;
280                 sk->sk_error_report(sk);
281         }
282 }
283 
284 void raw_icmp_error(struct sk_buff *skb, int protocol, u32 info)
285 {
286         int hash;
287         struct sock *raw_sk;
288         const struct iphdr *iph;
289         struct net *net;
290 
291         hash = protocol & (RAW_HTABLE_SIZE - 1);
292 
293         read_lock(&raw_v4_hashinfo.lock);
294         raw_sk = sk_head(&raw_v4_hashinfo.ht[hash]);
295         if (raw_sk) {
296                 iph = (const struct iphdr *)skb->data;
297                 net = dev_net(skb->dev);
298 
299                 while ((raw_sk = __raw_v4_lookup(net, raw_sk, protocol,
300                                                 iph->daddr, iph->saddr,
301                                                 skb->dev->ifindex)) != NULL) {
302                         raw_err(raw_sk, skb, info);
303                         raw_sk = sk_next(raw_sk);
304                         iph = (const struct iphdr *)skb->data;
305                 }
306         }
307         read_unlock(&raw_v4_hashinfo.lock);
308 }
309 
310 static int raw_rcv_skb(struct sock *sk, struct sk_buff *skb)
311 {
312         /* Charge it to the socket. */
313 
314         ipv4_pktinfo_prepare(sk, skb);
315         if (sock_queue_rcv_skb(sk, skb) < 0) {
316                 kfree_skb(skb);
317                 return NET_RX_DROP;
318         }
319 
320         return NET_RX_SUCCESS;
321 }
322 
323 int raw_rcv(struct sock *sk, struct sk_buff *skb)
324 {
325         if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb)) {
326                 atomic_inc(&sk->sk_drops);
327                 kfree_skb(skb);
328                 return NET_RX_DROP;
329         }
330         nf_reset(skb);
331 
332         skb_push(skb, skb->data - skb_network_header(skb));
333 
334         raw_rcv_skb(sk, skb);
335         return 0;
336 }
337 
338 static int raw_send_hdrinc(struct sock *sk, struct flowi4 *fl4,
339                            struct msghdr *msg, size_t length,
340                            struct rtable **rtp,
341                            unsigned int flags)
342 {
343         struct inet_sock *inet = inet_sk(sk);
344         struct net *net = sock_net(sk);
345         struct iphdr *iph;
346         struct sk_buff *skb;
347         unsigned int iphlen;
348         int err;
349         struct rtable *rt = *rtp;
350         int hlen, tlen;
351 
352         if (length > rt->dst.dev->mtu) {
353                 ip_local_error(sk, EMSGSIZE, fl4->daddr, inet->inet_dport,
354                                rt->dst.dev->mtu);
355                 return -EMSGSIZE;
356         }
357         if (flags&MSG_PROBE)
358                 goto out;
359 
360         hlen = LL_RESERVED_SPACE(rt->dst.dev);
361         tlen = rt->dst.dev->needed_tailroom;
362         skb = sock_alloc_send_skb(sk,
363                                   length + hlen + tlen + 15,
364                                   flags & MSG_DONTWAIT, &err);
365         if (!skb)
366                 goto error;
367         skb_reserve(skb, hlen);
368 
369         skb->priority = sk->sk_priority;
370         skb->mark = sk->sk_mark;
371         skb_dst_set(skb, &rt->dst);
372         *rtp = NULL;
373 
374         skb_reset_network_header(skb);
375         iph = ip_hdr(skb);
376         skb_put(skb, length);
377 
378         skb->ip_summed = CHECKSUM_NONE;
379 
380         sock_tx_timestamp(sk, &skb_shinfo(skb)->tx_flags);
381 
382         skb->transport_header = skb->network_header;
383         err = -EFAULT;
384         if (memcpy_from_msg(iph, msg, length))
385                 goto error_free;
386 
387         iphlen = iph->ihl * 4;
388 
389         /*
390          * We don't want to modify the ip header, but we do need to
391          * be sure that it won't cause problems later along the network
392          * stack.  Specifically we want to make sure that iph->ihl is a
393          * sane value.  If ihl points beyond the length of the buffer passed
394          * in, reject the frame as invalid
395          */
396         err = -EINVAL;
397         if (iphlen > length)
398                 goto error_free;
399 
400         if (iphlen >= sizeof(*iph)) {
401                 if (!iph->saddr)
402                         iph->saddr = fl4->saddr;
403                 iph->check   = 0;
404                 iph->tot_len = htons(length);
405                 if (!iph->id)
406                         ip_select_ident(net, skb, NULL);
407 
408                 iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);
409         }
410         if (iph->protocol == IPPROTO_ICMP)
411                 icmp_out_count(net, ((struct icmphdr *)
412                         skb_transport_header(skb))->type);
413 
414         err = NF_HOOK(NFPROTO_IPV4, NF_INET_LOCAL_OUT, sk, skb,
415                       NULL, rt->dst.dev, dst_output_sk);
416         if (err > 0)
417                 err = net_xmit_errno(err);
418         if (err)
419                 goto error;
420 out:
421         return 0;
422 
423 error_free:
424         kfree_skb(skb);
425 error:
426         IP_INC_STATS(net, IPSTATS_MIB_OUTDISCARDS);
427         if (err == -ENOBUFS && !inet->recverr)
428                 err = 0;
429         return err;
430 }
431 
432 static int raw_probe_proto_opt(struct raw_frag_vec *rfv, struct flowi4 *fl4)
433 {
434         int err;
435 
436         if (fl4->flowi4_proto != IPPROTO_ICMP)
437                 return 0;
438 
439         /* We only need the first two bytes. */
440         rfv->hlen = 2;
441 
442         err = memcpy_from_msg(rfv->hdr.c, rfv->msg, rfv->hlen);
443         if (err)
444                 return err;
445 
446         fl4->fl4_icmp_type = rfv->hdr.icmph.type;
447         fl4->fl4_icmp_code = rfv->hdr.icmph.code;
448 
449         return 0;
450 }
451 
452 static int raw_getfrag(void *from, char *to, int offset, int len, int odd,
453                        struct sk_buff *skb)
454 {
455         struct raw_frag_vec *rfv = from;
456 
457         if (offset < rfv->hlen) {
458                 int copy = min(rfv->hlen - offset, len);
459 
460                 if (skb->ip_summed == CHECKSUM_PARTIAL)
461                         memcpy(to, rfv->hdr.c + offset, copy);
462                 else
463                         skb->csum = csum_block_add(
464                                 skb->csum,
465                                 csum_partial_copy_nocheck(rfv->hdr.c + offset,
466                                                           to, copy, 0),
467                                 odd);
468 
469                 odd = 0;
470                 offset += copy;
471                 to += copy;
472                 len -= copy;
473 
474                 if (!len)
475                         return 0;
476         }
477 
478         offset -= rfv->hlen;
479 
480         return ip_generic_getfrag(rfv->msg, to, offset, len, odd, skb);
481 }
482 
483 static int raw_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
484 {
485         struct inet_sock *inet = inet_sk(sk);
486         struct ipcm_cookie ipc;
487         struct rtable *rt = NULL;
488         struct flowi4 fl4;
489         int free = 0;
490         __be32 daddr;
491         __be32 saddr;
492         u8  tos;
493         int err;
494         struct ip_options_data opt_copy;
495         struct raw_frag_vec rfv;
496 
497         err = -EMSGSIZE;
498         if (len > 0xFFFF)
499                 goto out;
500 
501         /*
502          *      Check the flags.
503          */
504 
505         err = -EOPNOTSUPP;
506         if (msg->msg_flags & MSG_OOB)   /* Mirror BSD error message */
507                 goto out;               /* compatibility */
508 
509         /*
510          *      Get and verify the address.
511          */
512 
513         if (msg->msg_namelen) {
514                 DECLARE_SOCKADDR(struct sockaddr_in *, usin, msg->msg_name);
515                 err = -EINVAL;
516                 if (msg->msg_namelen < sizeof(*usin))
517                         goto out;
518                 if (usin->sin_family != AF_INET) {
519                         pr_info_once("%s: %s forgot to set AF_INET. Fix it!\n",
520                                      __func__, current->comm);
521                         err = -EAFNOSUPPORT;
522                         if (usin->sin_family)
523                                 goto out;
524                 }
525                 daddr = usin->sin_addr.s_addr;
526                 /* ANK: I did not forget to get protocol from port field.
527                  * I just do not know, who uses this weirdness.
528                  * IP_HDRINCL is much more convenient.
529                  */
530         } else {
531                 err = -EDESTADDRREQ;
532                 if (sk->sk_state != TCP_ESTABLISHED)
533                         goto out;
534                 daddr = inet->inet_daddr;
535         }
536 
537         ipc.addr = inet->inet_saddr;
538         ipc.opt = NULL;
539         ipc.tx_flags = 0;
540         ipc.ttl = 0;
541         ipc.tos = -1;
542         ipc.oif = sk->sk_bound_dev_if;
543 
544         if (msg->msg_controllen) {
545                 err = ip_cmsg_send(sock_net(sk), msg, &ipc, false);
546                 if (err)
547                         goto out;
548                 if (ipc.opt)
549                         free = 1;
550         }
551 
552         saddr = ipc.addr;
553         ipc.addr = daddr;
554 
555         if (!ipc.opt) {
556                 struct ip_options_rcu *inet_opt;
557 
558                 rcu_read_lock();
559                 inet_opt = rcu_dereference(inet->inet_opt);
560                 if (inet_opt) {
561                         memcpy(&opt_copy, inet_opt,
562                                sizeof(*inet_opt) + inet_opt->opt.optlen);
563                         ipc.opt = &opt_copy.opt;
564                 }
565                 rcu_read_unlock();
566         }
567 
568         if (ipc.opt) {
569                 err = -EINVAL;
570                 /* Linux does not mangle headers on raw sockets,
571                  * so that IP options + IP_HDRINCL is non-sense.
572                  */
573                 if (inet->hdrincl)
574                         goto done;
575                 if (ipc.opt->opt.srr) {
576                         if (!daddr)
577                                 goto done;
578                         daddr = ipc.opt->opt.faddr;
579                 }
580         }
581         tos = get_rtconn_flags(&ipc, sk);
582         if (msg->msg_flags & MSG_DONTROUTE)
583                 tos |= RTO_ONLINK;
584 
585         if (ipv4_is_multicast(daddr)) {
586                 if (!ipc.oif)
587                         ipc.oif = inet->mc_index;
588                 if (!saddr)
589                         saddr = inet->mc_addr;
590         } else if (!ipc.oif)
591                 ipc.oif = inet->uc_index;
592 
593         flowi4_init_output(&fl4, ipc.oif, sk->sk_mark, tos,
594                            RT_SCOPE_UNIVERSE,
595                            inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol,
596                            inet_sk_flowi_flags(sk) |
597                             (inet->hdrincl ? FLOWI_FLAG_KNOWN_NH : 0),
598                            daddr, saddr, 0, 0);
599 
600         if (!inet->hdrincl) {
601                 rfv.msg = msg;
602                 rfv.hlen = 0;
603 
604                 err = raw_probe_proto_opt(&rfv, &fl4);
605                 if (err)
606                         goto done;
607         }
608 
609         security_sk_classify_flow(sk, flowi4_to_flowi(&fl4));
610         rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
611         if (IS_ERR(rt)) {
612                 err = PTR_ERR(rt);
613                 rt = NULL;
614                 goto done;
615         }
616 
617         err = -EACCES;
618         if (rt->rt_flags & RTCF_BROADCAST && !sock_flag(sk, SOCK_BROADCAST))
619                 goto done;
620 
621         if (msg->msg_flags & MSG_CONFIRM)
622                 goto do_confirm;
623 back_from_confirm:
624 
625         if (inet->hdrincl)
626                 err = raw_send_hdrinc(sk, &fl4, msg, len,
627                                       &rt, msg->msg_flags);
628 
629          else {
630                 sock_tx_timestamp(sk, &ipc.tx_flags);
631 
632                 if (!ipc.addr)
633                         ipc.addr = fl4.daddr;
634                 lock_sock(sk);
635                 err = ip_append_data(sk, &fl4, raw_getfrag,
636                                      &rfv, len, 0,
637                                      &ipc, &rt, msg->msg_flags);
638                 if (err)
639                         ip_flush_pending_frames(sk);
640                 else if (!(msg->msg_flags & MSG_MORE)) {
641                         err = ip_push_pending_frames(sk, &fl4);
642                         if (err == -ENOBUFS && !inet->recverr)
643                                 err = 0;
644                 }
645                 release_sock(sk);
646         }
647 done:
648         if (free)
649                 kfree(ipc.opt);
650         ip_rt_put(rt);
651 
652 out:
653         if (err < 0)
654                 return err;
655         return len;
656 
657 do_confirm:
658         dst_confirm(&rt->dst);
659         if (!(msg->msg_flags & MSG_PROBE) || len)
660                 goto back_from_confirm;
661         err = 0;
662         goto done;
663 }
664 
665 static void raw_close(struct sock *sk, long timeout)
666 {
667         /*
668          * Raw sockets may have direct kernel references. Kill them.
669          */
670         ip_ra_control(sk, 0, NULL);
671 
672         sk_common_release(sk);
673 }
674 
675 static void raw_destroy(struct sock *sk)
676 {
677         lock_sock(sk);
678         ip_flush_pending_frames(sk);
679         release_sock(sk);
680 }
681 
682 /* This gets rid of all the nasties in af_inet. -DaveM */
683 static int raw_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
684 {
685         struct inet_sock *inet = inet_sk(sk);
686         struct sockaddr_in *addr = (struct sockaddr_in *) uaddr;
687         int ret = -EINVAL;
688         int chk_addr_ret;
689 
690         if (sk->sk_state != TCP_CLOSE || addr_len < sizeof(struct sockaddr_in))
691                 goto out;
692         chk_addr_ret = inet_addr_type(sock_net(sk), addr->sin_addr.s_addr);
693         ret = -EADDRNOTAVAIL;
694         if (addr->sin_addr.s_addr && chk_addr_ret != RTN_LOCAL &&
695             chk_addr_ret != RTN_MULTICAST && chk_addr_ret != RTN_BROADCAST)
696                 goto out;
697         inet->inet_rcv_saddr = inet->inet_saddr = addr->sin_addr.s_addr;
698         if (chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST)
699                 inet->inet_saddr = 0;  /* Use device */
700         sk_dst_reset(sk);
701         ret = 0;
702 out:    return ret;
703 }
704 
705 /*
706  *      This should be easy, if there is something there
707  *      we return it, otherwise we block.
708  */
709 
710 static int raw_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
711                        int noblock, int flags, int *addr_len)
712 {
713         struct inet_sock *inet = inet_sk(sk);
714         size_t copied = 0;
715         int err = -EOPNOTSUPP;
716         DECLARE_SOCKADDR(struct sockaddr_in *, sin, msg->msg_name);
717         struct sk_buff *skb;
718 
719         if (flags & MSG_OOB)
720                 goto out;
721 
722         if (flags & MSG_ERRQUEUE) {
723                 err = ip_recv_error(sk, msg, len, addr_len);
724                 goto out;
725         }
726 
727         skb = skb_recv_datagram(sk, flags, noblock, &err);
728         if (!skb)
729                 goto out;
730         if (ccs_socket_post_recvmsg_permission(sk, skb, flags)) {
731                 err = -EAGAIN; /* Hope less harmful than -EPERM. */
732                 goto out;
733         }
734 
735         copied = skb->len;
736         if (len < copied) {
737                 msg->msg_flags |= MSG_TRUNC;
738                 copied = len;
739         }
740 
741         err = skb_copy_datagram_msg(skb, 0, msg, copied);
742         if (err)
743                 goto done;
744 
745         sock_recv_ts_and_drops(msg, sk, skb);
746 
747         /* Copy the address. */
748         if (sin) {
749                 sin->sin_family = AF_INET;
750                 sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
751                 sin->sin_port = 0;
752                 memset(&sin->sin_zero, 0, sizeof(sin->sin_zero));
753                 *addr_len = sizeof(*sin);
754         }
755         if (inet->cmsg_flags)
756                 ip_cmsg_recv(msg, skb);
757         if (flags & MSG_TRUNC)
758                 copied = skb->len;
759 done:
760         skb_free_datagram(sk, skb);
761 out:
762         if (err)
763                 return err;
764         return copied;
765 }
766 
767 static int raw_init(struct sock *sk)
768 {
769         struct raw_sock *rp = raw_sk(sk);
770 
771         if (inet_sk(sk)->inet_num == IPPROTO_ICMP)
772                 memset(&rp->filter, 0, sizeof(rp->filter));
773         return 0;
774 }
775 
776 static int raw_seticmpfilter(struct sock *sk, char __user *optval, int optlen)
777 {
778         if (optlen > sizeof(struct icmp_filter))
779                 optlen = sizeof(struct icmp_filter);
780         if (copy_from_user(&raw_sk(sk)->filter, optval, optlen))
781                 return -EFAULT;
782         return 0;
783 }
784 
785 static int raw_geticmpfilter(struct sock *sk, char __user *optval, int __user *optlen)
786 {
787         int len, ret = -EFAULT;
788 
789         if (get_user(len, optlen))
790                 goto out;
791         ret = -EINVAL;
792         if (len < 0)
793                 goto out;
794         if (len > sizeof(struct icmp_filter))
795                 len = sizeof(struct icmp_filter);
796         ret = -EFAULT;
797         if (put_user(len, optlen) ||
798             copy_to_user(optval, &raw_sk(sk)->filter, len))
799                 goto out;
800         ret = 0;
801 out:    return ret;
802 }
803 
804 static int do_raw_setsockopt(struct sock *sk, int level, int optname,
805                           char __user *optval, unsigned int optlen)
806 {
807         if (optname == ICMP_FILTER) {
808                 if (inet_sk(sk)->inet_num != IPPROTO_ICMP)
809                         return -EOPNOTSUPP;
810                 else
811                         return raw_seticmpfilter(sk, optval, optlen);
812         }
813         return -ENOPROTOOPT;
814 }
815 
816 static int raw_setsockopt(struct sock *sk, int level, int optname,
817                           char __user *optval, unsigned int optlen)
818 {
819         if (level != SOL_RAW)
820                 return ip_setsockopt(sk, level, optname, optval, optlen);
821         return do_raw_setsockopt(sk, level, optname, optval, optlen);
822 }
823 
824 #ifdef CONFIG_COMPAT
825 static int compat_raw_setsockopt(struct sock *sk, int level, int optname,
826                                  char __user *optval, unsigned int optlen)
827 {
828         if (level != SOL_RAW)
829                 return compat_ip_setsockopt(sk, level, optname, optval, optlen);
830         return do_raw_setsockopt(sk, level, optname, optval, optlen);
831 }
832 #endif
833 
834 static int do_raw_getsockopt(struct sock *sk, int level, int optname,
835                           char __user *optval, int __user *optlen)
836 {
837         if (optname == ICMP_FILTER) {
838                 if (inet_sk(sk)->inet_num != IPPROTO_ICMP)
839                         return -EOPNOTSUPP;
840                 else
841                         return raw_geticmpfilter(sk, optval, optlen);
842         }
843         return -ENOPROTOOPT;
844 }
845 
846 static int raw_getsockopt(struct sock *sk, int level, int optname,
847                           char __user *optval, int __user *optlen)
848 {
849         if (level != SOL_RAW)
850                 return ip_getsockopt(sk, level, optname, optval, optlen);
851         return do_raw_getsockopt(sk, level, optname, optval, optlen);
852 }
853 
854 #ifdef CONFIG_COMPAT
855 static int compat_raw_getsockopt(struct sock *sk, int level, int optname,
856                                  char __user *optval, int __user *optlen)
857 {
858         if (level != SOL_RAW)
859                 return compat_ip_getsockopt(sk, level, optname, optval, optlen);
860         return do_raw_getsockopt(sk, level, optname, optval, optlen);
861 }
862 #endif
863 
864 static int raw_ioctl(struct sock *sk, int cmd, unsigned long arg)
865 {
866         switch (cmd) {
867         case SIOCOUTQ: {
868                 int amount = sk_wmem_alloc_get(sk);
869 
870                 return put_user(amount, (int __user *)arg);
871         }
872         case SIOCINQ: {
873                 struct sk_buff *skb;
874                 int amount = 0;
875 
876                 spin_lock_bh(&sk->sk_receive_queue.lock);
877                 skb = skb_peek(&sk->sk_receive_queue);
878                 if (skb)
879                         amount = skb->len;
880                 spin_unlock_bh(&sk->sk_receive_queue.lock);
881                 return put_user(amount, (int __user *)arg);
882         }
883 
884         default:
885 #ifdef CONFIG_IP_MROUTE
886                 return ipmr_ioctl(sk, cmd, (void __user *)arg);
887 #else
888                 return -ENOIOCTLCMD;
889 #endif
890         }
891 }
892 
893 #ifdef CONFIG_COMPAT
894 static int compat_raw_ioctl(struct sock *sk, unsigned int cmd, unsigned long arg)
895 {
896         switch (cmd) {
897         case SIOCOUTQ:
898         case SIOCINQ:
899                 return -ENOIOCTLCMD;
900         default:
901 #ifdef CONFIG_IP_MROUTE
902                 return ipmr_compat_ioctl(sk, cmd, compat_ptr(arg));
903 #else
904                 return -ENOIOCTLCMD;
905 #endif
906         }
907 }
908 #endif
909 
910 struct proto raw_prot = {
911         .name              = "RAW",
912         .owner             = THIS_MODULE,
913         .close             = raw_close,
914         .destroy           = raw_destroy,
915         .connect           = ip4_datagram_connect,
916         .disconnect        = udp_disconnect,
917         .ioctl             = raw_ioctl,
918         .init              = raw_init,
919         .setsockopt        = raw_setsockopt,
920         .getsockopt        = raw_getsockopt,
921         .sendmsg           = raw_sendmsg,
922         .recvmsg           = raw_recvmsg,
923         .bind              = raw_bind,
924         .backlog_rcv       = raw_rcv_skb,
925         .release_cb        = ip4_datagram_release_cb,
926         .hash              = raw_hash_sk,
927         .unhash            = raw_unhash_sk,
928         .obj_size          = sizeof(struct raw_sock),
929         .h.raw_hash        = &raw_v4_hashinfo,
930 #ifdef CONFIG_COMPAT
931         .compat_setsockopt = compat_raw_setsockopt,
932         .compat_getsockopt = compat_raw_getsockopt,
933         .compat_ioctl      = compat_raw_ioctl,
934 #endif
935 };
936 
937 #ifdef CONFIG_PROC_FS
938 static struct sock *raw_get_first(struct seq_file *seq)
939 {
940         struct sock *sk;
941         struct raw_iter_state *state = raw_seq_private(seq);
942 
943         for (state->bucket = 0; state->bucket < RAW_HTABLE_SIZE;
944                         ++state->bucket) {
945                 sk_for_each(sk, &state->h->ht[state->bucket])
946                         if (sock_net(sk) == seq_file_net(seq))
947                                 goto found;
948         }
949         sk = NULL;
950 found:
951         return sk;
952 }
953 
954 static struct sock *raw_get_next(struct seq_file *seq, struct sock *sk)
955 {
956         struct raw_iter_state *state = raw_seq_private(seq);
957 
958         do {
959                 sk = sk_next(sk);
960 try_again:
961                 ;
962         } while (sk && sock_net(sk) != seq_file_net(seq));
963 
964         if (!sk && ++state->bucket < RAW_HTABLE_SIZE) {
965                 sk = sk_head(&state->h->ht[state->bucket]);
966                 goto try_again;
967         }
968         return sk;
969 }
970 
971 static struct sock *raw_get_idx(struct seq_file *seq, loff_t pos)
972 {
973         struct sock *sk = raw_get_first(seq);
974 
975         if (sk)
976                 while (pos && (sk = raw_get_next(seq, sk)) != NULL)
977                         --pos;
978         return pos ? NULL : sk;
979 }
980 
981 void *raw_seq_start(struct seq_file *seq, loff_t *pos)
982 {
983         struct raw_iter_state *state = raw_seq_private(seq);
984 
985         read_lock(&state->h->lock);
986         return *pos ? raw_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
987 }
988 EXPORT_SYMBOL_GPL(raw_seq_start);
989 
990 void *raw_seq_next(struct seq_file *seq, void *v, loff_t *pos)
991 {
992         struct sock *sk;
993 
994         if (v == SEQ_START_TOKEN)
995                 sk = raw_get_first(seq);
996         else
997                 sk = raw_get_next(seq, v);
998         ++*pos;
999         return sk;
1000 }
1001 EXPORT_SYMBOL_GPL(raw_seq_next);
1002 
1003 void raw_seq_stop(struct seq_file *seq, void *v)
1004 {
1005         struct raw_iter_state *state = raw_seq_private(seq);
1006 
1007         read_unlock(&state->h->lock);
1008 }
1009 EXPORT_SYMBOL_GPL(raw_seq_stop);
1010 
1011 static void raw_sock_seq_show(struct seq_file *seq, struct sock *sp, int i)
1012 {
1013         struct inet_sock *inet = inet_sk(sp);
1014         __be32 dest = inet->inet_daddr,
1015                src = inet->inet_rcv_saddr;
1016         __u16 destp = 0,
1017               srcp  = inet->inet_num;
1018 
1019         seq_printf(seq, "%4d: %08X:%04X %08X:%04X"
1020                 " %02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %d\n",
1021                 i, src, srcp, dest, destp, sp->sk_state,
1022                 sk_wmem_alloc_get(sp),
1023                 sk_rmem_alloc_get(sp),
1024                 0, 0L, 0,
1025                 from_kuid_munged(seq_user_ns(seq), sock_i_uid(sp)),
1026                 0, sock_i_ino(sp),
1027                 atomic_read(&sp->sk_refcnt), sp, atomic_read(&sp->sk_drops));
1028 }
1029 
1030 static int raw_seq_show(struct seq_file *seq, void *v)
1031 {
1032         if (v == SEQ_START_TOKEN)
1033                 seq_printf(seq, "  sl  local_address rem_address   st tx_queue "
1034                                 "rx_queue tr tm->when retrnsmt   uid  timeout "
1035                                 "inode ref pointer drops\n");
1036         else
1037                 raw_sock_seq_show(seq, v, raw_seq_private(seq)->bucket);
1038         return 0;
1039 }
1040 
1041 static const struct seq_operations raw_seq_ops = {
1042         .start = raw_seq_start,
1043         .next  = raw_seq_next,
1044         .stop  = raw_seq_stop,
1045         .show  = raw_seq_show,
1046 };
1047 
1048 int raw_seq_open(struct inode *ino, struct file *file,
1049                  struct raw_hashinfo *h, const struct seq_operations *ops)
1050 {
1051         int err;
1052         struct raw_iter_state *i;
1053 
1054         err = seq_open_net(ino, file, ops, sizeof(struct raw_iter_state));
1055         if (err < 0)
1056                 return err;
1057 
1058         i = raw_seq_private((struct seq_file *)file->private_data);
1059         i->h = h;
1060         return 0;
1061 }
1062 EXPORT_SYMBOL_GPL(raw_seq_open);
1063 
1064 static int raw_v4_seq_open(struct inode *inode, struct file *file)
1065 {
1066         return raw_seq_open(inode, file, &raw_v4_hashinfo, &raw_seq_ops);
1067 }
1068 
1069 static const struct file_operations raw_seq_fops = {
1070         .owner   = THIS_MODULE,
1071         .open    = raw_v4_seq_open,
1072         .read    = seq_read,
1073         .llseek  = seq_lseek,
1074         .release = seq_release_net,
1075 };
1076 
1077 static __net_init int raw_init_net(struct net *net)
1078 {
1079         if (!proc_create("raw", S_IRUGO, net->proc_net, &raw_seq_fops))
1080                 return -ENOMEM;
1081 
1082         return 0;
1083 }
1084 
1085 static __net_exit void raw_exit_net(struct net *net)
1086 {
1087         remove_proc_entry("raw", net->proc_net);
1088 }
1089 
1090 static __net_initdata struct pernet_operations raw_net_ops = {
1091         .init = raw_init_net,
1092         .exit = raw_exit_net,
1093 };
1094 
1095 int __init raw_proc_init(void)
1096 {
1097         return register_pernet_subsys(&raw_net_ops);
1098 }
1099 
1100 void __init raw_proc_exit(void)
1101 {
1102         unregister_pernet_subsys(&raw_net_ops);
1103 }
1104 #endif /* CONFIG_PROC_FS */
1105 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp