src/conversation/plugin_gnsrecord_conversation.c

   1 /*
   2      This file is part of GNUnet
   3      Copyright (C) 2013 GNUnet e.V.
   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., 51 Franklin Street, Fifth Floor,
  18      Boston, MA 02110-1301, USA.
  19 */
  20
  21 /**
  22  * @file conversation/plugin_gnsrecord_conversation.c
  23  * @brief gnsrecord plugin to provide the API for fundamental GNS records
  24  *                  This includes the VPN record because GNS resolution
  25  *                  is expected to understand VPN records and (if needed)
  26  *                  map the result to A/AAAA.
  27  * @author Christian Grothoff
  28  */
  29
  30 #include "platform.h"
  31 #include "gnunet_util_lib.h"
  32 #include "gnunet_gnsrecord_lib.h"
  33 #include "gnunet_conversation_service.h"
  34 #include "gnunet_gnsrecord_plugin.h"
  35
  36
  37 /**
  38  * Convert the 'value' of a record to a string.
  39  *
  40  * @param cls closure, unused
  41  * @param type type of the record
  42  * @param data value in binary encoding
  43  * @param data_size number of bytes in @a data
  44  * @return NULL on error, otherwise human-readable representation of the value
  45  */
  46 static char *
  47 conversation_value_to_string (void *cls,
  48                               uint32_t type,
  49                               const void *data,
  50                               size_t data_size)
  51 {
  52   char *s;
  53
  54   switch (type)
  55   {
  56   case GNUNET_GNSRECORD_TYPE_PHONE:
  57     {
  58       const struct GNUNET_CONVERSATION_PhoneRecord *pr;
  59       char *ret;
  60       char *pkey;
  61
  62       if (data_size != sizeof (struct GNUNET_CONVERSATION_PhoneRecord))
  63         return NULL;
  64       pr = data;
  65       if (0 != ntohl (pr->version))
  66         return NULL;
  67       pkey = GNUNET_CRYPTO_eddsa_public_key_to_string (&pr->peer.public_key);
  68       s = GNUNET_STRINGS_data_to_string_alloc (&pr->line_port,
  69                                                sizeof (struct GNUNET_HashCode));
  70
  71       GNUNET_asprintf (&ret,
  72                        "%s-%s",
  73                        s,
  74                        pkey);
  75       GNUNET_free (s);
  76       GNUNET_free (pkey);
  77       return ret;
  78     }
  79   default:
  80     return NULL;
  81   }
  82 }
  83
  84
  85 /**
  86  * Convert human-readable version of a 'value' of a record to the binary
  87  * representation.
  88  *
  89  * @param cls closure, unused
  90  * @param type type of the record
  91  * @param s human-readable string
  92  * @param data set to value in binary encoding (will be allocated)
  93  * @param data_size set to number of bytes in @a data
  94  * @return #GNUNET_OK on success
  95  */
  96 static int
  97 conversation_string_to_value (void *cls,
  98                               uint32_t type,
  99                               const char *s,
 100                               void **data,
 101                               size_t *data_size)
 102 {
 103   if (NULL == s)
 104     return GNUNET_SYSERR;
 105   switch (type)
 106   {
 107   case GNUNET_GNSRECORD_TYPE_PHONE:
 108     {
 109       struct GNUNET_CONVERSATION_PhoneRecord *pr;
 110       char line_port[128];
 111       const char *dash;
 112       struct GNUNET_PeerIdentity peer;
 113
 114       if ( (NULL == (dash = strchr (s, '-'))) ||
 115            (1 != sscanf (s, "%128s-", line_port)) ||
 116            (GNUNET_OK !=
 117             GNUNET_CRYPTO_eddsa_public_key_from_string (dash + 1,
 118                                                         strlen (dash + 1),
 119                                                         &peer.public_key)) )
 120       {
 121         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 122                     _("Unable to parse PHONE record `%s'\n"),
 123                     s);
 124         return GNUNET_SYSERR;
 125       }
 126       pr = GNUNET_new (struct GNUNET_CONVERSATION_PhoneRecord);
 127       pr->version = htonl (1);
 128       pr->reserved = htonl (0);
 129       if (GNUNET_OK !=
 130           GNUNET_STRINGS_string_to_data (line_port,
 131                                          strlen (line_port),
 132                                          &pr->line_port,
 133                                          sizeof (struct GNUNET_HashCode)))
 134       {
 135         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 136                     _("Unable to parse PHONE record `%s'\n"),
 137                     s);
 138         GNUNET_free (pr);
 139         return GNUNET_SYSERR;
 140       }
 141       pr->peer = peer;
 142       *data = pr;
 143       *data_size = sizeof (struct GNUNET_CONVERSATION_PhoneRecord);
 144       return GNUNET_OK;
 145     }
 146   default:
 147     return GNUNET_SYSERR;
 148   }
 149 }
 150
 151
 152 /**
 153  * Mapping of record type numbers to human-readable
 154  * record type names.
 155  */
 156 static struct {
 157   const char *name;
 158   uint32_t number;
 159 } name_map[] = {
 160   { "PHONE",  GNUNET_GNSRECORD_TYPE_PHONE },
 161   { NULL, UINT32_MAX }
 162 };
 163
 164
 165 /**
 166  * Convert a type name (i.e. "AAAA") to the corresponding number.
 167  *
 168  * @param cls closure, unused
 169  * @param gns_typename name to convert
 170  * @return corresponding number, UINT32_MAX on error
 171  */
 172 static uint32_t
 173 conversation_typename_to_number (void *cls,
 174                                  const char *gns_typename)
 175 {
 176   unsigned int i;
 177
 178   i=0;
 179   while ( (name_map[i].name != NULL) &&
 180           (0 != strcasecmp (gns_typename, name_map[i].name)) )
 181     i++;
 182   return name_map[i].number;
 183 }
 184
 185
 186 /**
 187  * Convert a type number (i.e. 1) to the corresponding type string (i.e. "A")
 188  *
 189  * @param cls closure, unused
 190  * @param type number of a type to convert
 191  * @return corresponding typestring, NULL on error
 192  */
 193 static const char *
 194 conversation_number_to_typename (void *cls,
 195                                  uint32_t type)
 196 {
 197   unsigned int i;
 198
 199   i=0;
 200   while ( (name_map[i].name != NULL) &&
 201           (type != name_map[i].number) )
 202     i++;
 203   return name_map[i].name;
 204 }
 205
 206
 207 /**
 208  * Entry point for the plugin.
 209  *
 210  * @param cls NULL
 211  * @return the exported block API
 212  */
 213 void *
 214 libgnunet_plugin_gnsrecord_conversation_init (void *cls)
 215 {
 216   struct GNUNET_GNSRECORD_PluginFunctions *api;
 217
 218   api = GNUNET_new (struct GNUNET_GNSRECORD_PluginFunctions);
 219   api->value_to_string = &conversation_value_to_string;
 220   api->string_to_value = &conversation_string_to_value;
 221   api->typename_to_number = &conversation_typename_to_number;
 222   api->number_to_typename = &conversation_number_to_typename;
 223   return api;
 224 }
 225
 226
 227 /**
 228  * Exit point from the plugin.
 229  *
 230  * @param cls the return value from #libgnunet_plugin_block_test_init
 231  * @return NULL
 232  */
 233 void *
 234 libgnunet_plugin_gnsrecord_conversation_done (void *cls)
 235 {
 236   struct GNUNET_GNSRECORD_PluginFunctions *api = cls;
 237
 238   GNUNET_free (api);
 239   return NULL;
 240 }
 241
 242 /* end of plugin_gnsrecord_conversation.c */