FD.io VPP  v18.04-17-g3a0d853
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 /* Parse an IP4 address %d.%d.%d.%d. */
60 uword
61 unformat_ip4_address (unformat_input_t * input, va_list * args)
62 {
63  u8 *result = va_arg (*args, u8 *);
64  unsigned a[4];
65 
66  if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
67  return 0;
68 
69  if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
70  return 0;
71 
72  result[0] = a[0];
73  result[1] = a[1];
74  result[2] = a[2];
75  result[3] = a[3];
76 
77  return 1;
78 }
79 
80 /* Format an IP4 header. */
81 u8 *
82 format_ip4_header (u8 * s, va_list * args)
83 {
84  ip4_header_t *ip = va_arg (*args, ip4_header_t *);
85  u32 max_header_bytes = va_arg (*args, u32);
86  u32 ip_version, header_bytes;
87  u32 indent;
88 
89  /* Nothing to do. */
90  if (max_header_bytes < sizeof (ip[0]))
91  return format (s, "IP header truncated");
92 
93  indent = format_get_indent (s);
94  indent += 2;
95 
96  ip_version = (ip->ip_version_and_header_length >> 4);
97  header_bytes = (ip->ip_version_and_header_length & 0xf) * sizeof (u32);
98 
99  s = format (s, "%U: %U -> %U",
103 
104  /* Show IP version and header length only with unexpected values. */
105  if (ip_version != 4 || header_bytes != sizeof (ip4_header_t))
106  s = format (s, "\n%Uversion %d, header length %d",
107  format_white_space, indent, ip_version, header_bytes);
108 
109  s = format (s, "\n%Utos 0x%02x, ttl %d, length %d, checksum 0x%04x",
110  format_white_space, indent,
111  ip->tos, ip->ttl,
112  clib_net_to_host_u16 (ip->length),
113  clib_net_to_host_u16 (ip->checksum));
114 
115  /* Check and report invalid checksums. */
116  {
117  u16 c = ip4_header_checksum (ip);
118  if (c != ip->checksum)
119  s = format (s, " (should be 0x%04x)", clib_net_to_host_u16 (c));
120  }
121 
122  {
123  u32 f = clib_net_to_host_u16 (ip->flags_and_fragment_offset);
124  u32 o;
125 
126  s = format (s, "\n%Ufragment id 0x%04x",
127  format_white_space, indent,
128  clib_net_to_host_u16 (ip->fragment_id));
129 
130  /* Fragment offset. */
131  o = 8 * (f & 0x1fff);
132  f ^= o;
133  if (o != 0)
134  s = format (s, " offset %d", o);
135 
136  if (f != 0)
137  {
138  s = format (s, ", flags ");
139 #define _(l) if (f & IP4_HEADER_FLAG_##l) s = format (s, #l);
140  _(MORE_FRAGMENTS);
141  _(DONT_FRAGMENT);
142  _(CONGESTION);
143 #undef _
144  }
145  }
146 
147  /* Recurse into next protocol layer. */
148  if (max_header_bytes != 0 && header_bytes < max_header_bytes)
149  {
150  ip_main_t *im = &ip_main;
152 
153  if (pi && pi->format_header)
154  s = format (s, "\n%U%U",
155  format_white_space, indent - 2, pi->format_header,
156  /* next protocol header */ (void *) ip + header_bytes,
157  max_header_bytes - header_bytes);
158  }
159 
160  return s;
161 }
162 
163 /* Parse an IP4 header. */
164 uword
165 unformat_ip4_header (unformat_input_t * input, va_list * args)
166 {
167  u8 **result = va_arg (*args, u8 **);
168  ip4_header_t *ip;
169  int old_length;
170 
171  /* Allocate space for IP header. */
172  {
173  void *p;
174 
175  old_length = vec_len (*result);
176  vec_add2 (*result, p, sizeof (ip4_header_t));
177  ip = p;
178  }
179 
180  memset (ip, 0, sizeof (ip[0]));
182 
183  if (!unformat (input, "%U: %U -> %U",
187  return 0;
188 
189  /* Parse options. */
190  while (1)
191  {
192  int i, j;
193 
194  if (unformat (input, "tos %U", unformat_vlib_number, &i))
195  ip->tos = i;
196 
197  else if (unformat (input, "ttl %U", unformat_vlib_number, &i))
198  ip->ttl = i;
199 
200  else if (unformat (input, "fragment id %U offset %U",
202  {
203  ip->fragment_id = clib_host_to_net_u16 (i);
205  clib_host_to_net_u16 ((i / 8) & 0x1fff);
206  }
207 
208  /* Flags. */
209  else if (unformat (input, "mf") || unformat (input, "MF"))
211  clib_host_to_net_u16 (IP4_HEADER_FLAG_MORE_FRAGMENTS);
212 
213  else if (unformat (input, "df") || unformat (input, "DF"))
215  clib_host_to_net_u16 (IP4_HEADER_FLAG_DONT_FRAGMENT);
216 
217  else if (unformat (input, "ce") || unformat (input, "CE"))
219  clib_host_to_net_u16 (IP4_HEADER_FLAG_CONGESTION);
220 
221  /* Can't parse input: try next protocol level. */
222  else
223  break;
224  }
225 
226  /* Fill in checksum. */
227  ip->checksum = ip4_header_checksum (ip);
228 
229  /* Recurse into next protocol layer. */
230  {
231  ip_main_t *im = &ip_main;
233 
234  if (pi && pi->unformat_header)
235  {
236  if (!unformat_user (input, pi->unformat_header, result))
237  return 0;
238 
239  /* Result may have moved. */
240  ip = (void *) *result + old_length;
241  }
242  }
243 
244  /* Fill in IP length. */
245  ip->length = clib_host_to_net_u16 (vec_len (*result) - old_length);
246 
247  return 1;
248 }
249 
250 /*
251  * fd.io coding-style-patch-verification: ON
252  *
253  * Local Variables:
254  * eval: (c-set-style "gnu")
255  * End:
256  */
format_function_t format_ip_protocol
Definition: format.h:45
unformat_function_t unformat_ip_protocol
Definition: format.h:46
a
Definition: bitmap.h:516
ip4_address_t src_address
Definition: ip4_packet.h:164
u8 * format_ip4_header(u8 *s, va_list *args)
Definition: ip4_format.c:82
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
Definition: vec.h:559
int i
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:983
static u32 format_get_indent(u8 *s)
Definition: format.h:72
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
u16 flags_and_fragment_offset
Definition: ip4_packet.h:145
Definition: ip.h:109
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:165
ip4_address_t dst_address
Definition: ip4_packet.h:164
u8 * format_white_space(u8 *s, va_list *va)
Definition: std-formats.c:113
static ip_protocol_info_t * ip_get_protocol_info(ip_main_t *im, u32 protocol)
Definition: ip.h:136
format_function_t * format_header
Definition: ip.h:81
struct _unformat_input_t unformat_input_t
#define IP4_HEADER_FLAG_MORE_FRAGMENTS
Definition: ip4_packet.h:146
svmdb_client_t * c
ip_main_t ip_main
Definition: ip_init.c:42
uword unformat_ip4_address(unformat_input_t *input, va_list *args)
Definition: ip4_format.c:61
unsigned int u32
Definition: types.h:88
unformat_function_t * unformat_header
Definition: ip.h:84
u8 * format_ip4_address(u8 *s, va_list *args)
Definition: ip4_format.c:44
#define IP4_HEADER_FLAG_CONGESTION
Definition: ip4_packet.h:148
u64 uword
Definition: types.h:112
unsigned short u16
Definition: types.h:57
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
unsigned char u8
Definition: types.h:56
#define IP4_VERSION_AND_HEADER_LENGTH_NO_OPTIONS
Definition: ip4_packet.h:188
#define IP4_HEADER_FLAG_DONT_FRAGMENT
Definition: ip4_packet.h:147
u8 ip_version_and_header_length
Definition: ip4_packet.h:132
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:239
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972