LCOV - code coverage report
Current view: top level - include/net - inet_sock.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 5 5 100.0 %
Date: 2017-01-25 Functions: 0 0 -

          Line data    Source code
       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             :  *              Definitions for inet_sock
       7             :  *
       8             :  * Authors:     Many, reorganised here by
       9             :  *              Arnaldo Carvalho de Melo <acme@mandriva.com>
      10             :  *
      11             :  *              This program is free software; you can redistribute it and/or
      12             :  *              modify it under the terms of the GNU General Public License
      13             :  *              as published by the Free Software Foundation; either version
      14             :  *              2 of the License, or (at your option) any later version.
      15             :  */
      16             : #ifndef _INET_SOCK_H
      17             : #define _INET_SOCK_H
      18             : 
      19             : 
      20             : #include <linux/kmemcheck.h>
      21             : #include <linux/string.h>
      22             : #include <linux/types.h>
      23             : #include <linux/jhash.h>
      24             : 
      25             : #include <net/flow.h>
      26             : #include <net/sock.h>
      27             : #include <net/request_sock.h>
      28             : #include <net/netns/hash.h>
      29             : 
      30             : /** struct ip_options - IP Options
      31             :  *
      32             :  * @faddr - Saved first hop address
      33             :  * @is_data - Options in __data, rather than skb
      34             :  * @is_strictroute - Strict source route
      35             :  * @srr_is_hit - Packet destination addr was our one
      36             :  * @is_changed - IP checksum more not valid
      37             :  * @rr_needaddr - Need to record addr of outgoing dev
      38             :  * @ts_needtime - Need to record timestamp
      39             :  * @ts_needaddr - Need to record addr of outgoing dev
      40             :  */
      41             : struct ip_options {
      42             :         __be32          faddr;
      43             :         unsigned char   optlen;
      44             :         unsigned char   srr;
      45             :         unsigned char   rr;
      46             :         unsigned char   ts;
      47             :         unsigned char   is_strictroute:1,
      48             :                         srr_is_hit:1,
      49             :                         is_changed:1,
      50             :                         rr_needaddr:1,
      51             :                         ts_needtime:1,
      52             :                         ts_needaddr:1;
      53             :         unsigned char   router_alert;
      54             :         unsigned char   cipso;
      55             :         unsigned char   __pad2;
      56             :         unsigned char   __data[0];
      57             : };
      58             : 
      59             : #define optlength(opt) (sizeof(struct ip_options) + opt->optlen)
      60             : 
      61             : struct inet_request_sock {
      62             :         struct request_sock     req;
      63             : #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
      64             :         u16                     inet6_rsk_offset;
      65             : #endif
      66             :         __be16                  loc_port;
      67             :         __be32                  loc_addr;
      68             :         __be32                  rmt_addr;
      69             :         __be16                  rmt_port;
      70             :         kmemcheck_bitfield_begin(flags);
      71             :         u16                     snd_wscale : 4,
      72             :                                 rcv_wscale : 4,
      73             :                                 tstamp_ok  : 1,
      74             :                                 sack_ok    : 1,
      75             :                                 wscale_ok  : 1,
      76             :                                 ecn_ok     : 1,
      77             :                                 acked      : 1,
      78             :                                 no_srccheck: 1;
      79             :         kmemcheck_bitfield_end(flags);
      80             :         struct ip_options       *opt;
      81             : };
      82             : 
      83             : static inline struct inet_request_sock *inet_rsk(const struct request_sock *sk)
      84             : {
      85             :         return (struct inet_request_sock *)sk;
      86             : }
      87           1 : 
      88             : struct ip_mc_socklist;
      89           2 : struct ipv6_pinfo;
      90             : struct rtable;
      91             : 
      92             : /** struct inet_sock - representation of INET sockets
      93             :  *
      94             :  * @sk - ancestor class
      95             :  * @pinet6 - pointer to IPv6 control block
      96             :  * @inet_daddr - Foreign IPv4 addr
      97             :  * @inet_rcv_saddr - Bound local IPv4 addr
      98             :  * @inet_dport - Destination port
      99             :  * @inet_num - Local port
     100             :  * @inet_saddr - Sending source
     101             :  * @uc_ttl - Unicast TTL
     102             :  * @inet_sport - Source port
     103             :  * @inet_id - ID counter for DF pkts
     104             :  * @tos - TOS
     105             :  * @mc_ttl - Multicasting TTL
     106             :  * @is_icsk - is this an inet_connection_sock?
     107             :  * @mc_index - Multicast device index
     108             :  * @mc_list - Group array
     109             :  * @cork - info to build ip hdr on each ip frag while socket is corked
     110             :  */
     111             : struct inet_sock {
     112             :         /* sk and pinet6 has to be the first two members of inet_sock */
     113             :         struct sock             sk;
     114             : #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
     115             :         struct ipv6_pinfo       *pinet6;
     116             : #endif
     117             :         /* Socket demultiplex comparisons on incoming packets. */
     118             :         __be32                  inet_daddr;
     119             :         __be32                  inet_rcv_saddr;
     120             :         __be16                  inet_dport;
     121             :         __u16                   inet_num;
     122             :         __be32                  inet_saddr;
     123             :         __s16                   uc_ttl;
     124             :         __u16                   cmsg_flags;
     125             :         struct ip_options       *opt;
     126             :         __be16                  inet_sport;
     127             :         __u16                   inet_id;
     128             :         __u8                    tos;
     129             :         __u8                    mc_ttl;
     130             :         __u8                    pmtudisc;
     131             :         __u8                    recverr:1,
     132             :                                 is_icsk:1,
     133             :                                 freebind:1,
     134             :                                 hdrincl:1,
     135             :                                 mc_loop:1,
     136             :                                 transparent:1,
     137             :                                 mc_all:1;
     138             :         int                     mc_index;
     139             :         __be32                  mc_addr;
     140             :         struct ip_mc_socklist   *mc_list;
     141             :         struct {
     142             :                 unsigned int            flags;
     143             :                 unsigned int            fragsize;
     144             :                 struct ip_options       *opt;
     145             :                 struct dst_entry        *dst;
     146             :                 int                     length; /* Total length of all frames */
     147             :                 __be32                  addr;
     148             :                 struct flowi            fl;
     149             :         } cork;
     150             : };
     151             : 
     152             : #define IPCORK_OPT      1       /* ip-options has been held in ipcork.opt */
     153             : #define IPCORK_ALLFRAG  2       /* always fragment (for ipv6 for now) */
     154             : 
     155             : static inline struct inet_sock *inet_sk(const struct sock *sk)
     156             : {
     157             :         return (struct inet_sock *)sk;
     158             : }
     159             : 
     160             : static inline void __inet_sk_copy_descendant(struct sock *sk_to,
     161             :                                              const struct sock *sk_from,
     162             :                                              const int ancestor_size)
     163             : {
     164             :         memcpy(inet_sk(sk_to) + 1, inet_sk(sk_from) + 1,
     165             :                sk_from->sk_prot->obj_size - ancestor_size);
     166             : }
     167             : #if !(defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE))
     168             : static inline void inet_sk_copy_descendant(struct sock *sk_to,
     169             :                                            const struct sock *sk_from)
     170             : {
     171             :         __inet_sk_copy_descendant(sk_to, sk_from, sizeof(struct inet_sock));
     172             : }
     173             : #endif
     174             : 
     175             : extern int inet_sk_rebuild_header(struct sock *sk);
     176             : 
     177             : extern u32 inet_ehash_secret;
     178             : extern void build_ehash_secret(void);
     179             : 
     180             : static inline unsigned int inet_ehashfn(struct net *net,
     181             :                                         const __be32 laddr, const __u16 lport,
     182             :                                         const __be32 faddr, const __be16 fport)
     183             : {
     184             :         return jhash_3words((__force __u32) laddr,
     185             :                             (__force __u32) faddr,
     186             :                             ((__u32) lport) << 16 | (__force __u32)fport,
     187             :                             inet_ehash_secret + net_hash_mix(net));
     188             : }
     189             : 
     190             : static inline int inet_sk_ehashfn(const struct sock *sk)
     191             : {
     192             :         const struct inet_sock *inet = inet_sk(sk);
     193             :         const __be32 laddr = inet->inet_rcv_saddr;
     194             :         const __u16 lport = inet->inet_num;
     195             :         const __be32 faddr = inet->inet_daddr;
     196             :         const __be16 fport = inet->inet_dport;
     197             :         struct net *net = sock_net(sk);
     198             : 
     199             :         return inet_ehashfn(net, laddr, lport, faddr, fport);
     200             : }
     201             : 
     202             : static inline struct request_sock *inet_reqsk_alloc(struct request_sock_ops *ops)
     203             : {
     204             :         struct request_sock *req = reqsk_alloc(ops);
     205             :         struct inet_request_sock *ireq = inet_rsk(req);
     206             : 
     207             :         if (req != NULL) {
     208             :                 kmemcheck_annotate_bitfield(ireq, flags);
     209             :                 ireq->opt = NULL;
     210             :         }
     211             : 
     212             :         return req;
     213             : }
     214             : 
     215             : static inline __u8 inet_sk_flowi_flags(const struct sock *sk)
     216             : {
     217             :         return inet_sk(sk)->transparent ? FLOWI_FLAG_ANYSRC : 0;
     218             : }
     219           1 : 
     220           1 : #endif  /* _INET_SOCK_H */

Generated by: LCOV version 1.10