X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fats%2Fats_api_scheduling.c;h=78e8d61ccef75f1dbf6a546c8eacce195808c20d;hb=82c4c89493dcbfc6ee7fd1232a9088d02e2cd0a2;hp=663a7925a1af7a59ac747123de7a1ab9e8d2eea5;hpb=b389970f4d7563721ada3861366d164fcb45031a;p=oweals%2Fgnunet.git

diff --git a/src/ats/ats_api_scheduling.c b/src/ats/ats_api_scheduling.c
index 663a7925a..78e8d61cc 100644
--- a/src/ats/ats_api_scheduling.c
+++ b/src/ats/ats_api_scheduling.c
@@ -27,6 +27,9 @@
 #include "gnunet_ats_service.h"
 #include "ats.h"
 
+#define DEBUG_ATS GNUNET_EXTRA_LOGGING
+
+#define INTERFACE_PROCESSING_INTERVALL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
 
 /**
  * Message in linked list we should send to the ATS service.  The
@@ -79,6 +82,19 @@ struct SessionRecord
 };
 
 
+struct ATS_Network
+{
+  struct ATS_Network * next;
+
+  struct ATS_Network * prev;
+
+  struct sockaddr *network;
+  struct sockaddr *netmask;
+  socklen_t length;
+};
+
+
+
 /**
  * Handle to the ATS subsystem for bandwidth/transport scheduling information.
  */
@@ -120,6 +136,17 @@ struct GNUNET_ATS_SchedulingHandle
    */
   struct GNUNET_CLIENT_TransmitHandle *th;
 
+  /**
+   * Head of network list
+   */
+  struct ATS_Network * net_head;
+
+  /**
+   * Tail of network list
+   */
+  struct ATS_Network * net_tail;
+
+
   /**
    * Array of session objects (we need to translate them to numbers and back
    * for the protocol; the offset in the array is the session number on the
@@ -133,6 +160,13 @@ struct GNUNET_ATS_SchedulingHandle
    */
   GNUNET_SCHEDULER_TaskIdentifier task;
 
+  /**
+   * Task retrieving interfaces from the system
+   */
+
+  GNUNET_SCHEDULER_TaskIdentifier interface_task;
+
+
   /**
    * Size of the session array.
    */
@@ -285,6 +319,10 @@ static struct Session *
 find_session (struct GNUNET_ATS_SchedulingHandle *sh, uint32_t session_id,
               const struct GNUNET_PeerIdentity *peer)
 {
+#if DEBUG_ATS
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Find session %u from peer %s in %p\n",
+              (unsigned int) session_id, GNUNET_i2s (peer), sh);
+#endif
   if (session_id >= sh->session_array_size)
   {
     GNUNET_break (0);
@@ -292,13 +330,22 @@ find_session (struct GNUNET_ATS_SchedulingHandle *sh, uint32_t session_id,
   }
   if (0 == session_id)
     return NULL;
-  /* Check if this session was:
-   *  removed by remove_session (transport service)
-   *  released by release_session (ATS)
-   *  */
   if (sh->session_array[session_id].session == NULL)
+  {
+    GNUNET_break (0 ==
+                  memcmp (peer, &sh->session_array[session_id].peer,
+                          sizeof (struct GNUNET_PeerIdentity)));
     return NULL;
+  }
 
+  if (0 !=
+      memcmp (peer, &sh->session_array[session_id].peer,
+              sizeof (struct GNUNET_PeerIdentity)))
+  {
+    GNUNET_break (0);
+    sh->reconnect = GNUNET_YES;
+    return NULL;
+  }
   return sh->session_array[session_id].session;
 }
 
@@ -319,6 +366,11 @@ get_session_id (struct GNUNET_ATS_SchedulingHandle *sh, struct Session *session,
   unsigned int i;
   unsigned int f;
 
+#if DEBUG_ATS
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Get session ID for session %p from peer %s in %p\n", session,
+              GNUNET_i2s (peer), sh);
+#endif
   if (NULL == session)
     return 0;
   f = 0;
@@ -326,11 +378,10 @@ get_session_id (struct GNUNET_ATS_SchedulingHandle *sh, struct Session *session,
   {
     if (session == sh->session_array[i].session)
     {
-      if (0 !=  memcmp (peer, &sh->session_array[i].peer,
-                             sizeof (struct GNUNET_PeerIdentity)))
-        continue;
-      else
-        return i;
+      GNUNET_assert (0 ==
+                     memcmp (peer, &sh->session_array[i].peer,
+                             sizeof (struct GNUNET_PeerIdentity)));
+      return i;
     }
     if ((f == 0) && (sh->session_array[i].slot_used == GNUNET_NO))
       f = i;
@@ -345,6 +396,11 @@ get_session_id (struct GNUNET_ATS_SchedulingHandle *sh, struct Session *session,
   sh->session_array[f].session = session;
   sh->session_array[f].peer = *peer;
   sh->session_array[f].slot_used = GNUNET_YES;
+#if DEBUG_ATS
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Assigning session ID %u for session %p of peer %s in %p\n", f,
+              session, GNUNET_i2s (peer), sh);
+#endif
   return f;
 }
 
@@ -361,11 +417,17 @@ static void
 remove_session (struct GNUNET_ATS_SchedulingHandle *sh, uint32_t session_id,
                 const struct GNUNET_PeerIdentity *peer)
 {
+#if DEBUG_ATS
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Remove sessionID %u from peer %s in %p\n",
+              (unsigned int) session_id, GNUNET_i2s (peer), sh);
+#endif
   if (0 == session_id)
     return;
   GNUNET_assert (session_id < sh->session_array_size);
   GNUNET_assert (GNUNET_YES == sh->session_array[session_id].slot_used);
-  GNUNET_assert (0 == memcmp (peer, &sh->session_array[session_id].peer,
+  GNUNET_assert (0 ==
+                 memcmp (peer, &sh->session_array[session_id].peer,
                          sizeof (struct GNUNET_PeerIdentity)));
   sh->session_array[session_id].session = NULL;
 }
@@ -383,6 +445,11 @@ static void
 release_session (struct GNUNET_ATS_SchedulingHandle *sh, uint32_t session_id,
                  const struct GNUNET_PeerIdentity *peer)
 {
+#if DEBUG_ATS
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Release sessionID %u from peer %s in %p\n",
+              (unsigned int) session_id, GNUNET_i2s (peer), sh);
+#endif
   if (session_id >= sh->session_array_size)
   {
     GNUNET_break (0);
@@ -393,7 +460,8 @@ release_session (struct GNUNET_ATS_SchedulingHandle *sh, uint32_t session_id,
   /* this slot should have been removed from remove_session before */
   GNUNET_assert (sh->session_array[session_id].session == NULL);
 
-  if (0 != memcmp (peer, &sh->session_array[session_id].peer,
+  if (0 !=
+      memcmp (peer, &sh->session_array[session_id].peer,
               sizeof (struct GNUNET_PeerIdentity)))
   {
     GNUNET_break (0);
@@ -433,6 +501,7 @@ process_ats_message (void *cls, const struct GNUNET_MessageHeader *msg)
   uint16_t plugin_name_length;
   uint32_t ats_count;
   struct GNUNET_HELLO_Address address;
+  struct Session *s;
 
   if (NULL == msg)
   {
@@ -474,9 +543,8 @@ process_ats_message (void *cls, const struct GNUNET_MessageHeader *msg)
     force_reconnect (sh);
     return;
   }
-  uint32_t session_id =  ntohl (m->session_id);
+  uint32_t session_id = ntohl (m->session_id);
 
-  struct Session * s = NULL;
   if (session_id == 0)
     s = NULL;
   else
@@ -484,8 +552,13 @@ process_ats_message (void *cls, const struct GNUNET_MessageHeader *msg)
     s = find_session (sh, session_id, &m->peer);
     if (s == NULL)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ATS tries to use outdated session `%s'\n", GNUNET_i2s(&m->peer));
-      //GNUNET_break (0);
+#if DEBUG_ATS
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "ATS tries to use outdated session `%s'\n",
+                  GNUNET_i2s (&m->peer));
+#endif
+      GNUNET_CLIENT_receive (sh->client, &process_ats_message, sh,
+                             GNUNET_TIME_UNIT_FOREVER_REL);
       return;
     }
   }
@@ -493,6 +566,19 @@ process_ats_message (void *cls, const struct GNUNET_MessageHeader *msg)
   address.address = plugin_address;
   address.address_length = plugin_address_length;
   address.transport_name = plugin_name;
+
+  if ((s == NULL) && (0 == address.address_length))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "ATS returned invalid address for peer `%s' transport `%s' address length %i, session_id %i\n",
+                GNUNET_i2s (&address.peer), address.transport_name,
+                plugin_address_length, session_id);
+    GNUNET_break_op (0);
+    GNUNET_CLIENT_receive (sh->client, &process_ats_message, sh,
+                           GNUNET_TIME_UNIT_FOREVER_REL);
+    return;
+  }
+
   sh->suggest_cb (sh->suggest_cb_cls, &address, s, m->bandwidth_out,
                   m->bandwidth_in, atsi, ats_count);
 
@@ -532,6 +618,259 @@ reconnect (struct GNUNET_ATS_SchedulingHandle *sh)
   do_transmit (sh);
 }
 
+/**
+ * delete the current network list
+ */
+
+static void
+delete_networks (struct GNUNET_ATS_SchedulingHandle *sh)
+{
+  struct ATS_Network * cur = sh->net_head;
+  while (cur != NULL)
+  {
+    GNUNET_CONTAINER_DLL_remove(sh->net_head, sh->net_tail, cur);
+    GNUNET_free (cur);
+    cur = sh->net_head;
+  }
+}
+
+
+static int
+interface_proc (void *cls, const char *name,
+                int isDefault,
+                const struct sockaddr *
+                addr,
+                const struct sockaddr *
+                broadcast_addr,
+                const struct sockaddr *
+                netmask, socklen_t addrlen)
+{
+  struct GNUNET_ATS_SchedulingHandle * sh = cls;
+  /* Calculate network */
+  struct ATS_Network *net = NULL;
+
+  /* Skipping IPv4 loopback addresses since we have special check  */
+  if  (addr->sa_family == AF_INET)
+  {
+    struct sockaddr_in * a4 = (struct sockaddr_in *) addr;
+
+    if ((a4->sin_addr.s_addr & htonl(0xff000000)) == htonl (0x7f000000))
+       return GNUNET_OK;
+  }
+  /* Skipping IPv6 loopback addresses since we have special check  */
+  if  (addr->sa_family == AF_INET6)
+  {
+    struct sockaddr_in6 * a6 = (struct sockaddr_in6 *) addr;
+    if (IN6_IS_ADDR_LOOPBACK (&a6->sin6_addr))
+      return GNUNET_OK;
+  }
+
+  if (addr->sa_family == AF_INET)
+  {
+    struct sockaddr_in *addr4 = (struct sockaddr_in *) addr;
+    struct sockaddr_in *netmask4 = (struct sockaddr_in *) netmask;
+    struct sockaddr_in *tmp = NULL;
+    struct sockaddr_in network4;
+
+    net = GNUNET_malloc(sizeof (struct ATS_Network) + 2 * sizeof (struct sockaddr_in));
+    tmp = (struct sockaddr_in *) &net[1];
+    net->network = (struct sockaddr *) &tmp[0];
+    net->netmask = (struct sockaddr *) &tmp[1];
+    net->length = addrlen;
+
+    memset (&network4, 0, sizeof (network4));
+    network4.sin_family = AF_INET;
+#if HAVE_SOCKADDR_IN_SIN_LEN
+    network4.sin_len = sizeof (network4);
+#endif
+    network4.sin_addr.s_addr = (addr4->sin_addr.s_addr & netmask4->sin_addr.s_addr);
+
+    memcpy (net->netmask, netmask4, sizeof (struct sockaddr_in));
+    memcpy (net->network, &network4, sizeof (struct sockaddr_in));
+  }
+
+  if (addr->sa_family == AF_INET6)
+  {
+    struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *) addr;
+    struct sockaddr_in6 *netmask6 = (struct sockaddr_in6 *) netmask;
+    struct sockaddr_in6 * tmp = NULL;
+    struct sockaddr_in6 network6;
+
+    net = GNUNET_malloc(sizeof (struct ATS_Network) + 2 * sizeof (struct sockaddr_in6));
+    tmp = (struct sockaddr_in6 *) &net[1];
+    net->network = (struct sockaddr *) &tmp[0];
+    net->netmask = (struct sockaddr *) &tmp[1];
+    net->length = addrlen;
+
+    memset (&network6, 0, sizeof (network6));
+    network6.sin6_family = AF_INET6;
+#if HAVE_SOCKADDR_IN_SIN_LEN
+    network6.sin6_len = sizeof (network6);
+#endif
+    int c = 0;
+    uint32_t *addr_elem = (uint32_t *) &addr6->sin6_addr;
+    uint32_t *mask_elem = (uint32_t *) &netmask6->sin6_addr;
+    uint32_t *net_elem = (uint32_t *) &network6.sin6_addr;
+    for (c = 0; c < 4; c++)
+      net_elem[c] = addr_elem[c] & mask_elem[c];
+
+    memcpy (net->netmask, netmask6, sizeof (struct sockaddr_in6));
+    memcpy (net->network, &network6, sizeof (struct sockaddr_in6));
+  }
+
+  /* Store in list */
+  if (net != NULL)
+  {
+#if VERBOSE_ATS
+    char * netmask = GNUNET_strdup (GNUNET_a2s((struct sockaddr *) net->netmask, addrlen));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding network `%s', netmask `%s'\n",
+        GNUNET_a2s((struct sockaddr *) net->network, addrlen),
+        netmask);
+    GNUNET_free (netmask);
+# endif
+    GNUNET_CONTAINER_DLL_insert(sh->net_head, sh->net_tail, net);
+  }
+  return GNUNET_OK;
+}
+
+
+
+/**
+ * Periodically get list of addresses
+ * @param cls closure
+ * @param tc Task context
+ */
+static void
+get_addresses (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_ATS_SchedulingHandle * sh = cls;
+  sh->interface_task = GNUNET_SCHEDULER_NO_TASK;
+  delete_networks (sh);
+  GNUNET_OS_network_interfaces_list(interface_proc, sh);
+  sh->interface_task = GNUNET_SCHEDULER_add_delayed (INTERFACE_PROCESSING_INTERVALL,
+                                                     get_addresses,
+                                                     sh);
+}
+
+/**
+ * Returns where the address is located: LAN or WAN or ...
+ * @param sh the scheduling handle
+ * @param addr address
+ * @param addrlen address length
+ * @return location as GNUNET_ATS_Information
+ */
+
+const struct GNUNET_ATS_Information
+GNUNET_ATS_address_get_type (struct GNUNET_ATS_SchedulingHandle * sh, const struct sockaddr * addr, socklen_t addrlen)
+{
+  GNUNET_assert (sh != NULL);
+  struct GNUNET_ATS_Information ats;
+  struct ATS_Network * cur = sh->net_head;
+  int type = GNUNET_ATS_NET_UNSPECIFIED;
+
+  if  (addr->sa_family == AF_UNIX)
+  {
+    type = GNUNET_ATS_NET_LOOPBACK;
+  }
+
+  /* IPv4 loopback check */
+  if  (addr->sa_family == AF_INET)
+  {
+    struct sockaddr_in * a4 = (struct sockaddr_in *) addr;
+
+    if ((a4->sin_addr.s_addr & htonl(0xff000000)) == htonl (0x7f000000))
+      type = GNUNET_ATS_NET_LOOPBACK;
+  }
+  /* IPv6 loopback check */
+  if  (addr->sa_family == AF_INET6)
+  {
+    struct sockaddr_in6 * a6 = (struct sockaddr_in6 *) addr;
+    if (IN6_IS_ADDR_LOOPBACK (&a6->sin6_addr))
+      type = GNUNET_ATS_NET_LOOPBACK;
+  }
+
+  /* Check local networks */
+  while ((cur != NULL) && (type == GNUNET_ATS_NET_UNSPECIFIED))
+  {
+    if (addrlen != cur->length)
+    {
+      cur = cur->next;
+      continue;
+    }
+
+    if (addr->sa_family == AF_INET)
+    {
+      struct sockaddr_in * a4 = (struct sockaddr_in *) addr;
+      struct sockaddr_in * net4 = (struct sockaddr_in *) cur->network;
+      struct sockaddr_in * mask4 = (struct sockaddr_in *) cur->netmask;
+
+      if (((a4->sin_addr.s_addr & mask4->sin_addr.s_addr)) == net4->sin_addr.s_addr)
+      {
+        char * net = GNUNET_strdup (GNUNET_a2s ((const struct sockaddr *) net4, addrlen));
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "`%s' is in network `%s'\n",
+            GNUNET_a2s ((const struct sockaddr *)a4, addrlen),
+            net);
+        GNUNET_free (net);
+        type = GNUNET_ATS_NET_LAN;
+      }
+    }
+    if (addr->sa_family == AF_INET6)
+    {
+      struct sockaddr_in6 * a6 = (struct sockaddr_in6 *) addr;
+      struct sockaddr_in6 * net6 = (struct sockaddr_in6 *) cur->network;
+      struct sockaddr_in6 * mask6 = (struct sockaddr_in6 *) cur->netmask;
+
+      int res = GNUNET_YES;
+      int c = 0;
+      uint32_t *addr_elem = (uint32_t *) &a6->sin6_addr;
+      uint32_t *mask_elem = (uint32_t *) &mask6->sin6_addr;
+      uint32_t *net_elem = (uint32_t *) &net6->sin6_addr;
+      for (c = 0; c < 4; c++)
+        if ((addr_elem[c] & mask_elem[c]) != net_elem[c])
+          res = GNUNET_NO;
+
+      if (res == GNUNET_YES)
+      {
+        char * net = GNUNET_strdup (GNUNET_a2s ((const struct sockaddr *) net6, addrlen));
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "`%s' is in network `%s'\n",
+              GNUNET_a2s ((const struct sockaddr *) a6, addrlen),
+              net);
+        GNUNET_free (net);
+        type = GNUNET_ATS_NET_LAN;
+      }
+    }
+    cur = cur->next;
+  }
+
+  /* no local network found for this address, default: WAN */
+  if (type == GNUNET_ATS_NET_UNSPECIFIED)
+    type = GNUNET_ATS_NET_WAN;
+
+#if VERBOSE
+  const char * range;
+  switch (type) {
+    case GNUNET_ATS_NET_WAN:
+        range = "WAN";
+      break;
+    case GNUNET_ATS_NET_LAN:
+        range = "LAN";
+      break;
+    case GNUNET_ATS_NET_LOOPBACK:
+        range = "LOOPBACK";
+      break;
+    default:
+
+      break;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "`%s' is in network `%s'\n",
+        GNUNET_a2s ((const struct sockaddr *) addr, addrlen),
+        range);
+#endif
+
+  ats.type = htonl (GNUNET_ATS_NETWORK_TYPE);
+  ats.value = htonl (type);
+  return (const struct GNUNET_ATS_Information) ats;
+}
 
 /**
  * Initialize the ATS subsystem.
@@ -553,6 +892,10 @@ GNUNET_ATS_scheduling_init (const struct GNUNET_CONFIGURATION_Handle *cfg,
   sh->suggest_cb = suggest_cb;
   sh->suggest_cb_cls = suggest_cb_cls;
   GNUNET_array_grow (sh->session_array, sh->session_array_size, 4);
+  GNUNET_OS_network_interfaces_list(interface_proc, sh);
+  sh->interface_task = GNUNET_SCHEDULER_add_delayed (INTERFACE_PROCESSING_INTERVALL,
+      get_addresses,
+      sh);
   reconnect (sh);
   return sh;
 }
@@ -583,8 +926,16 @@ GNUNET_ATS_scheduling_done (struct GNUNET_ATS_SchedulingHandle *sh)
     GNUNET_SCHEDULER_cancel (sh->task);
     sh->task = GNUNET_SCHEDULER_NO_TASK;
   }
+
+  delete_networks (sh);
+  if (sh->interface_task != GNUNET_SCHEDULER_NO_TASK)
+  {
+    GNUNET_SCHEDULER_cancel(sh->interface_task);
+    sh->interface_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   GNUNET_array_grow (sh->session_array, sh->session_array_size, 0);
   GNUNET_free (sh);
+  sh = NULL;
 }
 
 
@@ -670,7 +1021,20 @@ GNUNET_ATS_address_update (struct GNUNET_ATS_SchedulingHandle *sh,
   size_t namelen;
   size_t msize;
 
-  namelen = (address->transport_name == NULL) ? 0 : strlen (address->transport_name) + 1;
+  if (address == NULL)
+  {
+    GNUNET_break (0);
+    return;
+  }
+  if ((address == NULL) && (session == NULL))
+  {
+    GNUNET_break (0);
+    return;
+  }
+
+  namelen =
+      (address->transport_name ==
+       NULL) ? 0 : strlen (address->transport_name) + 1;
   msize =
       sizeof (struct AddressUpdateMessage) + address->address_length +
       ats_count * sizeof (struct GNUNET_ATS_Information) + namelen;
@@ -717,8 +1081,7 @@ GNUNET_ATS_address_update (struct GNUNET_ATS_SchedulingHandle *sh,
 void
 GNUNET_ATS_address_in_use (struct GNUNET_ATS_SchedulingHandle *sh,
                            const struct GNUNET_HELLO_Address *address,
-                           struct Session *session,
-                           int in_use)
+                           struct Session *session, int in_use)
 {
   struct PendingMessage *p;
   struct AddressUseMessage *m;
@@ -727,7 +1090,9 @@ GNUNET_ATS_address_in_use (struct GNUNET_ATS_SchedulingHandle *sh,
   size_t msize;
 
   GNUNET_assert (NULL != address);
-  namelen = (address->transport_name == NULL) ? 0 : strlen (address->transport_name) + 1;
+  namelen =
+      (address->transport_name ==
+       NULL) ? 0 : strlen (address->transport_name) + 1;
   msize = sizeof (struct AddressUseMessage) + address->address_length + namelen;
   if ((msize >= GNUNET_SERVER_MAX_MESSAGE_SIZE) ||
       (address->address_length >= GNUNET_SERVER_MAX_MESSAGE_SIZE) ||
@@ -775,8 +1140,12 @@ GNUNET_ATS_address_destroyed (struct GNUNET_ATS_SchedulingHandle *sh,
   size_t msize;
   uint32_t session_id;
 
-  namelen = (address->transport_name == NULL) ? 0 : strlen (address->transport_name) + 1;
-  msize = sizeof (struct AddressDestroyedMessage) + address->address_length + namelen;
+  GNUNET_assert (address->transport_name != NULL);
+  namelen = strlen (address->transport_name) + 1;
+  GNUNET_assert (namelen > 1);
+  msize =
+      sizeof (struct AddressDestroyedMessage) + address->address_length +
+      namelen;
   if ((msize >= GNUNET_SERVER_MAX_MESSAGE_SIZE) ||
       (address->address_length >= GNUNET_SERVER_MAX_MESSAGE_SIZE) ||
       (namelen >= GNUNET_SERVER_MAX_MESSAGE_SIZE))
@@ -785,7 +1154,6 @@ GNUNET_ATS_address_destroyed (struct GNUNET_ATS_SchedulingHandle *sh,
     return;
   }
 
-
   p = GNUNET_malloc (sizeof (struct PendingMessage) + msize);
   p->size = msize;
   p->is_init = GNUNET_NO;