FD.io VPP  v20.09-64-g4f7b92f0a
Vector Packet Processing
ip4_format.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  * ip/ip4_format.c: ip4 formatting
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 
42 /* Format an IP4 address. */
43 u8 *
44 format_ip4_address (u8 * s, va_list * args)
45 {
46  u8 *a = va_arg (*args, u8 *);
47  return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
48 }
49 
50 /* Format an IP4 route destination and length. */
51 u8 *
52 format_ip4_address_and_length (u8 * s, va_list * args)
53 {
54  u8 *a = va_arg (*args, u8 *);
55  u8 l = va_arg (*args, u32);
56  return format (s, "%U/%d", format_ip4_address, a, l);
57 }
58 
59 u8 *
60 format_ip4_address_and_mask (u8 * s, va_list * args)
61 {
62  ip4_address_and_mask_t *am = va_arg (*args, ip4_address_and_mask_t *);
63 
64  if (am->addr.as_u32 == 0 && am->mask.as_u32 == 0)
65  return format (s, "any");
66 
67  if (am->mask.as_u32 == ~0)
68  return format (s, "%U", format_ip4_address, &am->addr);
69 
70  return format (s, "%U/%U", format_ip4_address, &am->addr,
71  format_ip4_address, &am->mask);
72 }
73 
74 /* Parse an IP4 address %d.%d.%d.%d. */
75 uword
76 unformat_ip4_address (unformat_input_t * input, va_list * args)
77 {
78  u8 *result = va_arg (*args, u8 *);
79  unsigned a[4];
80 
81  if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
82  return 0;
83 
84  if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
85  return 0;
86 
87  result[0] = a[0];
88  result[1] = a[1];
89  result[2] = a[2];
90  result[3] = a[3];
91 
92  return 1;
93 }
94 
95 uword
97 {
98  ip4_address_and_mask_t *am = va_arg (*args, ip4_address_and_mask_t *);
99  u32 addr = 0, mask = 0;
100 
101  if (unformat (input, "any"))
102  ;
103  else if (unformat (input, "%U/%U", unformat_ip4_address, &addr,
105  ;
106  else if (unformat (input, "%U", unformat_ip4_address, &addr))
107  mask = ~0;
108  else
109  return 0;
110 
111  am->addr.as_u32 = addr;
112  am->mask.as_u32 = mask;
113  return 1;
114 }
115 
116 /* Format an IP4 header. */
117 u8 *
118 format_ip4_header (u8 * s, va_list * args)
119 {
120  ip4_header_t *ip = va_arg (*args, ip4_header_t *);
121  u32 max_header_bytes = va_arg (*args, u32);
122  u32 ip_version, header_bytes;
123  u32 indent;
124 
125  /* Nothing to do. */
126  if (max_header_bytes < sizeof (ip[0]))
127  return format (s, "IP header truncated");
128 
129  indent = format_get_indent (s);
130  indent += 2;
131 
132  ip_version = (ip->ip_version_and_header_length >> 4);
133  header_bytes = (ip->ip_version_and_header_length & 0xf) * sizeof (u32);
134 
135  s = format (s, "%U: %U -> %U",
139 
140  /* Show IP version and header length only with unexpected values. */
141  if (ip_version != 4 || header_bytes != sizeof (ip4_header_t))
142  s = format (s, "\n%Uversion %d, header length %d",
143  format_white_space, indent, ip_version, header_bytes);
144 
145  s = format (s, "\n%Utos 0x%02x, ttl %d, length %d, checksum 0x%04x",
146  format_white_space, indent,
147  ip->tos, ip->ttl,
148  clib_net_to_host_u16 (ip->length),
149  clib_net_to_host_u16 (ip->checksum));
150 
151  /* Check and report invalid checksums. */
152  {
154  s =
155  format (s, " (should be 0x%04x)",
156  clib_net_to_host_u16 (ip4_header_checksum (ip)));
157  }
158 
159  s = format (s, " dscp %U ecn %U",
162 
163  {
164  u32 f = clib_net_to_host_u16 (ip->flags_and_fragment_offset);
165  u32 o;
166 
167  s = format (s, "\n%Ufragment id 0x%04x",
168  format_white_space, indent,
169  clib_net_to_host_u16 (ip->fragment_id));
170 
171  /* Fragment offset. */
172  o = 8 * (f & 0x1fff);
173  f ^= f & 0x1fff;
174  if (o != 0)
175  s = format (s, " offset %d", o);
176 
177  if (f != 0)
178  {
179  s = format (s, ", flags ");
180 #define _(l) if (f & IP4_HEADER_FLAG_##l) s = format (s, #l);
181  _(MORE_FRAGMENTS);
182  _(DONT_FRAGMENT);
183  _(CONGESTION);
184 #undef _
185  }
186  /* Fragment packet but not the first. */
187  if (o != 0)
188  return s;
189  }
190 
191  /* Recurse into next protocol layer. */
192  if (max_header_bytes != 0 && header_bytes < max_header_bytes)
193  {
194  ip_main_t *im = &ip_main;
196 
197  if (pi && pi->format_header)
198  s = format (s, "\n%U%U",
199  format_white_space, indent - 2, pi->format_header,
200  /* next protocol header */ (void *) ip + header_bytes,
201  max_header_bytes - header_bytes);
202  }
203 
204  return s;
205 }
206 
207 /* Parse an IP4 header. */
208 uword
209 unformat_ip4_header (unformat_input_t * input, va_list * args)
210 {
211  u8 **result = va_arg (*args, u8 **);
212  ip4_header_t *ip;
213  int old_length;
214 
215  /* Allocate space for IP header. */
216  {
217  void *p;
218 
219  old_length = vec_len (*result);
220  vec_add2 (*result, p, sizeof (ip4_header_t));
221  ip = p;
222  }
223 
224  clib_memset (ip, 0, sizeof (ip[0]));
226 
227  if (!unformat (input, "%U: %U -> %U",
231  return 0;
232 
233  /* Parse options. */
234  while (1)
235  {
236  int i, j;
237 
238  if (unformat (input, "tos %U", unformat_vlib_number, &i))
239  ip->tos = i;
240 
241  else if (unformat (input, "ttl %U", unformat_vlib_number, &i))
242  ip->ttl = i;
243 
244  else if (unformat (input, "fragment id %U offset %U",
246  {
247  ip->fragment_id = clib_host_to_net_u16 (i);
249  clib_host_to_net_u16 ((i / 8) & 0x1fff);
250  }
251 
252  /* Flags. */
253  else if (unformat (input, "mf") || unformat (input, "MF"))
255  clib_host_to_net_u16 (IP4_HEADER_FLAG_MORE_FRAGMENTS);
256 
257  else if (unformat (input, "df") || unformat (input, "DF"))
259  clib_host_to_net_u16 (IP4_HEADER_FLAG_DONT_FRAGMENT);
260 
261  else if (unformat (input, "ce") || unformat (input, "CE"))
263  clib_host_to_net_u16 (IP4_HEADER_FLAG_CONGESTION);
264 
265  /* Can't parse input: try next protocol level. */
266  else
267  break;
268  }
269 
270  /* Fill in checksum. */
271  ip->checksum = ip4_header_checksum (ip);
272 
273  /* Recurse into next protocol layer. */
274  {
275  ip_main_t *im = &ip_main;
277 
278  if (pi && pi->unformat_header)
279  {
280  if (!unformat_user (input, pi->unformat_header, result))
281  return 0;
282 
283  /* Result may have moved. */
284  ip = (void *) *result + old_length;
285  }
286  }
287 
288  /* Fill in IP length. */
289  ip->length = clib_host_to_net_u16 (vec_len (*result) - old_length);
290 
291  return 1;
292 }
293 
294 /*
295  * fd.io coding-style-patch-verification: ON
296  *
297  * Local Variables:
298  * eval: (c-set-style "gnu")
299  * End:
300  */
format_function_t format_ip_protocol
Definition: format.h:45
unformat_function_t unformat_ip_protocol
Definition: format.h:46
uword unformat_ip4_address_and_mask(unformat_input_t *input, va_list *args)
Definition: ip4_format.c:96
a
Definition: bitmap.h:538
ip4_address_t src_address
Definition: ip4_packet.h:125
u8 * format_ip4_header(u8 *s, va_list *args)
Definition: ip4_format.c:118
static ip_dscp_t ip4_header_get_dscp(const ip4_header_t *ip4)
Definition: ip4_packet.h:351
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
Definition: vec.h:630
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:989
static u32 format_get_indent(u8 *s)
Definition: format.h:72
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
u16 flags_and_fragment_offset
Definition: ip4_packet.h:106
Definition: ip.h:107
u16 mask
Definition: flow_types.api:52
vhost_vring_addr_t addr
Definition: vhost_user.h:111
unsigned char u8
Definition: types.h:56
uword unformat_vlib_number(unformat_input_t *input, va_list *args)
Definition: format.c:148
uword unformat_ip4_header(unformat_input_t *input, va_list *args)
Definition: ip4_format.c:209
u8 * format_ip4_address_and_mask(u8 *s, va_list *args)
Definition: ip4_format.c:60
static uword ip4_header_checksum_is_valid(ip4_header_t *i)
Definition: ip4_packet.h:384
ip4_address_t dst_address
Definition: ip4_packet.h:125
u8 * format_white_space(u8 *s, va_list *va)
Definition: std-formats.c:129
unsigned int u32
Definition: types.h:88
u8 * format_ip_dscp(u8 *s, va_list *va)
Definition: ip.c:142
static ip_protocol_info_t * ip_get_protocol_info(ip_main_t *im, u32 protocol)
Definition: ip.h:134
format_function_t * format_header
Definition: ip.h:79
struct _unformat_input_t unformat_input_t
#define IP4_HEADER_FLAG_MORE_FRAGMENTS
Definition: ip4_packet.h:107
u8 * format_ip_ecn(u8 *s, va_list *va)
Definition: ip.c:159
ip_main_t ip_main
Definition: ip_init.c:42
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:317
uword unformat_ip4_address(unformat_input_t *input, va_list *args)
Definition: ip4_format.c:76
ip4_address_t addr
Definition: ip4_packet.h:84
ip_dscp_t tos
Definition: ip4_packet.h:96
unformat_function_t * unformat_header
Definition: ip.h:82
u8 * format_ip4_address(u8 *s, va_list *args)
Definition: ip4_format.c:44
#define IP4_HEADER_FLAG_CONGESTION
Definition: ip4_packet.h:109
vl_api_address_t ip
Definition: l2.api:501
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
u64 uword
Definition: types.h:112
static ip_ecn_t ip4_header_get_ecn(const ip4_header_t *ip4)
Definition: ip4_packet.h:357
ip4_address_t mask
Definition: ip4_packet.h:84
#define IP4_VERSION_AND_HEADER_LENGTH_NO_OPTIONS
Definition: ip4_packet.h:149
#define IP4_HEADER_FLAG_DONT_FRAGMENT
Definition: ip4_packet.h:108
u8 ip_version_and_header_length
Definition: ip4_packet.h:93
u8 * format_ip4_address_and_length(u8 *s, va_list *args)
Definition: ip4_format.c:52
static u16 ip4_header_checksum(ip4_header_t *i)
Definition: ip4_packet.h:314
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978