TID_RESP: array of servers rather than linked list

Provide an array of servers rather than a linked list for easier sorting.

TID_RESP is now allocated by talloc.

diff --git a/common/tr_msg.c b/common/tr_msg.c
index 28e2920..d2982fe 100644 (file)
--- a/common/tr_msg.c
+++ b/common/tr_msg.c
@@ -38,6 +38,8 @@
 #include <openssl/dh.h>
 #include <jansson.h>
 #include <assert.h>
+#include <talloc.h>
+
 
 #include <tr_msg.h>
 #include <trust_router/tr_name.h>
@@ -235,45 +237,40 @@ static json_t *tr_msg_encode_one_server(TID_SRVR_BLK *srvr)
   return jsrvr;
 }
 
-static TID_SRVR_BLK *tr_msg_decode_one_server(json_t *jsrvr) 
+static int tr_msg_decode_one_server(json_t *jsrvr, TID_SRVR_BLK *srvr) 
 {
-  TID_SRVR_BLK *srvr;
   json_t *jsrvr_addr = NULL;
   json_t *jsrvr_kn = NULL;
   json_t *jsrvr_dh = NULL;
 
   if (jsrvr == NULL)
-    return NULL;
+    return -1;
 
-  if (NULL == (srvr = malloc(sizeof(TID_SRVR_BLK)))) 
-    return NULL;
-  memset(srvr, 0, sizeof(TID_SRVR_BLK));
 
   if ((NULL == (jsrvr_addr = json_object_get(jsrvr, "server_addr"))) ||
       (NULL == (jsrvr_kn = json_object_get(jsrvr, "key_name"))) ||
       (NULL == (jsrvr_dh = json_object_get(jsrvr, "server_dh")))) {
-    fprintf (stderr, "tr_msg_decode_one_server(): Error parsing required fields.\n");
-    free(srvr);
-    return NULL;
+    tr_debug("tr_msg_decode_one_server(): Error parsing required fields.\n");
+    return -1;
   }
   
   /* TBD -- handle IPv6 Addresses */
   inet_aton(json_string_value(jsrvr_addr), &(srvr->aaa_server_addr));
   srvr->key_name = tr_new_name((char *)json_string_value(jsrvr_kn));
   srvr->aaa_server_dh = tr_msg_decode_dh(jsrvr_dh);
-
-  return srvr;
+  return 0;
 }
 
-static json_t *tr_msg_encode_servers(TID_SRVR_BLK *servers)
+static json_t *tr_msg_encode_servers(TID_RESP *resp)
 {
   json_t *jservers = NULL;
   json_t *jsrvr = NULL;
   TID_SRVR_BLK *srvr = NULL;
+  size_t index;
 
   jservers = json_array();
 
-  for (srvr = servers; srvr != NULL; srvr = srvr->next) {
+  tid_resp_servers_foreach(resp, srvr, index) {
     if ((NULL == (jsrvr = tr_msg_encode_one_server(srvr))) ||
        (-1 == json_array_append_new(jservers, jsrvr))) {
       return NULL;
@@ -285,11 +282,9 @@ static json_t *tr_msg_encode_servers(TID_SRVR_BLK *servers)
   return jservers;
 }
 
-static TID_SRVR_BLK *tr_msg_decode_servers(json_t *jservers) 
+static TID_SRVR_BLK *tr_msg_decode_servers(void * ctx, json_t *jservers) 
 {
   TID_SRVR_BLK *servers = NULL;
-  TID_SRVR_BLK *next = NULL;
-  TID_SRVR_BLK *srvr = NULL;
   json_t *jsrvr;
   size_t i, num_servers;
 
@@ -300,19 +295,16 @@ static TID_SRVR_BLK *tr_msg_decode_servers(json_t *jservers)
     fprintf(stderr, "tr_msg_decode_servers(): Server array is empty.\n"); 
     return NULL;
   }
+    servers = talloc_zero_array(ctx, TID_SRVR_BLK, num_servers);
 
   for (i = 0; i < num_servers; i++) {
     jsrvr = json_array_get(jservers, i);
-    srvr = tr_msg_decode_one_server(jsrvr);
-
-    /* skip to the end of the list, and add srvr to list of servers */
-    if (NULL == servers) {
-      servers = srvr;
-    }
-    else {
-      for (next = servers; next->next != NULL; next = next->next);
-      next->next = srvr;
+    if (0 != tr_msg_decode_one_server(jsrvr, &servers[i])) {
+      talloc_free(servers);
+      return NULL;
     }
+
+
   }
 
   return servers;
@@ -360,7 +352,7 @@ static json_t * tr_msg_encode_tidresp(TID_RESP *resp)
     fprintf(stderr, "tr_msg_encode_tidresp(): No servers to encode.\n");
     return jresp;
   }
-  jservers = tr_msg_encode_servers(resp->servers);
+  jservers = tr_msg_encode_servers(resp);
   json_object_set_new(jresp, "servers", jservers);
   
   return jresp;
@@ -377,12 +369,11 @@ static TID_RESP *tr_msg_decode_tidresp(json_t *jresp)
   json_t *jservers = NULL;
   json_t *jerr_msg = NULL;
 
-  if (!(tresp = malloc(sizeof(TID_RESP)))) {
+  if (!(tresp = talloc_zero(NULL, TID_RESP))) {
     fprintf (stderr, "tr_msg_decode_tidresp(): Error allocating TID_RESP structure.\n");
     return NULL;
   }
  
-  memset(tresp, 0, sizeof(TID_RESP));
 
   /* store required fields from response */
   if ((NULL == (jresult = json_object_get(jresp, "result"))) ||
@@ -394,7 +385,7 @@ static TID_RESP *tr_msg_decode_tidresp(json_t *jresp)
       (NULL == (jcomm = json_object_get(jresp, "comm"))) ||
       (!json_is_string(jcomm))) {
     fprintf (stderr, "tr_msg_decode_tidresp(): Error parsing response.\n");
-    free(tresp);
+    talloc_free(tresp);
     return NULL;
   }
 
@@ -402,9 +393,10 @@ static TID_RESP *tr_msg_decode_tidresp(json_t *jresp)
     fprintf(stderr, "tr_msg_decode_tidresp(): Success! result = %s.\n", json_string_value(jresult));
     if ((NULL != (jservers = json_object_get(jresp, "servers"))) ||
        (!json_is_array(jservers))) {
-      tresp->servers = tr_msg_decode_servers(jservers); 
+      tresp->servers = tr_msg_decode_servers(tresp, jservers); 
     } 
     else {
+      talloc_free(tresp);
       return NULL;
     }
     tresp->result = TID_SUCCESS;

diff --git a/include/tid_internal.h b/include/tid_internal.h
index db8189d..4e206da 100644 (file)
--- a/include/tid_internal.h
+++ b/include/tid_internal.h
@@ -71,7 +71,6 @@
 
 #include <jansson.h>
 typedef struct tid_srvr_blk {
-  struct tid_srvr_blk *next;
   struct in_addr aaa_server_addr;
   TR_NAME *key_name;
   DH *aaa_server_dh;           /* AAA server's public dh information */
@@ -85,7 +84,8 @@ typedef struct tid_resp {
   TR_NAME *comm;
   TR_CONSTRAINT_SET *cons;
   TR_NAME *orig_coi;
-  TID_SRVR_BLK *servers;               /* Linked list of servers */
+  TID_SRVR_BLK *servers;               /* array of servers */
+  size_t num_servers;
   /* TBD -- Trust Path Used */
 } TID_RESP;
 struct tid_req {

diff --git a/include/trust_router/tid.h b/include/trust_router/tid.h
index bae236b..43057db 100644 (file)
--- a/include/trust_router/tid.h
+++ b/include/trust_router/tid.h
@@ -112,16 +112,18 @@ TR_EXPORT TR_NAME *tid_resp_get_comm(TID_RESP *resp);
 void tid_resp_set_comm(TID_RESP *resp, TR_NAME *comm);
 TR_EXPORT TR_NAME *tid_resp_get_orig_coi(TID_RESP *resp);
 void tid_resp_set_orig_coi(TID_RESP *resp, TR_NAME *orig_coi);
-TR_EXPORT TID_SRVR_BLK *tid_resp_get_servers(TID_RESP *resp);
-void tid_resp_set_servers(TID_RESP *resp, TID_SRVR_BLK *servers);
-
+TR_EXPORT TID_SRVR_BLK *tid_resp_get_server(TID_RESP *resp, size_t index);
+TR_EXPORT size_t tid_resp_get_num_servers(const TID_RESP *resp);
 /* Server blocks*/
 TR_EXPORT void tid_srvr_get_address(const TID_SRVR_BLK *,
 const struct sockaddr **out_addr);
 TR_EXPORT DH *tid_srvr_get_dh(TID_SRVR_BLK *);
 TR_EXPORT const TR_NAME *tid_srvr_get_key_name(const TID_SRVR_BLK *);
 
-
+#define tid_resp_servers_foreach(RESP, SERVER, INDEX) \
+  for (INDEX=0,SERVER=NULL;                                            \
+       ((INDEX < tid_resp_get_num_servers(RESP))&&(SERVER = tid_resp_get_server(resp, INDEX))); \
+       INDEX++)
 
 
 /* TID Client functions, in tid/tidc.c */

diff --git a/tid/tid_resp.c b/tid/tid_resp.c
index 46ded18..9ff06ba 100644 (file)
--- a/tid/tid_resp.c
+++ b/tid/tid_resp.c
@@ -34,6 +34,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <assert.h>
 
 #include <tid_internal.h>
 
@@ -97,12 +98,17 @@ void tid_resp_set_orig_coi(TID_RESP *resp, TR_NAME *orig_coi)
   resp->orig_coi = orig_coi;
 }
 
-TR_EXPORT TID_SRVR_BLK *tid_resp_get_servers(TID_RESP *resp)
+TR_EXPORT TID_SRVR_BLK *tid_resp_get_server(TID_RESP *resp,
+                                           size_t index)
 {
-  return(resp->servers);
+  assert(resp);
+  assert(index < resp->num_servers);
+  return(&(resp->servers[index]));
 }
 
-void tid_resp_set_servers(TID_RESP *resp, TID_SRVR_BLK *servers)
+size_t tid_resp_get_num_servers(const TID_RESP *resp)
 {
-  resp->servers = servers;
+  assert(resp);
+  return resp->num_servers;
 }
+

diff --git a/tid/tids.c b/tid/tids.c
index ac236f1..79a96ca 100644 (file)
--- a/tid/tids.c
+++ b/tid/tids.c
@@ -41,7 +41,7 @@
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <jansson.h>
-
+#include <talloc.h>
 #include <tid_internal.h>
 #include <gsscon.h>
 #include <tr_msg.h>
@@ -50,7 +50,7 @@ static TID_RESP *tids_create_response (TIDS_INSTANCE *tids, TID_REQ *req)
 {
   TID_RESP *resp;
 
-  if ((NULL == (resp = calloc(sizeof(TID_RESP), 1)))) {
+  if ((NULL == (resp = talloc_zero(req, TID_RESP)))) {
     fprintf(stderr, "tids_create_response: Error allocating response structure.\n");
     return NULL;
   }
@@ -84,7 +84,7 @@ static void tids_destroy_response(TIDS_INSTANCE *tids, TID_RESP *resp)
       tr_free_name(resp->comm);
     if (resp->orig_coi)
       tr_free_name(resp->orig_coi);
-    free (resp);
+    talloc_free(resp);
   }
 }