-fixes, added get_authority api

5 files changed, 451 insertions, 18 deletions

diff --git a/src/gns/gns.h b/src/gns/gns.h
index e0cb0fd29..aad36ebfe 100644
--- a/src/gns/gns.h
+++ b/src/gns/gns.h
@@ -81,7 +81,7 @@ struct GNUNET_GNS_ClientLookupResultMessage
 };
 
 /**
- * Message from client to GNS service to lookup records.
+ * Message from client to GNS service to shorten names.
  */
 struct GNUNET_GNS_ClientShortenMessage
 {
@@ -117,6 +117,44 @@ struct GNUNET_GNS_ClientShortenResultMessage
   /* followed by the shortened name or '\0' for no result*/
 
 };
+
+/**
+ * Message from client to GNS service to lookup an authority of a name.
+ */
+struct GNUNET_GNS_ClientGetAuthMessage
+{
+  /**
+    * Header of type GNUNET_MESSAGE_TYPE_GNS_CLIENT_GET_AUTH
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Unique identifier for this request
+   */
+  uint32_t id GNUNET_PACKED;
+
+  /* Followed by the name to get authority for */
+};
+
+
+/**
+ * Message from GNS service to client: authority result.
+ */
+struct GNUNET_GNS_ClientGetAuthResultMessage
+{
+  /**
+    * Header of type GNUNET_MESSAGE_TYPE_GNS_CLIENT_GET_AUTH_RESULT
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Unique identifier for this request (for key collisions).
+   */
+  uint32_t id GNUNET_PACKED;
+
+  /* followed by the authority part of the name or '\0' for no result*/
+
+};
 GNUNET_NETWORK_STRUCT_END
 
 #endif
diff --git a/src/gns/gns_api.c b/src/gns/gns_api.c
index f9aa63335..be1ba58f7 100644
--- a/src/gns/gns_api.c
+++ b/src/gns/gns_api.c
@@ -40,6 +40,8 @@
 #define GNUNET_MESSAGE_TYPE_GNS_LOOKUP_RESULT 24
 #define GNUNET_MESSAGE_TYPE_GNS_SHORTEN 25
 #define GNUNET_MESSAGE_TYPE_GNS_SHORTEN_RESULT 26
+#define GNUNET_MESSAGE_TYPE_GNS_GET_AUTH 27
+#define GNUNET_MESSAGE_TYPE_GNS_GET_AUTH_RESULT 28
 
 /**
  * A QueueEntry.
@@ -67,6 +69,9 @@ struct GNUNET_GNS_QueueEntry
   
   /* processor to call on lookup result */
   GNUNET_GNS_LookupResultProcessor lookup_proc;
+
+  /* processor to call on authority lookup result */
+  GNUNET_GNS_GetAuthResultProcessor auth_proc;
   
   /* processor closure */
   void *proc_cls;
@@ -151,6 +156,16 @@ struct GNUNET_GNS_Handle
   struct GNUNET_GNS_QueueEntry *lookup_tail;
   
   /**
+   * Head of linked list of authority lookup messages we would like to transmit.
+   */
+  struct GNUNET_GNS_QueueEntry *get_auth_head;
+
+  /**
+   * Tail of linked list of authority lookup messages we would like to transmit.
+   */
+  struct GNUNET_GNS_QueueEntry *get_auth_tail;
+
+  /**
    * Reconnect task
    */
   GNUNET_SCHEDULER_TaskIdentifier reconnect_task;
@@ -360,6 +375,39 @@ process_shorten_reply (struct GNUNET_GNS_QueueEntry *qe,
 
 
 /**
+ * Process a given reply that might match the given
+ * request.
+ *
+ * @param qe the handle to the request
+ * @param msg the message to process
+ */
+static void
+process_get_auth_reply (struct GNUNET_GNS_QueueEntry *qe,
+                       const struct GNUNET_GNS_ClientGetAuthResultMessage *msg)
+{
+  struct GNUNET_GNS_Handle *h = qe->gns_handle;
+  const char *auth_name;
+
+  GNUNET_CONTAINER_DLL_remove(h->get_auth_head, h->get_auth_tail, qe);
+
+  auth_name = (char*)(&msg[1]);
+
+  if (ntohs (((struct GNUNET_MessageHeader*)msg)->size) <
+      sizeof (struct GNUNET_GNS_ClientGetAuthResultMessage))
+  {
+    GNUNET_break (0);
+    force_reconnect (h);
+    return;
+  }
+  
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received GET_AUTH reply `%s' from GNS service\n",
+              auth_name);
+  
+  qe->auth_proc(qe->proc_cls, auth_name);
+
+}
+/**
  * Process a given reply to the lookup request
  *
  * @param cls the 'struct GNUNET_GNS_ClientResultMessage'
@@ -412,6 +460,7 @@ process_message (void *cls, const struct GNUNET_MessageHeader *msg)
   struct GNUNET_GNS_QueueEntry *qe;
   const struct GNUNET_GNS_ClientLookupResultMessage *lookup_msg;
   const struct GNUNET_GNS_ClientShortenResultMessage *shorten_msg;
+  const struct GNUNET_GNS_ClientGetAuthResultMessage *get_auth_msg;
   uint16_t size;
   uint16_t type;
   uint32_t r_id;
@@ -457,7 +506,7 @@ process_message (void *cls, const struct GNUNET_MessageHeader *msg)
   else if (type == GNUNET_MESSAGE_TYPE_GNS_SHORTEN_RESULT)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Got shorten msg\n");
+                "Got SHORTEN_RESULT msg\n");
     shorten_msg = (struct GNUNET_GNS_ClientShortenResultMessage *) msg;
     
     r_id = ntohl (shorten_msg->id);
@@ -478,6 +527,30 @@ process_message (void *cls, const struct GNUNET_MessageHeader *msg)
     if (qe)
       process_shorten_reply(qe, shorten_msg);
   }
+  else if (type == GNUNET_MESSAGE_TYPE_GNS_GET_AUTH_RESULT)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Got GET_AUTH_RESULT msg\n");
+    get_auth_msg = (struct GNUNET_GNS_ClientGetAuthResultMessage *) msg;
+
+    r_id = ntohl (get_auth_msg->id);
+
+    if (r_id > handle->r_id)
+    {
+      /** no request found */
+      GNUNET_break_op (0);
+      GNUNET_CLIENT_receive (handle->client, &process_message, handle,
+                             GNUNET_TIME_UNIT_FOREVER_REL);
+    }
+
+    for (qe = handle->get_auth_head; qe != NULL; qe = qe->next)
+    {
+      if (qe->r_id == r_id)
+        break;
+    }
+    if (qe)
+      process_get_auth_reply(qe, get_auth_msg);
+  }
 
   GNUNET_CLIENT_receive (handle->client, &process_message, handle,
                          GNUNET_TIME_UNIT_FOREVER_REL);
@@ -651,5 +724,61 @@ GNUNET_GNS_shorten (struct GNUNET_GNS_Handle *handle,
 }
 
 
+/**
+ * Perform an authority lookup for a given name.
+ *
+ * @param handle handle to the GNS service
+ * @param name the name to look up authority for
+ * @param proc function to call on result
+ * @param proc_cls closure for processor
+ * @return handle to the operation
+ */
+struct GNUNET_GNS_QueueEntry *
+GNUNET_GNS_get_authority (struct GNUNET_GNS_Handle *handle,
+                    const char * name,
+                    GNUNET_GNS_GetAuthResultProcessor proc,
+                    void *proc_cls)
+{
+  struct GNUNET_GNS_ClientGetAuthMessage *get_auth_msg;
+  struct GNUNET_GNS_QueueEntry *qe;
+  size_t msize;
+  struct PendingMessage *pending;
+
+  if (NULL == name)
+  {
+    return NULL;
+  }
+
+  msize = sizeof (struct GNUNET_GNS_ClientGetAuthMessage) + strlen(name) + 1;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Trying to look up authority for %s in GNS\n", name);
+
+  qe = GNUNET_malloc(sizeof (struct GNUNET_GNS_QueueEntry));
+  qe->gns_handle = handle;
+  qe->shorten_proc = proc;
+  qe->proc_cls = proc_cls;
+  qe->r_id = get_request_id(handle);
+  GNUNET_CONTAINER_DLL_insert_tail(handle->get_auth_head,
+                                   handle->get_auth_tail, qe);
+
+  pending = GNUNET_malloc (sizeof (struct PendingMessage) + msize);
+  memset(pending, 0, (sizeof (struct PendingMessage) + msize));
+  
+  pending->size = msize;
+
+  get_auth_msg = (struct GNUNET_GNS_ClientGetAuthMessage *) &pending[1];
+  get_auth_msg->header.type = htons (GNUNET_MESSAGE_TYPE_GNS_GET_AUTH);
+  get_auth_msg->header.size = htons (msize);
+  get_auth_msg->id = htonl(qe->r_id);
+
+  memcpy(&get_auth_msg[1], name, strlen(name));
+
+  GNUNET_CONTAINER_DLL_insert (handle->pending_head, handle->pending_tail,
+                               pending);
+  
+  process_pending_messages (handle);
+  return qe;
+}
+
 
 /* end of gns_api.c */
diff --git a/src/gns/gnunet-service-gns.c b/src/gns/gnunet-service-gns.c
index 072c349da..8d9932ead 100644
--- a/src/gns/gnunet-service-gns.c
+++ b/src/gns/gnunet-service-gns.c
@@ -44,11 +44,13 @@
 #define DHT_GNS_REPLICATION_LEVEL 5
 #define MAX_DNS_LABEL_LENGTH 63
 
-/* Ignore for now not used anyway and probably never will */
+/* FIXME move to proper header in include */
 #define GNUNET_MESSAGE_TYPE_GNS_LOOKUP 23
 #define GNUNET_MESSAGE_TYPE_GNS_LOOKUP_RESULT 24
 #define GNUNET_MESSAGE_TYPE_GNS_SHORTEN 25
 #define GNUNET_MESSAGE_TYPE_GNS_SHORTEN_RESULT 26
+#define GNUNET_MESSAGE_TYPE_GNS_GET_AUTH 27
+#define GNUNET_MESSAGE_TYPE_GNS_GET_AUTH_RESULT 28
 
 
 struct AuthorityChain
@@ -177,6 +179,24 @@ struct ClientShortenHandle
 
 };
 
+
+/**
+ * Handle to a get auhtority operation from api
+ */
+struct ClientGetAuthHandle
+{
+  /* the requesting client that */
+  struct GNUNET_SERVER_Client *client;
+
+  /* request id */
+  uint64_t unique_id;
+
+  /* name to lookup authority */
+  char* name;
+
+};
+
+
 /**
  * Handle to a lookup operation from api
  */
@@ -2097,10 +2117,8 @@ handle_shorten_delegation_result(void* cls,
     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
                "Our zone: Sending name as shorten result %s\n", rh->name);
     
-    send_shorten_response(rh->name, csh); //FIXME +.gnunet!
+    send_shorten_response(result, csh); //FIXME +.gnunet!
     free_resolver_handle(rh);
-    GNUNET_free(csh->name);
-    GNUNET_free(csh);
     GNUNET_free(result);
     return;
   }
@@ -2145,9 +2163,9 @@ shorten_name(char* name, struct ClientShortenHandle* csh)
 
   csh->name = GNUNET_malloc(strlen(name)
                             - strlen(gnunet_tld) + 1);
-  memset(rh->name, 0,
+  memset(csh->name, 0,
          strlen(name)-strlen(gnunet_tld) + 1);
-  memcpy(rh->name, name,
+  memcpy(csh->name, name,
          strlen(name)-strlen(gnunet_tld));
 
   rh->authority_name = GNUNET_malloc(sizeof(char)*MAX_DNS_LABEL_LENGTH);
@@ -2248,6 +2266,211 @@ static void handle_shorten(void *cls,
 
 }
 
+
+/**
+ * Send get authority response back to client
+ * 
+ * @param name the shortened name result or NULL if cannot be shortened
+ * @param cah the handle to the get authority request
+ */
+static void
+send_get_auth_response(const char* name, struct ClientGetAuthHandle *cah)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message with %s\n",
+              "GET_AUTH_RESULT", name);
+  struct GNUNET_GNS_ClientGetAuthResultMessage *rmsg;
+  
+  if (name == NULL)
+  {
+    name = "";
+  }
+
+  rmsg = GNUNET_malloc(sizeof(struct GNUNET_GNS_ClientGetAuthResultMessage)
+                       + strlen(name) + 1);
+  
+  rmsg->id = cah->unique_id;
+  rmsg->header.type = htons(GNUNET_MESSAGE_TYPE_GNS_GET_AUTH_RESULT);
+  rmsg->header.size = 
+    htons(sizeof(struct GNUNET_GNS_ClientGetAuthResultMessage) +
+          strlen(name) + 1);
+
+  strcpy((char*)&rmsg[1], name);
+
+  GNUNET_SERVER_notification_context_unicast (nc, cah->client,
+                              (const struct GNUNET_MessageHeader *) rmsg,
+                              GNUNET_NO);
+  GNUNET_SERVER_receive_done (cah->client, GNUNET_OK);
+  
+  GNUNET_free(rmsg);
+  GNUNET_free(cah->name);
+  GNUNET_free(cah);
+
+}
+
+/**
+ * Process result from namestore delegation lookup
+ * for get authority operation
+ *
+ * @param cls the client get auth handle
+ * @param rh the resolver handle
+ * @param rd_count number of results (0)
+ * @param rd data (NULL)
+ */
+void
+handle_get_auth_delegation_result(void* cls,
+                      struct GNUNET_GNS_ResolverHandle *rh,
+                      uint32_t rd_count,
+                      const struct GNUNET_NAMESTORE_RecordData *rd)
+{
+  struct ClientGetAuthHandle* cah = (struct ClientGetAuthHandle*) cls;
+  struct AuthorityChain *auth_chain;
+  char* result;
+  size_t answer_len;
+  
+  /**
+   * At this point rh->name contains the part of the name
+   * that we do not have a PKEY in our namestore to resolve.
+   * The authority chain in the resolver handle is now
+   * useful to backtrack if needed
+   */
+  
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "PKEY resolved as far as possible in ns up to %s!\n", rh->name);
+
+  if (is_canonical(rh->name))
+  {
+    /**
+     * We successfully resolved the authority in the ns
+     * FIXME for our purposes this is fine
+     * but maybe we want to have an api that also looks
+     * into the dht (i.e. option in message)
+     **/
+    if (strlen(rh->name) > strlen(cah->name))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Record name longer than original lookup name... odd!\n");
+      //FIXME to sth here
+    }
+
+
+    answer_len = strlen(cah->name) - strlen(rh->name);
+    result = GNUNET_malloc(answer_len);
+    memset(result, 0, answer_len);
+    strcpy(result, cah->name + strlen(rh->name) + 1);
+
+    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+               "Our zone: Sending authority result %s\n", result);
+    
+    send_get_auth_response(result, cah);
+    free_resolver_handle(rh);
+    GNUNET_free(result);
+    return;
+  }
+  
+  auth_chain = rh->authority_chain_head;
+  /* backtrack authorities for pseu */
+  GNUNET_NAMESTORE_zone_to_name (namestore_handle,
+                                 &zone_hash, //ours
+                                 &auth_chain->zone,
+                                 &handle_shorten_zone_to_name,
+                                 rh);
+
+}
+
+
+/**
+ * Get authority for a given name
+ *
+ * @param name the name to shorten
+ * @param csh the shorten handle of the request
+ */
+static void
+get_authority(char* name, struct ClientGetAuthHandle* cah)
+{
+
+  struct GNUNET_GNS_ResolverHandle *rh;
+  
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Starting authority resolution for %s (type=%d)!\n",
+              name, GNUNET_GNS_RECORD_PKEY);
+  
+  rh = GNUNET_malloc(sizeof (struct GNUNET_GNS_ResolverHandle));
+  rh->authority = zone_hash;
+  
+  rh->name = GNUNET_malloc(strlen(name)
+                              - strlen(gnunet_tld) + 1);
+  memset(rh->name, 0,
+         strlen(name)-strlen(gnunet_tld) + 1);
+  memcpy(rh->name, name,
+         strlen(name)-strlen(gnunet_tld));
+
+  cah->name = GNUNET_malloc(strlen(name)
+                            - strlen(gnunet_tld) + 1);
+  memset(cah->name, 0,
+         strlen(name)-strlen(gnunet_tld) + 1);
+  memcpy(cah->name, name,
+         strlen(name)-strlen(gnunet_tld));
+
+  rh->authority_name = GNUNET_malloc(sizeof(char)*MAX_DNS_LABEL_LENGTH);
+
+  rh->authority_chain_head = GNUNET_malloc(sizeof(struct AuthorityChain));
+  rh->authority_chain_tail = rh->authority_chain_head;
+  rh->authority_chain_head->zone = zone_hash;
+  rh->proc = &handle_get_auth_delegation_result;
+  rh->proc_cls = (void*)cah;
+
+  /* Start delegation resolution in our namestore */
+  resolve_delegation_ns(rh);
+
+}
+
+
+/**
+ * Handle a get authority message from the api
+ *
+ * @param cls the closure
+ * @param client the client
+ * @param message the message
+ */
+static void handle_get_authority(void *cls,
+                           struct GNUNET_SERVER_Client * client,
+                           const struct GNUNET_MessageHeader * message)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "GET_AUTH");
+
+  size_t msg_size = 0;
+  struct ClientGetAuthHandle *cah;
+
+  if (ntohs (message->size) < sizeof (struct GNUNET_GNS_ClientGetAuthMessage))
+  {
+    GNUNET_break_op (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_OK);
+    return;
+  }
+
+  GNUNET_SERVER_notification_context_add (nc, client);
+
+  struct GNUNET_GNS_ClientGetAuthMessage *sh_msg =
+    (struct GNUNET_GNS_ClientGetAuthMessage *) message;
+  
+  msg_size = ntohs(message->size);
+
+  if (msg_size > GNUNET_SERVER_MAX_MESSAGE_SIZE)
+  {
+    GNUNET_break_op (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_OK);
+    return;
+  }
+
+  cah = GNUNET_malloc(sizeof(struct ClientGetAuthHandle));
+  cah->client = client;
+  cah->unique_id = sh_msg->id;
+  
+  get_authority((char*)&sh_msg[1], cah);
+
+}
+
+
 /**
  * Reply to client with the result from our lookup.
  *
@@ -2390,6 +2613,8 @@ handle_lookup(void *cls,
   lookup_name((char*)&sh_msg[1], clh);
 }
 
+
+
 /**
  * Process GNS requests.
  *
@@ -2409,7 +2634,8 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
 
   static const struct GNUNET_SERVER_MessageHandler handlers[] = {
     {&handle_shorten, NULL, GNUNET_MESSAGE_TYPE_GNS_SHORTEN, 0},
-    {&handle_lookup, NULL, GNUNET_MESSAGE_TYPE_GNS_LOOKUP, 0}
+    {&handle_lookup, NULL, GNUNET_MESSAGE_TYPE_GNS_LOOKUP, 0},
+    {&handle_get_authority, NULL, GNUNET_MESSAGE_TYPE_GNS_GET_AUTH, 0}
   };
 
   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (c, "gns",
diff --git a/src/gns/plugin_block_gns.c b/src/gns/plugin_block_gns.c
index fd6fcc250..4c8ab3eb9 100644
--- a/src/gns/plugin_block_gns.c
+++ b/src/gns/plugin_block_gns.c
@@ -72,6 +72,7 @@ block_plugin_gns_evaluate (void *cls, enum GNUNET_BLOCK_Type type,
   uint32_t rd_count;
   char* rd_data = NULL;
   int rd_len;
+  uint32_t record_xquery;
   unsigned int record_match;
 
   if (type != GNUNET_BLOCK_TYPE_GNS_NAMERECORD)
@@ -102,7 +103,7 @@ block_plugin_gns_evaluate (void *cls, enum GNUNET_BLOCK_Type type,
   {
     struct GNUNET_NAMESTORE_RecordData rd[rd_count];
     unsigned int i;
-    uint32_t record_xquery = ntohl(*((uint32_t*)xquery));
+    struct GNUNET_TIME_Absolute exp = GNUNET_TIME_absolute_get_forever();
     
     if (GNUNET_SYSERR == GNUNET_NAMESTORE_records_deserialize (rd_len,
                                                                rd_data,
@@ -113,18 +114,26 @@ block_plugin_gns_evaluate (void *cls, enum GNUNET_BLOCK_Type type,
                  "Data invalid (%d bytes, %d records)\n", rd_len, rd_count);
       return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
     }
+
+    if (xquery_size < sizeof(uint32_t))
+      record_xquery = 0;
+    else
+      record_xquery = ntohl(*((uint32_t*)xquery));
     
     for (i=0; i<rd_count; i++)
     {
-      if (xquery_size < sizeof(uint32_t))
-        continue;
       
-      if (rd[i].record_type == record_xquery)
+      exp = GNUNET_TIME_absolute_min (exp, rd[i].expiration);
+
+      if ((record_xquery != 0)
+          && (rd[i].record_type == record_xquery))
+      {
         record_match++;
+      }
     }
 
     if (GNUNET_OK != GNUNET_NAMESTORE_verify_signature (&nrb->public_key,
-                                                        GNUNET_TIME_absolute_get_forever(),
+                                                        exp,
                                                         name,
                                                         rd_count,
                                                         rd,
@@ -136,7 +145,7 @@ block_plugin_gns_evaluate (void *cls, enum GNUNET_BLOCK_Type type,
   }
   
   //No record matches query
-  if ((xquery_size > 0) && (record_match == 0))
+  if ((record_xquery != 0) && (record_match == 0))
     return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
 
   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Records match\n");
diff --git a/src/include/gnunet_gns_service.h b/src/include/gnunet_gns_service.h
index 5ae7fbefe..66cbab820 100644
--- a/src/include/gnunet_gns_service.h
+++ b/src/include/gnunet_gns_service.h
@@ -145,7 +145,6 @@ GNUNET_GNS_lookup (struct GNUNET_GNS_Handle *handle,
  * called only once
  *
  * @param cls closure
- * @param name "name" of the original lookup
  * @param short_name the shortened name or NULL if no result
  */
 typedef void (*GNUNET_GNS_ShortenResultProcessor) (void *cls,
@@ -158,7 +157,7 @@ typedef void (*GNUNET_GNS_ShortenResultProcessor) (void *cls,
  * @param handle handle to the GNS service
  * @param name the name to shorten
  * @param proc processor to call on result
- * @param iter_cls closure for processor
+ * @param cls closure for processor
  *
  * @return handle to the shorten operation
  */
@@ -166,7 +165,39 @@ struct GNUNET_GNS_QueueEntry *
 GNUNET_GNS_shorten (struct GNUNET_GNS_Handle *handle,
                          const char * name,
                          GNUNET_GNS_ShortenResultProcessor proc,
-                         void *iter_cls);
+                         void *cls);
+
+
+/* *************** Standard API: get authority ******************* */
+
+
+/**
+ * Processor called on for a name shortening result
+ * called only once
+ *
+ * @param cls closure
+ * @param auth_name the name of the auhtority or NULL
+ */
+typedef void (*GNUNET_GNS_GetAuthResultProcessor) (void *cls,
+                                        const char* short_name);
+
+
+/**
+ * Perform a shorten operation on name using the GNS.
+ *
+ * @param handle handle to the GNS service
+ * @param name the name to look up authority for
+ * @param proc processor to call on result
+ * @param cls closure for processor
+ *
+ * @return handle to the get authority operation
+ */
+struct GNUNET_GNS_QueueEntry *
+GNUNET_GNS_get_authority (struct GNUNET_GNS_Handle *handle,
+                         const char * name,
+                         GNUNET_GNS_GetAuthResultProcessor proc,
+                         void *cls);
+
 #if 0                           /* keep Emacsens' auto-indent happy */
 {
 #endif