src/gnsrecord/gnsrecord_misc.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009-2013 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 gnsrecord/gnsrecord_misc.c
  23  * @brief MISC functions related to GNS records
  24  * @author Martin Schanzenbach
  25  * @author Matthias Wachs
  26  * @author Christian Grothoff
  27  */
  28 #include "platform.h"
  29 #include "gnunet_util_lib.h"
  30 #include "gnunet_constants.h"
  31 #include "gnunet_signatures.h"
  32 #include "gnunet_arm_service.h"
  33 #include "gnunet_gnsrecord_lib.h"
  34 #include "gnunet_dnsparser_lib.h"
  35 #include "gnunet_tun_lib.h"
  36
  37
  38 #define LOG(kind,...) GNUNET_log_from (kind, "gnsrecord",__VA_ARGS__)
  39
  40 /**
  41  * Convert a UTF-8 string to UTF-8 lowercase
  42  * @param src source string
  43  * @return converted result
  44  */
  45 char *
  46 GNUNET_GNSRECORD_string_to_lowercase (const char *src)
  47 {
  48   char *res;
  49
  50   res = GNUNET_strdup (src);
  51   GNUNET_STRINGS_utf8_tolower (src, res);
  52   return res;
  53 }
  54
  55
  56 /**
  57  * Convert a zone key to a string (for printing debug messages).
  58  * This is one of the very few calls in the entire API that is
  59  * NOT reentrant!
  60  *
  61  * @param z the zone key
  62  * @return string form; will be overwritten by next call to #GNUNET_GNSRECORD_z2s
  63  */
  64 const char *
  65 GNUNET_GNSRECORD_z2s (const struct GNUNET_CRYPTO_EcdsaPublicKey *z)
  66 {
  67   static char buf[sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey) * 8];
  68   char *end;
  69
  70   end = GNUNET_STRINGS_data_to_string ((const unsigned char *) z,
  71                                        sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey),
  72                                        buf, sizeof (buf));
  73   if (NULL == end)
  74   {
  75     GNUNET_break (0);
  76     return NULL;
  77   }
  78   *end = '\0';
  79   return buf;
  80 }
  81
  82
  83 /**
  84  * Compares if two records are equal (ignoring flags such
  85  * as authority, private and pending, but not relative vs.
  86  * absolute expiration time).
  87  *
  88  * @param a record
  89  * @param b record
  90  * @return #GNUNET_YES if the records are equal or #GNUNET_NO if they are not
  91  */
  92 int
  93 GNUNET_GNSRECORD_records_cmp (const struct GNUNET_GNSRECORD_Data *a,
  94                               const struct GNUNET_GNSRECORD_Data *b)
  95 {
  96   LOG (GNUNET_ERROR_TYPE_DEBUG,
  97        "Comparing records\n");
  98   if (a->record_type != b->record_type)
  99   {
 100     LOG (GNUNET_ERROR_TYPE_DEBUG,
 101          "Record type %lu != %lu\n", a->record_type, b->record_type);
 102     return GNUNET_NO;
 103   }
 104   if ((a->expiration_time != b->expiration_time) &&
 105       ((a->expiration_time != 0) && (b->expiration_time != 0)))
 106   {
 107     LOG (GNUNET_ERROR_TYPE_DEBUG,
 108          "Expiration time %llu != %llu\n",
 109          a->expiration_time,
 110          b->expiration_time);
 111     return GNUNET_NO;
 112   }
 113   if ((a->flags & GNUNET_GNSRECORD_RF_RCMP_FLAGS)
 114        != (b->flags & GNUNET_GNSRECORD_RF_RCMP_FLAGS))
 115   {
 116     LOG (GNUNET_ERROR_TYPE_DEBUG,
 117          "Flags %lu (%lu) != %lu (%lu)\n", a->flags,
 118          a->flags & GNUNET_GNSRECORD_RF_RCMP_FLAGS, b->flags,
 119          b->flags & GNUNET_GNSRECORD_RF_RCMP_FLAGS);
 120     return GNUNET_NO;
 121   }
 122   if (a->data_size != b->data_size)
 123   {
 124     LOG (GNUNET_ERROR_TYPE_DEBUG,
 125          "Data size %lu != %lu\n",
 126          a->data_size,
 127          b->data_size);
 128     return GNUNET_NO;
 129   }
 130   if (0 != memcmp (a->data, b->data, a->data_size))
 131   {
 132     LOG (GNUNET_ERROR_TYPE_DEBUG,
 133          "Data contents do not match\n");
 134     return GNUNET_NO;
 135   }
 136   LOG (GNUNET_ERROR_TYPE_DEBUG,
 137        "Records are equal\n");
 138   return GNUNET_YES;
 139 }
 140
 141
 142 /**
 143  * Returns the expiration time of the given block of records. The block
 144  * expiration time is the expiration time of the record with smallest
 145  * expiration time.
 146  *
 147  * @param rd_count number of records given in @a rd
 148  * @param rd array of records
 149  * @return absolute expiration time
 150  */
 151 struct GNUNET_TIME_Absolute
 152 GNUNET_GNSRECORD_record_get_expiration_time (unsigned int rd_count,
 153                                              const struct GNUNET_GNSRECORD_Data *rd)
 154 {
 155   unsigned int c;
 156   unsigned int c2;
 157   struct GNUNET_TIME_Absolute expire;
 158   struct GNUNET_TIME_Absolute at;
 159   struct GNUNET_TIME_Relative rt;
 160   struct GNUNET_TIME_Absolute at_shadow;
 161   struct GNUNET_TIME_Relative rt_shadow;
 162
 163   if (NULL == rd)
 164     return GNUNET_TIME_UNIT_ZERO_ABS;
 165   expire = GNUNET_TIME_UNIT_FOREVER_ABS;
 166   for (c = 0; c < rd_count; c++)
 167   {
 168     if (0 != (rd[c].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
 169     {
 170       rt.rel_value_us = rd[c].expiration_time;
 171       at = GNUNET_TIME_relative_to_absolute (rt);
 172     }
 173     else
 174     {
 175       at.abs_value_us = rd[c].expiration_time;
 176     }
 177
 178     for (c2 = 0; c2 < rd_count; c2++)
 179     {
 180       /* Check for shadow record */
 181       if ((c == c2) ||
 182           (rd[c].record_type != rd[c2].record_type) ||
 183           (0 == (rd[c2].flags & GNUNET_GNSRECORD_RF_SHADOW_RECORD)))
 184           continue;
 185       /* We have a shadow record */
 186       if (0 != (rd[c2].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
 187       {
 188         rt_shadow.rel_value_us = rd[2].expiration_time;
 189         at_shadow = GNUNET_TIME_relative_to_absolute (rt_shadow);
 190       }
 191       else
 192       {
 193         at_shadow.abs_value_us = rd[c2].expiration_time;
 194       }
 195       at = GNUNET_TIME_absolute_max (at, at_shadow);
 196     }
 197     expire = GNUNET_TIME_absolute_min (at, expire);
 198   }
 199   LOG (GNUNET_ERROR_TYPE_DEBUG,
 200        "Determined expiration time for block with %u records to be %s\n",
 201        rd_count,
 202        GNUNET_STRINGS_absolute_time_to_string (expire));
 203   return expire;
 204 }
 205
 206
 207 /**
 208  * Test if a given record is expired.
 209  *
 210  * @return #GNUNET_YES if the record is expired,
 211  *         #GNUNET_NO if not
 212  */
 213 int
 214 GNUNET_GNSRECORD_is_expired (const struct GNUNET_GNSRECORD_Data *rd)
 215 {
 216   struct GNUNET_TIME_Absolute at;
 217
 218   if (0 != (rd->flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
 219     return GNUNET_NO;
 220   at.abs_value_us = rd->expiration_time;
 221   return (0 == GNUNET_TIME_absolute_get_remaining (at).rel_value_us) ? GNUNET_YES : GNUNET_NO;
 222 }
 223
 224
 225 /**
 226  * Convert public key to the respective absolute domain name in the
 227  * ".zkey" pTLD.
 228  * This is one of the very few calls in the entire API that is
 229  * NOT reentrant!
 230  *
 231  * @param pkey a public key with a point on the eliptic curve
 232  * @return string "X.zkey" where X is the public
 233  *         key in an encoding suitable for DNS labels.
 234  */
 235 const char *
 236 GNUNET_GNSRECORD_pkey_to_zkey (const struct GNUNET_CRYPTO_EcdsaPublicKey *pkey)
 237 {
 238   static char ret[128];
 239   char *pkeys;
 240
 241   pkeys = GNUNET_CRYPTO_ecdsa_public_key_to_string (pkey);
 242   GNUNET_snprintf (ret,
 243                    sizeof (ret),
 244                    "%s.zkey",
 245                    pkeys);
 246   GNUNET_free (pkeys);
 247   return ret;
 248 }
 249
 250
 251 /**
 252  * Convert an absolute domain name in the ".zkey" pTLD to the
 253  * respective public key.
 254  *
 255  * @param zkey string "X.zkey" where X is the coordinates of the public
 256  *         key in an encoding suitable for DNS labels.
 257  * @param pkey set to a public key on the eliptic curve
 258  * @return #GNUNET_SYSERR if @a zkey has the wrong syntax
 259  */
 260 int
 261 GNUNET_GNSRECORD_zkey_to_pkey (const char *zkey,
 262                                struct GNUNET_CRYPTO_EcdsaPublicKey *pkey)
 263 {
 264   char *cpy;
 265   char *dot;
 266   const char *x;
 267
 268   cpy = GNUNET_strdup (zkey);
 269   x = cpy;
 270   if (NULL == (dot = strchr (x, (int) '.')))
 271     goto error;
 272   *dot = '\0';
 273   if (0 != strcasecmp (dot + 1,
 274                        "zkey"))
 275     goto error;
 276
 277   if (GNUNET_OK !=
 278       GNUNET_CRYPTO_ecdsa_public_key_from_string (x,
 279                                                 strlen (x),
 280                                                 pkey))
 281     goto error;
 282   GNUNET_free (cpy);
 283   return GNUNET_OK;
 284  error:
 285   GNUNET_free (cpy);
 286   return GNUNET_SYSERR;
 287 }
 288
 289
 290 /* end of gnsrecord_misc.c */