[GNUnet-SVN] r10654 - gnunet/src/transport

[gnunet]

Author: grothoff
Date: 2010-03-18 15:46:42 +0100 (Thu, 18 Mar 2010)
New Revision: 10654

Modified:
   gnunet/src/transport/Makefile.am
   gnunet/src/transport/gnunet-service-transport.c
   gnunet/src/transport/transport_api_address_lookup.c
Log:
address resolution API implementation

Modified: gnunet/src/transport/Makefile.am
===================================================================
--- gnunet/src/transport/Makefile.am    2010-03-18 14:33:34 UTC (rev 10653)
+++ gnunet/src/transport/Makefile.am    2010-03-18 14:46:42 UTC (rev 10654)
@@ -23,7 +23,8 @@
 
 libgnunettransport_la_SOURCES = \
   transport_api.c transport.h \
-  transport_api_blacklist.c
+  transport_api_blacklist.c \
+  transport_api_address_lookup.c 
 libgnunettransport_la_LIBADD = \
   $(top_builddir)/src/arm/libgnunetarm.la \
   $(top_builddir)/src/hello/libgnunethello.la \

Modified: gnunet/src/transport/gnunet-service-transport.c
===================================================================
--- gnunet/src/transport/gnunet-service-transport.c     2010-03-18 14:33:34 UTC 
(rev 10653)
+++ gnunet/src/transport/gnunet-service-transport.c     2010-03-18 14:46:42 UTC 
(rev 10654)
@@ -3391,6 +3391,13 @@
 }
 
 
+/**
+ * Take the given address and append it to the set of results send back to
+ * the client.
+ * 
+ * @param cls the transmission context used ('struct 
GNUNET_SERVER_TransmitContext*')
+ * @param address the resolved name, NULL to indicate the last response
+ */
 static void
 transmit_address_to_client (void *cls, const char *address)
 {
@@ -3426,6 +3433,9 @@
   const char *address;
   uint16_t size;
   struct GNUNET_SERVER_TransmitContext *tc;
+  struct GNUNET_TIME_Absolute timeout;
+  struct GNUNET_TIME_Relative rtimeout;
+  int32_t numeric;
 
   size = ntohs (message->size);
   if (size < sizeof (struct AddressLookupMessage))
@@ -3451,10 +3461,9 @@
       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
       return;
     }
-  struct GNUNET_TIME_Absolute timeout =
-    GNUNET_TIME_absolute_ntoh (alum->timeout);
-  struct GNUNET_TIME_Relative rtimeout =
-    GNUNET_TIME_absolute_get_remaining (timeout);
+  timeout = GNUNET_TIME_absolute_ntoh (alum->timeout);
+  rtimeout = GNUNET_TIME_absolute_get_remaining (timeout);
+  numeric = ntohl (alum->numeric_only);
   lsPlugin = find_transport (nameTransport);
   if (NULL == lsPlugin)
     {
@@ -3466,7 +3475,8 @@
     }
   tc = GNUNET_SERVER_transmit_context_create (client);
   lsPlugin->api->address_pretty_printer (cls, nameTransport,
-                                         address, addressLen, GNUNET_YES,
+                                         address, addressLen, 
+                                        numeric,
                                          rtimeout,
                                          &transmit_address_to_client, tc);
 }

Modified: gnunet/src/transport/transport_api_address_lookup.c
===================================================================
--- gnunet/src/transport/transport_api_address_lookup.c 2010-03-18 14:33:34 UTC 
(rev 10653)
+++ gnunet/src/transport/transport_api_address_lookup.c 2010-03-18 14:46:42 UTC 
(rev 10654)
@@ -1,3 +1,22 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009, 2010 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 2, 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.
+*/
 #include "platform.h"
 #include "gnunet_client_lib.h"
 #include "gnunet_arm_service.h"
@@ -8,68 +27,84 @@
 #include "gnunet_transport_service.h"
 #include "transport.h"
 
-// FIXME: document
-struct AddressLookUpCB
+/**
+ * Context for the address lookup.
+ */ 
+struct AddressLookupCtx
 {
+  /**
+   * Function to call with the human-readable address.
+   */
   GNUNET_TRANSPORT_AddressLookUpCallback cb;
-  void *cls;
+
+  /**
+   * Closure for cb.
+   */
+  void *cb_cls;
+
+  /**
+   * Connection to the service.
+   */
+  struct GNUNET_CLIENT_Connection *client;
+
+  /**
+   * When should this operation time out?
+   */
   struct GNUNET_TIME_Absolute timeout;
-  struct GNUNET_CLIENT_Connection *client;
 };
 
 
-// FIXME: document
+/**
+ * Function called with responses from the service.
+ *
+ * @param cls our 'struct AddressLookupCtx*'
+ * @param msg NULL on timeout or error, otherwise presumably a
+ *        message with the human-readable address
+ */
 static void
-address_response_processor (void *cls, const struct GNUNET_MessageHeader *msg)
+address_response_processor (void *cls, 
+                           const struct GNUNET_MessageHeader *msg)
 {
-  struct AddressLookUpCB *alucb = cls;
+  struct AddressLookupCtx *alucb = cls;
   const char *address;
   uint16_t size;
 
   if (msg == NULL)
     {
-      /* timeout */
-      alucb->cb (alucb->cls, NULL);
-      GNUNET_CLIENT_disconnect (alucb->client. GNUNET_NO);
+      alucb->cb (alucb->cb_cls, NULL);
+      GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO);
       GNUNET_free (alucb);
       return;
     }
+  GNUNET_break (ntohs (msg->type) == 
GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
   size = ntohs (msg->size);
   if (size == sizeof (struct GNUNET_MessageHeader))
     {
-      /* last reply */
-      address = NULL;
+      /* done! */
+      alucb->cb (alucb->cb_cls, NULL);
+      GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO);
+      GNUNET_free (alucb);
+      return;
     }
-  else
+  address = (const char *) &msg[1];
+  if (address[size - sizeof (struct GNUNET_MessageHeader) - 1] != '\0')
     {
-      address = (const char *) &msg[1];
-      if (address[size - sizeof (struct GNUNET_MessageHeader) - 1] != '\0')
-        {
-          /* invalid reply */
-          GNUNET_break_op (0);
-          alucb->cb (alucb->cls, NULL);
-          GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO);
-          GNUNET_free (alucb);
-          return;
-        }
-      else
-        {
-          /* expect more replies */
-          GNUNET_CLIENT_receive (alucb->client, &address_response_processor,
-                                 alucb,
-                                 GNUNET_TIME_absolute_get_remaining
-                                 (alucb->timeout));
-        }
-    }
-  alucb->cb (alucb->cls, address);
-  if (address == NULL)
-    {
-      /* done! */
+      /* invalid reply */
+      GNUNET_break (0);
+      alucb->cb (alucb->cb_cls, NULL);
       GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO);
       GNUNET_free (alucb);
+      return;
     }
+  /* expect more replies */
+  GNUNET_CLIENT_receive (alucb->client,
+                        &address_response_processor, alucb,
+                        GNUNET_TIME_absolute_get_remaining
+                        (alucb->timeout));    
+  alucb->cb (alucb->cb_cls, address);
 }
 
+
 /**
  * Convert a binary address into a human readable address.
  *
@@ -95,14 +130,16 @@
                                  GNUNET_TRANSPORT_AddressLookUpCallback aluc,
                                  void *aluc_cls)
 {
-  size_t len =
-    sizeof (struct AddressLookupMessage) + addressLen + strlen (nameTrans) +
-    1;
+  size_t slen;
+  size_t len;
   struct AddressLookupMessage *msg;
   struct GNUNET_TIME_Absolute abs_timeout;
-  struct AddressLookUpCB *aluCB;
+  struct AddressLookupCtx *aluCB;
   struct GNUNET_CLIENT_Connection *client;
+  char *addrbuf;
 
+  slen = strlen (nameTrans) + 1;
+  len = sizeof (struct AddressLookupMessage) + addressLen + slen;
   if (len >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
     {
       GNUNET_break (0);
@@ -117,22 +154,26 @@
     }
   abs_timeout = GNUNET_TIME_relative_to_absolute (timeout);
   msg = GNUNET_malloc (len);
-  msg->header->size = htons (len);
-  msg->header->type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_LOOKUP);
+  msg->header.size = htons (len);
+  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_LOOKUP);
+  msg->numeric_only = htonl (numeric);
   msg->timeout = GNUNET_TIME_absolute_hton (abs_timeout);
   msg->addrlen = htonl (addressLen);
-  char *addrbuf = (char *) &msg[1];
+  addrbuf = (char *) &msg[1];
   memcpy (addrbuf, address, addressLen);
-  char *tbuf = &addrbuf[addressLen];
-  memcpy (tbuf, nameTrans, strlen (nameTrans) + 1);
-  aluCB = GNUNET_malloc (sizeof (struct AddressLookUpCB));
+  memcpy (&addrbuf[addressLen], nameTrans, slen);
+  aluCB = GNUNET_malloc (sizeof (struct AddressLookupCtx));
   aluCB->cb = aluc;
   aluCB->cb_cls = aluc_cls;
   aluCB->timeout = abs_timeout;
   aluCB->client = client;
-  GNUNET_CLIENT_transmit_and_get_response (client, msg->header, timeout,
+  GNUNET_CLIENT_transmit_and_get_response (client, 
+                                          &msg->header, 
+                                          timeout,
                                            GNUNET_YES,
                                            &address_response_processor,
                                            aluCB);
   GNUNET_free (msg);
 }
+
+/* end of transport_api_address_lookup.c */