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