Method UpdateDBL3Vpn

Server/src/bgp/parseBGP.cpp:468–561

* Update the Database advertised l3vpn * * \details This method will update the database for the supplied advertised prefixes * * \param [in] remove True if the records should be deleted, false if they are to be added/updated * \param [in] prefixes Reference to the list of advertised vpns * \param [in] attrs Reference to the parsed attributes map */

 * \param [in] attrs           Reference to the parsed attributes map
 */
void parseBGP::UpdateDBL3Vpn(bool remove, std::list<bgp::vpn_tuple> &prefixes,
                             bgp_msg::UpdateMsg::parsed_attrs_map &attrs) {
    vector<MsgBusInterface::obj_vpn> rib_list;
    MsgBusInterface::obj_vpn         rib_entry;
    uint32_t                         value_32bit;
    uint64_t                         value_64bit;

    /*
     * Loop through all vpn and add/update them in the DB
     */
    for (std::list<bgp::vpn_tuple>::iterator it = prefixes.begin();
                                                it != prefixes.end();
                                                it++) {
        bgp::vpn_tuple &tuple = (*it);

        memcpy(rib_entry.path_attr_hash_id, path_hash_id, sizeof(rib_entry.path_attr_hash_id));
        memcpy(rib_entry.peer_hash_id, p_entry->hash_id, sizeof(rib_entry.peer_hash_id));

        rib_entry.rd_type = tuple.rd_type;
        rib_entry.rd_assigned_number = tuple.rd_assigned_number;
        rib_entry.rd_administrator_subfield = tuple.rd_administrator_subfield;

        strncpy(rib_entry.prefix, tuple.prefix.c_str(), sizeof(rib_entry.prefix));
        
        rib_entry.prefix_len = tuple.len;

        snprintf(rib_entry.labels, sizeof(rib_entry.labels), "%s", tuple.labels.c_str());
        
        rib_entry.isIPv4 = tuple.isIPv4 ? 1 : 0;

        memcpy(rib_entry.prefix_bin, tuple.prefix_bin, sizeof(rib_entry.prefix_bin));

        // Add the ending IP for the prefix based on bits
        if (rib_entry.isIPv4) {
            if (tuple.len < 32) {
                memcpy(&value_32bit, tuple.prefix_bin, 4);
                bgp::SWAP_BYTES(&value_32bit);

                value_32bit |= 0xFFFFFFFF >> tuple.len;
                bgp::SWAP_BYTES(&value_32bit);
                memcpy(rib_entry.prefix_bcast_bin, &value_32bit, 4);

            } else
                memcpy(rib_entry.prefix_bcast_bin, tuple.prefix_bin, sizeof(tuple.prefix_bin));

        } else {
            if (tuple.len < 128) {
                if (tuple.len >= 64) {
                    // High order bytes are left alone
                    memcpy(rib_entry.prefix_bcast_bin, tuple.prefix_bin, 8);

                    // Low order bytes are updated
                    memcpy(&value_64bit, &tuple.prefix_bin[8], 8);
                    bgp::SWAP_BYTES(&value_64bit);

                    value_64bit |= 0xFFFFFFFFFFFFFFFF >> (tuple.len - 64);
                    bgp::SWAP_BYTES(&value_64bit);
                    memcpy(&rib_entry.prefix_bcast_bin[8], &value_64bit, 8);