trib.h

Go to the documentation of this file.

/*
 
    trip: Modern TRIP LS implementation
    Copyright (C) 2025 arf20 (Ángel Ruiz Fernandez)
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
*/

 
#ifndef _TRIB_H
#define _TRIB_H
 
#include <protocol/protocol.h>
#include <functions/locator.h>
 
#include "pib.h"
 
#include <stddef.h>
#include <time.h>
 
#define ATTR_USED_NEXTHOP               0b1
#define ATTR_USED_ADVERTPATH            0b10
#define ATTR_USED_ROUTEDPATH            0b100
#define ATTR_USED_LOCALPREF             0b1000
#define ATTR_USED_METRIC                0b10000
#define ATTR_USED_COMMUNITIES           0b100000
 
#define ATTR_IS_USED_NEXTHOP(x)         (((x) >> 0) & 1)
#define ATTR_IS_USED_ADVERTPATH(x)      (((x) >> 1) & 1)
#define ATTR_IS_USED_ROUTEDPATH(x)      (((x) >> 2) & 1)
#define ATTR_IS_USED_LOCALPREF(x)       (((x) >> 3) & 1)
#define ATTR_IS_USED_METRIC(x)          (((x) >> 4) & 1)
#define ATTR_IS_USED_COMMUNITIES(x)     (((x) >> 5) & 1)
 

typedef struct {
    uint32_t    use;            
    int         withdrawn;      
    uint32_t    nextitad;       
    char       *nexthop;        
    uint32_t   *advertpath;     
    size_t      advertpath_size;
    uint32_t   *routedpath;     
    size_t      routedpath_size;
    int         atomicaggregate;
    uint32_t    local_pref;     
    uint32_t    metric;         
    community_t*communities;    
    size_t      communities_size;
    int         convertedroute; 
} entry_attrs_t;
 
typedef enum {
    ENTRY_TYPE_TRIP,
    ENTRY_TYPE_CONNECTED,
    ENTRY_TYPE_STATIC
} entry_type_t;
 
extern const char *entry_type_strs[];

typedef struct {
    /* route */
    uint16_t    af;             
    uint16_t    app_proto;      
    char       *prefix;         
 
    entry_type_t type;          
 
    uint32_t    origin_itad;    
    
    /* learned from */
    uint32_t    learn_itad;     
    uint32_t    learn_lsid;     
    const peer_t *learn_peer;   
 
    int32_t     seq;            
    time_t      time;           
 
    entry_attrs_t attrs;        
    
    int         sent;           
} entry_t;

typedef struct {
    uint32_t    peer_itad, peer_id;      
    entry_t   **table;
    size_t      size, capacity;
    routemap_t *routemap;       
} table_t;
 
 
typedef struct {
    entry_attrs_t attrs;        
    entry_t   **entries;        
    size_t      size, capacity;
} entry_group_t;

typedef struct {
    uint32_t    local_itad;   
 
    table_t     loc_trib, optimized_loc_trib;
 
    table_t   **adj_tribs_in, **adj_tribs_out; 
    size_t      adj_tribs_capacity, adj_tribs_size;
    
    table_t     ext_trib;
 
    table_t     local_routes;
} trib_t;
 

entry_t *entry_clone(const entry_t *entry);
void entry_destroy(entry_t *entry);

void trib_table_deinit(table_t *t);

trib_t *trib_new(uint32_t local_itad);
void trib_adj_pair_add(trib_t *trib, table_t *in, table_t *out);
void trib_adj_pair_remove(trib_t *trib, table_t *in, table_t *out);
void trib_destroy(trib_t *trib);

entry_t **trib_table_find(table_t *t, uint16_t af, const char *prefix);

const entry_t *trib_table_lookup(const table_t *table, uint16_t af,
    uint16_t app_proto, const char *address);

void trib_table_insert(table_t *table, entry_t *route);
 
void trib_table_insert_or_replace(table_t *table, entry_t *route);

void trib_table_clear(table_t *table);
 

void trib_update_local(trib_t *trib);

void trib_update_adj_out(trib_t *trib, table_t *adj_trib_out);

void trib_update_full(trib_t *trib);

size_t get_new_entries(const table_t *table, entry_t ***new_ents_out);

size_t group_entries_by_attrs(entry_t **entries, size_t entries_size,
    entry_group_t **groups_out);
 
#endif /* _TRIB_H */