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->label!=NULL)
  48     tr_free_name(peer->label);
  49   if (peer->servicename!=NULL)
  50     tr_free_name(peer->servicename);
  51   return 0;
  52 }
  53 TRP_PEER *trp_peer_new(TALLOC_CTX *memctx)
  54 {
  55   TRP_PEER *peer=talloc(memctx, TRP_PEER);
  56   if (peer!=NULL) {
  57     peer->next=NULL;
  58     peer->label=NULL;
  59     peer->server=NULL;
  60     peer->servicename=NULL;
  61     peer->gss_names=NULL;
  62     peer->port=0;
  63     peer->linkcost=TRP_LINKCOST_DEFAULT;
  64     peer->last_conn_attempt=(struct timespec){0,0};
  65     peer->outgoing_status=PEER_DISCONNECTED;
  66     peer->incoming_status=PEER_DISCONNECTED;
  67     peer->conn_status_cb=NULL;
  68     peer->conn_status_cookie=NULL;
  69     talloc_set_destructor((void *)peer, trp_peer_destructor);
  70   }
  71   return peer;
  72 }
  73
  74 void trp_peer_free(TRP_PEER *peer)
  75 {
  76   talloc_free(peer);
  77 }
  78
  79 static TRP_PEER *trp_peer_tail(TRP_PEER *peer)
  80 {
  81   while (peer->next!=NULL) {
  82     peer=peer->next;
  83   }
  84   return peer;
  85 }
  86
  87
  88 /* Get a name that identifies this peer for display to the user, etc.
  89  * Do not modify or free the label. */
  90 TR_NAME *trp_peer_get_label(TRP_PEER *peer)
  91 {
  92   char *s=NULL;
  93
  94   if (peer->label==NULL) {
  95     s=talloc_asprintf(NULL, "%s:%u", peer->server, peer->port);
  96     if (s!=NULL) {
  97       peer->label=tr_new_name(s);
  98       talloc_free(s);
  99     }
 100   }
 101   return peer->label;
 102 }
 103
 104 /* Get a name that identifies this peer for display to the user, etc.
 105  * Makes a copy, caller is responsible for freeing.  */
 106 TR_NAME *trp_peer_dup_label(TRP_PEER *peer)
 107 {
 108   return tr_dup_name(trp_peer_get_label(peer));;
 109 }
 110
 111 char *trp_peer_get_server(TRP_PEER *peer)
 112 {
 113   return peer->server;
 114 }
 115
 116 static void trp_peer_set_servicename(TRP_PEER *peer, const char *server)
 117 {
 118   char *name=NULL;
 119   if (peer->servicename !=NULL)
 120     tr_free_name(peer->servicename);
 121
 122   if (server!=NULL)
 123     name=talloc_asprintf(NULL, "trustrouter/%s", server);
 124
 125   if (name!=NULL) {
 126     peer->servicename=tr_new_name(name);
 127     talloc_free(name);
 128   } else {
 129     peer->servicename=NULL;
 130   }
 131 }
 132
 133 /* copies input; on error, peer->servicename will be null */
 134 void trp_peer_set_server(TRP_PEER *peer, const char *server)
 135 {
 136   peer->server=talloc_strdup(peer, server); /* will be null on error */
 137   trp_peer_set_servicename(peer, server);
 138 }
 139
 140 void trp_peer_add_gss_name(TRP_PEER *peer, TR_NAME *gss_name)
 141 {
 142   if (peer->gss_names==NULL)
 143     trp_peer_set_gss_names(peer, tr_gss_names_new(peer));
 144   tr_gss_names_add(peer->gss_names, gss_name);
 145 }
 146
 147 void trp_peer_set_gss_names(TRP_PEER *peer, TR_GSS_NAMES *gss_names)
 148 {
 149   if (peer->gss_names!=NULL)
 150     talloc_free(peer->gss_names);
 151
 152   peer->gss_names=gss_names;
 153   talloc_steal(peer, gss_names);
 154 }
 155
 156 /* get the peer gss_names, caller must not free the result */
 157 TR_GSS_NAMES *trp_peer_get_gss_names(TRP_PEER *peer)
 158 {
 159   return peer->gss_names;
 160 }
 161
 162 /* get the service name (i.e., gssname we see when we connect to this peer) */
 163 TR_NAME *trp_peer_get_servicename(TRP_PEER *peer)
 164 {
 165   return peer->servicename;
 166 }
 167
 168 /* get a copy of the servicename, caller must free via tr_free_name */
 169 TR_NAME *trp_peer_dup_servicename(TRP_PEER *peer)
 170 {
 171   return tr_dup_name(peer->servicename);
 172 }
 173
 174 unsigned int trp_peer_get_port(TRP_PEER *peer)
 175 {
 176   return peer->port;
 177 }
 178
 179 void trp_peer_set_port(TRP_PEER *peer, unsigned int port)
 180 {
 181   peer->port=port;
 182 }
 183
 184 unsigned int trp_peer_get_linkcost(TRP_PEER *peer)
 185 {
 186   if (peer!=NULL)
 187     return peer->linkcost;
 188   else
 189     return 1;
 190 }
 191
 192 void trp_peer_set_linkcost(TRP_PEER *peer, unsigned int linkcost)
 193 {
 194   if ((linkcost>TRP_METRIC_INFINITY) && (linkcost!=TRP_METRIC_INVALID)) {
 195     /* This indicates a programming error, but probably means an already infinite metric
 196      * was (incorrectly) incremented. Issue a warning and proceed with an infinite metric. */
 197     tr_warning("trp_peer_set_linkcost: link cost > infinity encountered, setting to infinity");
 198     linkcost=TRP_METRIC_INFINITY;
 199   }
 200   peer->linkcost=linkcost;
 201 }
 202
 203 void trp_peer_set_conn_status_cb(TRP_PEER *peer, void (*cb)(TRP_PEER *, void *), void *cookie)
 204 {
 205   peer->conn_status_cb=cb;
 206   peer->conn_status_cookie=cookie;
 207 }
 208
 209 struct timespec *trp_peer_get_last_conn_attempt(TRP_PEER *peer)
 210 {
 211   return &(peer->last_conn_attempt);
 212 }
 213
 214 void trp_peer_set_last_conn_attempt(TRP_PEER *peer, struct timespec *time)
 215 {
 216   peer->last_conn_attempt=*time;
 217 }
 218
 219 TRP_PTABLE *trp_ptable_new(TALLOC_CTX *memctx)
 220 {
 221   TRP_PTABLE *ptbl=talloc(memctx, TRP_PTABLE);
 222   if (ptbl!=NULL) {
 223     ptbl->head=NULL;
 224   }
 225   return ptbl;
 226 }
 227
 228 void trp_peer_set_outgoing_status(TRP_PEER *peer, TRP_PEER_CONN_STATUS status)
 229 {
 230   TR_NAME *peer_label=trp_peer_get_label(peer);
 231   int was_connected=trp_peer_is_connected(peer);
 232   peer->outgoing_status=status;
 233   tr_debug("trp_peer_set_outgoing_status: %s: status=%d peer connected was %d now %d.",
 234            peer_label->buf, status, was_connected, trp_peer_is_connected(peer));
 235   if ((trp_peer_is_connected(peer) != was_connected) && (peer->conn_status_cb!=NULL))
 236     peer->conn_status_cb(peer, peer->conn_status_cookie);
 237 }
 238
 239 TRP_PEER_CONN_STATUS trp_peer_get_outgoing_status(TRP_PEER *peer)
 240 {
 241   return peer->outgoing_status;
 242 }
 243
 244 void trp_peer_set_incoming_status(TRP_PEER *peer, TRP_PEER_CONN_STATUS status)
 245 {
 246   TR_NAME *peer_label=trp_peer_get_label(peer);
 247   int was_connected=trp_peer_is_connected(peer);
 248   peer->incoming_status=status;
 249   tr_debug("trp_peer_set_incoming_status: %s: status=%d peer connected was %d now %d.",
 250            peer_label->buf, status, was_connected, trp_peer_is_connected(peer));
 251   if ((trp_peer_is_connected(peer) != was_connected) && (peer->conn_status_cb!=NULL))
 252     peer->conn_status_cb(peer, peer->conn_status_cookie);
 253 }
 254
 255 TRP_PEER_CONN_STATUS trp_peer_get_incoming_status(TRP_PEER *peer)
 256 {
 257   return peer->incoming_status;
 258 }
 259
 260 int trp_peer_is_connected(TRP_PEER *peer)
 261 {
 262   return (peer->outgoing_status==PEER_CONNECTED) && (peer->incoming_status==PEER_CONNECTED);
 263 }
 264
 265 void trp_ptable_free(TRP_PTABLE *ptbl)
 266 {
 267   talloc_free(ptbl);
 268 }
 269
 270 TRP_RC trp_ptable_add(TRP_PTABLE *ptbl, TRP_PEER *newpeer)
 271 {
 272   if (ptbl->head==NULL)
 273     ptbl->head=newpeer;
 274   else
 275     trp_peer_tail(ptbl->head)->next=newpeer;
 276
 277   talloc_steal(ptbl, newpeer);
 278   return TRP_SUCCESS;
 279 }
 280
 281 /* peer pointer is invalid after successful removal. Does nothing and returns
 282  * TRP_ERROR if peer is not in the list. */
 283 TRP_RC trp_ptable_remove(TRP_PTABLE *ptbl, TRP_PEER *peer)
 284 {
 285   TRP_PEER *cur=NULL;
 286   TRP_PEER *last=NULL;
 287   if (ptbl->head!=NULL) {
 288     if (ptbl->head==peer) {
 289       /* special case for removing head of list */
 290       cur=ptbl->head;
 291       ptbl->head=ptbl->head->next; /* advance the head */
 292       trp_peer_free(cur);
 293     }
 294     for (cur=ptbl->head->next; cur!=NULL; last=cur,cur=cur->next) {
 295       if (cur==peer) {
 296         if (last!=NULL)
 297           last->next=cur->next;
 298         trp_peer_free(cur);
 299         return TRP_SUCCESS;
 300       }
 301     }
 302   }
 303   return TRP_ERROR;
 304 }
 305
 306 TRP_PEER *trp_ptable_find_gss_name(TRP_PTABLE *ptbl, TR_NAME *gssname)
 307 {
 308   TRP_PEER *cur=ptbl->head;
 309   while ((cur!=NULL) && (!tr_gss_names_matches(trp_peer_get_gss_names(cur), gssname)))
 310     cur=cur->next;
 311   return cur;
 312 }
 313
 314 TRP_PEER *trp_ptable_find_servicename(TRP_PTABLE *ptbl, TR_NAME *servicename)
 315 {
 316   TRP_PEER *cur=ptbl->head;
 317   while ((cur!=NULL) && (0 != tr_name_cmp(trp_peer_get_servicename(cur), servicename)))
 318     cur=cur->next;
 319   return cur;
 320 }
 321
 322 char *trp_peer_to_str(TALLOC_CTX *memctx, TRP_PEER *peer, const char *sep)
 323 {
 324   if (sep==NULL)
 325     sep=", ";
 326   return talloc_asprintf(memctx,
 327                          "%s:%u%s0x%04X",
 328                          peer->server, peer->port, sep,
 329                          peer->linkcost);
 330 }
 331
 332 /* this is horribly inefficient but should be ok for small peer tables */
 333 char *trp_ptable_to_str(TALLOC_CTX *memctx, TRP_PTABLE *ptbl, const char *sep, const char *lineterm)
 334 {
 335   TALLOC_CTX *tmpctx=talloc_new(NULL);
 336   TRP_PEER *peer=NULL;
 337   char *result=talloc_strdup(tmpctx, "");
 338
 339   if (lineterm==NULL)
 340     lineterm="\n";
 341
 342   /* this leaves intermediate result strings in the tmpctx context, we'll free these when
 343    * we're done */
 344   for (peer=ptbl->head; peer!=NULL; peer=peer->next)
 345     result=talloc_asprintf(tmpctx, "%s%s%s", result, lineterm, trp_peer_to_str(tmpctx, peer, sep));
 346
 347   talloc_steal(memctx, result); /* hand result over to caller */
 348   talloc_free(tmpctx); /* free detritus */
 349   return result;
 350 }
 351
 352 TRP_PTABLE_ITER *trp_ptable_iter_new(TALLOC_CTX *mem_ctx)
 353 {
 354   TRP_PTABLE_ITER *iter=talloc(mem_ctx, TRP_PTABLE_ITER);
 355   *iter=NULL;
 356   return iter;
 357 }
 358
 359 TRP_PEER *trp_ptable_iter_first(TRP_PTABLE_ITER *iter, TRP_PTABLE *ptbl)
 360 {
 361   if (ptbl==NULL)
 362     *iter=NULL;
 363   else
 364     *iter=ptbl->head;
 365   return *iter;
 366 }
 367
 368 TRP_PEER *trp_ptable_iter_next(TRP_PTABLE_ITER *iter)
 369 {
 370   if (*iter!=NULL)
 371     *iter=(*iter)->next;
 372   return *iter;
 373 }
 374
 375 void trp_ptable_iter_free(TRP_PTABLE_ITER *iter)
 376 {
 377   talloc_free(iter);
 378 }
 379