From 09d2f44c757b9ffc2f38a28bdf212c61f67dabd8 Mon Sep 17 00:00:00 2001 From: Jennifer Richards Date: Thu, 13 Oct 2016 15:46:57 -0400 Subject: [PATCH] Refactoring to enable community flooding. Partially tested. --- Makefile.am | 6 + common/tr_apc.c | 46 +++ common/tr_comm.c | 686 ++++++++++++++++++++++++++++++++++++++--- common/tr_config.c | 232 +++++++------- common/tr_idp.c | 35 +++ common/tr_msg.c | 264 ++++++++++++++-- common/tr_name.c | 10 + common/tr_rp.c | 74 ++++- include/tr_apc.h | 10 + include/tr_comm.h | 107 ++++++- include/tr_config.h | 9 +- include/tr_idp.h | 9 + include/tr_rp.h | 15 +- include/trp_internal.h | 47 ++- include/trust_router/tr_name.h | 4 +- include/trust_router/trp.h | 26 +- tr/tr_tid.c | 12 +- tr/tr_trp.c | 1 + trp/trp_upd.c | 200 +++++++++++- trp/trps.c | 46 ++- 20 files changed, 1614 insertions(+), 225 deletions(-) diff --git a/Makefile.am b/Makefile.am index 3b434c3..664a5d6 100644 --- a/Makefile.am +++ b/Makefile.am @@ -83,6 +83,12 @@ tr_trpc_CFLAGS = $(AM_CFLAGS) -pthread trp_msgtst_SOURCES = trp/msgtst.c \ common/tr_msg.c \ +common/tr_comm.c \ +common/tr_apc.c \ +common/tr_rp.c \ +common/tr_idp.c \ +common/tr_gss.c \ +common/tr_filter.c \ trp/trp_req.c \ trp/trp_upd.c \ tid/tid_resp.c \ diff --git a/common/tr_apc.c b/common/tr_apc.c index 1a629a0..e2f1278 100644 --- a/common/tr_apc.c +++ b/common/tr_apc.c @@ -36,6 +36,7 @@ #include #include +#include static int tr_apc_destructor(void *obj) { @@ -116,3 +117,48 @@ char *tr_apc_to_str(TALLOC_CTX *mem_ctx, TR_APC *apc) { return talloc_strndup(mem_ctx, apc->id->buf, apc->id->len); } + +TR_APC_ITER *tr_apc_iter_new(TALLOC_CTX *mem_ctx) +{ + return talloc(mem_ctx, TR_APC_ITER); +} + +TR_APC *tr_apc_iter_first(TR_APC_ITER *iter, TR_APC *apc) +{ + *iter=apc; + return *iter; +} + +TR_APC *tr_apc_iter_next(TR_APC_ITER *iter) +{ + (*iter)=(*iter)->next; + return *iter; +} + +void tr_apc_iter_free(TR_APC_ITER *iter) +{ + talloc_free(iter); +} + +/* 1 on match, 0 on no match, -1 on error */ +int tr_apc_in_common(TR_APC *one, TR_APC *two) +{ + TALLOC_CTX *tmp_ctx=talloc_new(NULL); + TR_APC_ITER *i_one=tr_apc_iter_new(tmp_ctx); + TR_APC_ITER *i_two=tr_apc_iter_new(tmp_ctx); + TR_APC *cur_one=NULL; + TR_APC *cur_two=NULL; + + if ((i_one==NULL) || (i_two==NULL)) { + tr_err("tr_apc_in_common: unable to allocate iterators."); + talloc_free(tmp_ctx); + return -1; + } + for (cur_one=tr_apc_iter_first(i_one, one); cur_one!=NULL; cur_one=tr_apc_iter_next(i_one)) { + for (cur_two=tr_apc_iter_first(i_two, two); cur_two!=NULL; cur_two=tr_apc_iter_next(i_two)) { + if (cur_one==cur_two) + return 1; + } + } + return 0; +} diff --git a/common/tr_comm.c b/common/tr_comm.c index b8b8730..677a5b8 100644 --- a/common/tr_comm.c +++ b/common/tr_comm.c @@ -32,13 +32,20 @@ * */ +#include #include #include +#include #include #include #include + +/* static prototypes */ +static TR_NAME *tr_comm_memb_get_realm_id(TR_COMM_MEMB *memb); + + static int tr_comm_destructor(void *obj) { TR_COMM *comm=talloc_get_type_abort(obj, TR_COMM); @@ -59,10 +66,10 @@ TR_COMM *tr_comm_new(TALLOC_CTX *mem_ctx) comm->id=NULL; comm->type=TR_COMM_UNKNOWN; comm->apcs=NULL; - comm->idp_realms=NULL; - comm->rp_realms=NULL; comm->owner_realm=NULL; comm->owner_contact=NULL; + comm->expiration_interval=0; + comm->refcount=0; talloc_set_destructor((void *)comm, tr_comm_destructor); } return comm; @@ -80,6 +87,22 @@ void tr_comm_set_id(TR_COMM *comm, TR_NAME *id) comm->id=id; } +void tr_comm_incref(TR_COMM *comm) +{ + comm->refcount++; +} + +void tr_comm_decref(TR_COMM *comm) +{ + if (comm->refcount>0) + comm->refcount--; +} + +TR_APC *tr_comm_get_apcs(TR_COMM *comm) +{ + return comm->apcs; +} + TR_NAME *tr_comm_get_id(TR_COMM *comm) { return comm->id; @@ -134,30 +157,86 @@ TR_NAME *tr_comm_dup_owner_contact(TR_COMM *comm) return tr_dup_name(comm->owner_contact); } -/* does not take responsibility for freeing IDP realm */ -void tr_comm_add_idp_realm(TR_COMM *comm, TR_IDP_REALM *realm) +unsigned int tr_comm_get_refcount(TR_COMM *comm) +{ + return comm->refcount; +} + +/* add to the table if it's a new membership or has a shorter + * provenance list than our existing membership */ +static void tr_comm_add_if_shorter(TR_COMM_TABLE *ctab, TR_COMM_MEMB *existing, TR_COMM_MEMB *newmemb) { - TR_IDP_REALM *cur=NULL; + if (existing==NULL) { + /* not in the table */ + tr_comm_table_add_memb(ctab, newmemb); + } else { + /* Had an entry. Replace if we have shorter provenance. */ + if (tr_comm_memb_provenance_len(newmemb) < tr_comm_memb_provenance_len(existing)) { + tr_comm_table_remove_memb(ctab, existing); + tr_comm_memb_free(existing); + tr_comm_table_add_memb(ctab, newmemb); + } + } +} - if (comm->idp_realms==NULL) - comm->idp_realms=realm; - else { - for (cur=comm->idp_realms; cur->comm_next!=NULL; cur=cur->comm_next) { } - cur->comm_next=realm; +/* does not take responsibility for freeing IDP realm */ +void tr_comm_add_idp_realm(TR_COMM_TABLE *ctab, + TR_COMM *comm, + TR_IDP_REALM *realm, + json_t *provenance, + struct timespec *expiry) +{ + TALLOC_CTX *tmp_ctx=talloc_new(NULL); + TR_COMM_MEMB *newmemb=tr_comm_memb_new(tmp_ctx); + TR_COMM_MEMB *existing=NULL; + + if (newmemb==NULL) { + tr_err("tr_comm_add_idp_realm: unable to allocate new membership record."); + talloc_free(tmp_ctx); + return; } + + tr_comm_memb_set_idp_realm(newmemb, realm); + tr_comm_memb_set_comm(newmemb, comm); + tr_comm_memb_set_provenance(newmemb, provenance); + tr_comm_memb_set_expiry(newmemb, expiry); + + existing=tr_comm_table_find_idp_memb(ctab, + tr_idp_realm_get_id(realm), + tr_comm_get_id(comm), + tr_comm_memb_get_origin(newmemb)); + tr_comm_add_if_shorter(ctab, existing, newmemb); /* takes newmemb out of tmp_ctx if needed */ + talloc_free(tmp_ctx); } /* does not take responsibility for freeing RP realm */ -void tr_comm_add_rp_realm(TR_COMM *comm, TR_RP_REALM *realm) +void tr_comm_add_rp_realm(TR_COMM_TABLE *ctab, + TR_COMM *comm, + TR_RP_REALM *realm, + json_t *provenance, + struct timespec *expiry) { - TR_RP_REALM *cur=NULL; - - if (comm->rp_realms==NULL) - comm->rp_realms=realm; - else { - for (cur=comm->rp_realms; cur->next!=NULL; cur=cur->next) { } - cur->next=realm; + TALLOC_CTX *tmp_ctx=talloc_new(NULL); + TR_COMM_MEMB *newmemb=tr_comm_memb_new(tmp_ctx); + TR_COMM_MEMB *existing=NULL; + + if (newmemb==NULL) { + tr_err("tr_comm_add_idp_realm: unable to allocate new membership record."); + talloc_free(tmp_ctx); + return; } + + tr_comm_memb_set_rp_realm(newmemb, realm); + tr_comm_memb_set_comm(newmemb, comm); + tr_comm_memb_set_provenance(newmemb, provenance); + tr_comm_memb_set_expiry(newmemb, expiry); + + existing=tr_comm_table_find_rp_memb(ctab, + tr_rp_realm_get_id(realm), + tr_comm_get_id(comm), + tr_comm_memb_get_origin(newmemb)); + tr_comm_add_if_shorter(ctab, existing, newmemb); /* takes newmemb out of tmp_ctx if needed */ + talloc_free(tmp_ctx); } static TR_COMM *tr_comm_tail(TR_COMM *comm) @@ -174,7 +253,8 @@ static TR_COMM *tr_comm_tail(TR_COMM *comm) * This will require careful thought if entries are ever removed * Call like comms=tr_comm_add_func(comms, new_comm); * or just use the tr_comm_add(comms, new) macro. */ -TR_COMM *tr_comm_add_func(TR_COMM *comms, TR_COMM *new) +#define tr_comm_add(comms, new) ((comms)=tr_comm_add_func((comms), (new))) +static TR_COMM *tr_comm_add_func(TR_COMM *comms, TR_COMM *new) { if (comms==NULL) comms=new; @@ -188,54 +268,236 @@ TR_COMM *tr_comm_add_func(TR_COMM *comms, TR_COMM *new) return comms; } -TR_IDP_REALM *tr_find_comm_idp (TR_COMM *comm, TR_NAME *idp_realm) +/* guarantees comm is not in the list, not an error if it was't there */ +#define tr_comm_remove(comms, c) ((comms)=tr_comm_remove_func((comms), (c))) +static TR_COMM *tr_comm_remove_func(TR_COMM *comms, TR_COMM *remove) +{ + TR_COMM *this=comms; + + if ((this==NULL) || (this==remove)) + return NULL; + + for (; this->next!=NULL; this=this->next) { + if (this->next==remove) + this->next=remove->next; + } + return comms; +} + +TR_IDP_REALM *tr_comm_find_idp(TR_COMM_TABLE *ctab, TR_COMM *comm, TR_NAME *idp_realm) { - TR_IDP_REALM *idp; + TALLOC_CTX *tmp_ctx=talloc_new(NULL); + TR_COMM_ITER *iter=NULL; + TR_IDP_REALM *this_idp=NULL; - if ((!comm) || (!idp_realm)) { + if ((NULL==ctab) || (NULL==comm) || (NULL==idp_realm)) { + talloc_free(tmp_ctx); return NULL; } - for (idp = comm->idp_realms; NULL != idp; idp = idp->comm_next) { - if (!tr_name_cmp (idp_realm, idp->realm_id)) { - tr_debug("tr_find_comm_idp: Found IdP %s in community %s.", idp_realm->buf, comm->id->buf); - return idp; + iter=tr_comm_iter_new(tmp_ctx); + for (this_idp=tr_idp_realm_iter_first(iter, ctab, tr_comm_get_id(comm)); + this_idp!=NULL; + this_idp=tr_idp_realm_iter_next(iter)) { + if (0==tr_name_cmp(idp_realm, tr_idp_realm_get_id(this_idp))) { + tr_debug("tr_comm_find_idp: Found IdP %s in community %s.", idp_realm->buf, tr_comm_get_id(comm)->buf); + talloc_free(tmp_ctx); + return this_idp; } } - /* if we didn't find one, return NULL */ + tr_debug("tr_comm_find_idp: Unable to find IdP %s in community %s.", idp_realm->buf, tr_comm_get_id(comm)->buf); + talloc_free(tmp_ctx); return NULL; } -TR_RP_REALM *tr_find_comm_rp (TR_COMM *comm, TR_NAME *rp_realm) +TR_RP_REALM *tr_comm_find_rp (TR_COMM_TABLE *ctab, TR_COMM *comm, TR_NAME *rp_realm) { - TR_RP_REALM *rp; + TALLOC_CTX *tmp_ctx=talloc_new(NULL); + TR_COMM_ITER *iter=NULL; + TR_RP_REALM *this_rp=NULL; - if ((!comm) || (!rp_realm)) { + if ((NULL==ctab) || (NULL==comm) || (NULL==rp_realm)) { + talloc_free(tmp_ctx); return NULL; } - for (rp = comm->rp_realms; NULL != rp; rp = rp->next) { - if (!tr_name_cmp (rp_realm, rp->realm_name)) { - tr_debug("tr_find_comm_rp: Found RP %s in community %s.", rp_realm->buf, comm->id->buf); - return rp; + iter=tr_comm_iter_new(tmp_ctx); + for (this_rp=tr_rp_realm_iter_first(iter, ctab, tr_comm_get_id(comm)); + this_rp!=NULL; + this_rp=tr_rp_realm_iter_next(iter)) { + if (0==tr_name_cmp(rp_realm, tr_rp_realm_get_id(this_rp))) { + tr_debug("tr_comm_find_rp: Found RP %s in community %s.", rp_realm->buf, tr_comm_get_id(comm)->buf); + talloc_free(tmp_ctx); + return this_rp; } } - /* if we didn't find one, return NULL */ + tr_debug("tr_comm_find_rp: Unable to find RP %s in community %s.", rp_realm->buf, tr_comm_get_id(comm)->buf); + talloc_free(tmp_ctx); return NULL; } -TR_COMM *tr_comm_lookup(TR_COMM *comms, TR_NAME *comm_name) +static TR_COMM *tr_comm_lookup(TR_COMM *comms, TR_NAME *comm_name) { TR_COMM *cfg_comm = NULL; for (cfg_comm = comms; NULL != cfg_comm; cfg_comm = cfg_comm->next) { - if ((cfg_comm->id->len == comm_name->len) && - (!strncmp(cfg_comm->id->buf, comm_name->buf, comm_name->len))) + if (0==tr_name_cmp(cfg_comm->id, comm_name)) return cfg_comm; } return NULL; } +TR_COMM_ITER *tr_comm_iter_new(TALLOC_CTX *mem_ctx) +{ + TR_COMM_ITER *iter=talloc(mem_ctx, TR_COMM_ITER); + if (iter!=NULL) { + iter->cur_memb=NULL; + iter->match=NULL; + } + return iter; +} + +void tr_comm_iter_free(TR_COMM_ITER *iter) +{ + talloc_free(iter); +} + + +TR_COMM *tr_comm_iter_first(TR_COMM_ITER *iter, TR_COMM_TABLE *ctab, TR_NAME *realm) +{ + iter->match=realm; + + /* find memberships for this realm */ + for (iter->cur_memb=ctab->memberships; + iter->cur_memb!=NULL; + iter->cur_memb=iter->cur_memb->next) { + if (0==tr_name_cmp(iter->match, tr_comm_memb_get_realm_id(iter->cur_memb))) + return tr_comm_memb_get_comm(iter->cur_memb); + } + return NULL; +} + +TR_COMM *tr_comm_iter_next(TR_COMM_ITER *iter) +{ + for (iter->cur_memb=iter->cur_memb->next; + iter->cur_memb!=NULL; + iter->cur_memb=iter->cur_memb->next) { + if (0==tr_name_cmp(iter->match, tr_comm_memb_get_realm_id(iter->cur_memb))) + return tr_comm_memb_get_comm(iter->cur_memb); + } + return NULL; +} + +/* iterate only over RPs */ +TR_COMM *tr_comm_iter_first_rp(TR_COMM_ITER *iter, TR_COMM_TABLE *ctab, TR_NAME *realm) +{ + iter->match=realm; + + /* find memberships for this realm */ + for (iter->cur_memb=ctab->memberships; + iter->cur_memb!=NULL; + iter->cur_memb=iter->cur_memb->next) { + if ((tr_comm_memb_get_rp_realm(iter->cur_memb)!=NULL) && + (0==tr_name_cmp(iter->match, tr_comm_memb_get_realm_id(iter->cur_memb)))) + return tr_comm_memb_get_comm(iter->cur_memb); + } + return NULL; +} + +TR_COMM *tr_comm_iter_next_rp(TR_COMM_ITER *iter) +{ + for (iter->cur_memb=iter->cur_memb->next; + iter->cur_memb!=NULL; + iter->cur_memb=iter->cur_memb->next) { + if ((tr_comm_memb_get_rp_realm(iter->cur_memb)!=NULL) && + (0==tr_name_cmp(iter->match, tr_comm_memb_get_realm_id(iter->cur_memb)))) + return tr_comm_memb_get_comm(iter->cur_memb); + } + return NULL; +} + +/* iterate only over IDPs */ +TR_COMM *tr_comm_iter_first_idp(TR_COMM_ITER *iter, TR_COMM_TABLE *ctab, TR_NAME *realm) +{ + iter->match=realm; + + /* find memberships for this realm */ + for (iter->cur_memb=ctab->memberships; + iter->cur_memb!=NULL; + iter->cur_memb=iter->cur_memb->next) { + if ((tr_comm_memb_get_idp_realm(iter->cur_memb)!=NULL) && + (0==tr_name_cmp(iter->match, tr_comm_memb_get_realm_id(iter->cur_memb)))) + return tr_comm_memb_get_comm(iter->cur_memb); + } + return NULL; +} + +TR_COMM *tr_comm_iter_next_idp(TR_COMM_ITER *iter) +{ + for (iter->cur_memb=iter->cur_memb->next; + iter->cur_memb!=NULL; + iter->cur_memb=iter->cur_memb->next) { + if ((tr_comm_memb_get_idp_realm(iter->cur_memb)!=NULL) && + (0==tr_name_cmp(iter->match, tr_comm_memb_get_realm_id(iter->cur_memb)))) + return tr_comm_memb_get_comm(iter->cur_memb); + } + return NULL; +} + +TR_RP_REALM *tr_rp_realm_iter_first(TR_COMM_ITER *iter, TR_COMM_TABLE *ctab, TR_NAME *comm) +{ + iter->match=comm; + + /* find memberships for this comm */ + for (iter->cur_memb=ctab->memberships; + iter->cur_memb!=NULL; + iter->cur_memb=iter->cur_memb->next) { + if ((tr_comm_memb_get_rp_realm(iter->cur_memb)!=NULL) && + (0==tr_name_cmp(iter->match, tr_comm_get_id(tr_comm_memb_get_comm(iter->cur_memb))))) + return tr_comm_memb_get_rp_realm(iter->cur_memb); + } + return NULL; +} + +TR_RP_REALM *tr_rp_realm_iter_next(TR_COMM_ITER *iter) +{ + for (iter->cur_memb=iter->cur_memb->next; + iter->cur_memb!=NULL; + iter->cur_memb=iter->cur_memb->next) { + if ((tr_comm_memb_get_rp_realm(iter->cur_memb)!=NULL) && + (0==tr_name_cmp(iter->match, tr_comm_get_id(tr_comm_memb_get_comm(iter->cur_memb))))) + return tr_comm_memb_get_rp_realm(iter->cur_memb); + } + return NULL; +} + +TR_IDP_REALM *tr_idp_realm_iter_first(TR_COMM_ITER *iter, TR_COMM_TABLE *ctab, TR_NAME *comm) +{ + iter->match=comm; + + /* find memberships for this comm */ + for (iter->cur_memb=ctab->memberships; + iter->cur_memb!=NULL; + iter->cur_memb=iter->cur_memb->next) { + if ((tr_comm_memb_get_idp_realm(iter->cur_memb)!=NULL) && + (0==tr_name_cmp(iter->match, tr_comm_get_id(tr_comm_memb_get_comm(iter->cur_memb))))) + return tr_comm_memb_get_idp_realm(iter->cur_memb); + } + return NULL; +} + +TR_IDP_REALM *tr_idp_realm_iter_next(TR_COMM_ITER *iter) +{ + for (iter->cur_memb=iter->cur_memb->next; + iter->cur_memb!=NULL; + iter->cur_memb=iter->cur_memb->next) { + if ((tr_comm_memb_get_idp_realm(iter->cur_memb)!=NULL) && + (0==tr_name_cmp(iter->match, tr_comm_get_id(tr_comm_memb_get_comm(iter->cur_memb))))) + return tr_comm_memb_get_idp_realm(iter->cur_memb); + } + return NULL; +} + const char *tr_comm_type_to_str(TR_COMM_TYPE type) { const char *s=NULL; @@ -244,13 +506,357 @@ const char *tr_comm_type_to_str(TR_COMM_TYPE type) s="unknown"; break; case TR_COMM_APC: - s="APC"; + s="apc"; break; case TR_COMM_COI: - s="COI"; + s="coi"; break; default: s="invalid"; } return s; } + +TR_COMM_TYPE tr_comm_type_from_str(const char *s) +{ + if (strcmp(s, "apc")==0) + return TR_COMM_APC; + if (strcmp(s,"coi")==0) + return TR_COMM_COI; + return TR_COMM_UNKNOWN; +} + + +static int tr_comm_memb_destructor(void *obj) +{ + TR_COMM_MEMB *memb=talloc_get_type_abort(obj, TR_COMM_MEMB); + if (memb->origin!=NULL) + tr_free_name(memb->origin); + + if (memb->rp!=NULL) + tr_rp_realm_decref(memb->rp); + if (memb->idp!=NULL) + tr_idp_realm_decref(memb->idp); + if (memb->comm!=NULL) + tr_comm_decref(memb->comm); + if (memb->provenance!=NULL) + json_decref(memb->provenance); + return 0; +} + +TR_COMM_MEMB *tr_comm_memb_new(TALLOC_CTX *mem_ctx) +{ + TR_COMM_MEMB *memb=talloc(mem_ctx, TR_COMM_MEMB); + if (memb!=NULL) { + memb->next=NULL; + memb->idp=NULL; + memb->rp=NULL; + memb->comm=NULL; + memb->origin=NULL; + memb->provenance=NULL; + memb->expiry=NULL; + talloc_set_destructor(memb, tr_comm_memb_destructor); + } + return memb; +} + +void tr_comm_memb_free(TR_COMM_MEMB *memb) +{ + talloc_free(memb); +} + +void tr_comm_memb_set_rp_realm(TR_COMM_MEMB *memb, TR_RP_REALM *realm) +{ + if (memb->idp!=NULL) { + tr_idp_realm_decref(memb->idp); + memb->idp=NULL; + } + if (memb->rp!=NULL) + tr_rp_realm_decref(memb->rp); + + + memb->rp=realm; + tr_rp_realm_incref(realm); +} + +TR_RP_REALM *tr_comm_memb_get_rp_realm(TR_COMM_MEMB *memb) +{ + return memb->rp; +} + +void tr_comm_memb_set_idp_realm(TR_COMM_MEMB *memb, TR_IDP_REALM *realm) +{ + if (memb->rp!=NULL) { + tr_rp_realm_decref(memb->rp); + memb->rp=NULL; + } + if (memb->idp!=NULL) + tr_idp_realm_decref(memb->idp); + + memb->idp=realm; + tr_idp_realm_incref(realm); +} + +TR_IDP_REALM *tr_comm_memb_get_idp_realm(TR_COMM_MEMB *memb) +{ + return memb->idp; +} + +void tr_comm_memb_set_comm(TR_COMM_MEMB *memb, TR_COMM *comm) +{ + if (memb->comm!=NULL) + tr_comm_decref(memb->comm); + memb->comm=comm; + tr_comm_incref(comm); +} + +TR_COMM *tr_comm_memb_get_comm(TR_COMM_MEMB *memb) +{ + return memb->comm; +} + +static void tr_comm_memb_set_origin(TR_COMM_MEMB *memb, TR_NAME *origin) +{ + if (memb->origin!=NULL) + tr_free_name(memb->origin); + memb->origin=origin; +} + +TR_NAME *tr_comm_memb_get_origin(TR_COMM_MEMB *memb) +{ + return memb->origin; +} + +TR_NAME *tr_comm_memb_dup_origin(TR_COMM_MEMB *memb) +{ + if (memb->origin!=NULL) + return tr_dup_name(memb->origin); + return NULL; +} + +void tr_comm_memb_set_provenance(TR_COMM_MEMB *memb, json_t *prov) +{ + if (memb->provenance) + json_decref(memb->provenance); + + memb->provenance=prov; + if (prov!=NULL) { + json_incref(prov); + + /* next line sets origin to NULL if provenance is empty because jansson + * routines return NULL on error */ + memb->origin=tr_new_name(json_string_value(json_array_get(prov, 0))); + } else { + tr_comm_memb_set_origin(memb, NULL); + } +} + +void tr_comm_memb_add_to_provenance(TR_COMM_MEMB *memb, TR_NAME *hop) +{ + if (memb->provenance==NULL) { + memb->provenance=json_array(); + if (memb->provenance==NULL) { + tr_err("tr_comm_memb_add_to_provenance: unable to allocate provenance list."); + return; + } + /* this is the first entry in the provenance, so it is the origin */ + tr_comm_memb_set_origin(memb,tr_dup_name(hop)); + if (memb->origin==NULL) { + tr_err("tr_comm_memb_add_to_provenance: unable to allocate origin."); + json_decref(memb->provenance); + memb->provenance=NULL; + return; + } + } + if (0!=json_array_append_new(memb->provenance, tr_name_to_json_string(hop))) + tr_err("tr_comm_memb_add_to_provenance: unable to extend provenance list."); +} + +size_t tr_comm_memb_provenance_len(TR_COMM_MEMB *memb) +{ + if (memb->provenance==NULL) + return 0; + return json_array_size(memb->provenance); +} + +void tr_comm_memb_set_expiry(TR_COMM_MEMB *memb, struct timespec *time) +{ + memb->expiry=time; +} + +struct timespec *tr_comm_memb_get_expiry(TR_COMM_MEMB *memb) +{ + return memb->expiry; +} + +int tr_comm_memb_is_expired(TR_COMM_MEMB *memb, struct timespec *curtime) +{ + return ((curtime->tv_sec > memb->expiry->tv_sec) + || ((curtime->tv_sec == memb->expiry->tv_sec) + &&(curtime->tv_nsec >= memb->expiry->tv_nsec))); +} + +TR_COMM_TABLE *tr_comm_table_new(TALLOC_CTX *mem_ctx) +{ + TR_COMM_TABLE *ctab=talloc(mem_ctx, TR_COMM_TABLE); + if (ctab!=NULL) { + ctab->comms=NULL; + ctab->memberships=NULL; + } + return ctab; +} + +void tr_comm_table_free(TR_COMM_TABLE *ctab) +{ + talloc_free(ctab); +} + +void tr_comm_table_add_memb(TR_COMM_TABLE *ctab, TR_COMM_MEMB *new) +{ + TR_COMM_MEMB *cur=NULL; + + if (ctab->memberships==NULL) { + ctab->memberships=new; + talloc_steal(ctab, new); + } else { + for (cur=ctab->memberships; cur->next!=NULL; cur=cur->next) { } + cur->next=new; + } + talloc_steal(ctab, new); +} + +/* Remove memb from ctab. Do not free anything. Do nothing if memb not in ctab. */ +void tr_comm_table_remove_memb(TR_COMM_TABLE *ctab, TR_COMM_MEMB *memb) +{ + TR_COMM_MEMB *cur=NULL; + + if ((memb==NULL) || (ctab->memberships==NULL)) { + return; + } else if (ctab->memberships==memb) { + ctab->memberships=memb->next; + return; + } else { + for (cur=ctab->memberships; cur->next!=NULL; cur=cur->next) { + if (cur->next==memb) { + cur->next=memb->next; + return; + } + } + } +} + +static TR_NAME *tr_comm_memb_get_realm_id(TR_COMM_MEMB *memb) +{ + if (memb->rp!=NULL) + return tr_rp_realm_get_id(memb->rp); + else + return tr_idp_realm_get_id(memb->idp); +} + +TR_COMM_MEMB *tr_comm_table_find_memb(TR_COMM_TABLE *ctab, TR_NAME *realm, TR_NAME *comm, TR_NAME *origin) +{ + TR_COMM_MEMB *cur=NULL; + TR_NAME *cur_realm_name=NULL; + + for (cur=ctab->memberships; cur!=NULL; cur=cur->next) { + cur_realm_name=tr_comm_memb_get_realm_id(cur); + if (cur_realm_name==NULL) { + tr_warning("tr_comm_table_find: encountered realm with no name."); + continue; + } + if ((0==tr_name_cmp(realm, cur_realm_name)) && + (0==tr_name_cmp(comm, tr_comm_get_id(tr_comm_memb_get_comm(cur)))) && + (0==tr_name_cmp(origin, tr_comm_memb_get_origin(cur)))) { + return cur; + } + } + return NULL; +} + +TR_COMM_MEMB *tr_comm_table_find_idp_memb(TR_COMM_TABLE *ctab, TR_NAME *realm, TR_NAME *comm, TR_NAME *origin) +{ + TR_COMM_MEMB *cur=NULL; + TR_IDP_REALM *idp_realm=NULL; + + for (cur=ctab->memberships; cur!=NULL; cur=cur->next) { + idp_realm=tr_comm_memb_get_idp_realm(cur); + if (idp_realm==NULL) + continue; /* was not an idp */ + + if ((0==tr_name_cmp(realm, idp_realm->realm_id)) && + (0==tr_name_cmp(comm, tr_comm_get_id(tr_comm_memb_get_comm(cur)))) && + (0==tr_name_cmp(origin, tr_comm_memb_get_origin(cur)))) { + return cur; + } + } + return NULL; +} + +TR_COMM_MEMB *tr_comm_table_find_rp_memb(TR_COMM_TABLE *ctab, TR_NAME *realm, TR_NAME *comm, TR_NAME *origin) +{ + TR_COMM_MEMB *cur=NULL; + TR_RP_REALM *rp_realm=NULL; + + for (cur=ctab->memberships; cur!=NULL; cur=cur->next) { + rp_realm=tr_comm_memb_get_rp_realm(cur); + if (rp_realm==NULL) + continue; /* was not an rp */ + + if ((0==tr_name_cmp(realm, tr_rp_realm_get_id(rp_realm))) && + (0==tr_name_cmp(comm, tr_comm_get_id(tr_comm_memb_get_comm(cur)))) && + (0==tr_name_cmp(origin, tr_comm_memb_get_origin(cur)))) { + return cur; + } + } + return NULL; +} + +TR_COMM *tr_comm_table_find_comm(TR_COMM_TABLE *ctab, TR_NAME *comm_id) +{ + return tr_comm_lookup(ctab->comms, comm_id); +} + +void tr_comm_table_add_comm(TR_COMM_TABLE *ctab, TR_COMM *new) +{ + tr_comm_add(ctab->comms, new); +} + +void tr_comm_table_remove_comm(TR_COMM_TABLE *ctab, TR_COMM *comm) +{ + tr_comm_remove(ctab->comms, comm); +} + +/* how many communities in the table? */ +size_t tr_comm_table_size(TR_COMM_TABLE *ctab) +{ + size_t count=0; + TR_COMM *this=ctab->comms; + while(this!=NULL) { + this=this->next; + count++; + } + return count; +} + + +const char *tr_realm_role_to_str(TR_REALM_ROLE role) +{ + switch(role) { + case TR_ROLE_IDP: + return "idp"; + case TR_ROLE_RP: + return "rp"; + default: + return NULL; + } +} + +TR_REALM_ROLE tr_realm_role_from_str(const char *s) +{ + if (strcmp(s, "idp")==0) + return TR_ROLE_IDP; + if (strcmp(s, "rp")==0) + return TR_ROLE_RP; + return TR_ROLE_UNKNOWN; +} + diff --git a/common/tr_config.c b/common/tr_config.c index 4307183..0d862dd 100644 --- a/common/tr_config.c +++ b/common/tr_config.c @@ -54,47 +54,94 @@ void tr_print_config (TR_CFG *cfg) { tr_print_comms(cfg->comms); } -void tr_print_comms (TR_COMM *comm_list) { +void tr_print_comms (TR_COMM_TABLE *ctab) +{ TR_COMM *comm = NULL; - for (comm = comm_list; NULL != comm; comm = comm->next) { + for (comm = ctab->comms; NULL != comm; comm = comm->next) { tr_notice("tr_print_config: Community %s:", comm->id->buf); tr_notice("tr_print_config: - Member IdPs:"); - tr_print_comm_idps(comm->idp_realms); + tr_print_comm_idps(ctab, comm); tr_notice("tr_print_config: - Member RPs:"); - tr_print_comm_rps(comm->rp_realms); + tr_print_comm_rps(ctab, comm); } } -void tr_print_comm_idps (TR_IDP_REALM *idp_list) { +void tr_print_comm_idps(TR_COMM_TABLE *ctab, TR_COMM *comm) +{ + TALLOC_CTX *tmp_ctx=talloc_new(NULL); + TR_COMM_ITER *iter=NULL; TR_IDP_REALM *idp = NULL; char *s=NULL; - for (idp = idp_list; NULL != idp; idp = idp->comm_next) { - s=tr_idp_realm_to_str(NULL, idp); + iter=tr_comm_iter_new(tmp_ctx); + if (iter==NULL) { + tr_notice("tr_print_config: unable to allocate IdP iterator."); + talloc_free(tmp_ctx); + return; + } + + for (idp=tr_idp_realm_iter_first(iter, ctab, tr_comm_get_id(comm)); + NULL!=idp; + idp=tr_idp_realm_iter_next(iter)) { + s=tr_idp_realm_to_str(tmp_ctx, idp); if (s!=NULL) tr_notice("tr_print_config: - @%s", s); else - tr_notice("tr_print_config: unable to allocate idp output string."); + tr_notice("tr_print_config: unable to allocate IdP output string."); } + talloc_free(tmp_ctx); } -void tr_print_comm_rps(TR_RP_REALM *rp_list) { +void tr_print_comm_rps(TR_COMM_TABLE *ctab, TR_COMM *comm) +{ + TALLOC_CTX *tmp_ctx=talloc_new(NULL); + TR_COMM_ITER *iter=NULL; TR_RP_REALM *rp = NULL; + char *s=NULL; - for (rp = rp_list; NULL != rp; rp = rp->next) { - tr_notice("tr_print_config: - %s", rp->realm_name->buf); + iter=tr_comm_iter_new(tmp_ctx); + if (iter==NULL) { + tr_notice("tr_print_config: unable to allocate RP iterator."); + talloc_free(tmp_ctx); + return; } + + for (rp=tr_rp_realm_iter_first(iter, ctab, tr_comm_get_id(comm)); + NULL!=rp; + rp=tr_rp_realm_iter_next(iter)) { + s=tr_rp_realm_to_str(tmp_ctx, rp); + if (s!=NULL) + tr_notice("tr_print_config: - @%s", s); + else + tr_notice("tr_print_config: unable to allocate RP output string."); + } + talloc_free(tmp_ctx); } TR_CFG *tr_cfg_new(TALLOC_CTX *mem_ctx) { - return talloc_zero(mem_ctx, TR_CFG); + TR_CFG *cfg=talloc(mem_ctx, TR_CFG); + if (cfg!=NULL) { + cfg->internal=NULL; + cfg->idp_realms=NULL; + cfg->rp_realms=NULL; + cfg->rp_clients=NULL; + cfg->peers=NULL; + cfg->default_servers=NULL; + cfg->comms=tr_comm_table_new(cfg); + if (cfg->comms==NULL) { + talloc_free(cfg); + cfg=NULL; + } + } + return cfg; } -void tr_cfg_free (TR_CFG *cfg) { +void tr_cfg_free (TR_CFG *cfg) +{ talloc_free(cfg); } @@ -952,44 +999,6 @@ cleanup: return realms; } -#if 0 -static TR_IDP_REALM *tr_cfg_parse_remote_realms(TALLOC_CTX *mem_ctx, json_t *jrealms, TR_CFG_RC *rc) -{ - TALLOC_CTX *tmp_ctx=talloc_new(NULL); - TR_IDP_REALM *realms=NULL; - TR_IDP_REALM *new_realm=NULL; - json_t *this_jrealm=NULL; - int ii=0; - - *rc=TR_CFG_ERROR; - if ((jrealms==NULL) || (!json_is_array(jrealms))) { - tr_err("tr_cfg_parse_remote_realms: realms not an array"); - *rc=TR_CFG_BAD_PARAMS; - goto cleanup; - } - - for (ii=0; iicomm_next = idp; - idp = temp_idp; + tr_comm_add_idp_realm(trc->comms, comm, found_idp, NULL, NULL); /* no provenance, never expires */ } - return idp; + *rc=TR_CFG_SUCCESS; + return; } -static TR_RP_REALM *tr_cfg_parse_comm_rps (TR_CFG *trc, json_t *jrps, TR_CFG_RC *rc) +static void tr_cfg_parse_comm_rps(TR_CFG *trc, json_t *jrps, TR_COMM *comm, TR_CFG_RC *rc) { - TR_RP_REALM *rp = NULL; - TR_RP_REALM *temp_rp = NULL; - int i = 0; + TR_RP_REALM *found_rp=NULL; + TR_RP_REALM *new_rp=NULL; + TR_NAME *rp_name=NULL; + const char *s=NULL; + int ii=0; if ((!trc) || (!jrps) || (!json_is_array(jrps))) { if (rc) *rc = TR_CFG_BAD_PARAMS; - return NULL; + return; } - for (i = (json_array_size(jrps)-1); i >= 0; i--) { - if (NULL == (temp_rp = talloc_zero(trc, TR_RP_REALM))) { - tr_debug("tr_cfg_parse_comm_rps: Can't allocate memory for RP Realm."); - if (rc) - *rc = TR_CFG_NOMEM; - return NULL; + for (ii=0; iilen, tr_comm_get_id(comm)->buf); + continue; } - if (NULL == (temp_rp->realm_name = tr_new_name((char *)json_string_value(json_array_get(jrps, i))))) { - tr_debug("tr_cfg_parse_comm_rps: No memory for RP Realm Name."); - if (rc) - *rc = TR_CFG_NOMEM; - return NULL; + /* convert string to TR_NAME */ + rp_name=tr_new_name(s); + if (rp_name==NULL) { + tr_err("tr_cfg_parse_comm_rps: unable to allocate RP name for %s in community %.*s.", + s, tr_comm_get_id(comm)->len, tr_comm_get_id(comm)->buf); } - temp_rp->next = rp; - rp = temp_rp; - } + /* see if we already have this RP in this community */ + found_rp=tr_comm_find_rp(trc->comms, comm, rp_name); + if (found_rp!=NULL) { + tr_notice("tr_cfg_parse_comm_rps: RP %s repeated in community %.*s.", + s, tr_comm_get_id(comm)->len, tr_comm_get_id(comm)->buf); + tr_free_name(rp_name); + continue; + } - return rp; + /* Add the RP to the community, first see if we have the RP in any community */ + found_rp=tr_rp_realm_lookup(trc->rp_realms, rp_name); + if (found_rp!=NULL) + new_rp=found_rp; /* use it rather than creating a new realm record */ + else { + new_rp=tr_rp_realm_new(NULL); + if (new_rp==NULL) { + tr_err("tr_cfg_parse_comm_rps: unable to allocate RP record for %s in community %.*s.", + s, tr_comm_get_id(comm)->len, tr_comm_get_id(comm)->buf); + } + tr_rp_realm_set_id(new_rp, rp_name); + rp_name=NULL; /* rp_name no longer belongs to us */ + tr_rp_realm_add(trc->rp_realms, new_rp); + } + tr_comm_add_rp_realm(trc->comms, comm, new_rp, NULL, NULL); + } } static TR_COMM *tr_cfg_parse_one_comm (TALLOC_CTX *mem_ctx, TR_CFG *trc, json_t *jcomm, TR_CFG_RC *rc) @@ -1746,7 +1770,7 @@ static TR_COMM *tr_cfg_parse_one_comm (TALLOC_CTX *mem_ctx, TR_CFG *trc, json_t goto cleanup; } - comm->idp_realms = tr_cfg_parse_comm_idps(trc, jidps, rc); + tr_cfg_parse_comm_idps(trc, jidps, comm, rc); if (TR_CFG_SUCCESS != *rc) { tr_debug("tr_cfg_parse_one_comm: Can't parse IDP realms for comm %s.", tr_comm_get_id(comm)->buf); @@ -1754,9 +1778,9 @@ static TR_COMM *tr_cfg_parse_one_comm (TALLOC_CTX *mem_ctx, TR_CFG *trc, json_t goto cleanup; } - comm->rp_realms = tr_cfg_parse_comm_rps(trc, jrps, rc); + tr_cfg_parse_comm_rps(trc, jrps, comm, rc); if (TR_CFG_SUCCESS != *rc) { - tr_debug("tr_cfg_parse_comm: Can't parse RP realms for comm %s .", + tr_debug("tr_cfg_parse_one_comm: Can't parse RP realms for comm %s .", tr_comm_get_id(comm)->buf); comm=NULL; goto cleanup; @@ -1767,7 +1791,7 @@ static TR_COMM *tr_cfg_parse_one_comm (TALLOC_CTX *mem_ctx, TR_CFG *trc, json_t comm->expiration_interval = 43200; /*30 days*/ if (jexpire) { if (!json_is_integer(jexpire)) { - fprintf(stderr, "tr_parse_comm: expirae_interval is not an integer\n"); + fprintf(stderr, "tr_parse_one_comm: expiration_interval is not an integer\n"); comm=NULL; goto cleanup; } @@ -1812,8 +1836,8 @@ static TR_CFG_RC tr_cfg_parse_comms (TR_CFG *trc, json_t *jcfg) } tr_debug("tr_cfg_parse_comms: Community configured: %s.", tr_comm_get_id(comm)->buf); - comm->next = trc->comms; - trc->comms = comm; + + tr_comm_table_add_comm(trc->comms, comm); } } tr_debug("tr_cfg_parse_comms: Finished (rc=%d)", rc); @@ -1838,7 +1862,7 @@ TR_CFG_RC tr_cfg_validate(TR_CFG *trc) rc = TR_CFG_ERROR; } - if (NULL == trc->comms) { + if (0==tr_comm_table_size(trc->comms)) { tr_debug("tr_cfg_validate: Error: No Communities configured"); rc = TR_CFG_ERROR; } diff --git a/common/tr_idp.c b/common/tr_idp.c index b035d5a..6579253 100644 --- a/common/tr_idp.c +++ b/common/tr_idp.c @@ -33,6 +33,7 @@ */ #include +#include #include #include @@ -108,11 +109,34 @@ TR_IDP_REALM *tr_idp_realm_new(TALLOC_CTX *mem_ctx) idp->aaa_servers=NULL; idp->apcs=NULL; idp->origin=TR_REALM_LOCAL; + idp->peer=NULL; + idp->expiry=talloc(idp, struct timespec); + if (idp->expiry==NULL) { + talloc_free(idp); + return NULL; + } talloc_set_destructor((void *)idp, tr_idp_realm_destructor); } return idp; } +void tr_idp_realm_free(TR_IDP_REALM *idp) +{ + talloc_free(idp); +} + +TR_NAME *tr_idp_realm_get_id(TR_IDP_REALM *idp) +{ + return idp->realm_id; +} + +void tr_idp_realm_set_id(TR_IDP_REALM *idp, TR_NAME *id) +{ + if (idp->realm_id!=NULL) + tr_free_name(idp->realm_id); + idp->realm_id=id; +} + static TR_IDP_REALM *tr_idp_realm_tail(TR_IDP_REALM *idp) { if (idp==NULL) @@ -237,3 +261,14 @@ char *tr_idp_realm_to_str(TALLOC_CTX *mem_ctx, TR_IDP_REALM *idp) talloc_free(tmp_ctx); return result; } + +void tr_idp_realm_incref(TR_IDP_REALM *realm) +{ + realm->refcount++; +} + +void tr_idp_realm_decref(TR_IDP_REALM *realm) +{ + if (realm->refcount>0) + realm->refcount--; +} diff --git a/common/tr_msg.c b/common/tr_msg.c index 9ae5909..aaddb11 100644 --- a/common/tr_msg.c +++ b/common/tr_msg.c @@ -41,6 +41,8 @@ #include +#include +#include #include #include #include @@ -569,6 +571,139 @@ static TRP_RC tr_msg_encode_inforec_route(json_t *jrec, TRP_INFOREC *rec) return TRP_SUCCESS; } +/* returns a json array */ +static json_t *tr_msg_encode_apcs(TR_APC *apcs) +{ + TALLOC_CTX *tmp_ctx=talloc_new(NULL); + TR_APC_ITER *iter=tr_apc_iter_new(tmp_ctx); + TR_APC *apc=NULL; + json_t *jarray=NULL; + json_t *jid=NULL; + + if (iter==NULL) + goto cleanup; + + jarray=json_array(); + if (jarray==NULL) + goto cleanup; + + for (apc=tr_apc_iter_first(iter, apcs); apc!=NULL; apc=tr_apc_iter_next(iter)) { + jid=tr_name_to_json_string(tr_apc_get_id(apc)); + if ((jid==NULL) || (json_array_append_new(jarray, jid)!=0)) { + json_decref(jarray); + jarray=NULL; + goto cleanup; + } + } + +cleanup: + talloc_free(tmp_ctx); + return jarray; +} + +static TR_APC *tr_msg_decode_apcs(TALLOC_CTX *mem_ctx, json_t *jarray, TRP_RC *rc) +{ + TALLOC_CTX *tmp_ctx=talloc_new(NULL); + size_t ii=0; + TR_APC *apc_list=NULL; + TR_APC *new=NULL; + json_t *jstr=NULL; + + *rc=TRP_ERROR; + + for (ii=0; iitype)); + apcs=tr_msg_decode_apcs(rec, json_object_get(jrecord, "apcs"), &rc); + if (rc!=TRP_SUCCESS) { + rc=TRP_ERROR; + goto cleanup; + } + trp_inforec_set_apcs(rec, apcs); - rc=tr_msg_get_json_string(jrecord, "trust_router", &s, tmp_ctx); + rc=tr_msg_get_json_string(jrecord, "owner_realm", &s, tmp_ctx); if (rc != TRP_SUCCESS) goto cleanup; - if (TRP_SUCCESS!=trp_inforec_set_trust_router(rec, tr_new_name(s))) + if (TRP_SUCCESS!=trp_inforec_set_owner_realm(rec, tr_new_name(s))) { + rc=TRP_ERROR; goto cleanup; + } talloc_free(s); s=NULL; - trp_inforec_set_next_hop(rec, NULL); /* make sure this is null (filled in later) */ - - rc=tr_msg_get_json_integer(jrecord, "metric", &num); - if ((rc != TRP_SUCCESS) || (TRP_SUCCESS!=trp_inforec_set_metric(rec,num))) + rc=tr_msg_get_json_string(jrecord, "owner_contact", &s, tmp_ctx); + if (rc != TRP_SUCCESS) + goto cleanup; + if (TRP_SUCCESS!=trp_inforec_set_owner_contact(rec, tr_new_name(s))) { + rc=TRP_ERROR; goto cleanup; + } + talloc_free(s); s=NULL; + + trp_inforec_set_provenance(rec, json_object_get(jrecord, "provenance")); rc=tr_msg_get_json_integer(jrecord, "interval", &num); if ((rc != TRP_SUCCESS) || (TRP_SUCCESS!=trp_inforec_set_interval(rec,num))) goto cleanup; +cleanup: + talloc_free(tmp_ctx); + return rc; +} + +/* decode a single record */ +static TRP_INFOREC *tr_msg_decode_trp_inforec(TALLOC_CTX *mem_ctx, json_t *jrecord) +{ + TALLOC_CTX *tmp_ctx=talloc_new(NULL); + TRP_INFOREC_TYPE rectype; + TRP_INFOREC *rec=NULL; + TRP_RC rc=TRP_ERROR; + char *s=NULL; + + if (0!=tr_msg_get_json_string(jrecord, "record_type", &s, tmp_ctx)) + goto cleanup; + + rectype=trp_inforec_type_from_string(s); + talloc_free(s); s=NULL; + + rec=trp_inforec_new(tmp_ctx, rectype); + if (rec==NULL) { + rc=TRP_NOMEM; + goto cleanup; + } + + tr_debug("tr_msg_decode_trp_inforec: '%s' record found.", trp_inforec_type_to_string(rec->type)); + + switch(trp_inforec_get_type(rec)) { + case TRP_INFOREC_TYPE_ROUTE: + rc=tr_msg_decode_trp_inforec_route(jrecord, rec); + break; + case TRP_INFOREC_TYPE_COMMUNITY: + rc=tr_msg_decode_trp_inforec_comm(jrecord, rec); + break; + default: + rc=TRP_UNSUPPORTED; + goto cleanup; + } + talloc_steal(mem_ctx, rec); rc=TRP_SUCCESS; diff --git a/common/tr_name.c b/common/tr_name.c index 4480a6a..eacef63 100644 --- a/common/tr_name.c +++ b/common/tr_name.c @@ -34,6 +34,7 @@ #include #include +#include #include @@ -123,6 +124,15 @@ char * tr_name_strdup(TR_NAME *src) return s; } +json_t *tr_name_to_json_string(TR_NAME *src) +{ + char *s=tr_name_strdup(src); + json_t *js=json_string(s); + if (s!=NULL) + free(s); + return js; +} + TR_NAME *tr_name_cat(TR_NAME *n1, TR_NAME *n2) { char *s=malloc(n1->len+n2->len+1); diff --git a/common/tr_rp.c b/common/tr_rp.c index 3897e58..c3a7b3b 100644 --- a/common/tr_rp.c +++ b/common/tr_rp.c @@ -121,6 +121,47 @@ TR_RP_CLIENT *tr_rp_client_lookup(TR_RP_CLIENT *rp_clients, TR_NAME *gss_name) return NULL; } +TR_RP_REALM *tr_rp_realm_lookup(TR_RP_REALM *rp_realms, TR_NAME *rp_name) +{ + TR_RP_REALM *rp = NULL; + + if ((!rp_realms) || (!rp_name)) { + tr_debug("tr_rp_realm_lookup: Bad parameters."); + return NULL; + } + + for (rp = rp_realms; NULL != rp; rp = rp->next) { + if (tr_name_cmp(tr_rp_realm_get_id(rp), rp_name)) + return rp; + } + return NULL; +} + +static int tr_rp_realm_destructor(void *obj) +{ + TR_RP_REALM *rp=talloc_get_type_abort(obj, TR_RP_REALM); + if (rp->realm_id!=NULL) + tr_free_name(rp->realm_id); + return 0; +} + +TR_RP_REALM *tr_rp_realm_new(TALLOC_CTX *mem_ctx) +{ + TR_RP_REALM *rp=talloc(mem_ctx, TR_RP_REALM); + if (rp!=NULL) { + rp->next=NULL; + rp->realm_id=NULL; + rp->refcount=0; + talloc_set_destructor((void *)rp, tr_rp_realm_destructor); + } + return rp; +} + +void tr_rp_realm_free(TR_RP_REALM *rp) +{ + talloc_free(rp); +} + /* talloc note: lists of idp realms should be assembled using * tr_idp_realm_add(). This will put all of the elements in the * list, other than the head, as children of the head context. @@ -133,7 +174,8 @@ static TR_RP_REALM *tr_rp_realm_tail(TR_RP_REALM *realm) return realm; } -/* for correct behavior, call like: rp_realms=tr_rp_realm_add(rp_realms, new_realm); */ +/* for correct behavior, call like: rp_realms=tr_rp_realm_add_func(rp_realms, new_realm); + * or better yet, use the macro */ TR_RP_REALM *tr_rp_realm_add_func(TR_RP_REALM *head, TR_RP_REALM *new) { if (head==NULL) @@ -147,3 +189,33 @@ TR_RP_REALM *tr_rp_realm_add_func(TR_RP_REALM *head, TR_RP_REALM *new) } return head; } + +void tr_rp_realm_incref(TR_RP_REALM *realm) +{ + realm->refcount++; +} + +void tr_rp_realm_decref(TR_RP_REALM *realm) +{ + if (realm->refcount>0) + realm->refcount--; +} + +TR_NAME *tr_rp_realm_get_id(TR_RP_REALM *rp) +{ + return rp->realm_id; +} + +void tr_rp_realm_set_id(TR_RP_REALM *rp, TR_NAME *id) +{ + if (rp->realm_id!=NULL) + tr_free_name(rp->realm_id); + rp->realm_id=id; +} + +char *tr_rp_realm_to_str(TALLOC_CTX *mem_ctx, TR_RP_REALM *rp) +{ + return talloc_asprintf(mem_ctx, + "RP realm: \"%.*s\"\n", + rp->realm_id->len, rp->realm_id->buf); +} diff --git a/include/tr_apc.h b/include/tr_apc.h index 6257d24..54ab7e1 100644 --- a/include/tr_apc.h +++ b/include/tr_apc.h @@ -45,6 +45,9 @@ typedef struct tr_apc { TR_NAME *id; } TR_APC; +/* iterator is just a pointer to a TR_APC */ +typedef TR_APC *TR_APC_ITER; + TR_APC *tr_apc_new(TALLOC_CTX *mem_ctx); void tr_apc_free(TR_APC *apc); TR_APC *tr_apc_add_func(TR_APC *apcs, TR_APC *new); @@ -57,6 +60,13 @@ TR_NAME *tr_apc_dup_id(TR_APC *apc); char *tr_apc_to_str(TALLOC_CTX *mem_ctx, TR_APC *apc); +TR_APC_ITER *tr_apc_iter_new(TALLOC_CTX *mem_ctx); +TR_APC *tr_apc_iter_first(TR_APC_ITER *iter, TR_APC *apc); +TR_APC *tr_apc_iter_next(TR_APC_ITER *iter); +void tr_apc_iter_free(TR_APC_ITER *iter); + +int tr_apc_in_common(TR_APC *one, TR_APC *two); + #endif diff --git a/include/tr_comm.h b/include/tr_comm.h index 85c7b03..a660435 100644 --- a/include/tr_comm.h +++ b/include/tr_comm.h @@ -35,10 +35,15 @@ #ifndef TR_COMM_H #define TR_COMM_H +#include +#include + #include #include #include +typedef struct tr_comm_table TR_COMM_TABLE; + typedef enum tr_comm_type { TR_COMM_UNKNOWN, TR_COMM_APC, @@ -50,16 +55,78 @@ typedef struct tr_comm { TR_NAME *id; TR_COMM_TYPE type; TR_APC *apcs; - TR_IDP_REALM *idp_realms; - TR_RP_REALM *rp_realms; TR_NAME *owner_realm; /* what realm owns this community? */ TR_NAME *owner_contact; /* contact email */ time_t expiration_interval; /*Minutes to key expiration; only valid for an APC*/ + unsigned int refcount; /* how many TR_COMM_MEMBs refer to this community? */ } TR_COMM; +/* community membership - link realms to their communities */ +typedef struct tr_comm_memb { + struct tr_comm_memb *next; + TR_IDP_REALM *idp; /* only set one of idp and rp, other null */ + TR_RP_REALM *rp; /* only set one of idp and rp, other null */ + TR_COMM *comm; + TR_NAME *origin; + json_t *provenance; /* array of names of systems traversed */ + struct timespec *expiry; +} TR_COMM_MEMB; + +/* table of communities/memberships */ +struct tr_comm_table { + TR_COMM *comms; /* all communities */ + TR_COMM_MEMB *memberships; /* head of the linked list of membership records */ +}; + +typedef struct tr_comm_iter { + TR_COMM_MEMB *cur_memb; + TR_NAME *match; /* realm or comm to match */ +} TR_COMM_ITER; + +typedef enum tr_realm_role { + TR_ROLE_UNKNOWN=0, + TR_ROLE_IDP, + TR_ROLE_RP +} TR_REALM_ROLE; + + + +TR_COMM_TABLE *tr_comm_table_new(TALLOC_CTX *mem_ctx); +void tr_comm_table_free(TR_COMM_TABLE *ctab); + +TR_COMM_TABLE *tr_comm_table_new(TALLOC_CTX *mem_ctx); +void tr_comm_table_free(TR_COMM_TABLE *ctab); +void tr_comm_table_add_comm(TR_COMM_TABLE *ctab, TR_COMM *new); +void tr_comm_table_remove_comm(TR_COMM_TABLE *ctab, TR_COMM *comm); +void tr_comm_table_add_memb(TR_COMM_TABLE *ctab, TR_COMM_MEMB *new); +void tr_comm_table_remove_memb(TR_COMM_TABLE *ctab, TR_COMM_MEMB *memb); +TR_COMM_MEMB *tr_comm_table_find_memb(TR_COMM_TABLE *ctab, TR_NAME *realm, TR_NAME *comm, TR_NAME *origin); +TR_COMM_MEMB *tr_comm_table_find_rp_memb(TR_COMM_TABLE *ctab, TR_NAME *rp_realm, TR_NAME *comm, TR_NAME *origin); /* TODO ?? */ +TR_COMM_MEMB *tr_comm_table_find_idp_memb(TR_COMM_TABLE *ctab, TR_NAME *idp_realm, TR_NAME *comm, TR_NAME *origin); /* TODO ?? */ +TR_COMM *tr_comm_table_find_comm(TR_COMM_TABLE *ctab, TR_NAME *comm_id); +size_t tr_comm_table_size(TR_COMM_TABLE *ctab); + +TR_COMM_MEMB *tr_comm_memb_new(TALLOC_CTX *mem_ctx); +void tr_comm_memb_free(TR_COMM_MEMB *memb); +void tr_comm_memb_set_rp_realm(TR_COMM_MEMB *memb, TR_RP_REALM *realm); +TR_RP_REALM *tr_comm_memb_get_rp_realm(TR_COMM_MEMB *memb); +void tr_comm_memb_set_idp_realm(TR_COMM_MEMB *memb, TR_IDP_REALM *realm); +TR_IDP_REALM *tr_comm_memb_get_idp_realm(TR_COMM_MEMB *memb); +void tr_comm_memb_set_comm(TR_COMM_MEMB *memb, TR_COMM *comm); +TR_COMM *tr_comm_memb_get_comm(TR_COMM_MEMB *memb); +TR_NAME *tr_comm_memb_get_origin(TR_COMM_MEMB *memb); +TR_NAME *tr_comm_memb_dup_origin(TR_COMM_MEMB *memb); +void tr_comm_memb_set_provenance(TR_COMM_MEMB *memb, json_t *prov); +void tr_comm_memb_add_to_provenance(TR_COMM_MEMB *memb, TR_NAME *hop); +size_t tr_comm_memb_provenance_len(TR_COMM_MEMB *memb); +void tr_comm_memb_set_expiry(TR_COMM_MEMB *memb, struct timespec *time); +struct timespec *tr_comm_memb_get_expiry(TR_COMM_MEMB *memb); +int tr_comm_memb_is_expired(TR_COMM_MEMB *memb, struct timespec *curtime); + TR_COMM *tr_comm_new(TALLOC_CTX *mem_ctx); void tr_comm_free(TR_COMM *comm); void tr_comm_set_id(TR_COMM *comm, TR_NAME *id); +TR_APC *tr_comm_get_apcs(TR_COMM *comm); TR_NAME *tr_comm_get_id(TR_COMM *comm); TR_NAME *tr_comm_dup_id(TR_COMM *comm); void tr_comm_set_type(TR_COMM *comm, TR_COMM_TYPE type); @@ -70,13 +137,35 @@ TR_NAME *tr_comm_dup_owner_realm(TR_COMM *comm); void tr_comm_set_owner_contact(TR_COMM *comm, TR_NAME *contact); TR_NAME *tr_comm_get_owner_contact(TR_COMM *comm); TR_NAME *tr_comm_dup_owner_contact(TR_COMM *comm); -TR_COMM *tr_comm_add_func(TR_COMM *comms, TR_COMM *new); /* use the macro instead */ -#define tr_comm_add(comms, new) ((comms)=tr_comm_add_func((comms), (new))) -void tr_comm_add_idp_realm(TR_COMM *comm, TR_IDP_REALM *realm); -void tr_comm_add_rp_realm(TR_COMM *comm, TR_RP_REALM *realm); -TR_COMM *tr_comm_lookup(TR_COMM *comms, TR_NAME *comm_name); -TR_RP_REALM *tr_find_comm_rp (TR_COMM *comm, TR_NAME *rp_realm); -TR_IDP_REALM *tr_find_comm_idp (TR_COMM *comm, TR_NAME *idp_realm); +void tr_comm_add_idp_realm(TR_COMM_TABLE *ctab, TR_COMM *comm, TR_IDP_REALM *realm, json_t *provenance, struct timespec *expiry); +void tr_comm_add_rp_realm(TR_COMM_TABLE *ctab, TR_COMM *comm, TR_RP_REALM *realm, json_t *provenance, struct timespec *expiry); +TR_RP_REALM *tr_comm_find_rp(TR_COMM_TABLE *ctab, TR_COMM *comm, TR_NAME *rp_realm); +TR_IDP_REALM *tr_comm_find_idp(TR_COMM_TABLE *ctab, TR_COMM *comm, TR_NAME *idp_realm); const char *tr_comm_type_to_str(TR_COMM_TYPE type); +TR_COMM_TYPE tr_comm_type_from_str(const char *s); +void tr_comm_incref(TR_COMM *comm); +void tr_comm_decref(TR_COMM *comm); +unsigned int tr_comm_get_refcount(TR_COMM *comm); + +/* for iterating over communities within a realm or realms within a community */ +TR_COMM_ITER *tr_comm_iter_new(TALLOC_CTX *mem_ctx); +void tr_comm_iter_free(TR_COMM_ITER *iter); + +/* these iterate over communities for a realm */ +TR_COMM *tr_comm_iter_first(TR_COMM_ITER *iter, TR_COMM_TABLE *ctab, TR_NAME *realm); +TR_COMM *tr_comm_iter_next(TR_COMM_ITER *iter); +TR_COMM *tr_comm_iter_first_rp(TR_COMM_ITER *iter, TR_COMM_TABLE *ctab, TR_NAME *realm); +TR_COMM *tr_comm_iter_next_rp(TR_COMM_ITER *iter); +TR_COMM *tr_comm_iter_first_idp(TR_COMM_ITER *iter, TR_COMM_TABLE *ctab, TR_NAME *realm); +TR_COMM *tr_comm_iter_next_idp(TR_COMM_ITER *iter); + +/* iterate over realms for a community */ +TR_RP_REALM *tr_rp_realm_iter_first(TR_COMM_ITER *iter, TR_COMM_TABLE *ctab, TR_NAME *comm); +TR_RP_REALM *tr_rp_realm_iter_next(TR_COMM_ITER *iter); +TR_IDP_REALM *tr_idp_realm_iter_first(TR_COMM_ITER *iter, TR_COMM_TABLE *ctab, TR_NAME *comm); +TR_IDP_REALM *tr_idp_realm_iter_next(TR_COMM_ITER *iter); + +const char *tr_realm_role_to_str(TR_REALM_ROLE role); +TR_REALM_ROLE tr_realm_role_from_str(const char *s); #endif diff --git a/include/tr_config.h b/include/tr_config.h index 8bd9e5b..30a45d7 100644 --- a/include/tr_config.h +++ b/include/tr_config.h @@ -84,9 +84,10 @@ typedef struct tr_cfg_internal { typedef struct tr_cfg { TR_CFG_INTERNAL *internal; /* internal trust router config */ TR_IDP_REALM *idp_realms; /* locally associated IDP Realms */ + TR_RP_REALM *rp_realms; TR_RP_CLIENT *rp_clients; /* locally associated RP Clients */ TRP_PTABLE *peers; /* TRP peer table */ - TR_COMM *comms; /* locally-known communities */ + TR_COMM_TABLE *comms; /* communities */ TR_AAA_SERVER *default_servers; /* default server list */ /* TBD -- Global Filters */ } TR_CFG; @@ -108,9 +109,9 @@ void tr_cfg_free(TR_CFG *cfg); void tr_cfg_mgr_free(TR_CFG_MGR *cfg); void tr_print_config(TR_CFG *cfg); -void tr_print_comms(TR_COMM *comm_list); -void tr_print_comm_idps(TR_IDP_REALM *idp_list); -void tr_print_comm_rps(TR_RP_REALM *rp_list); +void tr_print_comms(TR_COMM_TABLE *ctab); +void tr_print_comm_idps(TR_COMM_TABLE *ctab, TR_COMM *comm); +void tr_print_comm_rps(TR_COMM_TABLE *ctab, TR_COMM *comm); TR_IDP_REALM *tr_cfg_find_idp (TR_CFG *cfg, TR_NAME *idp_id, TR_CFG_RC *rc); TR_RP_CLIENT *tr_cfg_find_rp (TR_CFG *cfg, TR_NAME *rp_gss, TR_CFG_RC *rc); diff --git a/include/tr_idp.h b/include/tr_idp.h index 9b44cf0..5a6727e 100644 --- a/include/tr_idp.h +++ b/include/tr_idp.h @@ -36,6 +36,7 @@ #define TR_IDP_H #include +#include #include #include @@ -61,12 +62,20 @@ typedef struct tr_idp_realm { TR_AAA_SERVER *aaa_servers; TR_APC *apcs; TR_REALM_ORIGIN origin; /* how did we learn about this realm? */ + TR_NAME *peer; /* for remote/discovered, who told us about this realm? */ + struct timespec *expiry; /* when does this realm entry expire? */ + unsigned int refcount; /* how many TR_COMM_MEMBs refer to this realm */ } TR_IDP_REALM; TR_IDP_REALM *tr_idp_realm_new(TALLOC_CTX *mem_ctx); +void tr_idp_realm_free(TR_IDP_REALM *idp); +TR_NAME *tr_idp_realm_get_id(TR_IDP_REALM *idp); +void tr_idp_realm_set_id(TR_IDP_REALM *idp, TR_NAME *id); TR_IDP_REALM *tr_idp_realm_add_func(TR_IDP_REALM *head, TR_IDP_REALM *new); #define tr_idp_realm_add(head,new) ((head)=tr_idp_realm_add_func((head),(new))) char *tr_idp_realm_to_str(TALLOC_CTX *mem_ctx, TR_IDP_REALM *idp); +void tr_idp_realm_incref(TR_IDP_REALM *realm); +void tr_idp_realm_decref(TR_IDP_REALM *realm); TR_AAA_SERVER *tr_aaa_server_new(TALLOC_CTX *mem_ctx, TR_NAME *hostname); void tr_aaa_server_free(TR_AAA_SERVER *aaa); diff --git a/include/tr_rp.h b/include/tr_rp.h index aab3ce1..92e8a04 100644 --- a/include/tr_rp.h +++ b/include/tr_rp.h @@ -50,7 +50,8 @@ typedef struct tr_rp_client { /* Structure to make a linked list of RP realms by name for community config */ typedef struct tr_rp_realm { struct tr_rp_realm *next; - TR_NAME *realm_name; + TR_NAME *realm_id; + unsigned int refcount; /* how many TR_COMM_MEMBs refer to this realm */ } TR_RP_REALM; /* prototypes */ @@ -60,8 +61,18 @@ TR_RP_CLIENT *tr_rp_client_add_func(TR_RP_CLIENT *clients, TR_RP_CLIENT *new); #define tr_rp_client_add(clients,new) ((clients)=tr_rp_client_add_func((clients),(new))) int tr_rp_client_add_gss_name(TR_RP_CLIENT *client, TR_NAME *name); int tr_rp_client_set_filter(TR_RP_CLIENT *client, TR_FILTER *filt); - TR_RP_CLIENT *tr_rp_client_lookup(TR_RP_CLIENT *rp_clients, TR_NAME *gss_name); + +TR_RP_REALM *tr_rp_realm_new(TALLOC_CTX *mem_ctx); +void tr_rp_realm_free(TR_RP_REALM *rp); +TR_NAME *tr_rp_realm_get_id(TR_RP_REALM *rp); +void tr_rp_realm_set_id(TR_RP_REALM *rp, TR_NAME *id); +TR_RP_REALM *tr_rp_realm_lookup(TR_RP_REALM *rp_realms, TR_NAME *rp_name); TR_RP_REALM *tr_rp_realm_add_func(TR_RP_REALM *head, TR_RP_REALM *new); #define tr_rp_realm_add(head,new) ((head)=tr_rp_realm_add_func((head),(new))) +void tr_rp_realm_incref(TR_RP_REALM *realm); +void tr_rp_realm_decref(TR_RP_REALM *realm); + +char *tr_rp_realm_to_str(TALLOC_CTX *mem_ctx, TR_RP_REALM *rp); + #endif diff --git a/include/trp_internal.h b/include/trp_internal.h index c7e4b22..a0a77e3 100644 --- a/include/trp_internal.h +++ b/include/trp_internal.h @@ -35,6 +35,7 @@ #ifndef TRP_INTERNAL_H #define TRP_INTERNAL_H +#include #include #include @@ -58,12 +59,13 @@ typedef struct trp_inforec_route { } TRP_INFOREC_ROUTE; typedef struct trp_inforec_comm { - TR_COMM_TYPE type; - int is_service_realm; - int is_idp_realm; + TR_COMM_TYPE comm_type; + TR_REALM_ROLE role; TR_APC *apcs; TR_NAME *owner_realm; TR_NAME *owner_contact; + json_t *provenance; + unsigned int interval; } TRP_INFOREC_COMM; typedef union trp_inforec_data { @@ -147,6 +149,7 @@ struct trps_instance { TR_MQ *mq; /* incoming message queue */ TRP_PTABLE *ptable; /* peer table */ TRP_RTABLE *rtable; /* route table */ + TR_COMM_TABLE *ctable; /* community table */ struct timeval connect_interval; /* interval between connection refreshes */ struct timeval update_interval; /* interval between scheduled updates */ struct timeval sweep_interval; /* interval between route table sweeps */ @@ -207,6 +210,7 @@ TRP_RC trpc_send_msg(TRPC_INSTANCE *trpc, const char *msg_content); TRPS_INSTANCE *trps_new (TALLOC_CTX *mem_ctx); void trps_free (TRPS_INSTANCE *trps); +void trps_set_ctable(TRPS_INSTANCE *trps, TR_COMM_TABLE *comm); void trps_set_ptable(TRPS_INSTANCE *trps, TRP_PTABLE *ptable); void trps_set_peer_status_callback(TRPS_INSTANCE *trps, void (*cb)(TRP_PEER *, void *), void *cookie); TRP_RC trps_init_rtable(TRPS_INSTANCE *trps); @@ -246,4 +250,41 @@ TRP_PEER *trps_get_peer_by_servicename(TRPS_INSTANCE *trps, TR_NAME *servicename TRP_RC trps_update(TRPS_INSTANCE *trps, TRP_UPDATE_TYPE type); int trps_peer_connected(TRPS_INSTANCE *trps, TRP_PEER *peer); TRP_RC trps_wildcard_route_req(TRPS_INSTANCE *trps, TR_NAME *peer_gssname); + +TRP_INFOREC *trp_inforec_new(TALLOC_CTX *mem_ctx, TRP_INFOREC_TYPE type); +void trp_inforec_free(TRP_INFOREC *rec); +TRP_INFOREC *trp_inforec_get_next(TRP_INFOREC *rec); +void trp_inforec_set_next(TRP_INFOREC *rec, TRP_INFOREC *next_rec); +TRP_INFOREC_TYPE trp_inforec_get_type(TRP_INFOREC *rec); +void trp_inforec_set_type(TRP_INFOREC *rec, TRP_INFOREC_TYPE type); +TR_NAME *trp_inforec_get_comm(TRP_INFOREC *rec); +TR_NAME *trp_inforec_dup_comm(TRP_INFOREC *rec); +TRP_RC trp_inforec_set_comm(TRP_INFOREC *rec, TR_NAME *comm); +TR_NAME *trp_inforec_get_realm(TRP_INFOREC *rec); +TR_NAME *trp_inforec_dup_realm(TRP_INFOREC *rec); +TRP_RC trp_inforec_set_realm(TRP_INFOREC *rec, TR_NAME *realm); +TR_NAME *trp_inforec_get_trust_router(TRP_INFOREC *rec); +TR_NAME *trp_inforec_dup_trust_router(TRP_INFOREC *rec); +TRP_RC trp_inforec_set_trust_router(TRP_INFOREC *rec, TR_NAME *trust_router); +TR_NAME *trp_inforec_get_next_hop(TRP_INFOREC *rec); +TR_NAME *trp_inforec_dup_next_hop(TRP_INFOREC *rec); +TRP_RC trp_inforec_set_next_hop(TRP_INFOREC *rec, TR_NAME *next_hop); +unsigned int trp_inforec_get_metric(TRP_INFOREC *rec); +TRP_RC trp_inforec_set_metric(TRP_INFOREC *rec, unsigned int metric); +unsigned int trp_inforec_get_interval(TRP_INFOREC *rec); +TRP_RC trp_inforec_set_interval(TRP_INFOREC *rec, unsigned int interval); +TR_NAME *trp_inforec_get_owner_realm(TRP_INFOREC *rec); +TRP_RC trp_inforec_set_owner_realm(TRP_INFOREC *rec, TR_NAME *name); +TR_NAME *trp_inforec_get_owner_contact(TRP_INFOREC *rec); +TRP_RC trp_inforec_set_owner_contact(TRP_INFOREC *rec, TR_NAME *name); +json_t *trp_inforec_get_provenance(TRP_INFOREC *rec); +TRP_RC trp_inforec_set_provenance(TRP_INFOREC *rec, json_t *prov); +TRP_INFOREC_TYPE trp_inforec_type_from_string(const char *s); +const char *trp_inforec_type_to_string(TRP_INFOREC_TYPE msgtype); +TR_COMM_TYPE trp_inforec_get_comm_type(TRP_INFOREC *rec); +TRP_RC trp_inforec_set_comm_type(TRP_INFOREC *rec, TR_COMM_TYPE type); +TR_REALM_ROLE trp_inforec_get_role(TRP_INFOREC *rec); +TRP_RC trp_inforec_set_role(TRP_INFOREC *rec, TR_REALM_ROLE role); +TR_APC *trp_inforec_get_apcs(TRP_INFOREC *rec); +TRP_RC trp_inforec_set_apcs(TRP_INFOREC *rec, TR_APC *apcs); #endif /* TRP_INTERNAL_H */ diff --git a/include/trust_router/tr_name.h b/include/trust_router/tr_name.h index 5509f87..7e86003 100644 --- a/include/trust_router/tr_name.h +++ b/include/trust_router/tr_name.h @@ -35,6 +35,7 @@ #ifndef TR_NAME_H #define TR_NAME_H #include +#include #include typedef const char *tr_const_string; @@ -50,6 +51,7 @@ TR_EXPORT void tr_free_name (TR_NAME *name); TR_EXPORT int tr_name_cmp (TR_NAME *one, TR_NAME *two); TR_EXPORT void tr_name_strlcat(char *dest, const TR_NAME *src, size_t len); TR_EXPORT char *tr_name_strdup(TR_NAME *); -TR_NAME *tr_name_cat(TR_NAME *n1, TR_NAME *n2); +TR_EXPORT json_t *tr_name_to_json_string(TR_NAME *src); +TR_EXPORT TR_NAME *tr_name_cat(TR_NAME *n1, TR_NAME *n2); #endif diff --git a/include/trust_router/trp.h b/include/trust_router/trp.h index f54c959..f174c95 100644 --- a/include/trust_router/trp.h +++ b/include/trust_router/trp.h @@ -65,7 +65,7 @@ typedef enum trp_rc { typedef enum trp_inforec_type { TRP_INFOREC_TYPE_UNKNOWN=0, /* conveniently, JSON parser returns 0 if a non-integer number is specified */ TRP_INFOREC_TYPE_ROUTE, - TRP_INFOREC_TYPE_COMMUNITY, /* not yet implemented (2016-06-14) */ + TRP_INFOREC_TYPE_COMMUNITY } TRP_INFOREC_TYPE; typedef struct trp_inforec TRP_INFOREC; @@ -89,30 +89,6 @@ TR_EXPORT TR_NAME *trp_upd_get_peer(TRP_UPD *upd); TR_NAME *trp_upd_dup_peer(TRP_UPD *upd); void trp_upd_set_peer(TRP_UPD *upd, TR_NAME *peer); void trp_upd_set_next_hop(TRP_UPD *upd, const char *hostname, unsigned int port); -TR_EXPORT TRP_INFOREC *trp_inforec_new(TALLOC_CTX *mem_ctx, TRP_INFOREC_TYPE type); -void trp_inforec_free(TRP_INFOREC *rec); -TR_EXPORT TRP_INFOREC *trp_inforec_get_next(TRP_INFOREC *rec); -void trp_inforec_set_next(TRP_INFOREC *rec, TRP_INFOREC *next_rec); -TR_EXPORT TRP_INFOREC_TYPE trp_inforec_get_type(TRP_INFOREC *rec); -void trp_inforec_set_type(TRP_INFOREC *rec, TRP_INFOREC_TYPE type); -TR_EXPORT TR_NAME *trp_inforec_get_comm(TRP_INFOREC *rec); -TR_EXPORT TR_NAME *trp_inforec_dup_comm(TRP_INFOREC *rec); -TRP_RC trp_inforec_set_comm(TRP_INFOREC *rec, TR_NAME *comm); -TR_EXPORT TR_NAME *trp_inforec_get_realm(TRP_INFOREC *rec); -TR_EXPORT TR_NAME *trp_inforec_dup_realm(TRP_INFOREC *rec); -TRP_RC trp_inforec_set_realm(TRP_INFOREC *rec, TR_NAME *realm); -TR_EXPORT TR_NAME *trp_inforec_get_trust_router(TRP_INFOREC *rec); -TR_EXPORT TR_NAME *trp_inforec_dup_trust_router(TRP_INFOREC *rec); -TRP_RC trp_inforec_set_trust_router(TRP_INFOREC *rec, TR_NAME *trust_router); -TR_EXPORT TR_NAME *trp_inforec_get_next_hop(TRP_INFOREC *rec); -TR_EXPORT TR_NAME *trp_inforec_dup_next_hop(TRP_INFOREC *rec); -TRP_RC trp_inforec_set_next_hop(TRP_INFOREC *rec, TR_NAME *next_hop); -TR_EXPORT unsigned int trp_inforec_get_metric(TRP_INFOREC *rec); -TRP_RC trp_inforec_set_metric(TRP_INFOREC *rec, unsigned int metric); -TR_EXPORT unsigned int trp_inforec_get_interval(TRP_INFOREC *rec); -TRP_RC trp_inforec_set_interval(TRP_INFOREC *rec, unsigned int interval); -TR_EXPORT TRP_INFOREC_TYPE trp_inforec_type_from_string(const char *s); -TR_EXPORT const char *trp_inforec_type_to_string(TRP_INFOREC_TYPE msgtype); /* Functions for TRP_REQ structures */ TR_EXPORT TRP_REQ *trp_req_new(TALLOC_CTX *mem_ctx); diff --git a/tr/tr_tid.c b/tr/tr_tid.c index 289ffba..b0715ac 100644 --- a/tr/tr_tid.c +++ b/tr/tr_tid.c @@ -115,7 +115,7 @@ static int tr_tids_req_handler (TIDS_INSTANCE *tids, goto cleanup; } - if (NULL == (cfg_comm = tr_comm_lookup(cfg_mgr->active->comms, orig_req->comm))) { + if (NULL == (cfg_comm = tr_comm_table_find_comm(cfg_mgr->active->comms, orig_req->comm))) { tr_notice("tr_tids_req_hander: Request for unknown comm: %s.", orig_req->comm->buf); tids_send_err_response(tids, orig_req, "Unknown community"); retval=-1; @@ -145,7 +145,7 @@ static int tr_tids_req_handler (TIDS_INSTANCE *tids, goto cleanup; } /* Check that the rp_realm is a member of the community in the request */ - if (NULL == (tr_find_comm_rp(cfg_comm, orig_req->rp_realm))) { + if (NULL == (tr_comm_find_rp(cfg_mgr->active->comms, cfg_comm, orig_req->rp_realm))) { tr_notice("tr_tids_req_handler: RP Realm (%s) not member of community (%s).", orig_req->rp_realm->buf, orig_req->comm->buf); tids_send_err_response(tids, orig_req, "RP COI membership error"); retval=-1; @@ -165,7 +165,7 @@ static int tr_tids_req_handler (TIDS_INSTANCE *tids, apc = tr_dup_name(cfg_comm->apcs->id); /* Check that the APC is configured */ - if (NULL == (cfg_apc = tr_comm_lookup(cfg_mgr->active->comms, apc))) { + if (NULL == (cfg_apc = tr_comm_table_find_comm(cfg_mgr->active->comms, apc))) { tr_notice("tr_tids_req_hander: Request for unknown comm: %s.", apc->buf); tids_send_err_response(tids, orig_req, "Unknown APC"); retval=-1; @@ -176,7 +176,7 @@ static int tr_tids_req_handler (TIDS_INSTANCE *tids, fwd_req->orig_coi = orig_req->comm; /* Check that rp_realm is a member of this APC */ - if (NULL == (tr_find_comm_rp(cfg_apc, orig_req->rp_realm))) { + if (NULL == (tr_comm_find_rp(cfg_mgr->active->comms, cfg_apc, orig_req->rp_realm))) { tr_notice("tr_tids_req_hander: RP Realm (%s) not member of community (%s).", orig_req->rp_realm->buf, orig_req->comm->buf); tids_send_err_response(tids, orig_req, "RP APC membership error"); retval=-1; @@ -217,13 +217,13 @@ static int tr_tids_req_handler (TIDS_INSTANCE *tids, } } else { /* if we aren't defaulting, check idp coi and apc membership */ - if (NULL == (tr_find_comm_idp(cfg_comm, fwd_req->realm))) { + if (NULL == (tr_comm_find_idp(cfg_mgr->active->comms, cfg_comm, fwd_req->realm))) { tr_notice("tr_tids_req_handler: IDP Realm (%s) not member of community (%s).", orig_req->realm->buf, orig_req->comm->buf); tids_send_err_response(tids, orig_req, "IDP community membership error"); retval=-1; goto cleanup; } - if ( cfg_apc && (NULL == (tr_find_comm_idp(cfg_apc, fwd_req->realm)))) { + if ( cfg_apc && (NULL == (tr_comm_find_idp(cfg_mgr->active->comms, cfg_apc, fwd_req->realm)))) { tr_notice("tr_tids_req_handler: IDP Realm (%s) not member of APC (%s).", orig_req->realm->buf, orig_req->comm->buf); tids_send_err_response(tids, orig_req, "IDP APC membership error"); retval=-1; diff --git a/tr/tr_trp.c b/tr/tr_trp.c index 1f30099..9ea8882 100644 --- a/tr/tr_trp.c +++ b/tr/tr_trp.c @@ -833,6 +833,7 @@ void tr_config_changed(TR_CFG *new_cfg, void *cookie) trps_set_connect_interval(trps, new_cfg->internal->trp_connect_interval); trps_set_update_interval(trps, new_cfg->internal->trp_update_interval); trps_set_sweep_interval(trps, new_cfg->internal->trp_sweep_interval); + trps_set_ctable(trps, new_cfg->comms); trps_set_ptable(trps, new_cfg->peers); trps_set_peer_status_callback(trps, tr_peer_status_change, (void *)trps); trps_clear_rtable(trps); /* should we do this every time??? */ diff --git a/trp/trp_upd.c b/trp/trp_upd.c index c8bd784..a76c76b 100644 --- a/trp/trp_upd.c +++ b/trp/trp_upd.c @@ -37,6 +37,8 @@ #include #include +#include +#include #include @@ -137,6 +139,8 @@ static int trp_inforec_comm_destructor(void *obj) tr_free_name(rec->owner_realm); if (rec->owner_contact!=NULL) tr_free_name(rec->owner_contact); + if (rec->provenance!=NULL) + json_decref(rec->provenance); return 0; } @@ -153,12 +157,12 @@ static TRP_INFOREC_DATA *trp_inforec_comm_new(TALLOC_CTX *mem_ctx) talloc_free(new_data); new_data=NULL; } else { - new_rec->type=TR_COMM_UNKNOWN; - new_rec->is_service_realm=0; - new_rec->is_idp_realm=0; + new_rec->comm_type=TR_COMM_UNKNOWN; + new_rec->role=TR_ROLE_UNKNOWN; new_rec->apcs=NULL; new_rec->owner_realm=NULL; new_rec->owner_contact=NULL; + new_rec->provenance=NULL; talloc_set_destructor((void *)new_rec, trp_inforec_comm_destructor); new_data->comm=new_rec; } @@ -303,6 +307,10 @@ unsigned int trp_inforec_get_interval(TRP_INFOREC *rec) if (rec->data->route!=NULL) return rec->data->route->interval; break; + case TRP_INFOREC_TYPE_COMMUNITY: + if (rec->data->comm!=NULL) + return rec->data->comm->interval; + break; default: break; } @@ -316,6 +324,96 @@ TRP_RC trp_inforec_set_interval(TRP_INFOREC *rec, unsigned int interval) if (rec->data->route!=NULL) { rec->data->route->interval=interval; return TRP_SUCCESS; + } + break; + case TRP_INFOREC_TYPE_COMMUNITY: + if (rec->data->comm!=NULL) { + rec->data->comm->interval=interval; + return TRP_SUCCESS; + } + default: + break; + } + return TRP_ERROR; +} + +TR_COMM_TYPE trp_inforec_get_comm_type(TRP_INFOREC *rec) +{ + switch (rec->type) { + case TRP_INFOREC_TYPE_COMMUNITY: + if (rec->data->comm!=NULL) + return rec->data->comm->comm_type; + break; + default: + break; + } + return TR_COMM_UNKNOWN; +} + +TRP_RC trp_inforec_set_comm_type(TRP_INFOREC *rec, TR_COMM_TYPE type) +{ + switch (rec->type) { + case TRP_INFOREC_TYPE_COMMUNITY: + if (rec->data->comm!=NULL) { + rec->data->comm->comm_type=type; + return TRP_SUCCESS; + } + break; + default: + break; + } + return TRP_ERROR; +} + +TR_REALM_ROLE trp_inforec_get_role(TRP_INFOREC *rec) +{ + switch (rec->type) { + case TRP_INFOREC_TYPE_COMMUNITY: + if (rec->data->comm!=NULL) + return rec->data->comm->role; + break; + default: + break; + } + return TR_ROLE_UNKNOWN; +} + +TRP_RC trp_inforec_set_role(TRP_INFOREC *rec, TR_REALM_ROLE role) +{ + switch (rec->type) { + case TRP_INFOREC_TYPE_COMMUNITY: + if (rec->data->comm!=NULL) { + rec->data->comm->role=role; + return TRP_SUCCESS; + break; + } + default: + break; + } + return TRP_ERROR; +} + +TR_APC *trp_inforec_get_apcs(TRP_INFOREC *rec) +{ + switch (rec->type) { + case TRP_INFOREC_TYPE_COMMUNITY: + if (rec->data->comm!=NULL) + return rec->data->comm->apcs; + break; + default: + break; + } + return NULL; +} + +TRP_RC trp_inforec_set_apcs(TRP_INFOREC *rec, TR_APC *apcs) +{ + switch (rec->type) { + case TRP_INFOREC_TYPE_COMMUNITY: + if (rec->data->comm!=NULL) { + rec->data->comm->apcs=apcs; + talloc_steal(rec, apcs); + return TRP_SUCCESS; default: break; } @@ -324,6 +422,95 @@ TRP_RC trp_inforec_set_interval(TRP_INFOREC *rec, unsigned int interval) return TRP_ERROR; } +TR_NAME *trp_inforec_get_owner_realm(TRP_INFOREC *rec) +{ + switch (rec->type) { + case TRP_INFOREC_TYPE_COMMUNITY: + if (rec->data->comm!=NULL) + return rec->data->comm->owner_realm; + break; + default: + break; + } + return NULL; +} + +TRP_RC trp_inforec_set_owner_realm(TRP_INFOREC *rec, TR_NAME *name) +{ + switch (rec->type) { + case TRP_INFOREC_TYPE_COMMUNITY: + if (rec->data->comm!=NULL) { + rec->data->comm->owner_realm=name; + return TRP_SUCCESS; + default: + break; + } + break; + } + return TRP_ERROR; +} + +TR_NAME *trp_inforec_get_owner_contact(TRP_INFOREC *rec) +{ + switch (rec->type) { + case TRP_INFOREC_TYPE_COMMUNITY: + if (rec->data->comm!=NULL) + return rec->data->comm->owner_contact; + break; + default: + break; + } + return NULL; +} + +TRP_RC trp_inforec_set_owner_contact(TRP_INFOREC *rec, TR_NAME *name) +{ + switch (rec->type) { + case TRP_INFOREC_TYPE_COMMUNITY: + if (rec->data->comm!=NULL) { + rec->data->comm->owner_contact=name; + return TRP_SUCCESS; + } + break; + default: + break; + } + return TRP_ERROR; +} + +/* caller needs to incref the output if they're going to hang on to it */ +json_t *trp_inforec_get_provenance(TRP_INFOREC *rec) +{ + switch (rec->type) { + case TRP_INFOREC_TYPE_COMMUNITY: + if (rec->data->comm!=NULL) + return rec->data->comm->provenance; + break; + default: + break; + } + return NULL; +} + +/* increments the reference count */ +TRP_RC trp_inforec_set_provenance(TRP_INFOREC *rec, json_t *prov) +{ + switch (rec->type) { + case TRP_INFOREC_TYPE_COMMUNITY: + if (rec->data->comm!=NULL) { + if (rec->data->comm->provenance!=NULL) + json_decref(rec->data->comm->provenance); + rec->data->comm->provenance=prov; + json_incref(prov); + return TRP_SUCCESS; + } + break; + default: + break; + } + return TRP_ERROR; +} + /* generic record type */ TRP_INFOREC *trp_inforec_new(TALLOC_CTX *mem_ctx, TRP_INFOREC_TYPE type) { @@ -484,10 +671,9 @@ static void trp_inforec_route_print(TRP_INFOREC_DATA *data) static void trp_inforec_comm_print(TRP_INFOREC_DATA *data) { if (data->comm!=NULL) { - printf(" type=%s\n service=%s\n IdP=%s\n owner=%.*s\n contact=%.*s]\n", - tr_comm_type_to_str(data->comm->type), - (data->comm->is_service_realm)?"yes":"no", - (data->comm->is_idp_realm)?"yes":"no", + printf(" type=%s\n role=%s\n owner=%.*s\n contact=%.*s]\n", + tr_comm_type_to_str(data->comm->comm_type), + tr_realm_role_to_str(data->comm->role), data->comm->owner_realm->len, data->comm->owner_realm->buf, data->comm->owner_contact->len, data->comm->owner_contact->buf); /* TODO: print apcs */ diff --git a/trp/trps.c b/trp/trps.c index e01b5bd..218f5d8 100644 --- a/trp/trps.c +++ b/trp/trps.c @@ -39,6 +39,7 @@ #include #include +#include #include #include #include @@ -157,6 +158,13 @@ void trps_set_sweep_interval(TRPS_INSTANCE *trps, unsigned int interval) trps->sweep_interval.tv_usec=0; } +void trps_set_ctable(TRPS_INSTANCE *trps, TR_COMM_TABLE *comm) +{ + if (trps->ctable!=NULL) + tr_comm_table_free(trps->ctable); + trps->ctable=comm; +} + void trps_set_ptable(TRPS_INSTANCE *trps, TRP_PTABLE *ptable) { if (trps->ptable!=NULL) @@ -798,7 +806,7 @@ static int trps_expired(struct timespec *expiry, struct timespec *curtime) { return ((curtime->tv_sec > expiry->tv_sec) || ((curtime->tv_sec == expiry->tv_sec) - &&(curtime->tv_nsec > expiry->tv_nsec))); + &&(curtime->tv_nsec >= expiry->tv_nsec))); } /* Sweep for expired routes. For each expired route, if its metric is infinite, the route is flushed. @@ -963,6 +971,26 @@ static TRP_INFOREC *trps_route_to_inforec(TALLOC_CTX *mem_ctx, TRPS_INSTANCE *tr return rec; } +/* Every realm has a community, so always returns at least one record except on error. */ +static TRP_INFOREC *trps_comm_inforecs_for_realm(TALLOC_CTX *mem_ctx, TRPS_INSTANCE *trps, TR_NAME *comm_name, TR_NAME *realm) +{ + TALLOC_CTX *tmp_ctx=talloc_new(NULL); +/* TRP_INFOREC *results=NULL;*/ +/* TRP_INFOREC *rec=NULL;*/ + TR_COMM *this_comm=NULL; + TR_COMM_ITER *comm_iter=NULL; + + comm_iter=tr_comm_iter_new(tmp_ctx); + for (this_comm=tr_comm_iter_first(comm_iter, trps->ctable, comm_name); + this_comm!=NULL; + this_comm=tr_comm_iter_next(comm_iter)) { + printf("dink"); + } + + talloc_free(tmp_ctx); + return NULL; +} + /* all routes to a single peer, unless comm/realm are specified (both or neither must be NULL) */ static TRP_RC trps_update_one_peer(TRPS_INSTANCE *trps, TRP_PEER *peer, @@ -1029,7 +1057,7 @@ static TRP_RC trps_update_one_peer(TRPS_INSTANCE *trps, goto cleanup; } if ((n_updates>0) && (update_list!=NULL)) { - tr_debug("trps_update_one_peer: sending %u update records.", (unsigned int)n_updates); + tr_debug("trps_update_one_peer: sending %u update messages.", (unsigned int)n_updates); for (ii=0; iilen, realm->buf, + comm->len, comm->buf); + rc=TRP_NOMEM; + goto cleanup; + } + trp_upd_add_inforec(upd, rec); + + /* now add community info records */ + rec=trps_comm_inforecs_for_realm(tmp_ctx, + trps, + trp_route_get_comm(update_list[ii]), + trp_route_get_realm(update_list[ii])); + if (rec==NULL) { tr_err("trps_update_one_peer: could not create all update records."); rc=TRP_NOMEM; goto cleanup; -- 2.1.4