FD.io VPP  v16.09
Vector Packet Processing
ip_checksum.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015 Cisco and/or its affiliates.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 /*
16  * ip4/ip_checksum.c: ip/tcp/udp checksums
17  *
18  * Copyright (c) 2008 Eliot Dresselhaus
19  *
20  * Permission is hereby granted, free of charge, to any person obtaining
21  * a copy of this software and associated documentation files (the
22  * "Software"), to deal in the Software without restriction, including
23  * without limitation the rights to use, copy, modify, merge, publish,
24  * distribute, sublicense, and/or sell copies of the Software, and to
25  * permit persons to whom the Software is furnished to do so, subject to
26  * the following conditions:
27  *
28  * The above copyright notice and this permission notice shall be
29  * included in all copies or substantial portions of the Software.
30  *
31  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
32  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
33  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
34  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
35  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
36  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
37  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
38  */
39 
40 #include <vnet/ip/ip.h>
41 
43 ip_incremental_checksum (ip_csum_t sum, void * _data, uword n_bytes)
44 {
45  uword data = pointer_to_uword (_data);
46  ip_csum_t sum0, sum1;
47 
48  sum0 = 0;
49  sum1 = sum;
50 
51  /* Align data pointer to 64 bits. */
52 #define _(t) \
53 do { \
54  if (n_bytes >= sizeof (t) \
55  && sizeof (t) < sizeof (ip_csum_t) \
56  && (data % (2 * sizeof (t))) != 0) \
57  { \
58  sum0 += * uword_to_pointer (data, t *); \
59  data += sizeof (t); \
60  n_bytes -= sizeof (t); \
61  } \
62 } while (0)
63 
64  _ (u8);
65  _ (u16);
66  if (BITS (ip_csum_t) > 32)
67  _ (u32);
68 
69 #undef _
70 
71  {
72  ip_csum_t * d = uword_to_pointer (data, ip_csum_t *);
73 
74  while (n_bytes >= 2 * sizeof (d[0]))
75  {
76  sum0 = ip_csum_with_carry (sum0, d[0]);
77  sum1 = ip_csum_with_carry (sum1, d[1]);
78  d += 2;
79  n_bytes -= 2 * sizeof (d[0]);
80  }
81 
82  data = pointer_to_uword (d);
83  }
84 
85 #define _(t) \
86 do { \
87  if (n_bytes >= sizeof (t) && sizeof (t) <= sizeof (ip_csum_t)) \
88  { \
89  sum0 = ip_csum_with_carry (sum0, * uword_to_pointer (data, t *)); \
90  data += sizeof (t); \
91  n_bytes -= sizeof (t); \
92  } \
93 } while (0)
94 
95  if (BITS (ip_csum_t) > 32)
96  _ (u64);
97  _ (u32);
98  _ (u16);
99  _ (u8);
100 
101 #undef _
102 
103  /* Combine even and odd sums. */
104  sum0 = ip_csum_with_carry (sum0, sum1);
105 
106  return sum0;
107 }
108 
109 ip_csum_t
110 ip_csum_and_memcpy (ip_csum_t sum, void * dst, void * src, uword n_bytes)
111 {
112  uword n_left;
113  ip_csum_t sum0 = sum, sum1;
114  n_left = n_bytes;
115 
116  if (n_left && (pointer_to_uword (dst) & sizeof(u8)))
117  {
118  u8 * d8, val;
119 
120  d8 = dst;
121  val = ((u8 *)src)[0];
122  d8[0] = val;
123  dst += 1;
124  src += 1;
125  n_left -= 1;
126  sum0 = ip_csum_with_carry (sum0, val << (8 * CLIB_ARCH_IS_LITTLE_ENDIAN));
127  }
128 
129  while ((n_left >= sizeof (u16)) && (pointer_to_uword (dst) & (sizeof (sum) - sizeof (u16))))
130  {
131  u16 * d16, * s16;
132 
133  d16 = dst;
134  s16 = src;
135 
136  d16[0] = clib_mem_unaligned (&s16[0], u16);
137 
138  sum0 = ip_csum_with_carry (sum0, d16[0]);
139  dst += sizeof (u16);
140  src += sizeof (u16);
141  n_left -= sizeof (u16);
142  }
143 
144  sum1 = 0;
145  while (n_left >= 2 * sizeof (sum))
146  {
147  ip_csum_t dst0, dst1;
148  ip_csum_t *dst_even, *src_even;
149 
150  dst_even = dst;
151  src_even = src;
152  dst0 = clib_mem_unaligned (&src_even[0], ip_csum_t);
153  dst1 = clib_mem_unaligned (&src_even[1], ip_csum_t);
154 
155  dst_even[0] = dst0;
156  dst_even[1] = dst1;
157 
158  dst += 2 * sizeof(dst_even[0]);
159  src += 2 * sizeof(dst_even[0]);
160  n_left -= 2 * sizeof (dst_even[0]);
161 
162  sum0 = ip_csum_with_carry (sum0, dst0);
163  sum1 = ip_csum_with_carry (sum1, dst1);
164  }
165 
166  sum0 = ip_csum_with_carry (sum0, sum1);
167  while (n_left >= 1 * sizeof (sum))
168  {
169  ip_csum_t dst0, *dst_even, *src_even;
170 
171  dst_even = dst;
172  src_even = src;
173 
174  dst0 = clib_mem_unaligned (&src_even[0], ip_csum_t);
175 
176  dst_even[0] = dst0;
177 
178  dst += 1 * sizeof(sum);
179  src += 1 * sizeof(sum);
180  n_left -= 1 * sizeof (sum);
181 
182  sum0 = ip_csum_with_carry (sum0, dst0);
183  }
184 
185  while (n_left >= sizeof (u16))
186  {
187  u16 dst0, *dst_short, *src_short;
188 
189  dst_short = dst;
190  src_short = src;
191 
192  dst0 = clib_mem_unaligned (&src_short[0], u16);
193 
194  dst_short[0] = dst0;
195 
196  sum0 = ip_csum_with_carry (sum0, dst_short[0]);
197  dst += 1 * sizeof (dst0);
198  src += 1 * sizeof (dst0);
199  n_left -= 1 * sizeof (dst0);
200 
201  }
202 
203  if (n_left == 1)
204  {
205  u8 * d8, * s8, val;
206 
207  d8 = dst;
208  s8 = src;
209 
210  d8[0] = val = s8[0];
211  d8 += 1;
212  s8 += 1;
213  n_left -= 1;
214  sum0 = ip_csum_with_carry (sum0, val << (8 * CLIB_ARCH_IS_BIG_ENDIAN));
215  }
216 
217  return sum0;
218 }
#define CLIB_ARCH_IS_LITTLE_ENDIAN
Definition: byte_order.h:45
uword ip_csum_t
Definition: ip_packet.h:86
static ip_csum_t ip_csum_with_carry(ip_csum_t sum, ip_csum_t x)
Definition: ip_packet.h:89
ip_csum_t ip_incremental_checksum(ip_csum_t sum, void *_data, uword n_bytes)
Definition: ip_checksum.c:43
ip_csum_t ip_csum_and_memcpy(ip_csum_t sum, void *dst, void *src, uword n_bytes)
Definition: ip_checksum.c:110
unsigned long u64
Definition: types.h:89
static uword pointer_to_uword(const void *p)
Definition: types.h:131
#define uword_to_pointer(u, type)
Definition: types.h:136
unsigned int u32
Definition: types.h:88
u64 uword
Definition: types.h:112
#define CLIB_ARCH_IS_BIG_ENDIAN
Definition: byte_order.h:44
unsigned short u16
Definition: types.h:57
unsigned char u8
Definition: types.h:56
#define clib_mem_unaligned(pointer, type)
Definition: types.h:155
#define BITS(x)
Definition: clib.h:58