src/transport/transport_api_monitoring.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009, 2010 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file transport/transport_api_monitoring.c
  23  * @brief montoring api for transport peer status and validation entries
  24  *
  25  * This api provides the ability to query the transport service about
  26  * the status of a specific or all peers as well as address validation entries.
  27  *
  28  * Calls back with information about peer(s) including address used, state and
  29  * state timeout for peer requests and address, address lifetime and next revalidation
  30  * for validation entries.
  31  */
  32 #include "platform.h"
  33 #include "gnunet_util_lib.h"
  34 #include "gnunet_arm_service.h"
  35 #include "gnunet_hello_lib.h"
  36 #include "gnunet_protocols.h"
  37 #include "gnunet_transport_service.h"
  38 #include "transport.h"
  39
  40 /**
  41  * Context for iterating validation entries.
  42  */
  43 struct GNUNET_TRANSPORT_PeerMonitoringContext
  44 {
  45   /**
  46    * Function to call with the binary address.
  47    */
  48   GNUNET_TRANSPORT_PeerIterateCallback cb;
  49
  50   /**
  51    * Closure for cb.
  52    */
  53   void *cb_cls;
  54
  55   /**
  56    * Connection to the service.
  57    */
  58   struct GNUNET_CLIENT_Connection *client;
  59
  60   /**
  61    * Configuration we use.
  62    */
  63   const struct GNUNET_CONFIGURATION_Handle *cfg;
  64
  65   /**
  66    * When should this operation time out?
  67    */
  68   struct GNUNET_TIME_Absolute timeout;
  69
  70   /**
  71    * Backoff for reconnect.
  72    */
  73   struct GNUNET_TIME_Relative backoff;
  74
  75   /**
  76    * Task ID for reconnect.
  77    */
  78   GNUNET_SCHEDULER_TaskIdentifier reconnect_task;
  79
  80   /**
  81    * Identity of the peer to monitor.
  82    */
  83   struct GNUNET_PeerIdentity peer;
  84
  85   /**
  86    * Was this a one-shot request?
  87    */
  88   int one_shot;
  89 };
  90
  91
  92 /**
  93  * Context for the address lookup.
  94  */
  95 struct GNUNET_TRANSPORT_ValidationMonitoringContext
  96 {
  97   /**
  98    * Function to call with the binary address.
  99    */
 100   GNUNET_TRANSPORT_ValidationIterateCallback cb;
 101
 102   /**
 103    * Closure for cb.
 104    */
 105   void *cb_cls;
 106
 107   /**
 108    * Connection to the service.
 109    */
 110   struct GNUNET_CLIENT_Connection *client;
 111
 112   /**
 113    * Configuration we use.
 114    */
 115   const struct GNUNET_CONFIGURATION_Handle *cfg;
 116
 117   /**
 118    * When should this operation time out?
 119    */
 120   struct GNUNET_TIME_Absolute timeout;
 121
 122   /**
 123    * Backoff for reconnect.
 124    */
 125   struct GNUNET_TIME_Relative backoff;
 126
 127   /**
 128    * Task ID for reconnect.
 129    */
 130   GNUNET_SCHEDULER_TaskIdentifier reconnect_task;
 131
 132   /**
 133    * Identity of the peer to monitor.
 134    */
 135   struct GNUNET_PeerIdentity peer;
 136
 137   /**
 138    * Was this a one-shot request?
 139    */
 140   int one_shot;
 141 };
 142
 143 /**
 144  * Check if a state is defined as connected
 145  *
 146  * @param state the state value
 147  * @return GNUNET_YES or GNUNET_NO
 148  */
 149 int
 150 GNUNET_TRANSPORT_is_connected (enum GNUNET_TRANSPORT_PeerState state)
 151 {
 152   switch (state)
 153   {
 154   case GNUNET_TRANSPORT_PS_NOT_CONNECTED:
 155   case GNUNET_TRANSPORT_PS_INIT_ATS:
 156   case GNUNET_TRANSPORT_PS_CONNECT_SENT:
 157   case GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS:
 158   case GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK:
 159     return GNUNET_NO;
 160   case GNUNET_TRANSPORT_PS_CONNECTED:
 161   case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
 162   case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
 163   case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT:
 164     return GNUNET_YES;
 165   case GNUNET_TRANSPORT_PS_DISCONNECT:
 166   case GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED:
 167     return GNUNET_NO;
 168   default:
 169     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 170                 "Unhandled state `%s' \n",
 171                 GNUNET_TRANSPORT_ps2s (state));
 172     GNUNET_break (0);
 173     break;
 174   }
 175   return GNUNET_SYSERR;
 176 }
 177
 178 /**
 179  * Convert peer state to human-readable string.
 180  *
 181  * @param state the state value
 182  * @return corresponding string
 183  */
 184 const char *
 185 GNUNET_TRANSPORT_ps2s (enum GNUNET_TRANSPORT_PeerState state)
 186 {
 187   switch (state)
 188   {
 189   case GNUNET_TRANSPORT_PS_NOT_CONNECTED:
 190     return "S_NOT_CONNECTED";
 191   case GNUNET_TRANSPORT_PS_INIT_ATS:
 192     return "S_INIT_ATS";
 193   case GNUNET_TRANSPORT_PS_CONNECT_SENT:
 194     return "S_CONNECT_SENT";
 195   case GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS:
 196     return "S_CONNECT_RECV_ATS";
 197   case GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK:
 198     return "S_CONNECT_RECV_ACK";
 199   case GNUNET_TRANSPORT_PS_CONNECTED:
 200     return "S_CONNECTED";
 201   case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
 202     return "S_RECONNECT_ATS";
 203   case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
 204     return "S_RECONNECT_SENT";
 205   case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT:
 206     return "S_CONNECTED_SWITCHING_CONNECT_SENT";
 207   case GNUNET_TRANSPORT_PS_DISCONNECT:
 208     return "S_DISCONNECT";
 209   case GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED:
 210     return "S_DISCONNECT_FINISHED";
 211   default:
 212     GNUNET_break (0);
 213     return "UNDEFINED";
 214   }
 215 }
 216
 217 /**
 218  * Convert validation state to human-readable string.
 219  *
 220  * @param state the state value
 221  * @return corresponding string
 222  */
 223 const char *
 224 GNUNET_TRANSPORT_vs2s (enum GNUNET_TRANSPORT_ValidationState state)
 225 {
 226   switch (state)
 227   {
 228   case GNUNET_TRANSPORT_VS_NONE:
 229     return "NONE";
 230   case GNUNET_TRANSPORT_VS_NEW:
 231     return "NEW";
 232   case GNUNET_TRANSPORT_VS_REMOVE:
 233     return "REMOVE";
 234   case GNUNET_TRANSPORT_VS_TIMEOUT:
 235     return "TIMEOUT";
 236   case GNUNET_TRANSPORT_VS_UPDATE:
 237     return "UPDATE";
 238   default:
 239     GNUNET_break (0);
 240     return "UNDEFINED";
 241   }
 242 }
 243
 244
 245 /**
 246  * Function called with responses from the service.
 247  *
 248  * @param cls our 'struct GNUNET_TRANSPORT_PeerAddressLookupContext*'
 249  * @param msg NULL on timeout or error, otherwise presumably a
 250  *        message with the human-readable address
 251  */
 252 static void
 253 peer_response_processor (void *cls, const struct GNUNET_MessageHeader *msg);
 254
 255
 256 /**
 257  * Function called with responses from the service.
 258  *
 259  * @param cls our 'struct GNUNET_TRANSPORT_PeerAddressLookupContext*'
 260  * @param msg NULL on timeout or error, otherwise presumably a
 261  *        message with the human-readable address
 262  */
 263 static void
 264 val_response_processor (void *cls, const struct GNUNET_MessageHeader *msg);
 265
 266 /**
 267  * Send our subscription request to the service.
 268  *
 269  * @param pal_ctx our context
 270  */
 271 static void
 272 send_peer_mon_request (struct GNUNET_TRANSPORT_PeerMonitoringContext *pal_ctx)
 273 {
 274   struct PeerMonitorMessage msg;
 275
 276   msg.header.size = htons (sizeof (struct PeerMonitorMessage));
 277   msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_REQUEST);
 278   msg.one_shot = htonl (pal_ctx->one_shot);
 279   msg.peer = pal_ctx->peer;
 280   GNUNET_assert (GNUNET_OK ==
 281                  GNUNET_CLIENT_transmit_and_get_response (pal_ctx->client,
 282                     &msg.header,
 283                     GNUNET_TIME_absolute_get_remaining (pal_ctx->timeout),
 284                     GNUNET_YES,
 285                     &peer_response_processor,
 286                     pal_ctx));
 287 }
 288
 289 /**
 290  * Send our subscription request to the service.
 291  *
 292  * @param val_ctx our context
 293  */
 294 static void
 295 send_val_mon_request (struct GNUNET_TRANSPORT_ValidationMonitoringContext *val_ctx)
 296 {
 297   struct ValidationMonitorMessage msg;
 298
 299   msg.header.size = htons (sizeof (struct ValidationMonitorMessage));
 300   msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_VALIDATION_REQUEST);
 301   msg.one_shot = htonl (val_ctx->one_shot);
 302   msg.peer = val_ctx->peer;
 303   GNUNET_assert (GNUNET_OK ==
 304                  GNUNET_CLIENT_transmit_and_get_response (val_ctx->client,
 305                     &msg.header,
 306                     GNUNET_TIME_absolute_get_remaining (val_ctx->timeout),
 307                     GNUNET_YES,
 308                     &val_response_processor,
 309                     val_ctx));
 310 }
 311
 312 /**
 313  * Task run to re-establish the connection.
 314  *
 315  * @param cls our 'struct GNUNET_TRANSPORT_PeerAddressLookupContext*'
 316  * @param tc scheduler context, unused
 317  */
 318 static void
 319 do_peer_connect (void *cls,
 320            const struct GNUNET_SCHEDULER_TaskContext *tc)
 321 {
 322   struct GNUNET_TRANSPORT_PeerMonitoringContext *pal_ctx = cls;
 323
 324   pal_ctx->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
 325   pal_ctx->client = GNUNET_CLIENT_connect ("transport", pal_ctx->cfg);
 326   GNUNET_assert (NULL != pal_ctx->client);
 327   send_peer_mon_request (pal_ctx);
 328 }
 329
 330
 331 /**
 332  * Cut the existing connection and reconnect.
 333  *
 334  * @param pal_ctx our context
 335  */
 336 static void
 337 reconnect_peer_ctx (struct GNUNET_TRANSPORT_PeerMonitoringContext *pal_ctx)
 338 {
 339   GNUNET_assert (GNUNET_NO == pal_ctx->one_shot);
 340   GNUNET_CLIENT_disconnect (pal_ctx->client);
 341   pal_ctx->client = NULL;
 342   pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL,
 343                GNUNET_TRANSPORT_PS_NOT_CONNECTED,
 344                GNUNET_TIME_UNIT_ZERO_ABS);
 345   pal_ctx->backoff = GNUNET_TIME_STD_BACKOFF (pal_ctx->backoff);
 346   pal_ctx->reconnect_task = GNUNET_SCHEDULER_add_delayed (pal_ctx->backoff,
 347                                                           &do_peer_connect,
 348                                                           pal_ctx);
 349 }
 350
 351
 352 /**
 353  * Task run to re-establish the connection.
 354  *
 355  * @param cls our 'struct GNUNET_TRANSPORT_PeerAddressLookupContext*'
 356  * @param tc scheduler context, unused
 357  */
 358 static void
 359 do_val_connect (void *cls,
 360            const struct GNUNET_SCHEDULER_TaskContext *tc)
 361 {
 362   struct GNUNET_TRANSPORT_ValidationMonitoringContext *val_ctx = cls;
 363
 364   val_ctx->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
 365   val_ctx->client = GNUNET_CLIENT_connect ("transport", val_ctx->cfg);
 366   GNUNET_assert (NULL != val_ctx->client);
 367   send_val_mon_request (val_ctx);
 368 }
 369
 370 /**
 371  * Cut the existing connection and reconnect.
 372  *
 373  * @param val_ctx our context
 374  */
 375 static void
 376 reconnect_val_ctx (struct GNUNET_TRANSPORT_ValidationMonitoringContext *val_ctx)
 377 {
 378   GNUNET_assert (GNUNET_NO == val_ctx->one_shot);
 379   GNUNET_CLIENT_disconnect (val_ctx->client);
 380   val_ctx->client = NULL;
 381   /* notify clients about (re)connect */
 382   val_ctx->cb (val_ctx->cb_cls, NULL, NULL,
 383                GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TIME_UNIT_ZERO_ABS,
 384                GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TRANSPORT_VS_TIMEOUT);
 385   val_ctx->backoff = GNUNET_TIME_STD_BACKOFF (val_ctx->backoff);
 386   val_ctx->reconnect_task = GNUNET_SCHEDULER_add_delayed (val_ctx->backoff,
 387                                                           &do_val_connect,
 388                                                           val_ctx);
 389 }
 390
 391 /**
 392  * Function called with responses from the service.
 393  *
 394  * @param cls our `struct GNUNET_TRANSPORT_PeerMonitoringContext *`
 395  * @param msg NULL on timeout or error, otherwise presumably a
 396  *        message with the human-readable address
 397  */
 398 static void
 399 val_response_processor (void *cls, const struct GNUNET_MessageHeader *msg)
 400 {
 401   struct GNUNET_TRANSPORT_ValidationMonitoringContext *val_ctx = cls;
 402   struct ValidationIterateResponseMessage *vr_msg;
 403   struct GNUNET_HELLO_Address *address;
 404   const char *addr;
 405   const char *transport_name;
 406   size_t size;
 407   size_t tlen;
 408   size_t alen;
 409
 410   if (NULL == msg)
 411   {
 412     if (val_ctx->one_shot)
 413     {
 414       /* Disconnect */
 415       val_ctx->cb (val_ctx->cb_cls, NULL, NULL,
 416           GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TIME_UNIT_ZERO_ABS,
 417           GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TRANSPORT_VS_TIMEOUT);
 418       GNUNET_TRANSPORT_monitor_validation_entries_cancel (val_ctx);
 419     }
 420     else
 421     {
 422       reconnect_val_ctx (val_ctx);
 423     }
 424     return;
 425   }
 426   size = ntohs (msg->size);
 427   GNUNET_break (ntohs (msg->type) ==
 428       GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_VALIDATION_RESPONSE);
 429
 430   if (size == sizeof (struct GNUNET_MessageHeader))
 431   {
 432     /* Done! */
 433     if (val_ctx->one_shot)
 434     {
 435       val_ctx->cb (val_ctx->cb_cls, NULL, NULL,
 436           GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TIME_UNIT_ZERO_ABS,
 437           GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TRANSPORT_VS_NONE);
 438       GNUNET_TRANSPORT_monitor_validation_entries_cancel (val_ctx);
 439     }
 440     else
 441     {
 442       reconnect_val_ctx (val_ctx);
 443     }
 444     return;
 445   }
 446
 447   if ((size < sizeof (struct ValidationIterateResponseMessage)) ||
 448       (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_VALIDATION_RESPONSE))
 449   {
 450     GNUNET_break (0);
 451     if (val_ctx->one_shot)
 452     {
 453       val_ctx->cb (val_ctx->cb_cls, NULL, NULL,
 454           GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TIME_UNIT_ZERO_ABS,
 455           GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TRANSPORT_VS_NONE);
 456       GNUNET_TRANSPORT_monitor_validation_entries_cancel (val_ctx);
 457     }
 458     else
 459     {
 460       reconnect_val_ctx (val_ctx);
 461     }
 462     return;
 463   }
 464
 465   vr_msg = (struct ValidationIterateResponseMessage *) msg;
 466   tlen = ntohl (vr_msg->pluginlen);
 467   alen = ntohl (vr_msg->addrlen);
 468
 469   if (size != sizeof (struct ValidationIterateResponseMessage) + tlen + alen)
 470   {
 471     GNUNET_break (0);
 472     if (val_ctx->one_shot)
 473     {
 474       val_ctx->cb (val_ctx->cb_cls, NULL, NULL,
 475           GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TIME_UNIT_ZERO_ABS,
 476           GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TRANSPORT_VS_NONE);
 477       GNUNET_TRANSPORT_monitor_validation_entries_cancel (val_ctx);
 478     }
 479     else
 480     {
 481       reconnect_val_ctx (val_ctx);
 482     }
 483     return;
 484   }
 485   if ( (0 == tlen) && (0 == alen) )
 486   {
 487     GNUNET_break (0);
 488     if (val_ctx->one_shot)
 489     {
 490       val_ctx->cb (val_ctx->cb_cls, NULL, NULL,
 491           GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TIME_UNIT_ZERO_ABS,
 492           GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TRANSPORT_VS_NONE);
 493       GNUNET_TRANSPORT_monitor_validation_entries_cancel (val_ctx);
 494     }
 495     else
 496     {
 497       reconnect_val_ctx (val_ctx);
 498     }
 499     return;
 500   }
 501   else
 502   {
 503     if (0 == tlen)
 504     {
 505       GNUNET_break (0); /* This must not happen: address without plugin */
 506       return;
 507     }
 508     addr = (const char *) &vr_msg[1];
 509     transport_name = &addr[alen];
 510
 511     if (transport_name[tlen - 1] != '\0')
 512     {
 513       /* Corrupt plugin name */
 514       GNUNET_break (0);
 515       if (val_ctx->one_shot)
 516       {
 517         val_ctx->cb (val_ctx->cb_cls, NULL, NULL,
 518             GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TIME_UNIT_ZERO_ABS,
 519             GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TRANSPORT_VS_NONE);
 520         GNUNET_TRANSPORT_monitor_validation_entries_cancel (val_ctx);
 521       }
 522       else
 523       {
 524         reconnect_val_ctx (val_ctx);
 525       }
 526       return;
 527     }
 528
 529     /* notify client */
 530     address = GNUNET_HELLO_address_allocate (&vr_msg->peer,
 531         transport_name, addr, alen, ntohl(vr_msg->local_address_info));
 532     val_ctx->cb (val_ctx->cb_cls, &vr_msg->peer, address,
 533         GNUNET_TIME_absolute_ntoh(vr_msg->last_validation),
 534         GNUNET_TIME_absolute_ntoh(vr_msg->valid_until),
 535         GNUNET_TIME_absolute_ntoh(vr_msg->next_validation),
 536         ntohl(vr_msg->state));
 537     GNUNET_HELLO_address_free (address);
 538   }
 539   /* expect more replies */
 540   GNUNET_CLIENT_receive (val_ctx->client,
 541                          &val_response_processor,
 542                          val_ctx,
 543                          GNUNET_TIME_absolute_get_remaining (val_ctx->timeout));
 544 }
 545
 546
 547 /**
 548  * Function called with responses from the service.
 549  *
 550  * @param cls our `struct GNUNET_TRANSPORT_PeerMonitoringContext *`
 551  * @param msg NULL on timeout or error, otherwise presumably a
 552  *        message with the human-readable address
 553  */
 554 static void
 555 peer_response_processor (void *cls,
 556                          const struct GNUNET_MessageHeader *msg)
 557 {
 558   struct GNUNET_TRANSPORT_PeerMonitoringContext *pal_ctx = cls;
 559   struct PeerIterateResponseMessage *pir_msg;
 560   struct GNUNET_HELLO_Address *address;
 561   const char *addr;
 562   const char *transport_name;
 563   uint16_t size;
 564   size_t alen;
 565   size_t tlen;
 566
 567   if (NULL == msg)
 568   {
 569     if (pal_ctx->one_shot)
 570     {
 571       /* Disconnect */
 572       pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL,
 573           GNUNET_TRANSPORT_PS_NOT_CONNECTED, GNUNET_TIME_UNIT_ZERO_ABS);
 574       GNUNET_TRANSPORT_monitor_peers_cancel (pal_ctx);
 575     }
 576     else
 577     {
 578       reconnect_peer_ctx (pal_ctx);
 579     }
 580     return;
 581   }
 582   size = ntohs (msg->size);
 583   GNUNET_break (ntohs (msg->type) ==
 584       GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE);
 585   if (size == sizeof (struct GNUNET_MessageHeader))
 586   {
 587     /* Done! */
 588     if (pal_ctx->one_shot)
 589     {
 590       /* iteration finished */
 591       pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL,
 592           GNUNET_TRANSPORT_PS_NOT_CONNECTED, GNUNET_TIME_UNIT_ZERO_ABS);
 593       GNUNET_TRANSPORT_monitor_peers_cancel (pal_ctx);
 594     }
 595     else
 596     {
 597       reconnect_peer_ctx (pal_ctx);
 598     }
 599     return;
 600   }
 601
 602   if ((size < sizeof (struct PeerIterateResponseMessage)) ||
 603       (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE))
 604   {
 605     GNUNET_break (0);
 606     if (pal_ctx->one_shot)
 607     {
 608       /* iteration finished (with error) */
 609       pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL,
 610           GNUNET_TRANSPORT_PS_NOT_CONNECTED, GNUNET_TIME_UNIT_ZERO_ABS);
 611       GNUNET_TRANSPORT_monitor_peers_cancel (pal_ctx);
 612     }
 613     else
 614     {
 615       reconnect_peer_ctx (pal_ctx);
 616     }
 617     return;
 618   }
 619
 620   pir_msg = (struct PeerIterateResponseMessage *) msg;
 621   tlen = ntohl (pir_msg->pluginlen);
 622   alen = ntohl (pir_msg->addrlen);
 623
 624   if (size != sizeof (struct PeerIterateResponseMessage) + tlen + alen)
 625   {
 626     GNUNET_break (0);
 627     if (pal_ctx->one_shot)
 628     {
 629       pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL,
 630           GNUNET_TRANSPORT_PS_NOT_CONNECTED, GNUNET_TIME_UNIT_ZERO_ABS);
 631       GNUNET_TRANSPORT_monitor_peers_cancel (pal_ctx);
 632     }
 633     else
 634     {
 635       reconnect_peer_ctx (pal_ctx);
 636     }
 637     return;
 638   }
 639
 640   if ( (0 == tlen) && (0 == alen) )
 641   {
 642     /* No address available */
 643     pal_ctx->cb (pal_ctx->cb_cls, &pir_msg->peer, NULL,
 644         ntohl(pir_msg->state),
 645         GNUNET_TIME_absolute_ntoh (pir_msg->state_timeout));
 646   }
 647   else
 648   {
 649     if (0 == tlen)
 650     {
 651       GNUNET_break (0); /* This must not happen: address without plugin */
 652       return;
 653     }
 654     addr = (const char *) &pir_msg[1];
 655     transport_name = &addr[alen];
 656
 657     if (transport_name[tlen - 1] != '\0')
 658     {
 659       /* Corrupt plugin name */
 660       GNUNET_break (0);
 661       if (pal_ctx->one_shot)
 662       {
 663         pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL,
 664             GNUNET_TRANSPORT_PS_NOT_CONNECTED, GNUNET_TIME_UNIT_ZERO_ABS);
 665         GNUNET_TRANSPORT_monitor_peers_cancel (pal_ctx);
 666       }
 667       else
 668       {
 669         reconnect_peer_ctx (pal_ctx);
 670       }
 671       return;
 672     }
 673
 674     /* notify client */
 675     address = GNUNET_HELLO_address_allocate (&pir_msg->peer,
 676         transport_name, addr, alen, ntohl(pir_msg->local_address_info));
 677     pal_ctx->cb (pal_ctx->cb_cls, &pir_msg->peer, address,
 678         ntohl(pir_msg->state),
 679         GNUNET_TIME_absolute_ntoh (pir_msg->state_timeout));
 680     GNUNET_HELLO_address_free (address);
 681
 682   }
 683
 684   /* expect more replies */
 685   GNUNET_CLIENT_receive (pal_ctx->client, &peer_response_processor,
 686                          pal_ctx,
 687                          GNUNET_TIME_absolute_get_remaining (pal_ctx->timeout));
 688 }
 689
 690
 691 /**
 692  * Return information about a specific peer or all peers currently known to
 693  * transport service once or in monitoring mode. To obtain information about
 694  * a specific peer, a peer identity can be passed. To obtain information about
 695  * all peers currently known to transport service, NULL can be passed as peer
 696  * identity.
 697  *
 698  * For each peer, the callback is called with information about the address used
 699  * to communicate with this peer, the state this peer is currently in and the
 700  * the current timeout for this state.
 701  *
 702  * Upon completion, the 'GNUNET_TRANSPORT_PeerIterateCallback' is called one
 703  * more time with 'NULL'. After this, the operation must no longer be
 704  * explicitly canceled.
 705  *
 706  * The #GNUNET_TRANSPORT_monitor_peers_cancel call MUST not be called in the
 707  * the peer_callback!
 708  *
 709  * @param cfg configuration to use
 710  * @param peer a specific peer identity to obtain information for,
 711  *      NULL for all peers
 712  * @param one_shot #GNUNET_YES to return the current state and then end (with NULL+NULL),
 713  *                 #GNUNET_NO to monitor peers continuously
 714  * @param timeout how long is the lookup allowed to take at most
 715  * @param peer_callback function to call with the results
 716  * @param peer_callback_cls closure for @a peer_address_callback
 717  */
 718 struct GNUNET_TRANSPORT_PeerMonitoringContext *
 719 GNUNET_TRANSPORT_monitor_peers (const struct GNUNET_CONFIGURATION_Handle *cfg,
 720                                 const struct GNUNET_PeerIdentity *peer,
 721                                 int one_shot,
 722                                 struct GNUNET_TIME_Relative timeout,
 723                                 GNUNET_TRANSPORT_PeerIterateCallback peer_callback,
 724                                 void *peer_callback_cls)
 725 {
 726   struct GNUNET_TRANSPORT_PeerMonitoringContext *pal_ctx;
 727   struct GNUNET_CLIENT_Connection *client;
 728
 729   client = GNUNET_CLIENT_connect ("transport", cfg);
 730   if (client == NULL)
 731     return NULL;
 732   if (GNUNET_YES != one_shot)
 733     timeout = GNUNET_TIME_UNIT_FOREVER_REL;
 734   pal_ctx = GNUNET_new (struct GNUNET_TRANSPORT_PeerMonitoringContext);
 735   pal_ctx->cb = peer_callback;
 736   pal_ctx->cb_cls = peer_callback_cls;
 737   pal_ctx->cfg = cfg;
 738   pal_ctx->timeout = GNUNET_TIME_relative_to_absolute (timeout);
 739   if (NULL != peer)
 740     pal_ctx->peer = *peer;
 741   pal_ctx->one_shot = one_shot;
 742   pal_ctx->client = client;
 743   send_peer_mon_request (pal_ctx);
 744
 745   return pal_ctx;
 746 }
 747
 748
 749 /**
 750  * Cancel request to monitor peers
 751  *
 752  * @param pic handle for the request to cancel
 753  */
 754 void
 755 GNUNET_TRANSPORT_monitor_peers_cancel (struct GNUNET_TRANSPORT_PeerMonitoringContext *pic)
 756 {
 757   if (NULL != pic->client)
 758   {
 759     GNUNET_CLIENT_disconnect (pic->client);
 760     pic->client = NULL;
 761   }
 762   if (GNUNET_SCHEDULER_NO_TASK != pic->reconnect_task)
 763   {
 764     GNUNET_SCHEDULER_cancel (pic->reconnect_task);
 765     pic->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
 766   }
 767   GNUNET_free (pic);
 768 }
 769
 770
 771 /**
 772  * Return information about pending address validation operations for a specific
 773  * or all peers
 774  *
 775  * @param cfg configuration to use
 776  * @param peer a specific peer identity to obtain validation entries for,
 777  *      NULL for all peers
 778  * @param one_shot GNUNET_YES to return all entries and then end (with NULL+NULL),
 779  *                 GNUNET_NO to monitor validation entries continuously
 780  * @param timeout how long is the lookup allowed to take at most
 781  * @param validation_callback function to call with the results
 782  * @param validation_callback_cls closure for peer_address_callback
 783  */
 784 struct GNUNET_TRANSPORT_ValidationMonitoringContext *
 785 GNUNET_TRANSPORT_monitor_validation_entries (const struct
 786                                 GNUNET_CONFIGURATION_Handle *cfg,
 787                                 const struct GNUNET_PeerIdentity *peer,
 788                                 int one_shot,
 789                                 struct GNUNET_TIME_Relative timeout,
 790                                 GNUNET_TRANSPORT_ValidationIterateCallback validation_callback,
 791                                 void *validation_callback_cls)
 792 {
 793   struct GNUNET_TRANSPORT_ValidationMonitoringContext *val_ctx;
 794   struct GNUNET_CLIENT_Connection *client;
 795
 796   client = GNUNET_CLIENT_connect ("transport", cfg);
 797   if (client == NULL)
 798     return NULL;
 799   if (GNUNET_YES != one_shot)
 800     timeout = GNUNET_TIME_UNIT_FOREVER_REL;
 801   val_ctx = GNUNET_new (struct GNUNET_TRANSPORT_ValidationMonitoringContext);
 802   val_ctx->cb = validation_callback;
 803   val_ctx->cb_cls = validation_callback_cls;
 804   val_ctx->cfg = cfg;
 805   val_ctx->timeout = GNUNET_TIME_relative_to_absolute (timeout);
 806   if (NULL != peer)
 807     val_ctx->peer = *peer;
 808   val_ctx->one_shot = one_shot;
 809   val_ctx->client = client;
 810   send_val_mon_request (val_ctx);
 811
 812   return val_ctx;
 813 }
 814
 815
 816 /**
 817  * Return information about all current pending validation operations
 818  *
 819  * @param vic handle for the request to cancel
 820  */
 821 void
 822 GNUNET_TRANSPORT_monitor_validation_entries_cancel (struct GNUNET_TRANSPORT_ValidationMonitoringContext *vic)
 823 {
 824   if (NULL != vic->client)
 825   {
 826     GNUNET_CLIENT_disconnect (vic->client);
 827     vic->client = NULL;
 828   }
 829   if (GNUNET_SCHEDULER_NO_TASK != vic->reconnect_task)
 830   {
 831     GNUNET_SCHEDULER_cancel (vic->reconnect_task);
 832     vic->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
 833   }
 834   GNUNET_free (vic);
 835 }
 836
 837
 838 /* end of transport_api_monitoring.c */