transport_api_monitor.c

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2018 GNUnet e.V.
 
     GNUnet is free software: you can redistribute it and/or modify it
     under the terms of the GNU Affero General Public License as published
     by the Free Software Foundation, either version 3 of the License,
     or (at your option) any later version.
 
     GNUnet is distributed in the hope that it will be useful, but
     WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Affero General Public License for more details.
 
     You should have received a copy of the GNU Affero General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
     SPDX-License-Identifier: AGPL3.0-or-later
 */
 
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_transport_monitor_service.h"
#include "transport.h"
 
 
struct GNUNET_TRANSPORT_MonitorContext
{
  const struct GNUNET_CONFIGURATION_Handle *cfg;
 
  struct GNUNET_MQ_Handle *mq;
 
  struct GNUNET_PeerIdentity peer;
 
  int one_shot;
 
  GNUNET_TRANSPORT_MonitorCallback cb;
 
  void *cb_cls;
};
 
 
static void
reconnect (struct GNUNET_TRANSPORT_MonitorContext *mc);
 
 
static void
send_start_monitor (struct GNUNET_TRANSPORT_MonitorContext *mc)
{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_TRANSPORT_MonitorStart *smm;
 
  if (NULL == mc->mq)
    return;
  env = GNUNET_MQ_msg (smm, GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_START);
  smm->one_shot = htonl ((uint32_t) mc->one_shot);
  smm->peer = mc->peer;
  GNUNET_MQ_send (mc->mq, env);
}
 
 
static void
disconnect (struct GNUNET_TRANSPORT_MonitorContext *mc)
{
  if (NULL == mc->mq)
    return;
  GNUNET_MQ_destroy (mc->mq);
  mc->mq = NULL;
}
 
 
static void
error_handler (void *cls, enum GNUNET_MQ_Error error)
{
  struct GNUNET_TRANSPORT_MonitorContext *mc = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "MQ failure %d, reconnecting to transport service.\n",
              error);
  disconnect (mc);
  /* TODO: maybe do this with exponential backoff/delay */
  reconnect (mc);
}
 
 
static int
check_monitor_data (void *cls, const struct GNUNET_TRANSPORT_MonitorData *md)
{
  (void) cls;
  GNUNET_MQ_check_zero_termination (md);
  return GNUNET_OK;
}
 
 
static void
handle_monitor_data (void *cls, const struct GNUNET_TRANSPORT_MonitorData *md)
{
  struct GNUNET_TRANSPORT_MonitorContext *mc = cls;
  struct GNUNET_TRANSPORT_MonitorInformation mi;
 
  mi.address = (const char *) &md[1];
  mi.nt = ntohl (md->nt);
  mi.cs = ntohl (md->cs);
  mi.num_msg_pending = ntohl (md->num_msg_pending);
  mi.num_bytes_pending = ntohl (md->num_bytes_pending);
  mi.last_validation = GNUNET_TIME_absolute_ntoh (md->last_validation);
  mi.valid_until = GNUNET_TIME_absolute_ntoh (md->valid_until);
  mi.next_validation = GNUNET_TIME_absolute_ntoh (md->next_validation);
  mi.rtt = GNUNET_TIME_relative_ntoh (md->rtt);
  mc->cb (mc->cb_cls, &md->peer, &mi);
}
 
 
static void
handle_monitor_end (void *cls, const struct GNUNET_MessageHeader *me)
{
  struct GNUNET_TRANSPORT_MonitorContext *mc = cls;
 
  if (GNUNET_YES != mc->one_shot)
  {
    GNUNET_break (0);
    disconnect (mc);
    reconnect (mc);
    return;
  }
  mc->cb (mc->cb_cls, NULL, NULL);
  GNUNET_TRANSPORT_monitor_cancel (mc);
}
 
 
static void
reconnect (struct GNUNET_TRANSPORT_MonitorContext *mc)
{
  struct GNUNET_MQ_MessageHandler handlers[] =
  { GNUNET_MQ_hd_var_size (monitor_data,
                           GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_DATA,
                           struct GNUNET_TRANSPORT_MonitorData,
                           mc),
    GNUNET_MQ_hd_fixed_size (monitor_end,
                             GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_END,
                             struct GNUNET_MessageHeader,
                             mc),
    GNUNET_MQ_handler_end () };
 
  mc->mq =
    GNUNET_CLIENT_connect (mc->cfg, "transport", handlers, &error_handler, mc);
  if (NULL == mc->mq)
    return;
  send_start_monitor (mc);
}
 
 
struct GNUNET_TRANSPORT_MonitorContext *
GNUNET_TRANSPORT_monitor (const struct GNUNET_CONFIGURATION_Handle *cfg,
                          const struct GNUNET_PeerIdentity *peer,
                          int one_shot,
                          GNUNET_TRANSPORT_MonitorCallback cb,
                          void *cb_cls)
{
  struct GNUNET_TRANSPORT_MonitorContext *mc;
 
  mc = GNUNET_new (struct GNUNET_TRANSPORT_MonitorContext);
  mc->cfg = cfg;
  if (NULL != peer)
    mc->peer = *peer;
  mc->one_shot = one_shot;
  mc->cb = cb;
  mc->cb_cls = cb_cls;
  reconnect (mc);
  if (NULL == mc->mq)
  {
    GNUNET_free (mc);
    return NULL;
  }
  return mc;
}
 
 
void
GNUNET_TRANSPORT_monitor_cancel (struct GNUNET_TRANSPORT_MonitorContext *mc)
{
  disconnect (mc);
  GNUNET_free (mc);
}
 
 
/* ***************** listing virtual links ******************* */
 
 
struct GNUNET_TRANSPORT_LinkListContext
{
  struct GNUNET_MQ_Handle *mq;
 
  GNUNET_TRANSPORT_LinkCallback cb;
 
  void *cb_cls;
};
 
 
static void
link_list_done (struct GNUNET_TRANSPORT_LinkListContext *llc)
{
  GNUNET_TRANSPORT_LinkCallback cb = llc->cb;
  void *cb_cls = llc->cb_cls;
 
  GNUNET_TRANSPORT_links_list_cancel (llc);
  cb (cb_cls, NULL, NULL);
}
 
 
static void
link_list_error_handler (void *cls, enum GNUNET_MQ_Error error)
{
  struct GNUNET_TRANSPORT_LinkListContext *llc = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "Transport service disconnected while listing links (%d)\n",
              (int) error);
  link_list_done (llc);
}
 
 
static enum GNUNET_GenericReturnValue
check_link_list_response (
  void *cls,
  const struct GNUNET_TRANSPORT_LinkListResponse *resp)
{
  const char *ccs = (const char *) &resp[1];
  uint16_t slen = ntohs (resp->header.size) - sizeof (*resp);
 
  (void) cls;
  if ((0 == slen) || ('\0' != ccs[slen - 1]))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}
 
 
static void
handle_link_list_response (
  void *cls,
  const struct GNUNET_TRANSPORT_LinkListResponse *resp)
{
  struct GNUNET_TRANSPORT_LinkListContext *llc = cls;
  struct GNUNET_TRANSPORT_LinkInformation li;
 
  memset (&li, 0, sizeof (li));
  li.communicators = (const char *) &resp[1];
  li.route = (enum GNUNET_TRANSPORT_LinkRoute) ntohl (resp->route);
  li.confirmed = (int) ntohl (resp->confirmed);
  li.distance = ntohl (resp->distance);
  li.num_queues = ntohl (resp->num_queues);
  li.core_recv_window = (int) (int32_t) ntohl (resp->core_recv_window);
  li.stalled = ntohl (resp->stalled);
  li.pending = ntohl (resp->pending);
  li.fc_retransmit_count = ntohl (resp->fc_retransmit_count);
  li.available_fc_window_size = GNUNET_ntohll (resp->available_fc_window_size);
  li.incoming_fc_window_size_ram
    = GNUNET_ntohll (resp->incoming_fc_window_size_ram);
  li.incoming_fc_window_size = GNUNET_ntohll (resp->incoming_fc_window_size);
  li.incoming_fc_window_size_used
    = GNUNET_ntohll (resp->incoming_fc_window_size_used);
  li.incoming_fc_window_size_loss
    = (int64_t) GNUNET_ntohll ((uint64_t) resp->incoming_fc_window_size_loss);
  li.outbound_fc_window_size = GNUNET_ntohll (resp->outbound_fc_window_size);
  li.outbound_fc_window_size_used
    = GNUNET_ntohll (resp->outbound_fc_window_size_used);
  li.last_fc_rtt = GNUNET_TIME_relative_ntoh (resp->last_fc_rtt);
  li.other_rtt = GNUNET_TIME_relative_ntoh (resp->other_rtt);
  li.last_fc_transmission
    = GNUNET_TIME_absolute_ntoh (resp->last_fc_transmission);
  llc->cb (llc->cb_cls, &resp->target, &li);
}
 
 
static void
handle_link_list_response_end (void *cls,
                               const struct GNUNET_MessageHeader *msg)
{
  struct GNUNET_TRANSPORT_LinkListContext *llc = cls;
 
  (void) msg;
  link_list_done (llc);
}
 
 
struct GNUNET_TRANSPORT_LinkListContext *
GNUNET_TRANSPORT_links_list (const struct GNUNET_CONFIGURATION_Handle *cfg,
                             const struct GNUNET_PeerIdentity *peer,
                             int include_unconfirmed,
                             GNUNET_TRANSPORT_LinkCallback cb,
                             void *cb_cls)
{
  struct GNUNET_TRANSPORT_LinkListContext *llc
    = GNUNET_new (struct GNUNET_TRANSPORT_LinkListContext);
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_var_size (link_list_response,
                           GNUNET_MESSAGE_TYPE_TRANSPORT_LINK_LIST_RESPONSE,
                           struct GNUNET_TRANSPORT_LinkListResponse,
                           llc),
    GNUNET_MQ_hd_fixed_size (
      link_list_response_end,
      GNUNET_MESSAGE_TYPE_TRANSPORT_LINK_LIST_RESPONSE_END,
      struct GNUNET_MessageHeader,
      llc),
    GNUNET_MQ_handler_end ()
  };
  struct GNUNET_TRANSPORT_LinkListRequest *req;
  struct GNUNET_MQ_Envelope *env;
 
  llc->cb = cb;
  llc->cb_cls = cb_cls;
  llc->mq = GNUNET_CLIENT_connect (cfg,
                                   "transport",
                                   handlers,
                                   &link_list_error_handler,
                                   llc);
  if (NULL == llc->mq)
  {
    GNUNET_free (llc);
    return NULL;
  }
  env = GNUNET_MQ_msg (req,
                       GNUNET_MESSAGE_TYPE_TRANSPORT_LINK_LIST_REQUEST);
  req->include_unconfirmed = htonl ((uint32_t) include_unconfirmed);
  if (NULL != peer)
    req->peer = *peer;
  GNUNET_MQ_send (llc->mq, env);
  return llc;
}
 
 
void
GNUNET_TRANSPORT_links_list_cancel (
  struct GNUNET_TRANSPORT_LinkListContext *llc)
{
  if (NULL != llc->mq)
  {
    GNUNET_MQ_destroy (llc->mq);
    llc->mq = NULL;
  }
  GNUNET_free (llc);
}
 
 
/* end of transport_api2_monitor.c */