-more cleanup and input validation fixes

1 files changed, 60 insertions, 55 deletions

diff --git a/src/namestore/namestore_common.c b/src/namestore/namestore_common.c
index 8c42bad67..47029b73b 100644
--- a/src/namestore/namestore_common.c
+++ b/src/namestore/namestore_common.c
@@ -318,22 +318,6 @@ GNUNET_NAMESTORE_create_signature (const struct GNUNET_CRYPTO_RsaPrivateKey *key
   return sig;
 }
 
-/**
- * Checks if a name is wellformed
- *
- * @param name the name to check
- * @return GNUNET_OK on success, GNUNET_SYSERR on error
- */
-int
-GNUNET_NAMESTORE_check_name (const char * name)
-{
-  if (name == NULL)
-    return GNUNET_SYSERR;
-  if (strlen (name) > 63)
-    return GNUNET_SYSERR;
-  return GNUNET_OK;
-}
-
 
 /**
  * Convert the 'value' of a record to a string.
@@ -489,11 +473,11 @@ GNUNET_NAMESTORE_string_to_value (uint32_t type,
   struct soa_data *soa;
   struct vpn_data *vpn;
   struct tlsa_data *tlsa;
-  char result[253];
-  char soa_rname[63];
-  char soa_mname[63];
-  char s_peer[104];
-  char s_serv[253];
+  char result[253 + 1];
+  char soa_rname[253 + 1];
+  char soa_mname[253 + 1];
+  char s_peer[103 + 1];
+  char s_serv[253 + 1];
   uint32_t soa_serial;
   uint32_t soa_refresh;
   uint32_t soa_retry;
@@ -502,15 +486,22 @@ GNUNET_NAMESTORE_string_to_value (uint32_t type,
   uint16_t mx_pref;
   uint16_t mx_pref_n;
   uint16_t proto;
-  int ret;
   
   switch (type)
   {
   case 0:
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Unsupported record type %d\n"),
+                (int) type);
     return GNUNET_SYSERR;
   case GNUNET_DNSPARSER_TYPE_A:
     if (1 != inet_pton (AF_INET, s, &value_a))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _("Unable to parse IPv4 address `%s'\n"),
+                  s);
       return GNUNET_SYSERR;
+    }
     *data = GNUNET_malloc (sizeof (struct in_addr));
     memcpy (*data, &value_a, sizeof (value_a));
     *data_size = sizeof (value_a);
@@ -524,13 +515,16 @@ GNUNET_NAMESTORE_string_to_value (uint32_t type,
     *data_size = strlen (s) + 1;
     return GNUNET_OK;
   case GNUNET_DNSPARSER_TYPE_SOA:
-    
-    if (SSCANF(s, "rname=%s mname=%s %u,%u,%u,%u,%u",
-               soa_rname, soa_mname,
-               &soa_serial, &soa_refresh, &soa_retry, &soa_expire, &soa_min) 
-        != 7)
+    if (7 != SSCANF (s, 
+                     "rname=%253s mname=%253s %u,%u,%u,%u,%u",
+                     soa_rname, soa_mname,
+                     &soa_serial, &soa_refresh, &soa_retry, &soa_expire, &soa_min))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _("Unable to parse SOA record `%s'\n"),
+                  s);
       return GNUNET_SYSERR;
-    
+    }
     *data_size = sizeof (struct soa_data)+strlen(soa_rname)+strlen(soa_mname)+2;
     *data = GNUNET_malloc (*data_size);
     soa = (struct soa_data*)*data;
@@ -542,14 +536,18 @@ GNUNET_NAMESTORE_string_to_value (uint32_t type,
     strcpy((char*)&soa[1], soa_rname);
     strcpy((char*)&soa[1]+strlen(*data)+1, soa_mname);
     return GNUNET_OK;
-
   case GNUNET_DNSPARSER_TYPE_PTR:
     *data = GNUNET_strdup (s);
     *data_size = strlen (s);
     return GNUNET_OK;
   case GNUNET_DNSPARSER_TYPE_MX:
-    if (SSCANF(s, "%hu,%s", &mx_pref, result) != 2)
+    if (2 != SSCANF(s, "%hu,%253s", &mx_pref, result))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _("Unable to parse MX record `%s'\n"),
+                  s);
       return GNUNET_SYSERR;
+    }
     *data_size = sizeof (uint16_t)+strlen(result)+1;
     *data = GNUNET_malloc (*data_size);
     mx_pref_n = htons(mx_pref);
@@ -562,7 +560,12 @@ GNUNET_NAMESTORE_string_to_value (uint32_t type,
     return GNUNET_OK;
   case GNUNET_DNSPARSER_TYPE_AAAA:
     if (1 != inet_pton (AF_INET6, s, &value_aaaa))    
-      return GNUNET_SYSERR;    
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _("Unable to parse IPv6 address `%s'\n"),
+                  s);
+      return GNUNET_SYSERR;
+    }
     *data = GNUNET_malloc (sizeof (struct in6_addr));
     *data_size = sizeof (struct in6_addr);
     memcpy (*data, &value_aaaa, sizeof (value_aaaa));
@@ -570,7 +573,12 @@ GNUNET_NAMESTORE_string_to_value (uint32_t type,
   case GNUNET_NAMESTORE_TYPE_PKEY:
     if (GNUNET_OK !=
         GNUNET_CRYPTO_short_hash_from_string (s, &pkey))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _("Unable to parse PKEY record `%s'\n"),
+                  s);
       return GNUNET_SYSERR;
+    }
     *data = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_ShortHashCode));
     memcpy (*data, &pkey, sizeof (pkey));
     *data_size = sizeof (struct GNUNET_CRYPTO_ShortHashCode);
@@ -584,52 +592,49 @@ GNUNET_NAMESTORE_string_to_value (uint32_t type,
     *data_size = strlen (s);
     return GNUNET_OK;
   case GNUNET_NAMESTORE_TYPE_VPN:
-    
-    ret = SSCANF (s,"%hu %s %s",
-                  &proto, s_peer, s_serv);
-    if (3 != ret)
+    if (3 != SSCANF (s,"%hu %103s %253s",
+                     &proto, s_peer, s_serv))
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Unable to parse VPN record string %s %d\n", s, ret);
+                  _("Unable to parse VPN record string `%s'\n"),
+                  s);
       return GNUNET_SYSERR;
     }
     *data_size = sizeof (struct vpn_data) + strlen (s_serv) + 1;
-    *data = GNUNET_malloc (*data_size);
-
-    vpn = (struct vpn_data*)*data;
-    
-    if (GNUNET_OK != GNUNET_CRYPTO_hash_from_string ((char*)&s_peer, &vpn->peer))
+    *data = vpn = GNUNET_malloc (*data_size);
+    if (GNUNET_OK != GNUNET_CRYPTO_hash_from_string ((char*)&s_peer,
+                                                     &vpn->peer))
     {
-      GNUNET_free (*data);
+      GNUNET_free (vpn);
+      *data_size = 0;
       return GNUNET_SYSERR;
     }
-
     vpn->proto = htons (proto);
     strcpy ((char*)&vpn[1], s_serv);
     return GNUNET_OK;
   case GNUNET_DNSPARSER_TYPE_TLSA:
     *data_size = sizeof (struct tlsa_data) + strlen (s) - 6;
-    *data = GNUNET_malloc (*data_size);
-    tlsa = (struct tlsa_data*)*data;
-    ret = SSCANF (s, "%c %c %c %s",
-                  &tlsa->usage,
-                  &tlsa->selector,
-                  &tlsa->matching_type,
-                  (char*)&tlsa[1]);
-
-    if (4 != ret)
+    *data = tlsa = GNUNET_malloc (*data_size);
+    if (4 != SSCANF (s, "%c %c %c %s",
+                     &tlsa->usage,
+                     &tlsa->selector,
+                     &tlsa->matching_type,
+                     (char*)&tlsa[1]))
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Unable to parse TLSA record string %s\n", s);
+                  _("Unable to parse TLSA record string `%s'\n"), 
+                  s);
       *data_size = 0;
       GNUNET_free (tlsa);
       return GNUNET_SYSERR;
     }
     return GNUNET_OK;
   default:
-    GNUNET_break (0);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Unsupported record type %d\n"),
+                (int) type);
+    return GNUNET_SYSERR;
   }
-  return GNUNET_SYSERR;
 }