From 44d8276063718ca4781e0ac86b41cea0b3547c87 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matthias=20Br=C3=A4uer?= Date: Fri, 8 Aug 2025 17:30:03 +0200 Subject: [PATCH] rtrlib: Make API consistent - To avoid name clashes and have a consistent API naming, every function, enum, struct, ... that is exported is prefixed with `rtr_`/`RTR_`. - `int` return types are changed to the pertinent `enum` type if applicable. - Change `bool` type to indicate the performed operation when notifying users about changes in the SPKI and PFX tables to specific `enum` type to improve readability and make the API specification stricter. - Make names of validation functions consistent --- doxygen/examples/rtr_mgr.c | 28 +- doxygen/examples/ssh_tr.c | 6 +- rtrlib/aspa/aspa.c | 272 +++++++-------- rtrlib/aspa/aspa.h | 54 +-- rtrlib/aspa/aspa_array/aspa_array.c | 82 ++--- rtrlib/aspa/aspa_array/aspa_array.h | 26 +- rtrlib/aspa/aspa_private.h | 26 +- rtrlib/aspa/aspa_verification.c | 45 +-- rtrlib/bgpsec/bgpsec.c | 62 ++-- rtrlib/bgpsec/bgpsec_private.h | 14 +- rtrlib/bgpsec/bgpsec_utils.c | 24 +- rtrlib/bgpsec/bgpsec_utils_private.h | 8 +- rtrlib/lib/alloc_utils.c | 20 +- rtrlib/lib/alloc_utils.h | 6 +- rtrlib/lib/alloc_utils_private.h | 14 +- rtrlib/lib/convert_byte_order.c | 4 +- rtrlib/lib/convert_byte_order_private.h | 10 +- rtrlib/lib/ip.c | 52 +-- rtrlib/lib/ip.h | 54 +-- rtrlib/lib/ip_private.h | 36 +- rtrlib/lib/ipv4.c | 16 +- rtrlib/lib/ipv4.h | 6 +- rtrlib/lib/ipv4_private.h | 14 +- rtrlib/lib/ipv6.c | 28 +- rtrlib/lib/ipv6.h | 8 +- rtrlib/lib/ipv6_private.h | 26 +- rtrlib/lib/log.c | 2 +- rtrlib/lib/log_private.h | 6 +- rtrlib/lib/utils.c | 4 +- rtrlib/lib/utils_private.h | 8 +- rtrlib/pfx/pfx.h | 66 ++-- rtrlib/pfx/pfx_private.h | 8 +- rtrlib/pfx/trie/trie-pfx.c | 329 +++++++++--------- rtrlib/pfx/trie/trie-pfx.h | 26 +- rtrlib/pfx/trie/trie.c | 24 +- rtrlib/pfx/trie/trie_private.h | 14 +- rtrlib/rtr/packets.c | 194 +++++------ rtrlib/rtr/rtr.c | 20 +- rtrlib/rtr/rtr.h | 8 +- rtrlib/rtr/rtr_private.h | 8 +- rtrlib/rtr_mgr.c | 154 +++++---- rtrlib/rtr_mgr.h | 74 ++-- rtrlib/spki/hashtable/ht-spkitable.c | 102 +++--- rtrlib/spki/hashtable/ht-spkitable_private.h | 6 +- rtrlib/spki/spkitable.h | 20 +- rtrlib/spki/spkitable_private.h | 34 +- rtrlib/transport/ssh/ssh_transport.c | 78 ++--- rtrlib/transport/ssh/ssh_transport.h | 4 +- rtrlib/transport/tcp/tcp_transport.c | 88 ++--- rtrlib/transport/tcp/tcp_transport.h | 4 +- rtrlib/transport/transport.c | 24 +- rtrlib/transport/transport.h | 20 +- rtrlib/transport/transport_private.h | 18 +- tests/test_as_path_verification.c | 341 ++++++++++--------- tests/test_aspa.c | 98 +++--- tests/test_aspa_array.c | 78 ++--- tests/test_bgpsec.c | 30 +- tests/test_dynamic_groups.c | 22 +- tests/test_getbits.c | 112 +++--- tests/test_ht_spkitable.c | 145 ++++---- tests/test_ht_spkitable_locks.c | 26 +- tests/test_ipaddr.c | 146 ++++---- tests/test_live_disabled_features.c | 6 +- tests/test_live_fetching.c | 6 +- tests/test_live_validation.c | 30 +- tests/test_pfx.c | 305 ++++++++--------- tests/test_pfx_locks.c | 54 +-- tests/test_trie.c | 68 ++-- tests/unittests/CMakeLists.txt | 2 +- tests/unittests/test_bgpsec_signing.c | 94 ++--- tests/unittests/test_bgpsec_validation.c | 76 ++--- tests/unittests/test_packets_static.c | 10 +- tests/unittests/test_packets_static.h | 2 +- third-party/tommyds/tommytypes.h | 8 +- tools/rpki-rov.c | 25 +- tools/rtrclient.c | 66 ++-- 76 files changed, 2056 insertions(+), 1978 deletions(-) diff --git a/doxygen/examples/rtr_mgr.c b/doxygen/examples/rtr_mgr.c index 7d0e5a8a..dd339882 100644 --- a/doxygen/examples/rtr_mgr.c +++ b/doxygen/examples/rtr_mgr.c @@ -34,8 +34,8 @@ int main() char ssh_user[] = "rpki_user"; char ssh_hostkey[] = "/etc/rpki-rtr/hostkey"; char ssh_privkey[] = "/etc/rpki-rtr/client.priv"; - struct tr_socket tr_ssh; - struct tr_ssh_config config = { + struct rtr_tr_socket tr_ssh; + struct rtr_tr_ssh_config config = { ssh_host, //IP 22, //Port NULL, //Source address @@ -47,14 +47,14 @@ int main() 0, // connect timeout NULL, // password }; - tr_ssh_init(&config, &tr_ssh); + rtr_tr_ssh_init(&config, &tr_ssh); //create a TCP transport socket - struct tr_socket tr_tcp; + struct rtr_tr_socket tr_tcp; char tcp_host[] = "rpki-validator.realmv6.org"; char tcp_port[] = "8282"; - struct tr_tcp_config tcp_config = { + struct rtr_tr_tcp_config tcp_config = { tcp_host, //IP tcp_port, //Port NULL, //Source address @@ -62,7 +62,7 @@ int main() NULL, //get_socket() 0, // connect timeout }; - tr_tcp_init(&tcp_config, &tr_tcp); + rtr_tr_tcp_init(&tcp_config, &tr_tcp); //create 3 rtr_sockets and associate them with the transprort sockets struct rtr_socket rtr_ssh, rtr_tcp; @@ -99,26 +99,26 @@ int main() } //validate the BGP-Route 10.10.0.0/24, origin ASN: 12345 - struct lrtr_ip_addr pref; - lrtr_ip_str_to_addr("10.10.0.0", &pref); - enum pfxv_state result; + struct rtr_ip_addr pref; + rtr_ip_str_to_addr("10.10.0.0", &pref); + enum rtr_pfxv_state result; const uint8_t mask = 24; - rtr_mgr_validate(conf, 12345, &pref, mask, &result); + rtr_mgr_roa_validate(conf, 12345, &pref, mask, &result); //output the result of the prefix validation above //to showcase the returned states. char buffer[INET_ADDRSTRLEN]; - lrtr_ip_addr_to_str(&pref, buffer, sizeof(buffer)); + rtr_ip_addr_to_str(&pref, buffer, sizeof(buffer)); printf("RESULT: The prefix %s/%i ", buffer, mask); switch (result) { - case BGP_PFXV_STATE_VALID: + case RTR_BGP_PFXV_STATE_VALID: printf("is valid.\n"); break; - case BGP_PFXV_STATE_INVALID: + case RTR_BGP_PFXV_STATE_INVALID: printf("is invalid.\n"); break; - case BGP_PFXV_STATE_NOT_FOUND: + case RTR_BGP_PFXV_STATE_NOT_FOUND: printf("was not found.\n"); break; default: diff --git a/doxygen/examples/ssh_tr.c b/doxygen/examples/ssh_tr.c index 28876ca2..c5786815 100644 --- a/doxygen/examples/ssh_tr.c +++ b/doxygen/examples/ssh_tr.c @@ -4,15 +4,15 @@ int main() { - struct tr_socket ssh_socket; + struct rtr_tr_socket ssh_socket; char ssh_host[] = "123.231.123.221"; char ssh_user[] = "rpki_user"; char ssh_hostkey[] = "/etc/rpki-rtr/hostkey"; char ssh_privkey[] = "/etc/rpki-rtr/client.priv"; - struct tr_ssh_config config = { + struct rtr_tr_ssh_config config = { ssh_host, 22, NULL, ssh_user, ssh_hostkey, ssh_privkey, NULL, NULL, 0, NULL }; - tr_ssh_init(&config, &ssh_socket); + rtr_tr_ssh_init(&config, &ssh_socket); } diff --git a/rtrlib/aspa/aspa.c b/rtrlib/aspa/aspa.c index ce5134fe..6a08b837 100644 --- a/rtrlib/aspa/aspa.c +++ b/rtrlib/aspa/aspa.c @@ -17,24 +17,24 @@ #include #include -static enum aspa_status aspa_table_notify_clients(struct aspa_table *aspa_table, struct aspa_record *record, - const struct rtr_socket *rtr_socket, - const enum aspa_operation_type operation_type) +static enum rtr_aspa_status aspa_table_notify_clients(struct rtr_aspa_table *aspa_table, struct rtr_aspa_record *record, + const struct rtr_socket *rtr_socket, + const enum rtr_aspa_operation_type operation_type) { if (!aspa_table || !rtr_socket) - return ASPA_ERROR; + return RTR_ASPA_ERROR; if (aspa_table->update_fp && record) { // Realloc in order not to expose internal record - struct aspa_record rec = *record; + struct rtr_aspa_record rec = *record; if (record->provider_asns && record->provider_count > 0) { size_t size = sizeof(uint32_t) * record->provider_count; - rec.provider_asns = lrtr_malloc(size); + rec.provider_asns = rtr_malloc(size); if (rec.provider_asns == NULL) { - return ASPA_ERROR; + return RTR_ASPA_ERROR; } memcpy(rec.provider_asns, record->provider_asns, size); @@ -45,20 +45,20 @@ static enum aspa_status aspa_table_notify_clients(struct aspa_table *aspa_table, aspa_table->update_fp(aspa_table, rec, rtr_socket, operation_type); } - return ASPA_SUCCESS; + return RTR_ASPA_SUCCESS; } -static enum aspa_status aspa_store_create_node(struct aspa_store_node **store, struct rtr_socket *rtr_socket, - struct aspa_array *aspa_array, struct aspa_store_node ***new_node) +static enum rtr_aspa_status aspa_store_create_node(struct aspa_store_node **store, struct rtr_socket *rtr_socket, + struct aspa_array *aspa_array, struct aspa_store_node ***new_node) { if (!rtr_socket) - return ASPA_ERROR; + return RTR_ASPA_ERROR; // Allocate new node - struct aspa_store_node *new = lrtr_malloc(sizeof(struct aspa_store_node)); + struct aspa_store_node *new = rtr_malloc(sizeof(struct aspa_store_node)); if (!new) - return ASPA_ERROR; + return RTR_ASPA_ERROR; // Store socket and ASPA array new->rtr_socket = rtr_socket; @@ -71,14 +71,14 @@ static enum aspa_status aspa_store_create_node(struct aspa_store_node **store, s if (new_node) *new_node = store; - return ASPA_SUCCESS; + return RTR_ASPA_SUCCESS; } static void aspa_store_remove_node(struct aspa_store_node **node) { struct aspa_store_node *tmp = *node; *node = (*node)->next; - lrtr_free(tmp); + rtr_free(tmp); } static struct aspa_store_node **aspa_store_get_node(struct aspa_store_node **node, const struct rtr_socket *rtr_socket) @@ -95,7 +95,7 @@ static struct aspa_store_node **aspa_store_get_node(struct aspa_store_node **nod return NULL; } -RTRLIB_EXPORT void aspa_table_init(struct aspa_table *aspa_table, aspa_update_fp update_fp) +RTRLIB_EXPORT void rtr_aspa_table_init(struct rtr_aspa_table *aspa_table, rtr_aspa_update_fp update_fp) { aspa_table->update_fp = update_fp; aspa_table->store = NULL; @@ -103,15 +103,15 @@ RTRLIB_EXPORT void aspa_table_init(struct aspa_table *aspa_table, aspa_update_fp pthread_rwlock_init(&(aspa_table->update_lock), NULL); } -static enum aspa_status aspa_table_remove_node(struct aspa_table *aspa_table, struct aspa_store_node **node, - bool notify) +static enum rtr_aspa_status aspa_table_remove_node(struct rtr_aspa_table *aspa_table, struct aspa_store_node **node, + bool notify) { if (!node) - return ASPA_ERROR; + return RTR_ASPA_ERROR; if (!*node) // Doesn't exist anymore - return ASPA_SUCCESS; + return RTR_ASPA_SUCCESS; struct aspa_array *array = (*node)->aspa_array; struct rtr_socket *socket = (*node)->rtr_socket; @@ -121,26 +121,26 @@ static enum aspa_status aspa_table_remove_node(struct aspa_table *aspa_table, st if (!array) // Doesn't exist anymore - return ASPA_SUCCESS; + return RTR_ASPA_SUCCESS; // Notify clients about these records being removed if (notify) { for (size_t i = 0; i < array->size; i++) - aspa_table_notify_clients(aspa_table, aspa_array_get_record(array, i), socket, false); + aspa_table_notify_clients(aspa_table, aspa_array_get_record(array, i), socket, RTR_ASPA_REMOVE); } // Release all records and their provider sets aspa_array_free(array, true); - return ASPA_SUCCESS; + return RTR_ASPA_SUCCESS; } -RTRLIB_EXPORT enum aspa_status aspa_table_src_remove(struct aspa_table *aspa_table, struct rtr_socket *rtr_socket, - bool notify) +RTRLIB_EXPORT enum rtr_aspa_status rtr_aspa_table_src_remove(struct rtr_aspa_table *aspa_table, + struct rtr_socket *rtr_socket, bool notify) { if (aspa_table == NULL) { ASPA_DBG1("ASPA table is not initialized. Nothing to remove."); - return ASPA_SUCCESS; + return RTR_ASPA_SUCCESS; } pthread_rwlock_wrlock(&aspa_table->update_lock); @@ -151,17 +151,17 @@ RTRLIB_EXPORT enum aspa_status aspa_table_src_remove(struct aspa_table *aspa_tab if (!node || !*node) { // Already gone pthread_rwlock_unlock(&(aspa_table->lock)); - return ASPA_SUCCESS; + return RTR_ASPA_SUCCESS; } - enum aspa_status res = aspa_table_remove_node(aspa_table, node, notify); + enum rtr_aspa_status res = aspa_table_remove_node(aspa_table, node, notify); pthread_rwlock_unlock(&(aspa_table->lock)); pthread_rwlock_unlock(&aspa_table->update_lock); return res; } -RTRLIB_EXPORT void aspa_table_free(struct aspa_table *aspa_table, bool notify) +RTRLIB_EXPORT void rtr_aspa_table_free(struct rtr_aspa_table *aspa_table, bool notify) { if (aspa_table == NULL) { ASPA_DBG1("ASPA table is not initialized. Nothing to free."); @@ -183,11 +183,11 @@ RTRLIB_EXPORT void aspa_table_free(struct aspa_table *aspa_table, bool notify) pthread_rwlock_destroy(&aspa_table->update_lock); } -enum aspa_status aspa_table_src_replace(struct aspa_table *dst, struct aspa_table *src, struct rtr_socket *rtr_socket, - bool notify_dst, bool notify_src) +enum rtr_aspa_status aspa_table_src_replace(struct rtr_aspa_table *dst, struct rtr_aspa_table *src, + struct rtr_socket *rtr_socket, bool notify_dst, bool notify_src) { if (!dst || !src || !rtr_socket || src == dst) - return ASPA_ERROR; + return RTR_ASPA_ERROR; pthread_rwlock_wrlock(&dst->update_lock); pthread_rwlock_wrlock(&src->update_lock); @@ -201,7 +201,7 @@ enum aspa_status aspa_table_src_replace(struct aspa_table *dst, struct aspa_tabl pthread_rwlock_unlock(&dst->lock); pthread_rwlock_unlock(&src->update_lock); pthread_rwlock_unlock(&dst->update_lock); - return ASPA_ERROR; + return RTR_ASPA_ERROR; } struct aspa_array *new_array = (*src_node)->aspa_array; @@ -217,12 +217,12 @@ enum aspa_status aspa_table_src_replace(struct aspa_table *dst, struct aspa_tabl } else { // There's no old_array. // Destination table hasn't got an existing store node for the socket, so create a new one - if (aspa_store_create_node(&dst->store, rtr_socket, new_array, NULL) != ASPA_SUCCESS) { + if (aspa_store_create_node(&dst->store, rtr_socket, new_array, NULL) != RTR_ASPA_SUCCESS) { pthread_rwlock_unlock(&src->lock); pthread_rwlock_unlock(&dst->lock); pthread_rwlock_unlock(&src->update_lock); pthread_rwlock_unlock(&dst->update_lock); - return ASPA_ERROR; + return RTR_ASPA_ERROR; } } @@ -236,14 +236,15 @@ enum aspa_status aspa_table_src_replace(struct aspa_table *dst, struct aspa_tabl if (notify_src) // Notify src clients their records are being removed for (size_t i = 0; i < new_array->size; i++) - aspa_table_notify_clients(src, aspa_array_get_record(new_array, i), rtr_socket, ASPA_REMOVE); + aspa_table_notify_clients(src, aspa_array_get_record(new_array, i), rtr_socket, + RTR_ASPA_REMOVE); if (old_array) { if (notify_dst) // Notify dst clients of their existing records are being removed for (size_t i = 0; i < old_array->size; i++) aspa_table_notify_clients(dst, aspa_array_get_record(old_array, i), rtr_socket, - ASPA_REMOVE); + RTR_ASPA_REMOVE); // Free the old array and their provider sets aspa_array_free(old_array, true); @@ -252,9 +253,9 @@ enum aspa_status aspa_table_src_replace(struct aspa_table *dst, struct aspa_tabl if (notify_dst) // Notify dst clients the records from src are added for (size_t i = 0; i < new_array->size; i++) - aspa_table_notify_clients(dst, aspa_array_get_record(new_array, i), rtr_socket, ASPA_ADD); + aspa_table_notify_clients(dst, aspa_array_get_record(new_array, i), rtr_socket, RTR_ASPA_ADD); - return ASPA_SUCCESS; + return RTR_ASPA_SUCCESS; } // MARK: - Updating an ASPA table @@ -289,10 +290,10 @@ static int compare_asns(const void *a, const void *b) * * @warning Do not call this function manually. This function fails if zero operations are supplied! */ -static enum aspa_status aspa_table_update_compute_internal(struct rtr_socket *rtr_socket, struct aspa_array *array, - struct aspa_array *new_array, - struct aspa_update_operation *operations, size_t count, - struct aspa_update_operation **failed_operation) +static enum rtr_aspa_status aspa_table_update_compute_internal(struct rtr_socket *rtr_socket, struct aspa_array *array, + struct aspa_array *new_array, + struct aspa_update_operation *operations, size_t count, + struct aspa_update_operation **failed_operation) { // Fail hard in debug builds. assert(rtr_socket); @@ -312,7 +313,7 @@ static enum aspa_status aspa_table_update_compute_internal(struct rtr_socket *rt #ifndef NDEBUG // Sanity check record - if (current->type == ASPA_REMOVE) { + if (current->type == RTR_ASPA_REMOVE) { assert(current->record.provider_count == 0); assert(!current->record.provider_asns); } @@ -326,23 +327,23 @@ static enum aspa_status aspa_table_update_compute_internal(struct rtr_socket *rt compare_asns); while (existing_i < array->size) { - struct aspa_record *existing_record = aspa_array_get_record(array, existing_i); + struct rtr_aspa_record *existing_record = aspa_array_get_record(array, existing_i); // Skip over records untouched by these add/remove operations if (existing_record->customer_asn < current->record.customer_asn) { existing_i += 1; // Append existing record (reuse existing provider array) - if (aspa_array_append(new_array, existing_record, false) != ASPA_SUCCESS) { + if (aspa_array_append(new_array, existing_record, false) != RTR_ASPA_SUCCESS) { *failed_operation = current; - return ASPA_ERROR; + return RTR_ASPA_ERROR; } } else { break; } } - struct aspa_record *existing_record = aspa_array_get_record(array, existing_i); + struct rtr_aspa_record *existing_record = aspa_array_get_record(array, existing_i); // existing record and current op have matching CAS bool existing_matches_current = existing_record && @@ -352,13 +353,13 @@ static enum aspa_status aspa_table_update_compute_internal(struct rtr_socket *rt bool next_matches_current = next && next->record.customer_asn == current->record.customer_asn; // MARK: Handling 'add' operations - if (current->type == ASPA_ADD) { + if (current->type == RTR_ASPA_ADD) { // Attempt to add record with $CAS twice. // Error: Duplicate Add. - if (next_matches_current && next->type == ASPA_ADD) { + if (next_matches_current && next->type == RTR_ASPA_ADD) { *failed_operation = next; current->record.provider_asns = NULL; - return ASPA_DUPLICATE_RECORD; + return RTR_ASPA_DUPLICATE_RECORD; } // This operation adds a new ASPA record with some $CAS; the next operation, however, @@ -366,7 +367,7 @@ static enum aspa_status aspa_table_update_compute_internal(struct rtr_socket *rt // // Independently, if a record for this customer number already exists or not, both // instructions cancel each other out and will remove an already present ASPA record. - if (next_matches_current && next->type == ASPA_REMOVE) { + if (next_matches_current && next->type == RTR_ASPA_REMOVE) { // Scenario 1 if (existing_matches_current) { // "Remove" record by simply not appending it to the new array @@ -396,9 +397,9 @@ static enum aspa_status aspa_table_update_compute_internal(struct rtr_socket *rt } // Add record by appending it to new array (copy providers) - if (aspa_array_append(new_array, ¤t->record, true) != ASPA_SUCCESS) { + if (aspa_array_append(new_array, ¤t->record, true) != RTR_ASPA_SUCCESS) { *failed_operation = current; - return ASPA_ERROR; + return RTR_ASPA_ERROR; } // If it's an add operation, we insert a reference to the newly created record's providers. @@ -407,19 +408,19 @@ static enum aspa_status aspa_table_update_compute_internal(struct rtr_socket *rt } // MARK: Handling 'remove' operations - else if (current->type == ASPA_REMOVE) { + else if (current->type == RTR_ASPA_REMOVE) { // Attempt to remove record with $CAS, but record with $CAS does not exist // Error: Removal of unknown record. if (!existing_matches_current) { *failed_operation = current; - return ASPA_RECORD_NOT_FOUND; + return RTR_ASPA_RECORD_NOT_FOUND; } // Attempt to remove record with $CAS twice. // Error: Removal of unknown record. - if (next_matches_current && next->type == ASPA_REMOVE) { + if (next_matches_current && next->type == RTR_ASPA_REMOVE) { *failed_operation = next; - return ASPA_RECORD_NOT_FOUND; + return RTR_ASPA_RECORD_NOT_FOUND; } // "Remove" record by simply not appending it to the new array @@ -431,8 +432,8 @@ static enum aspa_status aspa_table_update_compute_internal(struct rtr_socket *rt } } - struct aspa_record *last_record_from_new_array = aspa_array_get_record(new_array, new_array->size - 1); - struct aspa_record *next_record_from_old_array = aspa_array_get_record(array, existing_i); + struct rtr_aspa_record *last_record_from_new_array = aspa_array_get_record(new_array, new_array->size - 1); + struct rtr_aspa_record *next_record_from_old_array = aspa_array_get_record(array, existing_i); // If the customer AS number of the next element in the old array is already in the new array, skip that // element and don't copy it to the new array below. @@ -445,12 +446,12 @@ static enum aspa_status aspa_table_update_compute_internal(struct rtr_socket *rt for (; existing_i < array->size; existing_i++) aspa_array_append(new_array, aspa_array_get_record(array, existing_i), false); - return ASPA_SUCCESS; + return RTR_ASPA_SUCCESS; } -enum aspa_status aspa_table_update_swap_in_compute(struct aspa_table *aspa_table, struct rtr_socket *rtr_socket, - struct aspa_update_operation *operations, size_t count, - struct aspa_update **update) +enum rtr_aspa_status aspa_table_update_swap_in_compute(struct rtr_aspa_table *aspa_table, struct rtr_socket *rtr_socket, + struct aspa_update_operation *operations, size_t count, + struct aspa_update **update) { // Fail hard in debug builds. assert(aspa_table); @@ -458,16 +459,16 @@ enum aspa_status aspa_table_update_swap_in_compute(struct aspa_table *aspa_table assert(update); if (!aspa_table || !rtr_socket || !update || ((count > 0) && !operations)) - return ASPA_ERROR; + return RTR_ASPA_ERROR; if (count == 0) - return ASPA_SUCCESS; + return RTR_ASPA_SUCCESS; if (!*update) { - *update = lrtr_malloc(sizeof(struct aspa_update)); + *update = rtr_malloc(sizeof(struct aspa_update)); if (!*update) - return ASPA_ERROR; + return RTR_ASPA_ERROR; } // MARK: Update Lock @@ -493,16 +494,16 @@ enum aspa_status aspa_table_update_swap_in_compute(struct aspa_table *aspa_table // The given table doesn't have a node for that socket, so create one struct aspa_array *a = NULL; - if (aspa_array_create(&a) != ASPA_SUCCESS) - return ASPA_ERROR; + if (aspa_array_create(&a) != RTR_ASPA_SUCCESS) + return RTR_ASPA_ERROR; // Insert into table pthread_rwlock_wrlock(&aspa_table->lock); - if (aspa_store_create_node(&aspa_table->store, rtr_socket, a, &node) != ASPA_SUCCESS || !node || + if (aspa_store_create_node(&aspa_table->store, rtr_socket, a, &node) != RTR_ASPA_SUCCESS || !node || !*node) { aspa_array_free(a, false); pthread_rwlock_unlock(&aspa_table->lock); - return ASPA_ERROR; + return RTR_ASPA_ERROR; } pthread_rwlock_unlock(&aspa_table->lock); } @@ -514,16 +515,16 @@ enum aspa_status aspa_table_update_swap_in_compute(struct aspa_table *aspa_table // Create new array that will hold updated record data struct aspa_array *new_array = NULL; - if (aspa_array_create(&new_array) != ASPA_SUCCESS) - return ASPA_ERROR; + if (aspa_array_create(&new_array) != RTR_ASPA_SUCCESS) + return RTR_ASPA_ERROR; // Populate new_array pthread_rwlock_rdlock(&aspa_table->lock); - enum aspa_status res = aspa_table_update_compute_internal(rtr_socket, (*node)->aspa_array, new_array, - operations, count, &(*update)->failed_operation); + enum rtr_aspa_status res = aspa_table_update_compute_internal(rtr_socket, (*node)->aspa_array, new_array, + operations, count, &(*update)->failed_operation); pthread_rwlock_unlock(&aspa_table->lock); - if (res == ASPA_SUCCESS) { + if (res == RTR_ASPA_SUCCESS) { (*update)->node = *node; (*update)->new_array = new_array; } else { @@ -589,9 +590,9 @@ static void aspa_table_update_swap_in_consume(struct aspa_update **update_pointe // If it's a remove operation, we need to deallocate the existing record's // provider array as it is no longer present in the new ASPA array. - if (!op->is_no_op && op->type == ASPA_REMOVE) { + if (!op->is_no_op && op->type == RTR_ASPA_REMOVE) { if (op->record.provider_asns) - lrtr_free(op->record.provider_asns); + rtr_free(op->record.provider_asns); op->record.provider_asns = NULL; op->record.provider_count = 0; @@ -603,9 +604,9 @@ static void aspa_table_update_swap_in_consume(struct aspa_update **update_pointe // If it's an add operation, we need to deallocate the newly created record's // provider array as it is not needed - if (!op->is_no_op && op->type == ASPA_ADD) { + if (!op->is_no_op && op->type == RTR_ASPA_ADD) { if (op->record.provider_asns) - lrtr_free(op->record.provider_asns); + rtr_free(op->record.provider_asns); op->record.provider_asns = NULL; } @@ -620,7 +621,7 @@ static void aspa_table_update_swap_in_consume(struct aspa_update **update_pointe aspa_array_free(update->new_array, false); if (update->operations) - lrtr_free(update->operations); + rtr_free(update->operations); update->operations = NULL; update->operation_count = 0; @@ -628,7 +629,7 @@ static void aspa_table_update_swap_in_consume(struct aspa_update **update_pointe update->new_array = NULL; update->node = NULL; update->table = NULL; - lrtr_free(update); + rtr_free(update); } void aspa_table_update_swap_in_apply(struct aspa_update **update_pointer) @@ -643,9 +644,9 @@ void aspa_table_update_swap_in_discard(struct aspa_update **update_pointer) // MARK: - In-Place Update Mechanism -enum aspa_status aspa_table_update_in_place(struct aspa_table *aspa_table, struct rtr_socket *rtr_socket, - struct aspa_update_operation *operations, size_t count, - struct aspa_update_operation **failed_operation) +enum rtr_aspa_status aspa_table_update_in_place(struct rtr_aspa_table *aspa_table, struct rtr_socket *rtr_socket, + struct aspa_update_operation *operations, size_t count, + struct aspa_update_operation **failed_operation) { // Fail hard in debug builds. assert(aspa_table); @@ -653,10 +654,10 @@ enum aspa_status aspa_table_update_in_place(struct aspa_table *aspa_table, struc assert(failed_operation); if (!aspa_table || !rtr_socket || !failed_operation || ((count > 0) && !operations)) - return ASPA_ERROR; + return RTR_ASPA_ERROR; if (count == 0) - return ASPA_SUCCESS; + return RTR_ASPA_SUCCESS; // stable sort operations, so operations dealing with the same customer ASN // are located right next to each other @@ -669,15 +670,15 @@ enum aspa_status aspa_table_update_in_place(struct aspa_table *aspa_table, struc // The given table doesn't have a node for that socket, so create one struct aspa_array *a = NULL; - if (aspa_array_create(&a) != ASPA_SUCCESS) - return ASPA_ERROR; + if (aspa_array_create(&a) != RTR_ASPA_SUCCESS) + return RTR_ASPA_ERROR; // Insert into table - if (aspa_store_create_node(&aspa_table->store, rtr_socket, a, &node) != ASPA_SUCCESS || !node || + if (aspa_store_create_node(&aspa_table->store, rtr_socket, a, &node) != RTR_ASPA_SUCCESS || !node || !*node) { aspa_array_free(a, false); pthread_rwlock_unlock(&aspa_table->lock); - return ASPA_ERROR; + return RTR_ASPA_ERROR; } } @@ -697,7 +698,7 @@ enum aspa_status aspa_table_update_in_place(struct aspa_table *aspa_table, struc #ifndef NDEBUG // Sanity check record - if (current->type == ASPA_REMOVE) { + if (current->type == RTR_ASPA_REMOVE) { assert(current->record.provider_count == 0); assert(!current->record.provider_asns); } @@ -715,7 +716,7 @@ enum aspa_status aspa_table_update_in_place(struct aspa_table *aspa_table, struc existing_i += 1; } - struct aspa_record *existing_record = aspa_array_get_record(array, existing_i); + struct rtr_aspa_record *existing_record = aspa_array_get_record(array, existing_i); // existing record and current op have matching CAS bool existing_matches_current = existing_record && @@ -725,17 +726,17 @@ enum aspa_status aspa_table_update_in_place(struct aspa_table *aspa_table, struc bool next_matches_current = next && next->record.customer_asn == current->record.customer_asn; // MARK: Handling 'add' operations - if (current->type == ASPA_ADD) { + if (current->type == RTR_ASPA_ADD) { // Attempt to add record with $CAS, but record with $CAS already exists // Error: Duplicate Add. if (existing_matches_current) { *failed_operation = current; pthread_rwlock_unlock(&aspa_table->lock); - return ASPA_DUPLICATE_RECORD; + return RTR_ASPA_DUPLICATE_RECORD; } // This operation adds a record with $CAS, the next op however removes this $CAS record again. - if (next_matches_current && next->type == ASPA_REMOVE) { + if (next_matches_current && next->type == RTR_ASPA_REMOVE) { #if ASPA_NOTIFY_NO_OPS // Complete record's providers for clients next->record = current->record; @@ -753,21 +754,21 @@ enum aspa_status aspa_table_update_in_place(struct aspa_table *aspa_table, struc } // Add record by appending it to new array (copy providers) - if (aspa_array_insert(array, existing_i, ¤t->record, true) != ASPA_SUCCESS) { + if (aspa_array_insert(array, existing_i, ¤t->record, true) != RTR_ASPA_SUCCESS) { *failed_operation = current; pthread_rwlock_unlock(&aspa_table->lock); - return ASPA_ERROR; + return RTR_ASPA_ERROR; } } // MARK: Handling 'remove' operations - else if (current->type == ASPA_REMOVE) { + else if (current->type == RTR_ASPA_REMOVE) { // Attempt to remove record with $CAS, but record with $CAS does not exist // Error: Removal of unknown record. if (!existing_matches_current) { *failed_operation = current; pthread_rwlock_unlock(&aspa_table->lock); - return ASPA_RECORD_NOT_FOUND; + return RTR_ASPA_RECORD_NOT_FOUND; } // If it's a remove operation, we insert a reference to the removed record's providers. @@ -775,10 +776,10 @@ enum aspa_status aspa_table_update_in_place(struct aspa_table *aspa_table, struc current->record.provider_asns = existing_record->provider_asns; // Remove record (don't release providers) - if (aspa_array_remove(array, existing_i, false) != ASPA_SUCCESS) { + if (aspa_array_remove(array, existing_i, false) != RTR_ASPA_SUCCESS) { *failed_operation = current; pthread_rwlock_unlock(&aspa_table->lock); - return ASPA_RECORD_NOT_FOUND; + return RTR_ASPA_RECORD_NOT_FOUND; } } @@ -787,13 +788,14 @@ enum aspa_status aspa_table_update_in_place(struct aspa_table *aspa_table, struc } pthread_rwlock_unlock(&aspa_table->lock); - return ASPA_SUCCESS; + return RTR_ASPA_SUCCESS; } -static enum aspa_status aspa_table_update_in_place_undo_internal(struct aspa_table *aspa_table, - struct rtr_socket *rtr_socket, - struct aspa_update_operation *operations, size_t count, - struct aspa_update_operation *failed_operation) +static enum rtr_aspa_status aspa_table_update_in_place_undo_internal(struct rtr_aspa_table *aspa_table, + struct rtr_socket *rtr_socket, + struct aspa_update_operation *operations, + size_t count, + struct aspa_update_operation *failed_operation) { // Fail hard in debug builds. assert(aspa_table); @@ -807,7 +809,7 @@ static enum aspa_status aspa_table_update_in_place_undo_internal(struct aspa_tab if (!node || !*node || !(*node)->aspa_array) { // Node/array is gone -- nothing we can undo pthread_rwlock_unlock(&aspa_table->lock); - return ASPA_ERROR; + return RTR_ASPA_ERROR; } assert(node); @@ -830,7 +832,7 @@ static enum aspa_status aspa_table_update_in_place_undo_internal(struct aspa_tab existing_i += 1; } - struct aspa_record *existing_record = aspa_array_get_record(array, existing_i); + struct rtr_aspa_record *existing_record = aspa_array_get_record(array, existing_i); // existing record and current op have matching CAS bool existing_matches_current = existing_record && @@ -840,16 +842,16 @@ static enum aspa_status aspa_table_update_in_place_undo_internal(struct aspa_tab bool next_matches_current = next && next->record.customer_asn == current->record.customer_asn; // MARK: Undo 'add' operation - if (current->type == ASPA_ADD) { + if (current->type == RTR_ASPA_ADD) { // Attempt to remove record with $CAS, but record with $CAS does not exist // Error: Removal of unknown record. if (!existing_matches_current) { pthread_rwlock_unlock(&aspa_table->lock); - return ASPA_RECORD_NOT_FOUND; + return RTR_ASPA_RECORD_NOT_FOUND; } // This operation adds a record with $CAS, the next op however removes this $CAS record again. - if (next_matches_current && next->type == ASPA_REMOVE) { + if (next_matches_current && next->type == RTR_ASPA_REMOVE) { #if ASPA_NOTIFY_NO_OPS // If it's a remove operation, we insert a reference to the removed record's providers. next->record = current->record; @@ -867,21 +869,21 @@ static enum aspa_status aspa_table_update_in_place_undo_internal(struct aspa_tab } // Remove record (release providers) - if (aspa_array_remove(array, existing_i, true) != ASPA_SUCCESS) { + if (aspa_array_remove(array, existing_i, true) != RTR_ASPA_SUCCESS) { pthread_rwlock_unlock(&aspa_table->lock); - return ASPA_RECORD_NOT_FOUND; + return RTR_ASPA_RECORD_NOT_FOUND; } - aspa_table_notify_clients(aspa_table, ¤t->record, rtr_socket, ASPA_REMOVE); + aspa_table_notify_clients(aspa_table, ¤t->record, rtr_socket, RTR_ASPA_REMOVE); } // MARK: Undo 'remove' operation - else if (current->type == ASPA_REMOVE) { + else if (current->type == RTR_ASPA_REMOVE) { // Next adds record with $CAS again. // Treat these two as a 'replace' op - if (existing_matches_current & next_matches_current && next->type == ASPA_ADD) { + if (existing_matches_current & next_matches_current && next->type == RTR_ASPA_ADD) { if (existing_record->provider_asns) - lrtr_free(existing_record->provider_asns); + rtr_free(existing_record->provider_asns); // If it's a remove operation, we inserted a reference to the existing // provider array. Put back reference. @@ -889,23 +891,23 @@ static enum aspa_status aspa_table_update_in_place_undo_internal(struct aspa_tab existing_record->provider_count = current->record.provider_count; i += 1; - aspa_table_notify_clients(aspa_table, &next->record, rtr_socket, ASPA_REMOVE); + aspa_table_notify_clients(aspa_table, &next->record, rtr_socket, RTR_ASPA_REMOVE); } else { // Attempt to add record with $CAS, but record with $CAS already exists // Error: Duplicate Add. if (existing_matches_current) { pthread_rwlock_unlock(&aspa_table->lock); - return ASPA_DUPLICATE_RECORD; + return RTR_ASPA_DUPLICATE_RECORD; } // Insert record (don't copy providers) - if (aspa_array_insert(array, existing_i, ¤t->record, false) != ASPA_SUCCESS) { + if (aspa_array_insert(array, existing_i, ¤t->record, false) != RTR_ASPA_SUCCESS) { pthread_rwlock_unlock(&aspa_table->lock); - return ASPA_ERROR; + return RTR_ASPA_ERROR; } } - aspa_table_notify_clients(aspa_table, ¤t->record, rtr_socket, ASPA_ADD); + aspa_table_notify_clients(aspa_table, ¤t->record, rtr_socket, RTR_ASPA_ADD); // If it's a remove operation, we inserted a reference to the existing // provider array. Restore that 'remove' operation back to its original state. @@ -915,24 +917,24 @@ static enum aspa_status aspa_table_update_in_place_undo_internal(struct aspa_tab } pthread_rwlock_unlock(&aspa_table->lock); - return ASPA_SUCCESS; + return RTR_ASPA_SUCCESS; } -enum aspa_status aspa_table_update_in_place_undo(struct aspa_table *aspa_table, struct rtr_socket *rtr_socket, - struct aspa_update_operation *operations, size_t count, - struct aspa_update_operation *failed_operation) +enum rtr_aspa_status aspa_table_update_in_place_undo(struct rtr_aspa_table *aspa_table, struct rtr_socket *rtr_socket, + struct aspa_update_operation *operations, size_t count, + struct aspa_update_operation *failed_operation) { // Fail hard in debug builds. assert(aspa_table); assert(rtr_socket); if (!aspa_table || !rtr_socket || ((count > 0) && !operations)) - return ASPA_ERROR; + return RTR_ASPA_ERROR; if (count == 0) - return ASPA_SUCCESS; + return RTR_ASPA_SUCCESS; - enum aspa_status res = + enum rtr_aspa_status res = aspa_table_update_in_place_undo_internal(aspa_table, rtr_socket, operations, count, failed_operation); for (size_t i = 0; i < count; i++) { @@ -940,7 +942,7 @@ enum aspa_status aspa_table_update_in_place_undo(struct aspa_table *aspa_table, // If it's a remove operation, we inserted a reference to the removed record's providers. // Restore that 'remove' operation back to its original state. - if (op->type == ASPA_REMOVE) { + if (op->type == RTR_ASPA_REMOVE) { op->record.provider_asns = NULL; op->record.provider_count = 0; } @@ -961,15 +963,15 @@ void aspa_table_update_in_place_cleanup(struct aspa_update_operation **operation // If it's a remove operation, we inserted a reference to the removed record's providers. // Release that provider array now and restore that 'remove' // operation back to its original state. - if (!op->is_no_op && op->type == ASPA_REMOVE) { + if (!op->is_no_op && op->type == RTR_ASPA_REMOVE) { if (op->record.provider_asns) - lrtr_free(op->record.provider_asns); + rtr_free(op->record.provider_asns); op->record.provider_asns = NULL; op->record.provider_count = 0; } } - lrtr_free(*operations); + rtr_free(*operations); *operations = NULL; } diff --git a/rtrlib/aspa/aspa.h b/rtrlib/aspa/aspa.h index 5930b0e5..69beff00 100644 --- a/rtrlib/aspa/aspa.h +++ b/rtrlib/aspa/aspa.h @@ -36,7 +36,7 @@ * @param provider_count The number of providers this customer declares. * @param provider_asns An array of provider ASNs. */ -struct aspa_record { +struct rtr_aspa_record { uint32_t customer_asn; size_t provider_count; uint32_t *provider_asns; @@ -44,21 +44,21 @@ struct aspa_record { // MARK: - ASPA Table -struct aspa_table; +struct rtr_aspa_table; /** * @brief An enum describing the type of operation the ASPA table should perform using any given ASPA record. */ -enum __attribute__((__packed__)) aspa_operation_type { +enum __attribute__((__packed__)) rtr_aspa_operation_type { /** The existing record, identified by its customer ASN, shall be withdrawn from the ASPA table. */ - ASPA_REMOVE = 0, + RTR_ASPA_REMOVE = 0, /** * The new record, identified by its customer ASN, shall be added to the ASPA table. * If a record with the same customer ASN already exists, this operation is supposed * to replace the existing one with the new record. */ - ASPA_ADD = 1 + RTR_ASPA_ADD = 1 }; /** @@ -70,8 +70,9 @@ enum __attribute__((__packed__)) aspa_operation_type { * @param rtr_socket The socket the record originated from * @param operation_type The type of this operation. */ -typedef void (*aspa_update_fp)(struct aspa_table *aspa_table, const struct aspa_record record, - const struct rtr_socket *rtr_socket, const enum aspa_operation_type operation_type); +typedef void (*rtr_aspa_update_fp)(struct rtr_aspa_table *aspa_table, const struct rtr_aspa_record record, + const struct rtr_socket *rtr_socket, + const enum rtr_aspa_operation_type operation_type); /** * @brief ASPA Table @@ -84,31 +85,31 @@ typedef void (*aspa_update_fp)(struct aspa_table *aspa_table, const struct aspa_ * An ASPA table consists of a linked list of a sockets and ASPA arrays, simplifying removing or replacing records * originating from any given socket. */ -struct aspa_table { +struct rtr_aspa_table { pthread_rwlock_t lock; pthread_rwlock_t update_lock; - aspa_update_fp update_fp; + rtr_aspa_update_fp update_fp; struct aspa_store_node *store; }; /** * @brief Possible return values for `aspa_*` functions. */ -enum aspa_status { +enum rtr_aspa_status { /** Operation was successful. */ - ASPA_SUCCESS = 0, + RTR_ASPA_SUCCESS = 0, /** Error occurred. */ - ASPA_ERROR = -1, + RTR_ASPA_ERROR = -1, /** The supplied aspa_record already exists in the aspa_table. */ - ASPA_DUPLICATE_RECORD = -2, + RTR_ASPA_DUPLICATE_RECORD = -2, /** aspa_record wasn't found in the aspa_table. */ - ASPA_RECORD_NOT_FOUND = -3, + RTR_ASPA_RECORD_NOT_FOUND = -3, /** The ASPA feature was not initialized/enabled. */ - ASPA_NOT_INITIALIZED = -4, + RTR_ASPA_NOT_INITIALIZED = -4, }; /** @@ -117,7 +118,7 @@ enum aspa_status { * @param[in] aspa_table aspa_table that will be initialized. * @param[in] update_fp Pointer to update function */ -void aspa_table_init(struct aspa_table *aspa_table, aspa_update_fp update_fp); +void rtr_aspa_table_init(struct rtr_aspa_table *aspa_table, rtr_aspa_update_fp update_fp); /** * @brief Frees the memory associated with the @p aspa_table @@ -125,7 +126,7 @@ void aspa_table_init(struct aspa_table *aspa_table, aspa_update_fp update_fp); * @param[in] aspa_table aspa_table that will be initialized. * @param notify A boolean value determining whether to notify clients about records being removed from the table. */ -void aspa_table_free(struct aspa_table *aspa_table, bool notify); +void rtr_aspa_table_free(struct rtr_aspa_table *aspa_table, bool notify); /** * @brief Removes all records in the @p aspa_table that originated from the socket. @@ -136,19 +137,20 @@ void aspa_table_free(struct aspa_table *aspa_table, bool notify); * @return @c SPKI_SUCCESS On success. * @return @c SPKI_ERROR On error. */ -enum aspa_status aspa_table_src_remove(struct aspa_table *aspa_table, struct rtr_socket *rtr_socket, bool notify); +enum rtr_aspa_status rtr_aspa_table_src_remove(struct rtr_aspa_table *aspa_table, struct rtr_socket *rtr_socket, + bool notify); // MARK: - AS_PATH Verification -enum aspa_direction { ASPA_UPSTREAM, ASPA_DOWNSTREAM }; +enum rtr_aspa_direction { RTR_ASPA_UPSTREAM, RTR_ASPA_DOWNSTREAM }; /** * @brief AS_PATH verification result. */ -enum aspa_verification_result { - ASPA_AS_PATH_UNKNOWN, - ASPA_AS_PATH_INVALID, - ASPA_AS_PATH_VALID, +enum rtr_aspa_verification_result { + RTR_ASPA_AS_PATH_UNKNOWN, + RTR_ASPA_AS_PATH_INVALID, + RTR_ASPA_AS_PATH_VALID, }; /** @@ -165,15 +167,15 @@ enum aspa_verification_result { * @return @c ASPA_AS_PATH_INVALID if `AS_PATH` is invalid * @return @c ASPA_AS_PATH_VALID if `AS_PATH` is valid */ -enum aspa_verification_result aspa_verify_as_path(struct aspa_table *aspa_table, uint32_t as_path[], size_t len, - enum aspa_direction direction); +enum rtr_aspa_verification_result rtr_aspa_verify_as_path(struct rtr_aspa_table *aspa_table, uint32_t as_path[], + size_t len, enum rtr_aspa_direction direction); /** * @brief Collapses an `AS_PATH` in-place, replacing in-series repetitions with single occurences * * @return Length of the given array. */ -size_t aspa_collapse_as_path(uint32_t as_path[], size_t len); +size_t rtr_aspa_collapse_as_path(uint32_t as_path[], size_t len); #endif /* RTR_ASPA_H */ /** @} */ diff --git a/rtrlib/aspa/aspa_array/aspa_array.c b/rtrlib/aspa/aspa_array/aspa_array.c index 8d21b830..c0bfa6bf 100644 --- a/rtrlib/aspa/aspa_array/aspa_array.c +++ b/rtrlib/aspa/aspa_array/aspa_array.c @@ -15,21 +15,21 @@ // MARK: - Initialization & Deinitialization -enum aspa_status aspa_array_create(struct aspa_array **array_ptr) +enum rtr_aspa_status aspa_array_create(struct aspa_array **array_ptr) { const size_t default_initial_size = 128; // allocation the chunk of memory of the provider as numbers - struct aspa_record *data_field = lrtr_malloc(sizeof(struct aspa_record) * default_initial_size); + struct rtr_aspa_record *data_field = rtr_malloc(sizeof(struct rtr_aspa_record) * default_initial_size); if (!data_field) - return ASPA_ERROR; + return RTR_ASPA_ERROR; - struct aspa_array *array = lrtr_malloc(sizeof(struct aspa_array)); + struct aspa_array *array = rtr_malloc(sizeof(struct aspa_array)); if (!array) { - lrtr_free(data_field); - return ASPA_ERROR; + rtr_free(data_field); + return RTR_ASPA_ERROR; } // initializing member variables of the aspa record @@ -40,7 +40,7 @@ enum aspa_status aspa_array_create(struct aspa_array **array_ptr) // returning the array *array_ptr = array; - return ASPA_SUCCESS; + return RTR_ASPA_SUCCESS; } void aspa_array_free(struct aspa_array *array, bool free_provider_arrays) @@ -52,46 +52,46 @@ void aspa_array_free(struct aspa_array *array, bool free_provider_arrays) if (free_provider_arrays) { for (size_t i = 0; i < array->size; i++) { if (array->data[i].provider_asns) { - lrtr_free(array->data[i].provider_asns); + rtr_free(array->data[i].provider_asns); array->data[i].provider_asns = NULL; } } } - lrtr_free(array->data); + rtr_free(array->data); } - lrtr_free(array); + rtr_free(array); } // MARK: - Manipulation -static enum aspa_status aspa_array_reallocate(struct aspa_array *array) +static enum rtr_aspa_status aspa_array_reallocate(struct aspa_array *array) { // the factor by how much the capacity will increase: new_capacity = old_capacity + SIZE_INCREASE_OFFSET const size_t SIZE_INCREASE_OFFSET = 1000; // allocation the new chunk of memory - struct aspa_record *tmp = - lrtr_realloc(array->data, sizeof(struct aspa_record) * array->capacity + SIZE_INCREASE_OFFSET); + struct rtr_aspa_record *tmp = + rtr_realloc(array->data, sizeof(struct rtr_aspa_record) * array->capacity + SIZE_INCREASE_OFFSET); // malloc failed so returning an error if (!tmp) - return ASPA_ERROR; + return RTR_ASPA_ERROR; array->data = tmp; array->capacity += SIZE_INCREASE_OFFSET; - return ASPA_SUCCESS; + return RTR_ASPA_SUCCESS; } -static enum aspa_status aspa_array_insert_internal(struct aspa_array *array, size_t index, struct aspa_record *record, +static enum rtr_aspa_status aspa_array_insert_internal(struct aspa_array *array, size_t index, struct rtr_aspa_record *record, bool copy_providers) { // check if this element will fit into the array if (array->size >= array->capacity) { // increasing the array's size so the new element fits - if (aspa_array_reallocate(array) != ASPA_SUCCESS) - return ASPA_ERROR; + if (aspa_array_reallocate(array) != RTR_ASPA_SUCCESS) + return RTR_ASPA_ERROR; } uint32_t *provider_asns = NULL; @@ -100,9 +100,9 @@ static enum aspa_status aspa_array_insert_internal(struct aspa_array *array, siz if (copy_providers) { size_t provider_size = record->provider_count * sizeof(uint32_t); - provider_asns = lrtr_malloc(provider_size); + provider_asns = rtr_malloc(provider_size); if (!provider_asns) - return ASPA_ERROR; + return RTR_ASPA_ERROR; memcpy(provider_asns, record->provider_asns, provider_size); } else { @@ -112,7 +112,7 @@ static enum aspa_status aspa_array_insert_internal(struct aspa_array *array, siz // No need to move if last element if (index < array->size) { - size_t trailing = (array->size - index) * sizeof(struct aspa_record); + size_t trailing = (array->size - index) * sizeof(struct rtr_aspa_record); /* trailing * /-------------\ @@ -129,38 +129,38 @@ static enum aspa_status aspa_array_insert_internal(struct aspa_array *array, siz array->data[index].provider_asns = provider_asns; array->size += 1; - return ASPA_SUCCESS; + return RTR_ASPA_SUCCESS; } -enum aspa_status aspa_array_insert(struct aspa_array *array, size_t index, struct aspa_record *record, +enum rtr_aspa_status aspa_array_insert(struct aspa_array *array, size_t index, struct rtr_aspa_record *record, bool copy_providers) { if (!array || index > array->size || !array->data || !record || ((record->provider_count > 0) && !record->provider_asns)) - return ASPA_ERROR; + return RTR_ASPA_ERROR; return aspa_array_insert_internal(array, index, record, copy_providers); } -enum aspa_status aspa_array_append(struct aspa_array *array, struct aspa_record *record, bool copy_providers) +enum rtr_aspa_status aspa_array_append(struct aspa_array *array, struct rtr_aspa_record *record, bool copy_providers) { if (!array || !array->data || !record || ((record->provider_count > 0) && !record->provider_asns)) - return ASPA_ERROR; + return RTR_ASPA_ERROR; return aspa_array_insert_internal(array, array->size, record, copy_providers); } -enum aspa_status aspa_array_remove(struct aspa_array *array, size_t index, bool free_providers) +enum rtr_aspa_status aspa_array_remove(struct aspa_array *array, size_t index, bool free_providers) { if (!array || index >= array->size || array->size == 0) - return ASPA_RECORD_NOT_FOUND; + return RTR_ASPA_RECORD_NOT_FOUND; if (free_providers && array->data[index].provider_asns) - lrtr_free(array->data[index].provider_asns); + rtr_free(array->data[index].provider_asns); // No need to move if last element if (index < array->size - 1) { - size_t trailing = (array->size - index - 1) * sizeof(struct aspa_record); + size_t trailing = (array->size - index - 1) * sizeof(struct rtr_aspa_record); /* trailing * /-------------\ @@ -177,7 +177,7 @@ enum aspa_status aspa_array_remove(struct aspa_array *array, size_t index, bool // decreasing capacity if possible const size_t SIZE_DECREASE_OFFSET = 1000; if (array->size + SIZE_DECREASE_OFFSET < array->capacity) { - struct aspa_record *tmp_data = lrtr_realloc(array->data, array->size + SIZE_DECREASE_OFFSET); + struct rtr_aspa_record *tmp_data = rtr_realloc(array->data, array->size + SIZE_DECREASE_OFFSET); if (tmp_data == NULL) { /* @@ -185,17 +185,17 @@ enum aspa_status aspa_array_remove(struct aspa_array *array, size_t index, bool * the element at the given index has been removed and thus the * function's outcome can be considered successful. */ - return ASPA_SUCCESS; + return RTR_ASPA_SUCCESS; } array->data = tmp_data; array->capacity = array->size + SIZE_DECREASE_OFFSET; } - return ASPA_SUCCESS; + return RTR_ASPA_SUCCESS; } -inline struct aspa_record *aspa_array_get_record(struct aspa_array *array, size_t index) +inline struct rtr_aspa_record *aspa_array_get_record(struct aspa_array *array, size_t index) { if (!array || index >= array->size || array->size == 0 || !array->data) return NULL; @@ -205,7 +205,7 @@ inline struct aspa_record *aspa_array_get_record(struct aspa_array *array, size_ // MARK: - Retrieval -struct aspa_record *aspa_array_search(struct aspa_array *array, uint32_t customer_asn) +struct rtr_aspa_record *aspa_array_search(struct aspa_array *array, uint32_t customer_asn) { // if the array is empty we return an error if (array->size == 0 || array->capacity == 0) @@ -242,28 +242,28 @@ struct aspa_record *aspa_array_search(struct aspa_array *array, uint32_t custome return NULL; } -enum aspa_status aspa_array_reserve(struct aspa_array *array, size_t size) +enum rtr_aspa_status aspa_array_reserve(struct aspa_array *array, size_t size) { // the given array is null if (array == NULL) { - return ASPA_ERROR; + return RTR_ASPA_ERROR; } // we already have enough space allocated if (array->capacity >= size) { - return ASPA_SUCCESS; + return RTR_ASPA_SUCCESS; } - struct aspa_record *data = lrtr_realloc(array->data, sizeof(struct aspa_record) * size); + struct rtr_aspa_record *data = rtr_realloc(array->data, sizeof(struct rtr_aspa_record) * size); // realloc failed if (data == NULL) { - return ASPA_ERROR; + return RTR_ASPA_ERROR; } // updating the array array->capacity = size; array->data = data; - return ASPA_SUCCESS; + return RTR_ASPA_SUCCESS; } diff --git a/rtrlib/aspa/aspa_array/aspa_array.h b/rtrlib/aspa/aspa_array/aspa_array.h index a9f22c6c..ed844551 100644 --- a/rtrlib/aspa/aspa_array/aspa_array.h +++ b/rtrlib/aspa/aspa_array/aspa_array.h @@ -27,7 +27,7 @@ struct aspa_array { uint32_t size; size_t capacity; - struct aspa_record *data; + struct rtr_aspa_record *data; }; // MARK: - Initialization & Deinitialization @@ -35,9 +35,9 @@ struct aspa_array { /** * @brief Creates an vector object * @param[in,out] array_ptr Pointer to a variable that will hold a reference to the newly created array. - * @return @c ASPA_SUCCESS if the operation succeeds, @c ASPA_ERROR if it fails. + * @return @c RTR_ASPA_SUCCESS if the operation succeeds, @c ASPA_ERROR if it fails. */ -enum aspa_status aspa_array_create(struct aspa_array **array_ptr); +enum rtr_aspa_status aspa_array_create(struct aspa_array **array_ptr); /** * @brief Deletes the given ASPA array. @@ -56,9 +56,9 @@ void aspa_array_free(struct aspa_array *array, bool free_provider_arrays); * @param record The new record. * @param copy_providers A boolean value indicating whether the array should copy the record's * providers before inserting the record. - * @return @c ASPA_SUCCESS if the operation succeeds, @c ASPA_ERROR if it fails. + * @return @c RTR_ASPA_SUCCESS if the operation succeeds, @c ASPA_ERROR if it fails. */ -enum aspa_status aspa_array_insert(struct aspa_array *array, size_t index, struct aspa_record *record, +enum rtr_aspa_status aspa_array_insert(struct aspa_array *array, size_t index, struct rtr_aspa_record *record, bool copy_providers); /** @@ -68,9 +68,9 @@ enum aspa_status aspa_array_insert(struct aspa_array *array, size_t index, struc * @param record The record that will be appended to the array. * @param copy_providers A boolean value indicating whether the array should copy the record's * providers before appending the record. - * @return @c ASPA_SUCCESS if the operation succeeds, @c ASPA_ERROR if it fails. + * @return @c RTR_ASPA_SUCCESS if the operation succeeds, @c ASPA_ERROR if it fails. */ -enum aspa_status aspa_array_append(struct aspa_array *array, struct aspa_record *record, bool copy_providers); +enum rtr_aspa_status aspa_array_append(struct aspa_array *array, struct rtr_aspa_record *record, bool copy_providers); /** * @brief Removes the record at the given index from the array. @@ -78,10 +78,10 @@ enum aspa_status aspa_array_append(struct aspa_array *array, struct aspa_record * @param array The array to remove the record from. * @param index The record's index. * @param free_providers A boolean value determining whether to free the existing record's provider array. - * @return @c ASPA_SUCCESS if the operation succeeds, @c ASPA_RECORD_NOT_FOUND if the record's index doesn't exist, + * @return @c RTR_ASPA_SUCCESS if the operation succeeds, @c ASPA_RECORD_NOT_FOUND if the record's index doesn't exist, * @c ASPA_ERROR otherwise. */ -enum aspa_status aspa_array_remove(struct aspa_array *array, size_t index, bool free_providers); +enum rtr_aspa_status aspa_array_remove(struct aspa_array *array, size_t index, bool free_providers); // MARK: - Retrieval @@ -92,7 +92,7 @@ enum aspa_status aspa_array_remove(struct aspa_array *array, size_t index, bool * @param index The index in the ASPA array. * @return A reference to the `aspa_record` if found, @c NULL otherwise. */ -struct aspa_record *aspa_array_get_record(struct aspa_array *array, size_t index); +struct rtr_aspa_record *aspa_array_get_record(struct aspa_array *array, size_t index); /** * @brief Searches the given ASPA array for a record matching its customer ASN. @@ -101,15 +101,15 @@ struct aspa_record *aspa_array_get_record(struct aspa_array *array, size_t index * @param customer_asn Customer ASN * @return A reference to the `aspa_record` if found, @c NULL otherwise. */ -struct aspa_record *aspa_array_search(struct aspa_array *array, uint32_t customer_asn); +struct rtr_aspa_record *aspa_array_search(struct aspa_array *array, uint32_t customer_asn); /** * @brief Reserves some space in the array * * @param array The array to remove the record from. * @param size the number of object that should definetly fit into the array - * @return @c ASPA_SUCCESS if the operation succeeds @c ASPA_ERROR otherwise. + * @return @c RTR_ASPA_SUCCESS if the operation succeeds @c ASPA_ERROR otherwise. */ -enum aspa_status aspa_array_reserve(struct aspa_array *array, size_t size); +enum rtr_aspa_status aspa_array_reserve(struct aspa_array *array, size_t size); #endif // RTR_ASPA_ARRAY_H \ No newline at end of file diff --git a/rtrlib/aspa/aspa_private.h b/rtrlib/aspa/aspa_private.h index ce1d2e06..95ed480c 100644 --- a/rtrlib/aspa/aspa_private.h +++ b/rtrlib/aspa/aspa_private.h @@ -99,7 +99,7 @@ #define ASPA_NOTIFY_NO_OPS 0 -#define ASPA_DBG1(a) lrtr_dbg("ASPA: " a) +#define ASPA_DBG1(a) rtr_dbg("ASPA: " a) // MARK: - Verification @@ -109,7 +109,7 @@ enum aspa_hop_result { ASPA_NO_ATTESTATION, ASPA_NOT_PROVIDER_PLUS, ASPA_PROVIDE * @brief Checks a hop in the given `AS_PATH`. * @return @c aspa_hop_result . */ -enum aspa_hop_result aspa_check_hop(struct aspa_table *aspa_table, uint32_t customer_asn, uint32_t provider_asn); +enum aspa_hop_result aspa_check_hop(struct rtr_aspa_table *aspa_table, uint32_t customer_asn, uint32_t provider_asn); // MARK: - Storage /** @@ -133,9 +133,9 @@ struct aspa_store_node { * @param[in] rtr_socket The socket the records are associated with. * @param notify_dst A boolean value determining whether to notify the destination table's clients. * @param notify_src A boolean value determining whether to notify the source table's clients. - * @return @c ASPA_SUCCESS if the operation succeeds, @c ASPA_ERROR if it fails. + * @return @c RTR_ASPA_SUCCESS if the operation succeeds, @c ASPA_ERROR if it fails. */ -enum aspa_status aspa_table_src_replace(struct aspa_table *dst, struct aspa_table *src, struct rtr_socket *rtr_socket, +enum rtr_aspa_status aspa_table_src_replace(struct rtr_aspa_table *dst, struct rtr_aspa_table *src, struct rtr_socket *rtr_socket, bool notify_dst, bool notify_src); // MARK: - Updating @@ -150,8 +150,8 @@ enum aspa_status aspa_table_src_replace(struct aspa_table *dst, struct aspa_tabl */ struct aspa_update_operation { size_t index; - enum aspa_operation_type type; - struct aspa_record record; + enum rtr_aspa_operation_type type; + struct rtr_aspa_record record; bool is_no_op; }; @@ -168,7 +168,7 @@ struct aspa_update_operation { * @param new_array The new ASPA array replacing the node's existing array. */ struct aspa_update { - struct aspa_table *table; + struct rtr_aspa_table *table; struct aspa_update_operation *operations; size_t operation_count; struct aspa_update_operation *failed_operation; @@ -192,13 +192,13 @@ struct aspa_update { * @param[in] count Number of operations. * @param update The computed update. The update pointer must be non-NULL, but may point to a @c NULL * value initially. Points to an update struct after this function returns. - * @return @c ASPA_SUCCESS On success. + * @return @c RTR_ASPA_SUCCESS On success. * @return @c ASPA_RECORD_NOT_FOUND If a records is supposed to be removed but cannot be found. * @return @c ASPA_DUPLICATE_RECORD If a records is supposed to be added but its corresponding * customer ASN already exists. * @return @c ASPA_ERROR On other failures. */ -enum aspa_status aspa_table_update_swap_in_compute(struct aspa_table *aspa_table, struct rtr_socket *rtr_socket, +enum rtr_aspa_status aspa_table_update_swap_in_compute(struct rtr_aspa_table *aspa_table, struct rtr_socket *rtr_socket, struct aspa_update_operation *operations, size_t count, struct aspa_update **update); @@ -231,13 +231,13 @@ void aspa_table_update_swap_in_discard(struct aspa_update **update); * @param[in] operations Add and remove operations to perform. * @param[in] count Number of operations. * @param[out] failed_operation Failed operation, filled in if update fails. - * @return @c ASPA_SUCCESS On success. + * @return @c RTR_ASPA_SUCCESS On success. * @return @c ASPA_RECORD_NOT_FOUND If a records is supposed to be removed but cannot be found. * @return @c ASPA_DUPLICATE_RECORD If a records is supposed to be added but its corresponding customer ASN already * exists. * @return @c ASPA_ERROR On other failures. */ -enum aspa_status aspa_table_update_in_place(struct aspa_table *aspa_table, struct rtr_socket *rtr_socket, +enum rtr_aspa_status aspa_table_update_in_place(struct rtr_aspa_table *aspa_table, struct rtr_socket *rtr_socket, struct aspa_update_operation *operations, size_t count, struct aspa_update_operation **failed_operation); @@ -249,13 +249,13 @@ enum aspa_status aspa_table_update_in_place(struct aspa_table *aspa_table, struc * @param[in] operations Add and remove operations to perform. * @param[in] count Number of operations. * @param[in] failed_operation Failed operation. - * @return @c ASPA_SUCCESS On success. + * @return @c RTR_ASPA_SUCCESS On success. * @return @c ASPA_RECORD_NOT_FOUND If a records is supposed to be removed but cannot be found. * @return @c ASPA_DUPLICATE_RECORD If a records is supposed to be added but its corresponding customer ASN already * exists. * @return @c ASPA_ERROR On other failures. */ -enum aspa_status aspa_table_update_in_place_undo(struct aspa_table *aspa_table, struct rtr_socket *rtr_socket, +enum rtr_aspa_status aspa_table_update_in_place_undo(struct rtr_aspa_table *aspa_table, struct rtr_socket *rtr_socket, struct aspa_update_operation *operations, size_t count, struct aspa_update_operation *failed_operation); diff --git a/rtrlib/aspa/aspa_verification.c b/rtrlib/aspa/aspa_verification.c index af10eb32..aa4c3b35 100644 --- a/rtrlib/aspa/aspa_verification.c +++ b/rtrlib/aspa/aspa_verification.c @@ -42,12 +42,12 @@ static void *binary_search_asns(const uint32_t cas, uint32_t *array, size_t len) return NULL; } -enum aspa_hop_result aspa_check_hop(struct aspa_table *aspa_table, uint32_t customer_asn, uint32_t provider_asn) +enum aspa_hop_result aspa_check_hop(struct rtr_aspa_table *aspa_table, uint32_t customer_asn, uint32_t provider_asn) { bool customer_found = false; for (struct aspa_store_node *node = aspa_table->store; node != NULL; node = node->next) { - struct aspa_record *aspa_record = aspa_array_search(node->aspa_array, customer_asn); + struct rtr_aspa_record *aspa_record = aspa_array_search(node->aspa_array, customer_asn); if (!aspa_record) continue; @@ -67,12 +67,12 @@ enum aspa_hop_result aspa_check_hop(struct aspa_table *aspa_table, uint32_t cust return customer_found ? ASPA_NOT_PROVIDER_PLUS : ASPA_NO_ATTESTATION; } -static enum aspa_verification_result aspa_verify_as_path_upstream(struct aspa_table *aspa_table, uint32_t as_path[], - size_t len) +static enum rtr_aspa_verification_result aspa_verify_as_path_upstream(struct rtr_aspa_table *aspa_table, + uint32_t as_path[], size_t len) { if (aspa_table == NULL) { ASPA_DBG1("TRYING TO VALIDATE A AS_PATH BUT NO ASPA TABLE INITIALIZED"); - return ASPA_AS_PATH_INVALID; + return RTR_ASPA_AS_PATH_INVALID; } // Optimized AS_PATH verification algorithm using zero based array @@ -81,7 +81,7 @@ static enum aspa_verification_result aspa_verify_as_path_upstream(struct aspa_ta // Doesn't check any hop twice. if (len <= 1) // Trivially VALID AS_PATH - return ASPA_AS_PATH_VALID; + return RTR_ASPA_AS_PATH_VALID; pthread_rwlock_rdlock(&aspa_table->lock); @@ -95,7 +95,7 @@ static enum aspa_verification_result aspa_verify_as_path_upstream(struct aspa_ta if (r == 0) { // Complete customer-provider chain, VALID upstream AS_PATH pthread_rwlock_unlock(&aspa_table->lock); - return ASPA_AS_PATH_VALID; + return RTR_ASPA_AS_PATH_VALID; } bool found_nP_from_right = false; @@ -141,18 +141,18 @@ static enum aspa_verification_result aspa_verify_as_path_upstream(struct aspa_ta // If nP+ occurs upstream customer-provider chain, return INVALID. if (found_nP_from_right) { - return ASPA_AS_PATH_INVALID; + return RTR_ASPA_AS_PATH_INVALID; } - return ASPA_AS_PATH_UNKNOWN; + return RTR_ASPA_AS_PATH_UNKNOWN; } -static enum aspa_verification_result aspa_verify_as_path_downstream(struct aspa_table *aspa_table, uint32_t as_path[], - size_t len) +static enum rtr_aspa_verification_result aspa_verify_as_path_downstream(struct rtr_aspa_table *aspa_table, + uint32_t as_path[], size_t len) { if (aspa_table == NULL) { ASPA_DBG1("TRYING TO VALIDATE A AS_PATH BUT NO ASPA TABLE INITIALIZED"); - return ASPA_AS_PATH_INVALID; + return RTR_ASPA_AS_PATH_INVALID; } // Optimized AS_PATH verification algorithm using zero based array @@ -161,7 +161,7 @@ static enum aspa_verification_result aspa_verify_as_path_downstream(struct aspa_ // Doesn't check any hop twice. if (len <= 2) // Trivially VALID AS_PATH - return ASPA_AS_PATH_VALID; + return RTR_ASPA_AS_PATH_VALID; pthread_rwlock_rdlock(&aspa_table->lock); @@ -187,7 +187,7 @@ static enum aspa_verification_result aspa_verify_as_path_downstream(struct aspa_ // there's no way to create a route leak, return VALID. if (r - l <= 1) { pthread_rwlock_unlock(&aspa_table->lock); - return ASPA_AS_PATH_VALID; + return RTR_ASPA_AS_PATH_VALID; } /* @@ -267,27 +267,28 @@ static enum aspa_verification_result aspa_verify_as_path_downstream(struct aspa_ // If two nP+ occur in opposing directions, return INVALID. if (found_nP_from_right && found_nP_from_left) { pthread_rwlock_unlock(&aspa_table->lock); - return ASPA_AS_PATH_INVALID; + return RTR_ASPA_AS_PATH_INVALID; } pthread_rwlock_unlock(&aspa_table->lock); - return ASPA_AS_PATH_UNKNOWN; + return RTR_ASPA_AS_PATH_UNKNOWN; } -RTRLIB_EXPORT enum aspa_verification_result aspa_verify_as_path(struct aspa_table *aspa_table, uint32_t as_path[], - size_t len, enum aspa_direction direction) +RTRLIB_EXPORT enum rtr_aspa_verification_result rtr_aspa_verify_as_path(struct rtr_aspa_table *aspa_table, + uint32_t as_path[], size_t len, + enum rtr_aspa_direction direction) { switch (direction) { - case ASPA_UPSTREAM: + case RTR_ASPA_UPSTREAM: return aspa_verify_as_path_upstream(aspa_table, as_path, len); - case ASPA_DOWNSTREAM: + case RTR_ASPA_DOWNSTREAM: return aspa_verify_as_path_downstream(aspa_table, as_path, len); } - return ASPA_AS_PATH_UNKNOWN; + return RTR_ASPA_AS_PATH_UNKNOWN; } -RTRLIB_EXPORT size_t aspa_collapse_as_path(uint32_t as_path[], size_t len) +RTRLIB_EXPORT size_t rtr_aspa_collapse_as_path(uint32_t as_path[], size_t len) { if (len == 0) return 0; diff --git a/rtrlib/bgpsec/bgpsec.c b/rtrlib/bgpsec/bgpsec.c index 2ce7c30a..c7e64c2d 100644 --- a/rtrlib/bgpsec/bgpsec.c +++ b/rtrlib/bgpsec/bgpsec.c @@ -67,7 +67,7 @@ static const uint8_t algorithm_suites[] = {RTR_BGPSEC_ALGORITHM_SUITE_1}; * position of the array. */ -int rtr_bgpsec_validate_as_path(const struct rtr_bgpsec *data, struct spki_table *table) +int rtr_bgpsec_validate_as_path(const struct rtr_bgpsec *data, struct rtr_spki_table *table) { assert(table != NULL); @@ -78,7 +78,7 @@ int rtr_bgpsec_validate_as_path(const struct rtr_bgpsec *data, struct spki_table unsigned char *hash_result = NULL; /* A temporare spki record */ - struct spki_record *tmp_key = NULL; + struct rtr_spki_record *tmp_key = NULL; /* A stream that holds the data that is hashed */ struct stream *stream = NULL; @@ -197,7 +197,7 @@ int rtr_bgpsec_validate_as_path(const struct rtr_bgpsec *data, struct spki_table */ size_t len = get_stream_size(stream) - offset; - uint8_t *curr = lrtr_malloc(len); + uint8_t *curr = rtr_malloc(len); if (!curr) { retval = RTR_BGPSEC_ERROR; @@ -208,16 +208,16 @@ int rtr_bgpsec_validate_as_path(const struct rtr_bgpsec *data, struct spki_table retval = hash_byte_sequence(curr, len, data->alg, &hash_result); - lrtr_free(curr); + rtr_free(curr); if (retval != RTR_BGPSEC_SUCCESS) goto err; /* Store all router keys for the given SKI in tmp_key. */ unsigned int router_keys_len = 0; - enum spki_rtvals spki_retval = + enum rtr_spki_rtvals spki_retval = spki_table_search_by_ski(table, tmp_sig->ski, &tmp_key, &router_keys_len); - if (spki_retval == SPKI_ERROR) { + if (spki_retval == RTR_SPKI_ERROR) { retval = RTR_BGPSEC_ERROR; goto err; } @@ -240,8 +240,8 @@ int rtr_bgpsec_validate_as_path(const struct rtr_bgpsec *data, struct spki_table if (retval == RTR_BGPSEC_VALID) break; } - lrtr_free(hash_result); - lrtr_free(tmp_key); + rtr_free(hash_result); + rtr_free(tmp_key); hash_result = NULL; tmp_key = NULL; tmp_sig = tmp_sig->next; @@ -249,9 +249,9 @@ int rtr_bgpsec_validate_as_path(const struct rtr_bgpsec *data, struct spki_table err: if (hash_result) - lrtr_free(hash_result); + rtr_free(hash_result); if (tmp_key) - lrtr_free(tmp_key); + rtr_free(tmp_key); if (stream) free_stream(stream); @@ -263,8 +263,8 @@ int rtr_bgpsec_validate_as_path(const struct rtr_bgpsec *data, struct spki_table return retval; } -int rtr_bgpsec_generate_signature(const struct rtr_bgpsec *data, uint8_t *private_key, - struct rtr_signature_seg **new_signature) +enum rtr_bgpsec_rtvals rtr_bgpsec_generate_signature(const struct rtr_bgpsec *data, uint8_t *private_key, + struct rtr_signature_seg **new_signature) { /* The signature generation result. */ enum rtr_bgpsec_rtvals retval = 0; @@ -364,7 +364,7 @@ int rtr_bgpsec_generate_signature(const struct rtr_bgpsec *data, uint8_t *privat err: if (hash_result) - lrtr_free(hash_result); + rtr_free(hash_result); if (*new_signature && (retval == RTR_BGPSEC_SIGNING_ERROR)) rtr_bgpsec_free_signatures(*new_signature); if (stream) @@ -386,7 +386,7 @@ int rtr_bgpsec_get_version(void) return BGPSEC_VERSION; } -int rtr_bgpsec_has_algorithm_suite(uint8_t alg_suite) +enum rtr_bgpsec_rtvals rtr_bgpsec_has_algorithm_suite(uint8_t alg_suite) { int alg_suites_len = sizeof(algorithm_suites) / sizeof(uint8_t); @@ -404,7 +404,7 @@ int rtr_bgpsec_get_algorithm_suites(const uint8_t **algs_arr) return sizeof(algorithm_suites) / sizeof(uint8_t); } -int rtr_bgpsec_prepend_sig_seg(struct rtr_bgpsec *bgpsec, struct rtr_signature_seg *new_seg) +enum rtr_bgpsec_rtvals rtr_bgpsec_prepend_sig_seg(struct rtr_bgpsec *bgpsec, struct rtr_signature_seg *new_seg) { if (!new_seg || !new_seg->signature || !new_seg->sig_len || ski_is_empty(new_seg->ski)) return RTR_BGPSEC_ERROR; @@ -432,7 +432,7 @@ struct rtr_signature_seg *rtr_bgpsec_pop_signature_seg(struct rtr_bgpsec *bgpsec return tmp; } -int rtr_bgpsec_append_sig_seg(struct rtr_bgpsec *bgpsec, struct rtr_signature_seg *new_seg) +enum rtr_bgpsec_rtvals rtr_bgpsec_append_sig_seg(struct rtr_bgpsec *bgpsec, struct rtr_signature_seg *new_seg) { struct rtr_signature_seg *last = bgpsec->sigs; @@ -454,14 +454,14 @@ int rtr_bgpsec_append_sig_seg(struct rtr_bgpsec *bgpsec, struct rtr_signature_se struct rtr_signature_seg *rtr_bgpsec_new_signature_seg(uint8_t *ski, uint16_t sig_len, uint8_t *signature) { - struct rtr_signature_seg *sig_seg = lrtr_malloc(sizeof(struct rtr_signature_seg)); + struct rtr_signature_seg *sig_seg = rtr_malloc(sizeof(struct rtr_signature_seg)); if (!sig_seg) return NULL; - sig_seg->signature = lrtr_calloc(sig_len, 1); + sig_seg->signature = rtr_calloc(sig_len, 1); if (!sig_seg->signature) { - lrtr_free(sig_seg); + rtr_free(sig_seg); return NULL; } @@ -484,8 +484,8 @@ void rtr_bgpsec_free_signatures(struct rtr_signature_seg *seg) return; if (seg->next) rtr_bgpsec_free_signatures(seg->next); - lrtr_free(seg->signature); - lrtr_free(seg); + rtr_free(seg->signature); + rtr_free(seg); } void rtr_bgpsec_prepend_sec_path_seg(struct rtr_bgpsec *bgpsec, struct rtr_secure_path_seg *new_seg) @@ -514,7 +514,7 @@ void rtr_bgpsec_append_sec_path_seg(struct rtr_bgpsec *bgpsec, struct rtr_secure struct rtr_secure_path_seg *rtr_bgpsec_new_secure_path_seg(uint8_t pcount, uint8_t flags, uint32_t asn) { - struct rtr_secure_path_seg *seg = lrtr_malloc(sizeof(struct rtr_secure_path_seg)); + struct rtr_secure_path_seg *seg = rtr_malloc(sizeof(struct rtr_secure_path_seg)); if (!seg) { return NULL; @@ -544,7 +544,7 @@ struct rtr_secure_path_seg *rtr_bgpsec_pop_secure_path_seg(struct rtr_bgpsec *bg struct rtr_bgpsec *rtr_bgpsec_new(uint8_t alg, uint8_t safi, uint16_t afi, uint32_t my_as, uint32_t target_as, struct rtr_bgpsec_nlri *nlri) { - struct rtr_bgpsec *bgpsec = lrtr_malloc(sizeof(struct rtr_bgpsec)); + struct rtr_bgpsec *bgpsec = rtr_malloc(sizeof(struct rtr_bgpsec)); if (!bgpsec) return NULL; @@ -571,7 +571,7 @@ void rtr_bgpsec_free(struct rtr_bgpsec *bgpsec) rtr_bgpsec_free_signatures(bgpsec->sigs); if (bgpsec->nlri) rtr_bgpsec_nlri_free(bgpsec->nlri); - lrtr_free(bgpsec); + rtr_free(bgpsec); } void rtr_bgpsec_free_secure_path(struct rtr_secure_path_seg *seg) @@ -580,21 +580,21 @@ void rtr_bgpsec_free_secure_path(struct rtr_secure_path_seg *seg) return; if (seg->next) rtr_bgpsec_free_secure_path(seg->next); - lrtr_free(seg); + rtr_free(seg); } struct rtr_bgpsec_nlri *rtr_bgpsec_nlri_new(int nlri_len) { - struct rtr_bgpsec_nlri *nlri = lrtr_malloc(sizeof(struct rtr_bgpsec_nlri)); + struct rtr_bgpsec_nlri *nlri = rtr_malloc(sizeof(struct rtr_bgpsec_nlri)); if (!nlri) { return NULL; } - nlri->nlri = lrtr_malloc(nlri_len); + nlri->nlri = rtr_malloc(nlri_len); if (!nlri->nlri) { - lrtr_free(nlri); + rtr_free(nlri); return NULL; } @@ -607,12 +607,12 @@ void rtr_bgpsec_nlri_free(struct rtr_bgpsec_nlri *nlri) return; if (nlri->nlri) - lrtr_free(nlri->nlri); + rtr_free(nlri->nlri); - lrtr_free(nlri); + rtr_free(nlri); } -void rtr_bgpsec_add_spki_record(struct spki_table *table, struct spki_record *record) +void rtr_bgpsec_add_spki_record(struct rtr_spki_table *table, struct rtr_spki_record *record) { spki_table_add_entry(table, record); } diff --git a/rtrlib/bgpsec/bgpsec_private.h b/rtrlib/bgpsec/bgpsec_private.h index fbee76bc..03ec6c0c 100644 --- a/rtrlib/bgpsec/bgpsec_private.h +++ b/rtrlib/bgpsec/bgpsec_private.h @@ -28,7 +28,7 @@ * @return RTR_BGPSEC_ERROR If an error occurred. Refer to error codes for * more details. */ -int rtr_bgpsec_validate_as_path(const struct rtr_bgpsec *data, struct spki_table *table); +int rtr_bgpsec_validate_as_path(const struct rtr_bgpsec *data, struct rtr_spki_table *table); /** * @brief Signing function for a BGPsec_PATH. @@ -40,8 +40,8 @@ int rtr_bgpsec_validate_as_path(const struct rtr_bgpsec *data, struct spki_table * @return RTR_BGPSEC_ERROR If an error occurred. Refer to error codes for * more details. */ -int rtr_bgpsec_generate_signature(const struct rtr_bgpsec *data, uint8_t *private_key, - struct rtr_signature_seg **new_signature); +enum rtr_bgpsec_rtvals rtr_bgpsec_generate_signature(const struct rtr_bgpsec *data, uint8_t *private_key, + struct rtr_signature_seg **new_signature); /** * @brief Returns the highest supported BGPsec version. @@ -55,7 +55,7 @@ int rtr_bgpsec_get_version(void); * @return RTR_BGPSEC_SUCCESS If the algorithm suite is supported. * @return RTR_BGPSEC_ERROR If the algorithm suite is not supported. */ -int rtr_bgpsec_has_algorithm_suite(uint8_t alg_suite); +enum rtr_bgpsec_rtvals rtr_bgpsec_has_algorithm_suite(uint8_t alg_suite); /** * @brief Returns a pointer to a list that holds all supported algorithm suites. @@ -108,7 +108,7 @@ struct rtr_signature_seg *rtr_bgpsec_new_signature_seg(uint8_t *ski, uint16_t si * @return RTR_BGPSEC_ERROR If an error occurred during prepending, e.g. one * or more fields of new_seg was missing. */ -int rtr_bgpsec_prepend_sig_seg(struct rtr_bgpsec *bgpsec, struct rtr_signature_seg *new_seg); +enum rtr_bgpsec_rtvals rtr_bgpsec_prepend_sig_seg(struct rtr_bgpsec *bgpsec, struct rtr_signature_seg *new_seg); /** * @brief Initializes and returns a pointer to a rtr_bgpsec struct. @@ -177,7 +177,7 @@ struct rtr_secure_path_seg *rtr_bgpsec_pop_secure_path_seg(struct rtr_bgpsec *bg * @return RTR_BGPSEC_SUCCESS If the Signature Segment was successfully appended. * @return RTR_BGPSEC_ERROR If an error occurred in the proccess. */ -int rtr_bgpsec_append_sig_seg(struct rtr_bgpsec *bgpsec, struct rtr_signature_seg *new_seg); +enum rtr_bgpsec_rtvals rtr_bgpsec_append_sig_seg(struct rtr_bgpsec *bgpsec, struct rtr_signature_seg *new_seg); /** * @brief Append a Secure Path Segment to the end of the @ref rtr_bgpsec.path of a @@ -193,6 +193,6 @@ void rtr_bgpsec_append_sec_path_seg(struct rtr_bgpsec *bgpsec, struct rtr_secure * @param[in] table The SPKI table holding the SPKI data. * @param[in] record The new record that will be added to the SPKI table. */ -void rtr_bgpsec_add_spki_record(struct spki_table *table, struct spki_record *record); +void rtr_bgpsec_add_spki_record(struct rtr_spki_table *table, struct rtr_spki_record *record); #endif /* @} */ diff --git a/rtrlib/bgpsec/bgpsec_utils.c b/rtrlib/bgpsec/bgpsec_utils.c index 3cf0921a..24c0430a 100644 --- a/rtrlib/bgpsec/bgpsec_utils.c +++ b/rtrlib/bgpsec/bgpsec_utils.c @@ -25,16 +25,16 @@ struct stream { struct stream *init_stream(uint16_t size) { - struct stream *stream = lrtr_calloc(sizeof(struct stream), 1); + struct stream *stream = rtr_calloc(sizeof(struct stream), 1); if (stream == NULL) { return NULL; } - stream->stream = lrtr_calloc(size, 1); + stream->stream = rtr_calloc(size, 1); if (stream->stream == NULL) { - lrtr_free(stream); + rtr_free(stream); return NULL; } @@ -62,8 +62,8 @@ struct stream *copy_stream(struct stream *s) void free_stream(struct stream *s) { - lrtr_free((uint8_t *)s->start); - lrtr_free(s); + rtr_free((uint8_t *)s->start); + rtr_free(s); } void write_stream(struct stream *s, void *data, uint16_t len) @@ -139,16 +139,16 @@ int get_sig_seg_size(const struct rtr_signature_seg *sig_segs, enum align_type t return sig_segs_size; } -int check_router_keys(const struct rtr_signature_seg *sig_segs, struct spki_table *table) +int check_router_keys(const struct rtr_signature_seg *sig_segs, struct rtr_spki_table *table) { - struct spki_record *tmp_key = NULL; + struct rtr_spki_record *tmp_key = NULL; const struct rtr_signature_seg *curr = sig_segs; while (curr) { unsigned int router_keys_len = 0; - enum spki_rtvals spki_retval = + enum rtr_spki_rtvals spki_retval = spki_table_search_by_ski(table, (uint8_t *)curr->ski, &tmp_key, &router_keys_len); - if (spki_retval == SPKI_ERROR) + if (spki_retval == RTR_SPKI_ERROR) return RTR_BGPSEC_ERROR; /* Return an error, if a router key was not found. */ @@ -159,7 +159,7 @@ int check_router_keys(const struct rtr_signature_seg *sig_segs, struct spki_tabl BGPSEC_DBG("ERROR: Could not find router key for SKI: %s", ski_str); return RTR_BGPSEC_ROUTER_KEY_NOT_FOUND; } - lrtr_free(tmp_key); + rtr_free(tmp_key); curr = curr->next; } @@ -302,7 +302,7 @@ int align_byte_sequence(const struct rtr_bgpsec *data, struct stream *s, enum al return RTR_BGPSEC_SUCCESS; } -int validate_signature(const unsigned char *hash, const struct rtr_signature_seg *sig, struct spki_record *record) +int validate_signature(const unsigned char *hash, const struct rtr_signature_seg *sig, struct rtr_spki_record *record) { int status = 0; enum rtr_bgpsec_rtvals retval; @@ -409,7 +409,7 @@ int hash_byte_sequence(uint8_t *bytes, size_t bytes_len, uint8_t alg_suite_id, u if (alg_suite_id == RTR_BGPSEC_ALGORITHM_SUITE_1) { SHA256_CTX ctx; - *hash_result = lrtr_malloc(SHA256_DIGEST_LENGTH); + *hash_result = rtr_malloc(SHA256_DIGEST_LENGTH); if (!*hash_result) return RTR_BGPSEC_ERROR; diff --git a/rtrlib/bgpsec/bgpsec_utils_private.h b/rtrlib/bgpsec/bgpsec_utils_private.h index 8b8a7356..c8511aba 100644 --- a/rtrlib/bgpsec/bgpsec_utils_private.h +++ b/rtrlib/bgpsec/bgpsec_utils_private.h @@ -19,8 +19,8 @@ #include #include -#define BGPSEC_DBG(fmt, ...) lrtr_dbg("BGPSEC: " fmt, ##__VA_ARGS__) -#define BGPSEC_DBG1(a) lrtr_dbg("BGPSEC: " a) +#define BGPSEC_DBG(fmt, ...) rtr_dbg("BGPSEC: " fmt, ##__VA_ARGS__) +#define BGPSEC_DBG1(a) rtr_dbg("BGPSEC: " a) /** The length of a rtr_secure_path_seg without the next pointer: * pcount(1) + flags(1) + asn(4) @@ -81,7 +81,7 @@ size_t req_stream_size(const struct rtr_bgpsec *data, enum align_type type); int get_sig_seg_size(const struct rtr_signature_seg *sig_segs, enum align_type type); /* Check, if there is at least one router key for each SKI from sig_segs. */ -int check_router_keys(const struct rtr_signature_seg *sig_segs, struct spki_table *table); +int check_router_keys(const struct rtr_signature_seg *sig_segs, struct rtr_spki_table *table); /* Store the string representation of a BGPsec_PATH segment in buffer. */ int bgpsec_segment_to_str(char *buffer, struct rtr_signature_seg *sig_seg, struct rtr_secure_path_seg *sec_path); @@ -103,7 +103,7 @@ int align_byte_sequence(const struct rtr_bgpsec *data, struct stream *s, enum al int hash_byte_sequence(uint8_t *bytes, size_t bytes_len, uint8_t alg_suite_id, unsigned char **result_buffer); /* Validate a signature sig. */ -int validate_signature(const unsigned char *hash, const struct rtr_signature_seg *sig, struct spki_record *record); +int validate_signature(const unsigned char *hash, const struct rtr_signature_seg *sig, struct rtr_spki_record *record); /* Load a binary private key bytes_key and store it in the openssl EC_KEY * priv_key. diff --git a/rtrlib/lib/alloc_utils.c b/rtrlib/lib/alloc_utils.c index 2b8d6b1b..b3e559f7 100644 --- a/rtrlib/lib/alloc_utils.c +++ b/rtrlib/lib/alloc_utils.c @@ -21,21 +21,21 @@ static void *(*REALLOC_PTR)(void *ptr, size_t size) = realloc; static void (*FREE_PTR)(void *ptr) = free; /* cppcheck-suppress unusedFunction */ -RTRLIB_EXPORT void lrtr_set_alloc_functions(void *(*malloc_function)(size_t size), - void *(*realloc_function)(void *ptr, size_t size), - void(free_function)(void *ptr)) +RTRLIB_EXPORT void rtr_set_alloc_functions(void *(*malloc_function)(size_t size), + void *(*realloc_function)(void *ptr, size_t size), + void(free_function)(void *ptr)) { MALLOC_PTR = malloc_function; REALLOC_PTR = realloc_function; FREE_PTR = free_function; } -inline void *lrtr_malloc(size_t size) +inline void *rtr_malloc(size_t size) { return MALLOC_PTR(size); } -void *lrtr_calloc(size_t nmemb, size_t size) +void *rtr_calloc(size_t nmemb, size_t size) { int bytes = 0; @@ -51,7 +51,7 @@ void *lrtr_calloc(size_t nmemb, size_t size) } bytes = size * nmemb; #endif - void *p = lrtr_malloc(bytes); + void *p = rtr_malloc(bytes); if (!p) return p; @@ -59,22 +59,22 @@ void *lrtr_calloc(size_t nmemb, size_t size) return memset(p, 0, bytes); } -inline void lrtr_free(void *ptr) +inline void rtr_free(void *ptr) { return FREE_PTR(ptr); } -inline void *lrtr_realloc(void *ptr, size_t size) +inline void *rtr_realloc(void *ptr, size_t size) { return REALLOC_PTR(ptr, size); } -char *lrtr_strdup(const char *string) +char *rtr_strdup(const char *string) { assert(string); size_t length = strlen(string) + 1; - char *new_string = lrtr_malloc(length); + char *new_string = rtr_malloc(length); return new_string ? memcpy(new_string, string, length) : NULL; } diff --git a/rtrlib/lib/alloc_utils.h b/rtrlib/lib/alloc_utils.h index b2659152..1139e462 100644 --- a/rtrlib/lib/alloc_utils.h +++ b/rtrlib/lib/alloc_utils.h @@ -7,8 +7,8 @@ * Website: http://rtrlib.realmv6.org/ */ -#ifndef LRTR_ALLOC_UTILS_H -#define LRTR_ALLOC_UTILS_H +#ifndef RTR_ALLOC_UTILS_H +#define RTR_ALLOC_UTILS_H #include @@ -19,7 +19,7 @@ * @param[in] Pointer to realloc function * @param[in] Pointer to free function */ -void lrtr_set_alloc_functions(void *(*malloc_function)(size_t size), void *(*realloc_function)(void *ptr, size_t size), +void rtr_set_alloc_functions(void *(*malloc_function)(size_t size), void *(*realloc_function)(void *ptr, size_t size), void (*free_function)(void *ptr)); #endif diff --git a/rtrlib/lib/alloc_utils_private.h b/rtrlib/lib/alloc_utils_private.h index b6c67cc8..7ab7ea9d 100644 --- a/rtrlib/lib/alloc_utils_private.h +++ b/rtrlib/lib/alloc_utils_private.h @@ -7,20 +7,20 @@ * Website: http://rtrlib.realmv6.org/ */ -#ifndef LRTR_ALLOC_UTILS_PRIVATE_H -#define LRTR_ALLOC_UTILS_PRIVATE_H +#ifndef RTR_ALLOC_UTILS_PRIVATE_H +#define RTR_ALLOC_UTILS_PRIVATE_H #include "alloc_utils.h" #include -void *lrtr_malloc(size_t size); +void *rtr_malloc(size_t size); -void *lrtr_calloc(size_t nmemb, size_t size); +void *rtr_calloc(size_t nmemb, size_t size); -void lrtr_free(void *ptr); +void rtr_free(void *ptr); -void *lrtr_realloc(void *ptr, size_t size); +void *rtr_realloc(void *ptr, size_t size); /** * @brief Duplicates a string @@ -29,6 +29,6 @@ void *lrtr_realloc(void *ptr, size_t size); * @returns Duplicated string * @returns NULL on error */ -char *lrtr_strdup(const char *string); +char *rtr_strdup(const char *string); #endif diff --git a/rtrlib/lib/convert_byte_order.c b/rtrlib/lib/convert_byte_order.c index 402c141c..a0d6355e 100644 --- a/rtrlib/lib/convert_byte_order.c +++ b/rtrlib/lib/convert_byte_order.c @@ -13,7 +13,7 @@ #include #include -uint16_t lrtr_convert_short(const enum target_byte_order tbo, const uint16_t value) +uint16_t rtr_convert_short(const enum target_byte_order tbo, const uint16_t value) { if (tbo == TO_NETWORK_BYTE_ORDER) return htons(value); @@ -23,7 +23,7 @@ uint16_t lrtr_convert_short(const enum target_byte_order tbo, const uint16_t val assert(0); } -uint32_t lrtr_convert_long(const enum target_byte_order tbo, const uint32_t value) +uint32_t rtr_convert_long(const enum target_byte_order tbo, const uint32_t value) { if (tbo == TO_NETWORK_BYTE_ORDER) return htonl(value); diff --git a/rtrlib/lib/convert_byte_order_private.h b/rtrlib/lib/convert_byte_order_private.h index 839f82b7..9aeac2ac 100644 --- a/rtrlib/lib/convert_byte_order_private.h +++ b/rtrlib/lib/convert_byte_order_private.h @@ -7,8 +7,8 @@ * Website: http://rtrlib.realmv6.org/ */ -#ifndef LRTR_CONVERT_BYTE_ORDER_PRIVATE_H -#define LRTR_CONVERT_BYTE_ORDER_PRIVATE_H +#ifndef RTR_CONVERT_BYTE_ORDER_PRIVATE_H +#define RTR_CONVERT_BYTE_ORDER_PRIVATE_H #include @@ -26,7 +26,7 @@ enum target_byte_order { * @param[in] value Input (uint16_t) for conversion. * @result Converted uint16_t value. */ -uint16_t lrtr_convert_short(const enum target_byte_order tbo, const uint16_t value); +uint16_t rtr_convert_short(const enum target_byte_order tbo, const uint16_t value); /** * Converts the passed long value to the given target byte order. @@ -34,6 +34,6 @@ uint16_t lrtr_convert_short(const enum target_byte_order tbo, const uint16_t val * @param[in] value Input (uint32_t) for conversion. * @result Converted uint32_t value. */ -uint32_t lrtr_convert_long(const enum target_byte_order tbo, const uint32_t value); +uint32_t rtr_convert_long(const enum target_byte_order tbo, const uint32_t value); -#endif /* LRTR_CONVERT_BYTE_ORDER_H */ +#endif /* RTR_CONVERT_BYTE_ORDER_H */ diff --git a/rtrlib/lib/ip.c b/rtrlib/lib/ip.c index 39df7748..637f9902 100644 --- a/rtrlib/lib/ip.c +++ b/rtrlib/lib/ip.c @@ -14,9 +14,9 @@ #include #include -bool lrtr_ip_addr_is_zero(const struct lrtr_ip_addr prefix) +bool rtr_ip_addr_is_zero(const struct rtr_ip_addr prefix) { - if (prefix.ver == LRTR_IPV6) { + if (prefix.ver == RTR_IPV6) { if (prefix.u.addr6.addr[0] == 0 && prefix.u.addr6.addr[1] == 0 && prefix.u.addr6.addr[2] == 0 && prefix.u.addr6.addr[3] == 0) { return true; @@ -28,52 +28,52 @@ bool lrtr_ip_addr_is_zero(const struct lrtr_ip_addr prefix) return false; } -struct lrtr_ip_addr lrtr_ip_addr_get_bits(const struct lrtr_ip_addr *val, const uint8_t from, const uint8_t number) +struct rtr_ip_addr rtr_ip_addr_get_bits(const struct rtr_ip_addr *val, const uint8_t from, const uint8_t number) { - struct lrtr_ip_addr result; + struct rtr_ip_addr result; - if (val->ver == LRTR_IPV6) { - result.ver = LRTR_IPV6; - result.u.addr6 = lrtr_ipv6_get_bits(&(val->u.addr6), from, number); + if (val->ver == RTR_IPV6) { + result.ver = RTR_IPV6; + result.u.addr6 = rtr_ipv6_get_bits(&(val->u.addr6), from, number); } else { - result.ver = LRTR_IPV4; - result.u.addr4 = lrtr_ipv4_get_bits(&(val->u.addr4), from, number); + result.ver = RTR_IPV4; + result.u.addr4 = rtr_ipv4_get_bits(&(val->u.addr4), from, number); } return result; } -RTRLIB_EXPORT bool lrtr_ip_addr_equal(const struct lrtr_ip_addr a, const struct lrtr_ip_addr b) +RTRLIB_EXPORT bool rtr_ip_addr_equal(const struct rtr_ip_addr a, const struct rtr_ip_addr b) { if (a.ver != b.ver) return false; - if (a.ver == LRTR_IPV6) - return lrtr_ipv6_addr_equal(&(a.u.addr6), &(b.u.addr6)); - return lrtr_ipv4_addr_equal(&(a.u.addr4), &(b.u.addr4)); + if (a.ver == RTR_IPV6) + return rtr_ipv6_addr_equal(&(a.u.addr6), &(b.u.addr6)); + return rtr_ipv4_addr_equal(&(a.u.addr4), &(b.u.addr4)); } -RTRLIB_EXPORT int lrtr_ip_addr_to_str(const struct lrtr_ip_addr *ip, char *str, const unsigned int len) +RTRLIB_EXPORT int rtr_ip_addr_to_str(const struct rtr_ip_addr *ip, char *str, const unsigned int len) { - if (ip->ver == LRTR_IPV6) - return lrtr_ipv6_addr_to_str(&(ip->u.addr6), str, len); - return lrtr_ipv4_addr_to_str(&(ip->u.addr4), str, len); + if (ip->ver == RTR_IPV6) + return rtr_ipv6_addr_to_str(&(ip->u.addr6), str, len); + return rtr_ipv4_addr_to_str(&(ip->u.addr4), str, len); } -RTRLIB_EXPORT int lrtr_ip_str_to_addr(const char *str, struct lrtr_ip_addr *ip) +RTRLIB_EXPORT int rtr_ip_str_to_addr(const char *str, struct rtr_ip_addr *ip) { if (!strchr(str, ':')) { - ip->ver = LRTR_IPV4; - return lrtr_ipv4_str_to_addr(str, &(ip->u.addr4)); + ip->ver = RTR_IPV4; + return rtr_ipv4_str_to_addr(str, &(ip->u.addr4)); } - ip->ver = LRTR_IPV6; - return lrtr_ipv6_str_to_addr(str, &(ip->u.addr6)); + ip->ver = RTR_IPV6; + return rtr_ipv6_str_to_addr(str, &(ip->u.addr6)); } // cppcheck-suppress unusedFunction -RTRLIB_EXPORT bool lrtr_ip_str_cmp(const struct lrtr_ip_addr *addr1, const char *addr2) +RTRLIB_EXPORT bool rtr_ip_str_cmp(const struct rtr_ip_addr *addr1, const char *addr2) { - struct lrtr_ip_addr tmp; + struct rtr_ip_addr tmp; - if (lrtr_ip_str_to_addr(addr2, &tmp) == -1) + if (rtr_ip_str_to_addr(addr2, &tmp) == -1) return false; - return lrtr_ip_addr_equal(*addr1, tmp); + return rtr_ip_addr_equal(*addr1, tmp); } diff --git a/rtrlib/lib/ip.h b/rtrlib/lib/ip.h index df3bb06b..a0fd6c34 100644 --- a/rtrlib/lib/ip.h +++ b/rtrlib/lib/ip.h @@ -7,8 +7,8 @@ * Website: http://rtrlib.realmv6.org/ */ -#ifndef LRTR_IP_PUBLIC_H -#define LRTR_IP_PUBLIC_H +#ifndef RTR_IP_PUBLIC_H +#define RTR_IP_PUBLIC_H #include "rtrlib/lib/ipv4.h" #include "rtrlib/lib/ipv6.h" @@ -22,66 +22,66 @@ /** * @brief Version of the IP protocol. */ -enum lrtr_ip_version { +enum rtr_ip_version { /** IPV4 */ - LRTR_IPV4, + RTR_IPV4, - /** LRTR_IPV6 */ - LRTR_IPV6 + /** RTR_IPV6 */ + RTR_IPV6 }; /** - * @brief The lrtr_ip_addr struct stores a IPv4 or IPv6 address in host byte order. + * @brief The rtr_ip_addr struct stores a IPv4 or IPv6 address in host byte order. * @param ver Specifies the type of the stored address. - * @param u Union holding a lrtr_ipv4_addr or lrtr_ipv6_addr. + * @param u Union holding a rtr_ipv4_addr or rtr_ipv6_addr. */ -struct lrtr_ip_addr { - enum lrtr_ip_version ver; +struct rtr_ip_addr { + enum rtr_ip_version ver; union { - struct lrtr_ipv4_addr addr4; - struct lrtr_ipv6_addr addr6; + struct rtr_ipv4_addr addr4; + struct rtr_ipv6_addr addr6; } u; }; /** - * Converts the passed lrtr_ip_addr struct to string representation. - * @param[in] ip lrtr_ip_addr + * Converts the passed rtr_ip_addr struct to string representation. + * @param[in] ip rtr_ip_addr * @param[out] str Pointer to a char array. - * The array must be at least INET_ADDRSTRLEN bytes long if the passed lrtr_ip_addr stores an IPv4 address. - * If lrtr_ip_addr stores an IPv6 address, str must be at least INET6_ADDRSTRLEN bytes long. + * The array must be at least INET_ADDRSTRLEN bytes long if the passed rtr_ip_addr stores an IPv4 address. + * If rtr_ip_addr stores an IPv6 address, str must be at least INET6_ADDRSTRLEN bytes long. * @param[in] len Length of the str array. * @result 0 On success. * @result -1 On error. */ -int lrtr_ip_addr_to_str(const struct lrtr_ip_addr *ip, char *str, const unsigned int len); +int rtr_ip_addr_to_str(const struct rtr_ip_addr *ip, char *str, const unsigned int len); /** - * Converts the passed IP address in string representation to an lrtr_ip_addr. + * Converts the passed IP address in string representation to an rtr_ip_addr. * @param[in] str Pointer to a Null terminated char array. - * @param[out] ip Pointer to a lrtr_ip_addr struct. + * @param[out] ip Pointer to a rtr_ip_addr struct. * @result 0 On success. * @result -1 On error. */ -int lrtr_ip_str_to_addr(const char *str, struct lrtr_ip_addr *ip); +int rtr_ip_str_to_addr(const char *str, struct rtr_ip_addr *ip); /** * - * @brief Checks if two lrtr_ip_addr structs are equal. - * @param[in] a lrtr_ip_addr - * @param[in] b lrtr_ip_addr + * @brief Checks if two rtr_ip_addr structs are equal. + * @param[in] a rtr_ip_addr + * @param[in] b rtr_ip_addr * @return true If a == b. * @return false If a != b. */ -bool lrtr_ip_addr_equal(const struct lrtr_ip_addr a, const struct lrtr_ip_addr b); +bool rtr_ip_addr_equal(const struct rtr_ip_addr a, const struct rtr_ip_addr b); /** - * Compares addr1 in the lrtr_ip_addr struct with addr2 in string representation. - * @param[in] addr1 lrtr_ip_addr + * Compares addr1 in the rtr_ip_addr struct with addr2 in string representation. + * @param[in] addr1 rtr_ip_addr * @param[in] addr2 IP-address as string * @return true If a == b * @return false If a != b */ -bool lrtr_ip_str_cmp(const struct lrtr_ip_addr *addr1, const char *addr2); +bool rtr_ip_str_cmp(const struct rtr_ip_addr *addr1, const char *addr2); #endif /** @} */ diff --git a/rtrlib/lib/ip_private.h b/rtrlib/lib/ip_private.h index 623fd96d..7be6083f 100644 --- a/rtrlib/lib/ip_private.h +++ b/rtrlib/lib/ip_private.h @@ -7,8 +7,8 @@ * Website: http://rtrlib.realmv6.org/ */ -#ifndef LRTR_IP_PRIVATE_H -#define LRTR_IP_PRIVATE_H +#ifndef RTR_IP_PRIVATE_H +#define RTR_IP_PRIVATE_H #include "ip.h" @@ -16,43 +16,43 @@ #include "rtrlib/lib/ipv6_private.h" /** - * @brief Detects if the lrtr_ip_addr only contains 0 bits. - * @param[in] lrtr_ip_addr - * @returns true If the saved lrtr_ip_addr is 0. - * @returns false If the saved lrtr_ip_addr isn't 0. + * @brief Detects if the rtr_ip_addr only contains 0 bits. + * @param[in] rtr_ip_addr + * @returns true If the saved rtr_ip_addr is 0. + * @returns false If the saved rtr_ip_addr isn't 0. */ -bool lrtr_ip_addr_is_zero(const struct lrtr_ip_addr); +bool rtr_ip_addr_is_zero(const struct rtr_ip_addr); /** - * @brief Extracts number bits from the passed lrtr_ip_addr, starting at bit number from. The bit with the highest + * @brief Extracts number bits from the passed rtr_ip_addr, starting at bit number from. The bit with the highest * significance is bit 0. All bits that aren't in the specified range will be 0. - * @param[in] val lrtr_ip_addr + * @param[in] val rtr_ip_addr * @param[in] from Position of the first bit that is extracted. * @param[in] number How many bits will be extracted. - * @returns An lrtr_ipv_addr, where all bits that aren't in the specified range are set to 0. + * @returns An rtr_ipv_addr, where all bits that aren't in the specified range are set to 0. */ -struct lrtr_ip_addr lrtr_ip_addr_get_bits(const struct lrtr_ip_addr *val, const uint8_t from, const uint8_t number); +struct rtr_ip_addr rtr_ip_addr_get_bits(const struct rtr_ip_addr *val, const uint8_t from, const uint8_t number); /** * @defgroup util_h Utility functions * @{ * - * @brief Checks if two lrtr_ip_addr structs are equal. - * @param[in] a lrtr_ip_addr - * @param[in] b lrtr_ip_addr + * @brief Checks if two rtr_ip_addr structs are equal. + * @param[in] a rtr_ip_addr + * @param[in] b rtr_ip_addr * @return true If a == b. * @return false If a != b. */ -bool lrtr_ip_addr_equal(const struct lrtr_ip_addr a, const struct lrtr_ip_addr b); +bool rtr_ip_addr_equal(const struct rtr_ip_addr a, const struct rtr_ip_addr b); /** - * Compares addr1 in the lrtr_ip_addr struct with addr2 in string representation. - * @param[in] addr1 lrtr_ip_addr + * Compares addr1 in the rtr_ip_addr struct with addr2 in string representation. + * @param[in] addr1 rtr_ip_addr * @param[in] addr2 IP-address as string * @return true If a == b * @return false If a != b */ -bool lrtr_ip_str_cmp(const struct lrtr_ip_addr *addr1, const char *addr2); +bool rtr_ip_str_cmp(const struct rtr_ip_addr *addr1, const char *addr2); #endif /** @} */ diff --git a/rtrlib/lib/ipv4.c b/rtrlib/lib/ipv4.c index d7f10e1b..fc983273 100644 --- a/rtrlib/lib/ipv4.c +++ b/rtrlib/lib/ipv4.c @@ -15,15 +15,15 @@ #include #include -struct lrtr_ipv4_addr lrtr_ipv4_get_bits(const struct lrtr_ipv4_addr *val, const uint8_t from, const uint8_t quantity) +struct rtr_ipv4_addr rtr_ipv4_get_bits(const struct rtr_ipv4_addr *val, const uint8_t from, const uint8_t quantity) { - struct lrtr_ipv4_addr result; + struct rtr_ipv4_addr result; - result.addr = lrtr_get_bits(val->addr, from, quantity); + result.addr = rtr_get_bits(val->addr, from, quantity); return result; } -int lrtr_ipv4_addr_to_str(const struct lrtr_ipv4_addr *ip, char *str, unsigned int len) +int rtr_ipv4_addr_to_str(const struct rtr_ipv4_addr *ip, char *str, unsigned int len) { uint8_t buff[4]; @@ -38,7 +38,7 @@ int lrtr_ipv4_addr_to_str(const struct lrtr_ipv4_addr *ip, char *str, unsigned i return 0; } -int lrtr_ipv4_str_to_addr(const char *str, struct lrtr_ipv4_addr *ip) +int rtr_ipv4_str_to_addr(const char *str, struct rtr_ipv4_addr *ip) { uint8_t buff[4]; @@ -50,7 +50,7 @@ int lrtr_ipv4_str_to_addr(const char *str, struct lrtr_ipv4_addr *ip) return 0; } -bool lrtr_ipv4_addr_equal(const struct lrtr_ipv4_addr *a, const struct lrtr_ipv4_addr *b) +bool rtr_ipv4_addr_equal(const struct rtr_ipv4_addr *a, const struct rtr_ipv4_addr *b) { if (a->addr == b->addr) return true; @@ -58,7 +58,7 @@ bool lrtr_ipv4_addr_equal(const struct lrtr_ipv4_addr *a, const struct lrtr_ipv4 return false; } -void lrtr_ipv4_addr_convert_byte_order(const uint32_t src, uint32_t *dest, const enum target_byte_order tbo) +void rtr_ipv4_addr_convert_byte_order(const uint32_t src, uint32_t *dest, const enum target_byte_order tbo) { - *dest = lrtr_convert_long(tbo, src); + *dest = rtr_convert_long(tbo, src); } diff --git a/rtrlib/lib/ipv4.h b/rtrlib/lib/ipv4.h index 9aff5aad..d8098f14 100644 --- a/rtrlib/lib/ipv4.h +++ b/rtrlib/lib/ipv4.h @@ -7,8 +7,8 @@ * Website: http://rtrlib.realmv6.org/ */ -#ifndef LRTR_IPV4_H -#define LRTR_IPV4_H +#ifndef RTR_IPV4_H +#define RTR_IPV4_H #include @@ -16,7 +16,7 @@ * @brief Struct storing an IPv4 address in host byte order. * @param addr The IPv4 address. */ -struct lrtr_ipv4_addr { +struct rtr_ipv4_addr { uint32_t addr; }; diff --git a/rtrlib/lib/ipv4_private.h b/rtrlib/lib/ipv4_private.h index 73d0170f..c570c71d 100644 --- a/rtrlib/lib/ipv4_private.h +++ b/rtrlib/lib/ipv4_private.h @@ -7,8 +7,8 @@ * Website: http://rtrlib.realmv6.org/ */ -#ifndef LRTR_IPV4_PRIVATE_H -#define LRTR_IPV4_PRIVATE_H +#ifndef RTR_IPV4_PRIVATE_H +#define RTR_IPV4_PRIVATE_H #include "ipv4.h" @@ -29,7 +29,7 @@ * * @returns An ipv4_addr, with all bits not in the specified range set to 0. */ -struct lrtr_ipv4_addr lrtr_ipv4_get_bits(const struct lrtr_ipv4_addr *val, const uint8_t from, const uint8_t number); +struct rtr_ipv4_addr rtr_ipv4_get_bits(const struct rtr_ipv4_addr *val, const uint8_t from, const uint8_t number); /** * @brief Converts ab IPv4 address from string to ipv4_addr struct. @@ -40,7 +40,7 @@ struct lrtr_ipv4_addr lrtr_ipv4_get_bits(const struct lrtr_ipv4_addr *val, const * @result 0 on success * @result -1 on error */ -int lrtr_ipv4_str_to_addr(const char *str, struct lrtr_ipv4_addr *ip); +int rtr_ipv4_str_to_addr(const char *str, struct rtr_ipv4_addr *ip); /** * @brief Converts an ipv4_addr struct to its string representation. @@ -52,7 +52,7 @@ int lrtr_ipv4_str_to_addr(const char *str, struct lrtr_ipv4_addr *ip); * @result 0 on success * @result -1 on error */ -int lrtr_ipv4_addr_to_str(const struct lrtr_ipv4_addr *ip, char *str, const unsigned int len); +int rtr_ipv4_addr_to_str(const struct rtr_ipv4_addr *ip, char *str, const unsigned int len); /** * @brief Compares two ipv4_addr structs. @@ -63,7 +63,7 @@ int lrtr_ipv4_addr_to_str(const struct lrtr_ipv4_addr *ip, char *str, const unsi * @return true if a == b * @return false if a != b */ -bool lrtr_ipv4_addr_equal(const struct lrtr_ipv4_addr *a, const struct lrtr_ipv4_addr *b); +bool rtr_ipv4_addr_equal(const struct rtr_ipv4_addr *a, const struct rtr_ipv4_addr *b); /** * @ingroup util_h[{ @@ -74,6 +74,6 @@ bool lrtr_ipv4_addr_equal(const struct lrtr_ipv4_addr *a, const struct lrtr_ipv4 * @param[in] tbo Target byte order for address conversion. * } */ -void lrtr_ipv4_addr_convert_byte_order(const uint32_t src, uint32_t *dest, const enum target_byte_order tbo); +void rtr_ipv4_addr_convert_byte_order(const uint32_t src, uint32_t *dest, const enum target_byte_order tbo); #endif diff --git a/rtrlib/lib/ipv6.c b/rtrlib/lib/ipv6.c index 34bd8caa..ed0c376e 100644 --- a/rtrlib/lib/ipv6.c +++ b/rtrlib/lib/ipv6.c @@ -18,7 +18,7 @@ #include #include -inline bool lrtr_ipv6_addr_equal(const struct lrtr_ipv6_addr *a, const struct lrtr_ipv6_addr *b) +inline bool rtr_ipv6_addr_equal(const struct rtr_ipv6_addr *a, const struct rtr_ipv6_addr *b) { if (a->addr[0] == b->addr[0] && a->addr[1] == b->addr[1] && a->addr[2] == b->addr[2] && a->addr[3] == b->addr[3]) @@ -26,7 +26,7 @@ inline bool lrtr_ipv6_addr_equal(const struct lrtr_ipv6_addr *a, const struct lr return false; } -struct lrtr_ipv6_addr lrtr_ipv6_get_bits(const struct lrtr_ipv6_addr *val, const uint8_t first_bit, +struct rtr_ipv6_addr rtr_ipv6_get_bits(const struct rtr_ipv6_addr *val, const uint8_t first_bit, const uint8_t quantity) { assert(first_bit <= 127); @@ -34,7 +34,7 @@ struct lrtr_ipv6_addr lrtr_ipv6_get_bits(const struct lrtr_ipv6_addr *val, const assert(first_bit + quantity <= 128); // if no bytes get extracted the result has to be 0 - struct lrtr_ipv6_addr result; + struct rtr_ipv6_addr result; memset(&result, 0, sizeof(result)); @@ -45,7 +45,7 @@ struct lrtr_ipv6_addr lrtr_ipv6_get_bits(const struct lrtr_ipv6_addr *val, const assert(bits_left >= q); bits_left -= q; - result.addr[0] = lrtr_get_bits(val->addr[0], first_bit, q); + result.addr[0] = rtr_get_bits(val->addr[0], first_bit, q); } if ((first_bit <= 63) && ((first_bit + quantity) > 32)) { @@ -54,7 +54,7 @@ struct lrtr_ipv6_addr lrtr_ipv6_get_bits(const struct lrtr_ipv6_addr *val, const assert(bits_left >= q); bits_left -= q; - result.addr[1] = lrtr_get_bits(val->addr[1], fr, q); + result.addr[1] = rtr_get_bits(val->addr[1], fr, q); } if ((first_bit <= 95) && ((first_bit + quantity) > 64)) { @@ -63,7 +63,7 @@ struct lrtr_ipv6_addr lrtr_ipv6_get_bits(const struct lrtr_ipv6_addr *val, const assert(bits_left >= q); bits_left -= q; - result.addr[2] = lrtr_get_bits(val->addr[2], fr, q); + result.addr[2] = rtr_get_bits(val->addr[2], fr, q); } if ((first_bit <= 127) && ((first_bit + quantity) > 96)) { @@ -71,7 +71,7 @@ struct lrtr_ipv6_addr lrtr_ipv6_get_bits(const struct lrtr_ipv6_addr *val, const const uint8_t q = bits_left > 32 ? 32 : bits_left; assert(bits_left >= q); - result.addr[3] = lrtr_get_bits(val->addr[3], fr, q); + result.addr[3] = rtr_get_bits(val->addr[3], fr, q); } return result; } @@ -79,7 +79,7 @@ struct lrtr_ipv6_addr lrtr_ipv6_get_bits(const struct lrtr_ipv6_addr *val, const /* * This function was copied from the bird routing daemon's ip_pton(..) function. */ -int lrtr_ipv6_str_to_addr(const char *a, struct lrtr_ipv6_addr *ip) +int rtr_ipv6_str_to_addr(const char *a, struct rtr_ipv6_addr *ip) { uint32_t *o = ip->addr; uint16_t words[8]; @@ -120,9 +120,9 @@ int lrtr_ipv6_str_to_addr(const char *a, struct lrtr_ipv6_addr *ip) if (*a == ':' && a[1]) { a++; } else if (*a == '.' && (i == 6 || (i < 6 && hfil >= 0))) { /* Embedded IPv4 address */ - struct lrtr_ipv4_addr addr4; + struct rtr_ipv4_addr addr4; - if (lrtr_ipv4_str_to_addr(start, &addr4) == -1) + if (rtr_ipv4_str_to_addr(start, &addr4) == -1) return -1; words[i++] = addr4.addr >> 16; words[i++] = addr4.addr; @@ -144,7 +144,7 @@ int lrtr_ipv6_str_to_addr(const char *a, struct lrtr_ipv6_addr *ip) words[i] = 0; } - /* Convert the address to lrtr_ip_addr format */ + /* Convert the address to rtr_ip_addr format */ for (i = 0; i < 4; i++) o[i] = (words[2 * i] << 16) | words[2 * i + 1]; return 0; @@ -153,7 +153,7 @@ int lrtr_ipv6_str_to_addr(const char *a, struct lrtr_ipv6_addr *ip) /* * This function was copied from the bird routing daemon's ip_ntop(..) function. */ -int lrtr_ipv6_addr_to_str(const struct lrtr_ipv6_addr *ip_addr, char *b, const unsigned int len) +int rtr_ipv6_addr_to_str(const struct rtr_ipv6_addr *ip_addr, char *b, const unsigned int len) { if (len < INET6_ADDRSTRLEN) return -1; @@ -213,8 +213,8 @@ int lrtr_ipv6_addr_to_str(const struct lrtr_ipv6_addr *ip_addr, char *b, const u return 0; } -void lrtr_ipv6_addr_convert_byte_order(const uint32_t *src, uint32_t *dest, const enum target_byte_order tbo) +void rtr_ipv6_addr_convert_byte_order(const uint32_t *src, uint32_t *dest, const enum target_byte_order tbo) { for (int i = 0; i < 4; i++) - dest[i] = lrtr_convert_long(tbo, src[i]); + dest[i] = rtr_convert_long(tbo, src[i]); } diff --git a/rtrlib/lib/ipv6.h b/rtrlib/lib/ipv6.h index 6be7485e..8dd23f55 100644 --- a/rtrlib/lib/ipv6.h +++ b/rtrlib/lib/ipv6.h @@ -7,16 +7,16 @@ * Website: http://rtrlib.realmv6.org/ */ -#ifndef LRTR_IPV6_PUBLIC_H -#define LRTR_IPV6_PUBLIC_H +#ifndef RTR_IPV6_PUBLIC_H +#define RTR_IPV6_PUBLIC_H #include /** * @brief Struct holding an IPv6 address in host byte order. */ -struct lrtr_ipv6_addr { +struct rtr_ipv6_addr { uint32_t addr[4]; /**< The IPv6 address. */ }; -#endif /* LRTR_IPV6_PUBLIC_H */ +#endif /* RTR_IPV6_PUBLIC_H */ diff --git a/rtrlib/lib/ipv6_private.h b/rtrlib/lib/ipv6_private.h index 1007e73b..dfd77de7 100644 --- a/rtrlib/lib/ipv6_private.h +++ b/rtrlib/lib/ipv6_private.h @@ -7,8 +7,8 @@ * Website: http://rtrlib.realmv6.org/ */ -#ifndef LRTR_IPV6_PRIVATE_H -#define LRTR_IPV6_PRIVATE_H +#ifndef RTR_IPV6_PRIVATE_H +#define RTR_IPV6_PRIVATE_H #include "ipv6.h" @@ -19,15 +19,15 @@ #include /** - * @brief Compares two lrtr_ipv6_addr structs + * @brief Compares two rtr_ipv6_addr structs * - * @param[in] a lrtr_ipv6_addr - * @param[in] b lrtr_ipv6_addr + * @param[in] a rtr_ipv6_addr + * @param[in] b rtr_ipv6_addr * * @return true if a == b * @return false if a != b */ -bool lrtr_ipv6_addr_equal(const struct lrtr_ipv6_addr *a, const struct lrtr_ipv6_addr *b); +bool rtr_ipv6_addr_equal(const struct rtr_ipv6_addr *a, const struct rtr_ipv6_addr *b); /** * @brief Extracts quantity bits from an IPv6 address. @@ -41,7 +41,7 @@ bool lrtr_ipv6_addr_equal(const struct lrtr_ipv6_addr *a, const struct lrtr_ipv6 * * @returns ipv6_addr, with all bits not in specified range set to 0. */ -struct lrtr_ipv6_addr lrtr_ipv6_get_bits(const struct lrtr_ipv6_addr *val, const uint8_t first_bit, +struct rtr_ipv6_addr rtr_ipv6_get_bits(const struct rtr_ipv6_addr *val, const uint8_t first_bit, const uint8_t quantity); /** @@ -54,18 +54,18 @@ struct lrtr_ipv6_addr lrtr_ipv6_get_bits(const struct lrtr_ipv6_addr *val, const * @result 0 on success * @result -1 on error */ -int lrtr_ipv6_addr_to_str(const struct lrtr_ipv6_addr *ip, char *str, const unsigned int len); +int rtr_ipv6_addr_to_str(const struct rtr_ipv6_addr *ip, char *str, const unsigned int len); /** - * @brief Converts the passed IPv6 address string in to lrtr_ipv6_addr struct. + * @brief Converts the passed IPv6 address string in to rtr_ipv6_addr struct. * * @param[in] str Pointer to a string buffer - * @param[out] ip Pointer to lrtr_ipv6_addr + * @param[out] ip Pointer to rtr_ipv6_addr * * @result 0 on success * @result -1 on error */ -int lrtr_ipv6_str_to_addr(const char *str, struct lrtr_ipv6_addr *ip); +int rtr_ipv6_str_to_addr(const char *str, struct rtr_ipv6_addr *ip); /** * @ingroup util_h @@ -76,6 +76,6 @@ int lrtr_ipv6_str_to_addr(const char *str, struct lrtr_ipv6_addr *ip); * @param[out] dest IPv6 address (uint32_t array) in target byte order. * @param[in] tbo Target byte order for address conversion. */ -void lrtr_ipv6_addr_convert_byte_order(const uint32_t *src, uint32_t *dest, const enum target_byte_order tbo); +void rtr_ipv6_addr_convert_byte_order(const uint32_t *src, uint32_t *dest, const enum target_byte_order tbo); /** @} */ -#endif /* LRTR_IPV6_H */ +#endif /* RTR_IPV6_H */ diff --git a/rtrlib/lib/log.c b/rtrlib/lib/log.c index 6ceaaa35..1963c608 100644 --- a/rtrlib/lib/log.c +++ b/rtrlib/lib/log.c @@ -17,7 +17,7 @@ #include #include -void lrtr_dbg(const char *frmt, ...) +void rtr_dbg(const char *frmt, ...) { #ifndef NDEBUG va_list argptr; diff --git a/rtrlib/lib/log_private.h b/rtrlib/lib/log_private.h index e33ebf3d..b9b4e5d6 100644 --- a/rtrlib/lib/log_private.h +++ b/rtrlib/lib/log_private.h @@ -7,13 +7,13 @@ * Website: http://rtrlib.realmv6.org/ */ -#ifndef LRTR_LOG_PRIVATE_H -#define LRTR_LOG_PRIVATE_H +#ifndef RTR_LOG_PRIVATE_H +#define RTR_LOG_PRIVATE_H /** * @brief Writes a message to stdout if NDEBUG isn't defined. * @param[in] frmt log message in printf format style. */ -void lrtr_dbg(const char *frmt, ...) __attribute__((format(printf, 1, 2))); +void rtr_dbg(const char *frmt, ...) __attribute__((format(printf, 1, 2))); #endif diff --git a/rtrlib/lib/utils.c b/rtrlib/lib/utils.c index cf347103..e12e83bd 100644 --- a/rtrlib/lib/utils.c +++ b/rtrlib/lib/utils.c @@ -18,7 +18,7 @@ static double timeconvert = 0.0; #endif -int lrtr_get_monotonic_time(time_t *seconds) +int rtr_get_monotonic_time(time_t *seconds) { #if defined(__MACH__) && defined(__APPLE__) if (timeconvert == 0.0) { @@ -39,7 +39,7 @@ int lrtr_get_monotonic_time(time_t *seconds) return 0; } -uint32_t lrtr_get_bits(const uint32_t val, const uint8_t from, const uint8_t number) +uint32_t rtr_get_bits(const uint32_t val, const uint8_t from, const uint8_t number) { assert(number < 33); assert(number > 0); diff --git a/rtrlib/lib/utils_private.h b/rtrlib/lib/utils_private.h index 40e99ee7..e59fe05d 100644 --- a/rtrlib/lib/utils_private.h +++ b/rtrlib/lib/utils_private.h @@ -7,8 +7,8 @@ * Website: http://rtrlib.realmv6.org/ */ -#ifndef LRTR_UTILS_PRIVATE_H -#define LRTR_UTILS_PRIVATE_H +#ifndef RTR_UTILS_PRIVATE_H +#define RTR_UTILS_PRIVATE_H #include #include @@ -19,7 +19,7 @@ * @return 0 on successs * @return -1 on error */ -int lrtr_get_monotonic_time(time_t *seconds); +int rtr_get_monotonic_time(time_t *seconds); /** * @brief Extracts number bits from the passed uint32_t, starting at bit number from. The bit with the highest @@ -29,6 +29,6 @@ int lrtr_get_monotonic_time(time_t *seconds); * @param[in] number How many bits will be extracted. * @returns a uint32_t, where all bits that aren't in the specified range are set to 0. */ -uint32_t lrtr_get_bits(const uint32_t val, const uint8_t from, const uint8_t number); +uint32_t rtr_get_bits(const uint32_t val, const uint8_t from, const uint8_t number); #endif diff --git a/rtrlib/pfx/pfx.h b/rtrlib/pfx/pfx.h index 5bcb532c..0e8b859d 100644 --- a/rtrlib/pfx/pfx.h +++ b/rtrlib/pfx/pfx.h @@ -26,79 +26,79 @@ /** * @brief Possible return values for pfx_ functions. */ -enum pfx_rtvals { +enum rtr_pfx_rtvals { /** Operation was successful. */ - PFX_SUCCESS = 0, + RTR_PFX_SUCCESS = 0, /** Error occurred. */ - PFX_ERROR = -1, + RTR_PFX_ERROR = -1, /** The supplied pfx_record already exists in the pfx_table. */ - PFX_DUPLICATE_RECORD = -2, + RTR_PFX_DUPLICATE_RECORD = -2, /** pfx_record wasn't found in the pfx_table. */ - PFX_RECORD_NOT_FOUND = -3, + RTR_PFX_RECORD_NOT_FOUND = -3, /** The PFX feature was not initialized/enabled. */ - PFX_NOT_INITIALIZED = -4, + RTR_PFX_NOT_INITIALIZED = -4, }; /** * @brief Validation states returned from pfx_validate_origin. */ -enum pfxv_state { +enum rtr_pfxv_state { /** A valid certificate for the pfx_record exists. */ - BGP_PFXV_STATE_VALID, + RTR_BGP_PFXV_STATE_VALID, /** @brief No certificate for the route exists. */ - BGP_PFXV_STATE_NOT_FOUND, + RTR_BGP_PFXV_STATE_NOT_FOUND, /** @brief One or more records that match the input prefix exists in the pfx_table * but the prefix max_len or ASN doesn't match. */ - BGP_PFXV_STATE_INVALID + RTR_BGP_PFXV_STATE_INVALID }; /** * @brief A function pointer that is called for each record in the pfx_table. * @param pfx_record - * @param data forwarded data which the user has passed to pfx_table_for_each_ipv4_record() or - * pfx_table_for_each_ipv6_record() + * @param data forwarded data which the user has passed to rtr_pfx_table_for_each_ipv4_record() or + * rtr_pfx_table_for_each_ipv6_record() */ -typedef void (*pfx_for_each_fp)(const struct pfx_record *pfx_record, void *data); +typedef void (*rtr_pfx_for_each_fp)(const struct rtr_pfx_record *pfx_record, void *data); /** * @brief Initializes the pfx_table struct. * @param[in] pfx_table pfx_table that will be initialized. * @param[in] update_fp A function pointer that will be called if a record was added or removed. */ -void pfx_table_init(struct pfx_table *pfx_table, pfx_update_fp update_fp); +void rtr_pfx_table_init(struct rtr_pfx_table *pfx_table, rtr_pfx_update_fp update_fp); /** * @brief Frees all memory associated with the pfx_table. * @param[in] pfx_table pfx_table that will be freed. */ -void pfx_table_free(struct pfx_table *pfx_table); +void rtr_pfx_table_free(struct rtr_pfx_table *pfx_table); /** * @brief Adds a pfx_record to a pfx_table. * @param[in] pfx_table pfx_table to use. - * @param[in] pfx_record pfx_record that will be added. + * @param[in] record pfx_record that will be added. * @return PFX_SUCCESS On success. * @return PFX_ERROR On error. * @return PFX_DUPLICATE_RECORD If the pfx_record already exists. */ -int pfx_table_add(struct pfx_table *pfx_table, const struct pfx_record *pfx_record); +enum rtr_pfx_rtvals rtr_pfx_table_add(struct rtr_pfx_table *pfx_table, const struct rtr_pfx_record *record); /** * @brief Removes a pfx_record from a pfx_table. * @param[in] pfx_table pfx_table to use. - * @param[in] pfx_record Record that will be removed. + * @param[in] record Record that will be removed. * @return PFX_SUCCESS On success. * @return PFX_ERROR On error. * @return PFX_RECORD_NOT_FOUND If pfx_records couldn't be found. */ -int pfx_table_remove(struct pfx_table *pfx_table, const struct pfx_record *pfx_record); +enum rtr_pfx_rtvals rtr_pfx_table_remove(struct rtr_pfx_table *pfx_table, const struct rtr_pfx_record *record); /** * @brief Removes all entries in the pfx_table that match the passed socket_id value from a pfx_table. @@ -107,20 +107,21 @@ int pfx_table_remove(struct pfx_table *pfx_table, const struct pfx_record *pfx_r * @return PFX_SUCCESS On success. * @return PFX_ERROR On error. */ -int pfx_table_src_remove(struct pfx_table *pfx_table, const struct rtr_socket *socket); +enum rtr_pfx_rtvals rtr_pfx_table_src_remove(struct rtr_pfx_table *pfx_table, const struct rtr_socket *socket); /** * @brief Validates the origin of a BGP-Route. * @param[in] pfx_table pfx_table to use. * @param[in] asn Autonomous system number of the Origin-AS of the route. * @param[in] prefix Announced network Prefix. - * @param[in] mask_len Length of the network mask of the announced prefix. + * @param[in] prefix_len Length of the network mask of the announced prefix. * @param[out] result Result of the validation. * @return PFX_SUCCESS On success. * @return PFX_ERROR On error. */ -int pfx_table_validate(struct pfx_table *pfx_table, const uint32_t asn, const struct lrtr_ip_addr *prefix, - const uint8_t mask_len, enum pfxv_state *result); +enum rtr_pfx_rtvals rtr_pfx_table_validate(struct rtr_pfx_table *pfx_table, const uint32_t asn, + const struct rtr_ip_addr *prefix, const uint8_t prefix_len, + enum rtr_pfxv_state *result); /** * @brief Validates the origin of a BGP-Route and returns a list of pfx_record that decided the result. @@ -130,14 +131,15 @@ int pfx_table_validate(struct pfx_table *pfx_table, const uint32_t asn, const st * @param[out] reason_len Size of the array reason. * @param[in] asn Autonomous system number of the Origin-AS of the route. * @param[in] prefix Announced network Prefix - * @param[in] mask_len Length of the network mask of the announced prefix + * @param[in] prefix_len Length of the network mask of the announced prefix * @param[out] result Result of the validation. * @return PFX_SUCCESS On success. * @return PFX_ERROR On error. */ -int pfx_table_validate_r(struct pfx_table *pfx_table, struct pfx_record **reason, unsigned int *reason_len, - const uint32_t asn, const struct lrtr_ip_addr *prefix, const uint8_t mask_len, - enum pfxv_state *result); +enum rtr_pfx_rtvals rtr_pfx_table_validate_r(struct rtr_pfx_table *pfx_table, struct rtr_pfx_record **reason, + unsigned int *reason_len, const uint32_t asn, + const struct rtr_ip_addr *prefix, const uint8_t prefix_len, + enum rtr_pfxv_state *result); /** * @brief Iterates over all IPv4 records in the pfx_table. @@ -146,8 +148,11 @@ int pfx_table_validate_r(struct pfx_table *pfx_table, struct pfx_record **reason * @param[in] pfx_table * @param[in] fp A pointer to a callback function with the signature \c pfx_for_each_fp. * @param[in] data This parameter is forwarded to the callback function. + * @return PFX_SUCCESS on success. + * @return RTR_PFX_NOT_INITIALIZED if ROA support has not been enabled. */ -void pfx_table_for_each_ipv4_record(struct pfx_table *pfx_table, pfx_for_each_fp fp, void *data); +enum rtr_pfx_rtvals rtr_pfx_table_for_each_ipv4_record(struct rtr_pfx_table *pfx_table, rtr_pfx_for_each_fp fp, + void *data); /** * @brief Iterates over all IPv6 records in the pfx_table. @@ -156,8 +161,11 @@ void pfx_table_for_each_ipv4_record(struct pfx_table *pfx_table, pfx_for_each_fp * @param[in] pfx_table * @param[in] fp A pointer to a callback function with the signature \c pfx_for_each_fp. * @param[in] data This parameter is forwarded to the callback function. + * @return PFX_SUCCESS on success. + * @return RTR_PFX_NOT_INITIALIZED if ROA support has not been enabled. */ -void pfx_table_for_each_ipv6_record(struct pfx_table *pfx_table, pfx_for_each_fp fp, void *data); +enum rtr_pfx_rtvals rtr_pfx_table_for_each_ipv6_record(struct rtr_pfx_table *pfx_table, rtr_pfx_for_each_fp fp, + void *data); #endif /** @} */ diff --git a/rtrlib/pfx/pfx_private.h b/rtrlib/pfx/pfx_private.h index 6ec1d8a6..4f56de0d 100644 --- a/rtrlib/pfx/pfx_private.h +++ b/rtrlib/pfx/pfx_private.h @@ -28,14 +28,14 @@ * @brief Frees all memory associated with the pfx_table without calling the update callback. * @param[in] pfx_table pfx_table that will be freed. */ -void pfx_table_free_without_notify(struct pfx_table *pfx_table); +void pfx_table_free_without_notify(struct rtr_pfx_table *pfx_table); /** * @brief Swap root nodes of the argument tables * @param[in,out] a First table * @param[in,out] b second table */ -void pfx_table_swap(struct pfx_table *a, struct pfx_table *b); +void pfx_table_swap(struct rtr_pfx_table *a, struct rtr_pfx_table *b); /** * @brief Copy content of @p src_table into @p dst_table @@ -44,7 +44,7 @@ void pfx_table_swap(struct pfx_table *a, struct pfx_table *b); * @param[out] dst_table Destination table * @param[in] socket socket which prefixes should not be copied */ -int pfx_table_copy_except_socket(struct pfx_table *src_table, struct pfx_table *dst_table, +int pfx_table_copy_except_socket(struct rtr_pfx_table *src_table, struct rtr_pfx_table *dst_table, const struct rtr_socket *socket); /** @@ -54,7 +54,7 @@ int pfx_table_copy_except_socket(struct pfx_table *src_table, struct pfx_table * * @param[in] old_table * @param[in] socket socket which prefixes should be diffed */ -void pfx_table_notify_diff(struct pfx_table *new_table, struct pfx_table *old_table, const struct rtr_socket *socket); +void pfx_table_notify_diff(struct rtr_pfx_table *new_table, struct rtr_pfx_table *old_table, const struct rtr_socket *socket); #endif /** @} */ diff --git a/rtrlib/pfx/trie/trie-pfx.c b/rtrlib/pfx/trie/trie-pfx.c index 51f6420a..69801ae5 100644 --- a/rtrlib/pfx/trie/trie-pfx.c +++ b/rtrlib/pfx/trie/trie-pfx.c @@ -32,39 +32,42 @@ struct node_data { }; struct copy_cb_args { - struct pfx_table *pfx_table; + struct rtr_pfx_table *pfx_table; const struct rtr_socket *socket; bool error; }; struct notify_diff_cb_args { - struct pfx_table *old_table; - struct pfx_table *new_table; + struct rtr_pfx_table *old_table; + struct rtr_pfx_table *new_table; const struct rtr_socket *socket; - pfx_update_fp pfx_update_fp; - bool added; + rtr_pfx_update_fp pfx_update_fp; + enum rtr_pfx_operation_type operation_type; }; -static struct trie_node *pfx_table_get_root(const struct pfx_table *pfx_table, const enum lrtr_ip_version ver); +static struct trie_node *pfx_table_get_root(const struct rtr_pfx_table *pfx_table, const enum rtr_ip_version ver); static int pfx_table_del_elem(struct node_data *data, const unsigned int index); -static int pfx_table_create_node(struct trie_node **node, const struct pfx_record *record); -static int pfx_table_append_elem(struct node_data *data, const struct pfx_record *record); -static struct data_elem *pfx_table_find_elem(const struct node_data *data, const struct pfx_record *record, +static int pfx_table_create_node(struct trie_node **node, const struct rtr_pfx_record *record); +static int pfx_table_append_elem(struct node_data *data, const struct rtr_pfx_record *record); +static struct data_elem *pfx_table_find_elem(const struct node_data *data, const struct rtr_pfx_record *record, unsigned int *index); static bool pfx_table_elem_matches(struct node_data *data, const uint32_t asn, const uint8_t prefix_len); -static void pfx_table_notify_clients(struct pfx_table *pfx_table, const struct pfx_record *record, const bool added); -static int pfx_table_remove_id(struct pfx_table *pfx_table, struct trie_node **root, struct trie_node *node, +static void pfx_table_notify_clients(struct rtr_pfx_table *pfx_table, const struct rtr_pfx_record *record, + const enum rtr_pfx_operation_type); +static int pfx_table_remove_id(struct rtr_pfx_table *pfx_table, struct trie_node **root, struct trie_node *node, const struct rtr_socket *socket, const unsigned int level); -static int pfx_table_node2pfx_record(struct trie_node *node, struct pfx_record records[], const unsigned int ary_len); -static void pfx_table_free_reason(struct pfx_record **reason, unsigned int *reason_len); +static int pfx_table_node2pfx_record(struct trie_node *node, struct rtr_pfx_record records[], + const unsigned int ary_len); +static void pfx_table_free_reason(struct rtr_pfx_record **reason, unsigned int *reason_len); -void pfx_table_notify_clients(struct pfx_table *pfx_table, const struct pfx_record *record, const bool added) +void pfx_table_notify_clients(struct rtr_pfx_table *pfx_table, const struct rtr_pfx_record *record, + const enum rtr_pfx_operation_type operation_type) { if (pfx_table->update_fp) - pfx_table->update_fp(pfx_table, *record, added); + pfx_table->update_fp(pfx_table, *record, operation_type); } -RTRLIB_EXPORT void pfx_table_init(struct pfx_table *pfx_table, pfx_update_fp update_fp) +RTRLIB_EXPORT void rtr_pfx_table_init(struct rtr_pfx_table *pfx_table, rtr_pfx_update_fp update_fp) { pfx_table->ipv4 = NULL; pfx_table->ipv6 = NULL; @@ -72,13 +75,13 @@ RTRLIB_EXPORT void pfx_table_init(struct pfx_table *pfx_table, pfx_update_fp upd pthread_rwlock_init(&(pfx_table->lock), NULL); } -void pfx_table_free_without_notify(struct pfx_table *pfx_table) +void pfx_table_free_without_notify(struct rtr_pfx_table *pfx_table) { pfx_table->update_fp = NULL; - pfx_table_free(pfx_table); + rtr_pfx_table_free(pfx_table); } -RTRLIB_EXPORT void pfx_table_free(struct pfx_table *pfx_table) +RTRLIB_EXPORT void rtr_pfx_table_free(struct rtr_pfx_table *pfx_table) { if (pfx_table == NULL) { PFX_DBG1("PFX table is not initialized. Nothing to free."); @@ -96,15 +99,15 @@ RTRLIB_EXPORT void pfx_table_free(struct pfx_table *pfx_table) struct node_data *data = (struct node_data *)(root->data); for (unsigned int j = 0; j < data->len; j++) { - struct pfx_record record = {data->ary[j].asn, (root->prefix), root->len, - data->ary[j].max_len, data->ary[j].socket}; - pfx_table_notify_clients(pfx_table, &record, false); + struct rtr_pfx_record record = {data->ary[j].asn, (root->prefix), root->len, + data->ary[j].max_len, data->ary[j].socket}; + pfx_table_notify_clients(pfx_table, &record, RTR_PFX_REMOVE); } rm_node = (trie_remove(root, &(root->prefix), root->len, 0)); assert(rm_node); - lrtr_free(((struct node_data *)rm_node->data)->ary); - lrtr_free(rm_node->data); - lrtr_free(rm_node); + rtr_free(((struct node_data *)rm_node->data)->ary); + rtr_free(rm_node->data); + rtr_free(rm_node); } while (rm_node != root); if (i == 0) pfx_table->ipv4 = NULL; @@ -117,27 +120,27 @@ RTRLIB_EXPORT void pfx_table_free(struct pfx_table *pfx_table) pthread_rwlock_destroy(&(pfx_table->lock)); } -int pfx_table_append_elem(struct node_data *data, const struct pfx_record *record) +int pfx_table_append_elem(struct node_data *data, const struct rtr_pfx_record *record) { - struct data_elem *tmp = lrtr_realloc(data->ary, sizeof(struct data_elem) * ((data->len) + 1)); + struct data_elem *tmp = rtr_realloc(data->ary, sizeof(struct data_elem) * ((data->len) + 1)); if (!tmp) - return PFX_ERROR; + return RTR_PFX_ERROR; data->len++; data->ary = tmp; data->ary[data->len - 1].asn = record->asn; data->ary[data->len - 1].max_len = record->max_len; data->ary[data->len - 1].socket = record->socket; - return PFX_SUCCESS; + return RTR_PFX_SUCCESS; } -int pfx_table_create_node(struct trie_node **node, const struct pfx_record *record) +int pfx_table_create_node(struct trie_node **node, const struct rtr_pfx_record *record) { int err; - *node = lrtr_malloc(sizeof(struct trie_node)); + *node = rtr_malloc(sizeof(struct trie_node)); if (!*node) - return PFX_ERROR; + return RTR_PFX_ERROR; (*node)->prefix = record->prefix; (*node)->len = record->min_len; @@ -145,9 +148,9 @@ int pfx_table_create_node(struct trie_node **node, const struct pfx_record *reco (*node)->rchild = NULL; (*node)->parent = NULL; - (*node)->data = lrtr_malloc(sizeof(struct node_data)); + (*node)->data = rtr_malloc(sizeof(struct node_data)); if (!(*node)->data) { - err = PFX_ERROR; + err = RTR_PFX_ERROR; goto free_node; } @@ -158,17 +161,17 @@ int pfx_table_create_node(struct trie_node **node, const struct pfx_record *reco if (err) goto free_node_data; - return PFX_SUCCESS; + return RTR_PFX_SUCCESS; free_node_data: - lrtr_free((*node)->data); + rtr_free((*node)->data); free_node: - lrtr_free(*node); + rtr_free(*node); return err; } -struct data_elem *pfx_table_find_elem(const struct node_data *data, const struct pfx_record *record, +struct data_elem *pfx_table_find_elem(const struct node_data *data, const struct rtr_pfx_record *record, unsigned int *index) { for (unsigned int i = 0; i < data->len; i++) { @@ -182,10 +185,10 @@ struct data_elem *pfx_table_find_elem(const struct node_data *data, const struct return NULL; } -// returns pfx_table->ipv4 if record version is LRTR_IPV4 else pfx_table->ipv6 -inline struct trie_node *pfx_table_get_root(const struct pfx_table *pfx_table, const enum lrtr_ip_version ver) +// returns pfx_table->ipv4 if record version is RTR_IPV4 else pfx_table->ipv6 +inline struct trie_node *pfx_table_get_root(const struct rtr_pfx_table *pfx_table, const enum rtr_ip_version ver) { - return ver == LRTR_IPV4 ? pfx_table->ipv4 : pfx_table->ipv6; + return ver == RTR_IPV4 ? pfx_table->ipv4 : pfx_table->ipv6; } int pfx_table_del_elem(struct node_data *data, const unsigned int index) @@ -201,31 +204,32 @@ int pfx_table_del_elem(struct node_data *data, const unsigned int index) data->len--; if (!data->len) { - lrtr_free(data->ary); + rtr_free(data->ary); data->ary = NULL; - return PFX_SUCCESS; + return RTR_PFX_SUCCESS; } - tmp = lrtr_realloc(data->ary, sizeof(struct data_elem) * data->len); + tmp = rtr_realloc(data->ary, sizeof(struct data_elem) * data->len); if (!tmp) { data->ary[data->len] = deleted_elem; data->len++; - return PFX_ERROR; + return RTR_PFX_ERROR; } data->ary = tmp; - return PFX_SUCCESS; + return RTR_PFX_SUCCESS; } -RTRLIB_EXPORT int pfx_table_add(struct pfx_table *pfx_table, const struct pfx_record *record) +RTRLIB_EXPORT enum rtr_pfx_rtvals rtr_pfx_table_add(struct rtr_pfx_table *pfx_table, + const struct rtr_pfx_record *record) { if (pfx_table == NULL) { - return PFX_NOT_INITIALIZED; + return RTR_PFX_NOT_INITIALIZED; } if (record == NULL) { - return PFX_ERROR; + return RTR_PFX_ERROR; } pthread_rwlock_wrlock(&(pfx_table->lock)); @@ -240,48 +244,49 @@ RTRLIB_EXPORT int pfx_table_add(struct pfx_table *pfx_table, const struct pfx_re if (found) { // node with prefix exists if (pfx_table_find_elem(node->data, record, NULL)) { pthread_rwlock_unlock(&pfx_table->lock); - return PFX_DUPLICATE_RECORD; + return RTR_PFX_DUPLICATE_RECORD; } // append record to note_data array int rtval = pfx_table_append_elem(node->data, record); pthread_rwlock_unlock(&pfx_table->lock); - if (rtval == PFX_SUCCESS) - pfx_table_notify_clients(pfx_table, record, true); + if (rtval == RTR_PFX_SUCCESS) + pfx_table_notify_clients(pfx_table, record, RTR_PFX_ADD); return rtval; } // no node with same prefix and prefix_len found struct trie_node *new_node = NULL; - if (pfx_table_create_node(&new_node, record) == PFX_ERROR) { + if (pfx_table_create_node(&new_node, record) == RTR_PFX_ERROR) { pthread_rwlock_unlock(&pfx_table->lock); - return PFX_ERROR; + return RTR_PFX_ERROR; } trie_insert(node, new_node, lvl); pthread_rwlock_unlock(&pfx_table->lock); - pfx_table_notify_clients(pfx_table, record, true); - return PFX_SUCCESS; + pfx_table_notify_clients(pfx_table, record, RTR_PFX_ADD); + return RTR_PFX_SUCCESS; } // tree is empty, record will be the root_node struct trie_node *new_node = NULL; - if (pfx_table_create_node(&new_node, record) == PFX_ERROR) { + if (pfx_table_create_node(&new_node, record) == RTR_PFX_ERROR) { pthread_rwlock_unlock(&pfx_table->lock); - return PFX_ERROR; + return RTR_PFX_ERROR; } - if (record->prefix.ver == LRTR_IPV4) + if (record->prefix.ver == RTR_IPV4) pfx_table->ipv4 = new_node; else pfx_table->ipv6 = new_node; pthread_rwlock_unlock(&pfx_table->lock); - pfx_table_notify_clients(pfx_table, record, true); - return PFX_SUCCESS; + pfx_table_notify_clients(pfx_table, record, RTR_PFX_ADD); + return RTR_PFX_SUCCESS; } -RTRLIB_EXPORT int pfx_table_remove(struct pfx_table *pfx_table, const struct pfx_record *record) +RTRLIB_EXPORT enum rtr_pfx_rtvals rtr_pfx_table_remove(struct rtr_pfx_table *pfx_table, + const struct rtr_pfx_record *record) { pthread_rwlock_wrlock(&(pfx_table->lock)); struct trie_node *root = pfx_table_get_root(pfx_table, record->prefix.ver); @@ -292,7 +297,7 @@ RTRLIB_EXPORT int pfx_table_remove(struct pfx_table *pfx_table, const struct pfx if (!found) { pthread_rwlock_unlock(&pfx_table->lock); - return PFX_RECORD_NOT_FOUND; + return RTR_PFX_RECORD_NOT_FOUND; } unsigned int index; @@ -300,14 +305,14 @@ RTRLIB_EXPORT int pfx_table_remove(struct pfx_table *pfx_table, const struct pfx if (!elem) { pthread_rwlock_unlock(&pfx_table->lock); - return PFX_RECORD_NOT_FOUND; + return RTR_PFX_RECORD_NOT_FOUND; } struct node_data *ndata = (struct node_data *)node->data; - if (pfx_table_del_elem(ndata, index) == PFX_ERROR) { + if (pfx_table_del_elem(ndata, index) == RTR_PFX_ERROR) { pthread_rwlock_unlock(&pfx_table->lock); - return PFX_ERROR; + return RTR_PFX_ERROR; } if (ndata->len == 0) { @@ -315,20 +320,20 @@ RTRLIB_EXPORT int pfx_table_remove(struct pfx_table *pfx_table, const struct pfx assert(node); if (node == root) { - if (record->prefix.ver == LRTR_IPV4) + if (record->prefix.ver == RTR_IPV4) pfx_table->ipv4 = NULL; else pfx_table->ipv6 = NULL; } assert(((struct node_data *)node->data)->len == 0); - lrtr_free(node->data); - lrtr_free(node); + rtr_free(node->data); + rtr_free(node); } pthread_rwlock_unlock(&pfx_table->lock); - pfx_table_notify_clients(pfx_table, record, false); + pfx_table_notify_clients(pfx_table, record, RTR_PFX_REMOVE); - return PFX_SUCCESS; + return RTR_PFX_SUCCESS; } bool pfx_table_elem_matches(struct node_data *data, const uint32_t asn, const uint8_t prefix_len) @@ -340,12 +345,12 @@ bool pfx_table_elem_matches(struct node_data *data, const uint32_t asn, const ui return false; } -int pfx_table_node2pfx_record(struct trie_node *node, struct pfx_record *records, const unsigned int ary_len) +int pfx_table_node2pfx_record(struct trie_node *node, struct rtr_pfx_record *records, const unsigned int ary_len) { struct node_data *data = node->data; if (ary_len < data->len) - return PFX_ERROR; + return RTR_PFX_ERROR; for (unsigned int i = 0; i < data->len; i++) { records[i].asn = data->ary[i].asn; @@ -357,19 +362,20 @@ int pfx_table_node2pfx_record(struct trie_node *node, struct pfx_record *records return data->len; } -inline void pfx_table_free_reason(struct pfx_record **reason, unsigned int *reason_len) +inline void pfx_table_free_reason(struct rtr_pfx_record **reason, unsigned int *reason_len) { if (reason) { - lrtr_free(*reason); + rtr_free(*reason); *reason = NULL; } if (reason_len) *reason_len = 0; } -RTRLIB_EXPORT int pfx_table_validate_r(struct pfx_table *pfx_table, struct pfx_record **reason, - unsigned int *reason_len, const uint32_t asn, const struct lrtr_ip_addr *prefix, - const uint8_t prefix_len, enum pfxv_state *result) +RTRLIB_EXPORT enum rtr_pfx_rtvals rtr_pfx_table_validate_r(struct rtr_pfx_table *pfx_table, + struct rtr_pfx_record **reason, unsigned int *reason_len, + const uint32_t asn, const struct rtr_ip_addr *prefix, + const uint8_t prefix_len, enum rtr_pfxv_state *result) { // assert(reason_len == NULL || *reason_len == 0); // assert(reason == NULL || *reason == NULL); @@ -381,9 +387,9 @@ RTRLIB_EXPORT int pfx_table_validate_r(struct pfx_table *pfx_table, struct pfx_r if (!root) { pthread_rwlock_unlock(&pfx_table->lock); - *result = BGP_PFXV_STATE_NOT_FOUND; + *result = RTR_BGP_PFXV_STATE_NOT_FOUND; pfx_table_free_reason(reason, reason_len); - return PFX_SUCCESS; + return RTR_PFX_SUCCESS; } unsigned int lvl = 0; @@ -391,28 +397,28 @@ RTRLIB_EXPORT int pfx_table_validate_r(struct pfx_table *pfx_table, struct pfx_r if (!node) { pthread_rwlock_unlock(&pfx_table->lock); - *result = BGP_PFXV_STATE_NOT_FOUND; + *result = RTR_BGP_PFXV_STATE_NOT_FOUND; pfx_table_free_reason(reason, reason_len); - return PFX_SUCCESS; + return RTR_PFX_SUCCESS; } if (reason_len && reason) { *reason_len = ((struct node_data *)node->data)->len; - *reason = lrtr_realloc(*reason, *reason_len * sizeof(struct pfx_record)); + *reason = rtr_realloc(*reason, *reason_len * sizeof(struct rtr_pfx_record)); if (!*reason) { pthread_rwlock_unlock(&pfx_table->lock); pfx_table_free_reason(reason, reason_len); - return PFX_ERROR; + return RTR_PFX_ERROR; } - if (pfx_table_node2pfx_record(node, *reason, *reason_len) == PFX_ERROR) { + if (pfx_table_node2pfx_record(node, *reason, *reason_len) == RTR_PFX_ERROR) { pthread_rwlock_unlock(&pfx_table->lock); pfx_table_free_reason(reason, reason_len); - return PFX_ERROR; + return RTR_PFX_ERROR; } } while (!pfx_table_elem_matches(node->data, asn, prefix_len)) { - if (lrtr_ip_addr_is_zero(lrtr_ip_addr_get_bits( + if (rtr_ip_addr_is_zero(rtr_ip_addr_get_bits( prefix, lvl++, 1))) //post-incr lvl, trie_lookup is performed on child_nodes => parent lvl + 1 node = trie_lookup(node->lchild, prefix, prefix_len, &lvl); @@ -421,46 +427,48 @@ RTRLIB_EXPORT int pfx_table_validate_r(struct pfx_table *pfx_table, struct pfx_r if (!node) { pthread_rwlock_unlock(&pfx_table->lock); - *result = BGP_PFXV_STATE_INVALID; - return PFX_SUCCESS; + *result = RTR_BGP_PFXV_STATE_INVALID; + return RTR_PFX_SUCCESS; } if (reason_len && reason) { unsigned int r_len_old = *reason_len; *reason_len += ((struct node_data *)node->data)->len; - *reason = lrtr_realloc(*reason, *reason_len * sizeof(struct pfx_record)); - struct pfx_record *start = *reason + r_len_old; + *reason = rtr_realloc(*reason, *reason_len * sizeof(struct rtr_pfx_record)); + struct rtr_pfx_record *start = *reason + r_len_old; if (!*reason) { pthread_rwlock_unlock(&pfx_table->lock); pfx_table_free_reason(reason, reason_len); - return PFX_ERROR; + return RTR_PFX_ERROR; } if (pfx_table_node2pfx_record(node, start, ((struct node_data *)node->data)->len) == - PFX_ERROR) { + RTR_PFX_ERROR) { pthread_rwlock_unlock(&pfx_table->lock); pfx_table_free_reason(reason, reason_len); - return PFX_ERROR; + return RTR_PFX_ERROR; } } } pthread_rwlock_unlock(&pfx_table->lock); - *result = BGP_PFXV_STATE_VALID; - return PFX_SUCCESS; + *result = RTR_BGP_PFXV_STATE_VALID; + return RTR_PFX_SUCCESS; } -RTRLIB_EXPORT int pfx_table_validate(struct pfx_table *pfx_table, const uint32_t asn, const struct lrtr_ip_addr *prefix, - const uint8_t prefix_len, enum pfxv_state *result) +RTRLIB_EXPORT enum rtr_pfx_rtvals rtr_pfx_table_validate(struct rtr_pfx_table *pfx_table, const uint32_t asn, + const struct rtr_ip_addr *prefix, const uint8_t prefix_len, + enum rtr_pfxv_state *result) { - return pfx_table_validate_r(pfx_table, NULL, NULL, asn, prefix, prefix_len, result); + return rtr_pfx_table_validate_r(pfx_table, NULL, NULL, asn, prefix, prefix_len, result); } -RTRLIB_EXPORT int pfx_table_src_remove(struct pfx_table *pfx_table, const struct rtr_socket *socket) +RTRLIB_EXPORT enum rtr_pfx_rtvals rtr_pfx_table_src_remove(struct rtr_pfx_table *pfx_table, + const struct rtr_socket *socket) { if (pfx_table == NULL) { PFX_DBG1("PFX table is not initialized. Nothing to remove."); - return PFX_SUCCESS; + return RTR_PFX_SUCCESS; } for (unsigned int i = 0; i < 2; i++) { @@ -470,17 +478,17 @@ RTRLIB_EXPORT int pfx_table_src_remove(struct pfx_table *pfx_table, const struct if (*root) { int rtval = pfx_table_remove_id(pfx_table, root, *root, socket, 0); - if (rtval == PFX_ERROR) { + if (rtval == RTR_PFX_ERROR) { pthread_rwlock_unlock(&pfx_table->lock); - return PFX_ERROR; + return RTR_PFX_ERROR; } } pthread_rwlock_unlock(&pfx_table->lock); } - return PFX_SUCCESS; + return RTR_PFX_SUCCESS; } -int pfx_table_remove_id(struct pfx_table *pfx_table, struct trie_node **root, struct trie_node *node, +int pfx_table_remove_id(struct rtr_pfx_table *pfx_table, struct trie_node **root, struct trie_node *node, const struct rtr_socket *socket, const unsigned int level) { assert(node); @@ -495,11 +503,11 @@ int pfx_table_remove_id(struct pfx_table *pfx_table, struct trie_node **root, st for (unsigned int i = 0; i < data->len; i++) { while (data->len > i && data->ary[i].socket == socket) { - struct pfx_record record = {data->ary[i].asn, node->prefix, node->len, - data->ary[i].max_len, data->ary[i].socket}; - if (pfx_table_del_elem(data, i) == PFX_ERROR) - return PFX_ERROR; - pfx_table_notify_clients(pfx_table, &record, false); + struct rtr_pfx_record record = {data->ary[i].asn, node->prefix, node->len, + data->ary[i].max_len, data->ary[i].socket}; + if (pfx_table_del_elem(data, i) == RTR_PFX_ERROR) + return RTR_PFX_ERROR; + pfx_table_notify_clients(pfx_table, &record, RTR_PFX_REMOVE); } } if (data->len == 0) { @@ -507,14 +515,14 @@ int pfx_table_remove_id(struct pfx_table *pfx_table, struct trie_node **root, st assert(rm_node); assert(((struct node_data *)rm_node->data)->len == 0); - lrtr_free(((struct node_data *)rm_node->data)); - lrtr_free(rm_node); + rtr_free(((struct node_data *)rm_node->data)); + rtr_free(rm_node); if (rm_node == *root) { *root = NULL; - return PFX_SUCCESS; + return RTR_PFX_SUCCESS; } else if (rm_node == node) { - return PFX_SUCCESS; + return RTR_PFX_SUCCESS; } } else { check_node = false; @@ -522,17 +530,17 @@ int pfx_table_remove_id(struct pfx_table *pfx_table, struct trie_node **root, st } if (node->lchild) { - if (pfx_table_remove_id(pfx_table, root, node->lchild, socket, level + 1) == PFX_ERROR) - return PFX_ERROR; + if (pfx_table_remove_id(pfx_table, root, node->lchild, socket, level + 1) == RTR_PFX_ERROR) + return RTR_PFX_ERROR; } if (node->rchild) return pfx_table_remove_id(pfx_table, root, node->rchild, socket, level + 1); - return PFX_SUCCESS; + return RTR_PFX_SUCCESS; } -static void pfx_table_for_each_rec(struct trie_node *n, pfx_for_each_fp fp, void *data) +static void pfx_table_for_each_rec(struct trie_node *n, rtr_pfx_for_each_fp fp, void *data) { - struct pfx_record pfxr; + struct rtr_pfx_record pfxr; struct node_data *nd; assert(n); @@ -557,57 +565,65 @@ static void pfx_table_for_each_rec(struct trie_node *n, pfx_for_each_fp fp, void pfx_table_for_each_rec(n->rchild, fp, data); } -RTRLIB_EXPORT void pfx_table_for_each_ipv4_record(struct pfx_table *pfx_table, pfx_for_each_fp fp, void *data) +RTRLIB_EXPORT enum rtr_pfx_rtvals rtr_pfx_table_for_each_ipv4_record(struct rtr_pfx_table *pfx_table, + rtr_pfx_for_each_fp fp, void *data) { - assert(pfx_table); + if (pfx_table == NULL) { + return RTR_PFX_NOT_INITIALIZED; + } - if (!pfx_table->ipv4) - return; + if (pfx_table->ipv4) { + pthread_rwlock_rdlock(&(pfx_table->lock)); + pfx_table_for_each_rec(pfx_table->ipv4, fp, data); + pthread_rwlock_unlock(&pfx_table->lock); + } - pthread_rwlock_rdlock(&(pfx_table->lock)); - pfx_table_for_each_rec(pfx_table->ipv4, fp, data); - pthread_rwlock_unlock(&pfx_table->lock); + return RTR_PFX_SUCCESS; } -RTRLIB_EXPORT void pfx_table_for_each_ipv6_record(struct pfx_table *pfx_table, pfx_for_each_fp fp, void *data) +RTRLIB_EXPORT enum rtr_pfx_rtvals rtr_pfx_table_for_each_ipv6_record(struct rtr_pfx_table *pfx_table, + rtr_pfx_for_each_fp fp, void *data) { - assert(pfx_table); + if (pfx_table == NULL) { + return RTR_PFX_NOT_INITIALIZED; + } - if (!pfx_table->ipv6) - return; + if (pfx_table->ipv6) { + pthread_rwlock_rdlock(&(pfx_table->lock)); + pfx_table_for_each_rec(pfx_table->ipv6, fp, data); + pthread_rwlock_unlock(&pfx_table->lock); + } - pthread_rwlock_rdlock(&(pfx_table->lock)); - pfx_table_for_each_rec(pfx_table->ipv6, fp, data); - pthread_rwlock_unlock(&pfx_table->lock); + return RTR_PFX_SUCCESS; } -static void pfx_table_copy_cb(const struct pfx_record *record, void *data) +static void pfx_table_copy_cb(const struct rtr_pfx_record *record, void *data) { struct copy_cb_args *args = data; if (record->socket != args->socket) { - if (pfx_table_add(args->pfx_table, record) != PFX_SUCCESS) + if (rtr_pfx_table_add(args->pfx_table, record) != RTR_PFX_SUCCESS) args->error = true; } } -int pfx_table_copy_except_socket(struct pfx_table *src_table, struct pfx_table *dst_table, +int pfx_table_copy_except_socket(struct rtr_pfx_table *src_table, struct rtr_pfx_table *dst_table, const struct rtr_socket *socket) { struct copy_cb_args args = {dst_table, socket, false}; - pfx_table_for_each_ipv4_record(src_table, pfx_table_copy_cb, &args); + rtr_pfx_table_for_each_ipv4_record(src_table, pfx_table_copy_cb, &args); if (args.error) - return PFX_ERROR; + return RTR_PFX_ERROR; - pfx_table_for_each_ipv6_record(src_table, pfx_table_copy_cb, &args); + rtr_pfx_table_for_each_ipv6_record(src_table, pfx_table_copy_cb, &args); if (args.error) - return PFX_ERROR; + return RTR_PFX_ERROR; - return PFX_SUCCESS; + return RTR_PFX_SUCCESS; } -void pfx_table_swap(struct pfx_table *a, struct pfx_table *b) +void pfx_table_swap(struct rtr_pfx_table *a, struct rtr_pfx_table *b) { struct trie_node *ipv4_tmp; struct trie_node *ipv6_tmp; @@ -628,22 +644,23 @@ void pfx_table_swap(struct pfx_table *a, struct pfx_table *b) pthread_rwlock_unlock(&(a->lock)); } -static void pfx_table_notify_diff_cb(const struct pfx_record *record, void *data) +static void pfx_table_notify_diff_cb(const struct rtr_pfx_record *record, void *data) { struct notify_diff_cb_args *args = data; - if (args->socket == record->socket && args->added) { - if (pfx_table_remove(args->old_table, record) != PFX_SUCCESS) - pfx_table_notify_clients(args->new_table, record, args->added); - } else if (args->socket == record->socket && !args->added) { - pfx_table_notify_clients(args->new_table, record, args->added); + if (args->socket == record->socket && args->operation_type == RTR_PFX_ADD) { + if (rtr_pfx_table_remove(args->old_table, record) != RTR_PFX_SUCCESS) + pfx_table_notify_clients(args->new_table, record, args->operation_type); + } else if (args->socket == record->socket && args->operation_type == RTR_PFX_REMOVE) { + pfx_table_notify_clients(args->new_table, record, args->operation_type); } } -void pfx_table_notify_diff(struct pfx_table *new_table, struct pfx_table *old_table, const struct rtr_socket *socket) +void pfx_table_notify_diff(struct rtr_pfx_table *new_table, struct rtr_pfx_table *old_table, + const struct rtr_socket *socket) { - pfx_update_fp old_table_fp; - struct notify_diff_cb_args args = {old_table, new_table, socket, new_table->update_fp, true}; + rtr_pfx_update_fp old_table_fp; + struct notify_diff_cb_args args = {old_table, new_table, socket, new_table->update_fp, RTR_PFX_ADD}; // Disable update callback for old_table table old_table_fp = old_table->update_fp; @@ -651,14 +668,14 @@ void pfx_table_notify_diff(struct pfx_table *new_table, struct pfx_table *old_ta // Iterate new_table and try to delete every prefix from the given socket in old_table // If the prefix could not be removed it was added in new_table and the update cb must be called - pfx_table_for_each_ipv4_record(new_table, pfx_table_notify_diff_cb, &args); - pfx_table_for_each_ipv6_record(new_table, pfx_table_notify_diff_cb, &args); + rtr_pfx_table_for_each_ipv4_record(new_table, pfx_table_notify_diff_cb, &args); + rtr_pfx_table_for_each_ipv6_record(new_table, pfx_table_notify_diff_cb, &args); // Iterate over old_table table and search and remove remaining prefixes from the socket // issue a remove notification for every one of them, because they are not present in new_table. - args.added = false; - pfx_table_for_each_ipv4_record(old_table, pfx_table_notify_diff_cb, &args); - pfx_table_for_each_ipv6_record(old_table, pfx_table_notify_diff_cb, &args); + args.operation_type = RTR_PFX_REMOVE; + rtr_pfx_table_for_each_ipv4_record(old_table, pfx_table_notify_diff_cb, &args); + rtr_pfx_table_for_each_ipv6_record(old_table, pfx_table_notify_diff_cb, &args); // Restore original state of old_tables update_fp old_table->update_fp = old_table_fp; diff --git a/rtrlib/pfx/trie/trie-pfx.h b/rtrlib/pfx/trie/trie-pfx.h index 7a8f69af..8c1797cf 100644 --- a/rtrlib/pfx/trie/trie-pfx.h +++ b/rtrlib/pfx/trie/trie-pfx.h @@ -29,7 +29,18 @@ #include #include -struct pfx_table; +struct rtr_pfx_table; + +/** + * @brief An enum describing the type of operation that has been performed in the PFX table. + */ +enum __attribute__((__packed__)) rtr_pfx_operation_type { + /** An existing record has been removed. */ + RTR_PFX_REMOVE = 0, + + /** A new record has been added. */ + RTR_PFX_ADD = 1 +}; /** * @brief pfx_record. @@ -39,9 +50,9 @@ struct pfx_table; * @param max_len Maximum prefix length. * @param socket The rtr_socket that received this record. */ -struct pfx_record { +struct rtr_pfx_record { uint32_t asn; - struct lrtr_ip_addr prefix; + struct rtr_ip_addr prefix; uint8_t min_len; uint8_t max_len; const struct rtr_socket *socket; @@ -51,9 +62,10 @@ struct pfx_record { * @brief A function pointer that is called if an record was added to the pfx_table or was removed from the pfx_table. * @param pfx_table which was updated. * @param record pfx_record that was modified. - * @param added True if the record was added, false if the record was removed. + * @param operation_type The type of operation performed on the given record. */ -typedef void (*pfx_update_fp)(struct pfx_table *pfx_table, const struct pfx_record record, const bool added); +typedef void (*rtr_pfx_update_fp)(struct rtr_pfx_table *pfx_table, const struct rtr_pfx_record record, + const enum rtr_pfx_operation_type operation_type); /** * @brief pfx_table. @@ -62,10 +74,10 @@ typedef void (*pfx_update_fp)(struct pfx_table *pfx_table, const struct pfx_reco * @param update_fp * @param lock */ -struct pfx_table { +struct rtr_pfx_table { struct trie_node *ipv4; struct trie_node *ipv6; - pfx_update_fp update_fp; + rtr_pfx_update_fp update_fp; pthread_rwlock_t lock; }; diff --git a/rtrlib/pfx/trie/trie.c b/rtrlib/pfx/trie/trie.c index 90242c77..f8f26275 100644 --- a/rtrlib/pfx/trie/trie.c +++ b/rtrlib/pfx/trie/trie.c @@ -46,12 +46,12 @@ static void add_child_node(struct trie_node *parent, struct trie_node *child, en child->parent = parent; } -static inline bool is_left_child(const struct lrtr_ip_addr *addr, unsigned int lvl) +static inline bool is_left_child(const struct rtr_ip_addr *addr, unsigned int lvl) { /* A node must be inserted as left child if bit of the IP address * is 0 otherwise as right child */ - return lrtr_ip_addr_is_zero(lrtr_ip_addr_get_bits(addr, lvl, 1)); + return rtr_ip_addr_is_zero(rtr_ip_addr_get_bits(addr, lvl, 1)); } void trie_insert(struct trie_node *root, struct trie_node *new, const unsigned int lvl) @@ -72,12 +72,12 @@ void trie_insert(struct trie_node *root, struct trie_node *new, const unsigned i trie_insert(root->rchild, new, lvl + 1); } -struct trie_node *trie_lookup(const struct trie_node *root, const struct lrtr_ip_addr *prefix, const uint8_t mask_len, +struct trie_node *trie_lookup(const struct trie_node *root, const struct rtr_ip_addr *prefix, const uint8_t mask_len, unsigned int *lvl) { while (root) { - if (root->len <= mask_len && lrtr_ip_addr_equal(lrtr_ip_addr_get_bits(&root->prefix, 0, root->len), - lrtr_ip_addr_get_bits(prefix, 0, root->len))) + if (root->len <= mask_len && rtr_ip_addr_equal(rtr_ip_addr_get_bits(&root->prefix, 0, root->len), + rtr_ip_addr_get_bits(prefix, 0, root->len))) return (struct trie_node *)root; if (is_left_child(prefix, *lvl)) @@ -90,7 +90,7 @@ struct trie_node *trie_lookup(const struct trie_node *root, const struct lrtr_ip return NULL; } -struct trie_node *trie_lookup_exact(struct trie_node *root_node, const struct lrtr_ip_addr *prefix, +struct trie_node *trie_lookup_exact(struct trie_node *root_node, const struct rtr_ip_addr *prefix, const uint8_t mask_len, unsigned int *lvl, bool *found) { *found = false; @@ -101,7 +101,7 @@ struct trie_node *trie_lookup_exact(struct trie_node *root_node, const struct lr return root_node->parent; } - if (root_node->len == mask_len && lrtr_ip_addr_equal(root_node->prefix, *prefix)) { + if (root_node->len == mask_len && rtr_ip_addr_equal(root_node->prefix, *prefix)) { *found = true; return root_node; } @@ -134,9 +134,9 @@ static void deref_node(struct trie_node *n) n->parent->rchild = NULL; } -static inline bool prefix_is_same(const struct trie_node *n, const struct lrtr_ip_addr *p, uint8_t mask_len) +static inline bool prefix_is_same(const struct trie_node *n, const struct rtr_ip_addr *p, uint8_t mask_len) { - return n->len == mask_len && lrtr_ip_addr_equal(n->prefix, *p); + return n->len == mask_len && rtr_ip_addr_equal(n->prefix, *p); } static void replace_node_data(struct trie_node *a, struct trie_node *b) @@ -146,7 +146,7 @@ static void replace_node_data(struct trie_node *a, struct trie_node *b) a->data = b->data; } -struct trie_node *trie_remove(struct trie_node *root, const struct lrtr_ip_addr *prefix, const uint8_t mask_len, +struct trie_node *trie_remove(struct trie_node *root, const struct rtr_ip_addr *prefix, const uint8_t mask_len, const unsigned int lvl) { /* If the node has no children we can simply remove it @@ -193,7 +193,7 @@ static int append_node_to_array(struct trie_node ***ary, unsigned int *len, stru { struct trie_node **new; - new = lrtr_realloc(*ary, *len * sizeof(*n)); + new = rtr_realloc(*ary, *len * sizeof(*n)); if (!new) return -1; @@ -225,7 +225,7 @@ int trie_get_children(const struct trie_node *root_node, struct trie_node ***arr return 0; err: - lrtr_free(*array); + rtr_free(*array); return -1; } diff --git a/rtrlib/pfx/trie/trie_private.h b/rtrlib/pfx/trie/trie_private.h index 9c28be25..8e83e8e5 100644 --- a/rtrlib/pfx/trie/trie_private.h +++ b/rtrlib/pfx/trie/trie_private.h @@ -15,7 +15,7 @@ #include -#define PFX_DBG1(a) lrtr_dbg("PFX: " a) +#define PFX_DBG1(a) rtr_dbg("PFX: " a) /** * @brief trie_node @@ -27,7 +27,7 @@ * @param len number of elements in data array */ struct trie_node { - struct lrtr_ip_addr prefix; + struct rtr_ip_addr prefix; struct trie_node *rchild; struct trie_node *lchild; struct trie_node *parent; @@ -48,7 +48,7 @@ void trie_insert(struct trie_node *root, struct trie_node *new_node, const unsig * prefix and prefix length. If multiple matching nodes exist, the one * with the shortest prefix is returned. * @param[in] root_node Node were the lookup process starts. - * @param[in] lrtr_ip_addr IP-Prefix. + * @param[in] rtr_ip_addr IP-Prefix. * @param[in] mask_len Length of the network mask of the prefix. * @param[in,out] level of the the node root in the tree. Is set to the level of * the node that is returned. @@ -57,13 +57,13 @@ void trie_insert(struct trie_node *root, struct trie_node *new_node, const unsig * @returns NULL if no node that matches the passed prefix and prefix length * could be found. */ -struct trie_node *trie_lookup(const struct trie_node *root_node, const struct lrtr_ip_addr *prefix, +struct trie_node *trie_lookup(const struct trie_node *root_node, const struct rtr_ip_addr *prefix, const uint8_t mask_len, unsigned int *level); /** * @brief Search for a node with the same prefix and prefix length. * @param[in] root_node Node were the lookup process starts. - * @param[in] lrtr_ip_addr IP-Prefix. + * @param[in] rtr_ip_addr IP-Prefix. * @param[in] mask_len Length of the network mask of the prefix. * @param[in,out] level of the the node root in the tree. Is set to the level of * the node that is returned. @@ -74,7 +74,7 @@ struct trie_node *trie_lookup(const struct trie_node *root_node, const struct lr * stopped (found==false). * @return NULL if root_node is NULL. */ -struct trie_node *trie_lookup_exact(struct trie_node *root_node, const struct lrtr_ip_addr *prefix, +struct trie_node *trie_lookup_exact(struct trie_node *root_node, const struct rtr_ip_addr *prefix, const uint8_t mask_len, unsigned int *level, bool *found); /** @@ -86,7 +86,7 @@ struct trie_node *trie_lookup_exact(struct trie_node *root_node, const struct lr * @returns Node that was removed from the tree. The caller has to free it. * @returns NULL If the Prefix couldn't be found in the tree. */ -struct trie_node *trie_remove(struct trie_node *root_node, const struct lrtr_ip_addr *prefix, const uint8_t mask_len, +struct trie_node *trie_remove(struct trie_node *root_node, const struct rtr_ip_addr *prefix, const uint8_t mask_len, const unsigned int level); /** diff --git a/rtrlib/rtr/packets.c b/rtrlib/rtr/packets.c index 940b8696..4ccc6063 100644 --- a/rtrlib/rtr/packets.c +++ b/rtrlib/rtr/packets.c @@ -31,7 +31,7 @@ #include #include -#define MGR_DBG1(a) lrtr_dbg("RTR_MGR: " a) +#define MGR_DBG1(a) rtr_dbg("RTR_MGR: " a) #define TEMPORARY_PDU_STORE_INCREMENT_VALUE 100 #define MAX_SUPPORTED_PDU_TYPE 10 @@ -82,7 +82,7 @@ static inline enum pdu_type rtr_get_pdu_type(const void *pdu) static int rtr_set_last_update(struct rtr_socket *rtr_socket) { - if (lrtr_get_monotonic_time(&(rtr_socket->last_update)) == -1) { + if (rtr_get_monotonic_time(&(rtr_socket->last_update)) == -1) { RTR_DBG1("get_monotonic_time(..) failed "); rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL); return RTR_ERROR; @@ -189,9 +189,9 @@ static void rtr_pdu_convert_header_byte_order(void *pdu, const enum target_byte_ // The ROUTER_KEY and ASPA PDUs have two 1 Byte fields instead of the 2 Byte reserved field. if (header->type != ROUTER_KEY && header->type != ASPA) - header->reserved = lrtr_convert_short(target_byte_order, header->reserved); + header->reserved = rtr_convert_short(target_byte_order, header->reserved); - header->len = lrtr_convert_long(target_byte_order, header->len); + header->len = rtr_convert_long(target_byte_order, header->len); } static void rtr_pdu_convert_footer_byte_order(void *pdu, const enum target_byte_order target_byte_order) @@ -204,72 +204,72 @@ static void rtr_pdu_convert_footer_byte_order(void *pdu, const enum target_byte_ switch (type) { case SERIAL_QUERY: ((struct pdu_serial_query *)pdu)->sn = - lrtr_convert_long(target_byte_order, ((struct pdu_serial_query *)pdu)->sn); + rtr_convert_long(target_byte_order, ((struct pdu_serial_query *)pdu)->sn); break; case ERROR: err_pdu = (struct pdu_error *)pdu; if (target_byte_order == TO_NETWORK_BYTE_ORDER) { - *((uint32_t *)(err_pdu->rest + err_pdu->len_enc_pdu)) = lrtr_convert_long( + *((uint32_t *)(err_pdu->rest + err_pdu->len_enc_pdu)) = rtr_convert_long( target_byte_order, *((uint32_t *)(err_pdu->rest + err_pdu->len_enc_pdu))); - err_pdu->len_enc_pdu = lrtr_convert_long(target_byte_order, err_pdu->len_enc_pdu); + err_pdu->len_enc_pdu = rtr_convert_long(target_byte_order, err_pdu->len_enc_pdu); } else { - err_pdu->len_enc_pdu = lrtr_convert_long(target_byte_order, err_pdu->len_enc_pdu); - *((uint32_t *)(err_pdu->rest + err_pdu->len_enc_pdu)) = lrtr_convert_long( + err_pdu->len_enc_pdu = rtr_convert_long(target_byte_order, err_pdu->len_enc_pdu); + *((uint32_t *)(err_pdu->rest + err_pdu->len_enc_pdu)) = rtr_convert_long( target_byte_order, *((uint32_t *)(err_pdu->rest + err_pdu->len_enc_pdu))); } break; case SERIAL_NOTIFY: ((struct pdu_serial_notify *)pdu)->sn = - lrtr_convert_long(target_byte_order, ((struct pdu_serial_notify *)pdu)->sn); + rtr_convert_long(target_byte_order, ((struct pdu_serial_notify *)pdu)->sn); break; case EOD: if (header->ver == RTR_PROTOCOL_VERSION_1 || header->ver == RTR_PROTOCOL_VERSION_2) { - ((struct pdu_end_of_data_v1_v2 *)pdu)->expire_interval = lrtr_convert_long( + ((struct pdu_end_of_data_v1_v2 *)pdu)->expire_interval = rtr_convert_long( target_byte_order, ((struct pdu_end_of_data_v1_v2 *)pdu)->expire_interval); - ((struct pdu_end_of_data_v1_v2 *)pdu)->refresh_interval = lrtr_convert_long( + ((struct pdu_end_of_data_v1_v2 *)pdu)->refresh_interval = rtr_convert_long( target_byte_order, ((struct pdu_end_of_data_v1_v2 *)pdu)->refresh_interval); - ((struct pdu_end_of_data_v1_v2 *)pdu)->retry_interval = lrtr_convert_long( + ((struct pdu_end_of_data_v1_v2 *)pdu)->retry_interval = rtr_convert_long( target_byte_order, ((struct pdu_end_of_data_v1_v2 *)pdu)->retry_interval); ((struct pdu_end_of_data_v1_v2 *)pdu)->sn = - lrtr_convert_long(target_byte_order, ((struct pdu_end_of_data_v1_v2 *)pdu)->sn); + rtr_convert_long(target_byte_order, ((struct pdu_end_of_data_v1_v2 *)pdu)->sn); } else { ((struct pdu_end_of_data_v0 *)pdu)->sn = - lrtr_convert_long(target_byte_order, ((struct pdu_end_of_data_v0 *)pdu)->sn); + rtr_convert_long(target_byte_order, ((struct pdu_end_of_data_v0 *)pdu)->sn); } break; case IPV4_PREFIX: - lrtr_ipv4_addr_convert_byte_order(((struct pdu_ipv4 *)pdu)->prefix, &((struct pdu_ipv4 *)pdu)->prefix, + rtr_ipv4_addr_convert_byte_order(((struct pdu_ipv4 *)pdu)->prefix, &((struct pdu_ipv4 *)pdu)->prefix, target_byte_order); - ((struct pdu_ipv4 *)pdu)->asn = lrtr_convert_long(target_byte_order, ((struct pdu_ipv4 *)pdu)->asn); + ((struct pdu_ipv4 *)pdu)->asn = rtr_convert_long(target_byte_order, ((struct pdu_ipv4 *)pdu)->asn); break; case IPV6_PREFIX: - lrtr_ipv6_addr_convert_byte_order(((struct pdu_ipv6 *)pdu)->prefix, addr6, target_byte_order); + rtr_ipv6_addr_convert_byte_order(((struct pdu_ipv6 *)pdu)->prefix, addr6, target_byte_order); memcpy(((struct pdu_ipv6 *)pdu)->prefix, addr6, sizeof(addr6)); - ((struct pdu_ipv6 *)pdu)->asn = lrtr_convert_long(target_byte_order, ((struct pdu_ipv6 *)pdu)->asn); + ((struct pdu_ipv6 *)pdu)->asn = rtr_convert_long(target_byte_order, ((struct pdu_ipv6 *)pdu)->asn); break; case ROUTER_KEY: ((struct pdu_router_key *)pdu)->asn = - lrtr_convert_long(target_byte_order, ((struct pdu_router_key *)pdu)->asn); + rtr_convert_long(target_byte_order, ((struct pdu_router_key *)pdu)->asn); break; case ASPA: ((struct pdu_aspa *)pdu)->customer_asn = - lrtr_convert_long(target_byte_order, ((struct pdu_aspa *)pdu)->customer_asn); + rtr_convert_long(target_byte_order, ((struct pdu_aspa *)pdu)->customer_asn); uint16_t asn_count = rtr_aspa_provider_count(pdu); for (size_t i = 0; i < asn_count; i++) { ((struct pdu_aspa *)pdu)->provider_asns[i] = - lrtr_convert_long(target_byte_order, ((struct pdu_aspa *)pdu)->provider_asns[i]); + rtr_convert_long(target_byte_order, ((struct pdu_aspa *)pdu)->provider_asns[i]); } break; @@ -433,7 +433,7 @@ static int rtr_send_pdu(const struct rtr_socket *rtr_socket, const void *pdu, co if (rtval > 0) return RTR_SUCCESS; - if (rtval == TR_WOULDBLOCK) { + if (rtval == RTR_TR_WOULDBLOCK) { RTR_DBG1("send would block"); return RTR_ERROR; } @@ -562,12 +562,12 @@ static int rtr_receive_pdu(struct rtr_socket *rtr_socket, void *pdu, const size_ if (error == -1) { rtr_change_socket_state(rtr_socket, RTR_ERROR_TRANSPORT); return RTR_ERROR; - } else if (error == TR_WOULDBLOCK) { + } else if (error == RTR_TR_WOULDBLOCK) { RTR_DBG1("receive timeout expired"); - return TR_WOULDBLOCK; - } else if (error == TR_INTR) { + return RTR_TR_WOULDBLOCK; + } else if (error == RTR_TR_INTR) { RTR_DBG1("receive call interrupted"); - return TR_INTR; + return RTR_TR_INTR; } else if (error == CORRUPT_DATA) { RTR_DBG1("corrupt PDU received"); const char txt[] = "corrupt data received, length value in PDU is too small"; @@ -684,7 +684,7 @@ static int rtr_handle_cache_response_pdu(struct rtr_socket *rtr_socket, char *pd } static void rtr_key_pdu_2_spki_record(const struct rtr_socket *rtr_socket, const struct pdu_router_key *pdu, - struct spki_record *entry, const enum pdu_type type) + struct rtr_spki_record *entry, const enum pdu_type type) { assert(type == ROUTER_KEY); entry->asn = pdu->asn; @@ -693,7 +693,7 @@ static void rtr_key_pdu_2_spki_record(const struct rtr_socket *rtr_socket, const entry->socket = rtr_socket; } -static void rtr_prefix_pdu_2_pfx_record(const struct rtr_socket *rtr_socket, const void *pdu, struct pfx_record *pfxr, +static void rtr_prefix_pdu_2_pfx_record(const struct rtr_socket *rtr_socket, const void *pdu, struct rtr_pfx_record *pfxr, const enum pdu_type type) { assert(type == IPV4_PREFIX || type == IPV6_PREFIX); @@ -702,7 +702,7 @@ static void rtr_prefix_pdu_2_pfx_record(const struct rtr_socket *rtr_socket, con pfxr->prefix.u.addr4.addr = ipv4->prefix; pfxr->asn = ipv4->asn; - pfxr->prefix.ver = LRTR_IPV4; + pfxr->prefix.ver = RTR_IPV4; pfxr->min_len = ipv4->prefix_len; pfxr->max_len = ipv4->max_prefix_len; pfxr->socket = rtr_socket; @@ -710,7 +710,7 @@ static void rtr_prefix_pdu_2_pfx_record(const struct rtr_socket *rtr_socket, con const struct pdu_ipv6 *ipv6 = pdu; pfxr->asn = ipv6->asn; - pfxr->prefix.ver = LRTR_IPV6; + pfxr->prefix.ver = RTR_IPV6; memcpy(pfxr->prefix.u.addr6.addr, ipv6->prefix, sizeof(pfxr->prefix.u.addr6.addr)); pfxr->min_len = ipv6->prefix_len; pfxr->max_len = ipv6->max_prefix_len; @@ -721,33 +721,33 @@ static void rtr_prefix_pdu_2_pfx_record(const struct rtr_socket *rtr_socket, con __attribute__((always_inline)) static inline void rtr_aspa_pdu_2_aspa_operation(struct pdu_aspa *pdu, struct aspa_update_operation *op) { - op->type = (pdu->flags & 1) == 1 ? ASPA_ADD : ASPA_REMOVE; + op->type = (pdu->flags & 1) == 1 ? RTR_ASPA_ADD : RTR_ASPA_REMOVE; op->is_no_op = false; op->record.customer_asn = pdu->customer_asn; - op->record.provider_count = (op->type == ASPA_ADD) ? rtr_aspa_provider_count(pdu) : 0; - op->record.provider_asns = (op->type == ASPA_ADD) ? pdu->provider_asns : NULL; + op->record.provider_count = (op->type == RTR_ASPA_ADD) ? rtr_aspa_provider_count(pdu) : 0; + op->record.provider_asns = (op->type == RTR_ASPA_ADD) ? pdu->provider_asns : NULL; } /** * @brief Removes all prefixes from the @p pfx_table with flag field == ADD, adds all prefixes * to the @p pfx_table with if flag field == REMOVE. */ -static int rtr_undo_update_pfx_table(struct rtr_socket *rtr_socket, struct pfx_table *pfx_table, void *pdu) +static int rtr_undo_update_pfx_table(struct rtr_socket *rtr_socket, struct rtr_pfx_table *pfx_table, void *pdu) { const enum pdu_type type = rtr_get_pdu_type(pdu); assert(type == IPV4_PREFIX || type == IPV6_PREFIX); - struct pfx_record pfxr; + struct rtr_pfx_record pfxr; rtr_prefix_pdu_2_pfx_record(rtr_socket, pdu, &pfxr, type); int rtval = RTR_ERROR; // invert add/remove operation if (((struct pdu_ipv4 *)pdu)->flags == 1) - rtval = pfx_table_remove(pfx_table, &pfxr); + rtval = rtr_pfx_table_remove(pfx_table, &pfxr); else if (((struct pdu_ipv4 *)pdu)->flags == 0) - rtval = pfx_table_add(pfx_table, &pfxr); + rtval = rtr_pfx_table_add(pfx_table, &pfxr); return rtval; } @@ -755,18 +755,18 @@ static int rtr_undo_update_pfx_table(struct rtr_socket *rtr_socket, struct pfx_t * @brief Removes all prefixes from multiple PDUs from the @p pfx_table with flag field == ADD, adds all prefixes * to the @p pfx_table if flag field == REMOVE. */ -static int rtr_undo_update_pfx_table_batch(struct rtr_socket *rtr_socket, struct pfx_table *pfx_table, +static int rtr_undo_update_pfx_table_batch(struct rtr_socket *rtr_socket, struct rtr_pfx_table *pfx_table, struct pdu_ipv4 *ipv4_pdus, size_t ipv4_pdu_count, struct pdu_ipv6 *ipv6_pdus, size_t ipv6_pdu_count) { for (size_t i = 0; i < ipv4_pdu_count; i++) { int res = rtr_undo_update_pfx_table(rtr_socket, pfx_table, &(ipv4_pdus[i])); - if (res == RTR_ERROR || res == PFX_ERROR) { + if (res == RTR_ERROR || res == RTR_PFX_ERROR) { // Undo failed, cannot recover, remove all records associated with the socket instead RTR_DBG1( "Couldn't undo all update operations from failed data synchronisation: Purging all prefix records"); - pfx_table_src_remove(pfx_table, rtr_socket); + rtr_pfx_table_src_remove(pfx_table, rtr_socket); return RTR_ERROR; } } @@ -774,11 +774,11 @@ static int rtr_undo_update_pfx_table_batch(struct rtr_socket *rtr_socket, struct for (size_t i = 0; i < ipv6_pdu_count; i++) { int res = rtr_undo_update_pfx_table(rtr_socket, pfx_table, &(ipv6_pdus[i])); - if (res == RTR_ERROR || res == PFX_ERROR) { + if (res == RTR_ERROR || res == RTR_PFX_ERROR) { // Undo failed, cannot recover, remove all records associated with the socket instead RTR_DBG1( "Couldn't undo all update operations from failed data synchronisation: Purging all prefix records"); - pfx_table_src_remove(pfx_table, rtr_socket); + rtr_pfx_table_src_remove(pfx_table, rtr_socket); return RTR_ERROR; } } @@ -789,13 +789,13 @@ static int rtr_undo_update_pfx_table_batch(struct rtr_socket *rtr_socket, struct * @brief Removes router key from the @p spki_table with flag field == ADD, adds router keys * to the @p spki_table if flag field == REMOVE. */ -static int rtr_undo_update_spki_table(struct rtr_socket *rtr_socket, struct spki_table *spki_table, void *pdu) +static int rtr_undo_update_spki_table(struct rtr_socket *rtr_socket, struct rtr_spki_table *spki_table, void *pdu) { const enum pdu_type type = rtr_get_pdu_type(pdu); assert(type == ROUTER_KEY); - struct spki_record entry; + struct rtr_spki_record entry; rtr_key_pdu_2_spki_record(rtr_socket, pdu, &entry, type); @@ -812,13 +812,13 @@ static int rtr_undo_update_spki_table(struct rtr_socket *rtr_socket, struct spki * @brief Removes router key from multiple PDUs from the @p spki_table with flag field == ADD, adds router keys * to the @p spki_table if flag field == REMOVE. */ -static int rtr_undo_update_spki_table_batch(struct rtr_socket *rtr_socket, struct spki_table *spki_table, +static int rtr_undo_update_spki_table_batch(struct rtr_socket *rtr_socket, struct rtr_spki_table *spki_table, struct pdu_router_key *pdus, size_t pdu_count) { for (size_t i = 0; i < pdu_count; i++) { int res = rtr_undo_update_spki_table(rtr_socket, spki_table, &(pdus[i])); - if (res == RTR_ERROR || res == SPKI_ERROR) { + if (res == RTR_ERROR || res == RTR_SPKI_ERROR) { // Undo failed, cannot recover, remove all records associated with the socket instead RTR_DBG1( "Couldn't undo all update operations from failed data synchronisation: Purging all SPKI records"); @@ -844,7 +844,7 @@ static int rtr_store_prefix_pdu(struct rtr_socket *rtr_socket, const void *pdu, assert(type == IPV4_PREFIX || type == IPV6_PREFIX); if (*ind >= *size) { *size += TEMPORARY_PDU_STORE_INCREMENT_VALUE; - void *tmp = lrtr_realloc(*ary, *size * pdu_size); + void *tmp = rtr_realloc(*ary, *size * pdu_size); if (!tmp) { const char txt[] = "Realloc failed"; @@ -883,7 +883,7 @@ static int rtr_store_router_key_pdu(struct rtr_socket *rtr_socket, const void *p if (*ind >= *size) { *size += TEMPORARY_PDU_STORE_INCREMENT_VALUE; - void *tmp = lrtr_realloc(*ary, *size * pdu_size); + void *tmp = rtr_realloc(*ary, *size * pdu_size); if (!tmp) { const char txt[] = "Realloc failed"; @@ -913,7 +913,7 @@ static int rtr_store_aspa_pdu(struct rtr_socket *rtr_socket, const struct pdu_as { if (*count >= *capacity) { *capacity += TEMPORARY_PDU_STORE_INCREMENT_VALUE; - void *tmp = lrtr_realloc(*array, *capacity * sizeof(struct pdu_aspa *)); + void *tmp = rtr_realloc(*array, *capacity * sizeof(struct pdu_aspa *)); if (!tmp) { const char txt[] = "Realloc failed"; @@ -926,7 +926,7 @@ static int rtr_store_aspa_pdu(struct rtr_socket *rtr_socket, const struct pdu_as *array = tmp; } size_t pdu_size = pdu->len; - struct pdu_aspa *copy = lrtr_malloc(pdu_size); + struct pdu_aspa *copy = rtr_malloc(pdu_size); if (!copy) { const char txt[] = "Malloc failed"; @@ -943,7 +943,7 @@ static int rtr_store_aspa_pdu(struct rtr_socket *rtr_socket, const struct pdu_as return RTR_SUCCESS; } -static int rtr_update_pfx_table(struct rtr_socket *rtr_socket, struct pfx_table *pfx_table, const void *pdu) +static int rtr_update_pfx_table(struct rtr_socket *rtr_socket, struct rtr_pfx_table *pfx_table, const void *pdu) { // the prefix table was not initialized, hence we ignore incoming ROA Objects if (pfx_table == NULL) { @@ -956,7 +956,7 @@ static int rtr_update_pfx_table(struct rtr_socket *rtr_socket, struct pfx_table assert(type == IPV4_PREFIX || type == IPV6_PREFIX); - struct pfx_record pfxr; + struct rtr_pfx_record pfxr; size_t pdu_size = (type == IPV4_PREFIX ? sizeof(struct pdu_ipv4) : sizeof(struct pdu_ipv6)); rtr_prefix_pdu_2_pfx_record(rtr_socket, pdu, &pfxr, type); @@ -964,9 +964,9 @@ static int rtr_update_pfx_table(struct rtr_socket *rtr_socket, struct pfx_table int rtval; if (((struct pdu_ipv4 *)pdu)->flags == 1) { // add record - rtval = pfx_table_add(pfx_table, &pfxr); + rtval = rtr_pfx_table_add(pfx_table, &pfxr); } else if (((struct pdu_ipv4 *)pdu)->flags == 0) { // remove record - rtval = pfx_table_remove(pfx_table, &pfxr); + rtval = rtr_pfx_table_remove(pfx_table, &pfxr); } else { const char txt[] = "Prefix PDU with invalid flags value received"; @@ -975,21 +975,21 @@ static int rtr_update_pfx_table(struct rtr_socket *rtr_socket, struct pfx_table return RTR_ERROR; } - if (rtval == PFX_DUPLICATE_RECORD) { + if (rtval == RTR_PFX_DUPLICATE_RECORD) { char ip[INET6_ADDRSTRLEN]; - lrtr_ip_addr_to_str(&(pfxr.prefix), ip, INET6_ADDRSTRLEN); + rtr_ip_addr_to_str(&(pfxr.prefix), ip, INET6_ADDRSTRLEN); RTR_DBG("Duplicate Announcement for record: %s/%u-%u, ASN: %u, received", ip, pfxr.min_len, pfxr.max_len, pfxr.asn); rtr_send_error_pdu_from_host(rtr_socket, pdu, pdu_size, DUPLICATE_ANNOUNCEMENT, NULL, 0); rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL); return RTR_ERROR; - } else if (rtval == PFX_RECORD_NOT_FOUND) { + } else if (rtval == RTR_PFX_RECORD_NOT_FOUND) { RTR_DBG1("Withdrawal of unknown record"); rtr_send_error_pdu_from_host(rtr_socket, pdu, pdu_size, WITHDRAWAL_OF_UNKNOWN_RECORD, NULL, 0); rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL); return RTR_ERROR; - } else if (rtval == PFX_ERROR) { + } else if (rtval == RTR_PFX_ERROR) { const char txt[] = "PFX_TABLE Error"; RTR_DBG("%s", txt); @@ -1001,7 +1001,7 @@ static int rtr_update_pfx_table(struct rtr_socket *rtr_socket, struct pfx_table return RTR_SUCCESS; } -static int rtr_update_spki_table(struct rtr_socket *rtr_socket, struct spki_table *spki_table, const void *pdu) +static int rtr_update_spki_table(struct rtr_socket *rtr_socket, struct rtr_spki_table *spki_table, const void *pdu) { assert(rtr_socket); assert(pdu); @@ -1017,7 +1017,7 @@ static int rtr_update_spki_table(struct rtr_socket *rtr_socket, struct spki_tabl assert(type == ROUTER_KEY); - struct spki_record entry; + struct rtr_spki_record entry; size_t pdu_size = sizeof(struct pdu_router_key); @@ -1039,18 +1039,18 @@ static int rtr_update_spki_table(struct rtr_socket *rtr_socket, struct spki_tabl return RTR_ERROR; } - if (rtval == SPKI_DUPLICATE_RECORD) { + if (rtval == RTR_SPKI_DUPLICATE_RECORD) { // TODO: This debug message isn't working yet, how to display SKI/SPKI without %x? RTR_DBG("Duplicate Announcement for router key: ASN: %u received", entry.asn); rtr_send_error_pdu_from_host(rtr_socket, pdu, pdu_size, DUPLICATE_ANNOUNCEMENT, NULL, 0); rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL); return RTR_ERROR; - } else if (rtval == SPKI_RECORD_NOT_FOUND) { + } else if (rtval == RTR_SPKI_RECORD_NOT_FOUND) { RTR_DBG1("Withdrawal of unknown router key"); rtr_send_error_pdu_from_host(rtr_socket, pdu, pdu_size, WITHDRAWAL_OF_UNKNOWN_RECORD, NULL, 0); rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL); return RTR_ERROR; - } else if (rtval == SPKI_ERROR) { + } else if (rtval == RTR_SPKI_ERROR) { const char txt[] = "spki_table Error"; RTR_DBG("%s", txt); @@ -1063,7 +1063,7 @@ static int rtr_update_spki_table(struct rtr_socket *rtr_socket, struct spki_tabl } #if ASPA_UPDATE_MECHANISM == ASPA_SWAP_IN -static int rtr_compute_update_aspa_table(struct rtr_socket *rtr_socket, struct aspa_table *aspa_table, +static int rtr_compute_update_aspa_table(struct rtr_socket *rtr_socket, struct rtr_aspa_table *aspa_table, struct pdu_aspa **aspa_pdus, size_t pdu_count, struct aspa_update **update) { // Fail hard in debug builds. @@ -1081,7 +1081,7 @@ static int rtr_compute_update_aspa_table(struct rtr_socket *rtr_socket, struct a if (pdu_count == 0) return RTR_SUCCESS; - struct aspa_update_operation *operations = lrtr_malloc(sizeof(struct aspa_update_operation) * pdu_count); + struct aspa_update_operation *operations = rtr_malloc(sizeof(struct aspa_update_operation) * pdu_count); if (!operations) { const char txt[] = "Malloc failed"; @@ -1108,24 +1108,24 @@ static int rtr_compute_update_aspa_table(struct rtr_socket *rtr_socket, struct a operations[i].index = i; } - enum aspa_status res = aspa_table_update_swap_in_compute(aspa_table, rtr_socket, operations, pdu_count, update); + enum rtr_aspa_status res = aspa_table_update_swap_in_compute(aspa_table, rtr_socket, operations, pdu_count, update); if (*update && (*update)->failed_operation) { struct pdu_aspa *pdu = aspa_pdus[(*update)->failed_operation->index]; size_t pdu_size = pdu->len; - if (res == ASPA_DUPLICATE_RECORD) { + if (res == RTR_ASPA_DUPLICATE_RECORD) { RTR_DBG("Duplicate Announcement for ASPA customer ASN: %u received", pdu->customer_asn); rtr_send_error_pdu_from_host(rtr_socket, pdu, pdu_size, DUPLICATE_ANNOUNCEMENT, NULL, 0); rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL); return RTR_ERROR; - } else if (res == ASPA_RECORD_NOT_FOUND) { + } else if (res == RTR_ASPA_RECORD_NOT_FOUND) { RTR_DBG("Withdrawal of unknown ASPA customer ASN: %u", pdu->customer_asn); rtr_send_error_pdu_from_host(rtr_socket, pdu, pdu_size, WITHDRAWAL_OF_UNKNOWN_RECORD, NULL, 0); rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL); return RTR_ERROR; } - } else if (res != ASPA_SUCCESS) { + } else if (res != RTR_ASPA_SUCCESS) { const char txt[] = "aspa_table Error"; RTR_DBG("%s", txt); @@ -1150,7 +1150,7 @@ static int rtr_undo_update_aspa_table(struct rtr_socket *rtr_socket, struct aspa enum aspa_status res = aspa_table_update_in_place_undo(aspa_table, rtr_socket, operations, count, failed_operation); - if (res == ASPA_SUCCESS) { + if (res == RTR_ASPA_SUCCESS) { return RTR_SUCCESS; } // Undo failed, cannot recover, remove all records associated with the socket instead @@ -1181,7 +1181,7 @@ static int rtr_update_aspa_table(struct rtr_socket *rtr_socket, struct aspa_tabl if (!aspa_pdus && pdu_count == 0) return RTR_SUCCESS; - struct aspa_update_operation *operations = lrtr_malloc(sizeof(struct aspa_update_operation) * pdu_count); + struct aspa_update_operation *operations = rtr_malloc(sizeof(struct aspa_update_operation) * pdu_count); if (!operations) { const char txt[] = "Malloc failed"; @@ -1217,7 +1217,7 @@ static int rtr_update_aspa_table(struct rtr_socket *rtr_socket, struct aspa_tabl rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL); return RTR_ERROR; } - } else if (res != ASPA_SUCCESS) { + } else if (res != RTR_ASPA_SUCCESS) { const char txt[] = "aspa_table Error"; RTR_DBG("%s", txt); @@ -1230,8 +1230,8 @@ static int rtr_update_aspa_table(struct rtr_socket *rtr_socket, struct aspa_tabl } #endif -static int rtr_sync_update_tables(struct rtr_socket *rtr_socket, struct pfx_table *pfx_table, - struct spki_table *spki_table, struct aspa_table *aspa_table, +static int rtr_sync_update_tables(struct rtr_socket *rtr_socket, struct rtr_pfx_table *pfx_table, + struct rtr_spki_table *spki_table, struct rtr_aspa_table *aspa_table, struct pdu_ipv4 *ipv4_pdus, const unsigned int ipv4_pdu_count, struct pdu_ipv6 *ipv6_pdus, const unsigned int ipv6_pdu_count, struct pdu_router_key *router_key_pdus, const unsigned int router_key_pdu_count, @@ -1442,27 +1442,27 @@ void recv_loop_cleanup(void *p) return; if (*args->ipv4_pdus) { - lrtr_free(*args->ipv4_pdus); + rtr_free(*args->ipv4_pdus); *args->ipv4_pdus = NULL; } if (*args->ipv6_pdus) { - lrtr_free(*args->ipv6_pdus); + rtr_free(*args->ipv6_pdus); *args->ipv6_pdus = NULL; } if (*args->router_key_pdus) { - lrtr_free(*args->router_key_pdus); + rtr_free(*args->router_key_pdus); *args->router_key_pdus = NULL; } if (*args->aspa_pdus) { for (size_t i = 0; i < *args->aspa_pdu_count; i++) { if ((*args->aspa_pdus)[i]) - lrtr_free((*args->aspa_pdus)[i]); + rtr_free((*args->aspa_pdus)[i]); } - lrtr_free(*args->aspa_pdus); + rtr_free(*args->aspa_pdus); *args->aspa_pdus = NULL; *args->aspa_pdu_count = 0; } @@ -1498,7 +1498,7 @@ static int rtr_sync_receive_and_store_pdus(struct rtr_socket *rtr_socket) .aspa_pdus = &aspa_pdus, .aspa_pdu_count = &aspa_pdus_count}; - // receive LRTR_IPV4/IPV6/ASPA PDUs till EOD + // receive RTR_IPV4/IPV6/ASPA PDUs till EOD do { pthread_cleanup_push(recv_loop_cleanup, &cleanup_args); pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldcancelstate); @@ -1509,7 +1509,7 @@ static int rtr_sync_receive_and_store_pdus(struct rtr_socket *rtr_socket) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldcancelstate); pthread_cleanup_pop(0); - if (retval == TR_WOULDBLOCK) { + if (retval == RTR_TR_WOULDBLOCK) { rtr_change_socket_state(rtr_socket, RTR_ERROR_TRANSPORT); retval = RTR_ERROR; break; @@ -1578,23 +1578,23 @@ static int rtr_sync_receive_and_store_pdus(struct rtr_socket *rtr_socket) // Use table copies instead in order to perform an atomic update RTR_DBG1("Reset in progress creating shadow table for atomic reset"); - struct pfx_table *pfx_shadow_table = lrtr_malloc(sizeof(struct pfx_table)); + struct rtr_pfx_table *pfx_shadow_table = rtr_malloc(sizeof(struct rtr_pfx_table)); if (!pfx_shadow_table) { RTR_DBG1("Memory allocation for pfx shadow table failed"); retval = RTR_ERROR; goto cleanup; } - pfx_table_init(pfx_shadow_table, NULL); + rtr_pfx_table_init(pfx_shadow_table, NULL); if (pfx_table_copy_except_socket(rtr_socket->pfx_table, pfx_shadow_table, rtr_socket) != - PFX_SUCCESS) { + RTR_PFX_SUCCESS) { RTR_DBG1("Creation of pfx shadow table failed"); rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL); retval = RTR_ERROR; goto cleanup; } - struct spki_table *spki_shadow_table = lrtr_malloc(sizeof(struct spki_table)); + struct rtr_spki_table *spki_shadow_table = rtr_malloc(sizeof(struct rtr_spki_table)); if (!spki_shadow_table) { RTR_DBG1("Memory allocation for spki shadow table failed"); @@ -1603,21 +1603,21 @@ static int rtr_sync_receive_and_store_pdus(struct rtr_socket *rtr_socket) } spki_table_init(spki_shadow_table, NULL); if (spki_table_copy_except_socket(rtr_socket->spki_table, spki_shadow_table, - rtr_socket) != SPKI_SUCCESS) { + rtr_socket) != RTR_SPKI_SUCCESS) { RTR_DBG1("Creation of spki shadow table failed"); rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL); retval = RTR_ERROR; goto cleanup; } - struct aspa_table *aspa_shadow_table = lrtr_malloc(sizeof(struct aspa_table)); + struct rtr_aspa_table *aspa_shadow_table = rtr_malloc(sizeof(struct rtr_aspa_table)); if (!aspa_shadow_table) { RTR_DBG1("Memory allocation for aspa shadow table failed"); retval = RTR_ERROR; goto cleanup; } - aspa_table_init(aspa_shadow_table, NULL); + rtr_aspa_table_init(aspa_shadow_table, NULL); RTR_DBG1("Shadow tables created"); @@ -1658,17 +1658,17 @@ static int rtr_sync_receive_and_store_pdus(struct rtr_socket *rtr_socket) RTR_DBG1("Freeing shadow tables."); if (pfx_shadow_table) { pfx_table_free_without_notify(pfx_shadow_table); - lrtr_free(pfx_shadow_table); + rtr_free(pfx_shadow_table); } if (spki_shadow_table) { spki_table_free_without_notify(spki_shadow_table); - lrtr_free(spki_shadow_table); + rtr_free(spki_shadow_table); } if (aspa_shadow_table) { - aspa_table_free(aspa_shadow_table, false); - lrtr_free(aspa_shadow_table); + rtr_aspa_table_free(aspa_shadow_table, false); + rtr_free(aspa_shadow_table); } rtr_socket->is_resetting = false; @@ -1713,7 +1713,7 @@ int rtr_sync(struct rtr_socket *rtr_socket) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldcancelstate); // If the cache has closed the connection and we don't have a // session_id (no packages where exchanged) we should downgrade. - if (rtval == TR_CLOSED && rtr_socket->request_session_id) { + if (rtval == RTR_TR_CLOSED && rtr_socket->request_session_id) { RTR_DBG1("The cache server closed the connection and we have no session_id!"); if (rtr_socket->version > RTR_PROTOCOL_MIN_SUPPORTED_VERSION) { RTR_DBG("Downgrading from %i to version %i", rtr_socket->version, @@ -1724,7 +1724,7 @@ int rtr_sync(struct rtr_socket *rtr_socket) } } - if (rtval == TR_WOULDBLOCK) { + if (rtval == RTR_TR_WOULDBLOCK) { rtr_change_socket_state(rtr_socket, RTR_ERROR_TRANSPORT); return RTR_ERROR; } else if (rtval < 0) { @@ -1775,7 +1775,7 @@ int rtr_wait_for_sync(struct rtr_socket *rtr_socket) time_t cur_time; - lrtr_get_monotonic_time(&cur_time); + rtr_get_monotonic_time(&cur_time); time_t wait = (rtr_socket->last_update + rtr_socket->refresh_interval) - cur_time; if (wait < 0) @@ -1791,7 +1791,7 @@ int rtr_wait_for_sync(struct rtr_socket *rtr_socket) RTR_DBG("Serial Notify received (%u)", ((struct pdu_serial_notify *)pdu)->sn); return RTR_SUCCESS; } - } else if (rtval == TR_WOULDBLOCK) { + } else if (rtval == RTR_TR_WOULDBLOCK) { RTR_DBG1("Refresh interval expired"); return RTR_SUCCESS; } diff --git a/rtrlib/rtr/rtr.c b/rtrlib/rtr/rtr.c index 97cfcedb..70d2ec1a 100644 --- a/rtrlib/rtr/rtr.c +++ b/rtrlib/rtr/rtr.c @@ -56,8 +56,8 @@ static const char *socket_str_states[] = {[RTR_CONNECTING] = "RTR_CONNECTING", [RTR_ERROR_TRANSPORT] = "RTR_ERROR_TRANSPORT", [RTR_SHUTDOWN] = "RTR_SHUTDOWN"}; -int rtr_init(struct rtr_socket *rtr_socket, struct tr_socket *tr, struct pfx_table *pfx_table, - struct spki_table *spki_table, struct aspa_table *aspa_table, const unsigned int refresh_interval, +int rtr_init(struct rtr_socket *rtr_socket, struct rtr_tr_socket *tr, struct rtr_pfx_table *pfx_table, + struct rtr_spki_table *spki_table, struct rtr_aspa_table *aspa_table, const unsigned int refresh_interval, const unsigned int expire_interval, const unsigned int retry_interval, enum rtr_interval_mode iv_mode, rtr_connection_state_fp fp, void *fp_param_config, void *fp_param_group) { @@ -100,7 +100,7 @@ int rtr_start(struct rtr_socket *rtr_socket, const rtr_mgr_on_processing_thread_ if (rtr_socket->thread_id) return RTR_ERROR; - struct rtr_fsm_start_args *args = lrtr_malloc(sizeof(*args)); + struct rtr_fsm_start_args *args = rtr_malloc(sizeof(*args)); if (args == NULL) { RTR_DBG1("Not enough memory available to allocate FSM start arguments"); return RTR_ERROR; @@ -122,16 +122,16 @@ void rtr_purge_outdated_records(struct rtr_socket *rtr_socket) if (rtr_socket->last_update == 0) return; time_t cur_time; - int rtval = lrtr_get_monotonic_time(&cur_time); + int rtval = rtr_get_monotonic_time(&cur_time); if (rtval == -1 || (rtr_socket->last_update + rtr_socket->expire_interval) < cur_time) { if (rtval == -1) RTR_DBG1("get_monotic_time(..) failed"); - pfx_table_src_remove(rtr_socket->pfx_table, rtr_socket); + rtr_pfx_table_src_remove(rtr_socket->pfx_table, rtr_socket); RTR_DBG1("Removed outdated records from pfx_table"); spki_table_src_remove(rtr_socket->spki_table, rtr_socket); RTR_DBG1("Removed outdated router keys from spki_table"); - aspa_table_src_remove(rtr_socket->aspa_table, rtr_socket, true); + rtr_aspa_table_src_remove(rtr_socket->aspa_table, rtr_socket, true); RTR_DBG1("Removed outdated records from aspa_table"); rtr_socket->request_session_id = true; rtr_socket->serial_number = 0; @@ -150,7 +150,7 @@ void rtr_purge_outdated_records(struct rtr_socket *rtr_socket) inline static void rtr_free_fsm_start_args(struct rtr_fsm_start_args **args) { assert(args != NULL); - lrtr_free(*args); + rtr_free(*args); *args = NULL; } @@ -196,7 +196,7 @@ void *rtr_fsm_start(struct rtr_fsm_start_args *args) // old aspa_Record could exists in the aspa_table, check if they are too old and must be removed rtr_purge_outdated_records(rtr_socket); - if (tr_open(rtr_socket->tr_socket) == TR_ERROR) { + if (tr_open(rtr_socket->tr_socket) == RTR_TR_ERROR) { rtr_change_socket_state(rtr_socket, RTR_ERROR_TRANSPORT); } else if (rtr_socket->request_session_id) { // change to state RESET, if socket doesn't have a session_id @@ -316,9 +316,9 @@ void rtr_stop(struct rtr_socket *rtr_socket) rtr_socket->request_session_id = true; rtr_socket->serial_number = 0; rtr_socket->last_update = 0; - pfx_table_src_remove(rtr_socket->pfx_table, rtr_socket); + rtr_pfx_table_src_remove(rtr_socket->pfx_table, rtr_socket); spki_table_src_remove(rtr_socket->spki_table, rtr_socket); - aspa_table_src_remove(rtr_socket->aspa_table, rtr_socket, true); + rtr_aspa_table_src_remove(rtr_socket->aspa_table, rtr_socket, true); rtr_socket->thread_id = 0; rtr_socket->state = RTR_CLOSED; } diff --git a/rtrlib/rtr/rtr.h b/rtrlib/rtr/rtr.h index 64ec0763..79dc6388 100644 --- a/rtrlib/rtr/rtr.h +++ b/rtrlib/rtr/rtr.h @@ -134,7 +134,7 @@ typedef enum rtr_rtvals (*rtr_mgr_on_processing_thread_event)(enum rtr_mgr_proce * @param aspa_table spki_table that stores the ASPA records obtained from the connected rtr server */ struct rtr_socket { - struct tr_socket *tr_socket; + struct rtr_tr_socket *tr_socket; unsigned int refresh_interval; time_t last_update; unsigned int expire_interval; @@ -144,15 +144,15 @@ struct rtr_socket { uint32_t session_id; bool request_session_id; uint32_t serial_number; - struct pfx_table *pfx_table; + struct rtr_pfx_table *pfx_table; pthread_t thread_id; rtr_connection_state_fp connection_state_fp; void *connection_state_fp_param_config; void *connection_state_fp_param_group; unsigned int version; bool has_received_pdus; - struct spki_table *spki_table; - struct aspa_table *aspa_table; + struct rtr_spki_table *spki_table; + struct rtr_aspa_table *aspa_table; bool is_resetting; }; diff --git a/rtrlib/rtr/rtr_private.h b/rtrlib/rtr/rtr_private.h index f587b701..6da38d47 100644 --- a/rtrlib/rtr/rtr_private.h +++ b/rtrlib/rtr/rtr_private.h @@ -16,8 +16,8 @@ #include #include -#define RTR_DBG(fmt, ...) lrtr_dbg("RTR Socket: " fmt, ##__VA_ARGS__) -#define RTR_DBG1(a) lrtr_dbg("RTR Socket: " a) +#define RTR_DBG(fmt, ...) rtr_dbg("RTR Socket: " fmt, ##__VA_ARGS__) +#define RTR_DBG1(a) rtr_dbg("RTR Socket: " a) static const uint32_t RTR_EXPIRATION_MIN = 600; // ten minutes static const uint32_t RTR_EXPIRATION_MAX = 172800; // two days @@ -68,8 +68,8 @@ enum rtr_interval_type { RTR_INTERVAL_TYPE_EXPIRATION, RTR_INTERVAL_TYPE_REFRESH * @return RTR_INVALID_PARAM If the refresh_interval or the expire_interval is not valid. * @return RTR_SUCCESS On success. */ -int rtr_init(struct rtr_socket *rtr_socket, struct tr_socket *tr_socket, struct pfx_table *pfx_table, - struct spki_table *spki_table, struct aspa_table *aspa_table, const unsigned int refresh_interval, +int rtr_init(struct rtr_socket *rtr_socket, struct rtr_tr_socket *tr_socket, struct rtr_pfx_table *pfx_table, + struct rtr_spki_table *spki_table, struct rtr_aspa_table *aspa_table, const unsigned int refresh_interval, const unsigned int expire_interval, const unsigned int retry_interval, enum rtr_interval_mode iv_mode, rtr_connection_state_fp fp, void *fp_data_config, void *fp_data_group); diff --git a/rtrlib/rtr_mgr.c b/rtrlib/rtr_mgr.c index 934320d2..cdd1fd48 100644 --- a/rtrlib/rtr_mgr.c +++ b/rtrlib/rtr_mgr.c @@ -28,8 +28,8 @@ #include #include -#define MGR_DBG(fmt, ...) lrtr_dbg("RTR_MGR: " fmt, ##__VA_ARGS__) -#define MGR_DBG1(a) lrtr_dbg("RTR_MGR: " a) +#define MGR_DBG(fmt, ...) rtr_dbg("RTR_MGR: " fmt, ##__VA_ARGS__) +#define MGR_DBG1(a) rtr_dbg("RTR_MGR: " a) static const char *const mgr_str_status[] = { [RTR_MGR_CLOSED] = "RTR_MGR_CLOSED", @@ -54,7 +54,7 @@ static void set_status(const struct rtr_mgr_config *conf, struct rtr_mgr_group * conf->status_fp(group, mgr_status, rtr_sock, conf->status_fp_data); } -static int rtr_mgr_start_sockets(struct rtr_mgr_group *group, struct rtr_mgr_config *config) +static enum rtr_rtvals rtr_mgr_start_sockets(struct rtr_mgr_group *group, struct rtr_mgr_config *config) { for (unsigned int i = 0; i < group->sockets_len; i++) { if (rtr_start(group->sockets[i], config->processing_thread_event_callback, @@ -295,10 +295,11 @@ int rtr_mgr_config_cmp_tommy(const void *a, const void *b) } // TODO: Additional arguments trailing? -RTRLIB_EXPORT int rtr_mgr_init(struct rtr_mgr_config **config_out, struct rtr_mgr_group groups[], - const unsigned int groups_len, const rtr_mgr_status_fp status_fp, void *status_fp_data, - const rtr_mgr_on_processing_thread_event processing_thread_event_callback, - void *processing_thread_event_callback_data) +RTRLIB_EXPORT enum rtr_rtvals rtr_mgr_init(struct rtr_mgr_config **config_out, struct rtr_mgr_group groups[], + const unsigned int groups_len, const rtr_mgr_status_fp status_fp, + void *status_fp_data, + const rtr_mgr_on_processing_thread_event processing_thread_event_callback, + void *processing_thread_event_callback_data) { enum rtr_rtvals err_code = RTR_ERROR; struct rtr_mgr_config *config = NULL; @@ -311,7 +312,7 @@ RTRLIB_EXPORT int rtr_mgr_init(struct rtr_mgr_config **config_out, struct rtr_mg return RTR_ERROR; } - *config_out = config = lrtr_malloc(sizeof(*config)); + *config_out = config = rtr_malloc(sizeof(*config)); if (!config) return RTR_ERROR; @@ -345,24 +346,25 @@ RTRLIB_EXPORT int rtr_mgr_init(struct rtr_mgr_config **config_out, struct rtr_mg return RTR_SUCCESS; err: - lrtr_free(config->groups); - lrtr_free(config); + rtr_free(config->groups); + rtr_free(config); config = NULL; *config_out = NULL; return err_code; } -RTRLIB_EXPORT int rtr_mgr_setup_sockets(struct rtr_mgr_config *config, struct rtr_mgr_group groups[], - const unsigned int groups_len, const unsigned int refresh_interval, - const unsigned int expire_interval, const unsigned int retry_interval) +RTRLIB_EXPORT enum rtr_rtvals rtr_mgr_setup_sockets(struct rtr_mgr_config *config, struct rtr_mgr_group groups[], + const unsigned int groups_len, const unsigned int refresh_interval, + const unsigned int expire_interval, + const unsigned int retry_interval) { enum rtr_interval_mode iv_mode = RTR_INTERVAL_MODE_DEFAULT_MIN_MAX; struct rtr_mgr_group_node *group_node = NULL; struct rtr_mgr_group *cg = NULL; /* Copy the groups from the array into linked list config->groups */ config->len = groups_len; - config->groups = lrtr_malloc(sizeof(*config->groups)); + config->groups = rtr_malloc(sizeof(*config->groups)); if (!config->groups) { return RTR_ERROR; } @@ -370,7 +372,7 @@ RTRLIB_EXPORT int rtr_mgr_setup_sockets(struct rtr_mgr_config *config, struct rt config->groups->list = NULL; for (unsigned int i = 0; i < groups_len; i++) { - cg = lrtr_malloc(sizeof(struct rtr_mgr_group)); + cg = rtr_malloc(sizeof(struct rtr_mgr_group)); if (!cg) { return RTR_ERROR; } @@ -379,13 +381,13 @@ RTRLIB_EXPORT int rtr_mgr_setup_sockets(struct rtr_mgr_config *config, struct rt cg->status = RTR_MGR_CLOSED; if (rtr_mgr_init_sockets(cg, config, refresh_interval, expire_interval, retry_interval, iv_mode)) { - lrtr_free(cg); + rtr_free(cg); return RTR_ERROR; } - group_node = lrtr_malloc(sizeof(struct rtr_mgr_group_node)); + group_node = rtr_malloc(sizeof(struct rtr_mgr_group_node)); if (!group_node) { - lrtr_free(cg); + rtr_free(cg); return RTR_ERROR; } @@ -400,58 +402,61 @@ RTRLIB_EXPORT int rtr_mgr_setup_sockets(struct rtr_mgr_config *config, struct rt return RTR_SUCCESS; } -RTRLIB_EXPORT int rtr_mgr_add_roa_support(struct rtr_mgr_config *config, const pfx_update_fp pfx_update_fp) +RTRLIB_EXPORT enum rtr_rtvals rtr_mgr_add_roa_support(struct rtr_mgr_config *config, + const rtr_pfx_update_fp pfx_update_fp) { if (config == NULL) { return RTR_ERROR; } /* Init prefix table that we need to pass to the sockets */ - struct pfx_table *pfxt = lrtr_malloc(sizeof(*pfxt)); + struct rtr_pfx_table *pfxt = rtr_malloc(sizeof(*pfxt)); if (!pfxt) { return RTR_ERROR; } - pfx_table_init(pfxt, pfx_update_fp); + rtr_pfx_table_init(pfxt, pfx_update_fp); config->pfx_table = pfxt; return RTR_SUCCESS; } -RTRLIB_EXPORT int rtr_mgr_add_aspa_support(struct rtr_mgr_config *config, const aspa_update_fp aspa_update_fp) +RTRLIB_EXPORT enum rtr_rtvals rtr_mgr_add_aspa_support(struct rtr_mgr_config *config, + const rtr_aspa_update_fp aspa_update_fp) { if (config == NULL) { return RTR_ERROR; } /* Init aspa table that we need to pass to the sockets */ - struct aspa_table *aspa_table = lrtr_malloc(sizeof(*aspa_table)); + struct rtr_aspa_table *aspa_table = rtr_malloc(sizeof(*aspa_table)); if (!aspa_table) { return RTR_ERROR; } - aspa_table_init(aspa_table, aspa_update_fp); + rtr_aspa_table_init(aspa_table, aspa_update_fp); config->aspa_table = aspa_table; return RTR_SUCCESS; } -RTRLIB_EXPORT int rtr_mgr_add_spki_support(struct rtr_mgr_config *config, const spki_update_fp spki_update_fp) +RTRLIB_EXPORT enum rtr_rtvals rtr_mgr_add_spki_support(struct rtr_mgr_config *config, + const rtr_spki_update_fp spki_update_fp) { if (config == NULL) { return RTR_ERROR; } /* Init spki table that we need to pass to the sockets */ - struct spki_table *spki_table = lrtr_malloc(sizeof(*spki_table)); + struct rtr_spki_table *spki_table = rtr_malloc(sizeof(*spki_table)); if (!spki_table) { - return ASPA_ERROR; + return RTR_ASPA_ERROR; } spki_table_init(spki_table, spki_update_fp); config->spki_table = spki_table; - return ASPA_SUCCESS; + return RTR_ASPA_SUCCESS; } RTRLIB_EXPORT struct rtr_mgr_group *rtr_mgr_get_first_group(struct rtr_mgr_config *config) @@ -462,7 +467,7 @@ RTRLIB_EXPORT struct rtr_mgr_group *rtr_mgr_get_first_group(struct rtr_mgr_confi return group_node->group; } -RTRLIB_EXPORT int rtr_mgr_start(struct rtr_mgr_config *config) +RTRLIB_EXPORT enum rtr_rtvals rtr_mgr_start(struct rtr_mgr_config *config) { MGR_DBG("%s()", __func__); struct rtr_mgr_group *best_group = rtr_mgr_get_first_group(config); @@ -498,11 +503,11 @@ RTRLIB_EXPORT void rtr_mgr_free(struct rtr_mgr_config *config) MGR_DBG("%s()", __func__); pthread_rwlock_wrlock(&config->mutex); - pfx_table_free(config->pfx_table); + rtr_pfx_table_free(config->pfx_table); spki_table_free(config->spki_table); - aspa_table_free(config->aspa_table, true); - lrtr_free(config->spki_table); - lrtr_free(config->pfx_table); + rtr_aspa_table_free(config->aspa_table, true); + rtr_free(config->spki_table); + rtr_free(config->pfx_table); /* Free linked list */ tommy_node *head = tommy_list_head(&config->groups->list); @@ -515,47 +520,48 @@ RTRLIB_EXPORT void rtr_mgr_free(struct rtr_mgr_config *config) for (unsigned int j = 0; j < group_node->group->sockets_len; j++) tr_free(group_node->group->sockets[j]->tr_socket); - lrtr_free(group_node->group); - lrtr_free(group_node); + rtr_free(group_node->group); + rtr_free(group_node); } - lrtr_free(config->groups); + rtr_free(config->groups); pthread_rwlock_unlock(&config->mutex); pthread_rwlock_destroy(&config->mutex); - lrtr_free(config); + rtr_free(config); } /* cppcheck-suppress unusedFunction */ -RTRLIB_EXPORT inline enum pfx_rtvals rtr_mgr_validate(struct rtr_mgr_config *config, const uint32_t asn, - const struct lrtr_ip_addr *prefix, const uint8_t mask_len, - enum pfxv_state *result) +RTRLIB_EXPORT inline enum rtr_pfx_rtvals rtr_mgr_roa_validate(struct rtr_mgr_config *config, const uint32_t asn, + const struct rtr_ip_addr *prefix, const uint8_t mask_len, + enum rtr_pfxv_state *result) { if (config->pfx_table == NULL) { MGR_DBG1("PFX table is not initialized"); - return PFX_NOT_INITIALIZED; + return RTR_PFX_NOT_INITIALIZED; } - return pfx_table_validate(config->pfx_table, asn, prefix, mask_len, result); + return rtr_pfx_table_validate(config->pfx_table, asn, prefix, mask_len, result); } /* cppcheck-suppress unusedFunction */ -RTRLIB_EXPORT inline enum aspa_status rtr_mgr_verify_as_path(struct rtr_mgr_config *config, uint32_t as_path[], - size_t len, enum aspa_direction direction, - enum aspa_verification_result *result) +RTRLIB_EXPORT inline enum rtr_aspa_status rtr_mgr_aspa_validate(struct rtr_mgr_config *config, uint32_t as_path[], + size_t len, enum rtr_aspa_direction direction, + enum rtr_aspa_verification_result *result) { if (config->aspa_table == NULL) { MGR_DBG1("ASPA table is not initialized"); - return ASPA_NOT_INITIALIZED; + return RTR_ASPA_NOT_INITIALIZED; } - *result = aspa_verify_as_path(config->aspa_table, as_path, len, direction); - return ASPA_SUCCESS; + *result = rtr_aspa_verify_as_path(config->aspa_table, as_path, len, direction); + return RTR_ASPA_SUCCESS; } /* cppcheck-suppress unusedFunction */ -RTRLIB_EXPORT inline int rtr_mgr_get_spki(struct rtr_mgr_config *config, const uint32_t asn, uint8_t *ski, - struct spki_record **result, unsigned int *result_count) +RTRLIB_EXPORT inline enum rtr_spki_rtvals rtr_mgr_bgpsec_get_spki(struct rtr_mgr_config *config, const uint32_t asn, + uint8_t *ski, struct rtr_spki_record **result, + unsigned int *result_count) { return spki_table_get_all(config->spki_table, asn, ski, result, result_count); } @@ -577,7 +583,7 @@ RTRLIB_EXPORT void rtr_mgr_stop(struct rtr_mgr_config *config) } /* cppcheck-suppress unusedFunction */ -RTRLIB_EXPORT int rtr_mgr_add_group(struct rtr_mgr_config *config, const struct rtr_mgr_group *group) +RTRLIB_EXPORT enum rtr_rtvals rtr_mgr_add_group(struct rtr_mgr_config *config, const struct rtr_mgr_group *group) { unsigned int refresh_iv = 3600; unsigned int retry_iv = 600; @@ -611,7 +617,7 @@ RTRLIB_EXPORT int rtr_mgr_add_group(struct rtr_mgr_config *config, const struct expire_iv = gnode->group->sockets[0]->expire_interval; node = node->next; } - new_group = lrtr_malloc(sizeof(struct rtr_mgr_group)); + new_group = rtr_malloc(sizeof(struct rtr_mgr_group)); if (!new_group) goto err; @@ -623,7 +629,7 @@ RTRLIB_EXPORT int rtr_mgr_add_group(struct rtr_mgr_config *config, const struct if (err_code) goto err; - new_group_node = lrtr_malloc(sizeof(struct rtr_mgr_group_node)); + new_group_node = rtr_malloc(sizeof(struct rtr_mgr_group_node)); if (!new_group_node) goto err; @@ -647,13 +653,13 @@ RTRLIB_EXPORT int rtr_mgr_add_group(struct rtr_mgr_config *config, const struct pthread_rwlock_unlock(&config->mutex); if (new_group) - lrtr_free(new_group); + rtr_free(new_group); return err_code; } /* cppcheck-suppress unusedFunction */ -RTRLIB_EXPORT int rtr_mgr_remove_group(struct rtr_mgr_config *config, unsigned int preference) +RTRLIB_EXPORT enum rtr_rtvals rtr_mgr_remove_group(struct rtr_mgr_config *config, unsigned int preference) { pthread_rwlock_wrlock(&config->mutex); tommy_node *remove_node = NULL; @@ -703,15 +709,16 @@ RTRLIB_EXPORT int rtr_mgr_remove_group(struct rtr_mgr_config *config, unsigned i if (best_group->status == RTR_MGR_CLOSED) rtr_mgr_start_sockets(best_group, config); - lrtr_free(group_node->group); - lrtr_free(group_node); + rtr_free(group_node->group); + rtr_free(group_node); return RTR_SUCCESS; } // TODO: write test for this function. /* cppcheck-suppress unusedFunction */ -RTRLIB_EXPORT int rtr_mgr_for_each_group(struct rtr_mgr_config *config, - void(fp)(const struct rtr_mgr_group *group, void *data), void *data) +RTRLIB_EXPORT enum rtr_rtvals rtr_mgr_for_each_group(struct rtr_mgr_config *config, + void(fp)(const struct rtr_mgr_group *group, void *data), + void *data) { tommy_node *node = tommy_list_head(&config->groups->list); @@ -731,17 +738,17 @@ RTRLIB_EXPORT const char *rtr_mgr_status_to_str(enum rtr_mgr_status status) } /* cppcheck-suppress unusedFunction */ -RTRLIB_EXPORT inline void rtr_mgr_for_each_ipv4_record(struct rtr_mgr_config *config, - void(fp)(const struct pfx_record *, void *data), void *data) +RTRLIB_EXPORT inline enum rtr_pfx_rtvals rtr_mgr_roa_for_each_ipv4_record(struct rtr_mgr_config *config, + rtr_pfx_for_each_fp fp, void *data) { - pfx_table_for_each_ipv4_record(config->pfx_table, fp, data); + return rtr_pfx_table_for_each_ipv4_record(config->pfx_table, fp, data); } /* cppcheck-suppress unusedFunction */ -RTRLIB_EXPORT inline void rtr_mgr_for_each_ipv6_record(struct rtr_mgr_config *config, - void(fp)(const struct pfx_record *, void *data), void *data) +RTRLIB_EXPORT inline enum rtr_pfx_rtvals rtr_mgr_roa_for_each_ipv6_record(struct rtr_mgr_config *config, + rtr_pfx_for_each_fp fp, void *data) { - pfx_table_for_each_ipv6_record(config->pfx_table, fp, data); + return rtr_pfx_table_for_each_ipv6_record(config->pfx_table, fp, data); } #ifdef RTRLIB_BGPSEC_ENABLED @@ -760,8 +767,9 @@ RTRLIB_EXPORT enum rtr_bgpsec_rtvals rtr_mgr_bgpsec_validate_as_path(const struc } /* cppcheck-suppress unusedFunction */ -RTRLIB_EXPORT int rtr_mgr_bgpsec_generate_signature(const struct rtr_bgpsec *data, uint8_t *private_key, - struct rtr_signature_seg **new_signature) +RTRLIB_EXPORT enum rtr_bgpsec_rtvals rtr_mgr_bgpsec_generate_signature(const struct rtr_bgpsec *data, + uint8_t *private_key, + struct rtr_signature_seg **new_signature) { int retval = rtr_bgpsec_generate_signature(data, private_key, new_signature); @@ -775,7 +783,7 @@ RTRLIB_EXPORT int rtr_mgr_bgpsec_get_version(void) } /* cppcheck-suppress unusedFunction */ -RTRLIB_EXPORT int rtr_mgr_bgpsec_has_algorithm_suite(uint8_t alg_suite) +RTRLIB_EXPORT enum rtr_bgpsec_rtvals rtr_mgr_bgpsec_has_algorithm_suite(uint8_t alg_suite) { return rtr_bgpsec_has_algorithm_suite(alg_suite); } @@ -813,7 +821,8 @@ RTRLIB_EXPORT struct rtr_signature_seg *rtr_mgr_bgpsec_new_signature_seg(uint8_t } /* cppcheck-suppress unusedFunction */ -RTRLIB_EXPORT int rtr_mgr_bgpsec_prepend_sig_seg(struct rtr_bgpsec *bgpsec, struct rtr_signature_seg *new_seg) +RTRLIB_EXPORT enum rtr_bgpsec_rtvals rtr_mgr_bgpsec_prepend_sig_seg(struct rtr_bgpsec *bgpsec, + struct rtr_signature_seg *new_seg) { return rtr_bgpsec_prepend_sig_seg(bgpsec, new_seg); } @@ -832,7 +841,7 @@ RTRLIB_EXPORT void rtr_mgr_bgpsec_free(struct rtr_bgpsec *bgpsec) } /* cppcheck-suppress unusedFunction */ -RTRLIB_EXPORT void rtr_mgr_free_secure_path(struct rtr_secure_path_seg *seg) +RTRLIB_EXPORT void rtr_mgr_bgpsec_free_secure_path(struct rtr_secure_path_seg *seg) { rtr_bgpsec_free_secure_path(seg); } @@ -854,7 +863,8 @@ RTRLIB_EXPORT void rtr_mgr_bgpsec_append_sec_path_seg(struct rtr_bgpsec *bgpsec, rtr_bgpsec_append_sec_path_seg(bgpsec, new_seg); } -RTRLIB_EXPORT int rtr_mgr_bgpsec_append_sig_seg(struct rtr_bgpsec *bgpsec, struct rtr_signature_seg *new_seg) +RTRLIB_EXPORT enum rtr_bgpsec_rtvals rtr_mgr_bgpsec_append_sig_seg(struct rtr_bgpsec *bgpsec, + struct rtr_signature_seg *new_seg) { return rtr_bgpsec_append_sig_seg(bgpsec, new_seg); } @@ -869,7 +879,7 @@ RTRLIB_EXPORT void rtr_mgr_bgpsec_nlri_free(struct rtr_bgpsec_nlri *nlri) rtr_bgpsec_nlri_free(nlri); } -RTRLIB_EXPORT void rtr_mgr_bgpsec_add_spki_record(struct rtr_mgr_config *config, struct spki_record *record) +RTRLIB_EXPORT void rtr_mgr_bgpsec_add_spki_record(struct rtr_mgr_config *config, struct rtr_spki_record *record) { rtr_bgpsec_add_spki_record(config->spki_table, record); } diff --git a/rtrlib/rtr_mgr.h b/rtrlib/rtr_mgr.h index b716e56f..3cbe2a0b 100644 --- a/rtrlib/rtr_mgr.h +++ b/rtrlib/rtr_mgr.h @@ -102,9 +102,9 @@ struct rtr_mgr_config { * access to it should be properly synchronized. */ void *processing_thread_event_callback_data; - struct pfx_table *pfx_table; - struct spki_table *spki_table; - struct aspa_table *aspa_table; + struct rtr_pfx_table *pfx_table; + struct rtr_spki_table *spki_table; + struct rtr_aspa_table *aspa_table; }; /** @@ -146,13 +146,14 @@ struct rtr_mgr_config { * @return RTR_INVALID_PARAM If refresh_interval or expire_interval is invalid. * @return RTR_SUCCESS On success. */ -int rtr_mgr_init(struct rtr_mgr_config **config_out, struct rtr_mgr_group groups[], const unsigned int groups_len, - const rtr_mgr_status_fp status_fp, void *status_fp_data, - const rtr_mgr_on_processing_thread_event processing_thread_event_callback, void *processing_thread_event_callback_data); +enum rtr_rtvals rtr_mgr_init(struct rtr_mgr_config **config_out, struct rtr_mgr_group groups[], + const unsigned int groups_len, const rtr_mgr_status_fp status_fp, void *status_fp_data, + const rtr_mgr_on_processing_thread_event processing_thread_event_callback, + void *processing_thread_event_callback_data); -int rtr_mgr_setup_sockets(struct rtr_mgr_config *config, struct rtr_mgr_group groups[], const unsigned int groups_len, - const unsigned int refresh_interval, const unsigned int expire_interval, - const unsigned int retry_interval); +enum rtr_rtvals rtr_mgr_setup_sockets(struct rtr_mgr_config *config, struct rtr_mgr_group groups[], + const unsigned int groups_len, const unsigned int refresh_interval, + const unsigned int expire_interval, const unsigned int retry_interval); /** * @brief Sets up ROA support @@ -163,7 +164,7 @@ int rtr_mgr_setup_sockets(struct rtr_mgr_config *config, struct rtr_mgr_group gr * @return RTR_INVALID_PARAM If refresh_interval or expire_interval is invalid. * @return RTR_SUCCESS On success. */ -int rtr_mgr_add_roa_support(struct rtr_mgr_config *config, const pfx_update_fp pfx_update_fp); +enum rtr_rtvals rtr_mgr_add_roa_support(struct rtr_mgr_config *config, const rtr_pfx_update_fp pfx_update_fp); /** * @brief Adds a new rtr_mgr_group to the linked list of a initialized config. @@ -183,7 +184,7 @@ int rtr_mgr_add_roa_support(struct rtr_mgr_config *config, const pfx_update_fp p * @return RTR_SUCCESS If the group was successfully added. * */ -int rtr_mgr_add_group(struct rtr_mgr_config *config, const struct rtr_mgr_group *group); +enum rtr_rtvals rtr_mgr_add_group(struct rtr_mgr_config *config, const struct rtr_mgr_group *group); /** * @brief Removes an existing rtr_mgr_group from the linked list of config. * @details The group to be removed is identified by its preference value. @@ -196,7 +197,7 @@ int rtr_mgr_add_group(struct rtr_mgr_config *config, const struct rtr_mgr_group * @return RTR_SUCCESS If group was successfully removed. * */ -int rtr_mgr_remove_group(struct rtr_mgr_config *config, unsigned int preference); +enum rtr_rtvals rtr_mgr_remove_group(struct rtr_mgr_config *config, unsigned int preference); /** * @brief Frees all resources that were allocated from the rtr_mgr. * @details rtr_mgr_stop must be called before, to shutdown all rtr_sockets. @@ -213,7 +214,7 @@ void rtr_mgr_free(struct rtr_mgr_config *config); * @return RTR_SUCCESS On success * @return RTR_ERROR On error */ -int rtr_mgr_start(struct rtr_mgr_config *config); +enum rtr_rtvals rtr_mgr_start(struct rtr_mgr_config *config); /** * @brief Terminates rtr_socket connections @@ -241,8 +242,9 @@ bool rtr_mgr_conf_in_sync(struct rtr_mgr_config *config); * @return PFX_SUCCESS On success. * @return Any other `pfx_rtvals` code depending on the error. */ -enum pfx_rtvals rtr_mgr_validate(struct rtr_mgr_config *config, const uint32_t asn, const struct lrtr_ip_addr *prefix, - const uint8_t mask_len, enum pfxv_state *result); +enum rtr_pfx_rtvals rtr_mgr_roa_validate(struct rtr_mgr_config *config, const uint32_t asn, + const struct rtr_ip_addr *prefix, const uint8_t mask_len, + enum rtr_pfxv_state *result); /** * @brief Validates the given AS path using the ASPA algorithm. @@ -252,12 +254,12 @@ enum pfx_rtvals rtr_mgr_validate(struct rtr_mgr_config *config, const uint32_t a * @param direction The direction to check; upstream or downstream * @param[out] result The result of the AS path validation, i.e., whether the AS path is * considered valid, invalid, or whether the validation status is unknown - * @return ASPA_SUCCESS on success + * @return RTR_ASPA_SUCCESS on success * @return Any other `aspa_status` code depending on the error. */ -enum aspa_status rtr_mgr_verify_as_path(struct rtr_mgr_config *config, uint32_t as_path[], - size_t len, enum aspa_direction direction, - enum aspa_verification_result *result); +enum rtr_aspa_status rtr_mgr_aspa_validate(struct rtr_mgr_config *config, uint32_t as_path[], size_t len, + enum rtr_aspa_direction direction, + enum rtr_aspa_verification_result *result); /** * @brief Returns all SPKI records which match the given ASN and SKI. @@ -269,8 +271,8 @@ enum aspa_status rtr_mgr_verify_as_path(struct rtr_mgr_config *config, uint32_t * @return SPKI_SUCCESS On success * @return SPKI_ERROR If an error occurred */ -int rtr_mgr_get_spki(struct rtr_mgr_config *config, const uint32_t asn, uint8_t *ski, struct spki_record **result, - unsigned int *result_count); +enum rtr_spki_rtvals rtr_mgr_bgpsec_get_spki(struct rtr_mgr_config *config, const uint32_t asn, uint8_t *ski, + struct rtr_spki_record **result, unsigned int *result_count); /** * @brief Converts a rtr_mgr_status to a String. @@ -287,8 +289,10 @@ const char *rtr_mgr_status_to_str(enum rtr_mgr_status status); * @param[in] config rtr_mgr_config * @param[in] fp Pointer to callback function with signature \c pfx_for_each_fp. * @param[in] data This parameter is forwarded to the callback function. + * @return PFX_SUCCESS on success. + * @return RTR_PFX_NOT_INITIALIZED if ROA support has not been enabled. */ -void rtr_mgr_for_each_ipv4_record(struct rtr_mgr_config *config, pfx_for_each_fp fp, void *data); +enum rtr_pfx_rtvals rtr_mgr_roa_for_each_ipv4_record(struct rtr_mgr_config *config, rtr_pfx_for_each_fp fp, void *data); /** * @brief Iterates over all IPv6 records in the pfx_table. @@ -297,8 +301,10 @@ void rtr_mgr_for_each_ipv4_record(struct rtr_mgr_config *config, pfx_for_each_fp * @param[in] config rtr_mgr_config * @param[in] fp Pointer to callback function with signature \c pfx_for_each_fp. * @param[in] data This parameter is forwarded to the callback function. + * @return PFX_SUCCESS on success. + * @return RTR_PFX_NOT_INITIALIZED if ROA support has not been enabled. */ -void rtr_mgr_for_each_ipv6_record(struct rtr_mgr_config *config, pfx_for_each_fp fp, void *data); +enum rtr_pfx_rtvals rtr_mgr_roa_for_each_ipv6_record(struct rtr_mgr_config *config, rtr_pfx_for_each_fp fp, void *data); /** * @brief Returns the first, thus active group. @@ -307,8 +313,8 @@ void rtr_mgr_for_each_ipv6_record(struct rtr_mgr_config *config, pfx_for_each_fp */ struct rtr_mgr_group *rtr_mgr_get_first_group(struct rtr_mgr_config *config); -int rtr_mgr_for_each_group(struct rtr_mgr_config *config, void (*fp)(const struct rtr_mgr_group *group, void *data), - void *data); +enum rtr_rtvals rtr_mgr_for_each_group(struct rtr_mgr_config *config, + void (*fp)(const struct rtr_mgr_group *group, void *data), void *data); /** * @brief Sets up ASPA support @@ -319,7 +325,7 @@ int rtr_mgr_for_each_group(struct rtr_mgr_config *config, void (*fp)(const struc * @return RTR_INVALID_PARAM If refresh_interval or expire_interval is invalid. * @return RTR_SUCCESS On success. */ -int rtr_mgr_add_aspa_support(struct rtr_mgr_config *config, const aspa_update_fp aspa_update_fp); +enum rtr_rtvals rtr_mgr_add_aspa_support(struct rtr_mgr_config *config, const rtr_aspa_update_fp aspa_update_fp); /** * @brief Sets up BGPSEC support @@ -330,7 +336,7 @@ int rtr_mgr_add_aspa_support(struct rtr_mgr_config *config, const aspa_update_fp * @return RTR_INVALID_PARAM If refresh_interval or expire_interval is invalid. * @return RTR_SUCCESS On success. */ -int rtr_mgr_add_spki_support(struct rtr_mgr_config *config, const spki_update_fp spki_update_fp); +enum rtr_rtvals rtr_mgr_add_spki_support(struct rtr_mgr_config *config, const rtr_spki_update_fp spki_update_fp); /* @} */ @@ -362,8 +368,8 @@ enum rtr_bgpsec_rtvals rtr_mgr_bgpsec_validate_as_path(const struct rtr_bgpsec * * @return RTR_BGPSEC_ERROR If an error occurred. Refer to error codes for * more details. */ -int rtr_mgr_bgpsec_generate_signature(const struct rtr_bgpsec *data, uint8_t *private_key, - struct rtr_signature_seg **new_signature); +enum rtr_bgpsec_rtvals rtr_mgr_bgpsec_generate_signature(const struct rtr_bgpsec *data, uint8_t *private_key, + struct rtr_signature_seg **new_signature); /** * @brief Returns the highest supported BGPsec version. @@ -377,7 +383,7 @@ int rtr_mgr_bgpsec_get_version(void); * @return RTR_BGPSEC_SUCCESS If the algorithm suite is supported. * @return RTR_BGPSEC_ERROR If the algorithm suite is not supported. */ -int rtr_mgr_bgpsec_has_algorithm_suite(uint8_t alg_suite); +enum rtr_bgpsec_rtvals rtr_mgr_bgpsec_has_algorithm_suite(uint8_t alg_suite); /** * @brief Returns pointer to a list that holds all supported algorithm suites. @@ -430,7 +436,7 @@ struct rtr_signature_seg *rtr_mgr_bgpsec_new_signature_seg(uint8_t *ski, uint16_ * @return RTR_BGPSEC_ERROR If an error occurred during prepending, e.g. one * or more fields of new_seg was missing. */ -int rtr_mgr_bgpsec_prepend_sig_seg(struct rtr_bgpsec *bgpsec, struct rtr_signature_seg *new_seg); +enum rtr_bgpsec_rtvals rtr_mgr_bgpsec_prepend_sig_seg(struct rtr_bgpsec *bgpsec, struct rtr_signature_seg *new_seg); /** * @brief Initializes and returns a pointer to a rtr_bgpsec struct. @@ -457,7 +463,7 @@ void rtr_mgr_bgpsec_free(struct rtr_bgpsec *bgpsec); * by @ref rtr_secure_path_seg.next. * @param[in] seg The Secure Path Segment that is to be freed. */ -void rtr_mgr_free_secure_path(struct rtr_secure_path_seg *seg); +void rtr_mgr_bgpsec_free_secure_path(struct rtr_secure_path_seg *seg); /** * @brief Retrieve a pointer to the last appended Secure Path Segment @@ -479,13 +485,13 @@ struct rtr_signature_seg *rtr_mgr_bgpsec_pop_signature_seg(struct rtr_bgpsec *bg void rtr_mgr_bgpsec_append_sec_path_seg(struct rtr_bgpsec *bgpsec, struct rtr_secure_path_seg *new_seg); -int rtr_mgr_bgpsec_append_sig_seg(struct rtr_bgpsec *bgpsec, struct rtr_signature_seg *new_seg); +enum rtr_bgpsec_rtvals rtr_mgr_bgpsec_append_sig_seg(struct rtr_bgpsec *bgpsec, struct rtr_signature_seg *new_seg); struct rtr_bgpsec_nlri *rtr_mgr_bgpsec_nlri_new(int nlri_len); void rtr_mgr_bgpsec_nlri_free(struct rtr_bgpsec_nlri *nlri); -void rtr_mgr_bgpsec_add_spki_record(struct rtr_mgr_config *config, struct spki_record *record); +void rtr_mgr_bgpsec_add_spki_record(struct rtr_mgr_config *config, struct rtr_spki_record *record); #endif #endif diff --git a/rtrlib/spki/hashtable/ht-spkitable.c b/rtrlib/spki/hashtable/ht-spkitable.c index 9725b5d8..dbb4ab2b 100644 --- a/rtrlib/spki/hashtable/ht-spkitable.c +++ b/rtrlib/spki/hashtable/ht-spkitable.c @@ -49,7 +49,7 @@ static int key_entry_cmp(const void *arg, const void *obj) } /* Copying the content, target struct must already be allocated */ -static void key_entry_to_spki_record(struct key_entry *key_e, struct spki_record *spki_r) +static void key_entry_to_spki_record(struct key_entry *key_e, struct rtr_spki_record *spki_r) { spki_r->asn = key_e->asn; spki_r->socket = key_e->socket; @@ -58,7 +58,7 @@ static void key_entry_to_spki_record(struct key_entry *key_e, struct spki_record } /* Copying the content, target struct must already be allocated */ -static void spki_record_to_key_entry(struct spki_record *spki_r, struct key_entry *key_e) +static void spki_record_to_key_entry(struct rtr_spki_record *spki_r, struct key_entry *key_e) { key_e->asn = spki_r->asn; key_e->socket = spki_r->socket; @@ -70,15 +70,16 @@ static void spki_record_to_key_entry(struct spki_record *spki_r, struct key_entr * @brief Calls the spki_table update function. * @param[in] spki_table spki_table to use. * @param[in] record spki_record that was added/removed. - * @param[in] added True means record was added, False means removed + * @param[in] operation_type The type of operation performed on the given record */ -static void spki_table_notify_clients(struct spki_table *spki_table, const struct spki_record *record, const bool added) +static void spki_table_notify_clients(struct rtr_spki_table *spki_table, const struct rtr_spki_record *record, + const enum rtr_spki_operation_type operation_type) { if (spki_table->update_fp) - spki_table->update_fp(spki_table, *record, added); + spki_table->update_fp(spki_table, *record, operation_type); } -void spki_table_init(struct spki_table *spki_table, spki_update_fp update_fp) +void spki_table_init(struct rtr_spki_table *spki_table, rtr_spki_update_fp update_fp) { tommy_hashlin_init(&spki_table->hashtable); tommy_list_init(&spki_table->list); @@ -87,7 +88,7 @@ void spki_table_init(struct spki_table *spki_table, spki_update_fp update_fp) spki_table->update_fp = update_fp; } -void spki_table_free(struct spki_table *spki_table) +void spki_table_free(struct rtr_spki_table *spki_table) { if (spki_table == NULL) { SPKI_DBG1("SPKI table is not initialized. Nothing to free."); @@ -103,7 +104,7 @@ void spki_table_free(struct spki_table *spki_table) pthread_rwlock_destroy(&spki_table->lock); } -void spki_table_free_without_notify(struct spki_table *spki_table) +void spki_table_free_without_notify(struct rtr_spki_table *spki_table) { pthread_rwlock_wrlock(&spki_table->lock); @@ -115,35 +116,35 @@ void spki_table_free_without_notify(struct spki_table *spki_table) pthread_rwlock_destroy(&spki_table->lock); } -int spki_table_add_entry(struct spki_table *spki_table, struct spki_record *spki_record) +int spki_table_add_entry(struct rtr_spki_table *spki_table, struct rtr_spki_record *spki_record) { uint32_t hash; struct key_entry *entry; - entry = lrtr_malloc(sizeof(*entry)); + entry = rtr_malloc(sizeof(*entry)); if (!entry) - return SPKI_ERROR; + return RTR_SPKI_ERROR; spki_record_to_key_entry(spki_record, entry); hash = tommy_inthash_u32(spki_record->asn); pthread_rwlock_wrlock(&spki_table->lock); if (tommy_hashlin_search(&spki_table->hashtable, spki_table->cmp_fp, entry, hash)) { - lrtr_free(entry); + rtr_free(entry); pthread_rwlock_unlock(&spki_table->lock); - return SPKI_DUPLICATE_RECORD; + return RTR_SPKI_DUPLICATE_RECORD; } /* Insert into hashtable and list */ tommy_hashlin_insert(&spki_table->hashtable, &entry->hash_node, entry, hash); tommy_list_insert_tail(&spki_table->list, &entry->list_node, entry); pthread_rwlock_unlock(&spki_table->lock); - spki_table_notify_clients(spki_table, spki_record, true); - return SPKI_SUCCESS; + spki_table_notify_clients(spki_table, spki_record, RTR_SPKI_ADD); + return RTR_SPKI_SUCCESS; } -int spki_table_get_all(struct spki_table *spki_table, uint32_t asn, uint8_t *ski, struct spki_record **result, - unsigned int *result_size) +enum rtr_spki_rtvals spki_table_get_all(struct rtr_spki_table *spki_table, uint32_t asn, uint8_t *ski, + struct rtr_spki_record **result, unsigned int *result_size) { uint32_t hash = tommy_inthash_u32(asn); tommy_node *result_bucket; @@ -164,7 +165,7 @@ int spki_table_get_all(struct spki_table *spki_table, uint32_t asn, uint8_t *ski if (!result_bucket) { pthread_rwlock_unlock(&spki_table->lock); - return SPKI_SUCCESS; + return RTR_SPKI_SUCCESS; } /* Build the result array */ @@ -174,11 +175,11 @@ int spki_table_get_all(struct spki_table *spki_table, uint32_t asn, uint8_t *ski element = result_bucket->data; if (element->asn == asn && memcmp(element->ski, ski, sizeof(element->ski)) == 0) { (*result_size)++; - tmp = lrtr_realloc(*result, *result_size * sizeof(**result)); + tmp = rtr_realloc(*result, *result_size * sizeof(**result)); if (!tmp) { - lrtr_free(*result); + rtr_free(*result); pthread_rwlock_unlock(&spki_table->lock); - return SPKI_ERROR; + return RTR_SPKI_ERROR; } *result = tmp; key_entry_to_spki_record(element, *result + *result_size - 1); @@ -187,11 +188,11 @@ int spki_table_get_all(struct spki_table *spki_table, uint32_t asn, uint8_t *ski } pthread_rwlock_unlock(&spki_table->lock); - return SPKI_SUCCESS; + return RTR_SPKI_SUCCESS; } // cppcheck-suppress unusedFunction -int spki_table_search_by_ski(struct spki_table *spki_table, uint8_t *ski, struct spki_record **result, +int spki_table_search_by_ski(struct rtr_spki_table *spki_table, uint8_t *ski, struct rtr_spki_record **result, unsigned int *result_size) { tommy_node *current_node; @@ -209,11 +210,11 @@ int spki_table_search_by_ski(struct spki_table *spki_table, uint8_t *ski, struct if (memcmp(current_entry->ski, ski, sizeof(current_entry->ski)) == 0) { (*result_size)++; - tmp = lrtr_realloc(*result, sizeof(**result) * (*result_size)); + tmp = rtr_realloc(*result, sizeof(**result) * (*result_size)); if (!tmp) { - lrtr_free(*result); + rtr_free(*result); pthread_rwlock_unlock(&spki_table->lock); - return SPKI_ERROR; + return RTR_SPKI_ERROR; } *result = tmp; key_entry_to_spki_record(current_entry, *result + (*result_size - 1)); @@ -221,15 +222,15 @@ int spki_table_search_by_ski(struct spki_table *spki_table, uint8_t *ski, struct current_node = current_node->next; } pthread_rwlock_unlock(&spki_table->lock); - return SPKI_SUCCESS; + return RTR_SPKI_SUCCESS; } -int spki_table_remove_entry(struct spki_table *spki_table, struct spki_record *spki_record) +int spki_table_remove_entry(struct rtr_spki_table *spki_table, struct rtr_spki_record *spki_record) { uint32_t hash; struct key_entry entry; struct key_entry *rmv_elem; - int rtval = SPKI_ERROR; + int rtval = RTR_SPKI_ERROR; spki_record_to_key_entry(spki_record, &entry); hash = tommy_inthash_u32(spki_record->asn); @@ -237,25 +238,25 @@ int spki_table_remove_entry(struct spki_table *spki_table, struct spki_record *s pthread_rwlock_wrlock(&spki_table->lock); if (!tommy_hashlin_search(&spki_table->hashtable, spki_table->cmp_fp, &entry, hash)) { - rtval = SPKI_RECORD_NOT_FOUND; + rtval = RTR_SPKI_RECORD_NOT_FOUND; } else { /* Remove from hashtable and list */ rmv_elem = tommy_hashlin_remove(&spki_table->hashtable, spki_table->cmp_fp, &entry, hash); if (rmv_elem && tommy_list_remove_existing(&spki_table->list, &rmv_elem->list_node)) { - lrtr_free(rmv_elem); + rtr_free(rmv_elem); spki_table_notify_clients(spki_table, spki_record, false); - rtval = SPKI_SUCCESS; + rtval = RTR_SPKI_SUCCESS; } } pthread_rwlock_unlock(&spki_table->lock); return rtval; } -int spki_table_src_remove(struct spki_table *spki_table, const struct rtr_socket *socket) +int spki_table_src_remove(struct rtr_spki_table *spki_table, const struct rtr_socket *socket) { if (spki_table == NULL) { SPKI_DBG1("SPKI table is not initialized. Nothing to remove."); - return SPKI_SUCCESS; + return RTR_SPKI_SUCCESS; } struct key_entry *entry; @@ -270,38 +271,38 @@ int spki_table_src_remove(struct spki_table *spki_table, const struct rtr_socket current_node = current_node->next; if (!tommy_list_remove_existing(&spki_table->list, &entry->list_node)) { pthread_rwlock_unlock(&spki_table->lock); - return SPKI_ERROR; + return RTR_SPKI_ERROR; } if (!tommy_hashlin_remove_existing(&spki_table->hashtable, &entry->hash_node)) { pthread_rwlock_unlock(&spki_table->lock); - return SPKI_ERROR; + return RTR_SPKI_ERROR; } - lrtr_free(entry); + rtr_free(entry); } else { current_node = current_node->next; } } pthread_rwlock_unlock(&spki_table->lock); - return SPKI_SUCCESS; + return RTR_SPKI_SUCCESS; } -int spki_table_copy_except_socket(struct spki_table *src, struct spki_table *dst, struct rtr_socket *socket) +int spki_table_copy_except_socket(struct rtr_spki_table *src, struct rtr_spki_table *dst, struct rtr_socket *socket) { tommy_node *current_node; - int ret = SPKI_SUCCESS; + int ret = RTR_SPKI_SUCCESS; pthread_rwlock_rdlock(&src->lock); current_node = tommy_list_head(&src->list); while (current_node) { struct key_entry *entry; - struct spki_record record; + struct rtr_spki_record record; entry = (struct key_entry *)current_node->data; key_entry_to_spki_record(entry, &record); if (entry->socket != socket) { - if (spki_table_add_entry(dst, &record) != SPKI_SUCCESS) { - ret = SPKI_ERROR; + if (spki_table_add_entry(dst, &record) != RTR_SPKI_SUCCESS) { + ret = RTR_SPKI_ERROR; break; } } @@ -313,9 +314,10 @@ int spki_table_copy_except_socket(struct spki_table *src, struct spki_table *dst return ret; } -void spki_table_notify_diff(struct spki_table *new_table, struct spki_table *old_table, const struct rtr_socket *socket) +void spki_table_notify_diff(struct rtr_spki_table *new_table, struct rtr_spki_table *old_table, + const struct rtr_socket *socket) { - spki_update_fp old_table_fp; + rtr_spki_update_fp old_table_fp; // Disable update callback for old_table old_table_fp = old_table->update_fp; @@ -329,12 +331,12 @@ void spki_table_notify_diff(struct spki_table *new_table, struct spki_table *old struct key_entry *entry = (struct key_entry *)current_node->data; if (entry->socket == socket) { - struct spki_record record; + struct rtr_spki_record record; key_entry_to_spki_record(entry, &record); - if (spki_table_remove_entry(old_table, &record) == SPKI_RECORD_NOT_FOUND) - spki_table_notify_clients(new_table, &record, true); + if (spki_table_remove_entry(old_table, &record) == RTR_SPKI_RECORD_NOT_FOUND) + spki_table_notify_clients(new_table, &record, RTR_SPKI_ADD); } } @@ -345,7 +347,7 @@ void spki_table_notify_diff(struct spki_table *new_table, struct spki_table *old struct key_entry *entry = (struct key_entry *)current_node->data; if (entry->socket == socket) { - struct spki_record record; + struct rtr_spki_record record; key_entry_to_spki_record(entry, &record); spki_table_notify_clients(new_table, &record, false); @@ -356,7 +358,7 @@ void spki_table_notify_diff(struct spki_table *new_table, struct spki_table *old old_table->update_fp = old_table_fp; } -void spki_table_swap(struct spki_table *a, struct spki_table *b) +void spki_table_swap(struct rtr_spki_table *a, struct rtr_spki_table *b) { tommy_hashlin tmp_hashtable; tommy_list tmp_list; diff --git a/rtrlib/spki/hashtable/ht-spkitable_private.h b/rtrlib/spki/hashtable/ht-spkitable_private.h index c8407cc3..61d3dce7 100644 --- a/rtrlib/spki/hashtable/ht-spkitable_private.h +++ b/rtrlib/spki/hashtable/ht-spkitable_private.h @@ -15,7 +15,7 @@ #include "third-party/tommyds/tommyhashlin.h" #include "third-party/tommyds/tommylist.h" -#define SPKI_DBG1(a) lrtr_dbg("SPKI: " a) +#define SPKI_DBG1(a) rtr_dbg("SPKI: " a) typedef int (*hash_cmp_fp)(const void *arg, const void *obj); @@ -27,11 +27,11 @@ typedef int (*hash_cmp_fp)(const void *arg, const void *obj); * @param update_fp Update function, called when the hashtable changes * @param lock Read-Write lock to prevent data races */ -struct spki_table { +struct rtr_spki_table { tommy_hashlin hashtable; tommy_list list; hash_cmp_fp cmp_fp; - spki_update_fp update_fp; + rtr_spki_update_fp update_fp; pthread_rwlock_t lock; }; diff --git a/rtrlib/spki/spkitable.h b/rtrlib/spki/spkitable.h index 4158c58b..9f452ec5 100644 --- a/rtrlib/spki/spkitable.h +++ b/rtrlib/spki/spkitable.h @@ -26,7 +26,7 @@ #define SKI_SIZE 20 #define SPKI_SIZE 91 -struct spki_table; +struct rtr_spki_table; /** * @brief spki_record. @@ -35,20 +35,32 @@ struct spki_table; * @param spki Subject public key info * @param socket Pointer to the rtr_socket this spki_record was received in */ -struct spki_record { +struct rtr_spki_record { uint8_t ski[SKI_SIZE]; uint32_t asn; uint8_t spki[SPKI_SIZE]; const struct rtr_socket *socket; }; +/** + * @brief An enum describing the type of operation that has been performed in the SPKI table. + */ +enum __attribute__((__packed__)) rtr_spki_operation_type { + /** An existing record has been removed. */ + RTR_SPKI_REMOVE = 0, + + /** A new record has been added. */ + RTR_SPKI_ADD = 1 +}; + /** * @brief A function pointer that is called if an record was added * to the spki_table or was removed from the spki_table. * @param spki_table which was updated. * @param record spki_record that was modified. - * @param added True if the record was added, false if the record was removed. + * @param operation_type The type of operation performed on the given record. */ -typedef void (*spki_update_fp)(struct spki_table *spki_table, const struct spki_record record, const bool added); +typedef void (*rtr_spki_update_fp)(struct rtr_spki_table *spki_table, const struct rtr_spki_record record, + const enum rtr_spki_operation_type operation_type); #endif /** @} */ diff --git a/rtrlib/spki/spkitable_private.h b/rtrlib/spki/spkitable_private.h index 7aefe73b..0a9eaf08 100644 --- a/rtrlib/spki/spkitable_private.h +++ b/rtrlib/spki/spkitable_private.h @@ -25,18 +25,18 @@ /** * @brief Possible return values for some spki_table_ functions. */ -enum spki_rtvals { +enum rtr_spki_rtvals { /** Operation was successful. */ - SPKI_SUCCESS = 0, + RTR_SPKI_SUCCESS = 0, /** Error occurred. */ - SPKI_ERROR = -1, + RTR_SPKI_ERROR = -1, /** The supplied spki_record already exists in the spki_table. */ - SPKI_DUPLICATE_RECORD = -2, + RTR_SPKI_DUPLICATE_RECORD = -2, /** spki_record wasn't found in the spki_table. */ - SPKI_RECORD_NOT_FOUND = -3 + RTR_SPKI_RECORD_NOT_FOUND = -3 }; /** @@ -44,19 +44,19 @@ enum spki_rtvals { * @param[in] spki_table spki_table that will be initialized. * @param[in] update_fp Pointer to update function */ -void spki_table_init(struct spki_table *spki_table, spki_update_fp update_fp); +void spki_table_init(struct rtr_spki_table *spki_table, rtr_spki_update_fp update_fp); /** * @brief Frees the memory associated with the spki_table. * @param[in] spki_table spki_table that will be initialized. */ -void spki_table_free(struct spki_table *spki_table); +void spki_table_free(struct rtr_spki_table *spki_table); /** * @brief Frees the memory associated with the spki_table without calling the update callback. * @param[in] spki_table spki_table that will be initialized. */ -void spki_table_free_without_notify(struct spki_table *spki_table); +void spki_table_free_without_notify(struct rtr_spki_table *spki_table); /** * @brief Adds a spki_record to a spki_table. @@ -66,7 +66,7 @@ void spki_table_free_without_notify(struct spki_table *spki_table); * @return SPKI_ERROR On error. * @return SPKI_DUPLICATE_RECORD If an identical spki_record already exists */ -int spki_table_add_entry(struct spki_table *spki_table, struct spki_record *spki_record); +int spki_table_add_entry(struct rtr_spki_table *spki_table, struct rtr_spki_record *spki_record); /** * @brief Returns all spki_record whose ASN and SKI matches. @@ -78,8 +78,8 @@ int spki_table_add_entry(struct spki_table *spki_table, struct spki_record *spki * @return SPKI_SUCCESS On success * @return SPKI_ERROR On error */ -int spki_table_get_all(struct spki_table *spki_table, uint32_t asn, uint8_t *ski, struct spki_record **result, - unsigned int *result_size); +enum rtr_spki_rtvals spki_table_get_all(struct rtr_spki_table *spki_table, uint32_t asn, uint8_t *ski, + struct rtr_spki_record **result, unsigned int *result_size); /** * @brief Returns all spki_record whose SKI number matches the given one. @@ -90,7 +90,7 @@ int spki_table_get_all(struct spki_table *spki_table, uint32_t asn, uint8_t *ski * @return SPKI_SUCCESS On success * @return SPKI_ERROR On error */ -int spki_table_search_by_ski(struct spki_table *spki_table, uint8_t *ski, struct spki_record **result, +int spki_table_search_by_ski(struct rtr_spki_table *spki_table, uint8_t *ski, struct rtr_spki_record **result, unsigned int *result_size); /** @@ -101,7 +101,7 @@ int spki_table_search_by_ski(struct spki_table *spki_table, uint8_t *ski, struct * @return SPKI_ERROR On error * @return SPKI_RECORD_NOT_FOUND On record not found */ -int spki_table_remove_entry(struct spki_table *spki_table, struct spki_record *spki_record); +int spki_table_remove_entry(struct rtr_spki_table *spki_table, struct rtr_spki_record *spki_record); /** * @brief Removes all entries in the spki_table that match the passed socket_id. @@ -110,7 +110,7 @@ int spki_table_remove_entry(struct spki_table *spki_table, struct spki_record *s * @return SPKI_SUCCESS On success. * @return SPKI_ERROR On error. */ -int spki_table_src_remove(struct spki_table *spki_table, const struct rtr_socket *socket); +int spki_table_src_remove(struct rtr_spki_table *spki_table, const struct rtr_socket *socket); /** * @brief Copy spki table except entries from the given socket @@ -120,7 +120,7 @@ int spki_table_src_remove(struct spki_table *spki_table, const struct rtr_socket * @return SPKI_SUCCESS On success. * @return SPKI_ERROR On error. */ -int spki_table_copy_except_socket(struct spki_table *src, struct spki_table *dest, struct rtr_socket *socket); +int spki_table_copy_except_socket(struct rtr_spki_table *src, struct rtr_spki_table *dest, struct rtr_socket *socket); /** * @brief Notify client about changes between two spki tables regarding one specific socket @@ -129,7 +129,7 @@ int spki_table_copy_except_socket(struct spki_table *src, struct spki_table *des * @param[in] old_table * @param[in] socket socket which entries should be diffed */ -void spki_table_notify_diff(struct spki_table *new_table, struct spki_table *old_table, +void spki_table_notify_diff(struct rtr_spki_table *new_table, struct rtr_spki_table *old_table, const struct rtr_socket *socket); /** @@ -137,7 +137,7 @@ void spki_table_notify_diff(struct spki_table *new_table, struct spki_table *old * @param[in] a * @param[in] b */ -void spki_table_swap(struct spki_table *a, struct spki_table *b); +void spki_table_swap(struct rtr_spki_table *a, struct rtr_spki_table *b); #endif /** @} */ diff --git a/rtrlib/transport/ssh/ssh_transport.c b/rtrlib/transport/ssh/ssh_transport.c index 243e01ef..c29afd0f 100644 --- a/rtrlib/transport/ssh/ssh_transport.c +++ b/rtrlib/transport/ssh/ssh_transport.c @@ -25,24 +25,24 @@ #include #include -#define SSH_DBG(fmt, sock, ...) \ - do { \ - const struct tr_ssh_socket *tmp = sock; \ - lrtr_dbg("SSH Transport(%s@%s:%u): " fmt, tmp->config.username, tmp->config.host, tmp->config.port, \ - ##__VA_ARGS__); \ +#define SSH_DBG(fmt, sock, ...) \ + do { \ + const struct tr_ssh_socket *tmp = sock; \ + rtr_dbg("SSH Transport(%s@%s:%u): " fmt, tmp->config.username, tmp->config.host, tmp->config.port, \ + ##__VA_ARGS__); \ } while (0) #define SSH_DBG1(a, sock) SSH_DBG(a, sock) struct tr_ssh_socket { ssh_session session; ssh_channel channel; - struct tr_ssh_config config; + struct rtr_tr_ssh_config config; char *ident; }; static int tr_ssh_open(void *tr_ssh_sock); static void tr_ssh_close(void *tr_ssh_sock); -static void tr_ssh_free(struct tr_socket *tr_sock); +static void tr_ssh_free(struct rtr_tr_socket *tr_sock); static int tr_ssh_recv(const void *tr_ssh_sock, void *buf, const size_t buf_len, const time_t timeout); static int tr_ssh_send(const void *tr_ssh_sock, const void *pdu, const size_t len, const time_t timeout); static int tr_ssh_recv_async(const struct tr_ssh_socket *tr_ssh_sock, void *buf, const size_t buf_len); @@ -52,7 +52,7 @@ static const char *tr_ssh_ident(void *tr_ssh_sock); int tr_ssh_open(void *socket) { struct tr_ssh_socket *ssh_socket = socket; - const struct tr_ssh_config *config = &ssh_socket->config; + const struct rtr_tr_ssh_config *config = &ssh_socket->config; assert(!ssh_socket->channel); assert(!ssh_socket->session); @@ -84,7 +84,7 @@ int tr_ssh_open(void *socket) if (fd >= 0) { ssh_options_set(ssh_socket->session, SSH_OPTIONS_FD, &fd); } else { - SSH_DBG1("tr_ssh_init: opening SSH connection failed", ssh_socket); + SSH_DBG1("rtr_tr_ssh_init: opening SSH connection failed", ssh_socket); goto error; } } @@ -179,11 +179,11 @@ int tr_ssh_open(void *socket) } SSH_DBG1("Connection established", ssh_socket); - return TR_SUCCESS; + return RTR_TR_SUCCESS; error: tr_ssh_close(ssh_socket); - return TR_ERROR; + return RTR_TR_ERROR; } void tr_ssh_close(void *tr_ssh_sock) @@ -204,7 +204,7 @@ void tr_ssh_close(void *tr_ssh_sock) SSH_DBG1("Socket closed", socket); } -void tr_ssh_free(struct tr_socket *tr_sock) +void tr_ssh_free(struct rtr_tr_socket *tr_sock) { struct tr_ssh_socket *tr_ssh_sock = tr_sock->socket; @@ -213,15 +213,15 @@ void tr_ssh_free(struct tr_socket *tr_sock) SSH_DBG1("Freeing socket", tr_ssh_sock); - lrtr_free(tr_ssh_sock->config.host); - lrtr_free(tr_ssh_sock->config.bindaddr); - lrtr_free(tr_ssh_sock->config.username); - lrtr_free(tr_ssh_sock->config.client_privkey_path); - lrtr_free(tr_ssh_sock->config.server_hostkey_path); + rtr_free(tr_ssh_sock->config.host); + rtr_free(tr_ssh_sock->config.bindaddr); + rtr_free(tr_ssh_sock->config.username); + rtr_free(tr_ssh_sock->config.client_privkey_path); + rtr_free(tr_ssh_sock->config.server_hostkey_path); if (tr_ssh_sock->ident) - lrtr_free(tr_ssh_sock->ident); - lrtr_free(tr_ssh_sock); + rtr_free(tr_ssh_sock->ident); + rtr_free(tr_ssh_sock); tr_sock->socket = NULL; } @@ -232,13 +232,13 @@ int tr_ssh_recv_async(const struct tr_ssh_socket *tr_ssh_sock, void *buf, const if (rtval == 0) { if (ssh_channel_is_eof(tr_ssh_sock->channel) != 0) { SSH_DBG1("remote has sent EOF", tr_ssh_sock); - return TR_CLOSED; + return RTR_TR_CLOSED; } else { - return TR_WOULDBLOCK; + return RTR_TR_WOULDBLOCK; } } else if (rtval == SSH_ERROR) { SSH_DBG1("recv(..) error", tr_ssh_sock); - return TR_ERROR; + return RTR_TR_ERROR; } return rtval; } @@ -251,15 +251,15 @@ int tr_ssh_recv(const void *tr_ssh_sock, void *buf, const size_t buf_len, const ret = ssh_channel_select(rchans, NULL, NULL, &timev); if (ret == SSH_EINTR) - return TR_INTR; + return RTR_TR_INTR; else if (ret == SSH_ERROR) - return TR_ERROR; + return RTR_TR_ERROR; if (ssh_channel_is_eof(((struct tr_ssh_socket *)tr_ssh_sock)->channel) != 0) - return TR_ERROR; + return RTR_TR_ERROR; if (!rchans[0]) - return TR_WOULDBLOCK; + return RTR_TR_WOULDBLOCK; return tr_ssh_recv_async(tr_ssh_sock, buf, buf_len); } @@ -270,7 +270,7 @@ int tr_ssh_send(const void *tr_ssh_sock, const void *pdu, const size_t len, int ret = ssh_channel_write(((struct tr_ssh_socket *)tr_ssh_sock)->channel, pdu, len); if (ret == SSH_ERROR) - return TR_ERROR; + return RTR_TR_ERROR; return ret; } @@ -286,14 +286,14 @@ const char *tr_ssh_ident(void *tr_ssh_sock) return sock->ident; len = strlen(sock->config.username) + 1 + strlen(sock->config.host) + 1 + 5 + 1; - sock->ident = lrtr_malloc(len); + sock->ident = rtr_malloc(len); if (!sock->ident) return NULL; snprintf(sock->ident, len, "%s@%s:%u", sock->config.username, sock->config.host, sock->config.port); return sock->ident; } -RTRLIB_EXPORT int tr_ssh_init(const struct tr_ssh_config *config, struct tr_socket *socket) +RTRLIB_EXPORT enum rtr_tr_rtvals rtr_tr_ssh_init(const struct rtr_tr_ssh_config *config, struct rtr_tr_socket *socket) { socket->close_fp = &tr_ssh_close; socket->free_fp = &tr_ssh_free; @@ -302,21 +302,21 @@ RTRLIB_EXPORT int tr_ssh_init(const struct tr_ssh_config *config, struct tr_sock socket->send_fp = &tr_ssh_send; socket->ident_fp = &tr_ssh_ident; - socket->socket = lrtr_calloc(1, sizeof(struct tr_ssh_socket)); + socket->socket = rtr_calloc(1, sizeof(struct tr_ssh_socket)); struct tr_ssh_socket *ssh_socket = socket->socket; if (ssh_socket == NULL) { - return TR_ERROR; + return RTR_TR_ERROR; } ssh_socket->channel = NULL; ssh_socket->session = NULL; - ssh_socket->config.host = lrtr_strdup(config->host); + ssh_socket->config.host = rtr_strdup(config->host); if (!ssh_socket->config.host) goto error; ssh_socket->config.port = config->port; - ssh_socket->config.username = lrtr_strdup(config->username); + ssh_socket->config.username = rtr_strdup(config->username); if (!ssh_socket->config.username) goto error; @@ -324,7 +324,7 @@ RTRLIB_EXPORT int tr_ssh_init(const struct tr_ssh_config *config, struct tr_sock goto error; if (config->bindaddr) { - ssh_socket->config.bindaddr = lrtr_strdup(config->bindaddr); + ssh_socket->config.bindaddr = rtr_strdup(config->bindaddr); if (!ssh_socket->config.bindaddr) goto error; @@ -334,7 +334,7 @@ RTRLIB_EXPORT int tr_ssh_init(const struct tr_ssh_config *config, struct tr_sock } if (config->client_privkey_path) { - ssh_socket->config.client_privkey_path = lrtr_strdup(config->client_privkey_path); + ssh_socket->config.client_privkey_path = rtr_strdup(config->client_privkey_path); if (!ssh_socket->config.client_privkey_path) goto error; @@ -343,7 +343,7 @@ RTRLIB_EXPORT int tr_ssh_init(const struct tr_ssh_config *config, struct tr_sock } if (config->server_hostkey_path) { - ssh_socket->config.server_hostkey_path = lrtr_strdup(config->server_hostkey_path); + ssh_socket->config.server_hostkey_path = rtr_strdup(config->server_hostkey_path); if (!ssh_socket->config.server_hostkey_path) goto error; @@ -358,7 +358,7 @@ RTRLIB_EXPORT int tr_ssh_init(const struct tr_ssh_config *config, struct tr_sock ssh_socket->config.connect_timeout = config->connect_timeout; if (config->password) { - ssh_socket->config.password = lrtr_strdup(config->password); + ssh_socket->config.password = rtr_strdup(config->password); if (!ssh_socket->config.password) goto error; @@ -371,7 +371,7 @@ RTRLIB_EXPORT int tr_ssh_init(const struct tr_ssh_config *config, struct tr_sock ssh_socket->config.data = config->data; ssh_socket->config.new_socket = config->new_socket; - return TR_SUCCESS; + return RTR_TR_SUCCESS; error: if (ssh_socket->config.host) @@ -392,5 +392,5 @@ RTRLIB_EXPORT int tr_ssh_init(const struct tr_ssh_config *config, struct tr_sock if (ssh_socket->config.password) free(ssh_socket->config.password); - return TR_ERROR; + return RTR_TR_ERROR; } diff --git a/rtrlib/transport/ssh/ssh_transport.h b/rtrlib/transport/ssh/ssh_transport.h index 188e256e..916b2a04 100644 --- a/rtrlib/transport/ssh/ssh_transport.h +++ b/rtrlib/transport/ssh/ssh_transport.h @@ -48,7 +48,7 @@ * @param connect_timeout Time in seconds to wait for a successful connection. * Defaults to #RTRLIB_TRANSPORT_CONNECT_TIMEOUT_DEFAULT */ -struct tr_ssh_config { +struct rtr_tr_ssh_config { char *host; unsigned int port; char *bindaddr; @@ -68,7 +68,7 @@ struct tr_ssh_config { * @returns TR_SUCCESS On success. * @returns TR_ERROR On error. */ -int tr_ssh_init(const struct tr_ssh_config *config, struct tr_socket *socket); +enum rtr_tr_rtvals rtr_tr_ssh_init(const struct rtr_tr_ssh_config *config, struct rtr_tr_socket *socket); #endif /** @} */ diff --git a/rtrlib/transport/tcp/tcp_transport.c b/rtrlib/transport/tcp/tcp_transport.c index 593efbea..410bed6a 100644 --- a/rtrlib/transport/tcp/tcp_transport.c +++ b/rtrlib/transport/tcp/tcp_transport.c @@ -27,22 +27,22 @@ #include #include -#define TCP_DBG(fmt, sock, ...) \ - do { \ - const struct tr_tcp_socket *tmp = sock; \ - lrtr_dbg("TCP Transport(%s:%s): " fmt, tmp->config.host, tmp->config.port, ##__VA_ARGS__); \ +#define TCP_DBG(fmt, sock, ...) \ + do { \ + const struct tr_tcp_socket *tmp = sock; \ + rtr_dbg("TCP Transport(%s:%s): " fmt, tmp->config.host, tmp->config.port, ##__VA_ARGS__); \ } while (0) #define TCP_DBG1(a, sock) TCP_DBG(a, sock) struct tr_tcp_socket { int socket; - struct tr_tcp_config config; + struct rtr_tr_tcp_config config; char *ident; }; static int tr_tcp_open(void *tr_tcp_sock); static void tr_tcp_close(void *tr_tcp_sock); -static void tr_tcp_free(struct tr_socket *tr_sock); +static void tr_tcp_free(struct rtr_tr_socket *tr_sock); static int tr_tcp_recv(const void *tr_tcp_sock, void *pdu, const size_t len, const time_t timeout); static int tr_tcp_send(const void *tr_tcp_sock, const void *pdu, const size_t len, const time_t timeout); static const char *tr_tcp_ident(void *socket); @@ -52,14 +52,14 @@ static int set_socket_blocking(int socket) int flags = fcntl(socket, F_GETFL); if (flags == -1) - return TR_ERROR; + return RTR_TR_ERROR; flags &= ~O_NONBLOCK; if (fcntl(socket, F_SETFL, flags) == -1) - return TR_ERROR; + return RTR_TR_ERROR; - return TR_SUCCESS; + return RTR_TR_SUCCESS; } static int set_socket_non_blocking(int socket) @@ -67,14 +67,14 @@ static int set_socket_non_blocking(int socket) int flags = fcntl(socket, F_GETFL); if (flags == -1) - return TR_ERROR; + return RTR_TR_ERROR; flags |= O_NONBLOCK; if (fcntl(socket, F_SETFL, flags) == -1) - return TR_ERROR; + return RTR_TR_ERROR; - return TR_SUCCESS; + return RTR_TR_SUCCESS; } static int get_socket_error(int socket) @@ -83,7 +83,7 @@ static int get_socket_error(int socket) socklen_t result_len = sizeof(result); if (getsockopt(socket, SOL_SOCKET, SO_ERROR, &result, &result_len) < 0) - return TR_ERROR; + return RTR_TR_ERROR; return result; } @@ -91,10 +91,10 @@ static int get_socket_error(int socket) /* WARNING: This function has cancelable sections! */ int tr_tcp_open(void *tr_socket) { - int rtval = TR_ERROR; + int rtval = RTR_TR_ERROR; int tcp_rtval = 0; struct tr_tcp_socket *tcp_socket = tr_socket; - const struct tr_tcp_config *config = &tcp_socket->config; + const struct rtr_tr_tcp_config *config = &tcp_socket->config; assert(tcp_socket->socket == -1); @@ -122,7 +122,7 @@ int tr_tcp_open(void *tr_socket) } else { TCP_DBG("getaddrinfo error, %s", tcp_socket, gai_strerror(tcp_rtval)); } - return TR_ERROR; + return RTR_TR_ERROR; } tcp_socket->socket = socket(res->ai_family, res->ai_socktype, res->ai_protocol); @@ -150,7 +150,7 @@ int tr_tcp_open(void *tr_socket) bind_addrinfo = NULL; } - if (set_socket_non_blocking(tcp_socket->socket) == TR_ERROR) { + if (set_socket_non_blocking(tcp_socket->socket) == RTR_TR_ERROR) { TCP_DBG("Could not set socket to non blocking, %s", tcp_socket, strerror(errno)); goto end; } @@ -192,7 +192,7 @@ int tr_tcp_open(void *tr_socket) int socket_error = get_socket_error(tcp_socket->socket); - if (socket_error == TR_ERROR) { + if (socket_error == RTR_TR_ERROR) { TCP_DBG("Could not get socket error, %s", tcp_socket, strerror(errno)); goto end; @@ -201,14 +201,14 @@ int tr_tcp_open(void *tr_socket) goto end; } - if (set_socket_blocking(tcp_socket->socket) == TR_ERROR) { + if (set_socket_blocking(tcp_socket->socket) == RTR_TR_ERROR) { TCP_DBG("Could not set socket to blocking, %s", tcp_socket, strerror(errno)); goto end; } } TCP_DBG1("Connection established", tcp_socket); - rtval = TR_SUCCESS; + rtval = RTR_TR_SUCCESS; end: if (res) @@ -231,7 +231,7 @@ void tr_tcp_close(void *tr_tcp_sock) tcp_socket->socket = -1; } -void tr_tcp_free(struct tr_socket *tr_sock) +void tr_tcp_free(struct rtr_tr_socket *tr_sock) { struct tr_tcp_socket *tcp_sock = tr_sock->socket; @@ -240,14 +240,14 @@ void tr_tcp_free(struct tr_socket *tr_sock) TCP_DBG1("Freeing socket", tcp_sock); - lrtr_free(tcp_sock->config.host); - lrtr_free(tcp_sock->config.port); - lrtr_free(tcp_sock->config.bindaddr); + rtr_free(tcp_sock->config.host); + rtr_free(tcp_sock->config.port); + rtr_free(tcp_sock->config.bindaddr); if (tcp_sock->ident) - lrtr_free(tcp_sock->ident); + rtr_free(tcp_sock->ident); tr_sock->socket = NULL; - lrtr_free(tcp_sock); + rtr_free(tcp_sock); } int tr_tcp_recv(const void *tr_tcp_sock, void *pdu, const size_t len, const time_t timeout) @@ -262,21 +262,21 @@ int tr_tcp_recv(const void *tr_tcp_sock, void *pdu, const size_t len, const time if (setsockopt(tcp_socket->socket, SOL_SOCKET, SO_RCVTIMEO, &t, sizeof(t)) == -1) { TCP_DBG("setting SO_RCVTIMEO failed, %s", tcp_socket, strerror(errno)); - return TR_ERROR; + return RTR_TR_ERROR; } rtval = recv(tcp_socket->socket, pdu, len, 0); } if (rtval == -1) { if (errno == EAGAIN || errno == EWOULDBLOCK) - return TR_WOULDBLOCK; + return RTR_TR_WOULDBLOCK; if (errno == EINTR) - return TR_INTR; + return RTR_TR_INTR; TCP_DBG("recv(..) error: %s", tcp_socket, strerror(errno)); - return TR_ERROR; + return RTR_TR_ERROR; } if (rtval == 0) - return TR_CLOSED; + return RTR_TR_CLOSED; return rtval; } @@ -292,21 +292,21 @@ int tr_tcp_send(const void *tr_tcp_sock, const void *pdu, const size_t len, cons if (setsockopt(tcp_socket->socket, SOL_SOCKET, SO_SNDTIMEO, &t, sizeof(t)) == -1) { TCP_DBG("setting SO_SNDTIMEO failed, %s", tcp_socket, strerror(errno)); - return TR_ERROR; + return RTR_TR_ERROR; } rtval = send(tcp_socket->socket, pdu, len, 0); } if (rtval == -1) { if (errno == EAGAIN || errno == EWOULDBLOCK) - return TR_WOULDBLOCK; + return RTR_TR_WOULDBLOCK; if (errno == EINTR) - return TR_INTR; + return RTR_TR_INTR; TCP_DBG("send(..) error: %s", tcp_socket, strerror(errno)); - return TR_ERROR; + return RTR_TR_ERROR; } if (rtval == 0) - return TR_ERROR; + return RTR_TR_ERROR; return rtval; } @@ -321,7 +321,7 @@ const char *tr_tcp_ident(void *socket) return sock->ident; len = strlen(sock->config.port) + strlen(sock->config.host) + 2; - sock->ident = lrtr_malloc(len); + sock->ident = rtr_malloc(len); if (!sock->ident) return NULL; snprintf(sock->ident, len, "%s:%s", sock->config.host, sock->config.port); @@ -329,7 +329,7 @@ const char *tr_tcp_ident(void *socket) return sock->ident; } -RTRLIB_EXPORT int tr_tcp_init(const struct tr_tcp_config *config, struct tr_socket *socket) +RTRLIB_EXPORT enum rtr_tr_rtvals rtr_tr_tcp_init(const struct rtr_tr_tcp_config *config, struct rtr_tr_socket *socket) { socket->close_fp = &tr_tcp_close; socket->free_fp = &tr_tcp_free; @@ -338,19 +338,19 @@ RTRLIB_EXPORT int tr_tcp_init(const struct tr_tcp_config *config, struct tr_sock socket->send_fp = &tr_tcp_send; socket->ident_fp = &tr_tcp_ident; - socket->socket = lrtr_malloc(sizeof(struct tr_tcp_socket)); + socket->socket = rtr_malloc(sizeof(struct tr_tcp_socket)); if (socket->socket == NULL) { - return TR_ERROR; + return RTR_TR_ERROR; } struct tr_tcp_socket *tcp_socket = socket->socket; tcp_socket->socket = -1; - tcp_socket->config.host = lrtr_strdup(config->host); - tcp_socket->config.port = lrtr_strdup(config->port); + tcp_socket->config.host = rtr_strdup(config->host); + tcp_socket->config.port = rtr_strdup(config->port); if (config->bindaddr) - tcp_socket->config.bindaddr = lrtr_strdup(config->bindaddr); + tcp_socket->config.bindaddr = rtr_strdup(config->bindaddr); else tcp_socket->config.bindaddr = NULL; @@ -363,5 +363,5 @@ RTRLIB_EXPORT int tr_tcp_init(const struct tr_tcp_config *config, struct tr_sock tcp_socket->config.data = config->data; tcp_socket->config.new_socket = config->new_socket; - return TR_SUCCESS; + return RTR_TR_SUCCESS; } diff --git a/rtrlib/transport/tcp/tcp_transport.h b/rtrlib/transport/tcp/tcp_transport.h index 31980506..272380ae 100644 --- a/rtrlib/transport/tcp/tcp_transport.h +++ b/rtrlib/transport/tcp/tcp_transport.h @@ -38,7 +38,7 @@ * @param connect_timeout Time in seconds to wait for a successful connection. * Defaults to #RTRLIB_TRANSPORT_CONNECT_TIMEOUT_DEFAULT */ -struct tr_tcp_config { +struct rtr_tr_tcp_config { char *host; char *port; char *bindaddr; @@ -54,6 +54,6 @@ struct tr_tcp_config { * @returns TR_SUCCESS On success. * @returns TR_ERROR On error. */ -int tr_tcp_init(const struct tr_tcp_config *config, struct tr_socket *socket); +enum rtr_tr_rtvals rtr_tr_tcp_init(const struct rtr_tr_tcp_config *config, struct rtr_tr_socket *socket); #endif /** @} */ diff --git a/rtrlib/transport/transport.c b/rtrlib/transport/transport.c index d1bdfc56..425e2b67 100644 --- a/rtrlib/transport/transport.c +++ b/rtrlib/transport/transport.c @@ -11,50 +11,50 @@ #include "rtrlib/lib/utils_private.h" -inline int tr_open(struct tr_socket *socket) +inline int tr_open(struct rtr_tr_socket *socket) { return socket->open_fp(socket->socket); } -inline void tr_close(struct tr_socket *socket) +inline void tr_close(struct rtr_tr_socket *socket) { socket->close_fp(socket->socket); } -inline void tr_free(struct tr_socket *socket) +inline void tr_free(struct rtr_tr_socket *socket) { socket->free_fp(socket); } -inline int tr_send(const struct tr_socket *socket, const void *pdu, const size_t len, const time_t timeout) +inline int tr_send(const struct rtr_tr_socket *socket, const void *pdu, const size_t len, const time_t timeout) { return socket->send_fp(socket->socket, pdu, len, timeout); } -inline int tr_recv(const struct tr_socket *socket, void *buf, const size_t len, const time_t timeout) +inline int tr_recv(const struct rtr_tr_socket *socket, void *buf, const size_t len, const time_t timeout) { return socket->recv_fp(socket->socket, buf, len, timeout); } /* cppcheck-suppress unusedFunction */ -inline const char *tr_ident(struct tr_socket *sock) +inline const char *tr_ident(struct rtr_tr_socket *sock) { return sock->ident_fp(sock->socket); } -int tr_send_all(const struct tr_socket *socket, const void *pdu, const size_t len, const time_t timeout) +int tr_send_all(const struct rtr_tr_socket *socket, const void *pdu, const size_t len, const time_t timeout) { unsigned int total_send = 0; time_t end_time; - lrtr_get_monotonic_time(&end_time); + rtr_get_monotonic_time(&end_time); end_time = end_time + timeout; while (total_send < len) { time_t cur_time; int rtval; - lrtr_get_monotonic_time(&cur_time); + rtr_get_monotonic_time(&cur_time); rtval = tr_send(socket, ((char *)pdu) + total_send, (len - total_send), (end_time - cur_time)); if (rtval < 0) @@ -64,19 +64,19 @@ int tr_send_all(const struct tr_socket *socket, const void *pdu, const size_t le return total_send; } -int tr_recv_all(const struct tr_socket *socket, const void *pdu, const size_t len, const time_t timeout) +int tr_recv_all(const struct rtr_tr_socket *socket, const void *pdu, const size_t len, const time_t timeout) { size_t total_recv = 0; time_t end_time; - lrtr_get_monotonic_time(&end_time); + rtr_get_monotonic_time(&end_time); end_time += timeout; while (total_recv < len) { time_t cur_time; int rtval; - lrtr_get_monotonic_time(&cur_time); + rtr_get_monotonic_time(&cur_time); rtval = tr_recv(socket, ((char *)pdu) + total_recv, (len - total_recv), end_time - cur_time); if (rtval < 0) diff --git a/rtrlib/transport/transport.h b/rtrlib/transport/transport.h index c092a2f9..b2c373b2 100644 --- a/rtrlib/transport/transport.h +++ b/rtrlib/transport/transport.h @@ -13,7 +13,7 @@ * (e.g., SSH, TCP, TCP-AO) between an RTR server and client. * @details Before using the transport socket, a tr_socket must be * initialized based on a protocol-dependent init function (e.g., - * tr_tcp_init()).\n + * rtr_tr_tcp_init()).\n * The tr_* functions call the corresponding function pointers, which are * passed in the tr_socket struct, and forward the remaining arguments. * @@ -33,24 +33,24 @@ /** * @brief The return values for tr_ functions. */ -enum tr_rtvals { +enum rtr_tr_rtvals { /** @brief Operation was successful. */ - TR_SUCCESS = 0, + RTR_TR_SUCCESS = 0, /** Error occurred. */ - TR_ERROR = -1, + RTR_TR_ERROR = -1, /** No data is available on the socket. */ - TR_WOULDBLOCK = -2, + RTR_TR_WOULDBLOCK = -2, /** Call was interrupted from a signal */ - TR_INTR = -3, + RTR_TR_INTR = -3, /** Connection closed */ - TR_CLOSED = -4 + RTR_TR_CLOSED = -4 }; -struct tr_socket; +struct rtr_tr_socket; /** * @brief A function pointer to a technology specific close function. @@ -69,7 +69,7 @@ typedef int (*tr_open_fp)(void *socket); * All memory associated with the tr_socket will be freed. * \sa tr_free */ -typedef void (*tr_free_fp)(struct tr_socket *tr_sock); +typedef void (*tr_free_fp)(struct rtr_tr_socket *tr_sock); /** * @brief A function pointer to a technology specific recv function. @@ -99,7 +99,7 @@ typedef const char *(*tr_ident_fp)(void *socket); * @param send_fp Pointer to a function that sends data through this socket. * @param recv_fp Pointer to a function that receives data from this socket. */ -struct tr_socket { +struct rtr_tr_socket { void *socket; tr_open_fp open_fp; tr_close_fp close_fp; diff --git a/rtrlib/transport/transport_private.h b/rtrlib/transport/transport_private.h index 7fc2e19c..ff66add7 100644 --- a/rtrlib/transport/transport_private.h +++ b/rtrlib/transport/transport_private.h @@ -13,7 +13,7 @@ * (e.g., SSH, TCP, TCP-AO) between an RTR server and client. * @details Before using the transport socket, a tr_socket must be * initialized based on a protocol-dependent init function (e.g., - * tr_tcp_init()).\n + * rtr_tr_tcp_init()).\n * The tr_* functions call the corresponding function pointers, which are * passed in the tr_socket struct, and forward the remaining arguments. * @@ -33,20 +33,20 @@ * @return TR_SUCCESS On success. * @return TR_ERROR On error. */ -int tr_open(struct tr_socket *socket); +int tr_open(struct rtr_tr_socket *socket); /** * @brief Close the socket connection. * @param[in] socket Socket that will be closed. */ -void tr_close(struct tr_socket *socket); +void tr_close(struct rtr_tr_socket *socket); /** * @brief Deallocates all memory that the passed socket uses. * Socket have to be closed before. * @param[in] socket which will be freed. */ -void tr_free(struct tr_socket *socket); +void tr_free(struct rtr_tr_socket *socket); /** * @brief Receives <= len Bytes data from the socket. @@ -58,7 +58,7 @@ void tr_free(struct tr_socket *socket); * @return TR_ERROR On error. * @return TR_WOULDBLOCK If no data was available at the socket before the timeout expired. */ -int tr_recv(const struct tr_socket *socket, void *buf, const size_t len, const time_t timeout); +int tr_recv(const struct rtr_tr_socket *socket, void *buf, const size_t len, const time_t timeout); /** * @brief Send <= len Bytes data over the socket. @@ -69,7 +69,7 @@ int tr_recv(const struct tr_socket *socket, void *buf, const size_t len, const t * @return >0 Number of Bytes sent. * @return TR_ERROR On error. */ -int tr_send(const struct tr_socket *socket, const void *pdu, const size_t len, const time_t timeout); +int tr_send(const struct rtr_tr_socket *socket, const void *pdu, const size_t len, const time_t timeout); /** * Repeatedly calls tr_send(..) till len Bytes were sent, the timeout expired or an error occurred. @@ -81,7 +81,7 @@ int tr_send(const struct tr_socket *socket, const void *pdu, const size_t len, c * @return TR_ERROR On Error. * @return TR_WOULDBLOCK If send would block. */ -int tr_send_all(const struct tr_socket *socket, const void *pdu, const size_t len, const time_t timeout); +int tr_send_all(const struct rtr_tr_socket *socket, const void *pdu, const size_t len, const time_t timeout); /** * Repeatedly calls tr_recv(..) till len Bytes were received, the timeout expired or an error occurred. @@ -93,7 +93,7 @@ int tr_send_all(const struct tr_socket *socket, const void *pdu, const size_t le * @return TR_ERROR On error. * @return TR_WOULDBLOCK If send would block. */ -int tr_recv_all(const struct tr_socket *socket, const void *buf, const size_t len, const time_t timeout); +int tr_recv_all(const struct rtr_tr_socket *socket, const void *buf, const size_t len, const time_t timeout); /** * Returns an identifier for the socket endpoint, eg host:port. @@ -101,7 +101,7 @@ int tr_recv_all(const struct tr_socket *socket, const void *buf, const size_t le * return Pointer to a \0 terminated String * return NULL on error */ -const char *tr_ident(struct tr_socket *socket); +const char *tr_ident(struct rtr_tr_socket *socket); #endif /** @} */ diff --git a/tests/test_as_path_verification.c b/tests/test_as_path_verification.c index 52b097a4..09a085a3 100644 --- a/tests/test_as_path_verification.c +++ b/tests/test_as_path_verification.c @@ -23,7 +23,7 @@ // clang-format off -#define RECORD(cas, providers) ((struct aspa_record) { \ +#define RECORD(cas, providers) ((struct rtr_aspa_record) { \ .customer_asn = cas, \ .provider_count = (size_t)(sizeof(providers) / sizeof(uint32_t)), \ .provider_asns = sizeof(providers) == 0 ? NULL : providers \ @@ -32,48 +32,48 @@ #define ADD_OPERATION(idx, rec) ((struct aspa_update_operation) { \ .index = idx, \ .record = rec, \ - .type = ASPA_ADD, \ + .type = RTR_ASPA_ADD, \ .is_no_op = false \ }) #define BUILD_ASPA_TABLE(tablename, socketname, ...) \ - struct aspa_table *(tablename) = lrtr_malloc(sizeof(*tablename)); \ + struct rtr_aspa_table *(tablename) = rtr_malloc(sizeof(*tablename)); \ assert((tablename)); \ - aspa_table_init((tablename), NULL); \ + rtr_aspa_table_init((tablename), NULL); \ \ NEW_SOCKET_ADD_RECORDS((tablename), (socketname), __VA_ARGS__) \ #define NEW_SOCKET_ADD_RECORDS(tablename, socketname, ...) \ - struct rtr_socket *socketname = lrtr_malloc(sizeof(struct rtr_socket)); \ + struct rtr_socket *socketname = rtr_malloc(sizeof(struct rtr_socket)); \ assert(socketname); \ socketname->aspa_table = (tablename); \ { \ - struct aspa_record records[] = { __VA_ARGS__ }; \ - size_t len = sizeof(records) / sizeof(struct aspa_record); \ + struct rtr_aspa_record records[] = { __VA_ARGS__ }; \ + size_t len = sizeof(records) / sizeof(struct rtr_aspa_record); \ \ if (len) { \ struct aspa_update *update = NULL; \ struct aspa_update_operation *operations = \ - lrtr_malloc(len * sizeof(struct aspa_update_operation)); \ + rtr_malloc(len * sizeof(struct aspa_update_operation)); \ for (size_t i = 0; i < len; i++) \ operations[i] = ADD_OPERATION(i, records[i]); \ \ assert(aspa_table_update_swap_in_compute((tablename), \ (socketname), operations, len, &update) \ - == ASPA_SUCCESS); \ + == RTR_ASPA_SUCCESS); \ aspa_table_update_swap_in_apply(&update); \ } \ } #define VERIFY_AS_PATH(aspa_table, direction, expected, asns) \ - assert((expected) == aspa_verify_as_path(aspa_table, asns, sizeof(asns) / sizeof(uint32_t), direction)) \ + assert((expected) == rtr_aspa_verify_as_path(aspa_table, asns, sizeof(asns) / sizeof(uint32_t), direction)) \ -static struct aspa_table *test_create_aspa_table(void) +static struct rtr_aspa_table *test_create_aspa_table(void) { - struct aspa_table *aspa_table = lrtr_malloc(sizeof(*aspa_table)); + struct rtr_aspa_table *aspa_table = rtr_malloc(sizeof(*aspa_table)); assert(aspa_table); - aspa_table_init(aspa_table, NULL); + rtr_aspa_table_init(aspa_table, NULL); NEW_SOCKET_ADD_RECORDS(aspa_table, rtr_socket_1, RECORD(100, ASNS(200, 201)), @@ -108,7 +108,7 @@ static struct aspa_table *test_create_aspa_table(void) // clang-format on -static void test_hopping(struct aspa_table *aspa_table) +static void test_hopping(struct rtr_aspa_table *aspa_table) { // check that provider and not provider holds assert(aspa_check_hop(aspa_table, 100, 200) == ASPA_PROVIDER_PLUS); @@ -130,80 +130,82 @@ static void test_hopping(struct aspa_table *aspa_table) // - one not attested: unknown // - all attested: valid -static void test_upstream(struct aspa_table *aspa_table) +static void test_upstream(struct rtr_aspa_table *aspa_table) { // empty paths are valid - assert(aspa_verify_as_path(aspa_table, NULL, 0, ASPA_UPSTREAM) == ASPA_AS_PATH_VALID); + assert(rtr_aspa_verify_as_path(aspa_table, NULL, 0, RTR_ASPA_UPSTREAM) == RTR_ASPA_AS_PATH_VALID); // paths of length 1 are valid - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_VALID, ASNS(100)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_VALID, ASNS(100)); // valid upstream paths - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_VALID, ASNS(200, 100)); - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_VALID, ASNS(300, 200)); - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_VALID, ASNS(300, 200, 100)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_VALID, ASNS(200, 100)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_VALID, ASNS(300, 200)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_VALID, ASNS(300, 200, 100)); // single not-provider hop (nP) - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_INVALID, ASNS(999, 100)); - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_INVALID, ASNS(300, 999, 100)); - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_INVALID, ASNS(999, 999, 100)); - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_INVALID, ASNS(999, 100, 999)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_INVALID, ASNS(999, 100)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_INVALID, ASNS(300, 999, 100)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_INVALID, ASNS(999, 999, 100)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_INVALID, ASNS(999, 100, 999)); // single unattested hop (nA) - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_UNKNOWN, ASNS(999, 500, 400, 300)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_UNKNOWN, ASNS(999, 500, 400, 300)); } -static void test_downstream(struct aspa_table *aspa_table) +static void test_downstream(struct rtr_aspa_table *aspa_table) { // paths of length 1 <= N <= 2 are valid - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_VALID, ASNS(999)); - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_VALID, ASNS(998, 999)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_VALID, ASNS(999)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_VALID, ASNS(998, 999)); // either up- or down-ramp is valid, not both - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_VALID, ASNS(300, 400, 500)); - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_VALID, ASNS(500, 400, 300)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_VALID, ASNS(300, 400, 500)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_VALID, ASNS(500, 400, 300)); // w/o customer-provider gap - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_VALID, ASNS(300, 400, 500, 400, 300)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_VALID, ASNS(300, 400, 500, 400, 300)); // single not-provider (nP) in between - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_VALID, ASNS(302, 402, 502, 500, 400, 300)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_VALID, ASNS(302, 402, 502, 500, 400, 300)); // two highest-level hops are nP - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_INVALID, ASNS(301, 401, 501, 502, 502, 402, 302)); - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_UNKNOWN, ASNS(302, 402, 502, 999, 500, 400, 300)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_INVALID, + ASNS(301, 401, 501, 502, 502, 402, 302)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_UNKNOWN, + ASNS(302, 402, 502, 999, 500, 400, 300)); // single nA at highest level is valid - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_VALID, ASNS(999, 500, 400, 300)); - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_VALID, ASNS(300, 400, 500, 999)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_VALID, ASNS(999, 500, 400, 300)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_VALID, ASNS(300, 400, 500, 999)); // single nP at highest level is valid - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_VALID, ASNS(999, 502, 402, 302)); - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_VALID, ASNS(302, 402, 502, 999)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_VALID, ASNS(999, 502, 402, 302)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_VALID, ASNS(302, 402, 502, 999)); // the last hop in the down ramp must be valid - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_UNKNOWN, ASNS(999, 300, 400, 500)); - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_INVALID, ASNS(100, 300, 400, 500)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_UNKNOWN, ASNS(999, 300, 400, 500)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_INVALID, ASNS(100, 300, 400, 500)); // the first hop in the up ramp must be valid - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_UNKNOWN, ASNS(500, 400, 300, 999)); - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_INVALID, ASNS(500, 400, 300, 100)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_UNKNOWN, ASNS(500, 400, 300, 999)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_INVALID, ASNS(500, 400, 300, 100)); // consecutive up-ramps are invalid - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_INVALID, ASNS(400, 300, 200, 502, 402, 302)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_INVALID, ASNS(400, 300, 200, 502, 402, 302)); // consecutive down-ramps are invalid - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_INVALID, ASNS(200, 300, 400, 302, 402, 502)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_INVALID, ASNS(200, 300, 400, 302, 402, 502)); // both down- and up-ramp are invalid - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_INVALID, ASNS(400, 300, 200, 302, 402, 502)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_INVALID, ASNS(400, 300, 200, 302, 402, 502)); // overlapping customer-provider-relationships // 103 --> 203 <--> 303 <--> 403 <-- 304 - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_VALID, ASNS(304, 403, 303, 203, 103)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_VALID, ASNS(304, 403, 303, 203, 103)); - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_UNKNOWN, ASNS(20, 30, 90, 40, 70, 80)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_UNKNOWN, ASNS(20, 30, 90, 40, 70, 80)); } // clang-format off @@ -231,12 +233,12 @@ static void test_verify_example_1(void) RECORD(20, ASNS(30)), ) - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_VALID, + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_VALID, ASNS(20, 30, 40, 70, 80)); - aspa_table_free(aspa_table, false); - lrtr_free(aspa_table); - lrtr_free(rtr_socket); + rtr_aspa_table_free(aspa_table, false); + rtr_free(aspa_table); + rtr_free(rtr_socket); } /** @@ -264,12 +266,12 @@ static void test_verify_example_2(void) RECORD(90, ASNS(30, 40)), ) - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_UNKNOWN, + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_UNKNOWN, ASNS(20, 30, 90, 40, 70, 80)); - aspa_table_free(aspa_table, false); - lrtr_free(aspa_table); - lrtr_free(rtr_socket); + rtr_aspa_table_free(aspa_table, false); + rtr_free(aspa_table); + rtr_free(rtr_socket); } /** @@ -301,12 +303,12 @@ static void test_verify_example_2b(void) RECORD(40, ASNS()), ) - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_INVALID, + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_INVALID, ASNS(20, 30, 90, 40, 70, 80)); - aspa_table_free(aspa_table, false); - lrtr_free(aspa_table); - lrtr_free(rtr_socket); + rtr_aspa_table_free(aspa_table, false); + rtr_free(aspa_table); + rtr_free(rtr_socket); } /** @@ -332,12 +334,12 @@ static void test_verify_example_3a(void) RECORD(20, ASNS(30)), ) - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_UNKNOWN, + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_UNKNOWN, ASNS(20, 30, 90, 40, 70, 80)); - aspa_table_free(aspa_table, false); - lrtr_free(aspa_table); - lrtr_free(rtr_socket); + rtr_aspa_table_free(aspa_table, false); + rtr_free(aspa_table); + rtr_free(rtr_socket); } /** @@ -363,12 +365,12 @@ static void test_verify_example_3b(void) RECORD(20, ASNS(30)), ) - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_UNKNOWN, + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_UNKNOWN, ASNS(20, 30, 90, 100, 40, 70, 80)); - aspa_table_free(aspa_table, false); - lrtr_free(aspa_table); - lrtr_free(rtr_socket); + rtr_aspa_table_free(aspa_table, false); + rtr_free(aspa_table); + rtr_free(rtr_socket); } /** @@ -398,12 +400,12 @@ static void test_verify_example_3c(void) RECORD(40, ASNS()), ) - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_INVALID, + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_INVALID, ASNS(20, 30, 90, 100, 40, 70, 80)); - aspa_table_free(aspa_table, false); - lrtr_free(aspa_table); - lrtr_free(rtr_socket); + rtr_aspa_table_free(aspa_table, false); + rtr_free(aspa_table); + rtr_free(rtr_socket); } /** @@ -433,12 +435,12 @@ static void test_verify_example_3d(void) RECORD(40, ASNS()), ) - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_UNKNOWN, + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_UNKNOWN, ASNS(20, 30, 40, 100, 90, 70, 80)); - aspa_table_free(aspa_table, false); - lrtr_free(aspa_table); - lrtr_free(rtr_socket); + rtr_aspa_table_free(aspa_table, false); + rtr_free(aspa_table); + rtr_free(rtr_socket); } /** @@ -468,12 +470,12 @@ static void test_verify_example_3f(void) RECORD(40, ASNS()), ) - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_UNKNOWN, + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_UNKNOWN, ASNS(20, 30, 40, 100, 90, 70, 80)); - aspa_table_free(aspa_table, false); - lrtr_free(aspa_table); - lrtr_free(rtr_socket); + rtr_aspa_table_free(aspa_table, false); + rtr_free(aspa_table); + rtr_free(rtr_socket); } /** @@ -494,12 +496,12 @@ static void test_verify_example_4(void) RECORD(70, ASNS(80)), ) - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_INVALID, + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_INVALID, ASNS(20, 30, 40, 50, 60, 70, 80)); - aspa_table_free(aspa_table, false); - lrtr_free(aspa_table); - lrtr_free(rtr_socket); + rtr_aspa_table_free(aspa_table, false); + rtr_free(aspa_table); + rtr_free(rtr_socket); } /** @@ -525,12 +527,12 @@ static void test_verify_example_4_fixed(void) RECORD(30, ASNS(20)), ) - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_INVALID, + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_INVALID, ASNS(20, 30, 40, 50, 60, 70, 80)); - aspa_table_free(aspa_table, false); - lrtr_free(aspa_table); - lrtr_free(rtr_socket); + rtr_aspa_table_free(aspa_table, false); + rtr_free(aspa_table); + rtr_free(rtr_socket); } /** @@ -554,12 +556,12 @@ static void test_verify_example_5(void) RECORD(30, ASNS(20)), ) - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_VALID, + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_VALID, ASNS(20, 30, 40)); - aspa_table_free(aspa_table, false); - lrtr_free(aspa_table); - lrtr_free(rtr_socket); + rtr_aspa_table_free(aspa_table, false); + rtr_free(aspa_table); + rtr_free(rtr_socket); } /** @@ -598,12 +600,12 @@ static void test_verify_example_6(void) RECORD(20, ASNS(30)), ) - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_UNKNOWN, + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_UNKNOWN, ASNS(20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120)); - aspa_table_free(aspa_table, false); - lrtr_free(aspa_table); - lrtr_free(rtr_socket); + rtr_aspa_table_free(aspa_table, false); + rtr_free(aspa_table); + rtr_free(rtr_socket); } /** @@ -648,12 +650,12 @@ static void test_verify_example_7(void) RECORD(140, ASNS(130)), ) - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_UNKNOWN, + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_UNKNOWN, ASNS(20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140)); - aspa_table_free(aspa_table, false); - lrtr_free(aspa_table); - lrtr_free(rtr_socket); + rtr_aspa_table_free(aspa_table, false); + rtr_free(aspa_table); + rtr_free(rtr_socket); } /** @@ -673,12 +675,12 @@ static void test_verify_example_8(void) BUILD_ASPA_TABLE(aspa_table, rtr_socket, ) - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_VALID, + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_VALID, ASNS(20)); - aspa_table_free(aspa_table, false); - lrtr_free(aspa_table); - lrtr_free(rtr_socket); + rtr_aspa_table_free(aspa_table, false); + rtr_free(aspa_table); + rtr_free(rtr_socket); } /** @@ -698,12 +700,12 @@ static void test_verify_example_9(void) BUILD_ASPA_TABLE(aspa_table, rtr_socket, ) - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_VALID, + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_VALID, ASNS(20)); - aspa_table_free(aspa_table, false); - lrtr_free(aspa_table); - lrtr_free(rtr_socket); + rtr_aspa_table_free(aspa_table, false); + rtr_free(aspa_table); + rtr_free(rtr_socket); } /** @@ -725,12 +727,12 @@ static void test_verify_example_11(void) RECORD(30, ASNS()), ) - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_VALID, + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_VALID, ASNS(20, 30)); - aspa_table_free(aspa_table, false); - lrtr_free(aspa_table); - lrtr_free(rtr_socket); + rtr_aspa_table_free(aspa_table, false); + rtr_free(aspa_table); + rtr_free(rtr_socket); } /** @@ -749,12 +751,12 @@ static void test_verify_example_12(void) BUILD_ASPA_TABLE(aspa_table, rtr_socket, ) - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_UNKNOWN, + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_UNKNOWN, ASNS(20, 30)); - aspa_table_free(aspa_table, false); - lrtr_free(aspa_table); - lrtr_free(rtr_socket); + rtr_aspa_table_free(aspa_table, false); + rtr_free(aspa_table); + rtr_free(rtr_socket); } /** @@ -785,12 +787,12 @@ static void test_verify_example_13(void) RECORD(20, ASNS()), ) - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_INVALID, + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_INVALID, ASNS(20, 30, 40, 50, 60)); - aspa_table_free(aspa_table, false); - lrtr_free(aspa_table); - lrtr_free(rtr_socket); + rtr_aspa_table_free(aspa_table, false); + rtr_free(aspa_table); + rtr_free(rtr_socket); } /** @@ -819,12 +821,12 @@ static void test_verify_example_14(void) RECORD(20, ASNS(30)), ) - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_INVALID, + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_INVALID, ASNS(20, 30, 40, 50, 60)); - aspa_table_free(aspa_table, false); - lrtr_free(aspa_table); - lrtr_free(rtr_socket); + rtr_aspa_table_free(aspa_table, false); + rtr_free(aspa_table); + rtr_free(rtr_socket); } /** @@ -853,12 +855,12 @@ static void test_verify_example_15(void) RECORD(20, ASNS(30)), ) - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_INVALID, + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_INVALID, ASNS(20, 30, 40, 50, 60)); - aspa_table_free(aspa_table, false); - lrtr_free(aspa_table); - lrtr_free(rtr_socket); + rtr_aspa_table_free(aspa_table, false); + rtr_free(aspa_table); + rtr_free(rtr_socket); } /** @@ -883,12 +885,12 @@ static void test_verify_example_16(void) RECORD(40, ASNS(30)), ) - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_INVALID, + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_INVALID, ASNS(10, 20, 30, 40)); - aspa_table_free(aspa_table, false); - lrtr_free(aspa_table); - lrtr_free(rtr_socket); + rtr_aspa_table_free(aspa_table, false); + rtr_free(aspa_table); + rtr_free(rtr_socket); } /** @@ -916,12 +918,12 @@ static void test_verify_example_17(void) RECORD(50, ASNS(40)), ) - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_INVALID, + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_INVALID, ASNS(10, 20, 30, 40)); - aspa_table_free(aspa_table, false); - lrtr_free(aspa_table); - lrtr_free(rtr_socket); + rtr_aspa_table_free(aspa_table, false); + rtr_free(aspa_table); + rtr_free(rtr_socket); } /** @@ -941,12 +943,12 @@ static void test_verify_example_18(void) RECORD(20, ASNS()), ) - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_INVALID, + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_INVALID, ASNS(30, 20, 40)); - aspa_table_free(aspa_table, false); - lrtr_free(aspa_table); - lrtr_free(rtr_socket); + rtr_aspa_table_free(aspa_table, false); + rtr_free(aspa_table); + rtr_free(rtr_socket); } @@ -960,38 +962,37 @@ static void test_sriram_example_19(void) RECORD(7, ASNS(0)) ) - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_VALID, ASNS(6, 3, 1)); - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_INVALID, ASNS(4, 3, 1)); - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_UNKNOWN, ASNS(4, 6, 3, 1)); - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_UNKNOWN, ASNS(4, 5, 2)); - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_INVALID, ASNS(1, 4, 5, 2)); - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_INVALID, ASNS(1, 4, 7, 5, 2)); - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_INVALID, ASNS(1, 3, 6)); - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_INVALID, ASNS(1, 3, 6, 7)); - VERIFY_AS_PATH(aspa_table, ASPA_UPSTREAM, ASPA_AS_PATH_VALID, ASNS(5, 2)); - - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_UNKNOWN , ASNS(5, 7, 6, 3, 1)); - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_VALID , ASNS(5, 7, 4, 1)); - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_UNKNOWN , ASNS(5, 4, 3, 1)); - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_INVALID , ASNS(5, 7, 4, 3, 1)); - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_UNKNOWN , ASNS(3, 6, 4, 7)); - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_VALID , ASNS(4, 7, 5, 2)); - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_INVALID , ASNS(3, 4, 7, 5, 2)); - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_VALID , ASNS(6, 3, 1)); - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_VALID , ASNS(5, 1)); - VERIFY_AS_PATH(aspa_table, ASPA_DOWNSTREAM, ASPA_AS_PATH_VALID , ASNS(5, 3, 1)); - - aspa_table_free(aspa_table, false); - lrtr_free(aspa_table); - lrtr_free(rtr_socket); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_VALID, ASNS(6, 3, 1)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_INVALID, ASNS(4, 3, 1)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_UNKNOWN, ASNS(4, 6, 3, 1)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_UNKNOWN, ASNS(4, 5, 2)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_INVALID, ASNS(1, 4, 5, 2)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_INVALID, ASNS(1, 4, 7, 5, 2)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_INVALID, ASNS(1, 3, 6)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_INVALID, ASNS(1, 3, 6, 7)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_UPSTREAM, RTR_ASPA_AS_PATH_VALID, ASNS(5, 2)); + + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_UNKNOWN , ASNS(5, 7, 6, 3, 1)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_VALID , ASNS(5, 7, 4, 1)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_UNKNOWN , ASNS(5, 4, 3, 1)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_INVALID , ASNS(5, 7, 4, 3, 1)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_UNKNOWN , ASNS(3, 6, 4, 7)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_VALID , ASNS(4, 7, 5, 2)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_INVALID , ASNS(3, 4, 7, 5, 2)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_VALID , ASNS(6, 3, 1)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_VALID , ASNS(5, 1)); + VERIFY_AS_PATH(aspa_table, RTR_ASPA_DOWNSTREAM, RTR_ASPA_AS_PATH_VALID , ASNS(5, 3, 1)); + + rtr_aspa_table_free(aspa_table, false); + rtr_free(aspa_table); + rtr_free(rtr_socket); } - // clang-format on static void test_single_collapse(uint32_t input[], size_t input_len, uint32_t output[], size_t output_len) { - size_t retlen = aspa_collapse_as_path(input, input_len); + size_t retlen = rtr_aspa_collapse_as_path(input, input_len); assert(retlen == output_len); @@ -1014,16 +1015,16 @@ static void test_collapse(void) int main(void) { - struct aspa_table *aspa_table = test_create_aspa_table(); + struct rtr_aspa_table *aspa_table = test_create_aspa_table(); test_hopping(aspa_table); test_upstream(aspa_table); test_downstream(aspa_table); - lrtr_free(aspa_table->store->next->rtr_socket); - lrtr_free(aspa_table->store->rtr_socket); - aspa_table_free(aspa_table, false); - lrtr_free(aspa_table); + rtr_free(aspa_table->store->next->rtr_socket); + rtr_free(aspa_table->store->rtr_socket); + rtr_aspa_table_free(aspa_table, false); + rtr_free(aspa_table); test_verify_example_1(); test_verify_example_2(); diff --git a/tests/test_aspa.c b/tests/test_aspa.c index d134dda1..bc1c627c 100644 --- a/tests/test_aspa.c +++ b/tests/test_aspa.c @@ -43,17 +43,17 @@ size_t expected_error_pdus_index; size_t expected_error_pdus_count; struct update_callback { - struct aspa_table *source; - struct aspa_record record; - enum aspa_operation_type type; + struct rtr_aspa_table *source; + struct rtr_aspa_record record; + enum rtr_aspa_operation_type type; }; struct sent_pdu { uint16_t error_code; }; -#define BYTES16(X) lrtr_convert_short(TO_HOST_HOST_BYTE_ORDER, X) -#define BYTES32(X) lrtr_convert_long(TO_HOST_HOST_BYTE_ORDER, X) +#define BYTES16(X) rtr_convert_short(TO_HOST_HOST_BYTE_ORDER, X) +#define BYTES32(X) rtr_convert_long(TO_HOST_HOST_BYTE_ORDER, X) #define ASNS(...) ((uint32_t[]){__VA_ARGS__}) @@ -64,7 +64,7 @@ struct sent_pdu { (size_t)(sizeof(providers) / sizeof(uint32_t))) #define RECORD(cas, providers) \ - ((struct aspa_record){.customer_asn = cas, \ + ((struct rtr_aspa_record){.customer_asn = cas, \ .provider_count = (size_t)(sizeof(providers) / sizeof(uint32_t)), \ .provider_asns = sizeof(providers) == 0 ? NULL : providers}) @@ -73,18 +73,18 @@ struct sent_pdu { #define _LINEVAR(V) _CAT(V, __LINE__) #define ASSERT_TABLE(socket, ...) \ - struct aspa_record _LINEVAR(_records)[] = {__VA_ARGS__}; \ - assert_table(socket, _LINEVAR(_records), (size_t)(sizeof(_LINEVAR(_records)) / sizeof(struct aspa_record))) + struct rtr_aspa_record _LINEVAR(_records)[] = {__VA_ARGS__}; \ + assert_table(socket, _LINEVAR(_records), (size_t)(sizeof(_LINEVAR(_records)) / sizeof(struct rtr_aspa_record))) #define ASSERT_EMPTY_TABLE(socket) assert_table(socket, NULL, 0) -#define ADDED(rec) ((struct update_callback){.source = NULL, .record = rec, .type = ASPA_ADD}) +#define ADDED(rec) ((struct update_callback){.source = NULL, .record = rec, .type = RTR_ASPA_ADD}) -#define ADDED_TO(table, rec) ((struct update_callback){.source = table, .record = rec, .type = ASPA_ADD}) +#define ADDED_TO(table, rec) ((struct update_callback){.source = table, .record = rec, .type = RTR_ASPA_ADD}) -#define REMOVED(rec) ((struct update_callback){.source = NULL, .record = rec, .type = ASPA_REMOVE}) +#define REMOVED(rec) ((struct update_callback){.source = NULL, .record = rec, .type = RTR_ASPA_REMOVE}) -#define REMOVED_FROM(table, rec) ((struct update_callback){.source = table, .record = rec, .type = ASPA_REMOVE}) +#define REMOVED_FROM(table, rec) ((struct update_callback){.source = table, .record = rec, .type = RTR_ASPA_REMOVE}) #define EXPECT_UPDATE_CALLBACKS(...) \ struct update_callback _LINEVAR(_callbacks)[] = {__VA_ARGS__}; \ @@ -108,7 +108,7 @@ struct sent_pdu { #define ASPA_ANNOUNCE 1 #define ASPA_WITHDRAW 0 -static int custom_send(const struct tr_socket *socket __attribute__((unused)), const void *pdu, const size_t len, +static int custom_send(const struct rtr_tr_socket *socket __attribute__((unused)), const void *pdu, const size_t len, const time_t timeout __attribute__((unused))) { const struct pdu_error *err = pdu; @@ -129,7 +129,7 @@ static int custom_send(const struct tr_socket *socket __attribute__((unused)), c return len; } -static int custom_recv(const struct tr_socket *socket __attribute__((unused)), const void *buf, const size_t len, +static int custom_recv(const struct rtr_tr_socket *socket __attribute__((unused)), const void *buf, const size_t len, const time_t timeout __attribute__((unused))) { size_t rlen = len; @@ -145,9 +145,9 @@ static int custom_recv(const struct tr_socket *socket __attribute__((unused)), c static struct pdu_cache_response *begin_cache_response(uint8_t version, uint16_t session_id) { if (!data) - data = lrtr_malloc(sizeof(struct pdu_cache_response)); + data = rtr_malloc(sizeof(struct pdu_cache_response)); else - data = lrtr_realloc(data, data_size + sizeof(struct pdu_cache_response)); + data = rtr_realloc(data, data_size + sizeof(struct pdu_cache_response)); assert(data); @@ -168,7 +168,7 @@ static struct pdu_aspa *append_aspa(uint8_t version, uint8_t flags, uint32_t cus { size_t pdu_size = sizeof(struct pdu_aspa) + sizeof(uint32_t) * provider_count; - data = lrtr_realloc(data, data_size + pdu_size); + data = rtr_realloc(data, data_size + pdu_size); assert(data); struct pdu_aspa *aspa = (struct pdu_aspa *)(data + data_size); @@ -193,7 +193,7 @@ static struct pdu_aspa *append_aspa(uint8_t version, uint8_t flags, uint32_t cus static struct pdu_end_of_data_v1_v2 *end_cache_response(uint8_t version, uint16_t session_id, uint32_t sn) { - data = lrtr_realloc(data, data_size + sizeof(struct pdu_end_of_data_v1_v2)); + data = rtr_realloc(data, data_size + sizeof(struct pdu_end_of_data_v1_v2)); assert(data); struct pdu_end_of_data_v1_v2 *eod = (struct pdu_end_of_data_v1_v2 *)(data + data_size); @@ -244,9 +244,9 @@ static void clear_expected_sent_pdus(void) expected_error_pdus_count = 0; } -static void aspa_update_callback(struct aspa_table *s, const struct aspa_record record, +static void aspa_update_callback(struct rtr_aspa_table *s, const struct rtr_aspa_record record, const struct rtr_socket *rtr_sockt __attribute__((unused)), - const enum aspa_operation_type operation_type) + const enum rtr_aspa_operation_type operation_type) { if (assert_callbacks) { assert(callback_count > 0); @@ -278,10 +278,10 @@ static void aspa_update_callback(struct aspa_table *s, const struct aspa_record char c; switch (operation_type) { - case ASPA_ADD: + case RTR_ASPA_ADD: c = '+'; break; - case ASPA_REMOVE: + case RTR_ASPA_REMOVE: c = '-'; break; default: @@ -302,10 +302,10 @@ static void aspa_update_callback(struct aspa_table *s, const struct aspa_record } printf(" ]\n"); - lrtr_free(record.provider_asns); + rtr_free(record.provider_asns); } -static void assert_table(struct rtr_socket *socket, struct aspa_record records[], size_t record_count) +static void assert_table(struct rtr_socket *socket, struct rtr_aspa_record records[], size_t record_count) { assert(socket); assert(socket->aspa_table); @@ -733,11 +733,11 @@ static void test_regular_swap(struct rtr_socket *socket) RECORD(3300, ASNS(3301, 3302, 3303, 3304)), ); - struct aspa_table *src_table = socket->aspa_table; - struct aspa_table *dst_table = lrtr_malloc(sizeof(struct aspa_table)); + struct rtr_aspa_table *src_table = socket->aspa_table; + struct rtr_aspa_table *dst_table = rtr_malloc(sizeof(struct rtr_aspa_table)); assert(dst_table); - aspa_table_init(dst_table, aspa_update_callback); + rtr_aspa_table_init(dst_table, aspa_update_callback); socket->aspa_table = dst_table; printf("creating existing data, soon to be overwritten...\n"); @@ -783,12 +783,12 @@ static void test_regular_swap(struct rtr_socket *socket) ); EXPECT_NO_ERROR_PDUS_SENT(); - assert(aspa_table_src_replace(dst_table, src_table, socket, true, true) == ASPA_SUCCESS); + assert(aspa_table_src_replace(dst_table, src_table, socket, true, true) == RTR_ASPA_SUCCESS); assert(callback_index == callback_count); assert(expected_error_pdus_index == expected_error_pdus_count); - aspa_table_free(dst_table, false); - lrtr_free(dst_table); + rtr_aspa_table_free(dst_table, false); + rtr_free(dst_table); } static void test_withdraw_twice(struct rtr_socket *socket) @@ -978,11 +978,11 @@ static void test_multiple_syncs(struct rtr_socket *socket) // build array of all records expected to be in aspa_table // (customer asns after last withdrawn until including last announced) size_t record_count = c_wd + 2; - struct aspa_record records[record_count]; + struct rtr_aspa_record records[record_count]; for (size_t c_ex = c_wd + 1; c_ex <= c_an + 1; c_ex++) { records[c_ex - (c_wd + 1)] = - ((struct aspa_record) { + ((struct rtr_aspa_record) { .customer_asn = (uint32_t)c_ex, .provider_count = PROVIDER_COUNT, .provider_asns = &provider_asns[PROVIDER_COUNT * (c_ex - 2)] @@ -1013,12 +1013,12 @@ static void test_many_pdus(struct rtr_socket *socket) end_cache_response(RTR_PROTOCOL_VERSION_2, 0, 437); // records to verify aspa_table - struct aspa_record records[N]; + struct rtr_aspa_record records[N]; // callbacks struct update_callback callbacks[N]; for (size_t i = 0; i < N; i++) { - records[i] = (struct aspa_record){ + records[i] = (struct rtr_aspa_record){ .customer_asn = i + 1, .provider_count = PROVIDER_COUNT, .provider_asns = &provider_asns[i] @@ -1026,7 +1026,7 @@ static void test_many_pdus(struct rtr_socket *socket) callbacks[i] = (struct update_callback){ .source = NULL, .record = records[i], - .type = ASPA_ADD + .type = RTR_ASPA_ADD }; } @@ -1218,7 +1218,7 @@ static void cleanup(struct rtr_socket **socket) printf("cleaning...\n"); if (data) { - lrtr_free(data); + rtr_free(data); data = NULL; data_size = 0; data_index = 0; @@ -1226,24 +1226,24 @@ static void cleanup(struct rtr_socket **socket) if (socket && *socket) { if ((*socket)->aspa_table) { - aspa_table_free((*socket)->aspa_table, false); - lrtr_free((*socket)->aspa_table); + rtr_aspa_table_free((*socket)->aspa_table, false); + rtr_free((*socket)->aspa_table); } if ((*socket)->spki_table) { spki_table_free_without_notify((*socket)->spki_table); - lrtr_free((*socket)->spki_table); + rtr_free((*socket)->spki_table); } if ((*socket)->pfx_table) { pfx_table_free_without_notify((*socket)->pfx_table); - lrtr_free((*socket)->pfx_table); + rtr_free((*socket)->pfx_table); } if ((*socket)->tr_socket) - lrtr_free((*socket)->tr_socket); + rtr_free((*socket)->tr_socket); - lrtr_free(*socket); + rtr_free(*socket); *socket = NULL; } @@ -1253,12 +1253,12 @@ static void cleanup(struct rtr_socket **socket) static struct rtr_socket *create_socket(bool is_resetting) { - struct tr_socket *tr_socket = lrtr_calloc(1, sizeof(struct tr_socket)); + struct rtr_tr_socket *tr_socket = rtr_calloc(1, sizeof(struct rtr_tr_socket)); tr_socket->recv_fp = (tr_recv_fp)&custom_recv; tr_socket->send_fp = (tr_send_fp)&custom_send; - struct rtr_socket *socket = lrtr_calloc(1, sizeof(struct rtr_socket)); + struct rtr_socket *socket = rtr_calloc(1, sizeof(struct rtr_socket)); assert(socket); socket->is_resetting = is_resetting; @@ -1266,20 +1266,20 @@ static struct rtr_socket *create_socket(bool is_resetting) socket->state = RTR_SYNC; socket->tr_socket = tr_socket; - struct aspa_table *aspa_table = lrtr_malloc(sizeof(struct aspa_table)); + struct rtr_aspa_table *aspa_table = rtr_malloc(sizeof(struct rtr_aspa_table)); assert(aspa_table); - aspa_table_init(aspa_table, aspa_update_callback); + rtr_aspa_table_init(aspa_table, aspa_update_callback); socket->aspa_table = aspa_table; - struct spki_table *spki_table = lrtr_malloc(sizeof(struct spki_table)); + struct rtr_spki_table *spki_table = rtr_malloc(sizeof(struct rtr_spki_table)); spki_table_init(spki_table, NULL); socket->spki_table = spki_table; - struct pfx_table *pfx_table = lrtr_malloc(sizeof(struct pfx_table)); + struct rtr_pfx_table *pfx_table = rtr_malloc(sizeof(struct rtr_pfx_table)); - pfx_table_init(pfx_table, NULL); + rtr_pfx_table_init(pfx_table, NULL); socket->pfx_table = pfx_table; return socket; diff --git a/tests/test_aspa_array.c b/tests/test_aspa_array.c index 5e9dd5d6..7e2530a8 100644 --- a/tests/test_aspa_array.c +++ b/tests/test_aspa_array.c @@ -20,7 +20,7 @@ // clang-format off #define RECORD(cas, providers) \ - ((struct aspa_record){.customer_asn = cas, \ + ((struct rtr_aspa_record){.customer_asn = cas, \ .provider_count = (size_t)(sizeof(providers) / sizeof(uint32_t)), \ .provider_asns = sizeof(providers) == 0 ? NULL : providers}) @@ -30,7 +30,7 @@ static void test_create_array(void) { struct aspa_array *array; - assert(aspa_array_create(&array) == ASPA_SUCCESS); + assert(aspa_array_create(&array) == RTR_ASPA_SUCCESS); assert(array->data); assert(array->size == 0); assert(array->capacity >= 128); @@ -42,9 +42,9 @@ static void test_add_element(void) { struct aspa_array *array; - assert(aspa_array_create(&array) == ASPA_SUCCESS); + assert(aspa_array_create(&array) == RTR_ASPA_SUCCESS); - struct aspa_record record = RECORD(42, SEEDED_ASNS(300)); + struct rtr_aspa_record record = RECORD(42, SEEDED_ASNS(300)); assert(aspa_array_insert(array, 0, &record, true) == 0); assert(array->data[0].customer_asn == 42); @@ -60,26 +60,26 @@ static void test_insert(void) { struct aspa_array *array; - assert(aspa_array_create(&array) == ASPA_SUCCESS); + assert(aspa_array_create(&array) == RTR_ASPA_SUCCESS); array->capacity = 2; - struct aspa_record *old_pointer = array->data; + struct rtr_aspa_record *old_pointer = array->data; - struct aspa_record record_4 = RECORD(4, SEEDED_ASNS(600)); + struct rtr_aspa_record record_4 = RECORD(4, SEEDED_ASNS(600)); - assert(aspa_array_insert(array, 0, &record_4, true) == ASPA_SUCCESS); + assert(aspa_array_insert(array, 0, &record_4, true) == RTR_ASPA_SUCCESS); - struct aspa_record record_1 = RECORD(1, SEEDED_ASNS(300)); + struct rtr_aspa_record record_1 = RECORD(1, SEEDED_ASNS(300)); - assert(aspa_array_insert(array, 1, &record_1, true) == ASPA_SUCCESS); + assert(aspa_array_insert(array, 1, &record_1, true) == RTR_ASPA_SUCCESS); - struct aspa_record record_2 = RECORD(2, SEEDED_ASNS(400)); + struct rtr_aspa_record record_2 = RECORD(2, SEEDED_ASNS(400)); // Verify shifting works - assert(aspa_array_insert(array, 1, &record_2, true) == ASPA_SUCCESS); + assert(aspa_array_insert(array, 1, &record_2, true) == RTR_ASPA_SUCCESS); - struct aspa_record record_3 = RECORD(3, SEEDED_ASNS(500)); + struct rtr_aspa_record record_3 = RECORD(3, SEEDED_ASNS(500)); - assert(aspa_array_insert(array, 3, &record_3, true) == ASPA_SUCCESS); + assert(aspa_array_insert(array, 3, &record_3, true) == RTR_ASPA_SUCCESS); assert(old_pointer == array->data); assert(array->capacity >= 4); @@ -97,25 +97,25 @@ static void test_append(void) { struct aspa_array *array; - assert(aspa_array_create(&array) == ASPA_SUCCESS); + assert(aspa_array_create(&array) == RTR_ASPA_SUCCESS); array->capacity = 2; - struct aspa_record *old_pointer = array->data; + struct rtr_aspa_record *old_pointer = array->data; - struct aspa_record record_4 = RECORD(4, SEEDED_ASNS(600)); + struct rtr_aspa_record record_4 = RECORD(4, SEEDED_ASNS(600)); - assert(aspa_array_append(array, &record_4, true) == ASPA_SUCCESS); + assert(aspa_array_append(array, &record_4, true) == RTR_ASPA_SUCCESS); - struct aspa_record record_2 = RECORD(2, SEEDED_ASNS(400)); + struct rtr_aspa_record record_2 = RECORD(2, SEEDED_ASNS(400)); - assert(aspa_array_append(array, &record_2, true) == ASPA_SUCCESS); + assert(aspa_array_append(array, &record_2, true) == RTR_ASPA_SUCCESS); - struct aspa_record record_1 = RECORD(1, SEEDED_ASNS(300)); + struct rtr_aspa_record record_1 = RECORD(1, SEEDED_ASNS(300)); - assert(aspa_array_append(array, &record_1, true) == ASPA_SUCCESS); + assert(aspa_array_append(array, &record_1, true) == RTR_ASPA_SUCCESS); - struct aspa_record record_3 = RECORD(3, SEEDED_ASNS(500)); + struct rtr_aspa_record record_3 = RECORD(3, SEEDED_ASNS(500)); - assert(aspa_array_append(array, &record_3, true) == ASPA_SUCCESS); + assert(aspa_array_append(array, &record_3, true) == RTR_ASPA_SUCCESS); assert(old_pointer == array->data); assert(array->capacity >= 4); @@ -135,26 +135,26 @@ static void test_remove_element(void) assert(aspa_array_create(&array) == 0); - struct aspa_record record_1 = RECORD(1, SEEDED_ASNS(300)); + struct rtr_aspa_record record_1 = RECORD(1, SEEDED_ASNS(300)); - assert(aspa_array_insert(array, 0, &record_1, true) == ASPA_SUCCESS); + assert(aspa_array_insert(array, 0, &record_1, true) == RTR_ASPA_SUCCESS); - struct aspa_record record_2 = RECORD(2, SEEDED_ASNS(400)); + struct rtr_aspa_record record_2 = RECORD(2, SEEDED_ASNS(400)); - assert(aspa_array_insert(array, 1, &record_2, true) == ASPA_SUCCESS); + assert(aspa_array_insert(array, 1, &record_2, true) == RTR_ASPA_SUCCESS); - struct aspa_record record_3 = RECORD(3, SEEDED_ASNS(500)); + struct rtr_aspa_record record_3 = RECORD(3, SEEDED_ASNS(500)); - assert(aspa_array_insert(array, 2, &record_3, true) == ASPA_SUCCESS); + assert(aspa_array_insert(array, 2, &record_3, true) == RTR_ASPA_SUCCESS); - struct aspa_record record_4 = RECORD(4, SEEDED_ASNS(600)); + struct rtr_aspa_record record_4 = RECORD(4, SEEDED_ASNS(600)); - assert(aspa_array_insert(array, 3, &record_4, true) == ASPA_SUCCESS); + assert(aspa_array_insert(array, 3, &record_4, true) == RTR_ASPA_SUCCESS); assert(array->data[2].customer_asn == 3); - assert(aspa_array_remove(array, 2, true) == ASPA_SUCCESS); - assert(aspa_array_remove(array, 100, true) == ASPA_RECORD_NOT_FOUND); + assert(aspa_array_remove(array, 2, true) == RTR_ASPA_SUCCESS); + assert(aspa_array_remove(array, 100, true) == RTR_ASPA_RECORD_NOT_FOUND); assert(array->size == 3); assert(array->data[0].customer_asn == 1); @@ -170,23 +170,23 @@ static void test_find_element(void) assert(aspa_array_create(&array) == 0); - struct aspa_record record_1 = RECORD(1, SEEDED_ASNS(300)); + struct rtr_aspa_record record_1 = RECORD(1, SEEDED_ASNS(300)); assert(aspa_array_insert(array, 0, &record_1, true) == 0); - struct aspa_record record_2 = RECORD(2, SEEDED_ASNS(400)); + struct rtr_aspa_record record_2 = RECORD(2, SEEDED_ASNS(400)); assert(aspa_array_insert(array, 1, &record_2, true) == 0); - struct aspa_record record_3 = RECORD(3, SEEDED_ASNS(500)); + struct rtr_aspa_record record_3 = RECORD(3, SEEDED_ASNS(500)); assert(aspa_array_insert(array, 2, &record_3, true) == 0); - struct aspa_record record_4 = RECORD(4, SEEDED_ASNS(600)); + struct rtr_aspa_record record_4 = RECORD(4, SEEDED_ASNS(600)); assert(aspa_array_insert(array, 3, &record_4, true) == 0); - struct aspa_record record_5 = RECORD(5, SEEDED_ASNS(700)); + struct rtr_aspa_record record_5 = RECORD(5, SEEDED_ASNS(700)); assert(aspa_array_insert(array, 4, &record_5, true) == 0); diff --git a/tests/test_bgpsec.c b/tests/test_bgpsec.c index 9ec32e10..5b7c733b 100644 --- a/tests/test_bgpsec.c +++ b/tests/test_bgpsec.c @@ -78,9 +78,9 @@ static uint8_t wrong_private_key[] = { 0x95, 0xEE, 0x50, 0xBC, 0x4F, 0x75, 0xD2, 0x05, 0xA2, 0x5B, 0xD3, 0x6F, 0xF5}; /* Helper function to create a spki_record */ -static struct spki_record *create_record(int ASN, uint8_t *ski, uint8_t *spki) +static struct rtr_spki_record *create_record(int ASN, uint8_t *ski, uint8_t *spki) { - struct spki_record *record = malloc(sizeof(struct spki_record)); + struct rtr_spki_record *record = malloc(sizeof(struct rtr_spki_record)); memset(record, 0, sizeof(*record)); record->asn = ASN; @@ -99,10 +99,10 @@ static void validate_bgpsec_path_test(void) struct rtr_bgpsec_nlri *pfx = NULL; int pfx_int = 0; - struct spki_table table; - struct spki_record *record1; - struct spki_record *record2; - struct spki_record *duplicate_record; + struct rtr_spki_table table; + struct rtr_spki_record *record1; + struct rtr_spki_record *record2; + struct rtr_spki_record *duplicate_record; enum rtr_bgpsec_rtvals result; @@ -117,7 +117,7 @@ static void validate_bgpsec_path_test(void) pfx = rtr_mgr_bgpsec_nlri_new(3); assert(pfx != NULL); pfx->nlri_len = 24; - pfx->afi = 1; /* LRTR_IPV4 */ + pfx->afi = 1; /* RTR_IPV4 */ pfx_int = htonl(3221225984); /* 192.0.2.0 */ memcpy(pfx->nlri, &pfx_int, 3); @@ -222,9 +222,9 @@ static void generate_signature_test(void) struct rtr_bgpsec_nlri *pfx = NULL; int pfx_int = 0; - struct spki_table table; - struct spki_record *record1; - struct spki_record *record2; + struct rtr_spki_table table; + struct rtr_spki_record *record1; + struct rtr_spki_record *record2; struct rtr_signature_seg *new_sig = NULL; struct rtr_secure_path_seg *new_sec = NULL; @@ -243,7 +243,7 @@ static void generate_signature_test(void) pfx = rtr_mgr_bgpsec_nlri_new(3); assert(pfx != NULL); pfx->nlri_len = 24; - pfx->afi = 1; /* LRTR_IPV4 */ + pfx->afi = 1; /* RTR_IPV4 */ pfx_int = htonl(3221225984); /* 192.0.2.0 */ memcpy(pfx->nlri, &pfx_int, 3); @@ -321,9 +321,9 @@ static void originate_and_validate_test(void) struct rtr_bgpsec_nlri *pfx = NULL; int pfx_int = 0; - struct spki_table table; - struct spki_record *record1; - struct spki_record *record2; + struct rtr_spki_table table; + struct rtr_spki_record *record1; + struct rtr_spki_record *record2; struct rtr_signature_seg *new_sig = NULL; struct rtr_secure_path_seg *new_sec = NULL; @@ -339,7 +339,7 @@ static void originate_and_validate_test(void) pfx = rtr_mgr_bgpsec_nlri_new(3); assert(pfx != NULL); pfx->nlri_len = 24; - pfx->afi = 1; /* LRTR_IPV4 */ + pfx->afi = 1; /* RTR_IPV4 */ pfx_int = htonl(3221225984); /* 192.0.2.0 */ memcpy(pfx->nlri, &pfx_int, 3); diff --git a/tests/test_dynamic_groups.c b/tests/test_dynamic_groups.c index c02bea8c..f42ca284 100644 --- a/tests/test_dynamic_groups.c +++ b/tests/test_dynamic_groups.c @@ -40,8 +40,8 @@ int main(void) char tcp_port[] = "3323"; /* create a TCP transport socket */ - struct tr_socket tr_tcp; - struct tr_tcp_config tcp_config = { + struct rtr_tr_socket tr_tcp; + struct rtr_tr_tcp_config tcp_config = { tcp_host, //IP tcp_port, //Port NULL, //Source address @@ -53,7 +53,7 @@ int main(void) struct rtr_mgr_group groups[1]; /* init a TCP transport and create rtr socket */ - tr_tcp_init(&tcp_config, &tr_tcp); + rtr_tr_tcp_init(&tcp_config, &tr_tcp); rtr_tcp.tr_socket = &tr_tcp; /* create a rtr_mr_group array with 1 element */ @@ -62,11 +62,11 @@ int main(void) groups[0].sockets[0] = &rtr_tcp; groups[0].preference = 1; - struct tr_socket tr_tcp2; + struct rtr_tr_socket tr_tcp2; struct rtr_socket rtr_tcp2; struct rtr_mgr_group group2; - tr_tcp_init(&tcp_config, &tr_tcp2); + rtr_tr_tcp_init(&tcp_config, &tr_tcp2); rtr_tcp2.tr_socket = &tr_tcp2; group2.sockets = malloc(sizeof(struct rtr_socket *)); group2.sockets_len = 1; @@ -121,22 +121,22 @@ int main(void) assert(group_node->group->preference == 2); assert(conf->len == 1); - struct tr_socket tr_tcp3; + struct rtr_tr_socket tr_tcp3; struct rtr_socket rtr_tcp3; struct rtr_mgr_group group3; - tr_tcp_init(&tcp_config, &tr_tcp3); + rtr_tr_tcp_init(&tcp_config, &tr_tcp3); rtr_tcp3.tr_socket = &tr_tcp3; group3.sockets = malloc(sizeof(struct rtr_socket *)); group3.sockets_len = 1; group3.sockets[0] = &rtr_tcp3; group3.preference = 3; - struct tr_socket tr_tcp4; + struct rtr_tr_socket tr_tcp4; struct rtr_socket rtr_tcp4; struct rtr_mgr_group group4; - tr_tcp_init(&tcp_config, &tr_tcp4); + rtr_tr_tcp_init(&tcp_config, &tr_tcp4); rtr_tcp4.tr_socket = &tr_tcp4; group4.sockets = malloc(sizeof(struct rtr_socket *)); group4.sockets_len = 1; @@ -160,11 +160,11 @@ int main(void) retval = rtr_mgr_remove_group(conf, 10); assert(retval == RTR_ERROR); - struct tr_socket tr_tcp5; + struct rtr_tr_socket tr_tcp5; struct rtr_socket rtr_tcp5; struct rtr_mgr_group group5; - tr_tcp_init(&tcp_config, &tr_tcp5); + rtr_tr_tcp_init(&tcp_config, &tr_tcp5); rtr_tcp5.tr_socket = &tr_tcp5; group5.sockets = malloc(sizeof(struct rtr_socket *)); group5.sockets_len = 1; diff --git a/tests/test_getbits.c b/tests/test_getbits.c index 125ce949..9256dae6 100644 --- a/tests/test_getbits.c +++ b/tests/test_getbits.c @@ -11,63 +11,63 @@ */ static void get_bits_testv4(void) { - struct lrtr_ip_addr addr; - struct lrtr_ip_addr result; + struct rtr_ip_addr addr; + struct rtr_ip_addr result; - addr.ver = LRTR_IPV4; + addr.ver = RTR_IPV4; addr.u.addr4.addr = 0xAABBCC22; - result = lrtr_ip_addr_get_bits(&addr, 0, 32); + result = rtr_ip_addr_get_bits(&addr, 0, 32); assert(result.u.addr4.addr == 0xAABBCC22); - result = lrtr_ip_addr_get_bits(&addr, 0, 1); + result = rtr_ip_addr_get_bits(&addr, 0, 1); assert(result.u.addr4.addr == 0x80000000); - result = lrtr_ip_addr_get_bits(&addr, 1, 1); + result = rtr_ip_addr_get_bits(&addr, 1, 1); assert(result.u.addr4.addr == 0); - result = lrtr_ip_addr_get_bits(&addr, 2, 1); + result = rtr_ip_addr_get_bits(&addr, 2, 1); assert(result.u.addr4.addr == 0x20000000); - result = lrtr_ip_addr_get_bits(&addr, 0, 8); + result = rtr_ip_addr_get_bits(&addr, 0, 8); assert(result.u.addr4.addr == 0xAA000000); - result = lrtr_ip_addr_get_bits(&addr, 8, 8); + result = rtr_ip_addr_get_bits(&addr, 8, 8); assert(result.u.addr4.addr == 0x00BB0000); - lrtr_ip_str_to_addr("10.10.10.0", &addr); + rtr_ip_str_to_addr("10.10.10.0", &addr); - result = lrtr_ip_addr_get_bits(&addr, 0, 8); - assert(lrtr_ip_str_cmp(&result, "10.0.0.0")); + result = rtr_ip_addr_get_bits(&addr, 0, 8); + assert(rtr_ip_str_cmp(&result, "10.0.0.0")); - result = lrtr_ip_addr_get_bits(&addr, 0, 16); - assert(lrtr_ip_str_cmp(&result, "10.10.0.0")); + result = rtr_ip_addr_get_bits(&addr, 0, 16); + assert(rtr_ip_str_cmp(&result, "10.10.0.0")); - result = lrtr_ip_addr_get_bits(&addr, 8, 8); - assert(lrtr_ip_str_cmp(&result, "0.10.0.0")); + result = rtr_ip_addr_get_bits(&addr, 8, 8); + assert(rtr_ip_str_cmp(&result, "0.10.0.0")); - result = lrtr_ip_addr_get_bits(&addr, 8, 24); - assert(lrtr_ip_str_cmp(&result, "0.10.10.0")); + result = rtr_ip_addr_get_bits(&addr, 8, 24); + assert(rtr_ip_str_cmp(&result, "0.10.10.0")); - result = lrtr_ip_addr_get_bits(&addr, 31, 1); + result = rtr_ip_addr_get_bits(&addr, 31, 1); assert(result.u.addr4.addr == 0); - result = lrtr_ip_addr_get_bits(&addr, 0, 1); + result = rtr_ip_addr_get_bits(&addr, 0, 1); assert(result.u.addr4.addr == 0); - result = lrtr_ip_addr_get_bits(&addr, 3, 3); - assert(lrtr_ip_str_cmp(&result, "8.0.0.0")); + result = rtr_ip_addr_get_bits(&addr, 3, 3); + assert(rtr_ip_str_cmp(&result, "8.0.0.0")); - assert(lrtr_ip_str_to_addr("132.200.0.0", &addr) == 0); - result = lrtr_ip_addr_get_bits(&addr, 0, 1); + assert(rtr_ip_str_to_addr("132.200.0.0", &addr) == 0); + result = rtr_ip_addr_get_bits(&addr, 0, 1); assert(result.u.addr4.addr == 0x80000000); - assert(lrtr_ip_str_to_addr("101.200.0.0", &addr) == 0); - result = lrtr_ip_addr_get_bits(&addr, 0, 1); + assert(rtr_ip_str_to_addr("101.200.0.0", &addr) == 0); + result = rtr_ip_addr_get_bits(&addr, 0, 1); assert(result.u.addr4.addr == 0); addr.u.addr4.addr = 0x6D698000; - result = lrtr_ip_addr_get_bits(&addr, 0, 19); + result = rtr_ip_addr_get_bits(&addr, 0, 19); assert(result.u.addr4.addr == 0x6D698000); /* ip_str_to_addr("109.105.128.0", &addr); @@ -76,8 +76,8 @@ static void get_bits_testv4(void) */ char buf[INET_ADDRSTRLEN]; - assert(lrtr_ip_str_to_addr("10.10.10.5", &addr) == 0); - assert(lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)) == 0); + assert(rtr_ip_str_to_addr("10.10.10.5", &addr) == 0); + assert(rtr_ip_addr_to_str(&addr, buf, sizeof(buf)) == 0); assert(strcmp("10.10.10.5", buf) == 0); } @@ -86,77 +86,77 @@ static void get_bits_testv4(void) */ static void get_bits_testv6(void) { - struct lrtr_ip_addr addr; - struct lrtr_ip_addr result; + struct rtr_ip_addr addr; + struct rtr_ip_addr result; - addr.ver = LRTR_IPV6; + addr.ver = RTR_IPV6; addr.u.addr6.addr[0] = 0x22AABBCC; addr.u.addr6.addr[1] = 0xDDEEFF99; addr.u.addr6.addr[2] = 0x33001122; addr.u.addr6.addr[3] = 0x33445566; - result = lrtr_ip_addr_get_bits(&addr, 0, 128); + result = rtr_ip_addr_get_bits(&addr, 0, 128); assert(result.u.addr6.addr[0] == addr.u.addr6.addr[0] && result.u.addr6.addr[1] == addr.u.addr6.addr[1] && result.u.addr6.addr[2] == addr.u.addr6.addr[2] && result.u.addr6.addr[3] == addr.u.addr6.addr[3]); - result = lrtr_ip_addr_get_bits(&addr, 0, 64); + result = rtr_ip_addr_get_bits(&addr, 0, 64); assert(result.u.addr6.addr[0] == addr.u.addr6.addr[0] && result.u.addr6.addr[1] == addr.u.addr6.addr[1] && result.u.addr6.addr[2] == 0 && result.u.addr6.addr[3] == 0); bzero(&result, sizeof(result)); - result = lrtr_ip_addr_get_bits(&addr, 64, 64); + result = rtr_ip_addr_get_bits(&addr, 64, 64); assert(result.u.addr6.addr[0] == 0); assert(result.u.addr6.addr[1] == 0); assert(result.u.addr6.addr[2] == addr.u.addr6.addr[2]); assert(result.u.addr6.addr[3] == addr.u.addr6.addr[3]); - result = lrtr_ip_addr_get_bits(&addr, 0, 8); + result = rtr_ip_addr_get_bits(&addr, 0, 8); assert(result.u.addr6.addr[0] == 0x22000000 && result.u.addr6.addr[1] == 0); - result = lrtr_ip_addr_get_bits(&addr, 64, 8); + result = rtr_ip_addr_get_bits(&addr, 64, 8); assert(result.u.addr6.addr[1] == 0 && result.u.addr6.addr[2] == 0x33000000); - result = lrtr_ip_addr_get_bits(&addr, 7, 8); + result = rtr_ip_addr_get_bits(&addr, 7, 8); assert(result.u.addr6.addr[0] == 0xAA0000 && result.u.addr6.addr[1] == 0); - result = lrtr_ip_addr_get_bits(&addr, 68, 7); + result = rtr_ip_addr_get_bits(&addr, 68, 7); assert(result.u.addr6.addr[0] == 0 && result.u.addr6.addr[2] == 0x03000000); char buf[INET6_ADDRSTRLEN]; - lrtr_ip_str_to_addr("fe80::862b:2bff:fe9a:f50f", &addr); - addr.ver = LRTR_IPV6; + rtr_ip_str_to_addr("fe80::862b:2bff:fe9a:f50f", &addr); + addr.ver = RTR_IPV6; assert(addr.u.addr6.addr[0] == 0xfe800000); assert(addr.u.addr6.addr[1] == 0); assert(addr.u.addr6.addr[2] == 0x862b2bff); assert(addr.u.addr6.addr[3] == 0xfe9af50f); - assert(lrtr_ip_str_to_addr("2001::", &addr) == 0); + assert(rtr_ip_str_to_addr("2001::", &addr) == 0); assert(addr.u.addr6.addr[0] == 0x20010000); assert(addr.u.addr6.addr[1] == 0); assert(addr.u.addr6.addr[2] == 0); assert(addr.u.addr6.addr[3] == 0); - assert(lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)) == 0); + assert(rtr_ip_addr_to_str(&addr, buf, sizeof(buf)) == 0); assert(strcmp("2001::", buf) == 0); - lrtr_ip_str_to_addr("2001:0db8:85a3:08d3:1319:8a2e:0370:7344", &addr); - assert(lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)) == 0); + rtr_ip_str_to_addr("2001:0db8:85a3:08d3:1319:8a2e:0370:7344", &addr); + assert(rtr_ip_addr_to_str(&addr, buf, sizeof(buf)) == 0); assert(strcmp("2001:db8:85a3:8d3:1319:8a2e:370:7344", buf) == 0); - result = lrtr_ip_addr_get_bits(&addr, 0, 16); - assert(lrtr_ip_addr_to_str(&result, buf, sizeof(buf)) == 0); - assert(lrtr_ip_str_cmp(&result, "2001::")); + result = rtr_ip_addr_get_bits(&addr, 0, 16); + assert(rtr_ip_addr_to_str(&result, buf, sizeof(buf)) == 0); + assert(rtr_ip_str_cmp(&result, "2001::")); - result = lrtr_ip_addr_get_bits(&addr, 16, 16); - assert(lrtr_ip_addr_to_str(&result, buf, sizeof(buf)) == 0); - assert(lrtr_ip_str_cmp(&result, "0:db8::")); - result = lrtr_ip_addr_get_bits(&addr, 0, 1); - assert(lrtr_ip_str_cmp(&result, "::")); + result = rtr_ip_addr_get_bits(&addr, 16, 16); + assert(rtr_ip_addr_to_str(&result, buf, sizeof(buf)) == 0); + assert(rtr_ip_str_cmp(&result, "0:db8::")); + result = rtr_ip_addr_get_bits(&addr, 0, 1); + assert(rtr_ip_str_cmp(&result, "::")); - result = lrtr_ip_addr_get_bits(&addr, 126, 1); - assert(lrtr_ip_addr_to_str(&result, buf, sizeof(buf)) == 0); - assert(lrtr_ip_str_cmp(&result, "::")); + result = rtr_ip_addr_get_bits(&addr, 126, 1); + assert(rtr_ip_addr_to_str(&result, buf, sizeof(buf)) == 0); + assert(rtr_ip_str_cmp(&result, "::")); } int main(void) diff --git a/tests/test_ht_spkitable.c b/tests/test_ht_spkitable.c index ad6178de..ed78dc3a 100644 --- a/tests/test_ht_spkitable.c +++ b/tests/test_ht_spkitable.c @@ -32,7 +32,7 @@ * * @return true if r1 == r2, false otherwise */ -static bool spki_records_are_equal(struct spki_record *r1, struct spki_record *r2) +static bool spki_records_are_equal(struct rtr_spki_record *r1, struct rtr_spki_record *r2) { if (r1->asn != r2->asn) return false; @@ -51,9 +51,9 @@ static bool spki_records_are_equal(struct spki_record *r1, struct spki_record *r * * @return new SPKI record */ -static struct spki_record *create_record(int ASN, int ski_offset, int spki_offset, struct rtr_socket *socket) +static struct rtr_spki_record *create_record(int ASN, int ski_offset, int spki_offset, struct rtr_socket *socket) { - struct spki_record *record = malloc(sizeof(struct spki_record)); + struct rtr_spki_record *record = malloc(sizeof(struct rtr_spki_record)); uint32_t i; memset(record, 0, sizeof(*record)); @@ -74,18 +74,18 @@ static struct spki_record *create_record(int ASN, int ski_offset, int spki_offse * Assert fails if memory allocation for new entry fails OR * if the entry already exists. */ -static void _spki_table_add_assert(struct spki_table *table, struct spki_record *record) +static void _spki_table_add_assert(struct rtr_spki_table *table, struct rtr_spki_record *record) { - assert(spki_table_add_entry(table, record) == SPKI_SUCCESS); + assert(spki_table_add_entry(table, record) == RTR_SPKI_SUCCESS); } /** * @brief Helper shortcut, to assert remove of table entry * Assert fails if entry does not exist in table, or any search error occurs. */ -static void _spki_table_remove_assert(struct spki_table *table, struct spki_record *record) +static void _spki_table_remove_assert(struct rtr_spki_table *table, struct rtr_spki_record *record) { - assert(spki_table_remove_entry(table, record) == SPKI_SUCCESS); + assert(spki_table_remove_entry(table, record) == RTR_SPKI_SUCCESS); } /** @@ -93,12 +93,12 @@ static void _spki_table_remove_assert(struct spki_table *table, struct spki_reco * Assert fails if a matching enrty is found, but memory allocation fails OR * if number of results does not match reference value: NUM_SKIS_RECORDS. */ -static void _spki_table_search_assert(struct spki_table *table, uint8_t *ski) +static void _spki_table_search_assert(struct rtr_spki_table *table, uint8_t *ski) { - struct spki_record *result; + struct rtr_spki_record *result; unsigned int result_len; - assert(spki_table_search_by_ski(table, ski, &result, &result_len) == SPKI_SUCCESS); + assert(spki_table_search_by_ski(table, ski, &result, &result_len) == RTR_SPKI_SUCCESS); assert(result_len == NUM_SKIS_RECORDS); free(result); } @@ -114,14 +114,14 @@ static void _spki_table_search_assert(struct spki_table *table, uint8_t *ski) */ static void test_ht_1(void) { - struct spki_table table; + struct rtr_spki_table table; struct rtr_socket *socket_one = malloc(sizeof(struct rtr_socket)); struct rtr_socket *socket_two = malloc(sizeof(struct rtr_socket)); uint8_t ski[SKI_SIZE]; uint32_t asn = 1; /* test create record */ - struct spki_record *record = create_record(1, 0, 0, NULL); + struct rtr_spki_record *record = create_record(1, 0, 0, NULL); spki_table_init(&table, NULL); memcpy(ski, record->ski, 20); @@ -138,7 +138,7 @@ static void test_ht_1(void) free(record); } - struct spki_record *result; + struct rtr_spki_record *result; unsigned int result_len; int count = 0; /* verify all (255) records for asn and ski size */ @@ -176,12 +176,12 @@ static void test_ht_1(void) */ static void test_ht_2(void) { - struct spki_table table; - struct spki_record *result; + struct rtr_spki_table table; + struct rtr_spki_record *result; unsigned int result_len; /* create 2 distinct records */ - struct spki_record *record1 = create_record(10, 20, 30, NULL); - struct spki_record *record2 = create_record(10, 20, 40, NULL); + struct rtr_spki_record *record1 = create_record(10, 20, 30, NULL); + struct rtr_spki_record *record2 = create_record(10, 20, 40, NULL); /* TEST1: verify 2 diff SPKIs hash to the same SKI */ spki_table_init(&table, NULL); _spki_table_add_assert(&table, record1); @@ -225,15 +225,15 @@ static void test_ht_2(void) */ static void test_ht_3(void) { - struct spki_table table; - struct spki_record *result; + struct rtr_spki_table table; + struct rtr_spki_record *result; unsigned int result_len; /* create 4 distinct SPKI records, (at least) one parameter different */ - struct spki_record *record1 = create_record(10, 10, 10, NULL); - struct spki_record *record2 = create_record(10, 10, 11, NULL); - struct spki_record *record3 = create_record(10, 11, 10, NULL); - struct spki_record *record4 = create_record(11, 10, 10, NULL); + struct rtr_spki_record *record1 = create_record(10, 10, 10, NULL); + struct rtr_spki_record *record2 = create_record(10, 10, 11, NULL); + struct rtr_spki_record *record3 = create_record(10, 11, 10, NULL); + struct rtr_spki_record *record4 = create_record(11, 10, 10, NULL); /* TEST0:init table and add records -> checks compare function */ spki_table_init(&table, NULL); @@ -245,15 +245,15 @@ static void test_ht_3(void) /* TEST1: remove record1, check others -------------------------------*/ _spki_table_remove_assert(&table, record1); /* Check if other records are still there */ - assert(spki_table_get_all(&table, record2->asn, record2->ski, &result, &result_len) == SPKI_SUCCESS); + assert(spki_table_get_all(&table, record2->asn, record2->ski, &result, &result_len) == RTR_SPKI_SUCCESS); assert(result_len == 1); free(result); - assert(spki_table_get_all(&table, record3->asn, record3->ski, &result, &result_len) == SPKI_SUCCESS); + assert(spki_table_get_all(&table, record3->asn, record3->ski, &result, &result_len) == RTR_SPKI_SUCCESS); assert(result_len == 1); free(result); - assert(spki_table_get_all(&table, record4->asn, record4->ski, &result, &result_len) == SPKI_SUCCESS); + assert(spki_table_get_all(&table, record4->asn, record4->ski, &result, &result_len) == RTR_SPKI_SUCCESS); assert(result_len == 1); free(result); /* (re)add record1 */ @@ -262,15 +262,15 @@ static void test_ht_3(void) /* TEST2: remove record2, check others -------------------------------*/ _spki_table_remove_assert(&table, record2); /* Check if other records are still there */ - assert(spki_table_get_all(&table, record1->asn, record1->ski, &result, &result_len) == SPKI_SUCCESS); + assert(spki_table_get_all(&table, record1->asn, record1->ski, &result, &result_len) == RTR_SPKI_SUCCESS); assert(result_len == 1); free(result); - assert(spki_table_get_all(&table, record3->asn, record3->ski, &result, &result_len) == SPKI_SUCCESS); + assert(spki_table_get_all(&table, record3->asn, record3->ski, &result, &result_len) == RTR_SPKI_SUCCESS); assert(result_len == 1); free(result); - assert(spki_table_get_all(&table, record4->asn, record4->ski, &result, &result_len) == SPKI_SUCCESS); + assert(spki_table_get_all(&table, record4->asn, record4->ski, &result, &result_len) == RTR_SPKI_SUCCESS); assert(result_len == 1); free(result); /* (re)add record2 */ @@ -279,15 +279,15 @@ static void test_ht_3(void) /* TEST3: remove record3, check others -------------------------------*/ _spki_table_remove_assert(&table, record3); /* Check if other records are still there */ - assert(spki_table_get_all(&table, record1->asn, record1->ski, &result, &result_len) == SPKI_SUCCESS); + assert(spki_table_get_all(&table, record1->asn, record1->ski, &result, &result_len) == RTR_SPKI_SUCCESS); assert(result_len == 2); free(result); - assert(spki_table_get_all(&table, record2->asn, record2->ski, &result, &result_len) == SPKI_SUCCESS); + assert(spki_table_get_all(&table, record2->asn, record2->ski, &result, &result_len) == RTR_SPKI_SUCCESS); assert(result_len == 2); free(result); - assert(spki_table_get_all(&table, record4->asn, record4->ski, &result, &result_len) == SPKI_SUCCESS); + assert(spki_table_get_all(&table, record4->asn, record4->ski, &result, &result_len) == RTR_SPKI_SUCCESS); assert(result_len == 1); free(result); /* (re)add record3 */ @@ -296,15 +296,15 @@ static void test_ht_3(void) /* TEST4: remove record4, check others -------------------------------*/ _spki_table_remove_assert(&table, record4); /* Check if other records are still there */ - assert(spki_table_get_all(&table, record1->asn, record1->ski, &result, &result_len) == SPKI_SUCCESS); + assert(spki_table_get_all(&table, record1->asn, record1->ski, &result, &result_len) == RTR_SPKI_SUCCESS); assert(result_len == 2); free(result); - assert(spki_table_get_all(&table, record2->asn, record2->ski, &result, &result_len) == SPKI_SUCCESS); + assert(spki_table_get_all(&table, record2->asn, record2->ski, &result, &result_len) == RTR_SPKI_SUCCESS); assert(result_len == 2); free(result); - assert(spki_table_get_all(&table, record3->asn, record3->ski, &result, &result_len) == SPKI_SUCCESS); + assert(spki_table_get_all(&table, record3->asn, record3->ski, &result, &result_len) == RTR_SPKI_SUCCESS); assert(result_len == 1); free(result); @@ -324,10 +324,10 @@ static void test_ht_3(void) */ static void test_ht_4(void) { - struct spki_table table; - struct spki_record *result; + struct rtr_spki_table table; + struct rtr_spki_record *result; unsigned int result_len; - struct spki_record *records[NUM_TABLE_X][NUM_TABLE_Y]; + struct rtr_spki_record *records[NUM_TABLE_X][NUM_TABLE_Y]; spki_table_init(&table, NULL); /* Add 50 * 50 entries */ @@ -342,7 +342,7 @@ static void test_ht_4(void) for (int i = 0; i < NUM_TABLE_X; i++) { for (int j = 0; j < NUM_TABLE_Y; j++) { assert(spki_table_get_all(&table, records[i][j]->asn, records[i][j]->ski, &result, - &result_len) == SPKI_SUCCESS); + &result_len) == RTR_SPKI_SUCCESS); assert(result_len == 1); _spki_table_remove_assert(&table, records[i][j]); free(result); @@ -370,18 +370,18 @@ static void test_ht_4(void) */ static void test_ht_5(void) { - struct spki_table table; + struct rtr_spki_table table; /* create 2 equal records */ - struct spki_record *record1 = create_record(10, 10, 10, NULL); - struct spki_record *record2 = create_record(10, 10, 10, NULL); + struct rtr_spki_record *record1 = create_record(10, 10, 10, NULL); + struct rtr_spki_record *record2 = create_record(10, 10, 10, NULL); /* create table and (try) add records -> check for duplicates */ spki_table_init(&table, NULL); - assert(spki_table_add_entry(&table, record1) == SPKI_SUCCESS); - assert(spki_table_add_entry(&table, record2) == SPKI_DUPLICATE_RECORD); - assert(spki_table_add_entry(&table, record1) == SPKI_DUPLICATE_RECORD); + assert(spki_table_add_entry(&table, record1) == RTR_SPKI_SUCCESS); + assert(spki_table_add_entry(&table, record2) == RTR_SPKI_DUPLICATE_RECORD); + assert(spki_table_add_entry(&table, record1) == RTR_SPKI_DUPLICATE_RECORD); - struct spki_record *result; + struct rtr_spki_record *result; unsigned int result_len; /* check that only record1 is in table and matches query */ @@ -402,8 +402,8 @@ static void test_ht_5(void) */ static void test_ht_6(void) { - struct spki_table table; - struct spki_record *records[NUM_SKIS][NUM_SKIS_RECORDS]; + struct rtr_spki_table table; + struct rtr_spki_record *records[NUM_SKIS][NUM_SKIS_RECORDS]; /* Add the records to the table */ spki_table_init(&table, NULL); for (unsigned int i = 0; i < NUM_SKIS; i++) { @@ -435,8 +435,8 @@ static void test_ht_6(void) */ static void test_ht_7(void) { - struct spki_table table; - struct spki_record *records[NUM_OF_RECORDS]; + struct rtr_spki_table table; + struct rtr_spki_record *records[NUM_OF_RECORDS]; /* ASN(1) <---> SKI(n) ---------------------------------------------- */ spki_table_init(&table, NULL); /* Create NUM_OF_RECORDS spki_records with same ASN but different SKI */ @@ -447,7 +447,7 @@ static void test_ht_7(void) /* Validate */ for (unsigned int i = 0; i < NUM_OF_RECORDS; i++) { - struct spki_record *result; + struct rtr_spki_record *result; unsigned int size = 0; spki_table_get_all(&table, 2555, records[i]->ski, &result, &size); @@ -469,7 +469,7 @@ static void test_ht_7(void) /* Validate */ for (unsigned int i = 0; i < NUM_OF_RECORDS; i++) { - struct spki_record *result; + struct rtr_spki_record *result; unsigned int size = 0; spki_table_get_all(&table, i, records[NUM_OF_RECORDS - 1]->ski, &result, &size); @@ -481,7 +481,7 @@ static void test_ht_7(void) } spki_table_free(&table); - struct spki_record *records_n_n[NUM_OF_RECORDS][NUM_OF_SKI]; + struct rtr_spki_record *records_n_n[NUM_OF_RECORDS][NUM_OF_SKI]; /* ASN(n) <---> SKI(n) ---------------------------------------------- */ spki_table_init(&table, NULL); /* Create: {NUM_OF_RECORDS} x {NUM_OF_SKI} spki_records */ @@ -496,7 +496,7 @@ static void test_ht_7(void) /* Validate */ for (unsigned int i = 0; i < NUM_OF_RECORDS; i++) { for (unsigned int j = 0; j < NUM_OF_SKI; j++) { - struct spki_record *result; + struct rtr_spki_record *result; unsigned int size = 0; spki_table_get_all(&table, i, records_n_n[i][j]->ski, &result, &size); @@ -515,11 +515,11 @@ static void test_ht_7(void) static void test_table_swap(void) { - struct spki_table table1; - struct spki_table table2; + struct rtr_spki_table table1; + struct rtr_spki_table table2; - struct spki_record *test_record1 = create_record(1, 10, 100, NULL); - struct spki_record *test_record2 = create_record(2, 20, 200, NULL); + struct rtr_spki_record *test_record1 = create_record(1, 10, 100, NULL); + struct rtr_spki_record *test_record2 = create_record(2, 20, 200, NULL); spki_table_init(&table1, NULL); spki_table_init(&table2, NULL); @@ -527,27 +527,27 @@ static void test_table_swap(void) _spki_table_add_assert(&table1, test_record1); _spki_table_add_assert(&table2, test_record2); - struct spki_record *result; + struct rtr_spki_record *result; unsigned int result_len; - assert(spki_table_search_by_ski(&table1, test_record1->ski, &result, &result_len) == SPKI_SUCCESS); + assert(spki_table_search_by_ski(&table1, test_record1->ski, &result, &result_len) == RTR_SPKI_SUCCESS); assert(result_len == 1); free(result); result = NULL; - assert(spki_table_search_by_ski(&table2, test_record2->ski, &result, &result_len) == SPKI_SUCCESS); + assert(spki_table_search_by_ski(&table2, test_record2->ski, &result, &result_len) == RTR_SPKI_SUCCESS); assert(result_len == 1); free(result); result = NULL; spki_table_swap(&table1, &table2); - assert(spki_table_search_by_ski(&table1, test_record2->ski, &result, &result_len) == SPKI_SUCCESS); + assert(spki_table_search_by_ski(&table1, test_record2->ski, &result, &result_len) == RTR_SPKI_SUCCESS); assert(result_len == 1); free(result); result = NULL; - assert(spki_table_search_by_ski(&table2, test_record1->ski, &result, &result_len) == SPKI_SUCCESS); + assert(spki_table_search_by_ski(&table2, test_record1->ski, &result, &result_len) == RTR_SPKI_SUCCESS); assert(result_len == 1); free(result); result = NULL; @@ -560,9 +560,10 @@ static void test_table_swap(void) printf("%s() complete\n", __func__); } -static void update_spki(struct spki_table *s __attribute__((unused)), const struct spki_record record, const bool added) +static void update_spki(struct rtr_spki_table *s __attribute__((unused)), const struct rtr_spki_record record, + const enum rtr_spki_operation_type operation_type) { - printf("%c ASN: %u\n", (added ? '+' : '-'), record.asn); + printf("%c ASN: %u\n", (operation_type == RTR_SPKI_ADD ? '+' : '-'), record.asn); int i; int size = sizeof(record.ski); @@ -589,22 +590,22 @@ static void update_spki(struct spki_table *s __attribute__((unused)), const stru printf("\n"); if (record.asn == 1) - assert(!added); + assert(operation_type == RTR_SPKI_REMOVE); if (record.asn == 2) assert(false); if (record.asn == 3) - assert(added); + assert(operation_type == RTR_SPKI_ADD); } static void test_table_diff(void) { - struct spki_table table1; - struct spki_table table2; + struct rtr_spki_table table1; + struct rtr_spki_table table2; struct rtr_socket *socket = (struct rtr_socket *)1; - struct spki_record *test_record1 = create_record(1, 10, 100, socket); - struct spki_record *test_record2 = create_record(2, 20, 200, socket); - struct spki_record *test_record3 = create_record(3, 30, 300, socket); + struct rtr_spki_record *test_record1 = create_record(1, 10, 100, socket); + struct rtr_spki_record *test_record2 = create_record(2, 20, 200, socket); + struct rtr_spki_record *test_record3 = create_record(3, 30, 300, socket); spki_table_init(&table1, NULL); spki_table_init(&table2, NULL); diff --git a/tests/test_ht_spkitable_locks.c b/tests/test_ht_spkitable_locks.c index 9e198102..c820ab8c 100644 --- a/tests/test_ht_spkitable_locks.c +++ b/tests/test_ht_spkitable_locks.c @@ -15,25 +15,25 @@ #include struct add_records_args { - struct spki_table *table; + struct rtr_spki_table *table; int start_asn; int count; }; struct remove_records_args { - struct spki_table *table; + struct rtr_spki_table *table; int start_asn; int count; }; -static struct spki_record *create_record(int ASN, int ski_offset, int spki_offset, struct rtr_socket *socket); +static struct rtr_spki_record *create_record(int ASN, int ski_offset, int spki_offset, struct rtr_socket *socket); /** * @brief Compare SPKI records for equality * * @return true if r1 == r2, false otherwise */ -static bool compare_spki_records(struct spki_record *r1, struct spki_record *r2) +static bool compare_spki_records(struct rtr_spki_record *r1, struct rtr_spki_record *r2) { if (r1->asn != r2->asn) return false; @@ -52,9 +52,9 @@ static bool compare_spki_records(struct spki_record *r1, struct spki_record *r2) * * @return new SPKI record */ -static struct spki_record *create_record(int ASN, int ski_offset, int spki_offset, struct rtr_socket *socket) +static struct rtr_spki_record *create_record(int ASN, int ski_offset, int spki_offset, struct rtr_socket *socket) { - struct spki_record *record = malloc(sizeof(struct spki_record)); + struct rtr_spki_record *record = malloc(sizeof(struct rtr_spki_record)); uint32_t i; record->asn = ASN; @@ -78,10 +78,10 @@ static void *add_records(struct add_records_args *args) { printf("Add %i records: ASN [%i..%i]\n", args->count, args->start_asn, args->count + args->start_asn - 1); for (int i = args->start_asn; i < args->count + args->start_asn; i++) { - struct spki_record *record = create_record(i, i, i, NULL); + struct rtr_spki_record *record = create_record(i, i, i, NULL); int ret = spki_table_add_entry(args->table, record); - assert(ret == SPKI_SUCCESS); + assert(ret == RTR_SPKI_SUCCESS); free(record); } @@ -96,10 +96,10 @@ static void *remove_records(struct remove_records_args *args) { printf("Remove %i records: ASN [%i..%i]\n", args->count, args->start_asn, args->count + args->start_asn - 1); for (int i = args->start_asn; i < args->count + args->start_asn; i++) { - struct spki_record *record = create_record(i, i, i, NULL); + struct rtr_spki_record *record = create_record(i, i, i, NULL); int ret = spki_table_remove_entry(args->table, record); - assert(ret == SPKI_SUCCESS); + assert(ret == RTR_SPKI_SUCCESS); free(record); } @@ -113,7 +113,7 @@ static void lock_test1(void) { unsigned int max_threads = 20; unsigned int records_per_thread = 10000; - struct spki_table spkit; + struct rtr_spki_table spkit; struct add_records_args args[max_threads]; spki_table_init(&spkit, NULL); @@ -134,11 +134,11 @@ static void lock_test1(void) } /* Check all records for successful add */ - struct spki_record *result; + struct rtr_spki_record *result; unsigned int result_size = 0; for (unsigned int i = 0; i < records_per_thread * max_threads; i++) { - struct spki_record *record = create_record(i, i, i, NULL); + struct rtr_spki_record *record = create_record(i, i, i, NULL); spki_table_get_all(&spkit, record->asn, record->ski, &result, &result_size); assert(result_size == 1); diff --git a/tests/test_ipaddr.c b/tests/test_ipaddr.c index c0fea5bf..fda2c47d 100644 --- a/tests/test_ipaddr.c +++ b/tests/test_ipaddr.c @@ -21,54 +21,54 @@ */ static void test_v4(void) { - struct lrtr_ip_addr addr; + struct rtr_ip_addr addr; char buf[INET_ADDRSTRLEN]; - lrtr_ip_str_to_addr("0.0.0.0", &addr); - assert(addr.ver == LRTR_IPV4); + rtr_ip_str_to_addr("0.0.0.0", &addr); + assert(addr.ver == RTR_IPV4); assert(addr.u.addr4.addr == 0); - lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)); + rtr_ip_addr_to_str(&addr, buf, sizeof(buf)); assert(strcmp("0.0.0.0", buf) == 0); - lrtr_ip_str_to_addr("255.255.255.255", &addr); - assert(addr.ver == LRTR_IPV4); + rtr_ip_str_to_addr("255.255.255.255", &addr); + assert(addr.ver == RTR_IPV4); assert(addr.u.addr4.addr == 0xffffffff); - lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)); + rtr_ip_addr_to_str(&addr, buf, sizeof(buf)); assert(strcmp("255.255.255.255", buf) == 0); - lrtr_ip_str_to_addr("0.2.6.7", &addr); - assert(addr.ver == LRTR_IPV4); + rtr_ip_str_to_addr("0.2.6.7", &addr); + assert(addr.ver == RTR_IPV4); assert(addr.u.addr4.addr == 0x20607); - lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)); + rtr_ip_addr_to_str(&addr, buf, sizeof(buf)); assert(strcmp("0.2.6.7", buf) == 0); - lrtr_ip_str_to_addr("78.69.255.0", &addr); - assert(addr.ver == LRTR_IPV4); + rtr_ip_str_to_addr("78.69.255.0", &addr); + assert(addr.ver == RTR_IPV4); assert(addr.u.addr4.addr == 0x4e45ff00); - lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)); + rtr_ip_addr_to_str(&addr, buf, sizeof(buf)); assert(strcmp("78.69.255.0", buf) == 0); - lrtr_ip_str_to_addr("1.1.1.1", &addr); - assert(addr.ver == LRTR_IPV4); + rtr_ip_str_to_addr("1.1.1.1", &addr); + assert(addr.ver == RTR_IPV4); assert(addr.u.addr4.addr == 0x1010101); - lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)); + rtr_ip_addr_to_str(&addr, buf, sizeof(buf)); assert(strcmp("1.1.1.1", buf) == 0); - lrtr_ip_str_to_addr("5.0.255.255", &addr); - assert(addr.ver == LRTR_IPV4); + rtr_ip_str_to_addr("5.0.255.255", &addr); + assert(addr.ver == RTR_IPV4); assert(addr.u.addr4.addr == 0x500ffff); - lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)); + rtr_ip_addr_to_str(&addr, buf, sizeof(buf)); assert(strcmp("5.0.255.255", buf) == 0); - lrtr_ip_str_to_addr("8.9.6.3", &addr); - assert(addr.ver == LRTR_IPV4); + rtr_ip_str_to_addr("8.9.6.3", &addr); + assert(addr.ver == RTR_IPV4); assert(addr.u.addr4.addr == 0x8090603); - lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)); + rtr_ip_addr_to_str(&addr, buf, sizeof(buf)); assert(strcmp("8.9.6.3", buf) == 0); /* check some malformed addresses */ - assert(lrtr_ip_str_to_addr("8,3,4,5", &addr) == -1); - assert(lrtr_ip_str_to_addr("8.4.5", &addr) == -1); + assert(rtr_ip_str_to_addr("8,3,4,5", &addr) == -1); + assert(rtr_ip_str_to_addr("8.4.5", &addr) == -1); } /* @@ -76,150 +76,150 @@ static void test_v4(void) */ static void test_v6(void) { - struct lrtr_ip_addr addr; + struct rtr_ip_addr addr; char buf[INET6_ADDRSTRLEN]; - lrtr_ip_str_to_addr("fdf8:f53b:82e4::53", &addr); + rtr_ip_str_to_addr("fdf8:f53b:82e4::53", &addr); assert(addr.u.addr6.addr[0] == 0xfdf8f53b); assert(addr.u.addr6.addr[1] == 0x82e40000); assert(addr.u.addr6.addr[2] == 0); assert(addr.u.addr6.addr[3] == 0x53); - lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)); + rtr_ip_addr_to_str(&addr, buf, sizeof(buf)); assert(strcmp("fdf8:f53b:82e4::53", buf) == 0); - lrtr_ip_str_to_addr("fe80::200:5aee:feaa:20a2", &addr); + rtr_ip_str_to_addr("fe80::200:5aee:feaa:20a2", &addr); assert(addr.u.addr6.addr[0] == 0xfe800000); assert(addr.u.addr6.addr[1] == 0); assert(addr.u.addr6.addr[2] == 0x2005aee); assert(addr.u.addr6.addr[3] == 0xfeaa20a2); - lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)); + rtr_ip_addr_to_str(&addr, buf, sizeof(buf)); assert(strcmp("fe80::200:5aee:feaa:20a2", buf) == 0); - lrtr_ip_str_to_addr("2001::1", &addr); + rtr_ip_str_to_addr("2001::1", &addr); assert(addr.u.addr6.addr[0] == 0x20010000); assert(addr.u.addr6.addr[1] == 0); assert(addr.u.addr6.addr[2] == 0); assert(addr.u.addr6.addr[3] == 0x1); - lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)); + rtr_ip_addr_to_str(&addr, buf, sizeof(buf)); assert(strcmp("2001::1", buf) == 0); - lrtr_ip_str_to_addr("2001:0:4136:e378:8000:63bf:3fff:fdd2", &addr); + rtr_ip_str_to_addr("2001:0:4136:e378:8000:63bf:3fff:fdd2", &addr); assert(addr.u.addr6.addr[0] == 0x20010000); assert(addr.u.addr6.addr[1] == 0x4136e378); assert(addr.u.addr6.addr[2] == 0x800063bf); assert(addr.u.addr6.addr[3] == 0x3ffffdd2); - lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)); + rtr_ip_addr_to_str(&addr, buf, sizeof(buf)); assert(strcmp("2001:0:4136:e378:8000:63bf:3fff:fdd2", buf) == 0); - lrtr_ip_str_to_addr("2001:2:6c::430", &addr); + rtr_ip_str_to_addr("2001:2:6c::430", &addr); assert(addr.u.addr6.addr[0] == 0x20010002); assert(addr.u.addr6.addr[1] == 0x6C0000); assert(addr.u.addr6.addr[2] == 0); assert(addr.u.addr6.addr[3] == 0x430); - lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)); + rtr_ip_addr_to_str(&addr, buf, sizeof(buf)); assert(strcmp("2001:2:6c::430", buf) == 0); - lrtr_ip_str_to_addr("2001:10:240:ab::a", &addr); + rtr_ip_str_to_addr("2001:10:240:ab::a", &addr); assert(addr.u.addr6.addr[0] == 0x20010010); assert(addr.u.addr6.addr[1] == 0x24000AB); assert(addr.u.addr6.addr[2] == 0); assert(addr.u.addr6.addr[3] == 0xa); - lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)); + rtr_ip_addr_to_str(&addr, buf, sizeof(buf)); assert(strcmp("2001:10:240:ab::a", buf) == 0); - lrtr_ip_str_to_addr("2002:cb0a:3cdd:1::1", &addr); + rtr_ip_str_to_addr("2002:cb0a:3cdd:1::1", &addr); assert(addr.u.addr6.addr[0] == 0x2002cb0a); assert(addr.u.addr6.addr[1] == 0x3cdd0001); assert(addr.u.addr6.addr[2] == 0); assert(addr.u.addr6.addr[3] == 0x1); - lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)); + rtr_ip_addr_to_str(&addr, buf, sizeof(buf)); assert(strcmp("2002:cb0a:3cdd:1::1", buf) == 0); - lrtr_ip_str_to_addr("2001:db8:8:4::2", &addr); + rtr_ip_str_to_addr("2001:db8:8:4::2", &addr); assert(addr.u.addr6.addr[0] == 0x20010db8); assert(addr.u.addr6.addr[1] == 0x80004); assert(addr.u.addr6.addr[2] == 0); assert(addr.u.addr6.addr[3] == 0x2); - lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)); + rtr_ip_addr_to_str(&addr, buf, sizeof(buf)); assert(strcmp("2001:db8:8:4::2", buf) == 0); - lrtr_ip_str_to_addr("FF01:0:0:0:0:0:0:2", &addr); + rtr_ip_str_to_addr("FF01:0:0:0:0:0:0:2", &addr); assert(addr.u.addr6.addr[0] == 0xff010000); assert(addr.u.addr6.addr[1] == 0); assert(addr.u.addr6.addr[2] == 0); assert(addr.u.addr6.addr[3] == 0x2); - lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)); + rtr_ip_addr_to_str(&addr, buf, sizeof(buf)); assert(strcmp("ff01::2", buf) == 0); - lrtr_ip_str_to_addr("fdf8:f53b:82e4::53", &addr); + rtr_ip_str_to_addr("fdf8:f53b:82e4::53", &addr); assert(addr.u.addr6.addr[0] == 0xfdf8f53b); assert(addr.u.addr6.addr[1] == 0x82e40000); assert(addr.u.addr6.addr[2] == 0); assert(addr.u.addr6.addr[3] == 0x53); - lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)); + rtr_ip_addr_to_str(&addr, buf, sizeof(buf)); assert(strcmp("fdf8:f53b:82e4::53", buf) == 0); - lrtr_ip_str_to_addr("fe80::200:5aee:feaa:20a2", &addr); + rtr_ip_str_to_addr("fe80::200:5aee:feaa:20a2", &addr); assert(addr.u.addr6.addr[0] == 0xfe800000); assert(addr.u.addr6.addr[1] == 0); assert(addr.u.addr6.addr[2] == 0x2005aee); assert(addr.u.addr6.addr[3] == 0xfeaa20a2); - lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)); + rtr_ip_addr_to_str(&addr, buf, sizeof(buf)); assert(strcmp("fe80::200:5aee:feaa:20a2", buf) == 0); - lrtr_ip_str_to_addr("2001::1", &addr); + rtr_ip_str_to_addr("2001::1", &addr); assert(addr.u.addr6.addr[0] == 0x20010000); assert(addr.u.addr6.addr[1] == 0); assert(addr.u.addr6.addr[2] == 0); assert(addr.u.addr6.addr[3] == 1); - lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)); + rtr_ip_addr_to_str(&addr, buf, sizeof(buf)); assert(strcmp("2001::1", buf) == 0); - lrtr_ip_str_to_addr("2001:0:4136:e378:8000:63bf:3fff:fdd2", &addr); + rtr_ip_str_to_addr("2001:0:4136:e378:8000:63bf:3fff:fdd2", &addr); assert(addr.u.addr6.addr[0] == 0x20010000); assert(addr.u.addr6.addr[1] == 0x4136e378); assert(addr.u.addr6.addr[2] == 0x800063bf); assert(addr.u.addr6.addr[3] == 0x3ffffdd2); - lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)); + rtr_ip_addr_to_str(&addr, buf, sizeof(buf)); assert(strcmp("2001:0:4136:e378:8000:63bf:3fff:fdd2", buf) == 0); /* test embedded ipv4 */ - lrtr_ip_str_to_addr("::ffff:192.0.2.128", &addr); + rtr_ip_str_to_addr("::ffff:192.0.2.128", &addr); assert(addr.u.addr6.addr[0] == 0); assert(addr.u.addr6.addr[1] == 0); assert(addr.u.addr6.addr[2] == 0xffff); assert(addr.u.addr6.addr[3] == 0xc0000280); - lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)); + rtr_ip_addr_to_str(&addr, buf, sizeof(buf)); assert(strcmp("::ffff:192.0.2.128", buf) == 0); - lrtr_ip_str_to_addr("::10.58.64.34", &addr); + rtr_ip_str_to_addr("::10.58.64.34", &addr); assert(addr.u.addr6.addr[0] == 0); assert(addr.u.addr6.addr[1] == 0); assert(addr.u.addr6.addr[2] == 0); assert(addr.u.addr6.addr[3] == 0xa3a4022); - lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)); + rtr_ip_addr_to_str(&addr, buf, sizeof(buf)); assert(strcmp("::10.58.64.34", buf) == 0); /* test check for malformed embedded ipv4 */ - assert(lrtr_ip_str_to_addr("::ffff:192.0,2.128", &addr) == -1); + assert(rtr_ip_str_to_addr("::ffff:192.0,2.128", &addr) == -1); /* buffer size check*/ - assert(lrtr_ip_addr_to_str(&addr, buf, 10) == -1); + assert(rtr_ip_addr_to_str(&addr, buf, 10) == -1); /* test leading single colon check */ - assert(lrtr_ip_str_to_addr(":ffff::ffff", &addr) == -1); + assert(rtr_ip_str_to_addr(":ffff::ffff", &addr) == -1); /* test multiple double colons check */ - assert(lrtr_ip_str_to_addr("::ffff::ffff", &addr) == -1); + assert(rtr_ip_str_to_addr("::ffff::ffff", &addr) == -1); /* test check for to long addresses */ - assert(lrtr_ip_str_to_addr("2001:0:6:8:0:f:3fff:fdd2:55", &addr) == -1); + assert(rtr_ip_str_to_addr("2001:0:6:8:0:f:3fff:fdd2:55", &addr) == -1); /* test check for to big groups */ - assert(lrtr_ip_str_to_addr("::fffff", &addr) == -1); + assert(rtr_ip_str_to_addr("::fffff", &addr) == -1); /* check for null byte in address string */ - assert(lrtr_ip_str_to_addr("2001:\0::", &addr) == -1); + assert(rtr_ip_str_to_addr("2001:\0::", &addr) == -1); } /* @@ -227,23 +227,23 @@ static void test_v6(void) */ static void test_cmp(void) { - struct lrtr_ip_addr addr1, addr2; + struct rtr_ip_addr addr1, addr2; - lrtr_ip_str_to_addr("2001:0:4136:e378:8000:63bf:3fff:fdd2", &addr1); - lrtr_ip_str_to_addr("2001:0:4136:e378:8000:63bf:3fff:fdd2", &addr2); + rtr_ip_str_to_addr("2001:0:4136:e378:8000:63bf:3fff:fdd2", &addr1); + rtr_ip_str_to_addr("2001:0:4136:e378:8000:63bf:3fff:fdd2", &addr2); - assert(lrtr_ip_addr_equal(addr1, addr2) == true); + assert(rtr_ip_addr_equal(addr1, addr2) == true); - lrtr_ip_str_to_addr("2001:0:4136:e378:8000:63bf:3fff:fdd3", &addr2); - assert(lrtr_ip_addr_equal(addr1, addr2) == false); + rtr_ip_str_to_addr("2001:0:4136:e378:8000:63bf:3fff:fdd3", &addr2); + assert(rtr_ip_addr_equal(addr1, addr2) == false); - lrtr_ip_str_to_addr("141.22.5.22", &addr2); - assert(lrtr_ip_addr_equal(addr1, addr2) == false); + rtr_ip_str_to_addr("141.22.5.22", &addr2); + assert(rtr_ip_addr_equal(addr1, addr2) == false); - lrtr_ip_str_to_addr("141.22.5.22", &addr1); - assert(lrtr_ip_addr_equal(addr1, addr2) == true); + rtr_ip_str_to_addr("141.22.5.22", &addr1); + assert(rtr_ip_addr_equal(addr1, addr2) == true); - lrtr_ip_str_to_addr("141.26.5.23", &addr1); + rtr_ip_str_to_addr("141.26.5.23", &addr1); } int main(void) diff --git a/tests/test_live_disabled_features.c b/tests/test_live_disabled_features.c index 7ebb7844..ad2f56fd 100644 --- a/tests/test_live_disabled_features.c +++ b/tests/test_live_disabled_features.c @@ -49,13 +49,13 @@ int main(void) char RPKI_CACHE_PORT[] = "3323"; // rir rtr /* create a TCP transport socket */ - struct tr_socket tr_tcp; - struct tr_tcp_config tcp_config = {RPKI_CACHE_HOST, RPKI_CACHE_PORT, NULL, NULL, NULL, 0}; + struct rtr_tr_socket tr_tcp; + struct rtr_tr_tcp_config tcp_config = {RPKI_CACHE_HOST, RPKI_CACHE_PORT, NULL, NULL, NULL, 0}; struct rtr_socket rtr_tcp; struct rtr_mgr_group groups[1]; /* init a TCP transport and create rtr socket */ - tr_tcp_init(&tcp_config, &tr_tcp); + rtr_tr_tcp_init(&tcp_config, &tr_tcp); rtr_tcp.tr_socket = &tr_tcp; /* create a rtr_mgr_group array with 1 element */ diff --git a/tests/test_live_fetching.c b/tests/test_live_fetching.c index e76b95ce..894c984e 100644 --- a/tests/test_live_fetching.c +++ b/tests/test_live_fetching.c @@ -59,13 +59,13 @@ int main(void) char RPKI_CACHE_PORT[] = "3323"; // rir rtr /* create a TCP transport socket */ - struct tr_socket tr_tcp; - struct tr_tcp_config tcp_config = {RPKI_CACHE_HOST, RPKI_CACHE_PORT, NULL, NULL, NULL, 0}; + struct rtr_tr_socket tr_tcp; + struct rtr_tr_tcp_config tcp_config = {RPKI_CACHE_HOST, RPKI_CACHE_PORT, NULL, NULL, NULL, 0}; struct rtr_socket rtr_tcp; struct rtr_mgr_group groups[1]; /* init a TCP transport and create rtr socket */ - tr_tcp_init(&tcp_config, &tr_tcp); + rtr_tr_tcp_init(&tcp_config, &tr_tcp); rtr_tcp.tr_socket = &tr_tcp; /* create a rtr_mgr_group array with 1 element */ diff --git a/tests/test_live_validation.c b/tests/test_live_validation.c index 62f9ebc0..ae692ef4 100644 --- a/tests/test_live_validation.c +++ b/tests/test_live_validation.c @@ -26,12 +26,12 @@ struct test_validity_query { * (https://www.ripe.net/analyse/internet-measurements/ * routing-information-service-ris/current-ris-routing-beacons) */ -const struct test_validity_query queries[] = {{"93.175.146.0", 24, 12654, BGP_PFXV_STATE_VALID}, - {"2001:7fb:fd02::", 48, 12654, BGP_PFXV_STATE_VALID}, - {"93.175.147.0", 24, 12654, BGP_PFXV_STATE_INVALID}, - {"2001:7fb:fd03::", 48, 12654, BGP_PFXV_STATE_INVALID}, - {"84.205.83.0", 24, 12654, BGP_PFXV_STATE_NOT_FOUND}, - {"2001:7fb:ff03::", 48, 12654, BGP_PFXV_STATE_NOT_FOUND}, +const struct test_validity_query queries[] = {{"93.175.146.0", 24, 12654, RTR_BGP_PFXV_STATE_VALID}, + {"2001:7fb:fd02::", 48, 12654, RTR_BGP_PFXV_STATE_VALID}, + {"93.175.147.0", 24, 12654, RTR_BGP_PFXV_STATE_INVALID}, + {"2001:7fb:fd03::", 48, 12654, RTR_BGP_PFXV_STATE_INVALID}, + {"84.205.83.0", 24, 12654, RTR_BGP_PFXV_STATE_NOT_FOUND}, + {"2001:7fb:ff03::", 48, 12654, RTR_BGP_PFXV_STATE_NOT_FOUND}, {NULL, 0, 0, 0}}; const int connection_timeout = 80; @@ -61,8 +61,8 @@ int main(void) char RPKI_CACHE_POST[] = "3323"; /* create a TCP transport socket */ - struct tr_socket tr_tcp; - struct tr_tcp_config tcp_config = { + struct rtr_tr_socket tr_tcp; + struct rtr_tr_tcp_config tcp_config = { RPKI_CACHE_HOST, //IP RPKI_CACHE_POST, //Port NULL, //source address @@ -74,7 +74,7 @@ int main(void) struct rtr_mgr_group groups[1]; /* init a TCP transport and create rtr socket */ - tr_tcp_init(&tcp_config, &tr_tcp); + rtr_tr_tcp_init(&tcp_config, &tr_tcp); rtr_tcp.tr_socket = &tr_tcp; /* create a rtr_mgr_group array with 1 element */ @@ -122,14 +122,14 @@ int main(void) struct test_validity_query q = queries[i]; /* test validity of entries in queries[] */ while (q.pfx) { - struct lrtr_ip_addr pref; - enum pfxv_state result; - struct pfx_record *reason = NULL; + struct rtr_ip_addr pref; + enum rtr_pfxv_state result; + struct rtr_pfx_record *reason = NULL; unsigned int reason_len = 0; - lrtr_ip_str_to_addr(q.pfx, &pref); - pfx_table_validate_r(groups[0].sockets[0]->pfx_table, &reason, &reason_len, q.asn, &pref, q.len, - &result); + rtr_ip_str_to_addr(q.pfx, &pref); + rtr_pfx_table_validate_r(groups[0].sockets[0]->pfx_table, &reason, &reason_len, q.asn, &pref, q.len, + &result); if (result != q.val) { printf("ERROR: prefix validation mismatch.\n"); return EXIT_FAILURE; diff --git a/tests/test_pfx.c b/tests/test_pfx.c index 31599744..e6cc31f2 100644 --- a/tests/test_pfx.c +++ b/tests/test_pfx.c @@ -22,54 +22,54 @@ #include #include -static void validate(struct pfx_table *pfxt, uint32_t asn, const char *prefix, uint8_t prefix_len, - enum pfxv_state expected_result) +static void validate(struct rtr_pfx_table *pfxt, uint32_t asn, const char *prefix, uint8_t prefix_len, + enum rtr_pfxv_state expected_result) { - struct lrtr_ip_addr ip; - enum pfxv_state val_res; + struct rtr_ip_addr ip; + enum rtr_pfxv_state val_res; - assert(!lrtr_ip_str_to_addr(prefix, &ip)); + assert(!rtr_ip_str_to_addr(prefix, &ip)); - assert(pfx_table_validate(pfxt, asn, &ip, prefix_len, &val_res) == PFX_SUCCESS); + assert(rtr_pfx_table_validate(pfxt, asn, &ip, prefix_len, &val_res) == RTR_PFX_SUCCESS); assert(val_res == expected_result); } /** * @brief remove_src_test - * This test verifies pfx_table_src_remove function. It first adds certain + * This test verifies rtr_pfx_table_src_remove function. It first adds certain * records with different sockets into a pfx_table. Afterwards entries with * socket tr1 are removed, and the remaining records are verified. */ static void remove_src_test(void) { - struct pfx_table pfxt; + struct rtr_pfx_table pfxt; struct rtr_socket tr1; - struct pfx_record pfx; + struct rtr_pfx_record pfx; /* TEST1: init prefix table ----------------------------------------- */ - pfx_table_init(&pfxt, NULL); + rtr_pfx_table_init(&pfxt, NULL); pfx.min_len = 32; pfx.max_len = 32; /* TEST2: add and verify different prefixes -------------------------- */ pfx.asn = 80; pfx.socket = &tr1; - lrtr_ip_str_to_addr("10.11.10.0", &pfx.prefix); - assert(pfx_table_add(&pfxt, &pfx) == PFX_SUCCESS); + rtr_ip_str_to_addr("10.11.10.0", &pfx.prefix); + assert(rtr_pfx_table_add(&pfxt, &pfx) == RTR_PFX_SUCCESS); pfx.asn = 90; pfx.socket = NULL; - lrtr_ip_str_to_addr("10.11.10.0", &pfx.prefix); - assert(pfx_table_add(&pfxt, &pfx) == PFX_SUCCESS); + rtr_ip_str_to_addr("10.11.10.0", &pfx.prefix); + assert(rtr_pfx_table_add(&pfxt, &pfx) == RTR_PFX_SUCCESS); pfx.socket = NULL; pfx.min_len = 24; - lrtr_ip_str_to_addr("192.168.0.0", &pfx.prefix); - assert(pfx_table_add(&pfxt, &pfx) == PFX_SUCCESS); + rtr_ip_str_to_addr("192.168.0.0", &pfx.prefix); + assert(rtr_pfx_table_add(&pfxt, &pfx) == RTR_PFX_SUCCESS); pfx.socket = &tr1; pfx.min_len = 8; - lrtr_ip_str_to_addr("10.0.0.0", &pfx.prefix); - assert(pfx_table_add(&pfxt, &pfx) == PFX_SUCCESS); + rtr_ip_str_to_addr("10.0.0.0", &pfx.prefix); + assert(rtr_pfx_table_add(&pfxt, &pfx) == RTR_PFX_SUCCESS); unsigned int len = 0; struct trie_node **array = NULL; @@ -80,21 +80,21 @@ static void remove_src_test(void) assert((len + 1) == 3); /* remove entries with socket tr1, verify remaining 2 records */ - pfx_table_src_remove(&pfxt, &tr1); + rtr_pfx_table_src_remove(&pfxt, &tr1); len = 0; assert(trie_get_children(pfxt.ipv4, &array, &len) != -1); free(array); assert((len + 1) == 2); /* verify validation of prefixes */ - validate(&pfxt, 90, "10.0.0.0", 8, BGP_PFXV_STATE_NOT_FOUND); + validate(&pfxt, 90, "10.0.0.0", 8, RTR_BGP_PFXV_STATE_NOT_FOUND); - validate(&pfxt, 90, "10.11.10.0", 32, BGP_PFXV_STATE_VALID); + validate(&pfxt, 90, "10.11.10.0", 32, RTR_BGP_PFXV_STATE_VALID); - validate(&pfxt, 80, "10.11.10.0", 32, BGP_PFXV_STATE_INVALID); + validate(&pfxt, 80, "10.11.10.0", 32, RTR_BGP_PFXV_STATE_INVALID); /* cleanup: free table */ - pfx_table_free(&pfxt); + rtr_pfx_table_free(&pfxt); printf("%s() successful\n", __func__); } @@ -105,13 +105,13 @@ static void remove_src_test(void) */ static void mass_test(void) { - struct pfx_table pfxt; - struct pfx_record pfx; - enum pfxv_state res; + struct rtr_pfx_table pfxt; + struct rtr_pfx_record pfx; + enum rtr_pfxv_state res; const uint32_t min_i = 0xFFFF0000; const uint32_t max_i = 0xFFFFFFF0; /* init table with huge number of records */ - pfx_table_init(&pfxt, NULL); + rtr_pfx_table_init(&pfxt, NULL); printf("Inserting %u records\n", (max_i - min_i) * 3); for (uint32_t i = max_i; i >= min_i; i--) { pfx.min_len = 32; @@ -119,18 +119,18 @@ static void mass_test(void) pfx.socket = NULL; pfx.asn = i; pfx.prefix.u.addr4.addr = htonl(i); - pfx.prefix.ver = LRTR_IPV4; - assert(pfx_table_add(&pfxt, &pfx) == PFX_SUCCESS); + pfx.prefix.ver = RTR_IPV4; + assert(rtr_pfx_table_add(&pfxt, &pfx) == RTR_PFX_SUCCESS); /* add same prefix, with diff asn */ pfx.asn = i + 1; - assert(pfx_table_add(&pfxt, &pfx) == PFX_SUCCESS); + assert(rtr_pfx_table_add(&pfxt, &pfx) == RTR_PFX_SUCCESS); /* add same prefix, with diff len */ pfx.min_len = 128; pfx.max_len = 128; - pfx.prefix.ver = LRTR_IPV6; + pfx.prefix.ver = RTR_IPV6; ((uint32_t *)pfx.prefix.u.addr6.addr)[2] = max_i; ((uint32_t *)pfx.prefix.u.addr6.addr)[0] = min_i + i; - assert(pfx_table_add(&pfxt, &pfx) == PFX_SUCCESS); + assert(rtr_pfx_table_add(&pfxt, &pfx) == RTR_PFX_SUCCESS); } /* verify validation of huge number of records */ @@ -138,21 +138,21 @@ static void mass_test(void) for (uint32_t i = max_i; i >= min_i; i--) { pfx.min_len = 32; pfx.max_len = 32; - pfx.prefix.ver = LRTR_IPV4; + pfx.prefix.ver = RTR_IPV4; pfx.prefix.u.addr4.addr = htonl(i); - assert(pfx_table_validate(&pfxt, i, &pfx.prefix, pfx.min_len, &res) == PFX_SUCCESS); - assert(res == BGP_PFXV_STATE_VALID); - assert(pfx_table_validate(&pfxt, i + 1, &pfx.prefix, pfx.min_len, &res) == PFX_SUCCESS); - assert(res == BGP_PFXV_STATE_VALID); + assert(rtr_pfx_table_validate(&pfxt, i, &pfx.prefix, pfx.min_len, &res) == RTR_PFX_SUCCESS); + assert(res == RTR_BGP_PFXV_STATE_VALID); + assert(rtr_pfx_table_validate(&pfxt, i + 1, &pfx.prefix, pfx.min_len, &res) == RTR_PFX_SUCCESS); + assert(res == RTR_BGP_PFXV_STATE_VALID); pfx.min_len = 128; pfx.max_len = 128; - pfx.prefix.ver = LRTR_IPV6; + pfx.prefix.ver = RTR_IPV6; ((uint32_t *)pfx.prefix.u.addr6.addr)[2] = max_i; ((uint32_t *)pfx.prefix.u.addr6.addr)[0] = min_i + i; - assert(pfx_table_validate(&pfxt, i + 1, &pfx.prefix, pfx.min_len, &res) == PFX_SUCCESS); - assert(res == BGP_PFXV_STATE_VALID); + assert(rtr_pfx_table_validate(&pfxt, i + 1, &pfx.prefix, pfx.min_len, &res) == RTR_PFX_SUCCESS); + assert(res == RTR_BGP_PFXV_STATE_VALID); } /* verify removal of huge number of records */ @@ -162,213 +162,213 @@ static void mass_test(void) pfx.min_len = 32; pfx.max_len = 32; pfx.asn = i; - pfx.prefix.ver = LRTR_IPV4; + pfx.prefix.ver = RTR_IPV4; pfx.prefix.u.addr4.addr = htonl(i); - assert(pfx_table_remove(&pfxt, &pfx) == PFX_SUCCESS); + assert(rtr_pfx_table_remove(&pfxt, &pfx) == RTR_PFX_SUCCESS); pfx.asn = i + 1; - assert(pfx_table_remove(&pfxt, &pfx) == PFX_SUCCESS); + assert(rtr_pfx_table_remove(&pfxt, &pfx) == RTR_PFX_SUCCESS); - pfx.prefix.ver = LRTR_IPV6; + pfx.prefix.ver = RTR_IPV6; pfx.min_len = 128; pfx.max_len = 128; ((uint32_t *)pfx.prefix.u.addr6.addr)[2] = max_i; ((uint32_t *)pfx.prefix.u.addr6.addr)[0] = min_i + i; - assert(pfx_table_remove(&pfxt, &pfx) == PFX_SUCCESS); + assert(rtr_pfx_table_remove(&pfxt, &pfx) == RTR_PFX_SUCCESS); } /* cleanup: free table */ - pfx_table_free(&pfxt); + rtr_pfx_table_free(&pfxt); printf("%s() successful\n", __func__); } /** * @brief Test of pfx_table functions * This test verifies pfx_table and its core functions, namely - * pfx_table_add and pfx_table_validate. + * rtr_pfx_table_add and rtr_pfx_table_validate. */ static void pfx_table_test(void) { - struct pfx_table pfxt; - struct pfx_record pfx; - enum pfxv_state res; + struct rtr_pfx_table pfxt; + struct rtr_pfx_record pfx; + enum rtr_pfxv_state res; - pfx_table_init(&pfxt, NULL); + rtr_pfx_table_init(&pfxt, NULL); pfx.asn = 123; - pfx.prefix.ver = LRTR_IPV4; - lrtr_ip_str_to_addr("10.10.0.0", &pfx.prefix); + pfx.prefix.ver = RTR_IPV4; + rtr_ip_str_to_addr("10.10.0.0", &pfx.prefix); pfx.min_len = 16; pfx.max_len = 24; - assert(pfx_table_add(&pfxt, &pfx) == PFX_SUCCESS); + assert(rtr_pfx_table_add(&pfxt, &pfx) == RTR_PFX_SUCCESS); - validate(&pfxt, 123, "10.10.0.0", 16, BGP_PFXV_STATE_VALID); - validate(&pfxt, 124, "10.10.0.0", 16, BGP_PFXV_STATE_INVALID); - validate(&pfxt, 123, "10.10.0.0", 24, BGP_PFXV_STATE_VALID); - validate(&pfxt, 123, "10.10.10.0", 20, BGP_PFXV_STATE_VALID); - validate(&pfxt, 123, "10.10.10.0", 25, BGP_PFXV_STATE_INVALID); - validate(&pfxt, 123, "10.11.10.0", 16, BGP_PFXV_STATE_NOT_FOUND); + validate(&pfxt, 123, "10.10.0.0", 16, RTR_BGP_PFXV_STATE_VALID); + validate(&pfxt, 124, "10.10.0.0", 16, RTR_BGP_PFXV_STATE_INVALID); + validate(&pfxt, 123, "10.10.0.0", 24, RTR_BGP_PFXV_STATE_VALID); + validate(&pfxt, 123, "10.10.10.0", 20, RTR_BGP_PFXV_STATE_VALID); + validate(&pfxt, 123, "10.10.10.0", 25, RTR_BGP_PFXV_STATE_INVALID); + validate(&pfxt, 123, "10.11.10.0", 16, RTR_BGP_PFXV_STATE_NOT_FOUND); - lrtr_ip_str_to_addr("10.10.0.0", &pfx.prefix); + rtr_ip_str_to_addr("10.10.0.0", &pfx.prefix); pfx.asn = 122; - assert(pfx_table_add(&pfxt, &pfx) == PFX_SUCCESS); - validate(&pfxt, 122, "10.10.0.0", 18, BGP_PFXV_STATE_VALID); + assert(rtr_pfx_table_add(&pfxt, &pfx) == RTR_PFX_SUCCESS); + validate(&pfxt, 122, "10.10.0.0", 18, RTR_BGP_PFXV_STATE_VALID); - lrtr_ip_str_to_addr("11.10.0.0", &pfx.prefix); + rtr_ip_str_to_addr("11.10.0.0", &pfx.prefix); pfx.asn = 22; pfx.min_len = 17; - assert(pfx_table_add(&pfxt, &pfx) == PFX_SUCCESS); - validate(&pfxt, 22, "11.10.0.0", 17, BGP_PFXV_STATE_VALID); + assert(rtr_pfx_table_add(&pfxt, &pfx) == RTR_PFX_SUCCESS); + validate(&pfxt, 22, "11.10.0.0", 17, RTR_BGP_PFXV_STATE_VALID); - lrtr_ip_str_to_addr("2a01:4f8:131::", &pfx.prefix); - pfx.prefix.ver = LRTR_IPV6; + rtr_ip_str_to_addr("2a01:4f8:131::", &pfx.prefix); + pfx.prefix.ver = RTR_IPV6; pfx.min_len = 48; pfx.max_len = 48; pfx.asn = 124; - assert(pfx_table_add(&pfxt, &pfx) == PFX_SUCCESS); - assert(pfx_table_validate(&pfxt, 124, &pfx.prefix, 48, &res) == PFX_SUCCESS); - validate(&pfxt, 124, "2a01:4f8:131::", 48, BGP_PFXV_STATE_VALID); + assert(rtr_pfx_table_add(&pfxt, &pfx) == RTR_PFX_SUCCESS); + assert(rtr_pfx_table_validate(&pfxt, 124, &pfx.prefix, 48, &res) == RTR_PFX_SUCCESS); + validate(&pfxt, 124, "2a01:4f8:131::", 48, RTR_BGP_PFXV_STATE_VALID); - validate(&pfxt, 124, "2a01:4f8:131:15::", 56, BGP_PFXV_STATE_INVALID); + validate(&pfxt, 124, "2a01:4f8:131:15::", 56, RTR_BGP_PFXV_STATE_INVALID); - assert(lrtr_ip_str_to_addr("1.0.4.0", &pfx.prefix) == 0); + assert(rtr_ip_str_to_addr("1.0.4.0", &pfx.prefix) == 0); pfx.min_len = 22; pfx.max_len = 22; pfx.asn = 56203; - assert(pfx_table_add(&pfxt, &pfx) == PFX_SUCCESS); - validate(&pfxt, pfx.asn, "1.0.4.0", pfx.min_len, BGP_PFXV_STATE_VALID); + assert(rtr_pfx_table_add(&pfxt, &pfx) == RTR_PFX_SUCCESS); + validate(&pfxt, pfx.asn, "1.0.4.0", pfx.min_len, RTR_BGP_PFXV_STATE_VALID); - assert(lrtr_ip_str_to_addr("1.8.1.0", &pfx.prefix) == 0); + assert(rtr_ip_str_to_addr("1.8.1.0", &pfx.prefix) == 0); pfx.min_len = 24; pfx.max_len = 24; pfx.asn = 38345; - assert(pfx_table_add(&pfxt, &pfx) == PFX_SUCCESS); - validate(&pfxt, pfx.asn, "1.8.1.0", pfx.min_len, BGP_PFXV_STATE_VALID); + assert(rtr_pfx_table_add(&pfxt, &pfx) == RTR_PFX_SUCCESS); + validate(&pfxt, pfx.asn, "1.8.1.0", pfx.min_len, RTR_BGP_PFXV_STATE_VALID); - assert(lrtr_ip_str_to_addr("1.8.8.0", &pfx.prefix) == 0); + assert(rtr_ip_str_to_addr("1.8.8.0", &pfx.prefix) == 0); pfx.min_len = 24; pfx.max_len = 24; pfx.asn = 38345; - assert(pfx_table_add(&pfxt, &pfx) == PFX_SUCCESS); - validate(&pfxt, pfx.asn, "1.8.8.0", pfx.min_len, BGP_PFXV_STATE_VALID); - pfx_table_free(&pfxt); + assert(rtr_pfx_table_add(&pfxt, &pfx) == RTR_PFX_SUCCESS); + validate(&pfxt, pfx.asn, "1.8.8.0", pfx.min_len, RTR_BGP_PFXV_STATE_VALID); + rtr_pfx_table_free(&pfxt); - assert(lrtr_ip_str_to_addr("1.0.65.0", &pfx.prefix) == 0); + assert(rtr_ip_str_to_addr("1.0.65.0", &pfx.prefix) == 0); pfx.min_len = 18; pfx.max_len = 18; pfx.asn = 18144; - assert(pfx_table_add(&pfxt, &pfx) == PFX_SUCCESS); - validate(&pfxt, pfx.asn, "1.0.65.0", pfx.min_len, BGP_PFXV_STATE_VALID); - pfx_table_free(&pfxt); + assert(rtr_pfx_table_add(&pfxt, &pfx) == RTR_PFX_SUCCESS); + validate(&pfxt, pfx.asn, "1.0.65.0", pfx.min_len, RTR_BGP_PFXV_STATE_VALID); + rtr_pfx_table_free(&pfxt); - assert(lrtr_ip_str_to_addr("10.0.0.0", &pfx.prefix) == 0); + assert(rtr_ip_str_to_addr("10.0.0.0", &pfx.prefix) == 0); pfx.min_len = 16; pfx.max_len = 16; pfx.asn = 123; - assert(pfx_table_add(&pfxt, &pfx) == PFX_SUCCESS); - validate(&pfxt, pfx.asn, "10.0.0.0", pfx.min_len, BGP_PFXV_STATE_VALID); - validate(&pfxt, 124, "10.0.5.0", 24, BGP_PFXV_STATE_INVALID); - pfx_table_free(&pfxt); + assert(rtr_pfx_table_add(&pfxt, &pfx) == RTR_PFX_SUCCESS); + validate(&pfxt, pfx.asn, "10.0.0.0", pfx.min_len, RTR_BGP_PFXV_STATE_VALID); + validate(&pfxt, 124, "10.0.5.0", 24, RTR_BGP_PFXV_STATE_INVALID); + rtr_pfx_table_free(&pfxt); - assert(lrtr_ip_str_to_addr("109.105.96.0", &pfx.prefix) == 0); + assert(rtr_ip_str_to_addr("109.105.96.0", &pfx.prefix) == 0); pfx.min_len = 19; pfx.max_len = 19; pfx.asn = 123; - assert(pfx_table_add(&pfxt, &pfx) == PFX_SUCCESS); - validate(&pfxt, 456, "109.105.128.0", 20, BGP_PFXV_STATE_NOT_FOUND); - pfx_table_free(&pfxt); + assert(rtr_pfx_table_add(&pfxt, &pfx) == RTR_PFX_SUCCESS); + validate(&pfxt, 456, "109.105.128.0", 20, RTR_BGP_PFXV_STATE_NOT_FOUND); + rtr_pfx_table_free(&pfxt); - assert(lrtr_ip_str_to_addr("190.57.224.0", &pfx.prefix) == 0); + assert(rtr_ip_str_to_addr("190.57.224.0", &pfx.prefix) == 0); pfx.min_len = 19; pfx.max_len = 24; pfx.asn = 123; - assert(pfx_table_add(&pfxt, &pfx) == PFX_SUCCESS); - validate(&pfxt, 123, "190.57.72.0", 21, BGP_PFXV_STATE_NOT_FOUND); - pfx_table_free(&pfxt); + assert(rtr_pfx_table_add(&pfxt, &pfx) == RTR_PFX_SUCCESS); + validate(&pfxt, 123, "190.57.72.0", 21, RTR_BGP_PFXV_STATE_NOT_FOUND); + rtr_pfx_table_free(&pfxt); - assert(lrtr_ip_str_to_addr("80.253.128.0", &pfx.prefix) == 0); + assert(rtr_ip_str_to_addr("80.253.128.0", &pfx.prefix) == 0); pfx.min_len = 19; pfx.max_len = 19; pfx.asn = 123; - assert(pfx_table_add(&pfxt, &pfx) == PFX_SUCCESS); - validate(&pfxt, 123, "80.253.144.0", 20, BGP_PFXV_STATE_INVALID); + assert(rtr_pfx_table_add(&pfxt, &pfx) == RTR_PFX_SUCCESS); + validate(&pfxt, 123, "80.253.144.0", 20, RTR_BGP_PFXV_STATE_INVALID); - assert(lrtr_ip_str_to_addr("10.10.0.0", &pfx.prefix) == 0); + assert(rtr_ip_str_to_addr("10.10.0.0", &pfx.prefix) == 0); pfx.min_len = 16; pfx.max_len = 16; pfx.asn = 0; - assert(pfx_table_add(&pfxt, &pfx) == PFX_SUCCESS); - validate(&pfxt, 123, "10.10.0.0", 16, BGP_PFXV_STATE_INVALID); + assert(rtr_pfx_table_add(&pfxt, &pfx) == RTR_PFX_SUCCESS); + validate(&pfxt, 123, "10.10.0.0", 16, RTR_BGP_PFXV_STATE_INVALID); - assert(lrtr_ip_str_to_addr("10.0.0.0", &pfx.prefix) == 0); + assert(rtr_ip_str_to_addr("10.0.0.0", &pfx.prefix) == 0); pfx.min_len = 8; pfx.max_len = 15; pfx.asn = 6; - assert(pfx_table_add(&pfxt, &pfx) == PFX_SUCCESS); + assert(rtr_pfx_table_add(&pfxt, &pfx) == RTR_PFX_SUCCESS); - assert(lrtr_ip_str_to_addr("10.0.0.0", &pfx.prefix) == 0); + assert(rtr_ip_str_to_addr("10.0.0.0", &pfx.prefix) == 0); pfx.min_len = 8; pfx.max_len = 15; pfx.asn = 5; - assert(pfx_table_add(&pfxt, &pfx) == PFX_SUCCESS); + assert(rtr_pfx_table_add(&pfxt, &pfx) == RTR_PFX_SUCCESS); - assert(lrtr_ip_str_to_addr("10.1.0.0", &pfx.prefix) == 0); + assert(rtr_ip_str_to_addr("10.1.0.0", &pfx.prefix) == 0); pfx.min_len = 16; pfx.max_len = 16; pfx.asn = 5; - assert(pfx_table_add(&pfxt, &pfx) == PFX_SUCCESS); + assert(rtr_pfx_table_add(&pfxt, &pfx) == RTR_PFX_SUCCESS); - validate(&pfxt, 123, "10.1.0.0", 16, BGP_PFXV_STATE_INVALID); + validate(&pfxt, 123, "10.1.0.0", 16, RTR_BGP_PFXV_STATE_INVALID); /* cleanup: free record and table */ - pfx_table_free(&pfxt); + rtr_pfx_table_free(&pfxt); printf("%s() successful\n", __func__); } -static void create_ip4_pfx_record(struct pfx_record *pfx, uint32_t asn, const char *ip, uint8_t min_mask_len, +static void create_ip4_pfx_record(struct rtr_pfx_record *pfx, uint32_t asn, const char *ip, uint8_t min_mask_len, uint8_t max_mask_len) { pfx->asn = asn; pfx->min_len = min_mask_len; pfx->max_len = max_mask_len; pfx->socket = (struct rtr_socket *)1; - assert(!lrtr_ip_str_to_addr(ip, &pfx->prefix)); + assert(!rtr_ip_str_to_addr(ip, &pfx->prefix)); } -static void add_ip4_pfx_record(struct pfx_table *pfxt, uint32_t asn, const char *ip, uint8_t min_mask_len, +static void add_ip4_pfx_record(struct rtr_pfx_table *pfxt, uint32_t asn, const char *ip, uint8_t min_mask_len, uint8_t max_mask_len) { - struct pfx_record pfx; - enum pfxv_state val_res; + struct rtr_pfx_record pfx; + enum rtr_pfxv_state val_res; create_ip4_pfx_record(&pfx, asn, ip, min_mask_len, max_mask_len); - assert(pfx_table_add(pfxt, &pfx) == PFX_SUCCESS); + assert(rtr_pfx_table_add(pfxt, &pfx) == RTR_PFX_SUCCESS); - assert(pfx_table_validate(pfxt, pfx.asn, &pfx.prefix, pfx.min_len, &val_res) == PFX_SUCCESS); - assert(val_res == BGP_PFXV_STATE_VALID); + assert(rtr_pfx_table_validate(pfxt, pfx.asn, &pfx.prefix, pfx.min_len, &val_res) == RTR_PFX_SUCCESS); + assert(val_res == RTR_BGP_PFXV_STATE_VALID); } static void test_issue99(void) { - struct pfx_table pfxt; + struct rtr_pfx_table pfxt; - pfx_table_init(&pfxt, NULL); + rtr_pfx_table_init(&pfxt, NULL); add_ip4_pfx_record(&pfxt, 200, "10.100.255.0", 24, 24); add_ip4_pfx_record(&pfxt, 300, "255.0.0.0", 24, 24); add_ip4_pfx_record(&pfxt, 400, "128.0.0.0", 1, 24); - validate(&pfxt, 400, "255.0.0.0", 24, BGP_PFXV_STATE_VALID); - pfx_table_free(&pfxt); + validate(&pfxt, 400, "255.0.0.0", 24, RTR_BGP_PFXV_STATE_VALID); + rtr_pfx_table_free(&pfxt); } static void test_issue152(void) { - struct pfx_table pfxt; - struct pfx_record *records = calloc(6, sizeof(struct pfx_record)); + struct rtr_pfx_table pfxt; + struct rtr_pfx_record *records = calloc(6, sizeof(struct rtr_pfx_record)); - pfx_table_init(&pfxt, NULL); + rtr_pfx_table_init(&pfxt, NULL); create_ip4_pfx_record(&records[0], 1, "89.18.183.0", 24, 24); create_ip4_pfx_record(&records[1], 2, "109.164.0.0", 17, 25); create_ip4_pfx_record(&records[2], 3, "185.131.60.0", 22, 24); @@ -377,52 +377,53 @@ static void test_issue152(void) create_ip4_pfx_record(&records[5], 6, "213.175.86.0", 24, 24); for (size_t i = 0; i < 6; i++) - assert(pfx_table_add(&pfxt, &records[i]) == PFX_SUCCESS); + assert(rtr_pfx_table_add(&pfxt, &records[i]) == RTR_PFX_SUCCESS); for (size_t i = 0; i < 6; i++) - assert(pfx_table_remove(&pfxt, &records[i]) == PFX_SUCCESS); + assert(rtr_pfx_table_remove(&pfxt, &records[i]) == RTR_PFX_SUCCESS); free(records); } -static void update_cb1(struct pfx_table *p __attribute__((unused)), const struct pfx_record rec, const bool added) +static void update_cb1(struct rtr_pfx_table *p __attribute__((unused)), const struct rtr_pfx_record rec, + const enum rtr_pfx_operation_type operation_type) { char ip[INET6_ADDRSTRLEN]; - if (added) + if (operation_type == RTR_PFX_ADD) printf("+ "); else printf("- "); - lrtr_ip_addr_to_str(&rec.prefix, ip, sizeof(ip)); + rtr_ip_addr_to_str(&rec.prefix, ip, sizeof(ip)); printf("%-40s %3u - %3u %10u\n", ip, rec.min_len, rec.max_len, rec.asn); if (rec.asn == 1) - assert(!added); + assert(operation_type == RTR_PFX_REMOVE); if (rec.asn == 2) assert(false); if (rec.asn == 3) - assert(added); + assert(operation_type == RTR_PFX_ADD); } static void test_pfx_merge(void) { - struct pfx_table pfxt1; - struct pfx_table pfxt2; - struct pfx_record records[3]; + struct rtr_pfx_table pfxt1; + struct rtr_pfx_table pfxt2; + struct rtr_pfx_record records[3]; - pfx_table_init(&pfxt1, NULL); - pfx_table_init(&pfxt2, NULL); + rtr_pfx_table_init(&pfxt1, NULL); + rtr_pfx_table_init(&pfxt2, NULL); create_ip4_pfx_record(&records[0], 1, "1.1.1.1", 24, 24); create_ip4_pfx_record(&records[1], 2, "2.2.2.2", 24, 24); create_ip4_pfx_record(&records[2], 3, "3.3.3.3", 24, 24); printf("Adding to table one\n"); - assert(pfx_table_add(&pfxt1, &records[0]) == PFX_SUCCESS); - assert(pfx_table_add(&pfxt1, &records[1]) == PFX_SUCCESS); + assert(rtr_pfx_table_add(&pfxt1, &records[0]) == RTR_PFX_SUCCESS); + assert(rtr_pfx_table_add(&pfxt1, &records[1]) == RTR_PFX_SUCCESS); printf("Adding to table two\n"); - assert(pfx_table_add(&pfxt2, &records[1]) == PFX_SUCCESS); - assert(pfx_table_add(&pfxt2, &records[2]) == PFX_SUCCESS); + assert(rtr_pfx_table_add(&pfxt2, &records[1]) == RTR_PFX_SUCCESS); + assert(rtr_pfx_table_add(&pfxt2, &records[2]) == RTR_PFX_SUCCESS); printf("Computing diff\n"); pfxt1.update_fp = update_cb1; @@ -432,21 +433,21 @@ static void test_pfx_merge(void) pfxt2.update_fp = NULL; printf("Freeing table one\n"); - pfx_table_free(&pfxt1); + rtr_pfx_table_free(&pfxt1); printf("Freeing table two\n"); - pfx_table_free(&pfxt2); + rtr_pfx_table_free(&pfxt2); } static void test_pfx_table_add_null_arguments(void) { - struct pfx_table pfxt; - struct pfx_record records[1] = {0}; + struct rtr_pfx_table pfxt; + struct rtr_pfx_record records[1] = {0}; - pfx_table_init(&pfxt, NULL); + rtr_pfx_table_init(&pfxt, NULL); - assert(pfx_table_add(NULL, &records[0]) == PFX_NOT_INITIALIZED); - assert(pfx_table_add(NULL, NULL) == PFX_NOT_INITIALIZED); - assert(pfx_table_add(&pfxt, NULL) == PFX_ERROR); + assert(rtr_pfx_table_add(NULL, &records[0]) == RTR_PFX_NOT_INITIALIZED); + assert(rtr_pfx_table_add(NULL, NULL) == RTR_PFX_NOT_INITIALIZED); + assert(rtr_pfx_table_add(&pfxt, NULL) == RTR_PFX_ERROR); } int main(void) diff --git a/tests/test_pfx_locks.c b/tests/test_pfx_locks.c index 1decf913..0895d0da 100644 --- a/tests/test_pfx_locks.c +++ b/tests/test_pfx_locks.c @@ -27,14 +27,14 @@ uint32_t max_i = 0xFFFFFFF0; /** * @brief Add records to prefix table */ -static void *rec_add(struct pfx_table *pfxt) +static void *rec_add(struct rtr_pfx_table *pfxt) { const int tid = getpid(); - struct pfx_record rec; + struct rtr_pfx_record rec; rec.min_len = 32; rec.max_len = 32; - rec.prefix.ver = LRTR_IPV4; + rec.prefix.ver = RTR_IPV4; rec.prefix.u.addr4.addr = 0; printf("Inserting %u records\n", (max_i - min_i) * 3); @@ -44,17 +44,17 @@ static void *rec_add(struct pfx_table *pfxt) rec.socket = NULL; rec.asn = tid % 2; rec.prefix.u.addr4.addr = htonl(i); - rec.prefix.ver = LRTR_IPV4; - pfx_table_add(pfxt, &rec); + rec.prefix.ver = RTR_IPV4; + rtr_pfx_table_add(pfxt, &rec); rec.asn = (tid % 2) + 1; - pfx_table_add(pfxt, &rec); + rtr_pfx_table_add(pfxt, &rec); rec.min_len = 128; rec.max_len = 128; - rec.prefix.ver = LRTR_IPV6; + rec.prefix.ver = RTR_IPV6; rec.prefix.u.addr6.addr[1] = min_i + 0xFFFFFFFF; rec.prefix.u.addr6.addr[0] = htonl(i) + 0xFFFFFFFF; - pfx_table_add(pfxt, &rec); + rtr_pfx_table_add(pfxt, &rec); usleep(rand() / (RAND_MAX / 20)); } @@ -64,32 +64,32 @@ static void *rec_add(struct pfx_table *pfxt) /** * @brief Validate records in prefix table */ -static void *rec_val(struct pfx_table *pfxt) +static void *rec_val(struct rtr_pfx_table *pfxt) { const int tid = getpid(); - struct pfx_record rec; - enum pfxv_state res; + struct rtr_pfx_record rec; + enum rtr_pfxv_state res; rec.min_len = 32; rec.max_len = 32; - rec.prefix.ver = LRTR_IPV4; + rec.prefix.ver = RTR_IPV4; rec.prefix.u.addr4.addr = 0; printf("validating..\n"); for (uint32_t i = max_i; i >= min_i; i--) { rec.min_len = 32; rec.max_len = 32; - rec.prefix.ver = LRTR_IPV4; + rec.prefix.ver = RTR_IPV4; rec.prefix.u.addr4.addr = htonl(i); - pfx_table_validate(pfxt, (tid % 2), &rec.prefix, rec.min_len, &res); - pfx_table_validate(pfxt, (tid % 2) + 1, &rec.prefix, rec.min_len, &res); + rtr_pfx_table_validate(pfxt, (tid % 2), &rec.prefix, rec.min_len, &res); + rtr_pfx_table_validate(pfxt, (tid % 2) + 1, &rec.prefix, rec.min_len, &res); rec.min_len = 128; rec.max_len = 128; - rec.prefix.ver = LRTR_IPV6; + rec.prefix.ver = RTR_IPV6; rec.prefix.u.addr6.addr[1] = min_i + 0xFFFFFFFF; rec.prefix.u.addr6.addr[0] = htonl(i) + 0xFFFFFFFF; - pfx_table_validate(pfxt, (tid % 2) + 1, &rec.prefix, rec.min_len, &res); + rtr_pfx_table_validate(pfxt, (tid % 2) + 1, &rec.prefix, rec.min_len, &res); usleep(rand() / (RAND_MAX / 20)); } @@ -99,14 +99,14 @@ static void *rec_val(struct pfx_table *pfxt) /** * @brief Delete records from prefix table */ -static void *rec_del(struct pfx_table *pfxt) +static void *rec_del(struct rtr_pfx_table *pfxt) { const int tid = getpid(); - struct pfx_record rec; + struct rtr_pfx_record rec; rec.min_len = 32; rec.max_len = 32; - rec.prefix.ver = LRTR_IPV4; + rec.prefix.ver = RTR_IPV4; rec.prefix.u.addr4.addr = 0; printf("removing records\n"); for (uint32_t i = max_i; i >= min_i; i--) { @@ -114,19 +114,19 @@ static void *rec_del(struct pfx_table *pfxt) rec.min_len = 32; rec.max_len = 32; rec.asn = tid % 2; - rec.prefix.ver = LRTR_IPV4; + rec.prefix.ver = RTR_IPV4; rec.prefix.u.addr4.addr = htonl(i); - pfx_table_remove(pfxt, &rec); + rtr_pfx_table_remove(pfxt, &rec); rec.asn = (tid % 2) + 1; - pfx_table_remove(pfxt, &rec); + rtr_pfx_table_remove(pfxt, &rec); - rec.prefix.ver = LRTR_IPV6; + rec.prefix.ver = RTR_IPV6; rec.min_len = 128; rec.max_len = 128; rec.prefix.u.addr6.addr[1] = min_i + 0xFFFFFFFF; rec.prefix.u.addr6.addr[0] = htonl(i) + 0xFFFFFFFF; - pfx_table_remove(pfxt, &rec); + rtr_pfx_table_remove(pfxt, &rec); usleep(rand() / (RAND_MAX / 20)); } printf("Done\n"); @@ -144,10 +144,10 @@ static void *rec_del(struct pfx_table *pfxt) int main(void) { unsigned int max_threads = 15; - struct pfx_table pfxt; + struct rtr_pfx_table pfxt; pthread_t threads[max_threads]; - pfx_table_init(&pfxt, NULL); + rtr_pfx_table_init(&pfxt, NULL); srand(time(NULL)); for (unsigned int i = 0; i < max_threads; i++) { diff --git a/tests/test_trie.c b/tests/test_trie.c index e7ebb3c0..ae07a4f5 100644 --- a/tests/test_trie.c +++ b/tests/test_trie.c @@ -23,13 +23,13 @@ */ static void trie_test(void) { - struct lrtr_ip_addr addr; + struct rtr_ip_addr addr; struct trie_node *result; struct trie_node n1, n2, n3, n4; unsigned int lvl = 0; bool found; - addr.ver = LRTR_IPV4; + addr.ver = RTR_IPV4; /* node 1 * Tree after insert should be: @@ -41,16 +41,16 @@ static void trie_test(void) n1.rchild = NULL; n1.parent = NULL; n1.data = NULL; - lrtr_ip_str_to_addr("100.200.0.0", &n1.prefix); + rtr_ip_str_to_addr("100.200.0.0", &n1.prefix); addr = n1.prefix; result = trie_lookup(&n1, &addr, 16, &lvl); assert(result); - assert(lrtr_ip_str_cmp(&result->prefix, "100.200.0.0")); + assert(rtr_ip_str_cmp(&result->prefix, "100.200.0.0")); - lrtr_ip_str_to_addr("100.200.30.0", &addr); + rtr_ip_str_to_addr("100.200.30.0", &addr); result = trie_lookup(&n1, &addr, 16, &lvl); assert(result); - assert(lrtr_ip_str_cmp(&result->prefix, "100.200.0.0")); + assert(rtr_ip_str_cmp(&result->prefix, "100.200.0.0")); /* node 2 * Tree after insert should be: @@ -63,13 +63,13 @@ static void trie_test(void) n2.rchild = NULL; n2.parent = NULL; n2.data = NULL; - lrtr_ip_str_to_addr("132.200.0.0", &n2.prefix); + rtr_ip_str_to_addr("132.200.0.0", &n2.prefix); trie_insert(&n1, &n2, 0); - lrtr_ip_str_to_addr("132.200.0.0", &addr); + rtr_ip_str_to_addr("132.200.0.0", &addr); lvl = 0; result = trie_lookup(&n1, &addr, 16, &lvl); assert(result); - assert(lrtr_ip_str_cmp(&result->prefix, "132.200.0.0")); + assert(rtr_ip_str_cmp(&result->prefix, "132.200.0.0")); assert(n1.rchild == &n2); /* node 3 @@ -84,13 +84,13 @@ static void trie_test(void) n3.parent = NULL; n3.data = NULL; - lrtr_ip_str_to_addr("101.200.0.0", &n3.prefix); + rtr_ip_str_to_addr("101.200.0.0", &n3.prefix); trie_insert(&n1, &n3, 0); - lrtr_ip_str_to_addr("101.200.0.0", &addr); + rtr_ip_str_to_addr("101.200.0.0", &addr); lvl = 0; result = trie_lookup(&n1, &addr, 16, &lvl); assert(result); - assert(lrtr_ip_str_cmp(&result->prefix, "101.200.0.0")); + assert(rtr_ip_str_cmp(&result->prefix, "101.200.0.0")); assert(n1.lchild == &n3); /* node 4 @@ -107,52 +107,52 @@ static void trie_test(void) n4.parent = NULL; n4.data = NULL; - lrtr_ip_str_to_addr("132.201.3.0", &n4.prefix); + rtr_ip_str_to_addr("132.201.3.0", &n4.prefix); trie_insert(&n1, &n4, 0); - lrtr_ip_str_to_addr("132.201.3.0", &addr); + rtr_ip_str_to_addr("132.201.3.0", &addr); lvl = 0; result = trie_lookup(&n1, &addr, 24, &lvl); assert(result); - assert(lrtr_ip_str_cmp(&result->prefix, "132.201.3.0")); + assert(rtr_ip_str_cmp(&result->prefix, "132.201.3.0")); - assert(lrtr_ip_str_cmp(&n1.prefix, "100.200.0.0")); + assert(rtr_ip_str_cmp(&n1.prefix, "100.200.0.0")); assert(n1.len == 16); /* verify tree structure */ - assert(lrtr_ip_str_cmp(&n1.lchild->prefix, "101.200.0.0")); + assert(rtr_ip_str_cmp(&n1.lchild->prefix, "101.200.0.0")); assert(n1.lchild->len == 16); - assert(lrtr_ip_str_cmp(&n1.rchild->prefix, "132.200.0.0")); + assert(rtr_ip_str_cmp(&n1.rchild->prefix, "132.200.0.0")); assert(n1.rchild->len == 16); - assert(lrtr_ip_str_cmp(&n1.rchild->lchild->prefix, "132.201.3.0")); + assert(rtr_ip_str_cmp(&n1.rchild->lchild->prefix, "132.201.3.0")); assert(n1.rchild->lchild->len == 24); - lrtr_ip_str_to_addr("132.200.0.0", &addr); + rtr_ip_str_to_addr("132.200.0.0", &addr); lvl = 0; result = trie_lookup(&n1, &addr, 16, &lvl); assert(result); - assert(lrtr_ip_str_cmp(&result->prefix, "132.200.0.0")); + assert(rtr_ip_str_cmp(&result->prefix, "132.200.0.0")); /* verify that a search for 132.200.3.0 returns 132.200/16 */ - lrtr_ip_str_to_addr("132.200.3.0", &addr); + rtr_ip_str_to_addr("132.200.3.0", &addr); lvl = 0; result = trie_lookup(&n1, &addr, 16, &lvl); assert(result); - assert(lrtr_ip_str_cmp(&result->prefix, "132.200.0.0")); + assert(rtr_ip_str_cmp(&result->prefix, "132.200.0.0")); /* verify no result for prefix 132.0.0.0/16 is found */ lvl = 0; - lrtr_ip_str_to_addr("132.0.0.0", &addr); + rtr_ip_str_to_addr("132.0.0.0", &addr); result = trie_lookup_exact(&n1, &addr, 16, &lvl, &found); assert(!found); /* verify trie_lookup_exact for prefix 132.201.3.0/24 is found */ lvl = 0; - lrtr_ip_str_to_addr("132.201.3.0", &addr); + rtr_ip_str_to_addr("132.201.3.0", &addr); result = trie_lookup_exact(&n1, &addr, 24, &lvl, &found); assert(found); - assert(lrtr_ip_str_cmp(&result->prefix, "132.201.3.0")); + assert(rtr_ip_str_cmp(&result->prefix, "132.201.3.0")); /* remove root->rchild * Tree after remove should be: @@ -160,12 +160,12 @@ static void trie_test(void) * / \ * 101.200.0.0/16 132.201.3.0/24 */ - lrtr_ip_str_to_addr("132.200.0.0", &addr); + rtr_ip_str_to_addr("132.200.0.0", &addr); result = trie_remove(&n1, &addr, 16, 0); assert(result); - assert(lrtr_ip_str_cmp(&n1.prefix, "100.200.0.0")); - assert(lrtr_ip_str_cmp(&n1.lchild->prefix, "101.200.0.0")); - assert(lrtr_ip_str_cmp(&n1.rchild->prefix, "132.201.3.0")); + assert(rtr_ip_str_cmp(&n1.prefix, "100.200.0.0")); + assert(rtr_ip_str_cmp(&n1.lchild->prefix, "101.200.0.0")); + assert(rtr_ip_str_cmp(&n1.rchild->prefix, "132.201.3.0")); assert(!n1.rchild->lchild); /* remove root->lchild @@ -174,19 +174,19 @@ static void trie_test(void) * \ * 132.201.3.0/24 */ - lrtr_ip_str_to_addr("101.200.0.0", &addr); + rtr_ip_str_to_addr("101.200.0.0", &addr); result = trie_remove(&n1, &addr, 16, 0); assert(result); - assert(lrtr_ip_str_cmp(&n1.rchild->prefix, "132.201.3.0")); + assert(rtr_ip_str_cmp(&n1.rchild->prefix, "132.201.3.0")); assert(!n1.lchild); /* remove root node * Tree after remove should be: * 132.201.3.0/24 */ - lrtr_ip_str_to_addr("100.200.0.0", &addr); + rtr_ip_str_to_addr("100.200.0.0", &addr); result = trie_remove(&n1, &addr, 16, 0); - assert(lrtr_ip_str_cmp(&n1.prefix, "132.201.3.0")); + assert(rtr_ip_str_cmp(&n1.prefix, "132.201.3.0")); assert(result); assert(!n1.lchild); assert(!n1.rchild); diff --git a/tests/unittests/CMakeLists.txt b/tests/unittests/CMakeLists.txt index 827901e0..2ccba752 100644 --- a/tests/unittests/CMakeLists.txt +++ b/tests/unittests/CMakeLists.txt @@ -1,7 +1,7 @@ add_rtr_unit_test(test_packets_static test_packets_static.c rtrlib_static cmocka) -wrap_functions(test_packets_static lrtr_get_monotonic_time tr_send_all) +wrap_functions(test_packets_static rtr_get_monotonic_time tr_send_all) add_rtr_unit_test(test_packets test_packets.c rtrlib_static cmocka) wrap_functions(test_packets rtr_change_socket_state tr_send_all) diff --git a/tests/unittests/test_bgpsec_signing.c b/tests/unittests/test_bgpsec_signing.c index 4cd86141..5debf98b 100644 --- a/tests/unittests/test_bgpsec_signing.c +++ b/tests/unittests/test_bgpsec_signing.c @@ -28,14 +28,14 @@ struct rtr_bgpsec *setup_bgpsec(void) pfx = rtr_bgpsec_nlri_new(3); assert(pfx != NULL); pfx->nlri_len = 24; - pfx->afi = 1; /* LRTR_IPV4 */ + pfx->afi = 1; /* RTR_IPV4 */ pfx_int = htonl(3221225984); /* 192.0.2.0 */ memcpy(pfx->nlri, &pfx_int, 3); bgpsec = rtr_bgpsec_new(alg, safi, afi, my_as, target_as, pfx); - bgpsec->path = lrtr_malloc(sizeof(struct rtr_secure_path_seg)); - bgpsec->sigs = lrtr_malloc(sizeof(struct rtr_signature_seg)); + bgpsec->path = rtr_malloc(sizeof(struct rtr_secure_path_seg)); + bgpsec->sigs = rtr_malloc(sizeof(struct rtr_signature_seg)); bgpsec->path->next = NULL; bgpsec->sigs->next = NULL; bgpsec->sigs->sig_len = 0; @@ -93,10 +93,10 @@ int __wrap_sign_byte_sequence(uint8_t *hash_result, EC_KEY *priv_key, uint8_t al static void test_sanity_checks(void **state) { struct rtr_bgpsec *bgpsec = setup_bgpsec(); - uint8_t *private_key = lrtr_malloc(20); + uint8_t *private_key = rtr_malloc(20); struct rtr_signature_seg *new_signature = NULL; enum rtr_bgpsec_rtvals result = RTR_BGPSEC_SUCCESS; - struct rtr_signature_seg *not_empty = lrtr_malloc(sizeof(struct rtr_signature_seg)); + struct rtr_signature_seg *not_empty = rtr_malloc(sizeof(struct rtr_signature_seg)); UNUSED(state); @@ -124,25 +124,25 @@ static void test_sanity_checks(void **state) result = rtr_bgpsec_generate_signature(bgpsec, private_key, ¬_empty); assert_int_equal(RTR_BGPSEC_INVALID_ARGUMENTS, result); - lrtr_free(bgpsec->path); - lrtr_free(bgpsec->sigs); + rtr_free(bgpsec->path); + rtr_free(bgpsec->sigs); bgpsec->path = NULL; result = rtr_bgpsec_generate_signature(bgpsec, private_key, &new_signature); assert_int_equal(RTR_BGPSEC_INVALID_ARGUMENTS, result); - lrtr_free(private_key); - lrtr_free(bgpsec->nlri->nlri); - lrtr_free(bgpsec->nlri); - lrtr_free(bgpsec); - lrtr_free(not_empty); + rtr_free(private_key); + rtr_free(bgpsec->nlri->nlri); + rtr_free(bgpsec->nlri); + rtr_free(bgpsec); + rtr_free(not_empty); rtr_bgpsec_free_signatures(new_signature); } static void test_load_private_key(void **state) { struct rtr_bgpsec *bgpsec = setup_bgpsec(); - uint8_t *private_key = lrtr_malloc(20); + uint8_t *private_key = rtr_malloc(20); struct rtr_signature_seg *new_signature = NULL; enum rtr_bgpsec_rtvals result = RTR_BGPSEC_SUCCESS; @@ -155,19 +155,19 @@ static void test_load_private_key(void **state) result = rtr_bgpsec_generate_signature(bgpsec, private_key, &new_signature); assert_int_equal(RTR_BGPSEC_LOAD_PRIV_KEY_ERROR, result); - lrtr_free(private_key); - lrtr_free(bgpsec->path); - lrtr_free(bgpsec->sigs); - lrtr_free(bgpsec->nlri->nlri); - lrtr_free(bgpsec->nlri); - lrtr_free(bgpsec); + rtr_free(private_key); + rtr_free(bgpsec->path); + rtr_free(bgpsec->sigs); + rtr_free(bgpsec->nlri->nlri); + rtr_free(bgpsec->nlri); + rtr_free(bgpsec); rtr_bgpsec_free_signatures(new_signature); } static void test_ecdsa_size(void **state) { struct rtr_bgpsec *bgpsec = setup_bgpsec(); - uint8_t *private_key = lrtr_malloc(20); + uint8_t *private_key = rtr_malloc(20); struct rtr_signature_seg *new_signature = NULL; enum rtr_bgpsec_rtvals result = RTR_BGPSEC_SUCCESS; @@ -181,19 +181,19 @@ static void test_ecdsa_size(void **state) result = rtr_bgpsec_generate_signature(bgpsec, private_key, &new_signature); assert_int_equal(RTR_BGPSEC_LOAD_PRIV_KEY_ERROR, result); - lrtr_free(private_key); - lrtr_free(bgpsec->path); - lrtr_free(bgpsec->sigs); - lrtr_free(bgpsec->nlri->nlri); - lrtr_free(bgpsec->nlri); - lrtr_free(bgpsec); + rtr_free(private_key); + rtr_free(bgpsec->path); + rtr_free(bgpsec->sigs); + rtr_free(bgpsec->nlri->nlri); + rtr_free(bgpsec->nlri); + rtr_free(bgpsec); rtr_bgpsec_free_signatures(new_signature); } static void test_align_byte_sequence(void **state) { struct rtr_bgpsec *bgpsec = setup_bgpsec(); - uint8_t *private_key = lrtr_malloc(20); + uint8_t *private_key = rtr_malloc(20); struct rtr_signature_seg *new_signature = NULL; enum rtr_bgpsec_rtvals result = RTR_BGPSEC_SUCCESS; @@ -209,19 +209,19 @@ static void test_align_byte_sequence(void **state) result = rtr_bgpsec_generate_signature(bgpsec, private_key, &new_signature); assert_int_equal(RTR_BGPSEC_ERROR, result); - lrtr_free(private_key); - lrtr_free(bgpsec->path); - lrtr_free(bgpsec->sigs); - lrtr_free(bgpsec->nlri->nlri); - lrtr_free(bgpsec->nlri); - lrtr_free(bgpsec); + rtr_free(private_key); + rtr_free(bgpsec->path); + rtr_free(bgpsec->sigs); + rtr_free(bgpsec->nlri->nlri); + rtr_free(bgpsec->nlri); + rtr_free(bgpsec); rtr_bgpsec_free_signatures(new_signature); } static void test_hash_byte_sequence(void **state) { struct rtr_bgpsec *bgpsec = setup_bgpsec(); - uint8_t *private_key = lrtr_malloc(20); + uint8_t *private_key = rtr_malloc(20); struct rtr_signature_seg *new_signature = NULL; enum rtr_bgpsec_rtvals result = RTR_BGPSEC_SUCCESS; @@ -238,19 +238,19 @@ static void test_hash_byte_sequence(void **state) result = rtr_bgpsec_generate_signature(bgpsec, private_key, &new_signature); assert_int_equal(RTR_BGPSEC_ERROR, result); - lrtr_free(private_key); - lrtr_free(bgpsec->path); - lrtr_free(bgpsec->sigs); - lrtr_free(bgpsec->nlri->nlri); - lrtr_free(bgpsec->nlri); - lrtr_free(bgpsec); + rtr_free(private_key); + rtr_free(bgpsec->path); + rtr_free(bgpsec->sigs); + rtr_free(bgpsec->nlri->nlri); + rtr_free(bgpsec->nlri); + rtr_free(bgpsec); rtr_bgpsec_free_signatures(new_signature); } static void test_sign_byte_sequence(void **state) { struct rtr_bgpsec *bgpsec = setup_bgpsec(); - uint8_t *private_key = lrtr_malloc(20); + uint8_t *private_key = rtr_malloc(20); struct rtr_signature_seg *new_signature = NULL; enum rtr_bgpsec_rtvals result = RTR_BGPSEC_SUCCESS; @@ -268,12 +268,12 @@ static void test_sign_byte_sequence(void **state) result = rtr_bgpsec_generate_signature(bgpsec, private_key, &new_signature); assert_int_equal(RTR_BGPSEC_SIGNING_ERROR, result); - lrtr_free(private_key); - lrtr_free(bgpsec->path); - lrtr_free(bgpsec->sigs); - lrtr_free(bgpsec->nlri->nlri); - lrtr_free(bgpsec->nlri); - lrtr_free(bgpsec); + rtr_free(private_key); + rtr_free(bgpsec->path); + rtr_free(bgpsec->sigs); + rtr_free(bgpsec->nlri->nlri); + rtr_free(bgpsec->nlri); + rtr_free(bgpsec); } int main(void) diff --git a/tests/unittests/test_bgpsec_validation.c b/tests/unittests/test_bgpsec_validation.c index 56e3b416..ed0ba345 100644 --- a/tests/unittests/test_bgpsec_validation.c +++ b/tests/unittests/test_bgpsec_validation.c @@ -29,14 +29,14 @@ struct rtr_bgpsec *setup_bgpsec(void) pfx = rtr_bgpsec_nlri_new(3); assert(pfx != NULL); pfx->nlri_len = 24; - pfx->afi = 1; /* LRTR_IPV4 */ + pfx->afi = 1; /* RTR_IPV4 */ pfx_int = htonl(3221225984); /* 192.0.2.0 */ memcpy(pfx->nlri, &pfx_int, 3); bgpsec = rtr_bgpsec_new(alg, safi, afi, my_as, target_as, pfx); - bgpsec->path = lrtr_malloc(sizeof(struct rtr_secure_path_seg)); - bgpsec->sigs = lrtr_malloc(sizeof(struct rtr_signature_seg)); + bgpsec->path = rtr_malloc(sizeof(struct rtr_secure_path_seg)); + bgpsec->sigs = rtr_malloc(sizeof(struct rtr_signature_seg)); bgpsec->path->next = NULL; bgpsec->sigs->next = NULL; bgpsec->sigs->sig_len = 0; @@ -96,7 +96,7 @@ int __wrap_spki_table_search_by_ski(struct spki_table *spki_table, uint8_t *ski, static void test_sanity_checks(void **state) { struct rtr_bgpsec *bgpsec = setup_bgpsec(); - struct spki_table *table = lrtr_malloc(16); + struct spki_table *table = rtr_malloc(16); enum rtr_bgpsec_rtvals result = RTR_BGPSEC_SUCCESS; UNUSED(state); @@ -129,8 +129,8 @@ static void test_sanity_checks(void **state) result = rtr_bgpsec_validate_as_path(bgpsec, table); assert_int_equal(RTR_BGPSEC_UNSUPPORTED_AFI, result); - lrtr_free(bgpsec->path); - lrtr_free(bgpsec->sigs); + rtr_free(bgpsec->path); + rtr_free(bgpsec->sigs); bgpsec->path = NULL; bgpsec->sigs = NULL; @@ -138,16 +138,16 @@ static void test_sanity_checks(void **state) result = rtr_bgpsec_validate_as_path(bgpsec, table); assert_int_equal(RTR_BGPSEC_INVALID_ARGUMENTS, result); - lrtr_free(table); - lrtr_free(bgpsec->nlri->nlri); - lrtr_free(bgpsec->nlri); - lrtr_free(bgpsec); + rtr_free(table); + rtr_free(bgpsec->nlri->nlri); + rtr_free(bgpsec->nlri); + rtr_free(bgpsec); } static void test_check_router_keys(void **state) { struct rtr_bgpsec *bgpsec = setup_bgpsec(); - struct spki_table *table = lrtr_malloc(16); + struct spki_table *table = rtr_malloc(16); enum rtr_bgpsec_rtvals result = RTR_BGPSEC_SUCCESS; UNUSED(state); @@ -157,18 +157,18 @@ static void test_check_router_keys(void **state) assert_int_equal(RTR_BGPSEC_ROUTER_KEY_NOT_FOUND, result); - lrtr_free(table); - lrtr_free(bgpsec->path); - lrtr_free(bgpsec->sigs); - lrtr_free(bgpsec->nlri->nlri); - lrtr_free(bgpsec->nlri); - lrtr_free(bgpsec); + rtr_free(table); + rtr_free(bgpsec->path); + rtr_free(bgpsec->sigs); + rtr_free(bgpsec->nlri->nlri); + rtr_free(bgpsec->nlri); + rtr_free(bgpsec); } static void test_align_byte_sequence(void **state) { struct rtr_bgpsec *bgpsec = setup_bgpsec(); - struct spki_table *table = lrtr_malloc(16); + struct spki_table *table = rtr_malloc(16); enum rtr_bgpsec_rtvals result = RTR_BGPSEC_SUCCESS; UNUSED(state); @@ -180,18 +180,18 @@ static void test_align_byte_sequence(void **state) assert_int_equal(RTR_BGPSEC_ERROR, result); - lrtr_free(table); - lrtr_free(bgpsec->path); - lrtr_free(bgpsec->sigs); - lrtr_free(bgpsec->nlri->nlri); - lrtr_free(bgpsec->nlri); - lrtr_free(bgpsec); + rtr_free(table); + rtr_free(bgpsec->path); + rtr_free(bgpsec->sigs); + rtr_free(bgpsec->nlri->nlri); + rtr_free(bgpsec->nlri); + rtr_free(bgpsec); } static void test_hash_byte_sequence(void **state) { struct rtr_bgpsec *bgpsec = setup_bgpsec(); - struct spki_table *table = lrtr_malloc(16); + struct spki_table *table = rtr_malloc(16); enum rtr_bgpsec_rtvals result = RTR_BGPSEC_SUCCESS; UNUSED(state); @@ -204,18 +204,18 @@ static void test_hash_byte_sequence(void **state) assert_int_equal(RTR_BGPSEC_ERROR, result); - lrtr_free(table); - lrtr_free(bgpsec->path); - lrtr_free(bgpsec->sigs); - lrtr_free(bgpsec->nlri->nlri); - lrtr_free(bgpsec->nlri); - lrtr_free(bgpsec); + rtr_free(table); + rtr_free(bgpsec->path); + rtr_free(bgpsec->sigs); + rtr_free(bgpsec->nlri->nlri); + rtr_free(bgpsec->nlri); + rtr_free(bgpsec); } static void test_validate_signature(void **state) { struct rtr_bgpsec *bgpsec = setup_bgpsec(); - struct spki_table *table = lrtr_malloc(16); + struct spki_table *table = rtr_malloc(16); enum rtr_bgpsec_rtvals result = RTR_BGPSEC_SUCCESS; UNUSED(state); @@ -230,12 +230,12 @@ static void test_validate_signature(void **state) assert_int_equal(RTR_BGPSEC_ERROR, result); - lrtr_free(table); - lrtr_free(bgpsec->path); - lrtr_free(bgpsec->sigs); - lrtr_free(bgpsec->nlri->nlri); - lrtr_free(bgpsec->nlri); - lrtr_free(bgpsec); + rtr_free(table); + rtr_free(bgpsec->path); + rtr_free(bgpsec->sigs); + rtr_free(bgpsec->nlri->nlri); + rtr_free(bgpsec->nlri); + rtr_free(bgpsec); } int main(void) diff --git a/tests/unittests/test_packets_static.c b/tests/unittests/test_packets_static.c index be4f5409..d2a2ff13 100644 --- a/tests/unittests/test_packets_static.c +++ b/tests/unittests/test_packets_static.c @@ -14,7 +14,7 @@ #include "rtrlib/rtr/packets.c" #include "rtrlib/rtr_mgr_private.h" -int __wrap_lrtr_get_monotonic_time(time_t *seconds) +int __wrap_rtr_get_monotonic_time(time_t *seconds) { UNUSED(seconds); return mock_type(int); @@ -66,10 +66,10 @@ static void test_set_last_update(void **state) socket.connection_state_fp = NULL; - will_return(__wrap_lrtr_get_monotonic_time, RTR_ERROR); + will_return(__wrap_rtr_get_monotonic_time, RTR_ERROR); assert_int_equal(rtr_set_last_update(&socket), RTR_ERROR); - will_return(__wrap_lrtr_get_monotonic_time, RTR_SUCCESS); + will_return(__wrap_rtr_get_monotonic_time, RTR_SUCCESS); assert_int_equal(rtr_set_last_update(&socket), RTR_SUCCESS); } @@ -232,8 +232,8 @@ static void test_pdu_to_host_byte_order(void **state) static void test_rtr_pdu_check_size(void **state) { struct pdu_header pdu; - struct pdu_error *error = lrtr_calloc(1, 30); - struct pdu_aspa *aspa = lrtr_calloc(1, sizeof(struct pdu_aspa) + 2 * sizeof(uint32_t)); + struct pdu_error *error = rtr_calloc(1, 30); + struct pdu_aspa *aspa = rtr_calloc(1, sizeof(struct pdu_aspa) + 2 * sizeof(uint32_t)); UNUSED(state); diff --git a/tests/unittests/test_packets_static.h b/tests/unittests/test_packets_static.h index 58704bab..a83a0a23 100644 --- a/tests/unittests/test_packets_static.h +++ b/tests/unittests/test_packets_static.h @@ -9,6 +9,6 @@ #include "rtrlib/transport/transport_private.h" -int __wrap_lrtr_get_monotonic_time(time_t *seconds); +int __wrap_rtr_get_monotonic_time(time_t *seconds); int __wrap_tr_send_all(const struct tr_socket *socket, const void *pdu, const size_t len, const time_t timeout); diff --git a/third-party/tommyds/tommytypes.h b/third-party/tommyds/tommytypes.h index a52d910d..9b9b2be3 100644 --- a/third-party/tommyds/tommytypes.h +++ b/third-party/tommyds/tommytypes.h @@ -90,16 +90,16 @@ typedef tommy_uint32_t tommy_count_t; #include "rtrlib/lib/alloc_utils_private.h" #endif #if !defined(tommy_malloc) -#define tommy_malloc lrtr_malloc +#define tommy_malloc rtr_malloc #endif #if !defined(tommy_calloc) -#define tommy_calloc lrtr_calloc +#define tommy_calloc rtr_calloc #endif #if !defined(tommy_realloc) -#define tommy_realloc lrtr_realloc +#define tommy_realloc rtr_realloc #endif #if !defined(tommy_free) -#define tommy_free lrtr_free +#define tommy_free rtr_free #endif /******************************************************************************/ diff --git a/tools/rpki-rov.c b/tools/rpki-rov.c index 52bd6403..289da617 100644 --- a/tools/rpki-rov.c +++ b/tools/rpki-rov.c @@ -66,14 +66,14 @@ int main(int argc, char *argv[]) return EXIT_FAILURE; } - struct tr_socket tr_tcp; - struct tr_tcp_config tcp_config = {argv[1], argv[2], NULL, NULL, NULL, 0}; + struct rtr_tr_socket tr_tcp; + struct rtr_tr_tcp_config tcp_config = {argv[1], argv[2], NULL, NULL, NULL, 0}; struct rtr_socket rtr_tcp; struct rtr_mgr_config *conf; struct rtr_mgr_group groups[1]; /* init a TCP transport and create rtr socket */ - tr_tcp_init(&tcp_config, &tr_tcp); + rtr_tr_tcp_init(&tcp_config, &tr_tcp); rtr_tcp.tr_socket = &tr_tcp; /* create a rtr_mgr_group array with 1 element */ @@ -165,7 +165,7 @@ int main(int argc, char *argv[]) char *input_tok = NULL; input_tok = strtok(input, delims); - struct lrtr_ip_addr pref; + struct rtr_ip_addr pref; char ip[INET6_ADDRSTRLEN]; if (strlen(input_tok) > sizeof(ip) - 1) { @@ -176,7 +176,7 @@ int main(int argc, char *argv[]) memset(ip, 0, sizeof(ip)); strncpy(ip, input_tok, sizeof(ip) - 1); - if (lrtr_ip_str_to_addr(ip, &pref) != 0) { + if (rtr_ip_str_to_addr(ip, &pref) != 0) { fprintf(stderr, "Error: Invalid ip addr\n"); continue; } @@ -197,20 +197,21 @@ int main(int argc, char *argv[]) continue; } - enum pfxv_state result; - struct pfx_record *reason = NULL; + enum rtr_pfxv_state result; + struct rtr_pfx_record *reason = NULL; unsigned int reason_len = 0; /* do validation */ - pfx_table_validate_r(groups[0].sockets[0]->pfx_table, &reason, &reason_len, asn, &pref, mask, &result); + rtr_pfx_table_validate_r(groups[0].sockets[0]->pfx_table, &reason, &reason_len, asn, &pref, mask, + &result); int validity_code = -1; /* translate validation result */ - if (result == BGP_PFXV_STATE_VALID) + if (result == RTR_BGP_PFXV_STATE_VALID) validity_code = 0; - else if (result == BGP_PFXV_STATE_NOT_FOUND) + else if (result == RTR_BGP_PFXV_STATE_NOT_FOUND) validity_code = 1; - else if (result == BGP_PFXV_STATE_INVALID) + else if (result == RTR_BGP_PFXV_STATE_INVALID) validity_code = 2; /* IP Mask BGP-ASN| */ @@ -223,7 +224,7 @@ int main(int argc, char *argv[]) for (i = 0; i < reason_len; i++) { char tmp[100]; - lrtr_ip_addr_to_str(&reason[i].prefix, tmp, sizeof(tmp)); + rtr_ip_addr_to_str(&reason[i].prefix, tmp, sizeof(tmp)); printf("%u %s %u %u", reason[i].asn, tmp, reason[i].min_len, reason[i].max_len); if ((i + 1) < reason_len) printf(","); diff --git a/tools/rtrclient.c b/tools/rtrclient.c index 6c177e19..bd84b491 100644 --- a/tools/rtrclient.c +++ b/tools/rtrclient.c @@ -56,7 +56,7 @@ enum socket_type { struct socket_config { struct rtr_socket socket; - struct tr_socket tr_socket; + struct rtr_tr_socket tr_socket; enum socket_type type; bool print_pfx_updates; bool print_spki_updates; @@ -299,9 +299,9 @@ struct pfx_export_cb_arg { tommy_hashlin *hashtable; }; -static void pfx_export_cb(const struct pfx_record *pfx_record, void *data); +static void pfx_export_cb(const struct rtr_pfx_record *pfx_record, void *data); -static tommy_uint32_t hash_pfx_record(const struct pfx_record *record) +static tommy_uint32_t hash_pfx_record(const struct rtr_pfx_record *record) { struct pfx_record_packed { uint8_t ip[16]; @@ -314,10 +314,10 @@ static tommy_uint32_t hash_pfx_record(const struct pfx_record *record) memset(&packed_record, 0, sizeof(packed_record)); - if (record->prefix.ver == LRTR_IPV4) - memcpy(&packed_record.ip, &record->prefix.u.addr4, sizeof(struct lrtr_ipv4_addr)); + if (record->prefix.ver == RTR_IPV4) + memcpy(&packed_record.ip, &record->prefix.u.addr4, sizeof(struct rtr_ipv4_addr)); else - memcpy(&packed_record.ip, &record->prefix.u.addr6, sizeof(struct lrtr_ipv6_addr)); + memcpy(&packed_record.ip, &record->prefix.u.addr6, sizeof(struct rtr_ipv6_addr)); packed_record.asn = record->asn; packed_record.min_len = record->min_len; @@ -328,11 +328,11 @@ static tommy_uint32_t hash_pfx_record(const struct pfx_record *record) static int pfx_record_cmp(const void *data1, const void *data2) { - const struct pfx_record *arg1 = data1; - const struct pfx_record *arg2 = data2; + const struct rtr_pfx_record *arg1 = data1; + const struct rtr_pfx_record *arg2 = data2; if ((arg1->asn == arg2->asn) && (arg1->max_len == arg2->max_len) && (arg1->min_len == arg2->min_len) && - lrtr_ip_addr_equal(arg1->prefix, arg2->prefix)) + rtr_ip_addr_equal(arg1->prefix, arg2->prefix)) return 0; return 1; @@ -383,12 +383,12 @@ static int template_put(void *closure, const char *name, __attribute__((unused)) if (!state->roa_section || namelen == 0) return MUSTACH_ERROR_SYSTEM; - struct pfx_record *pfx_record = tommy_array_get(state->roas, state->current_roa); + struct rtr_pfx_record *pfx_record = tommy_array_get(state->roas, state->current_roa); if (strncmp("prefix", name, namelen) == 0) { char prefix_str[INET6_ADDRSTRLEN]; - lrtr_ip_addr_to_str(&pfx_record->prefix, prefix_str, sizeof(prefix_str)); + rtr_ip_addr_to_str(&pfx_record->prefix, prefix_str, sizeof(prefix_str)); fputs(prefix_str, file); } else if (strncmp("length", name, namelen) == 0) { @@ -469,7 +469,8 @@ static void status_fp(const struct rtr_mgr_group *group __attribute__((unused)), } } -static void update_cb(struct pfx_table *p __attribute__((unused)), const struct pfx_record rec, const bool added) +static void update_cb(struct rtr_pfx_table *p __attribute__((unused)), const struct rtr_pfx_record rec, + const enum rtr_pfx_operation_type operation_type) { char ip[INET6_ADDRSTRLEN]; @@ -479,11 +480,11 @@ static void update_cb(struct pfx_table *p __attribute__((unused)), const struct return; pthread_mutex_lock(&stdout_mutex); - if (added) + if (operation_type == RTR_PFX_ADD) printf("+ "); else printf("- "); - lrtr_ip_addr_to_str(&rec.prefix, ip, sizeof(ip)); + rtr_ip_addr_to_str(&rec.prefix, ip, sizeof(ip)); if (socket_count > 1) printf("%s:%s %-40s %3u - %3u %10u\n", config->host, config->port, ip, rec.min_len, rec.max_len, rec.asn); @@ -493,7 +494,8 @@ static void update_cb(struct pfx_table *p __attribute__((unused)), const struct pthread_mutex_unlock(&stdout_mutex); } -static void update_spki(struct spki_table *s __attribute__((unused)), const struct spki_record record, const bool added) +static void update_spki(struct rtr_spki_table *s __attribute__((unused)), const struct rtr_spki_record record, + const enum rtr_spki_operation_type operation_type) { const struct socket_config *config = (const struct socket_config *)record.socket; @@ -502,7 +504,7 @@ static void update_spki(struct spki_table *s __attribute__((unused)), const stru pthread_mutex_lock(&stdout_mutex); - char c = added ? '+' : '-'; + char c = operation_type == RTR_SPKI_ADD ? '+' : '-'; printf("%c ", c); printf("HOST: %s:%s\n", config->host, config->port); @@ -535,8 +537,8 @@ static void update_spki(struct spki_table *s __attribute__((unused)), const stru pthread_mutex_unlock(&stdout_mutex); } -static void update_aspa(struct aspa_table *s __attribute__((unused)), const struct aspa_record record, - const struct rtr_socket *rtr_sockt, const enum aspa_operation_type operation_type) +static void update_aspa(struct rtr_aspa_table *s __attribute__((unused)), const struct rtr_aspa_record record, + const struct rtr_socket *rtr_sockt, const enum rtr_aspa_operation_type operation_type) { const struct socket_config *config = (const struct socket_config *)rtr_sockt; @@ -550,10 +552,10 @@ static void update_aspa(struct aspa_table *s __attribute__((unused)), const stru char c; switch (operation_type) { - case ASPA_ADD: + case RTR_ASPA_ADD: c = '+'; break; - case ASPA_REMOVE: + case RTR_ASPA_REMOVE: c = '-'; break; default: @@ -903,9 +905,9 @@ static void init_sockets(void) { for (size_t i = 0; i < socket_count; ++i) { struct socket_config *config = socket_config[i]; - struct tr_tcp_config tcp_config = {}; + struct rtr_tr_tcp_config tcp_config = {}; #ifdef RTRLIB_HAVE_LIBSSH - struct tr_ssh_config ssh_config = {}; + struct rtr_tr_ssh_config ssh_config = {}; #endif switch (config->type) { @@ -914,7 +916,7 @@ static void init_sockets(void) tcp_config.port = config->port; tcp_config.bindaddr = config->bindaddr; - tr_tcp_init(&tcp_config, &config->tr_socket); + rtr_tr_tcp_init(&tcp_config, &config->tr_socket); config->socket.tr_socket = &config->tr_socket; break; @@ -928,7 +930,7 @@ static void init_sockets(void) ssh_config.server_hostkey_path = config->ssh_host_key; ssh_config.password = config->ssh_password; - tr_ssh_init(&ssh_config, &config->tr_socket); + rtr_tr_ssh_init(&ssh_config, &config->tr_socket); config->socket.tr_socket = &config->tr_socket; break; #endif @@ -954,9 +956,9 @@ int main(int argc, char **argv) groups[0].sockets = (struct rtr_socket **)socket_config; groups[0].preference = 1; - spki_update_fp spki_update_fp = activate_spki_update_cb ? update_spki : NULL; - pfx_update_fp pfx_update_fp = activate_pfx_update_cb ? update_cb : NULL; - aspa_update_fp aspa_update_fp = activate_aspa_update_cb ? update_aspa : NULL; + rtr_spki_update_fp spki_update_fp = activate_spki_update_cb ? update_spki : NULL; + rtr_pfx_update_fp pfx_update_fp = activate_pfx_update_cb ? update_cb : NULL; + rtr_aspa_update_fp aspa_update_fp = activate_aspa_update_cb ? update_aspa : NULL; int ret = rtr_mgr_init(&conf, groups, 1, status_fp, NULL, NULL, NULL); @@ -1021,8 +1023,8 @@ int main(int argc, char **argv) tommy_array_init(&prefixes); tommy_hashlin_init(&prefix_hash); - pfx_table_for_each_ipv4_record(conf->pfx_table, pfx_export_cb, &arg); - pfx_table_for_each_ipv6_record(conf->pfx_table, pfx_export_cb, &arg); + rtr_pfx_table_for_each_ipv4_record(conf->pfx_table, pfx_export_cb, &arg); + rtr_pfx_table_for_each_ipv6_record(conf->pfx_table, pfx_export_cb, &arg); struct exporter_state state = { .roa_section = false, @@ -1055,11 +1057,11 @@ int main(int argc, char **argv) } struct pfx_record_entry { - struct pfx_record record; + struct rtr_pfx_record record; tommy_node hash_node; }; -static void pfx_export_cb(const struct pfx_record *pfx_record, void *data) +static void pfx_export_cb(const struct rtr_pfx_record *pfx_record, void *data) { struct pfx_export_cb_arg *arg = data; tommy_array *roa_array = arg->array; @@ -1072,7 +1074,7 @@ static void pfx_export_cb(const struct pfx_record *pfx_record, void *data) struct pfx_record_entry *pfx_record_entry = malloc(sizeof(struct pfx_record_entry)); - memcpy(&pfx_record_entry->record, pfx_record, sizeof(struct pfx_record)); + memcpy(&pfx_record_entry->record, pfx_record, sizeof(struct rtr_pfx_record)); tommy_hashlin_insert(roa_hashtable, &pfx_record_entry->hash_node, pfx_record_entry, record_hash); tommy_array_insert(roa_array, pfx_record_entry);