src/plugins/nat/pnat/tests/pnat_test_stubs.h

   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) {}
  21 u32 ip4_fib_table_get_index_for_sw_if_index(u32 sw_if_index) { return 0; }
  22 #include <vpp/stats/stat_segment.h>
  23 clib_error_t *stat_segment_register_gauge(u8 *names,
  24                                           stat_segment_update_fn update_fn,
  25                                           u32 index) {
  26     return 0;
  27 };
  28 #include <vnet/feature/feature.h>
  29 vnet_feature_main_t feature_main;
  30 void classify_get_trace_chain(void){};
  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 vl_counter_t pnat_error_counters[10];
  42
  43 int ip4_sv_reass_enable_disable_with_refcnt(u32 sw_if_index, int is_enable) {
  44     return 0;
  45 }
  46 int ip4_sv_reass_output_enable_disable_with_refcnt(u32 sw_if_index,
  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 static struct {
  59     vec_header_t h;
  60     vlib_main_t *vm;
  61 } __attribute__((packed)) __bootstrap_vlib_main_vector
  62     __attribute__((aligned(CLIB_CACHE_LINE_BYTES))) = {
  63         .h.len = 1,
  64         .vm = &vlib_global_main,
  65 };
  66
  67 vlib_main_t **vlib_mains = &__bootstrap_vlib_main_vector.vm;
  68
  69 /* Compute TCP/UDP/ICMP4 checksum in software. */
  70 u16 ip4_tcp_udp_compute_checksum(vlib_main_t *vm, vlib_buffer_t *p0,
  71                                  ip4_header_t *ip0) {
  72     ip_csum_t sum0;
  73     u32 ip_header_length, payload_length_host_byte_order;
  74
  75     /* Initialize checksum with ip header. */
  76     ip_header_length = ip4_header_bytes(ip0);
  77     payload_length_host_byte_order =
  78         clib_net_to_host_u16(ip0->length) - ip_header_length;
  79     sum0 = clib_host_to_net_u32(payload_length_host_byte_order +
  80                                 (ip0->protocol << 16));
  81
  82     if (BITS(uword) == 32) {
  83         sum0 = ip_csum_with_carry(sum0,
  84                                   clib_mem_unaligned(&ip0->src_address, u32));
  85         sum0 = ip_csum_with_carry(sum0,
  86                                   clib_mem_unaligned(&ip0->dst_address, u32));
  87     } else
  88         sum0 = ip_csum_with_carry(sum0,
  89                                   clib_mem_unaligned(&ip0->src_address, u64));
  90     return ip_calculate_l4_checksum(vm, p0, sum0,
  91                                     payload_length_host_byte_order, (u8 *)ip0,
  92                                     ip_header_length, NULL);
  93 }
  94
  95 u32 ip4_tcp_udp_validate_checksum(vlib_main_t *vm, vlib_buffer_t *p0) {
  96     ip4_header_t *ip0 = vlib_buffer_get_current(p0);
  97     udp_header_t *udp0;
  98     u16 sum16;
  99
 100     ASSERT(ip0->protocol == IP_PROTOCOL_TCP ||
 101            ip0->protocol == IP_PROTOCOL_UDP);
 102
 103     udp0 = (void *)(ip0 + 1);
 104     if (ip0->protocol == IP_PROTOCOL_UDP && udp0->checksum == 0) {
 105         p0->flags |= (VNET_BUFFER_F_L4_CHECKSUM_COMPUTED |
 106                       VNET_BUFFER_F_L4_CHECKSUM_CORRECT);
 107         return p0->flags;
 108     }
 109
 110     sum16 = ip4_tcp_udp_compute_checksum(vm, p0, ip0);
 111
 112     p0->flags |= (VNET_BUFFER_F_L4_CHECKSUM_COMPUTED |
 113                   ((sum16 == 0) << VNET_BUFFER_F_LOG2_L4_CHECKSUM_CORRECT));
 114
 115     return p0->flags;
 116 }
 117 u8 *format_tcp_header(u8 *s, va_list *args) {
 118     tcp_header_t *tcp = va_arg(*args, tcp_header_t *);
 119     u32 max_header_bytes = va_arg(*args, u32);
 120     u32 header_bytes;
 121     u32 indent;
 122
 123     /* Nothing to do. */
 124     if (max_header_bytes < sizeof(tcp[0]))
 125         return format(s, "TCP header truncated");
 126
 127     indent = format_get_indent(s);
 128     indent += 2;
 129     header_bytes = tcp_header_bytes(tcp);
 130
 131     s = format(s, "TCP: %d -> %d", clib_net_to_host_u16(tcp->src),
 132                clib_net_to_host_u16(tcp->dst));
 133
 134     s = format(s, "\n%Useq. 0x%08x ack 0x%08x", format_white_space, indent,
 135                clib_net_to_host_u32(tcp->seq_number),
 136                clib_net_to_host_u32(tcp->ack_number));
 137
 138     s = format(s, "\n%Utcp header: %d bytes", format_white_space, indent,
 139                tcp->flags, header_bytes);
 140
 141     s = format(s, "\n%Uwindow %d, checksum 0x%04x", format_white_space, indent,
 142                clib_net_to_host_u16(tcp->window),
 143                clib_net_to_host_u16(tcp->checksum));
 144     return s;
 145 }
 146 /* Format UDP header. */
 147 u8 *format_udp_header(u8 *s, va_list *args) {
 148     udp_header_t *udp = va_arg(*args, udp_header_t *);
 149     u32 max_header_bytes = va_arg(*args, u32);
 150     u32 indent;
 151
 152     /* Nothing to do. */
 153     if (max_header_bytes < sizeof(udp[0]))
 154         return format(s, "UDP header truncated");
 155
 156     indent = format_get_indent(s);
 157     indent += 2;
 158
 159     s = format(s, "UDP: %d -> %d", clib_net_to_host_u16(udp->src_port),
 160                clib_net_to_host_u16(udp->dst_port));
 161
 162     s = format(s, "\n%Ulength %d, checksum 0x%04x", format_white_space, indent,
 163                clib_net_to_host_u16(udp->length),
 164                clib_net_to_host_u16(udp->checksum));
 165
 166     return s;
 167 }
 168
 169 /* Format an IP4 header. */
 170 u8 *format_ip4_header(u8 *s, va_list *args) {
 171     ip4_header_t *ip = va_arg(*args, ip4_header_t *);
 172     u32 max_header_bytes = va_arg(*args, u32);
 173     u32 ip_version, header_bytes;
 174     u32 indent;
 175
 176     /* Nothing to do. */
 177     if (max_header_bytes < sizeof(ip[0]))
 178         return format(s, "IP header truncated");
 179
 180     indent = format_get_indent(s);
 181     indent += 2;
 182
 183     ip_version = (ip->ip_version_and_header_length >> 4);
 184     header_bytes = (ip->ip_version_and_header_length & 0xf) * sizeof(u32);
 185
 186     s = format(s, "%d: %U -> %U", ip->protocol, format_ip4_address,
 187                ip->src_address.data, format_ip4_address, ip->dst_address.data);
 188
 189     /* Show IP version and header length only with unexpected values. */
 190     if (ip_version != 4 || header_bytes != sizeof(ip4_header_t))
 191         s = format(s, "\n%Uversion %d, header length %d", format_white_space,
 192                    indent, ip_version, header_bytes);
 193
 194     s = format(s, "\n%Utos 0x%02x, ttl %d, length %d, checksum 0x%04x",
 195                format_white_space, indent, ip->tos, ip->ttl,
 196                clib_net_to_host_u16(ip->length),
 197                clib_net_to_host_u16(ip->checksum));
 198
 199     /* Check and report invalid checksums. */
 200     {
 201         if (!ip4_header_checksum_is_valid(ip))
 202             s = format(s, " (should be 0x%04x)",
 203                        clib_net_to_host_u16(ip4_header_checksum(ip)));
 204     }
 205
 206     {
 207         u32 f = clib_net_to_host_u16(ip->flags_and_fragment_offset);
 208         u32 o;
 209
 210         s = format(s, "\n%Ufragment id 0x%04x", format_white_space, indent,
 211                    clib_net_to_host_u16(ip->fragment_id));
 212
 213         /* Fragment offset. */
 214         o = 8 * (f & 0x1fff);
 215         f ^= f & 0x1fff;
 216         if (o != 0)
 217             s = format(s, " offset %d", o);
 218
 219         if (f != 0) {
 220             s = format(s, ", flags ");
 221 #define _(l)                                                                   \
 222     if (f & IP4_HEADER_FLAG_##l)                                               \
 223         s = format(s, #l);
 224             _(MORE_FRAGMENTS);
 225             _(DONT_FRAGMENT);
 226             _(CONGESTION);
 227 #undef _
 228         }
 229         /* Fragment packet but not the first. */
 230         if (o != 0)
 231             return s;
 232     }
 233
 234     return s;
 235 }
 236
 237 #endif