vpn_api.c

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2012, 2016 Christian Grothoff
 
     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_vpn_service.h"
#include "vpn.h"
 
 
struct GNUNET_VPN_Handle
{
  const struct GNUNET_CONFIGURATION_Handle *cfg;
 
  struct GNUNET_MQ_Handle *mq;
 
  struct GNUNET_VPN_RedirectionRequest *rr_head;
 
  struct GNUNET_VPN_RedirectionRequest *rr_tail;
 
  struct GNUNET_SCHEDULER_Task *rt;
 
  struct GNUNET_TIME_Relative backoff;
 
  uint64_t request_id_gen;
};
 
 
struct GNUNET_VPN_RedirectionRequest
{
  struct GNUNET_VPN_RedirectionRequest *next;
 
  struct GNUNET_VPN_RedirectionRequest *prev;
 
  struct GNUNET_VPN_Handle *vh;
 
  const void *addr;
 
  GNUNET_VPN_AllocationCallback cb;
 
  void *cb_cls;
 
  struct GNUNET_PeerIdentity peer;
 
  struct GNUNET_HashCode serv;
 
  struct GNUNET_TIME_Absolute expiration_time;
 
  uint64_t request_id;
 
  int result_af;
 
  int addr_af;
 
  uint8_t protocol;
};
 
 
static void
reconnect (struct GNUNET_VPN_Handle *vh);
 
 
static int
check_use_ip (void *cls,
              const struct RedirectToIpResponseMessage *rm)
{
  size_t alen;
  int af;
 
  af = (int) ntohl (rm->result_af);
  switch (af)
  {
  case AF_UNSPEC:
    alen = 0;
    break;
 
  case AF_INET:
    alen = sizeof(struct in_addr);
    break;
 
  case AF_INET6:
    alen = sizeof(struct in6_addr);
    break;
 
  default:
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if ((ntohs (rm->header.size) != alen + sizeof(*rm)) ||
      (0 == rm->request_id))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}
 
 
static void
handle_use_ip (void *cls,
               const struct RedirectToIpResponseMessage *rm)
{
  struct GNUNET_VPN_Handle *vh = cls;
  struct GNUNET_VPN_RedirectionRequest *rr;
  int af;
 
  af = (int) ntohl (rm->result_af);
  for (rr = vh->rr_head; NULL != rr; rr = rr->next)
  {
    if (rr->request_id == rm->request_id)
    {
      GNUNET_CONTAINER_DLL_remove (vh->rr_head,
                                   vh->rr_tail,
                                   rr);
      rr->cb (rr->cb_cls,
              af,
              (af == AF_UNSPEC) ? NULL : &rm[1]);
      GNUNET_free (rr);
      break;
    }
  }
}
 
 
static void
send_request (struct GNUNET_VPN_RedirectionRequest *rr)
{
  struct GNUNET_VPN_Handle *vh = rr->vh;
  struct RedirectToIpRequestMessage *rip;
  struct RedirectToServiceRequestMessage *rs;
  struct GNUNET_MQ_Envelope *env;
  size_t alen;
 
  if (NULL == vh->mq)
    return;
  if (NULL == rr->addr)
  {
    env = GNUNET_MQ_msg (rs,
                         GNUNET_MESSAGE_TYPE_VPN_CLIENT_REDIRECT_TO_SERVICE);
    rs->reserved = htonl (0);
    rs->expiration_time = GNUNET_TIME_absolute_hton (rr->expiration_time);
    rs->protocol = htonl (rr->protocol);
    rs->result_af = htonl (rr->result_af);
    rs->target = rr->peer;
    rs->service_descriptor = rr->serv;
    rs->request_id = rr->request_id = ++vh->request_id_gen;
  }
  else
  {
    switch (rr->addr_af)
    {
    case AF_INET:
      alen = sizeof(struct in_addr);
      break;
 
    case AF_INET6:
      alen = sizeof(struct in6_addr);
      break;
 
    default:
      GNUNET_assert (0);
      return;
    }
    env = GNUNET_MQ_msg_extra (rip,
                               alen,
                               GNUNET_MESSAGE_TYPE_VPN_CLIENT_REDIRECT_TO_IP);
    rip->reserved = htonl (0);
    rip->expiration_time = GNUNET_TIME_absolute_hton (rr->expiration_time);
    rip->result_af = htonl (rr->result_af);
    rip->addr_af = htonl (rr->addr_af);
    rip->request_id = rr->request_id = ++vh->request_id_gen;
    GNUNET_memcpy (&rip[1],
                   rr->addr,
                   alen);
  }
  GNUNET_MQ_send (vh->mq,
                  env);
}
 
 
static void
mq_error_handler (void *cls,
                  enum GNUNET_MQ_Error error)
{
  struct GNUNET_VPN_Handle *vh = cls;
 
  reconnect (vh);
}
 
 
static void
connect_task (void *cls)
{
  struct GNUNET_VPN_Handle *vh = cls;
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_var_size (use_ip,
                           GNUNET_MESSAGE_TYPE_VPN_CLIENT_USE_IP,
                           struct RedirectToIpResponseMessage,
                           cls),
    GNUNET_MQ_handler_end ()
  };
  struct GNUNET_VPN_RedirectionRequest *rr;
 
  vh->rt = NULL;
  vh->mq = GNUNET_CLIENT_connect (vh->cfg,
                                  "vpn",
                                  handlers,
                                  &mq_error_handler,
                                  vh);
  if (NULL == vh->mq)
    return;
  for (rr = vh->rr_head; NULL != rr; rr = rr->next)
    send_request (rr);
}
 
 
static void
reconnect (struct GNUNET_VPN_Handle *vh)
{
  struct GNUNET_VPN_RedirectionRequest *rr;
 
  GNUNET_MQ_destroy (vh->mq);
  vh->mq = NULL;
  vh->request_id_gen = 0;
  for (rr = vh->rr_head; NULL != rr; rr = rr->next)
    rr->request_id = 0;
  vh->backoff = GNUNET_TIME_relative_max (GNUNET_TIME_UNIT_MILLISECONDS,
                                          GNUNET_TIME_relative_min (
                                            GNUNET_TIME_relative_saturating_multiply (
                                              vh->backoff, 2),
                                            GNUNET_TIME_relative_multiply (
                                              GNUNET_TIME_UNIT_SECONDS, 30)));
  vh->rt = GNUNET_SCHEDULER_add_delayed (vh->backoff,
                                         &connect_task,
                                         vh);
}
 
 
void
GNUNET_VPN_cancel_request (struct GNUNET_VPN_RedirectionRequest *rr)
{
  struct GNUNET_VPN_Handle *vh;
 
  vh = rr->vh;
  GNUNET_CONTAINER_DLL_remove (vh->rr_head,
                               vh->rr_tail,
                               rr);
  GNUNET_free (rr);
}
 
 
struct GNUNET_VPN_RedirectionRequest *
GNUNET_VPN_redirect_to_peer (struct GNUNET_VPN_Handle *vh,
                             int result_af,
                             uint8_t protocol,
                             const struct GNUNET_PeerIdentity *peer,
                             const struct GNUNET_HashCode *serv,
                             struct GNUNET_TIME_Absolute expiration_time,
                             GNUNET_VPN_AllocationCallback cb,
                             void *cb_cls)
{
  struct GNUNET_VPN_RedirectionRequest *rr;
 
  rr = GNUNET_new (struct GNUNET_VPN_RedirectionRequest);
  rr->vh = vh;
  rr->cb = cb;
  rr->cb_cls = cb_cls;
  rr->peer = *peer;
  rr->serv = *serv;
  rr->expiration_time = expiration_time;
  rr->result_af = result_af;
  rr->protocol = protocol;
  GNUNET_CONTAINER_DLL_insert_tail (vh->rr_head,
                                    vh->rr_tail,
                                    rr);
  send_request (rr);
  return rr;
}
 
 
struct GNUNET_VPN_RedirectionRequest *
GNUNET_VPN_redirect_to_ip (struct GNUNET_VPN_Handle *vh,
                           int result_af,
                           int addr_af,
                           const void *addr,
                           struct GNUNET_TIME_Absolute expiration_time,
                           GNUNET_VPN_AllocationCallback cb,
                           void *cb_cls)
{
  struct GNUNET_VPN_RedirectionRequest *rr;
  size_t alen;
 
  switch (addr_af)
  {
  case AF_INET:
    alen = sizeof(struct in_addr);
    break;
 
  case AF_INET6:
    alen = sizeof(struct in6_addr);
    break;
 
  default:
    GNUNET_break (0);
    return NULL;
  }
  rr = GNUNET_malloc (sizeof(struct GNUNET_VPN_RedirectionRequest) + alen);
  rr->vh = vh;
  rr->addr = &rr[1];
  rr->cb = cb;
  rr->cb_cls = cb_cls;
  rr->expiration_time = expiration_time;
  rr->result_af = result_af;
  rr->addr_af = addr_af;
  GNUNET_memcpy (&rr[1],
                 addr,
                 alen);
  GNUNET_CONTAINER_DLL_insert_tail (vh->rr_head,
                                    vh->rr_tail,
                                    rr);
  send_request (rr);
  return rr;
}
 
 
struct GNUNET_VPN_Handle *
GNUNET_VPN_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
{
  struct GNUNET_VPN_Handle *vh
    = GNUNET_new (struct GNUNET_VPN_Handle);
 
  vh->cfg = cfg;
  connect_task (vh);
  if (NULL == vh->mq)
  {
    GNUNET_free (vh);
    return NULL;
  }
  return vh;
}
 
 
void
GNUNET_VPN_disconnect (struct GNUNET_VPN_Handle *vh)
{
  GNUNET_assert (NULL == vh->rr_head);
  if (NULL != vh->mq)
  {
    GNUNET_MQ_destroy (vh->mq);
    vh->mq = NULL;
  }
  if (NULL != vh->rt)
  {
    GNUNET_SCHEDULER_cancel (vh->rt);
    vh->rt = NULL;
  }
  GNUNET_free (vh);
}
 
 
/* end of vpn_api.c */