trp/trp_ptable.c

   1 /*
   2  * Copyright (c) 2016, JANET(UK)
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  *
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * 3. Neither the name of JANET(UK) nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  23  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  24  * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  25  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  26  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  27  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  29  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  31  * OF THE POSSIBILITY OF SUCH DAMAGE.
  32  *
  33  */
  34
  35 #include <time.h>
  36 #include <talloc.h>
  37
  38 #include <trust_router/tr_name.h>
  39 #include <trp_internal.h>
  40 #include <tr_gss.h>
  41 #include <trp_ptable.h>
  42 #include <tr_debug.h>
  43
  44 static int trp_peer_destructor(void *object)
  45 {
  46   TRP_PEER *peer=talloc_get_type_abort(object, TRP_PEER);
  47   if (peer->servicename!=NULL)
  48     tr_free_name(peer->servicename);
  49   return 0;
  50 }
  51 TRP_PEER *trp_peer_new(TALLOC_CTX *memctx)
  52 {
  53   TRP_PEER *peer=talloc(memctx, TRP_PEER);
  54   if (peer!=NULL) {
  55     peer->next=NULL;
  56     peer->server=NULL;
  57     peer->servicename=NULL;
  58     peer->gss_names=NULL;
  59     peer->port=0;
  60     peer->linkcost=TRP_LINKCOST_DEFAULT;
  61     peer->last_conn_attempt=(struct timespec){0,0};
  62     peer->outgoing_status=PEER_DISCONNECTED;
  63     peer->incoming_status=PEER_DISCONNECTED;
  64     peer->conn_status_cb=NULL;
  65     peer->conn_status_cookie=NULL;
  66     talloc_set_destructor((void *)peer, trp_peer_destructor);
  67   }
  68   return peer;
  69 }
  70
  71 void trp_peer_free(TRP_PEER *peer)
  72 {
  73   talloc_free(peer);
  74 }
  75
  76 static TRP_PEER *trp_peer_tail(TRP_PEER *peer)
  77 {
  78   while (peer->next!=NULL) {
  79     peer=peer->next;
  80   }
  81   return peer;
  82 }
  83
  84
  85 /* Get a name that identifies this peer for display to the user, etc.
  86  * Do not modify or free the label. */
  87 TR_NAME *trp_peer_get_label(TRP_PEER *peer)
  88 {
  89   TR_GSS_NAMES_ITER *iter=tr_gss_names_iter_new(NULL);
  90   TR_NAME *name=NULL;
  91
  92   /* for now, use the first gss name */
  93   if (iter!=NULL) {
  94     name=tr_gss_names_iter_first(iter, peer->gss_names);
  95     talloc_free(iter);
  96   }
  97   return name;
  98 }
  99
 100 /* Get a name that identifies this peer for display to the user, etc.
 101  * Makes a copy, caller is responsible for freeing.  */
 102 TR_NAME *trp_peer_dup_label(TRP_PEER *peer)
 103 {
 104   return tr_dup_name(trp_peer_get_label(peer));;
 105 }
 106
 107 char *trp_peer_get_server(TRP_PEER *peer)
 108 {
 109   return peer->server;
 110 }
 111
 112 static void trp_peer_set_servicename(TRP_PEER *peer, const char *server)
 113 {
 114   char *name=NULL;
 115   if (peer->servicename !=NULL)
 116     tr_free_name(peer->servicename);
 117
 118   if (server!=NULL)
 119     name=talloc_asprintf(NULL, "trustrouter/%s", server);
 120
 121   if (name!=NULL) {
 122     peer->servicename=tr_new_name(name);
 123     talloc_free(name);
 124   } else {
 125     peer->servicename=NULL;
 126   }
 127 }
 128
 129 /* copies input; on error, peer->servicename will be null */
 130 void trp_peer_set_server(TRP_PEER *peer, const char *server)
 131 {
 132   peer->server=talloc_strdup(peer, server); /* will be null on error */
 133   trp_peer_set_servicename(peer, server);
 134 }
 135
 136 void trp_peer_add_gss_name(TRP_PEER *peer, TR_NAME *gss_name)
 137 {
 138   if (peer->gss_names==NULL)
 139     trp_peer_set_gss_names(peer, tr_gss_names_new(peer));
 140   tr_gss_names_add(peer->gss_names, gss_name);
 141 }
 142
 143 void trp_peer_set_gss_names(TRP_PEER *peer, TR_GSS_NAMES *gss_names)
 144 {
 145   if (peer->gss_names!=NULL)
 146     talloc_free(peer->gss_names);
 147
 148   peer->gss_names=gss_names;
 149   talloc_steal(peer, gss_names);
 150 }
 151
 152 /* get the peer gss_names, caller must not free the result */
 153 TR_GSS_NAMES *trp_peer_get_gss_names(TRP_PEER *peer)
 154 {
 155   return peer->gss_names;
 156 }
 157
 158 /* get the service name (i.e., gssname we see when we connect to this peer) */
 159 TR_NAME *trp_peer_get_servicename(TRP_PEER *peer)
 160 {
 161   return peer->servicename;
 162 }
 163
 164 /* get a copy of the servicename, caller must free via tr_free_name */
 165 TR_NAME *trp_peer_dup_servicename(TRP_PEER *peer)
 166 {
 167   return tr_dup_name(peer->servicename);
 168 }
 169
 170 unsigned int trp_peer_get_port(TRP_PEER *peer)
 171 {
 172   return peer->port;
 173 }
 174
 175 void trp_peer_set_port(TRP_PEER *peer, unsigned int port)
 176 {
 177   peer->port=port;
 178 }
 179
 180 unsigned int trp_peer_get_linkcost(TRP_PEER *peer)
 181 {
 182   if (peer!=NULL)
 183     return peer->linkcost;
 184   else
 185     return 1;
 186 }
 187
 188 void trp_peer_set_linkcost(TRP_PEER *peer, unsigned int linkcost)
 189 {
 190   if ((linkcost>TRP_METRIC_INFINITY) && (linkcost!=TRP_METRIC_INVALID)) {
 191     /* This indicates a programming error, but probably means an already infinite metric
 192      * was (incorrectly) incremented. Issue a warning and proceed with an infinite metric. */
 193     tr_warning("trp_peer_set_linkcost: link cost > infinity encountered, setting to infinity");
 194     linkcost=TRP_METRIC_INFINITY;
 195   }
 196   peer->linkcost=linkcost;
 197 }
 198
 199 void trp_peer_set_conn_status_cb(TRP_PEER *peer, void (*cb)(TRP_PEER *, void *), void *cookie)
 200 {
 201   peer->conn_status_cb=cb;
 202   peer->conn_status_cookie=cookie;
 203 }
 204
 205 struct timespec *trp_peer_get_last_conn_attempt(TRP_PEER *peer)
 206 {
 207   return &(peer->last_conn_attempt);
 208 }
 209
 210 void trp_peer_set_last_conn_attempt(TRP_PEER *peer, struct timespec *time)
 211 {
 212   peer->last_conn_attempt=*time;
 213 }
 214
 215 TRP_PTABLE *trp_ptable_new(TALLOC_CTX *memctx)
 216 {
 217   TRP_PTABLE *ptbl=talloc(memctx, TRP_PTABLE);
 218   if (ptbl!=NULL) {
 219     ptbl->head=NULL;
 220   }
 221   return ptbl;
 222 }
 223
 224 void trp_peer_set_outgoing_status(TRP_PEER *peer, TRP_PEER_CONN_STATUS status)
 225 {
 226   TR_NAME *peer_label=trp_peer_get_label(peer);
 227   int was_connected=trp_peer_is_connected(peer);
 228   peer->outgoing_status=status;
 229   tr_debug("trp_peer_set_outgoing_status: %s: status=%d peer connected was %d now %d.",
 230            peer_label->buf, status, was_connected, trp_peer_is_connected(peer));
 231   if ((trp_peer_is_connected(peer) != was_connected) && (peer->conn_status_cb!=NULL))
 232     peer->conn_status_cb(peer, peer->conn_status_cookie);
 233 }
 234
 235 TRP_PEER_CONN_STATUS trp_peer_get_outgoing_status(TRP_PEER *peer)
 236 {
 237   return peer->outgoing_status;
 238 }
 239
 240 void trp_peer_set_incoming_status(TRP_PEER *peer, TRP_PEER_CONN_STATUS status)
 241 {
 242   TR_NAME *peer_label=trp_peer_get_label(peer);
 243   int was_connected=trp_peer_is_connected(peer);
 244   peer->incoming_status=status;
 245   tr_debug("trp_peer_set_incoming_status: %s: status=%d peer connected was %d now %d.",
 246            peer_label->buf, status, was_connected, trp_peer_is_connected(peer));
 247   if ((trp_peer_is_connected(peer) != was_connected) && (peer->conn_status_cb!=NULL))
 248     peer->conn_status_cb(peer, peer->conn_status_cookie);
 249 }
 250
 251 TRP_PEER_CONN_STATUS trp_peer_get_incoming_status(TRP_PEER *peer)
 252 {
 253   return peer->incoming_status;
 254 }
 255
 256 int trp_peer_is_connected(TRP_PEER *peer)
 257 {
 258   return (peer->outgoing_status==PEER_CONNECTED) && (peer->incoming_status==PEER_CONNECTED);
 259 }
 260
 261 void trp_ptable_free(TRP_PTABLE *ptbl)
 262 {
 263   talloc_free(ptbl);
 264 }
 265
 266 TRP_RC trp_ptable_add(TRP_PTABLE *ptbl, TRP_PEER *newpeer)
 267 {
 268   if (ptbl->head==NULL)
 269     ptbl->head=newpeer;
 270   else
 271     trp_peer_tail(ptbl->head)->next=newpeer;
 272
 273   talloc_steal(ptbl, newpeer);
 274   return TRP_SUCCESS;
 275 }
 276
 277 /* peer pointer is invalid after successful removal. Does nothing and returns
 278  * TRP_ERROR if peer is not in the list. */
 279 TRP_RC trp_ptable_remove(TRP_PTABLE *ptbl, TRP_PEER *peer)
 280 {
 281   TRP_PEER *cur=NULL;
 282   TRP_PEER *last=NULL;
 283   if (ptbl->head!=NULL) {
 284     if (ptbl->head==peer) {
 285       /* special case for removing head of list */
 286       cur=ptbl->head;
 287       ptbl->head=ptbl->head->next; /* advance the head */
 288       trp_peer_free(cur);
 289     }
 290     for (cur=ptbl->head->next; cur!=NULL; last=cur,cur=cur->next) {
 291       if (cur==peer) {
 292         if (last!=NULL)
 293           last->next=cur->next;
 294         trp_peer_free(cur);
 295         return TRP_SUCCESS;
 296       }
 297     }
 298   }
 299   return TRP_ERROR;
 300 }
 301
 302 TRP_PEER *trp_ptable_find_gss_name(TRP_PTABLE *ptbl, TR_NAME *gssname)
 303 {
 304   TRP_PEER *cur=ptbl->head;
 305   while ((cur!=NULL) && (!tr_gss_names_matches(trp_peer_get_gss_names(cur), gssname)))
 306     cur=cur->next;
 307   return cur;
 308 }
 309
 310 TRP_PEER *trp_ptable_find_servicename(TRP_PTABLE *ptbl, TR_NAME *servicename)
 311 {
 312   TRP_PEER *cur=ptbl->head;
 313   while ((cur!=NULL) && (0 != tr_name_cmp(trp_peer_get_servicename(cur), servicename)))
 314     cur=cur->next;
 315   return cur;
 316 }
 317
 318 char *trp_peer_to_str(TALLOC_CTX *memctx, TRP_PEER *peer, const char *sep)
 319 {
 320   if (sep==NULL)
 321     sep=", ";
 322   return talloc_asprintf(memctx,
 323                          "%s:%u%s0x%04X",
 324                          peer->server, peer->port, sep,
 325                          peer->linkcost);
 326 }
 327
 328 /* this is horribly inefficient but should be ok for small peer tables */
 329 char *trp_ptable_to_str(TALLOC_CTX *memctx, TRP_PTABLE *ptbl, const char *sep, const char *lineterm)
 330 {
 331   TALLOC_CTX *tmpctx=talloc_new(NULL);
 332   TRP_PEER *peer=NULL;
 333   char *result=talloc_strdup(tmpctx, "");
 334
 335   if (lineterm==NULL)
 336     lineterm="\n";
 337
 338   /* this leaves intermediate result strings in the tmpctx context, we'll free these when
 339    * we're done */
 340   for (peer=ptbl->head; peer!=NULL; peer=peer->next)
 341     result=talloc_asprintf(tmpctx, "%s%s%s", result, lineterm, trp_peer_to_str(tmpctx, peer, sep));
 342
 343   talloc_steal(memctx, result); /* hand result over to caller */
 344   talloc_free(tmpctx); /* free detritus */
 345   return result;
 346 }
 347
 348 TRP_PTABLE_ITER *trp_ptable_iter_new(TALLOC_CTX *mem_ctx)
 349 {
 350   TRP_PTABLE_ITER *iter=talloc(mem_ctx, TRP_PTABLE_ITER);
 351   *iter=NULL;
 352   return iter;
 353 }
 354
 355 TRP_PEER *trp_ptable_iter_first(TRP_PTABLE_ITER *iter, TRP_PTABLE *ptbl)
 356 {
 357   if (ptbl==NULL)
 358     *iter=NULL;
 359   else
 360     *iter=ptbl->head;
 361   return *iter;
 362 }
 363
 364 TRP_PEER *trp_ptable_iter_next(TRP_PTABLE_ITER *iter)
 365 {
 366   if (*iter!=NULL)
 367     *iter=(*iter)->next;
 368   return *iter;
 369 }
 370
 371 void trp_ptable_iter_free(TRP_PTABLE_ITER *iter)
 372 {
 373   talloc_free(iter);
 374 }
 375