1 files changed, 221 insertions, 453 deletions

diff --git a/src/gns/plugin_rest_gns.c b/src/gns/plugin_rest_gns.c
index e76a5d116..fd2469577 100644
--- a/src/gns/plugin_rest_gns.c
+++ b/src/gns/plugin_rest_gns.c
@@ -11,42 +11,42 @@
    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/>.
    */
 /**
- * @author Martin Schanzenbach
+ * @author Philippe Buschmann
  * @file gns/plugin_rest_gns.c
- * @brief GNUnet GNS REST plugin
- *
+ * @brief GNUnet Gns REST plugin
  */
 
 #include "platform.h"
 #include "gnunet_rest_plugin.h"
-#include <gnunet_dnsparser_lib.h>
-#include <gnunet_identity_service.h>
-#include <gnunet_gnsrecord_lib.h>
-#include <gnunet_namestore_service.h>
-#include <gnunet_gns_service.h>
-#include <gnunet_rest_lib.h>
-#include <gnunet_jsonapi_lib.h>
-#include <gnunet_jsonapi_util.h>
+#include "gnunet_rest_lib.h"
+#include "gnunet_json_lib.h"
+#include "gnunet_gnsrecord_lib.h"
+#include "gnunet_gns_service.h"
+#include "microhttpd.h"
 #include <jansson.h>
 
 #define GNUNET_REST_API_NS_GNS "/gns"
 
-#define GNUNET_REST_JSONAPI_GNS_RECORD_TYPE "record_type"
-
-#define GNUNET_REST_JSONAPI_GNS_TYPEINFO "gns_name"
 
-#define GNUNET_REST_JSONAPI_GNS_RECORD "records"
+#define GNUNET_REST_GNS_PARAM_NAME "name"
 
-#define GNUNET_REST_JSONAPI_GNS_EGO "ego"
+#define GNUNET_REST_GNS_PARAM_RECORD_TYPE "record_type"
+#define GNUNET_REST_GNS_ERROR_UNKNOWN "Unknown Error"
 
-#define GNUNET_REST_JSONAPI_GNS_PKEY "pkey"
+/**
+ * The configuration handle
+ */
+const struct GNUNET_CONFIGURATION_Handle *cfg;
 
-#define GNUNET_REST_JSONAPI_GNS_OPTIONS "options"
+/**
+ * HTTP methods allows for this plugin
+ */
+static char* allow_methods;
 
 /**
  * @brief struct returned by the initialization function of the plugin
@@ -56,54 +56,44 @@ struct Plugin
   const struct GNUNET_CONFIGURATION_Handle *cfg;
 };
 
-const struct GNUNET_CONFIGURATION_Handle *cfg;
 
-struct LookupHandle
+struct RequestHandle
 {
-  /**
-   * Handle to GNS service.
-   */
-  struct GNUNET_GNS_Handle *gns;
 
   /**
-   * Desired timeout for the lookup (default is no timeout).
+   * Connection to GNS
    */
-  struct GNUNET_TIME_Relative timeout;
+  struct GNUNET_GNS_Handle *gns;
 
   /**
-   * Handle to lookup request
+   * Active GNS lookup
    */
-  struct GNUNET_GNS_LookupRequest *lookup_request;
+  struct GNUNET_GNS_LookupWithTldRequest *gns_lookup;
 
   /**
-   * Handle to rest request
+   * Name to look up
    */
-  struct GNUNET_REST_RequestHandle *rest_handle;
+  char *name;
 
   /**
-   * Lookup an ego with the identity service.
+   * Record type to look up
    */
-  struct GNUNET_IDENTITY_EgoLookup *el;
+  int record_type;
 
   /**
-   * Handle for identity service.
+   * Rest connection
    */
-  struct GNUNET_IDENTITY_Handle *identity;
-
+  struct GNUNET_REST_RequestHandle *rest_handle;
+  
   /**
-   * Active operation on identity service.
+   * Desired timeout for the lookup (default is no timeout).
    */
-  struct GNUNET_IDENTITY_Operation *id_op;
+  struct GNUNET_TIME_Relative timeout;
 
   /**
    * ID of a task associated with the resolution process.
    */
-  struct GNUNET_SCHEDULER_Task * timeout_task;
-
-  /**
-   * The root of the received JSON or NULL
-   */
-  json_t *json_root;
+  struct GNUNET_SCHEDULER_Task *timeout_task;
 
   /**
    * The plugin result processor
@@ -116,49 +106,17 @@ struct LookupHandle
   void *proc_cls;
 
   /**
-   * The name to look up
-   */
-  char *name;
-
-  /**
-   * The ego to use
-   * In string representation from JSON
-   */
-  const char *ego_str;
-
-  /**
-   * The Pkey to use
-   * In string representation from JSON
-   */
-  const char *pkey_str;
-
-  /**
-   * The record type
+   * The url
    */
-  int type;
+  char *url;
 
   /**
-   * The public key of to use for lookup
+   * Error response message
    */
-  struct GNUNET_CRYPTO_EcdsaPublicKey pkey;
+  char *emsg;
 
   /**
-   * The public key to use for lookup
-   */
-  struct GNUNET_CRYPTO_EcdsaPublicKey pkeym;
-
-  /**
-   * The resolver options
-   */
-  enum GNUNET_GNS_LocalOptions options;
-
-  /**
-   * the shorten key
-   */
-  struct GNUNET_CRYPTO_EcdsaPrivateKey shorten_key;
-
-  /**
-   * HTTP response code
+   * Reponse code
    */
   int response_code;
 
@@ -166,39 +124,20 @@ struct LookupHandle
 
 
 /**
- * Cleanup lookup handle.
- *
+ * Cleanup lookup handle
  * @param handle Handle to clean up
  */
 static void
-cleanup_handle (struct LookupHandle *handle)
+cleanup_handle (void *cls)
 {
+  struct RequestHandle *handle = cls;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Cleaning up\n");
-  if (NULL != handle->json_root)
-    json_decref (handle->json_root);
 
-  if (NULL != handle->name)
-    GNUNET_free (handle->name);
-  if (NULL != handle->el)
-  {
-    GNUNET_IDENTITY_ego_lookup_cancel (handle->el);
-    handle->el = NULL;
-  }
-  if (NULL != handle->id_op)
-  {
-    GNUNET_IDENTITY_cancel (handle->id_op);
-    handle->id_op = NULL;
-  }
-  if (NULL != handle->lookup_request)
-  {
-    GNUNET_GNS_lookup_cancel (handle->lookup_request);
-    handle->lookup_request = NULL;
-  }
-  if (NULL != handle->identity)
+  if (NULL != handle->gns_lookup)
   {
-    GNUNET_IDENTITY_disconnect (handle->identity);
-    handle->identity = NULL;
+    GNUNET_GNS_lookup_with_tld_cancel (handle->gns_lookup);
+    handle->gns_lookup = NULL;
   }
   if (NULL != handle->gns)
   {
@@ -209,387 +148,181 @@ cleanup_handle (struct LookupHandle *handle)
   if (NULL != handle->timeout_task)
   {
     GNUNET_SCHEDULER_cancel (handle->timeout_task);
+    handle->timeout_task = NULL;
   }
+  if (NULL != handle->url)
+    GNUNET_free (handle->url);
+  if (NULL != handle->name)
+    GNUNET_free (handle->name);
+  if (NULL != handle->emsg)
+    GNUNET_free (handle->emsg);
+  
   GNUNET_free (handle);
 }
 
 
 /**
- * Task run on shutdown.  Cleans up everything.
+ * Task run on errors.  Reports an error and cleans up everything.
  *
- * @param cls unused
- * @param tc scheduler context
+ * @param cls the `struct RequestHandle`
  */
 static void
 do_error (void *cls)
 {
-  struct LookupHandle *handle = cls;
+  struct RequestHandle *handle = cls;
   struct MHD_Response *resp;
+  json_t *json_error = json_object();
+  char *response;
 
-  resp = GNUNET_REST_create_response (NULL);
-  handle->proc (handle->proc_cls, resp, handle->response_code);
-  cleanup_handle (handle);
-}
-
+  if (NULL == handle->emsg)
+    handle->emsg = GNUNET_strdup(GNUNET_REST_GNS_ERROR_UNKNOWN);
 
-/**
- * Create json representation of a GNSRECORD
- *
- * @param rd the GNSRECORD_Data
- */
-static json_t *
-gnsrecord_to_json (const struct GNUNET_GNSRECORD_Data *rd)
-{
-  const char *typename;
-  char *string_val;
-  const char *exp_str;
-  json_t *record_obj;
-
-  typename = GNUNET_GNSRECORD_number_to_typename (rd->record_type);
-  string_val = GNUNET_GNSRECORD_value_to_string (rd->record_type,
-                                                 rd->data,
-                                                 rd->data_size);
+  json_object_set_new(json_error,"error", json_string(handle->emsg));
 
-  if (NULL == string_val)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Record of type %d malformed, skipping\n",
-                (int) rd->record_type);
-    return NULL;
-  }
-  record_obj = json_object ();
-  json_object_set_new (record_obj, "type", json_string (typename));
-  json_object_set_new (record_obj, "value", json_string (string_val));
-  GNUNET_free (string_val);
-
-  if (GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION & rd->flags)
-  {
-    struct GNUNET_TIME_Relative time_rel;
-    time_rel.rel_value_us = rd->expiration_time;
-    exp_str = GNUNET_STRINGS_relative_time_to_string (time_rel, 1);
-  }
-  else
-  {
-    struct GNUNET_TIME_Absolute time_abs;
-    time_abs.abs_value_us = rd->expiration_time;
-    exp_str = GNUNET_STRINGS_absolute_time_to_string (time_abs);
-  }
-  json_object_set_new (record_obj, "expiration_time", json_string (exp_str));
-
-  json_object_set_new (record_obj, "expired",
-                       json_boolean (GNUNET_YES == GNUNET_GNSRECORD_is_expired (rd)));
-  return record_obj;
-}
-
-
-static void
-do_cleanup (void *cls)
-{
-  struct LookupHandle *handle = cls;
-  cleanup_handle (handle);
+  if (0 == handle->response_code)
+    handle->response_code = MHD_HTTP_OK;
+  response = json_dumps (json_error, 0);
+  resp = GNUNET_REST_create_response (response);
+  handle->proc (handle->proc_cls, resp, handle->response_code);
+  json_decref(json_error);
+  GNUNET_free(response);
+  GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
 }
 
 
 /**
- * Function called with the result of a GNS lookup.
+ * Iterator called on obtained result for a GNS lookup.
  *
- * @param cls the 'const char *' name that was resolved
- * @param rd_count number of records returned
- * @param rd array of @a rd_count records with the results
+ * @param cls closure with the object
+ * @param was_gns #GNUNET_NO if name was not a GNS name
+ * @param rd_count number of records in @a rd
+ * @param rd the records in reply
  */
 static void
-process_lookup_result (void *cls, uint32_t rd_count,
-                       const struct GNUNET_GNSRECORD_Data *rd)
+handle_gns_response (void *cls,
+                     int was_gns,
+                     uint32_t rd_count,
+                     const struct GNUNET_GNSRECORD_Data *rd)
 {
-  struct LookupHandle *handle = cls;
+  struct RequestHandle *handle = cls;
   struct MHD_Response *resp;
-  struct GNUNET_JSONAPI_Document *json_document;
-  struct GNUNET_JSONAPI_Resource *json_resource;
-  uint32_t i;
-  char *result;
   json_t *result_array;
   json_t *record_obj;
+  char *result;
+
+  handle->gns_lookup = NULL;
+
+  if (GNUNET_NO == was_gns)
+  {
+    handle->emsg = GNUNET_strdup("Name not found in GNS");
+    GNUNET_SCHEDULER_add_now (&do_error, handle);
+    return;
+  }
 
   result_array = json_array();
-  json_document = GNUNET_JSONAPI_document_new ();
-  json_resource = GNUNET_JSONAPI_resource_new (GNUNET_REST_JSONAPI_GNS_TYPEINFO, handle->name);
-  handle->lookup_request = NULL;
-  for (i=0; i<rd_count; i++)
+  for (uint32_t i=0;i<rd_count;i++)
   {
-    if ( (rd[i].record_type != handle->type) &&
-         (GNUNET_GNSRECORD_TYPE_ANY != handle->type) )
+    if ((rd[i].record_type != handle->record_type) &&
+        (GNUNET_GNSRECORD_TYPE_ANY != handle->record_type) )
+    {
       continue;
-    record_obj = gnsrecord_to_json (&(rd[i]));
+    }
+
+    record_obj = GNUNET_JSON_from_gns_record(NULL,&rd[i]);
     json_array_append (result_array, record_obj);
     json_decref (record_obj);
   }
-  GNUNET_JSONAPI_resource_add_attr (json_resource,
-                                         GNUNET_REST_JSONAPI_GNS_RECORD,
-                                         result_array);
-  GNUNET_JSONAPI_document_resource_add (json_document, json_resource);
-  GNUNET_JSONAPI_document_serialize (json_document, &result);
+
+  result = json_dumps(result_array, 0);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result);
-  json_decref (result_array);
-  GNUNET_JSONAPI_document_delete (json_document);
   resp = GNUNET_REST_create_response (result);
   handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
   GNUNET_free (result);
-  GNUNET_SCHEDULER_add_now (&do_cleanup, handle);
+  json_decref (result_array);
+  GNUNET_SCHEDULER_add_now(&cleanup_handle, handle);
 }
 
 
 /**
- * Perform the actual resolution, starting with the zone
- * identified by the given public key and the shorten zone.
+ * Handle gns GET request
  *
- * @param pkey public key to use for the zone, can be NULL
+ * @param con_handle the connection handle
+ * @param url the url
+ * @param cls the RequestHandle
  */
-static void
-lookup_with_public_key (struct LookupHandle *handle)
+void
+get_gns_cont (struct GNUNET_REST_RequestHandle *con_handle,
+              const char* url,
+              void *cls)
 {
-  if (UINT32_MAX == handle->type)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Invalid typename specified, assuming `ANY'\n"));
-    handle->type = GNUNET_GNSRECORD_TYPE_ANY;
-  }
-  if (NULL != handle->name)
-  {
-    handle->lookup_request = GNUNET_GNS_lookup (handle->gns,
-                                                handle->name,
-                                                &handle->pkey,
-                                                handle->type,
-                                                handle->options,
-                                                &process_lookup_result,
-                                                handle);
-  }
-  else
+  struct RequestHandle *handle = cls;
+  struct GNUNET_HashCode key;
+  char *record_type;
+  char *name;
+
+  GNUNET_CRYPTO_hash (GNUNET_REST_GNS_PARAM_NAME,
+                      strlen (GNUNET_REST_GNS_PARAM_NAME),
+                      &key);
+  if ( GNUNET_NO
+       == GNUNET_CONTAINER_multihashmap_contains (con_handle->url_param_map,
+                                                  &key))
   {
+    handle->emsg = GNUNET_strdup("Parameter name is missing");
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
-}
-
-
-/**
- * Method called to with the ego we are to use for the lookup,
- * when the ego is determined by a name.
- *
- * @param cls closure (NULL, unused)
- * @param ego ego handle, NULL if not found
- */
-static void
-identity_zone_cb (void *cls,
-                  const struct GNUNET_IDENTITY_Ego *ego)
-{
-  struct LookupHandle *handle = cls;
-
-  handle->el = NULL;
-  if (NULL == ego)
+  name = GNUNET_CONTAINER_multihashmap_get (con_handle->url_param_map,&key);
+  if(0 >= strlen (name))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Ego for not found, cannot perform lookup.\n"));
+    handle->emsg = GNUNET_strdup("Length of parameter name is zero");
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
-  else
-  {
-    GNUNET_IDENTITY_ego_get_public_key (ego, &handle->pkey);
-    lookup_with_public_key (handle);
-  }
-  json_decref(handle->json_root);
-}
-
+  handle->name = GNUNET_strdup(name);
 
-/**
- * Method called to with the ego we are to use for the lookup,
- * when the ego is the one for the default master zone.
- *
- * @param cls closure (NULL, unused)
- * @param ego ego handle, NULL if not found
- * @param ctx context for application to store data for this ego
- *                 (during the lifetime of this process, initially NULL)
- * @param name name assigned by the user for this ego,
- *                   NULL if the user just deleted the ego and it
- *                   must thus no longer be used
- */
-static void
-identity_master_cb (void *cls,
-                    struct GNUNET_IDENTITY_Ego *ego,
-                    void **ctx,
-                    const char *name)
-{
-  const char *dot;
-  struct LookupHandle *handle = cls;
-
-  handle->id_op = NULL;
-  if (NULL == ego)
+  handle->record_type = UINT32_MAX;
+  GNUNET_CRYPTO_hash (GNUNET_REST_GNS_PARAM_RECORD_TYPE,
+                      strlen (GNUNET_REST_GNS_PARAM_RECORD_TYPE),
+                      &key);
+  if ( GNUNET_YES
+       == GNUNET_CONTAINER_multihashmap_contains (con_handle->url_param_map,
+                                                  &key))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Ego for `gns-master' not found, cannot perform lookup.  Did you run gnunet-gns-import.sh?\n"));
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
+    record_type = GNUNET_CONTAINER_multihashmap_get (con_handle->url_param_map, &key);
+    handle->record_type = GNUNET_GNSRECORD_typename_to_number(record_type);
   }
-  GNUNET_IDENTITY_ego_get_public_key (ego,
-                                      &handle->pkey);
-  /* main name is our own master zone, do no look for that in the DHT */
-  handle->options = GNUNET_GNS_LO_LOCAL_MASTER;
-  /* if the name is of the form 'label.gnu', never go to the DHT */
-  dot = NULL;
-  if (NULL != handle->name)
-    dot = strchr (handle->name, '.');
-  if ( (NULL != dot) &&
-       (0 == strcasecmp (dot, ".gnu")) )
-    handle->options = GNUNET_GNS_LO_NO_DHT;
-  lookup_with_public_key (handle);
-}
-
-/**
- * Parse REST uri for name and record type
- *
- * @param url Url to parse
- * @param handle lookup handle to populate
- * @return GNUNET_SYSERR on error
- */
-static int
-parse_url (const char *url, struct LookupHandle *handle)
-{
-  char *name;
-  char tmp_url[strlen(url)+1];
-  char *tok;
-
-  strcpy (tmp_url, url);
-  tok = strtok ((char*)tmp_url, "/");
-  if (NULL == tok)
-    return GNUNET_SYSERR;
-  name = strtok (NULL, "/");
-  if (NULL == name)
-    return GNUNET_SYSERR;
-  GNUNET_asprintf (&handle->name,
-                   "%s",
-                   name);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Got name: %s\n", handle->name);
-  return GNUNET_OK;
-}
-
 
-static void
-get_gns_cont (struct GNUNET_REST_RequestHandle *conndata_handle,
-              const char* url,
-              void *cls)
-{
-  struct LookupHandle *handle = cls;
-  struct GNUNET_HashCode key;
 
-  //parse name and type from url
-  if (GNUNET_OK != parse_url (url, handle))
+  if(UINT32_MAX == handle->record_type)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error parsing url...\n");
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
+    handle->record_type = GNUNET_GNSRECORD_TYPE_ANY;
   }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Connecting...\n");
+
   handle->gns = GNUNET_GNS_connect (cfg);
-  handle->identity = GNUNET_IDENTITY_connect (cfg, NULL, NULL);
-  handle->timeout_task = GNUNET_SCHEDULER_add_delayed (handle->timeout,
-                                                       &do_error, handle);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Connected\n");
   if (NULL == handle->gns)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Connecting to GNS failed\n");
+    handle->emsg = GNUNET_strdup ("GNS not available");
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
-  GNUNET_CRYPTO_hash (GNUNET_REST_JSONAPI_GNS_OPTIONS,
-                      strlen (GNUNET_REST_JSONAPI_GNS_OPTIONS),
-                      &key);
-  handle->options = GNUNET_GNS_LO_DEFAULT;
-  if ( GNUNET_YES ==
-       GNUNET_CONTAINER_multihashmap_contains (conndata_handle->url_param_map,
-                                               &key) )
-  {
-    handle->options = GNUNET_GNS_LO_DEFAULT;//TODO(char*) GNUNET_CONTAINER_multihashmap_get (conndata_handle->url_param_map,
-    //&key);
-  }
-  GNUNET_CRYPTO_hash (GNUNET_REST_JSONAPI_GNS_RECORD_TYPE,
-                      strlen (GNUNET_REST_JSONAPI_GNS_RECORD_TYPE),
-                      &key);
-  if ( GNUNET_YES ==
-       GNUNET_CONTAINER_multihashmap_contains (conndata_handle->url_param_map,
-                                               &key) )
-  {
-    handle->type = GNUNET_GNSRECORD_typename_to_number
-      (GNUNET_CONTAINER_multihashmap_get (conndata_handle->url_param_map,
-                                          &key));
-  }
-  else
-    handle->type = GNUNET_GNSRECORD_TYPE_ANY;
 
-  GNUNET_CRYPTO_hash (GNUNET_REST_JSONAPI_GNS_PKEY,
-                      strlen (GNUNET_REST_JSONAPI_GNS_PKEY),
-                      &key);
-  if ( GNUNET_YES ==
-       GNUNET_CONTAINER_multihashmap_contains (conndata_handle->url_param_map,
-                                               &key) )
-  {
-    handle->pkey_str = GNUNET_CONTAINER_multihashmap_get (conndata_handle->url_param_map,
-                                                          &key);
-    GNUNET_assert (NULL != handle->pkey_str);
-    if (GNUNET_OK !=
-        GNUNET_CRYPTO_ecdsa_public_key_from_string (handle->pkey_str,
-                                                    strlen(handle->pkey_str),
-                                                    &(handle->pkey)))
-    {
-      GNUNET_SCHEDULER_add_now (&do_error, handle);
-      return;
-    }
-    lookup_with_public_key (handle);
-    return;
-  }
-  GNUNET_CRYPTO_hash (GNUNET_REST_JSONAPI_GNS_EGO,
-                      strlen (GNUNET_REST_JSONAPI_GNS_EGO),
-                      &key);
-  if ( GNUNET_YES ==
-       GNUNET_CONTAINER_multihashmap_contains (conndata_handle->url_param_map,
-                                               &key) )
-  {
-    handle->ego_str = GNUNET_CONTAINER_multihashmap_get (conndata_handle->url_param_map,
-                                                         &key);
-    handle->el = GNUNET_IDENTITY_ego_lookup (cfg,
-                                             handle->ego_str,
-                                             &identity_zone_cb,
-                                             handle);
-    return;
-  }
-  if ( (NULL != handle->name) &&
-       (strlen (handle->name) > 4) &&
-       (0 == strcmp (".zkey",
-                     &handle->name[strlen (handle->name) - 4])) )
-  {
-    GNUNET_CRYPTO_ecdsa_key_get_public
-      (GNUNET_CRYPTO_ecdsa_key_get_anonymous (),
-       &(handle->pkey));
-    lookup_with_public_key (handle);
-  }
-  else
-  {
-    GNUNET_break (NULL == handle->id_op);
-    handle->id_op = GNUNET_IDENTITY_get (handle->identity,
-                                         "gns-master",
-                                         &identity_master_cb,
-                                         handle);
-    GNUNET_assert (NULL != handle->id_op);
-  }
+  handle->gns_lookup = GNUNET_GNS_lookup_with_tld (handle->gns,
+                                                   handle->name,
+                                                   handle->record_type,
+                                                   GNUNET_NO,
+                                                   &handle_gns_response,
+                                                   handle);
+  return;
 }
 
+
+
 /**
- * Handle rest request
+ * Respond to OPTIONS request
  *
- * @param handle the lookup handle
+ * @param con_handle the connection handle
+ * @param url the url
+ * @param cls the RequestHandle
  */
 static void
 options_cont (struct GNUNET_REST_RequestHandle *con_handle,
@@ -597,53 +330,38 @@ options_cont (struct GNUNET_REST_RequestHandle *con_handle,
               void *cls)
 {
   struct MHD_Response *resp;
-  struct LookupHandle *handle = cls;
+  struct RequestHandle *handle = cls;
 
-  //For GNS, independent of path return all options
+  //independent of path return all options
   resp = GNUNET_REST_create_response (NULL);
   MHD_add_response_header (resp,
                            "Access-Control-Allow-Methods",
-                           MHD_HTTP_METHOD_GET);
-  handle->proc (handle->proc_cls,
-                resp,
-                MHD_HTTP_OK);
-  cleanup_handle (handle);
+                           allow_methods);
+  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
+  GNUNET_SCHEDULER_add_now(&cleanup_handle, handle);
+  return;
 }
 
 
 /**
- * Function processing the REST call
+ * Handle rest request
  *
- * @param method HTTP method
- * @param url URL of the HTTP request
- * @param data body of the HTTP request (optional)
- * @param data_size length of the body
- * @param proc callback function for the result
- * @param proc_cls closure for @a proc
- * @return #GNUNET_OK if request accepted
+ * @param handle the request handle
  */
 static void
-rest_gns_process_request (struct GNUNET_REST_RequestHandle *conndata_handle,
-                          GNUNET_REST_ResultProcessor proc,
-                          void *proc_cls)
+init_cont (struct RequestHandle *handle)
 {
+  struct GNUNET_REST_RequestHandlerError err;
   static const struct GNUNET_REST_RequestHandler handlers[] = {
     {MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_GNS, &get_gns_cont},
     {MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_GNS, &options_cont},
     GNUNET_REST_HANDLER_END
   };
-  struct LookupHandle *handle = GNUNET_new (struct LookupHandle);
-  struct GNUNET_REST_RequestHandlerError err;
-
-  handle->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
-  handle->proc_cls = proc_cls;
-  handle->proc = proc;
-  handle->rest_handle = conndata_handle;
 
-  if (GNUNET_NO == GNUNET_JSONAPI_handle_request (conndata_handle,
-                                                  handlers,
-                                                  &err,
-                                                  handle))
+  if (GNUNET_NO == GNUNET_REST_handle_request (handle->rest_handle,
+                                               handlers,
+                                               &err,
+                                               handle))
   {
     handle->response_code = err.error_code;
     GNUNET_SCHEDULER_add_now (&do_error, handle);
@@ -652,18 +370,58 @@ rest_gns_process_request (struct GNUNET_REST_RequestHandle *conndata_handle,
 
 
 /**
+ * Function processing the REST call
+ *
+ * @param method HTTP method
+ * @param url URL of the HTTP request
+ * @param data body of the HTTP request (optional)
+ * @param data_size length of the body
+ * @param proc callback function for the result
+ * @param proc_cls closure for callback function
+ * @return GNUNET_OK if request accepted
+ */
+static void
+rest_process_request(struct GNUNET_REST_RequestHandle *rest_handle,
+                     GNUNET_REST_ResultProcessor proc,
+                     void *proc_cls)
+{
+  struct RequestHandle *handle = GNUNET_new (struct RequestHandle);
+
+  handle->response_code = 0;
+  handle->timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60);
+  handle->proc_cls = proc_cls;
+  handle->proc = proc;
+  handle->rest_handle = rest_handle;
+
+  handle->url = GNUNET_strdup (rest_handle->url);
+  if (handle->url[strlen (handle->url)-1] == '/')
+    handle->url[strlen (handle->url)-1] = '\0';
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting...\n");
+
+  init_cont(handle);
+
+  handle->timeout_task =
+    GNUNET_SCHEDULER_add_delayed (handle->timeout,
+                                  &do_error,
+                                  handle);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connected\n");
+}
+
+
+/**
  * Entry point for the plugin.
  *
- * @param cls the "struct GNUNET_NAMESTORE_PluginEnvironment*"
+ * @param cls Config info
  * @return NULL on error, otherwise the plugin context
  */
 void *
 libgnunet_plugin_rest_gns_init (void *cls)
 {
   static struct Plugin plugin;
-  cfg = cls;
   struct GNUNET_REST_Plugin *api;
 
+  cfg = cls;
   if (NULL != plugin.cfg)
     return NULL;                /* can only initialize once! */
   memset (&plugin, 0, sizeof (struct Plugin));
@@ -671,9 +429,17 @@ libgnunet_plugin_rest_gns_init (void *cls)
   api = GNUNET_new (struct GNUNET_REST_Plugin);
   api->cls = &plugin;
   api->name = GNUNET_REST_API_NS_GNS;
-  api->process_request = &rest_gns_process_request;
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              _("GNS REST API initialized\n"));
+  api->process_request = &rest_process_request;
+  GNUNET_asprintf (&allow_methods,
+                   "%s, %s, %s, %s, %s",
+                   MHD_HTTP_METHOD_GET,
+                   MHD_HTTP_METHOD_POST,
+                   MHD_HTTP_METHOD_PUT,
+                   MHD_HTTP_METHOD_DELETE,
+                   MHD_HTTP_METHOD_OPTIONS);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              _("Gns REST API initialized\n"));
   return api;
 }
 
@@ -689,12 +455,14 @@ libgnunet_plugin_rest_gns_done (void *cls)
 {
   struct GNUNET_REST_Plugin *api = cls;
   struct Plugin *plugin = api->cls;
-
   plugin->cfg = NULL;
+
+  GNUNET_free_non_null (allow_methods);
   GNUNET_free (api);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "GNS REST plugin is finished\n");
+              "Gns REST plugin is finished\n");
   return NULL;
 }
 
 /* end of plugin_rest_gns.c */
+