static int
lisp_gpe_rewrite (lisp_gpe_tunnel_t * t)
{
u8 *rw = 0;
lisp_gpe_header_t * lisp0;
int len;
if (ip_addr_version(&t->src) == IP4)
{
ip4_header_t * ip0;
ip4_udp_lisp_gpe_header_t * h0;
len = sizeof(*h0);
vec_validate_aligned(rw, len - 1, CLIB_CACHE_LINE_BYTES);
h0 = (ip4_udp_lisp_gpe_header_t *) rw;
/* Fixed portion of the (outer) ip4 header */
ip0 = &h0->ip4;
ip0->ip_version_and_header_length = 0x45;
ip0->ttl = 254;
ip0->protocol = IP_PROTOCOL_UDP;
/* we fix up the ip4 header length and checksum after-the-fact */
ip_address_copy_addr(&ip0->src_address, &t->src);
ip_address_copy_addr(&ip0->dst_address, &t->dst);
ip0->checksum = ip4_header_checksum (ip0);
/* UDP header, randomize src port on something, maybe? */
h0->udp.src_port = clib_host_to_net_u16 (4341);
h0->udp.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_lisp_gpe);
/* LISP-gpe header */
lisp0 = &h0->lisp;
}
else
{
ip6_header_t * ip0;
ip6_udp_lisp_gpe_header_t * h0;
len = sizeof(*h0);
vec_validate_aligned(rw, len - 1, CLIB_CACHE_LINE_BYTES);
h0 = (ip6_udp_lisp_gpe_header_t *) rw;
/* Fixed portion of the (outer) ip6 header */
ip0 = &h0->ip6;
ip0->ip_version_traffic_class_and_flow_label =
clib_host_to_net_u32 (0x6 << 28);
ip0->hop_limit = 254;
ip0->protocol = IP_PROTOCOL_UDP;
/* we fix up the ip6 header length after-the-fact */
ip_address_copy_addr(&ip0->src_address, &t->src);
ip_address_copy_addr(&ip0->dst_address, &t->dst);
/* UDP header, randomize src port on something, maybe? */
h0->udp.src_port = clib_host_to_net_u16 (4341);
h0->udp.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_lisp_gpe);
/* LISP-gpe header */
lisp0 = &h0->lisp;
}
lisp0->flags = t->flags;
lisp0->ver_res = t->ver_res;
lisp0->res = t->res;
lisp0->next_protocol = t->next_protocol;
lisp0->iid = clib_host_to_net_u32 (t->vni);
t->rewrite = rw;
return 0;
}
/*
* ip6_sixrd
*/
static uword
ip6_sixrd (vlib_main_t *vm,
vlib_node_runtime_t *node,
vlib_frame_t *frame)
{
u32 n_left_from, *from, next_index, *to_next, n_left_to_next;
vlib_node_runtime_t *error_node = vlib_node_get_runtime(vm, ip6_sixrd_node.index);
u32 encap = 0;
from = vlib_frame_vector_args(frame);
n_left_from = frame->n_vectors;
next_index = node->cached_next_index;
while (n_left_from > 0) {
vlib_get_next_frame(vm, node, next_index, to_next, n_left_to_next);
while (n_left_from > 0 && n_left_to_next > 0) {
u32 pi0;
vlib_buffer_t *p0;
sixrd_domain_t *d0;
u8 error0 = SIXRD_ERROR_NONE;
ip6_header_t *ip60;
ip4_header_t *ip4h0;
u32 next0 = IP6_SIXRD_NEXT_IP4_LOOKUP;
u32 sixrd_domain_index0 = ~0;
pi0 = to_next[0] = from[0];
from += 1;
n_left_from -= 1;
to_next +=1;
n_left_to_next -= 1;
p0 = vlib_get_buffer(vm, pi0);
ip60 = vlib_buffer_get_current(p0);
// p0->current_length = clib_net_to_host_u16(ip40->length);
d0 = ip6_sixrd_get_domain(vnet_buffer(p0)->ip.adj_index[VLIB_TX], &sixrd_domain_index0);
ASSERT(d0);
/* SIXRD calc */
u64 dal60 = clib_net_to_host_u64(ip60->dst_address.as_u64[0]);
u32 da40 = sixrd_get_addr(d0, dal60);
u16 len = clib_net_to_host_u16(ip60->payload_length) + 60;
if (da40 == 0) error0 = SIXRD_ERROR_UNKNOWN;
/* construct ipv4 header */
vlib_buffer_advance(p0, - (sizeof(ip4_header_t)));
ip4h0 = vlib_buffer_get_current(p0);
vnet_buffer(p0)->sw_if_index[VLIB_TX] = (u32)~0;
ip4h0->ip_version_and_header_length = 0x45;
ip4h0->tos = 0;
ip4h0->length = clib_host_to_net_u16(len);
ip4h0->fragment_id = 0;
ip4h0->flags_and_fragment_offset = 0;
ip4h0->ttl = 0x40;
ip4h0->protocol = IP_PROTOCOL_IPV6;
ip4h0->src_address = d0->ip4_src;
ip4h0->dst_address.as_u32 = clib_host_to_net_u32(da40);
ip4h0->checksum = ip4_header_checksum(ip4h0);
next0 = error0 == SIXRD_ERROR_NONE ? IP6_SIXRD_NEXT_IP4_LOOKUP : IP6_SIXRD_NEXT_DROP;
if (PREDICT_FALSE(p0->flags & VLIB_BUFFER_IS_TRACED)) {
sixrd_trace_t *tr = vlib_add_trace(vm, node, p0, sizeof(*tr));
tr->sixrd_domain_index = sixrd_domain_index0;
}
p0->error = error_node->errors[error0];
if (PREDICT_TRUE(error0 == SIXRD_ERROR_NONE)) encap++;
vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next, n_left_to_next, pi0, next0);
}
vlib_put_next_frame(vm, node, next_index, n_left_to_next);
}
vlib_node_increment_counter(vm, ip6_sixrd_node.index, SIXRD_ERROR_ENCAPSULATED, encap);
return frame->n_vectors;
}
/**
* @brief Create an IPFIX template packet rewrite string
* @param frm flow_report_main_t *
* @param fr flow_report_t *
* @param collector_address ip4_address_t * the IPFIX collector address
* @param src_address ip4_address_t * the source address we should use
* @param collector_port u16 the collector port we should use, host byte order
* @returns u8 * vector containing the indicated IPFIX template packet
*/
static inline u8 *
flowprobe_template_rewrite_inline (flow_report_main_t * frm,
flow_report_t * fr,
ip4_address_t * collector_address,
ip4_address_t * src_address,
u16 collector_port,
flowprobe_variant_t which)
{
ip4_header_t *ip;
udp_header_t *udp;
ipfix_message_header_t *h;
ipfix_set_header_t *s;
ipfix_template_header_t *t;
ipfix_field_specifier_t *f;
ipfix_field_specifier_t *first_field;
u8 *rewrite = 0;
ip4_ipfix_template_packet_t *tp;
u32 field_count = 0;
flow_report_stream_t *stream;
flowprobe_main_t *fm = &flowprobe_main;
flowprobe_record_t flags = fr->opaque.as_uword;
bool collect_ip4 = false, collect_ip6 = false;
stream = &frm->streams[fr->stream_index];
if (flags & FLOW_RECORD_L3)
{
collect_ip4 = which == FLOW_VARIANT_L2_IP4 || which == FLOW_VARIANT_IP4;
collect_ip6 = which == FLOW_VARIANT_L2_IP6 || which == FLOW_VARIANT_IP6;
if (which == FLOW_VARIANT_L2_IP4)
flags |= FLOW_RECORD_L2_IP4;
if (which == FLOW_VARIANT_L2_IP6)
flags |= FLOW_RECORD_L2_IP6;
}
field_count += flowprobe_template_common_field_count ();
if (flags & FLOW_RECORD_L2)
field_count += flowprobe_template_l2_field_count ();
if (collect_ip4)
field_count += flowprobe_template_ip4_field_count ();
if (collect_ip6)
field_count += flowprobe_template_ip6_field_count ();
if (flags & FLOW_RECORD_L4)
field_count += flowprobe_template_l4_field_count ();
/* allocate rewrite space */
vec_validate_aligned
(rewrite, sizeof (ip4_ipfix_template_packet_t)
+ field_count * sizeof (ipfix_field_specifier_t) - 1,
CLIB_CACHE_LINE_BYTES);
tp = (ip4_ipfix_template_packet_t *) rewrite;
ip = (ip4_header_t *) & tp->ip4;
udp = (udp_header_t *) (ip + 1);
h = (ipfix_message_header_t *) (udp + 1);
s = (ipfix_set_header_t *) (h + 1);
t = (ipfix_template_header_t *) (s + 1);
first_field = f = (ipfix_field_specifier_t *) (t + 1);
ip->ip_version_and_header_length = 0x45;
ip->ttl = 254;
ip->protocol = IP_PROTOCOL_UDP;
ip->src_address.as_u32 = src_address->as_u32;
ip->dst_address.as_u32 = collector_address->as_u32;
udp->src_port = clib_host_to_net_u16 (stream->src_port);
udp->dst_port = clib_host_to_net_u16 (collector_port);
udp->length = clib_host_to_net_u16 (vec_len (rewrite) - sizeof (*ip));
/* FIXUP: message header export_time */
/* FIXUP: message header sequence_number */
h->domain_id = clib_host_to_net_u32 (stream->domain_id);
/* Add TLVs to the template */
f = flowprobe_template_common_fields (f);
if (flags & FLOW_RECORD_L2)
f = flowprobe_template_l2_fields (f);
if (collect_ip4)
f = flowprobe_template_ip4_fields (f);
if (collect_ip6)
f = flowprobe_template_ip6_fields (f);
if (flags & FLOW_RECORD_L4)
f = flowprobe_template_l4_fields (f);
/* Back to the template packet... */
ip = (ip4_header_t *) & tp->ip4;
udp = (udp_header_t *) (ip + 1);
ASSERT (f - first_field);
/* Field count in this template */
t->id_count = ipfix_id_count (fr->template_id, f - first_field);
fm->template_size[flags] = (u8 *) f - (u8 *) s;
/* set length in octets */
s->set_id_length =
ipfix_set_id_length (2 /* set_id */ , (u8 *) f - (u8 *) s);
/* message length in octets */
h->version_length = version_length ((u8 *) f - (u8 *) h);
ip->length = clib_host_to_net_u16 ((u8 *) f - (u8 *) ip);
ip->checksum = ip4_header_checksum (ip);
return rewrite;
}
