Internet on FIRE

src := attrs.c bgp.c packets.c map.c

tests_objs := $(tests_objs) $(src-o-files)

#include <string.h>

#include <stdio.h>

    const char *name;

    uint type;

    uint flags;

    void (*export)(struct bgp_export_state *s, eattr *a);

    int  (*encode)(struct bgp_write_state *s, eattr *a, byte *buf, uint size);

    void (*decode)(struct bgp_parse_state *s, uint code, uint flags, byte *data, uint len, ea_list **to);

    void (*format)(eattr *ea, byte *buf, uint size);

/**

 * This function initialize the map used for the RT and the ASLoad map

 *

 * @author Mattia Milani

 */

void initRTmap(){

    //Map init

    map_init(&RTmap);

    map_init(&ExternalDestinationMap);

    map_init(&ASLoad_map);

    //Variable setting

    esportoDestinazioni = 0;

    total_number_of_update_sent = 0;

}

/**

 * Init function for the init of a RT element to be loaded in the data structure

 * @param dest Destination addr

 * @param l Load

 * @param inter Define if an addr is intern or extern

 * @return Return the RTable element

 */

RTable

initRTableElement(net_addr *dest, int l, int inter){

    RTable element;

    element.interno = inter;

    element.d = dest;

    map_init(&element.NH);

    map_init(&element.loadin);

    element.load = l;

    return element;

}

        bgp_set_attr(ea_list **attrs, struct linpool *pool, uint code, uint flags, uintptr_t val)

ASSERT(bgp_attr_known(code));

ea_list *a = lp_alloc(pool, sizeof(ea_list) + sizeof(eattr));

eattr *e = &a->attrs[0];

a->flags = EALF_SORTED;

a->count = 1;

a->next = *attrs;

*attrs = a;

e->id = EA_CODE(EAP_BGP, code);

e->type = bgp_attr_table[code].type;

e->flags = flags;

if (e->type & EAF_EMBEDDED)

e->u.data = (u32) val;

else

e->u.ptr = (struct adata *) val;

return e;

    *buf++ = flags;

    *buf++ = code;

    *buf++ = len;

    return 3;

    *buf++ = flags | BAF_EXT_LEN;

    *buf++ = code;

    put_u16(buf, len);

    return 4;

    if (len < 256)

        return bgp_put_attr_hdr3(buf, code, flags, len);

    else

        return bgp_put_attr_hdr4(buf, code, flags, len);

    if (size < (3+1))

        return -1;

    bgp_put_attr_hdr3(buf, EA_ID(a->id), a->flags, 1);

    buf[3] = a->u.data;

    return 3+1;

    if (size < (3+4))

        return -1;

    bgp_put_attr_hdr3(buf, EA_ID(a->id), a->flags, 4);

    put_u32(buf+3, a->u.data);

    return 3+4;

    uint len = a->u.ptr->length;

    if (size < (4+len))

        return -1;

    uint hdr = bgp_put_attr_hdr(buf, EA_ID(a->id), a->flags, len);

    put_u32s(buf + hdr, (u32 *) a->u.ptr->data, len / 4);

    return hdr + len;

    if (size < (4+len))

        return -1;

    uint hdr = bgp_put_attr_hdr(buf, code, flags, len);

    memcpy(buf + hdr, data, len);

    return hdr + len;

    return bgp_put_attr(buf, size, EA_ID(a->id), a->flags, a->u.ptr->data, a->u.ptr->length);

    if (a->u.data > 2)

        WITHDRAW(BAD_VALUE, "ORIGIN", a->u.data);

    if (len != 1)

        WITHDRAW(BAD_LENGTH, "ORIGIN", len);

    if (data[0] > 2)

        WITHDRAW(BAD_VALUE, "ORIGIN", data[0]);

    bgp_set_attr_u32(to, s->pool, BA_ORIGIN, flags, data[0]);

    static const char *bgp_origin_names[] = { "IGP", "EGP", "Incomplete" };

    bsprintf(buf, (a->u.data <= 2) ? bgp_origin_names[a->u.data] : "?");

    byte *data = a->u.ptr->data;

    uint len = a->u.ptr->length;

    if (!s->as4_session)

    {

        /* Prepare 16-bit AS_PATH (from 32-bit one) in a temporary buffer */

        byte *src = data;

        data = alloca(len);

        len = as_path_32to16(data, src, len);

    }

    return bgp_put_attr(buf, size, BA_AS_PATH, a->flags, data, len);

}

static int

bgp_encode_nhs_list(struct bgp_write_state *s, eattr *a, byte *buf, uint size)

{

    byte *data = a->u.ptr->data;

    uint len = a->u.ptr->length;

    if (!s->as4_session)

    {

        /* Prepare 16-bit AS_PATH (from 32-bit one) in a temporary buffer */

        byte *src = data;

        data = alloca(len);

        len = as_path_32to16(data, src, len);

    }

    return bgp_put_attr(buf, size, BA_AS_NH_LIST, a->flags, data, len);

/**

 * Function to encode the load to the correct attribute

 * @param s bgp write state

 * @param a attribute

 * @param buf buffer

 * @param size size of the attribute

 * @return

 */

static int

bgp_encode_as_load(struct bgp_write_state *s, eattr *a, byte *buf, uint size)

{

    //Pointer to the data contained in the attribute

    byte *data = a->u.ptr->data;

    //Actual length of the attribute data

    uint len = a->u.ptr->length;

    if (!s->as4_session)

    {

        // Prepare 16-bit AS_PATH (from 32-bit one) in a temporary buffer

        byte *src = data;

        data = alloca(len);

        len = as_path_32to16(data, src, len);

    }

    return bgp_put_attr(buf, size, BA_AS_LOAD, a->flags, data, len);

}

/**

 * Function to decode the as path passed from the packet

 * @param s

 * @param code

 * @param flags

 * @param data

 * @param len

 * @param to

 */

    struct bgp_proto *p = s->proto;

    int as_length = s->as4_session ? 4 : 2;

    int as_confed = p->cf->confederation && p->is_interior;

    char err[128];

    //Catch malformed attribute

    if (!as_path_valid(data, len, as_length, as_confed, err, sizeof(err)))

        WITHDRAW("Malformed AS_PATH attribute - %s", err);

    /* In some circumstances check for initial AS_CONFED_SEQUENCE; RFC 5065 5.0 */

    if (p->is_interior && !p->is_internal &&

        ((len < 2) || (data[0] != AS_PATH_CONFED_SEQUENCE)))

        WITHDRAW("Malformed AS_PATH attribute - %s", "missing initial AS_CONFED_SEQUENCE");

    if (!s->as4_session)

    {

        /* Prepare 32-bit AS_PATH (from 16-bit one) in a temporary buffer */

        byte *src = data;

        data = alloca(2*len);

        len = as_path_16to32(data, src, len);

    }

    char buf2[32];

    sprintf(buf2, "%02X%02X%02X%02X",data[2], data[3], data[4], data[5]);

    //TODO this data cannot be taken from the attribute data?

    ASRicezione = (int)strtol(buf2, NULL, 16);

    //log(L_INFO "%d", ASRicezione);

    bgp_set_attr_data(to, s->pool, BA_AS_PATH, flags, data, len);

}

/**

 * Function used to decode the list of NHs take from the packet

 * @param s

 * @param code

 * @param flags

 * @param data

 * @param len

 * @param to

 */

static void

bgp_decode_nhs_list(struct bgp_parse_state *s, uint code UNUSED, uint flags, byte *data, uint len, ea_list **to)

{

    struct bgp_proto *p = s->proto;

    int as_length = s->as4_session ? 4 : 2;

    int as_confed = p->cf->confederation && p->is_interior;

    char err[128];

    if (!as_path_valid(data, len, as_length, as_confed, err, sizeof(err)))

        WITHDRAW("Malformed AS_PATH attribute - %s", err);

    /* In some circumstances check for initial AS_CONFED_SEQUENCE; RFC 5065 5.0 */

    if (p->is_interior && !p->is_internal &&

        ((len < 2) || (data[0] != AS_PATH_CONFED_SEQUENCE)))

        WITHDRAW("Malformed AS_PATH attribute - %s", "missing initial AS_CONFED_SEQUENCE");

    if (!s->as4_session)

    {

        /* Prepare 32-bit AS_PATH (from 16-bit one) in a temporary buffer */

        byte *src = data;

        data = alloca(2*len);

        len = as_path_16to32(data, src, len);

    }

    //log(L_INFO "Len: %d", len);

    if(len > 0){

        numeroNHarrivati = data[1];

        //log(L_INFO "Decodifica nh %d:", numeroNHarrivati);

        int i = 0;

        int k = 2;

        /* Check if my as is in the NH list */

        for(i = 0;i < data[1]; i++){

            /*log(L_INFO "C'è un NH");

            *log(L_INFO "data[%d] = %d",i, data[k]);

            *log(L_INFO "data[%d] = %d",i, data[k+1]);

            *log(L_INFO "data[%d] = %d",i, data[k+2]);

            *log(L_INFO "data[%d] = %d",i, data[k+3]);

            */

            char buf2[32];

            sprintf(buf2, "%02X%02X%02X%02X",data[k], data[k+1], data[k+2], data[k+3]);

            unsigned int nhLetto = (int)strtol(buf2, NULL, 16);

            //log(L_INFO "nh[%d] = %d",i, nhLetto);

            k+=4;

            if(p->public_as == nhLetto){

                //log(L_INFO "Hey io sono il NH");

                //I founded that I am in the nh list

                sonoIlNH = 1;

            }

        }

    }

/**

 * Function to decode the load data structure from an update packet

 * @param s

 * @param code

 * @param flags

 * @param data

 * @param len

 * @param to

 */

static void

bgp_decode_as_load(struct bgp_parse_state *s, uint code UNUSED, uint flags, byte *data, uint len, ea_list **to)

{

    //log(L_INFO "SONO IN AS LOAD");

    struct bgp_proto *p = s->proto;

    int as_length = s->as4_session ? 4 : 2;

    int as_confed = p->cf->confederation && p->is_interior;

    char err[128];

    if (!as_path_valid(data, len, as_length, as_confed, err, sizeof(err)))

        WITHDRAW("Malformed AS_LOAD attribute - %s", err);

    // In some circumstances check for initial AS_CONFED_SEQUENCE; RFC 5065 5.0

    if (p->is_interior && !p->is_internal &&

        ((len < 2) || (data[0] != AS_PATH_CONFED_SEQUENCE)))

        WITHDRAW("Malformed AS_LOAD attribute - %s", "missing initial AS_CONFED_SEQUENCE");

    if (!s->as4_session)

    {

        // Prepare 32-bit AS_PATH (from 16-bit one) in a temporary buffer

        byte *src = data;

        data = alloca(2*len);

        len = as_path_16to32(data, src, len);

    }

    //log(L_INFO "Len: %d", len);

    if(len > 0){

        //log(L_INFO "Decodifica nh %d:", data[1]);

        int i = 0;

        int k = 2;

        for(i = 0;i < data[1]; i++){

            /*log(L_INFO "C'è un AS");

            log(L_INFO "data[%d] = %d",i, data[k]);

            log(L_INFO "data[%d] = %d",i, data[k+1]);

            log(L_INFO "data[%d] = %d",i, data[k+2]);

            log(L_INFO "data[%d] = %d",i, data[k+3]);

            log(L_INFO "AS => %02X%02X%02X%02X",data[k], data[k+1], data[k+2], data[k+3]);*/

            char buf2[32];

            sprintf(buf2, "%02X%02X%02X%02X",data[k], data[k+1], data[k+2], data[k+3]);

            unsigned int asLetto = (int)strtol(buf2, NULL, 16);

            //log(L_INFO "as[%d] = %d",i, asLetto);

            k+=4;

            i++;

            /*log(L_INFO "Load AS");

            log(L_INFO "data[%d] = %d",i, data[k]);

            log(L_INFO "data[%d] = %d",i, data[k+1]);

            log(L_INFO "data[%d] = %d",i, data[k+2]);

            log(L_INFO "data[%d] = %d",i, data[k+3]);

            log(L_INFO "AS LOAD => %02X%02X%02X%02X",data[k], data[k+1], data[k+2], data[k+3]);*/

            sprintf(buf2, "%02X%02X%02X%02X",data[k], data[k+1], data[k+2], data[k+3]);

            int loadLetto = (int)strtol(buf2, NULL, 16);

            float loadASRileato = *((float *) &loadLetto);

            char output[50];

            snprintf(output, 50, "%f", loadASRileato);

            //log(L_INFO "load[%d] = %s",i, output);

            k+=4;

            i++;

            /*log(L_INFO "Metrica Load AS");

            log(L_INFO "data[%d] = %d",i, data[k]);

            log(L_INFO "data[%d] = %d",i, data[k+1]);

            log(L_INFO "data[%d] = %d",i, data[k+2]);

            log(L_INFO "data[%d] = %d",i, data[k+3]);

            log(L_INFO "AS METRIC => %02X%02X%02X%02X",data[k], data[k+1], data[k+2], data[k+3]);*/

            sprintf(buf2, "%02X%02X%02X%02X",data[k], data[k+1], data[k+2], data[k+3]);

            int metrica = (int)strtol(buf2, NULL, 16);

            //log(L_INFO "metrica[%d] = %d",i, metrica);

            k+=4;

            char chKeyASLoad[12] = "";

            sprintf(chKeyASLoad, "%d", asLetto);

            //Generate an ASLoad element from the data get in this section of the packet

            ASLoad ASLoad_ricevuto = {loadASRileato, metrica, 1, NULL};

            map_init(&ASLoad_ricevuto.remoteMap);

            //Check if it's already in the data structure

            ASLoad *ASLoad_element = map_get(&ASLoad_map, chKeyASLoad);

            if (ASLoad_element) {

                //log(L_INFO "AS già presente, aggiorno il valore");

                if(asLetto != p->public_as && ASLoad_element->metrica < ASLoad_ricevuto.metrica){

                    ASLoad_element->load = ASLoad_ricevuto.load;

                    ASLoad_element->metrica = ASLoad_ricevuto.metrica;

                    //ASLoad_element->changed = 1;

                    //Clean the remote map

                    const char *key;

                    map_iter_t iter = map_iter(&ASLoad_element->remoteMap);

                    while ((key = map_next(&ASLoad_element->remoteMap, &iter))) {

                        map_remove(&ASLoad_element->remoteMap, key);

                    }

                }

                if(asLetto == p->public_as && ASLoad_element->metrica < ASLoad_ricevuto.metrica){

                    ASLoad_element->metrica = ASLoad_ricevuto.metrica++;

                    //ASLoad_element->changed = 1;

                    const char *key;

                    map_iter_t iter = map_iter(&ASLoad_element->remoteMap);

                    while ((key = map_next(&ASLoad_element->remoteMap, &iter))) {

                        map_remove(&ASLoad_element->remoteMap, key);

                    }

                }

            } else {

                //log(L_INFO "AS non presente, lo aggiungo");

                map_set(&ASLoad_map, chKeyASLoad, ASLoad_ricevuto);

            }

        }

    }

}

/**

 * Function to encode the NH

 * @param s

 * @param a

 * @param buf

 * @param size

 * @return

 */

    /*

     * The NEXT_HOP attribute is used only in traditional (IPv4) BGP. In MP-BGP,

     * the next hop is encoded as a part of the MP_REACH_NLRI attribute, so we

     * store it and encode it later by AFI-specific hooks.

     */

    if (s->channel->afi == BGP_AF_IPV4)

    {

        ASSERT(a->u.ptr->length == sizeof(ip_addr));

        if (size < (3+4))

            return -1;

        bgp_put_attr_hdr3(buf, BA_NEXT_HOP, a->flags, 4);

        put_ip4(buf+3, ipa_to_ip4( *(ip_addr *) a->u.ptr->data ));

        return 3+4;

    }

    else

    {

        s->mp_next_hop = a;

        return 0;

    }

    if (len != 4)

        WITHDRAW(BAD_LENGTH, "NEXT_HOP", len);

    nhKey = 0;

    nhKey += data[0] + data[1] + data[2] + data[3];

    /* Semantic checks are done later */

    s->ip_next_hop_len = len;

    s->ip_next_hop_data = data;

    ip_addr *nh = (void *) a->u.ptr->data;

    uint len = a->u.ptr->length;

    ASSERT((len == 16) || (len == 32));

    /* in IPv6, we may have two addresses in NEXT HOP */

    if ((len == 16) || ipa_zero(nh[1]))

        bsprintf(buf, "%I", nh[0]);

    else

        bsprintf(buf, "%I %I", nh[0], nh[1]);

    if (len != 4)

        WITHDRAW(BAD_LENGTH, "MULTI_EXIT_DISC", len);

    u32 val = get_u32(data);

    bgp_set_attr_u32(to, s->pool, BA_MULTI_EXIT_DISC, flags, val);

//TODO hard todo, use atributes and not variables for those things

/**

 * Function to decode the load_out in a packet

 * @param s

 * @param code

 * @param flags

 * @param data

 * @param len

 * @param to

 */

static void

bgp_decode_load_out(struct bgp_parse_state *s, uint code UNUSED, uint flags, byte *data, uint len, ea_list **to)

{

    if (len != 4)

        WITHDRAW(BAD_LENGTH, "BA_LOAD_SENDER", len);

    u32 val = get_u32(data);

    char output[50];

    int v = val;

    loadOutRilevato = *((float *) &v);

    snprintf(output, 50, "%f", loadOutRilevato);

}

    if (!s->proto->is_interior && !s->proto->cf->allow_local_pref)

        UNSET(a);

    if (!s->proto->is_interior && !s->proto->cf->allow_local_pref)

        DISCARD(BAD_EBGP, "LOCAL_PREF");

    if (len != 4)

        WITHDRAW(BAD_LENGTH, "LOCAL_PREF", len);

    u32 val = get_u32(data);

    bgp_set_attr_u32(to, s->pool, BA_LOCAL_PREF, flags, val);

    if (len != 0)

        DISCARD(BAD_LENGTH, "ATOMIC_AGGR", len);

    bgp_set_attr_data(to, s->pool, BA_ATOMIC_AGGR, flags, NULL, 0);

    byte *data = a->u.ptr->data;

    uint len = a->u.ptr->length;

    if (!s->as4_session)

    {

        /* Prepare 16-bit AGGREGATOR (from 32-bit one) in a temporary buffer */

        byte *src = data;

        data = alloca(6);

        len = aggregator_32to16(data, src);

    }

    return bgp_put_attr(buf, size, BA_AGGREGATOR, a->flags, data, len);

    if (len != (s->as4_session ? 8 : 6))

        DISCARD(BAD_LENGTH, "AGGREGATOR", len);

    if (!s->as4_session)

    {

        /* Prepare 32-bit AGGREGATOR (from 16-bit one) in a temporary buffer */

        byte *src = data;

        data = alloca(8);

        len = aggregator_16to32(data, src);

    }

    bgp_set_attr_data(to, s->pool, BA_AGGREGATOR, flags, data, len);

    byte *data = a->u.ptr->data;

    bsprintf(buf, "%I4 AS%u", get_ip4(data+4), get_u32(data+0));

    if (a->u.ptr->length == 0)

        UNSET(a);

    a->u.ptr = int_set_sort(s->pool, a->u.ptr);

    if (!len || (len % 4))

        WITHDRAW(BAD_LENGTH, "COMMUNITY", len);

    struct adata *ad = lp_alloc_adata(s->pool, len);

    get_u32s(data, (u32 *) ad->data, len / 4);

    bgp_set_attr_ptr(to, s->pool, BA_COMMUNITY, flags, ad);

    if (!s->proto->is_internal)

        UNSET(a);

    if (!s->proto->is_internal)

        DISCARD(BAD_EBGP, "ORIGINATOR_ID");

    if (len != 4)

        WITHDRAW(BAD_LENGTH, "ORIGINATOR_ID", len);

    u32 val = get_u32(data);

    bgp_set_attr_u32(to, s->pool, BA_ORIGINATOR_ID, flags, val);

    if (!s->proto->is_internal)

        UNSET(a);

    if (a->u.ptr->length == 0)

        UNSET(a);

    if (!s->proto->is_internal)

        DISCARD(BAD_EBGP, "CLUSTER_LIST");

    if (!len || (len % 4))

        WITHDRAW(BAD_LENGTH, "CLUSTER_LIST", len);

    struct adata *ad = lp_alloc_adata(s->pool, len);

    get_u32s(data, (u32 *) ad->data, len / 4);

    bgp_set_attr_ptr(to, s->pool, BA_CLUSTER_LIST, flags, ad);

    /* Truncates cluster lists larger than buflen, probably not a problem */

    int_set_format(a->u.ptr, 0, -1, buf, size);

    return (get_u16(buf) << 16) | buf[2];

    /*

     *	2 B	MP_REACH_NLRI data - Address Family Identifier

     *	1 B	MP_REACH_NLRI data - Subsequent Address Family Identifier

     *	1 B	MP_REACH_NLRI data - Length of Next Hop Network Address

     *	var	MP_REACH_NLRI data - Network Address of Next Hop

     *	1 B	MP_REACH_NLRI data - Reserved (zero)

     *	var	MP_REACH_NLRI data - Network Layer Reachability Information

     */

    if ((len < 5) || (len < (5 + (uint) data[3])))

    s->mp_reach_af = get_af3(data);

    s->mp_next_hop_len = data[3];

    s->mp_next_hop_data = data + 4;

    s->mp_reach_len = len - 5 - s->mp_next_hop_len;

    s->mp_reach_nlri = data + 5 + s->mp_next_hop_len;

    /*

     *	2 B	MP_UNREACH_NLRI data - Address Family Identifier

     *	1 B	MP_UNREACH_NLRI data - Subsequent Address Family Identifier

     *	var	MP_UNREACH_NLRI data - Network Layer Reachability Information

     */

    if (len < 3)

        bgp_parse_error(s, 9);

    s->mp_unreach_af = get_af3(data);

    s->mp_unreach_len = len - 3;

    s->mp_unreach_nlri = data + 3;

    a->u.ptr = ec_set_del_nontrans(s->pool, a->u.ptr);

    if (a->u.ptr->length == 0)

        UNSET(a);

    ec_set_sort_x(a->u.ptr);

    if (!len || (len % 8))

        WITHDRAW(BAD_LENGTH, "EXT_COMMUNITY", len);

    struct adata *ad = lp_alloc_adata(s->pool, len);

    get_u32s(data, (u32 *) ad->data, len / 4);

    bgp_set_attr_ptr(to, s->pool, BA_EXT_COMMUNITY, flags, ad);

    if (s->as4_session)

        DISCARD(NEW_BGP, "AS4_AGGREGATOR");

    if (len != 8)

        DISCARD(BAD_LENGTH, "AS4_AGGREGATOR", len);

    bgp_set_attr_data(to, s->pool, BA_AS4_AGGREGATOR, flags, data, len);

    char err[128];

    if (s->as4_session)

        DISCARD(NEW_BGP, "AS4_PATH");

    if (len < 6)

        DISCARD(BAD_LENGTH, "AS4_PATH", len);

    if (!as_path_valid(data, len, 4, 1, err, sizeof(err)))

        DISCARD("Malformed AS4_PATH attribute - %s", err);

    struct adata *a = lp_alloc_adata(s->pool, len);

    memcpy(a->data, data, len);

    /* AS_CONFED* segments are invalid in AS4_PATH; RFC 6793 6 */

    if (as_path_contains_confed(a))

    {

        REPORT("Discarding AS_CONFED* segment from AS4_PATH attribute");

        a = as_path_strip_confed(s->pool, a);

    }

    bgp_set_attr_ptr(to, s->pool, BA_AS4_PATH, flags, a);

    if (a->u.ptr->length == 0)

        UNSET(a);

    a->u.ptr = lc_set_sort(s->pool, a->u.ptr);

    if (!len || (len % 12))

        WITHDRAW(BAD_LENGTH, "LARGE_COMMUNITY", len);

    struct adata *ad = lp_alloc_adata(s->pool, len);

    get_u32s(data, (u32 *) ad->data, len / 4);

    bgp_set_attr_ptr(to, s->pool, BA_LARGE_COMMUNITY, flags, ad);

    net_addr *n = s->route->net->n.addr;

    u32 *labels = (u32 *) a->u.ptr->data;

    uint lnum = a->u.ptr->length / 4;

    /* Perhaps we should just ignore it? */

    if (!s->mpls)

        WITHDRAW("Unexpected MPLS stack");

    /* Empty MPLS stack is not allowed */

    if (!lnum)

        WITHDRAW("Malformed MPLS stack - empty");

    /* This is ugly, but we must ensure that labels fit into NLRI field */

    if ((24*lnum + (net_is_vpn(n) ? 64 : 0) + net_pxlen(n)) > 255)

        WITHDRAW("Malformed MPLS stack - too many labels (%u)", lnum);

    for (uint i = 0; i < lnum; i++)

    {

        if (labels[i] > 0xfffff)

            WITHDRAW("Malformed MPLS stack - invalid label (%u)", labels[i]);

    }

    /*

     * MPLS labels are encoded as a part of the NLRI in MP_REACH_NLRI attribute,

     * so we store MPLS_LABEL_STACK and encode it later by AFI-specific hooks.

     */

    s->mpls_labels = a->u.ptr;

    return 0;

    DISCARD("Discarding received attribute #0");

    u32 *labels = (u32 *) a->u.ptr->data;

    uint lnum = a->u.ptr->length / 4;

    char *pos = buf;

    for (uint i = 0; i < lnum; i++)

        if (size < 20)

        {

            bsprintf(pos, "...");

            return;

        }

        uint l = bsprintf(pos, "%d/", labels[i]);

        ADVANCE(pos, size, l);

    /* Clear last slash or terminate empty string */

    pos[lnum ? -1 : 0] = 0;

    /* Cannot use bgp_set_attr_data() as it works on known attributes only */

    ea_set_attr_data(to, s->pool, EA_CODE(EAP_BGP, code), flags, EAF_TYPE_OPAQUE, data, len);

        [BA_ORIGIN] = {

                .name = "origin",

                .type = EAF_TYPE_INT,

                .flags = BAF_TRANSITIVE,

                .export = bgp_export_origin,

                .encode = bgp_encode_u8,

                .decode = bgp_decode_origin,

                .format = bgp_format_origin,

        },

        [BA_AS_PATH] = {

                .name = "as_path",

                .type = EAF_TYPE_AS_PATH,

                .flags = BAF_OPTIONAL | BAF_TRANSITIVE,

                .encode = bgp_encode_as_path,

                .decode = bgp_decode_as_path,

        },

        [BA_AS_NH_LIST] = {

                .name = "NH",

                .type = EAF_TYPE_AS_PATH,

                .flags = BAF_TRANSITIVE, //-> documentation

                .encode = bgp_encode_nhs_list,

                .decode = bgp_decode_nhs_list,

        },

        [BA_AS_LOAD] = {

                .name = "AS_LOAD",

                .type = EAF_TYPE_AS_PATH,

                .flags = BAF_TRANSITIVE,

                .encode = bgp_encode_as_load,

                .decode = bgp_decode_as_load,

        },

        [BA_LOAD_OUT] = {

                .name = "load_out",

                .type = EAF_TYPE_INT,

                .flags = BAF_OPTIONAL | BAF_TRANSITIVE,

                .encode = bgp_encode_u32,

                .decode = bgp_decode_load_out,

        },

        [BA_NEXT_HOP] = {

                .name = "next_hop",

                .type = EAF_TYPE_IP_ADDRESS,

                .flags = BAF_TRANSITIVE,

                .encode = bgp_encode_next_hop,

                .decode = bgp_decode_next_hop,

                .format = bgp_format_next_hop,

        },

        [BA_MULTI_EXIT_DISC] = {

                .name = "med",

                .type = EAF_TYPE_INT,

                .flags = BAF_OPTIONAL,

                .encode = bgp_encode_u32,

                .decode = bgp_decode_med,

        },

        [BA_LOCAL_PREF] = {

                .name = "local_pref",

                .type = EAF_TYPE_INT,

                .flags = BAF_TRANSITIVE,

                .export = bgp_export_local_pref,

                .encode = bgp_encode_u32,

                .decode = bgp_decode_local_pref,

        },

        [BA_ATOMIC_AGGR] = {

                .name = "atomic_aggr",

                .type = EAF_TYPE_OPAQUE,

                .flags = BAF_TRANSITIVE,

                .encode = bgp_encode_raw,

                .decode = bgp_decode_atomic_aggr,

        },

        [BA_AGGREGATOR] = {

                .name = "aggregator",

                .type = EAF_TYPE_OPAQUE,

                .flags = BAF_OPTIONAL | BAF_TRANSITIVE,

                .encode = bgp_encode_aggregator,

                .decode = bgp_decode_aggregator,

                .format = bgp_format_aggregator,

        },

        [BA_COMMUNITY] = {

                .name = "community",

                .type = EAF_TYPE_INT_SET,

                .flags = BAF_OPTIONAL | BAF_TRANSITIVE,

                .export = bgp_export_community,

                .encode = bgp_encode_u32s,

                .decode = bgp_decode_community,

        },

        [BA_ORIGINATOR_ID] = {

                .name = "originator_id",

                .type = EAF_TYPE_ROUTER_ID,

                .flags = BAF_OPTIONAL,

                .export = bgp_export_originator_id,

                .encode = bgp_encode_u32,

                .decode = bgp_decode_originator_id,

        },

        [BA_CLUSTER_LIST] = {

                .name = "cluster_list",

                .type = EAF_TYPE_INT_SET,

                .flags = BAF_OPTIONAL,

                .export = bgp_export_cluster_list,

                .encode = bgp_encode_u32s,

                .decode = bgp_decode_cluster_list,

                .format = bgp_format_cluster_list,

        },

        [BA_MP_REACH_NLRI] = {

                .name = "mp_reach_nlri",

                .type = EAF_TYPE_OPAQUE,