FD.io VPP  v21.06
Vector Packet Processing
pnat_test_stubs.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2021 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 #ifndef included_pnat_test_stubs_h
17 #define included_pnat_test_stubs_h
18 
19 void os_panic(void) {}
20 void os_exit(int code) {}
22 #include <vpp/stats/stat_segment.h>
24  stat_segment_update_fn update_fn,
25  u32 index) {
26  return 0;
27 };
28 #include <vnet/feature/feature.h>
31 
32 /* Format an IP4 address. */
33 u8 *format_ip4_address(u8 *s, va_list *args) {
34  u8 *a = va_arg(*args, u8 *);
35  return format(s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
36 }
37 
38 u8 *format_pnat_match_tuple(u8 *s, va_list *args) { return 0; }
39 u8 *format_pnat_rewrite_tuple(u8 *s, va_list *args) { return 0; }
40 
41 vlib_error_desc_t pnat_error_counters[10];
42 
44  return 0;
45 }
47  int is_enable) {
48  return 0;
49 }
50 int vnet_feature_enable_disable(const char *arc_name, const char *node_name,
51  u32 sw_if_index, int enable_disable,
52  void *feature_config,
53  u32 n_feature_config_bytes) {
54  return 0;
55 }
56 vnet_main_t *vnet_get_main(void) { return 0; }
57 
58 /* Compute TCP/UDP/ICMP4 checksum in software. */
60  ip4_header_t *ip0) {
61  ip_csum_t sum0;
62  u32 ip_header_length, payload_length_host_byte_order;
63 
64  /* Initialize checksum with ip header. */
65  ip_header_length = ip4_header_bytes(ip0);
66  payload_length_host_byte_order =
67  clib_net_to_host_u16(ip0->length) - ip_header_length;
68  sum0 = clib_host_to_net_u32(payload_length_host_byte_order +
69  (ip0->protocol << 16));
70 
71  if (BITS(uword) == 32) {
72  sum0 = ip_csum_with_carry(sum0,
74  sum0 = ip_csum_with_carry(sum0,
76  } else
77  sum0 = ip_csum_with_carry(sum0,
79  return ip_calculate_l4_checksum(vm, p0, sum0,
80  payload_length_host_byte_order, (u8 *)ip0,
81  ip_header_length, NULL);
82 }
83 
86  udp_header_t *udp0;
87  u16 sum16;
88 
89  ASSERT(ip0->protocol == IP_PROTOCOL_TCP ||
90  ip0->protocol == IP_PROTOCOL_UDP);
91 
92  udp0 = (void *)(ip0 + 1);
93  if (ip0->protocol == IP_PROTOCOL_UDP && udp0->checksum == 0) {
94  p0->flags |= (VNET_BUFFER_F_L4_CHECKSUM_COMPUTED |
95  VNET_BUFFER_F_L4_CHECKSUM_CORRECT);
96  return p0->flags;
97  }
98 
99  sum16 = ip4_tcp_udp_compute_checksum(vm, p0, ip0);
100 
101  p0->flags |= (VNET_BUFFER_F_L4_CHECKSUM_COMPUTED |
102  ((sum16 == 0) << VNET_BUFFER_F_LOG2_L4_CHECKSUM_CORRECT));
103 
104  return p0->flags;
105 }
106 u8 *format_tcp_header(u8 *s, va_list *args) {
107  tcp_header_t *tcp = va_arg(*args, tcp_header_t *);
108  u32 max_header_bytes = va_arg(*args, u32);
109  u32 header_bytes;
110  u32 indent;
111 
112  /* Nothing to do. */
113  if (max_header_bytes < sizeof(tcp[0]))
114  return format(s, "TCP header truncated");
115 
116  indent = format_get_indent(s);
117  indent += 2;
118  header_bytes = tcp_header_bytes(tcp);
119 
120  s = format(s, "TCP: %d -> %d", clib_net_to_host_u16(tcp->src),
121  clib_net_to_host_u16(tcp->dst));
122 
123  s = format(s, "\n%Useq. 0x%08x ack 0x%08x", format_white_space, indent,
124  clib_net_to_host_u32(tcp->seq_number),
125  clib_net_to_host_u32(tcp->ack_number));
126 
127  s = format(s, "\n%Utcp header: %d bytes", format_white_space, indent,
128  tcp->flags, header_bytes);
129 
130  s = format(s, "\n%Uwindow %d, checksum 0x%04x", format_white_space, indent,
131  clib_net_to_host_u16(tcp->window),
132  clib_net_to_host_u16(tcp->checksum));
133  return s;
134 }
135 /* Format UDP header. */
136 u8 *format_udp_header(u8 *s, va_list *args) {
137  udp_header_t *udp = va_arg(*args, udp_header_t *);
138  u32 max_header_bytes = va_arg(*args, u32);
139  u32 indent;
140 
141  /* Nothing to do. */
142  if (max_header_bytes < sizeof(udp[0]))
143  return format(s, "UDP header truncated");
144 
145  indent = format_get_indent(s);
146  indent += 2;
147 
148  s = format(s, "UDP: %d -> %d", clib_net_to_host_u16(udp->src_port),
149  clib_net_to_host_u16(udp->dst_port));
150 
151  s = format(s, "\n%Ulength %d, checksum 0x%04x", format_white_space, indent,
152  clib_net_to_host_u16(udp->length),
153  clib_net_to_host_u16(udp->checksum));
154 
155  return s;
156 }
157 
158 /* Format an IP4 header. */
159 u8 *format_ip4_header(u8 *s, va_list *args) {
160  ip4_header_t *ip = va_arg(*args, ip4_header_t *);
161  u32 max_header_bytes = va_arg(*args, u32);
162  u32 ip_version, header_bytes;
163  u32 indent;
164 
165  /* Nothing to do. */
166  if (max_header_bytes < sizeof(ip[0]))
167  return format(s, "IP header truncated");
168 
169  indent = format_get_indent(s);
170  indent += 2;
171 
172  ip_version = (ip->ip_version_and_header_length >> 4);
173  header_bytes = (ip->ip_version_and_header_length & 0xf) * sizeof(u32);
174 
175  s = format(s, "%d: %U -> %U", ip->protocol, format_ip4_address,
177 
178  /* Show IP version and header length only with unexpected values. */
179  if (ip_version != 4 || header_bytes != sizeof(ip4_header_t))
180  s = format(s, "\n%Uversion %d, header length %d", format_white_space,
181  indent, ip_version, header_bytes);
182 
183  s = format(s, "\n%Utos 0x%02x, ttl %d, length %d, checksum 0x%04x",
184  format_white_space, indent, ip->tos, ip->ttl,
185  clib_net_to_host_u16(ip->length),
186  clib_net_to_host_u16(ip->checksum));
187 
188  /* Check and report invalid checksums. */
189  {
191  s = format(s, " (should be 0x%04x)",
192  clib_net_to_host_u16(ip4_header_checksum(ip)));
193  }
194 
195  {
196  u32 f = clib_net_to_host_u16(ip->flags_and_fragment_offset);
197  u32 o;
198 
199  s = format(s, "\n%Ufragment id 0x%04x", format_white_space, indent,
200  clib_net_to_host_u16(ip->fragment_id));
201 
202  /* Fragment offset. */
203  o = 8 * (f & 0x1fff);
204  f ^= f & 0x1fff;
205  if (o != 0)
206  s = format(s, " offset %d", o);
207 
208  if (f != 0) {
209  s = format(s, ", flags ");
210 #define _(l) \
211  if (f & IP4_HEADER_FLAG_##l) \
212  s = format(s, #l);
213  _(MORE_FRAGMENTS);
214  _(DONT_FRAGMENT);
215  _(CONGESTION);
216 #undef _
217  }
218  /* Fragment packet but not the first. */
219  if (o != 0)
220  return s;
221  }
222 
223  return s;
224 }
225 
226 #endif
u8 * format_pnat_match_tuple(u8 *s, va_list *args)
u32 flags
buffer flags: VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index, VLIB_BUFFER_IS_TRACED: trace this buffer.
Definition: buffer.h:133
int ip4_sv_reass_output_enable_disable_with_refcnt(u32 sw_if_index, int is_enable)
a
Definition: bitmap.h:544
ip4_address_t src_address
Definition: ip4_packet.h:125
unsigned long u64
Definition: types.h:89
u8 * format_ip4_header(u8 *s, va_list *args)
u8 * format_pnat_rewrite_tuple(u8 *s, va_list *args)
u16 ip4_tcp_udp_compute_checksum(vlib_main_t *vm, vlib_buffer_t *p0, ip4_header_t *ip0)
void os_exit(int code)
static u32 format_get_indent(u8 *s)
Definition: format.h:72
uword ip_csum_t
Definition: ip_packet.h:245
static ip_csum_t ip_csum_with_carry(ip_csum_t sum, ip_csum_t x)
Definition: ip_packet.h:248
u16 flags_and_fragment_offset
Definition: ip4_packet.h:106
struct _tcp_header tcp_header_t
unsigned char u8
Definition: types.h:56
void(* stat_segment_update_fn)(stat_segment_directory_entry_t *e, u32 i)
Definition: stat_segment.h:65
u8 * format_udp_header(u8 *s, va_list *args)
unsigned int u32
Definition: types.h:88
vlib_frame_t * f
static u16 ip_calculate_l4_checksum(vlib_main_t *vm, vlib_buffer_t *p0, ip_csum_t sum0, u32 payload_length, u8 *iph, u32 ip_header_size, u8 *l4h)
Definition: ip.h:184
static uword ip4_header_checksum_is_valid(ip4_header_t *i)
Definition: ip4_packet.h:396
ip4_address_t dst_address
Definition: ip4_packet.h:125
u8 * format_white_space(u8 *s, va_list *va)
Definition: std-formats.c:129
description fragment has unexpected format
Definition: map.api:433
u32 ip4_fib_table_get_index_for_sw_if_index(u32 sw_if_index)
vnet_main_t * vnet_get_main(void)
int ip4_sv_reass_enable_disable_with_refcnt(u32 sw_if_index, int is_enable)
vl_api_interface_index_t sw_if_index
Definition: wireguard.api:34
unsigned short u16
Definition: types.h:57
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:257
int vnet_feature_enable_disable(const char *arc_name, const char *node_name, u32 sw_if_index, int enable_disable, void *feature_config, u32 n_feature_config_bytes)
u8 * format_ip4_address(u8 *s, va_list *args)
vlib_main_t * vm
X-connect all packets from the HOST to the PHY.
Definition: nat44_ei.c:3047
void classify_get_trace_chain(void)
void os_panic(void)
u32 index
Definition: flow_types.api:221
vnet_feature_main_t feature_main
#define ASSERT(truth)
ip_dscp_t tos
Definition: ip4_packet.h:96
u32 ip4_tcp_udp_validate_checksum(vlib_main_t *vm, vlib_buffer_t *p0)
#define clib_mem_unaligned(pointer, type)
Definition: types.h:155
clib_error_t * stat_segment_register_gauge(u8 *names, stat_segment_update_fn update_fn, u32 index)
vl_api_address_t ip
Definition: l2.api:558
VLIB buffer representation.
Definition: buffer.h:111
u64 uword
Definition: types.h:112
static int tcp_header_bytes(tcp_header_t *t)
Definition: tcp_packet.h:93
static int ip4_header_bytes(const ip4_header_t *i)
Definition: ip4_packet.h:190
u8 ip_version_and_header_length
Definition: ip4_packet.h:93
#define BITS(x)
Definition: clib.h:69
static u16 ip4_header_checksum(ip4_header_t *i)
Definition: ip4_packet.h:314
u8 * format_tcp_header(u8 *s, va_list *args)