gns_tld_api.c

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2009-2013, 2016, 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_common.h"
#include "gnunet_util_lib.h"
#include "gnunet_constants.h"
#include "gnunet_arm_service.h"
#include "gnunet_identity_service.h"
#include "gnunet_protocols.h"
#include "gnunet_dht_service.h"
#include "gns.h"
#include "gns_api.h"
 
 
#define LOG(kind, ...) GNUNET_log_from (kind, "gns-tld-api", __VA_ARGS__)
 
 
struct GNUNET_GNS_LookupWithTldRequest
{
  struct GNUNET_GNS_Handle *gns_handle;
 
  GNUNET_GNS_LookupResultProcessor2 lookup_proc;
 
  char *name;
 
  void *lookup_proc_cls;
 
  struct GNUNET_GNS_LookupRequest *lr;
 
  struct GNUNET_IDENTITY_EgoSuffixLookup *id_co;
 
  char *longest_match;
 
  struct GNUNET_IDENTITY_Ego *longest_match_ego;
 
  uint32_t type;
 
  enum GNUNET_GNS_LocalOptions options;
};
 
 
static const char *
get_tld (const char *name)
{
  const char *tld;
 
  tld = strrchr (name, (unsigned char) '.');
  if (NULL == tld)
    tld = name;
  else
    tld++; /* skip the '.' */
  return tld;
}
 
 
static void
eat_tld (char *name, const char *tld)
{
  GNUNET_assert (0 < strlen (name));
  if ((NULL == tld) || (strlen (name) == strlen (tld)))
  {
    strcpy (name, GNUNET_GNS_EMPTY_LABEL_AT);
  }
  else
  {
    GNUNET_assert (strlen (tld) < strlen (name));
    name[strlen (name) - strlen (tld) - 1] = '\0';
  }
}
 
 
static void
process_lookup_result (void *cls,
                       uint32_t rd_count,
                       const struct GNUNET_GNSRECORD_Data *rd)
{
  struct GNUNET_GNS_LookupWithTldRequest *ltr = cls;
 
  ltr->lr = NULL;
  ltr->lookup_proc (ltr->lookup_proc_cls, GNUNET_YES, rd_count, rd);
  GNUNET_GNS_lookup_with_tld_cancel (ltr);
}
 
 
static void
lookup_with_public_key (struct GNUNET_GNS_LookupWithTldRequest *ltr,
                        const struct GNUNET_CRYPTO_PublicKey *pkey)
{
  ltr->lr = GNUNET_GNS_lookup (ltr->gns_handle,
                               ltr->name,
                               pkey,
                               ltr->type,
                               ltr->options,
                               &process_lookup_result,
                               ltr);
}
 
 
static void
identity_zone_cb (void *cls,
                  const struct GNUNET_CRYPTO_PrivateKey *priv,
                  const char *ego_name)
{
  struct GNUNET_GNS_LookupWithTldRequest *ltr = cls;
  struct GNUNET_CRYPTO_PublicKey pkey;
 
  ltr->id_co = NULL;
  if (NULL == priv)
  {
    /* no matching ego found */
    ltr->lookup_proc (ltr->lookup_proc_cls, GNUNET_NO, 0, NULL);
    return;
  }
  /* Final case: TLD matches one of our egos */
  if (0 == strcmp (ltr->name, ego_name))
  {
    /* name matches ego name perfectly, only "@" remains */
    strcpy (ltr->name, GNUNET_GNS_EMPTY_LABEL_AT);
  }
  else
  {
    GNUNET_assert (strlen (ego_name) < strlen (ltr->name));
    ltr->name[strlen (ltr->name) - strlen (ego_name) - 1] = '\0';
  }
  /* if the name is of the form 'label' (and not 'label.SUBDOMAIN'), never go to the DHT */
  if (NULL == strchr (ltr->name, (unsigned char) '.'))
    ltr->options = GNUNET_GNS_LO_NO_DHT;
  else
    ltr->options = GNUNET_GNS_LO_LOCAL_MASTER;
  GNUNET_CRYPTO_key_get_public (priv, &pkey);
  lookup_with_public_key (ltr, &pkey);
}
 
 
enum GNUNET_GenericReturnValue
GNUNET_GNS_parse_ztld (const char *name,
                       struct GNUNET_CRYPTO_PublicKey *ztld_key)
{
  const char *tld;
 
  /* start with trivial case: TLD is zkey */
  tld = get_tld (name);
  return GNUNET_CRYPTO_public_key_from_string (tld, ztld_key);
}
 
 
struct GNUNET_GNS_LookupWithTldRequest *
GNUNET_GNS_lookup_with_tld (struct GNUNET_GNS_Handle *handle,
                            const char *name,
                            uint32_t type,
                            enum GNUNET_GNS_LocalOptions options,
                            GNUNET_GNS_LookupResultProcessor2 proc,
                            void *proc_cls)
{
  struct GNUNET_GNS_LookupWithTldRequest *ltr;
  const char *tld;
  char *dot_tld;
  char *zonestr;
  struct GNUNET_CRYPTO_PublicKey pkey;
 
  ltr = GNUNET_new (struct GNUNET_GNS_LookupWithTldRequest);
  ltr->gns_handle = handle;
  ltr->name = GNUNET_strdup (name);
  ltr->type = type;
  ltr->options = options;
  ltr->lookup_proc = proc;
  ltr->lookup_proc_cls = proc_cls;
  /* start with trivial case: TLD is zkey */
  if (GNUNET_OK ==
      GNUNET_GNS_parse_ztld (ltr->name, &pkey))
  {
    tld = get_tld (ltr->name);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "`%s' seems to be a valid zone key\n", tld);
    eat_tld (ltr->name, tld);
    lookup_with_public_key (ltr, &pkey);
    return ltr;
  }
 
  /* second case: domain is mapped in our configuration file */
  for (const char *domain = name; NULL != domain;
       domain = strchr (domain, (unsigned char) '.'))
  {
    if ('.' == domain[0])
      domain++;
    GNUNET_asprintf (&dot_tld, ".%s", domain);
    if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (handle->cfg,
                                                            "gns",
                                                            dot_tld,
                                                            &zonestr))
    {
      if (GNUNET_OK !=
          GNUNET_CRYPTO_public_key_from_string (zonestr,
                                                &pkey))
      {
        GNUNET_log_config_invalid (
          GNUNET_ERROR_TYPE_ERROR,
          "gns",
          dot_tld,
          _ ("Expected a base32-encoded public zone key\n"));
        GNUNET_free (zonestr);
        GNUNET_free (dot_tld);
        GNUNET_free (ltr->name);
        GNUNET_free (ltr);
        return NULL;
      }
      eat_tld (ltr->name, &dot_tld[1]);
      GNUNET_free (zonestr);
      GNUNET_free (dot_tld);
      lookup_with_public_key (ltr, &pkey);
      return ltr;
    }
    GNUNET_free (dot_tld);
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "`%s' should be a valid ego\n", ltr->name);
  ltr->id_co =
    GNUNET_IDENTITY_ego_lookup_by_suffix (ltr->gns_handle->cfg,
                                          ltr->name,
                                          &identity_zone_cb,
                                          ltr);
  if (NULL == ltr->id_co)
  {
    GNUNET_free (ltr->name);
    GNUNET_free (ltr);
    return NULL;
  }
  return ltr;
}
 
 
void *
GNUNET_GNS_lookup_with_tld_cancel (struct GNUNET_GNS_LookupWithTldRequest *ltr)
{
  void *ret = ltr->lookup_proc_cls;
 
  if (NULL != ltr->id_co)
  {
    GNUNET_IDENTITY_ego_lookup_by_suffix_cancel (ltr->id_co);
    ltr->id_co = NULL;
  }
  if (NULL != ltr->lr)
  {
    GNUNET_GNS_lookup_cancel (ltr->lr);
    ltr->lr = NULL;
  }
  GNUNET_free (ltr->longest_match);
  GNUNET_free (ltr->name);
  GNUNET_free (ltr);
  return ret;
}
 
 
/* end of gns_tld_api.c */