5 files changed, 545 insertions, 81 deletions

diff --git a/src/gns/Makefile.am b/src/gns/Makefile.am
index bb10a5973..c65d52492 100644
--- a/src/gns/Makefile.am
+++ b/src/gns/Makefile.am
@@ -45,6 +45,7 @@ check_PROGRAMS = \
   test_gns_simple_lookup \
   test_gns_simple_delegated_lookup \
   test_gns_simple_mx_lookup \
+        test_gns_simple_srv_lookup \
   test_gns_simple_zkey_lookup \
   test_gns_dht_delegated_lookup \
   test_gns_pseu_shorten \
@@ -115,6 +116,19 @@ test_gns_simple_mx_lookup_DEPENDENCIES = \
   $(top_builddir)/src/gns/libgnunetgns.la \
   $(top_builddir)/src/testing_old/libgnunettesting_old.la
 
+test_gns_simple_srv_lookup_SOURCES = \
+  test_gns_simple_srv_lookup.c
+test_gns_simple_srv_lookup_LDADD = \
+  $(top_builddir)/src/util/libgnunetutil.la \
+  $(top_builddir)/src/namestore/libgnunetnamestore.la \
+  $(top_builddir)/src/gns/libgnunetgns.la \
+  $(top_builddir)/src/testing_old/libgnunettesting_old.la
+test_gns_simple_srv_lookup_DEPENDENCIES = \
+  $(top_builddir)/src/util/libgnunetutil.la \
+  $(top_builddir)/src/namestore/libgnunetnamestore.la \
+  $(top_builddir)/src/gns/libgnunetgns.la \
+  $(top_builddir)/src/testing_old/libgnunettesting_old.la
+
 test_gns_simple_zkey_lookup_SOURCES = \
   test_gns_simple_zkey_lookup.c
 test_gns_simple_zkey_lookup_LDADD = \
diff --git a/src/gns/gnunet-service-gns_resolver.c b/src/gns/gnunet-service-gns_resolver.c
index 045112eae..bbeea86f4 100644
--- a/src/gns/gnunet-service-gns_resolver.c
+++ b/src/gns/gnunet-service-gns_resolver.c
@@ -97,6 +97,31 @@ static struct GetPseuAuthorityHandle *gph_tail;
  */
 static unsigned long long rid = 0;
 
+static int
+is_srv (char* name)
+{
+  char* ndup;
+  int ret = 1;
+
+  if (*name != '_')
+    return 0;
+  if (NULL == strstr (name, "._"))
+    return 0;
+
+  ndup = GNUNET_strdup (name);
+  strtok (ndup, ".");
+
+  if (NULL == strtok (NULL, "."))
+    ret = 0;
+
+  if (NULL == strtok (NULL, "."))
+    ret = 0;
+
+  if (NULL != strtok (NULL, "."))
+    ret = 0;
+
+  return ret;
+}
 
 /**
  * Determine if this name is canonical.
@@ -110,14 +135,23 @@ static unsigned long long rid = 0;
 static int
 is_canonical(char* name)
 {
-  uint32_t len = strlen(name);
-  int i;
+  char* ndup;
+  char* tok;
+
+  ndup = GNUNET_strdup (name);
+  tok = strtok (ndup, ".");
 
-  for (i=0; i<len; i++)
+  for (tok = strtok (NULL, "."); tok != NULL; tok = strtok (NULL, "."))
   {
-    if (*(name+i) == '.')
-      return 0;
+    /*
+     * probably srv
+     */
+    if (*tok == '_')
+      continue;
+    GNUNET_free (ndup);
+    return 0;
   }
+  GNUNET_free (ndup);
   return 1;
 }
 
@@ -1126,12 +1160,12 @@ resolve_record_dht (struct ResolverHandle *rh)
  * @param signature the signature of the authority for the record data
  */
 static void
-process_record_result_ns(void* cls,
-                         const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
-                         struct GNUNET_TIME_Absolute expiration,
-                         const char *name, unsigned int rd_count,
-                         const struct GNUNET_NAMESTORE_RecordData *rd,
-                         const struct GNUNET_CRYPTO_RsaSignature *signature)
+process_record_result_ns (void* cls,
+                          const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
+                          struct GNUNET_TIME_Absolute expiration,
+                          const char *name, unsigned int rd_count,
+                          const struct GNUNET_NAMESTORE_RecordData *rd,
+                          const struct GNUNET_CRYPTO_RsaSignature *signature)
 {
   struct ResolverHandle *rh;
   struct RecordLookupHandle *rlh;
@@ -2313,6 +2347,7 @@ process_delegation_result_dht(void* cls,
 #define MAX_SOA_LENGTH sizeof(uint32_t)+sizeof(uint32_t)+sizeof(uint32_t)+sizeof(uint32_t)\
                         +(MAX_DNS_NAME_LENGTH*2)
 #define MAX_MX_LENGTH sizeof(uint16_t)+MAX_DNS_NAME_LENGTH
+#define MAX_SRV_LENGTH (sizeof(uint16_t)*3)+MAX_DNS_NAME_LENGTH
 
 
 static void
@@ -2365,6 +2400,7 @@ finish_lookup(struct ResolverHandle *rh,
   char new_rr_data[MAX_DNS_NAME_LENGTH];
   char new_mx_data[MAX_MX_LENGTH];
   char new_soa_data[MAX_SOA_LENGTH];
+  char new_srv_data[MAX_SRV_LENGTH];
   struct GNUNET_NAMESTORE_RecordData p_rd[rd_count];
   char* repl_string;
   char* pos;
@@ -2385,7 +2421,8 @@ finish_lookup(struct ResolverHandle *rh,
     if (rd[i].record_type != GNUNET_GNS_RECORD_TYPE_NS &&
         rd[i].record_type != GNUNET_GNS_RECORD_TYPE_CNAME &&
         rd[i].record_type != GNUNET_GNS_RECORD_MX &&
-        rd[i].record_type != GNUNET_GNS_RECORD_TYPE_SOA)
+        rd[i].record_type != GNUNET_GNS_RECORD_TYPE_SOA &&
+        rd[i].record_type != GNUNET_GNS_RECORD_TYPE_SRV)
     {
       p_rd[i].data = rd[i].data;
       continue;
@@ -2408,7 +2445,7 @@ finish_lookup(struct ResolverHandle *rh,
     offset = 0;
     if (rd[i].record_type == GNUNET_GNS_RECORD_MX)
     {
-      memcpy(new_mx_data, (char*)rd[i].data, sizeof(uint16_t));
+      memcpy (new_mx_data, (char*)rd[i].data, sizeof(uint16_t));
       offset = sizeof(uint16_t);
       pos = new_mx_data+offset;
       expand_plus(&pos, (char*)rd[i].data+sizeof(uint16_t),
@@ -2417,6 +2454,20 @@ finish_lookup(struct ResolverHandle *rh,
       p_rd[i].data = new_mx_data;
       p_rd[i].data_size = offset;
     }
+    else if (rd[i].record_type == GNUNET_GNS_RECORD_TYPE_SRV)
+    {
+      /*
+       * Prio, weight and port
+       */
+      memcpy (new_srv_data, (char*)rd[i].data, sizeof (uint16_t) * 3);
+      offset = sizeof (uint16_t) * 3;
+      pos = new_srv_data+offset;
+      expand_plus(&pos, (char*)rd[i].data+(sizeof(uint16_t)*3),
+                  repl_string);
+      offset += strlen(new_srv_data+(sizeof(uint16_t)*3))+1;
+      p_rd[i].data = new_srv_data;
+      p_rd[i].data_size = offset;
+    }
     else if (rd[i].record_type == GNUNET_GNS_RECORD_TYPE_SOA)
     {
       /* expand mname and rname */
@@ -2501,6 +2552,8 @@ handle_record_ns (void* cls, struct ResolverHandle *rh,
 {
   struct RecordLookupHandle* rlh;
   rlh = (struct RecordLookupHandle*) cls;
+  int check_dht = GNUNET_YES;
+
   if (rd_count == 0)
   {
     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
@@ -2519,12 +2572,22 @@ handle_record_ns (void* cls, struct ResolverHandle *rh,
      *    would already have an entry in the NS for the record)
      * 5. We are not in cache only mode
      */
-    if (( ((rh->status & RSL_RECORD_EXPIRED) != 0) ||
-         ((rh->status & RSL_RECORD_EXISTS) == 0) ) &&
-        GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone,
-                                        &rh->private_local_zone) &&
-        (strcmp(rh->name, "+") == 0) &&
-        (rh->only_cached == GNUNET_NO))
+    if (((rh->status & RSL_RECORD_EXPIRED) != 0) &&
+        ((rh->status & RSL_RECORD_EXISTS) == 0) )
+      check_dht = GNUNET_NO;
+    
+    if (0 != GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone,
+                                          &rh->private_local_zone))
+      check_dht = GNUNET_NO;
+    
+    if ((strcmp (rh->name, "+") != 0) && (is_srv (rh->name) != 0))
+        check_dht = GNUNET_NO;
+
+
+    if (rh->only_cached == GNUNET_YES)
+      check_dht = GNUNET_NO;
+    
+    if (GNUNET_YES == check_dht)
     {
       rh->proc = &handle_record_dht;
       resolve_record_dht(rh);
@@ -2559,7 +2622,7 @@ pop_tld(char* name, char* dest)
 {
   uint32_t len;
 
-  if (is_canonical(name))
+  if (is_canonical (name))
   {
     strcpy(dest, name);
     strcpy(name, "");
@@ -2757,6 +2820,7 @@ handle_delegation_ns (void* cls, struct ResolverHandle *rh,
 {
   struct RecordLookupHandle* rlh;
   rlh = (struct RecordLookupHandle*) cls;
+  int check_dht = GNUNET_YES;
   int s_len = 0;
 
   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
@@ -2920,9 +2984,19 @@ handle_delegation_ns (void* cls, struct ResolverHandle *rh,
    * and exists
    * or we are authority
    **/
-  if (((rh->status & RSL_RECORD_EXISTS) && (!(rh->status & RSL_RECORD_EXPIRED)))
-      || !GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone,
-                                       &rh->private_local_zone))
+
+  if ((rh->status & RSL_RECORD_EXISTS) &&
+       !(rh->status & RSL_RECORD_EXPIRED))
+    check_dht = GNUNET_NO;
+
+  if (0 == GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone,
+                                        &rh->private_local_zone))
+    check_dht = GNUNET_NO;
+
+  if (rh->only_cached == GNUNET_YES)
+    check_dht = GNUNET_NO;
+
+  if (check_dht == GNUNET_NO)
   {
     if (is_canonical(rh->name))
     {
@@ -2946,15 +3020,6 @@ handle_delegation_ns (void* cls, struct ResolverHandle *rh,
     return;
   }
 
-  if (rh->only_cached == GNUNET_YES)
-  {
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-               "GNS_PHASE_DELEGATE_NS-%llu: Only cache resolution, no result\n",
-               rh->id, rh->name);
-    finish_lookup(rh, rlh, rd_count, rd);
-    return;
-  }
-  
   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
       "GNS_PHASE_DELEGATE_NS-%llu: Trying to resolve delegation for %s via DHT\n",
       rh->id, rh->name);
@@ -2994,29 +3059,29 @@ process_delegation_result_ns (void* cls,
   struct GNUNET_TIME_Absolute et;
  
   rh = (struct ResolverHandle *)cls; 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "GNS_PHASE_DELEGATE_NS-%llu: Got %d records from authority lookup\n",
-             rh->id, rd_count);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+          "GNS_PHASE_DELEGATE_NS-%llu: Got %d records from authority lookup\n",
+          rh->id, rd_count);
 
-  GNUNET_CRYPTO_short_hash(key,
-                     sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
-                     &zone);
+  GNUNET_CRYPTO_short_hash (key,
+                      sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                      &zone);
   remaining_time = GNUNET_TIME_absolute_get_remaining (expiration);
   
   rh->status = 0;
   
   if (name != NULL)
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-               "GNS_PHASE_DELEGATE_NS-%llu: Records with name %s exist.\n",
-               rh->id, name);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "GNS_PHASE_DELEGATE_NS-%llu: Records with name %s exist.\n",
+                rh->id, name);
     rh->status |= RSL_RECORD_EXISTS;
   
     if (remaining_time.rel_value == 0)
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "GNS_PHASE_DELEGATE_NS-%llu: Record set %s expired.\n",
-                 rh->id, name);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "GNS_PHASE_DELEGATE_NS-%llu: Record set %s expired.\n",
+                  rh->id, name);
       rh->status |= RSL_RECORD_EXPIRED;
     }
   }
@@ -3035,31 +3100,29 @@ process_delegation_result_ns (void* cls,
      * Promote this authority back to a name maybe it is
      * our record.
      */
-    if (strcmp(rh->name, "") == 0)
+    if (strcmp (rh->name, "") == 0)
     {
       /* simply promote back */
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "GNS_PHASE_DELEGATE_NS-%llu: Promoting %s back to name\n",
-                 rh->id, rh->authority_name);
-      strcpy(rh->name, rh->authority_name);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "GNS_PHASE_DELEGATE_NS-%llu: Promoting %s back to name\n",
+                  rh->id, rh->authority_name);
+      strcpy (rh->name, rh->authority_name);
     }
     else
     {
       /* add back to existing name */
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "GNS_PHASE_DELEGATE_NS-%llu: Adding %s back to %s\n",
-                 rh->id, rh->authority_name, rh->name);
-      //memset(new_name, 0, strlen(rh->name) + strlen(rh->authority_name) + 2);
-      GNUNET_snprintf(new_name, MAX_DNS_NAME_LENGTH, "%s.%s",
-                      rh->name, rh->authority_name);
-      //strcpy(new_name, rh->name);
-      //strcpy(new_name+strlen(new_name), ".");
-      //strcpy(new_name+strlen(new_name), rh->authority_name);
-      strcpy(rh->name, new_name);
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "GNS_PHASE_DELEGATE_NS-%llu: %s restored\n", rh->id, rh->name);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "GNS_PHASE_DELEGATE_NS-%llu: Adding %s back to %s\n",
+                  rh->id, rh->authority_name, rh->name);
+      GNUNET_snprintf (new_name, MAX_DNS_NAME_LENGTH, "%s.%s",
+                       rh->name, rh->authority_name);
+      strcpy (rh->name, new_name);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "GNS_PHASE_DELEGATE_NS-%llu: %s restored\n",
+                  rh->id, rh->name);
     }
-    rh->proc(rh->proc_cls, rh, 0, NULL);
+
+    rh->proc (rh->proc_cls, rh, 0, NULL);
     return;
   }
 
@@ -3068,7 +3131,7 @@ process_delegation_result_ns (void* cls,
    * move on with query
    * Note only 1 pkey should have been returned.. anything else would be strange
    */
-  for (i=0; i<rd_count;i++)
+  for (i=0; i < rd_count;i++)
   {
     
     /**
@@ -3118,11 +3181,11 @@ process_delegation_result_ns (void* cls,
 
     rh->status |= RSL_DELEGATE_PKEY;
 
-    if (ignore_pending_records &&
+    if ((ignore_pending_records != 0) &&
         (rd[i].flags & GNUNET_NAMESTORE_RF_PENDING))
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-      "GNS_PHASE_DELEGATE_NS-%llu: PKEY for %s is pending user confirmation.\n",
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+     "GNS_PHASE_DELEGATE_NS-%llu: PKEY for %s is pending user confirmation.\n",
         rh->id,
         name);
       continue;
@@ -3133,16 +3196,16 @@ process_delegation_result_ns (void* cls,
     if ((GNUNET_TIME_absolute_get_remaining (et)).rel_value
          == 0)
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "GNS_PHASE_DELEGATE_NS-%llu: This pkey is expired.\n",
-                 rh->id);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "GNS_PHASE_DELEGATE_NS-%llu: This pkey is expired.\n",
+                  rh->id);
       if (remaining_time.rel_value == 0)
       {
-        GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                   "GNS_PHASE_DELEGATE_NS-%llu: This dht entry is expired.\n",
-                   rh->id);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "GNS_PHASE_DELEGATE_NS-%llu: This dht entry is expired.\n",
+                    rh->id);
         rh->authority_chain_head->fresh = 0;
-        rh->proc(rh->proc_cls, rh, 0, NULL);
+        rh->proc (rh->proc_cls, rh, 0, NULL);
         return;
       }
 
@@ -3152,13 +3215,13 @@ process_delegation_result_ns (void* cls,
     /**
      * Resolve rest of query with new authority
      */
-    GNUNET_assert(rd[i].record_type == GNUNET_GNS_RECORD_PKEY);
-    memcpy(&rh->authority, rd[i].data,
-           sizeof(struct GNUNET_CRYPTO_ShortHashCode));
-    struct AuthorityChain *auth = GNUNET_malloc(sizeof(struct AuthorityChain));
+    GNUNET_assert (rd[i].record_type == GNUNET_GNS_RECORD_PKEY);
+    memcpy (&rh->authority, rd[i].data,
+            sizeof (struct GNUNET_CRYPTO_ShortHashCode));
+    struct AuthorityChain *auth = GNUNET_malloc(sizeof (struct AuthorityChain));
     auth->zone = rh->authority;
-    memset(auth->name, 0, strlen(rh->authority_name)+1);
-    strcpy(auth->name, rh->authority_name);
+    memset (auth->name, 0, strlen (rh->authority_name)+1);
+    strcpy (auth->name, rh->authority_name);
     GNUNET_CONTAINER_DLL_insert (rh->authority_chain_head,
                                  rh->authority_chain_tail,
                                  auth);
diff --git a/src/gns/test_gns_simple_srv_lookup.c b/src/gns/test_gns_simple_srv_lookup.c
new file mode 100644
index 000000000..b23d6ded3
--- /dev/null
+++ b/src/gns/test_gns_simple_srv_lookup.c
@@ -0,0 +1,387 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 3, 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
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+/**
+ * @file gns/test_gns_simple_srv_lookup.c
+ * @brief base testcase for testing GNS SRV lookups
+ *
+ */
+#include "platform.h"
+#include "gnunet_testing_lib.h"
+#include "gnunet_core_service.h"
+#include "block_dns.h"
+#include "gnunet_signatures.h"
+#include "gnunet_namestore_service.h"
+#include "../namestore/namestore.h"
+#include "gnunet_dnsparser_lib.h"
+#include "gnunet_gns_service.h"
+
+/* DEFINES */
+#define VERBOSE GNUNET_YES
+
+/* Timeout for entire testcase */
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 20)
+
+/* If number of peers not in config file, use this number */
+#define DEFAULT_NUM_PEERS 2
+
+/* test records to resolve */
+#define TEST_DOMAIN "_sip._tcp.bob.gnunet"
+#define TEST_IP "127.0.0.1"
+#define TEST_RECORD_NAME "sipserver"
+#define TEST_RECORD_NAME_SRV "_sip._tcp"
+#define TEST_SRV_NAME "sipserver.+"
+#define TEST_EXPECTED_SRV "sipserver.bob.gnunet"
+
+#define TEST_AUTHORITY_NAME "bob"
+
+#define KEYFILE_BOB "../namestore/zonefiles/HGU0A0VCU334DN7F2I9UIUMVQMM7JMSD142LIMNUGTTV9R0CF4EG.zkey"
+
+/* Globals */
+
+/**
+ * Directory to store temp data in, defined in config file
+ */
+static char *test_directory;
+
+static struct GNUNET_TESTING_PeerGroup *pg;
+
+/* Task handle to use to schedule test failure */
+GNUNET_SCHEDULER_TaskIdentifier die_task;
+
+/* Global return value (0 for success, anything else for failure) */
+static int ok;
+
+static struct GNUNET_NAMESTORE_Handle *namestore_handle;
+
+static struct GNUNET_GNS_Handle *gns_handle;
+
+const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+/**
+ * Check whether peers successfully shut down.
+ */
+void
+shutdown_callback (void *cls, const char *emsg)
+{
+  if (emsg != NULL)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error on shutdown! ret=%d\n", ok);
+    if (ok == 0)
+      ok = 2;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "done(ret=%d)!\n", ok);
+}
+
+static void
+on_lookup_result(void *cls, uint32_t rd_count,
+                 const struct GNUNET_NAMESTORE_RecordData *rd)
+{
+  int i;
+  uint16_t *srv_data;
+  char* srv;
+  
+  if (rd_count == 0)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Lookup failed, rp_filtering?\n");
+    ok = 2;
+  }
+  else
+  {
+    ok = 1;
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "name: %s\n", (char*)cls);
+    for (i=0; i<rd_count; i++)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO, "type: %d\n", rd[i].record_type);
+      if (rd[i].record_type == GNUNET_GNS_RECORD_TYPE_SRV)
+      {
+        srv_data = (uint16_t*)rd[i].data;
+        srv = (char*)&srv_data[3];
+        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                    "Got SRV %s with p=%d,w=%d,port=%d\n",
+                    srv, srv_data, &srv_data[1], &srv_data[2]);
+        if (0 == strcmp(srv, TEST_EXPECTED_SRV))
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                      "%s correctly resolved to %s!\n", TEST_DOMAIN,
+                      TEST_EXPECTED_SRV);
+          ok = 0;
+        }
+      }
+    }
+  }
+
+  GNUNET_GNS_disconnect(gns_handle);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutting down peer1!\n");
+  GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
+}
+
+
+/**
+ * Function scheduled to be run on the successful start of services
+ * tries to look up the dns record for TEST_DOMAIN
+ */
+static void
+commence_testing (void *cls, int32_t success, const char *emsg)
+{
+  GNUNET_NAMESTORE_disconnect(namestore_handle, GNUNET_YES);
+
+  gns_handle = GNUNET_GNS_connect(cfg);
+
+  if (NULL == gns_handle)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to connect to GNS!\n");
+  }
+
+  GNUNET_GNS_lookup(gns_handle, TEST_DOMAIN, GNUNET_GNS_RECORD_TYPE_SRV,
+                    GNUNET_NO,
+                    NULL,
+                    &on_lookup_result, TEST_DOMAIN);
+}
+
+/**
+ * Continuation for the GNUNET_DHT_get_stop call, so that we don't shut
+ * down the peers without freeing memory associated with GET request.
+ */
+static void
+end_badly_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+
+  if (pg != NULL)
+    GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
+  GNUNET_SCHEDULER_cancel (die_task);
+}
+
+/**
+ * Check if the get_handle is being used, if so stop the request.  Either
+ * way, schedule the end_badly_cont function which actually shuts down the
+ * test.
+ */
+static void
+end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failing test with error: `%s'!\n",
+              (char *) cls);
+  GNUNET_SCHEDULER_add_now (&end_badly_cont, NULL);
+  ok = 1;
+}
+
+GNUNET_NETWORK_STRUCT_BEGIN
+struct srv_data
+{
+  uint16_t prio GNUNET_PACKED;
+  uint16_t weight GNUNET_PACKED;
+  uint16_t port GNUNET_PACKED;
+};
+GNUNET_NETWORK_STRUCT_END
+
+static void
+do_lookup(void *cls, const struct GNUNET_PeerIdentity *id,
+          const struct GNUNET_CONFIGURATION_Handle *_cfg,
+          struct GNUNET_TESTING_Daemon *d, const char *emsg)
+{
+  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey;
+  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded bob_pkey;
+  struct GNUNET_CRYPTO_RsaPrivateKey *alice_key;
+  struct GNUNET_CRYPTO_RsaPrivateKey *bob_key;
+  struct GNUNET_CRYPTO_ShortHashCode bob_hash;
+  struct GNUNET_CRYPTO_RsaSignature *sig;
+  char* alice_keyfile;
+  struct srv_data *srv_data;
+  struct GNUNET_TIME_Absolute et;
+
+  cfg = _cfg;
+
+  GNUNET_SCHEDULER_cancel (die_task);
+
+  /* put records into namestore */
+  namestore_handle = GNUNET_NAMESTORE_connect(cfg);
+  if (NULL == namestore_handle)
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to namestore\n");
+    ok = -1;
+    return;
+  }
+
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
+                                                          "ZONEKEY",
+                                                          &alice_keyfile))
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
+    ok = -1;
+    return;
+  }
+
+  alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (alice_keyfile);
+  bob_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_BOB);
+
+  GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey);
+  GNUNET_CRYPTO_rsa_key_get_public (bob_key, &bob_pkey);
+
+  struct GNUNET_NAMESTORE_RecordData rd;
+  char* ip = TEST_IP;
+  struct in_addr *sipserver = GNUNET_malloc (sizeof (struct in_addr));
+  srv_data = GNUNET_malloc (sizeof (struct srv_data) + strlen (TEST_SRV_NAME) + 1);
+  uint16_t srv_weight = 60;
+  uint16_t srv_prio = 50;
+  uint16_t srv_port = 5060;
+
+  rd.expiration_time = UINT64_MAX;
+  GNUNET_assert(1 == inet_pton (AF_INET, ip, sipserver));
+  
+  GNUNET_CRYPTO_short_hash(&bob_pkey, sizeof(bob_pkey), &bob_hash);
+
+  rd.data_size = sizeof(struct GNUNET_CRYPTO_ShortHashCode);
+  rd.data = &bob_hash;
+  rd.record_type = GNUNET_GNS_RECORD_PKEY;
+  rd.flags = GNUNET_NAMESTORE_RF_AUTHORITY;
+
+  GNUNET_NAMESTORE_record_create (namestore_handle,
+                                  alice_key,
+                                  TEST_AUTHORITY_NAME,
+                                  &rd,
+                                  NULL,
+                                  NULL);
+
+  rd.data_size = sizeof (struct in_addr);
+  rd.data = sipserver;
+  rd.record_type = GNUNET_DNSPARSER_TYPE_A;
+  sig = GNUNET_NAMESTORE_create_signature(bob_key,
+                                          GNUNET_TIME_UNIT_FOREVER_ABS,
+                                          TEST_RECORD_NAME,
+                                          &rd, 1);
+  et.abs_value = rd.expiration_time;
+  GNUNET_NAMESTORE_record_put (namestore_handle,
+                               &bob_pkey,
+                               TEST_RECORD_NAME,
+                               et,
+                               1,
+                               &rd,
+                               sig,
+                               NULL,
+                               NULL);
+  
+  rd.data_size = sizeof (struct srv_data)+strlen(TEST_SRV_NAME)+1;
+  srv_data->port = srv_port;
+  srv_data->prio = srv_prio;
+  srv_data->weight = srv_weight;
+  strcpy((char*)&srv_data[1], TEST_SRV_NAME);
+  rd.data = srv_data;
+  rd.record_type = GNUNET_GNS_RECORD_TYPE_SRV;
+  sig = GNUNET_NAMESTORE_create_signature(bob_key,
+                                          GNUNET_TIME_UNIT_FOREVER_ABS,
+                                          TEST_RECORD_NAME_SRV,
+                                          &rd, 1);
+  et.abs_value = rd.expiration_time;
+  GNUNET_NAMESTORE_record_put (namestore_handle,
+                               &bob_pkey,
+                               TEST_RECORD_NAME_SRV,
+                               et,
+                               1,
+                               &rd,
+                               sig,
+                               &commence_testing,
+                               NULL);
+  GNUNET_free(srv_data);
+  GNUNET_free(sipserver);
+  GNUNET_free(sig);
+  GNUNET_CRYPTO_rsa_key_free(bob_key);
+  GNUNET_CRYPTO_rsa_key_free(alice_key);
+}
+
+static void
+run (void *cls, char *const *args, const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *c)
+{
+  cfg = c;
+   /* Get path from configuration file */
+  if (GNUNET_YES !=
+      GNUNET_CONFIGURATION_get_value_string (cfg, "paths", "servicehome",
+                                             &test_directory))
+  {
+    ok = 404;
+    return;
+  }
+
+    
+  /* Set up a task to end testing if peer start fails */
+  die_task =
+      GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly,
+                                    "didn't start all daemons in reasonable amount of time!!!");
+  
+  /* Start alice */
+  pg = GNUNET_TESTING_daemons_start(cfg, 1, 1, 1, TIMEOUT,
+                                    NULL, NULL, &do_lookup, NULL,
+                                    NULL, NULL, NULL);
+}
+
+static int
+check ()
+{
+  int ret;
+
+  /* Arguments for GNUNET_PROGRAM_run */
+  char *const argv[] = { "test-gns-simple-mx-lookup", /* Name to give running binary */
+    "-c",
+    "test_gns_simple_lookup.conf",       /* Config file to use */
+#if VERBOSE
+    "-L", "DEBUG",
+#endif
+    NULL
+  };
+  struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_OPTION_END
+  };
+  /* Run the run function as a new program */
+  ret =
+      GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, argv,
+                          "test-gns-simple-mx-lookup", "nohelp", options, &run,
+                          &ok);
+  if (ret != GNUNET_OK)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "`test-gns-simple-mx-lookup': Failed with error code %d\n", ret);
+  }
+  return ok;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int ret;
+
+  GNUNET_log_setup ("test-gns-simple-mx-lookup",
+#if VERBOSE
+                    "DEBUG",
+#else
+                    "WARNING",
+#endif
+                    NULL);
+  ret = check ();
+  /**
+   * Need to remove base directory, subdirectories taken care
+   * of by the testing framework.
+   */
+  return ret;
+}
+
+/* end of test_gns_simple_mx_lookup.c */
diff --git a/src/include/gnunet_dnsparser_lib.h b/src/include/gnunet_dnsparser_lib.h
index 5a42baea6..a36996432 100644
--- a/src/include/gnunet_dnsparser_lib.h
+++ b/src/include/gnunet_dnsparser_lib.h
@@ -190,8 +190,7 @@ struct GNUNET_DNSPARSER_SrvRecord
 {
   
   /**
-   * Preference for this entry (lower value is higher preference).
-   * Without the underscore (!).  Note that RFC 6335 clarifies the
+   * Service name without the underscore (!).  Note that RFC 6335 clarifies the
    * set of legal characters for service names.
    */
   char *service;
diff --git a/src/include/gnunet_gns_service.h b/src/include/gnunet_gns_service.h
index 86caf249e..521fcfadf 100644
--- a/src/include/gnunet_gns_service.h
+++ b/src/include/gnunet_gns_service.h
@@ -71,6 +71,7 @@ enum GNUNET_GNS_RecordType
   GNUNET_GNS_RECORD_TYPE_NS    = GNUNET_DNSPARSER_TYPE_NS,
   GNUNET_GNS_RECORD_TYPE_CNAME = GNUNET_DNSPARSER_TYPE_CNAME,
   GNUNET_GNS_RECORD_TYPE_SOA   = GNUNET_DNSPARSER_TYPE_SOA,
+  GNUNET_GNS_RECORD_TYPE_SRV   = GNUNET_DNSPARSER_TYPE_SRV,
   GNUNET_GNS_RECORD_TYPE_PTR   = GNUNET_DNSPARSER_TYPE_PTR,
   GNUNET_GNS_RECORD_MX         = GNUNET_DNSPARSER_TYPE_MX,
   GNUNET_GNS_RECORD_TXT        = GNUNET_DNSPARSER_TYPE_TXT,