protected int sendBind(DHTTransportContact target) {
    try {
      Map request = new HashMap();

      request.put("type", new Long(RT_BIND_REQUEST));

      Map response = sendRequest(target, request, TRANSFER_TIMEOUT);

      if (response == null) {

        return (RESP_FAILED);
      }

      if (((Long) response.get("type")).intValue() == RT_BIND_REPLY) {

        int result = ((Long) response.get("ok")).intValue();

        trace("received bind reply: " + (result == 0 ? "failed" : "ok"));

        if (result == 1) {

          return (RESP_OK);
        }
      }

      return (RESP_NOT_OK);

    } catch (Throwable e) {

      log(e);

      return (RESP_FAILED);
    }
  }
  protected void receiveQuery(DHTTransportUDPContact originator, Map request, Map response) {
    trace("received query request");

    InetSocketAddress address = originator.getTransportAddress();

    response.put("ip", address.getAddress().getHostAddress().getBytes());

    response.put("port", new Long(address.getPort()));

    response.put("ok", new Long(1));
  }
  public void destroy() {
    try {
      server_mon.enter();

      Iterator it = rendezvous_bindings.values().iterator();

      while (it.hasNext()) {

        Object[] entry = (Object[]) it.next();

        final DHTTransportUDPContact contact = (DHTTransportUDPContact) entry[0];

        new AEThread2("DHTNATPuncher:destroy", true) {
          public void run() {
            sendClose(contact);
          }
        }.start();
      }
    } catch (Throwable e) {

      log(e);

    } finally {

      server_mon.exit();
    }
  }
  protected Map sendConnect(
      DHTTransportContact target, DHTTransportContact originator, Map originator_client_data) {
    try {
      Map request = new HashMap();

      request.put("type", new Long(RT_CONNECT_REQUEST));

      request.put("origin", encodeContact(originator));

      request.put(
          "port", new Long(((DHTTransportUDPContact) originator).getTransportAddress().getPort()));

      if (originator_client_data != null) {

        request.put("client_data", originator_client_data);
      }

      Map response = sendRequest(target, request, TRANSFER_TIMEOUT);

      if (response == null) {

        return (null);
      }

      if (((Long) response.get("type")).intValue() == RT_CONNECT_REPLY) {

        int result = ((Long) response.get("ok")).intValue();

        trace("received connect reply: " + (result == 0 ? "failed" : "ok"));

        if (result == 1) {

          Map target_client_data = (Map) response.get("client_data");

          if (target_client_data == null) {

            target_client_data = new HashMap();
          }

          return (target_client_data);
        }
      }

      return (null);

    } catch (Throwable e) {

      log(e);

      return (null);
    }
  }
  public void setRendezvous(DHTTransportContact target, DHTTransportContact rendezvous) {
    explicit_rendezvous_map.put(target.getAddress(), rendezvous);

    if (target.getAddress().equals(dht.getTransport().getLocalContact().getAddress())) {

      publish(true);
    }
  }
  protected boolean sendTunnelOutbound(DHTTransportContact target) {
    log("Sending tunnel outbound message to " + target.getString());

    try {
      Map message = new HashMap();

      message.put("type", new Long(RT_TUNNEL_OUTBOUND));

      return (sendTunnelMessage(target, message));

    } catch (Throwable e) {

      log(e);

      return (false);
    }
  }
  protected void receiveBind(DHTTransportUDPContact originator, Map request, Map response) {
    trace("received bind request");

    boolean ok = true;
    boolean log = true;

    try {
      server_mon.enter();

      Object[] entry = (Object[]) rendezvous_bindings.get(originator.getAddress().toString());

      if (entry == null) {

        if (rendezvous_bindings.size() == RENDEZVOUS_SERVER_MAX) {

          ok = false;
        }
      } else {

        // already present, no need to log again

        log = false;
      }

      if (ok) {

        long now = plugin_interface.getUtilities().getCurrentSystemTime();

        rendezvous_bindings.put(
            originator.getAddress().toString(), new Object[] {originator, new Long(now)});

        response.put("port", new Long(originator.getAddress().getPort()));
      }
    } finally {

      server_mon.exit();
    }

    if (log) {

      log("Rendezvous request from " + originator.getString() + " " + (ok ? "accepted" : "denied"));
    }

    response.put("ok", new Long(ok ? 1 : 0));
  }
  protected void rendezvousFailed(DHTTransportContact current_target, boolean tidy) {
    log("Rendezvous " + (tidy ? "closed" : "failed") + ": " + current_target.getString());

    try {
      pub_mon.enter();

      failed_rendezvous.put(current_target.getAddress(), "");

    } finally {

      pub_mon.exit();
    }

    publish(true);
  }
  protected void receiveClose(DHTTransportUDPContact originator, Map request, Map response) {
    trace("received close request");

    final DHTTransportContact current_target = rendezvous_target;

    if (current_target != null && Arrays.equals(current_target.getID(), originator.getID())) {

      new AEThread2("DHTNATPuncher:close", true) {
        public void run() {
          rendezvousFailed(current_target, true);
        }
      }.start();
    }

    response.put("ok", new Long(1));
  }
Exemple #10
0
  protected void receivePunch(DHTTransportUDPContact originator, Map request, Map response) {
    trace("received punch request");

    boolean ok = false;

    String target_str = new String((byte[]) request.get("target"));

    Object[] entry;

    try {
      server_mon.enter();

      entry = (Object[]) rendezvous_bindings.get(target_str);

    } finally {

      server_mon.exit();
    }

    if (entry != null) {

      DHTTransportUDPContact target = (DHTTransportUDPContact) entry[0];

      Map target_client_data = sendConnect(target, originator, (Map) request.get("client_data"));

      if (target_client_data != null) {

        response.put("client_data", target_client_data);

        response.put("port", new Long(target.getTransportAddress().getPort()));

        ok = true;
      }
    }

    log(
        "Rendezvous punch request from "
            + originator.getString()
            + " to "
            + target_str
            + " "
            + (ok ? "initiated" : "failed"));

    response.put("ok", new Long(ok ? 1 : 0));
  }
Exemple #11
0
  protected Map receiveRequest(DHTTransportUDPContact originator, Map data) {
    int type = ((Long) data.get("type")).intValue();

    Map response = new HashMap();

    switch (type) {
      case RT_BIND_REQUEST:
        {
          response.put("type", new Long(RT_BIND_REPLY));

          receiveBind(originator, data, response);

          break;
        }
      case RT_CLOSE_REQUEST:
        {
          response.put("type", new Long(RT_CLOSE_REPLY));

          receiveClose(originator, data, response);

          break;
        }
      case RT_QUERY_REQUEST:
        {
          response.put("type", new Long(RT_QUERY_REPLY));

          receiveQuery(originator, data, response);

          break;
        }
      case RT_PUNCH_REQUEST:
        {
          response.put("type", new Long(RT_PUNCH_REPLY));

          receivePunch(originator, data, response);

          break;
        }
      case RT_CONNECT_REQUEST:
        {
          response.put("type", new Long(RT_CONNECT_REPLY));

          receiveConnect(originator, data, response);

          break;
        }
      case RT_TUNNEL_INBOUND:
        {
          receiveTunnelInbound(originator, data);

          response = null;

          break;
        }
      case RT_TUNNEL_OUTBOUND:
        {
          receiveTunnelOutbound(originator, data);

          response = null;

          break;
        }
      default:
        {
          response = null;

          break;
        }
    }

    return (response);
  }
Exemple #12
0
  protected void publishSupport() {
    DHTTransport transport = dht.getTransport();

    if (TESTING || !transport.isReachable()) {

      DHTTransportContact local_contact = transport.getLocalContact();

      // see if the rendezvous has failed and therefore we are required to find a new one

      boolean force =
          rendezvous_target != null
              && failed_rendezvous.containsKey(rendezvous_target.getAddress());

      if (rendezvous_local_contact != null && !force) {

        if (local_contact.getAddress().equals(rendezvous_local_contact.getAddress())) {

          // already running for the current local contact

          return;
        }
      }

      DHTTransportContact explicit =
          (DHTTransportContact) explicit_rendezvous_map.get(local_contact.getAddress());

      if (explicit != null) {

        try {
          pub_mon.enter();

          rendezvous_local_contact = local_contact;
          rendezvous_target = explicit;

          runRendezvous();

        } finally {

          pub_mon.exit();
        }
      } else {

        final DHTTransportContact[] new_rendezvous_target = {null};

        DHTTransportContact[] reachables = dht.getTransport().getReachableContacts();

        int reachables_tried = 0;
        int reachables_skipped = 0;

        final Semaphore sem = plugin_interface.getUtilities().getSemaphore();

        for (int i = 0; i < reachables.length; i++) {

          DHTTransportContact contact = reachables[i];

          try {
            pub_mon.enter();

            // see if we've found a good one yet

            if (new_rendezvous_target[0] != null) {

              break;
            }

            // skip any known bad ones

            if (failed_rendezvous.containsKey(contact.getAddress())) {

              reachables_skipped++;

              sem.release();

              continue;
            }
          } finally {

            pub_mon.exit();
          }

          if (i > 0) {

            try {
              Thread.sleep(1000);

            } catch (Throwable e) {

            }
          }

          reachables_tried++;

          contact.sendPing(
              new DHTTransportReplyHandlerAdapter() {
                public void pingReply(DHTTransportContact ok_contact) {
                  trace("Punch:" + ok_contact.getString() + " OK");

                  try {
                    pub_mon.enter();

                    if (new_rendezvous_target[0] == null) {

                      new_rendezvous_target[0] = ok_contact;
                    }
                  } finally {

                    pub_mon.exit();

                    sem.release();
                  }
                }

                public void failed(DHTTransportContact failed_contact, Throwable e) {
                  try {
                    trace("Punch:" + failed_contact.getString() + " Failed");

                  } finally {

                    sem.release();
                  }
                }
              });
        }

        for (int i = 0; i < reachables.length; i++) {

          sem.reserve();

          try {
            pub_mon.enter();

            if (new_rendezvous_target[0] != null) {

              rendezvous_target = new_rendezvous_target[0];
              rendezvous_local_contact = local_contact;

              log(
                  "Rendezvous found: "
                      + rendezvous_local_contact.getString()
                      + " -> "
                      + rendezvous_target.getString());

              runRendezvous();

              break;
            }
          } finally {

            pub_mon.exit();
          }
        }

        if (new_rendezvous_target[0] == null) {

          log(
              "No rendezvous found: candidates="
                  + reachables.length
                  + ",tried="
                  + reachables_tried
                  + ",skipped="
                  + reachables_skipped);

          try {
            pub_mon.enter();

            rendezvous_local_contact = null;
            rendezvous_target = null;

          } finally {

            pub_mon.exit();
          }
        }
      }
    } else {

      try {
        pub_mon.enter();

        rendezvous_local_contact = null;
        rendezvous_target = null;

      } finally {

        pub_mon.exit();
      }
    }
  }
Exemple #13
0
  protected DHTTransportContact getRendezvous(String reason, DHTTransportContact target) {
    DHTTransportContact explicit =
        (DHTTransportContact) explicit_rendezvous_map.get(target.getAddress());

    if (explicit != null) {

      return (explicit);
    }

    byte[] key = getPublishKey(target);

    final DHTTransportValue[] result_value = {null};

    final Semaphore sem = plugin_interface.getUtilities().getSemaphore();

    dht.get(
        key,
        reason + ": lookup for '" + target.getString() + "'",
        (byte) 0,
        1,
        RENDEZVOUS_LOOKUP_TIMEOUT,
        false,
        true,
        new DHTOperationAdapter() {
          public void read(DHTTransportContact contact, DHTTransportValue value) {
            result_value[0] = value;

            sem.release();
          }

          public void complete(boolean timeout) {
            sem.release();
          }
        });

    sem.reserve();

    DHTTransportContact result = null;

    if (result_value[0] != null) {

      byte[] bytes = result_value[0].getValue();

      try {
        ByteArrayInputStream bais = new ByteArrayInputStream(bytes);

        DataInputStream dis = new DataInputStream(bais);

        byte version = dis.readByte();

        if (version != 0) {

          throw (new Exception("Unsupported rendezvous version '" + version + "'"));
        }

        result = dht.getTransport().importContact(dis);

      } catch (Throwable e) {

        log(e);
      }
    }

    log(
        "Lookup of rendezvous for "
            + target.getString()
            + " -> "
            + (result == null ? "None" : result.getString()));

    return (result);
  }
Exemple #14
0
  protected void receiveConnect(DHTTransportContact rendezvous, Map request, Map response) {
    trace("received connect request");

    boolean ok = false;

    // ensure that we've received this from our current rendezvous node

    DHTTransportContact rt = rendezvous_target;

    if (rt != null && rt.getAddress().equals(rendezvous.getAddress())) {

      final DHTTransportUDPContact target = decodeContact((byte[]) request.get("origin"));

      if (target != null) {

        int transport_port = 0;

        Long indirect_port = (Long) request.get("port");

        if (indirect_port != null) {

          transport_port = indirect_port.intValue();
        }

        if (transport_port != 0) {

          InetSocketAddress existing_address = target.getTransportAddress();

          if (transport_port != existing_address.getPort()) {

            target.setTransportAddress(
                new InetSocketAddress(existing_address.getAddress(), transport_port));
          }
        }

        Map originator_client_data = (Map) request.get("client_data");

        boolean no_tunnel = false;

        if (originator_client_data == null) {

          originator_client_data = new HashMap();

        } else {

          no_tunnel = originator_client_data.get("_notunnel") != null;
        }

        if (no_tunnel) {

          log("Received message from " + target.getString());

        } else {

          log("Received connect request from " + target.getString());

          // ping the origin a few times to try and establish a tunnel

          UTTimerEvent event =
              timer.addPeriodicEvent(
                  3000,
                  new UTTimerEventPerformer() {
                    private int pings = 1;

                    public void perform(UTTimerEvent ev) {
                      if (pings > 3) {

                        ev.cancel();

                        return;
                      }

                      pings++;

                      if (sendTunnelInbound(target)) {

                        ev.cancel();
                      }
                    }
                  });

          if (sendTunnelInbound(target)) {

            event.cancel();
          }
        }

        Map client_data =
            adapter.getClientData(target.getTransportAddress(), originator_client_data);

        if (client_data == null) {

          client_data = new HashMap();
        }

        response.put("client_data", client_data);

        ok = true;

      } else {

        log("Connect request: failed to decode target");
      }
    } else {

      log("Connect request from invalid rendezvous: " + rendezvous.getString());
    }

    response.put("ok", new Long(ok ? 1 : 0));
  }
Exemple #15
0
  protected Map sendPunch(
      DHTTransportContact rendezvous,
      final DHTTransportUDPContact target,
      Map originator_client_data,
      boolean no_tunnel) {
    AESemaphore wait_sem = new AESemaphore("DHTNatPuncher::sendPunch");
    Object[] wait_data = new Object[] {target, wait_sem, new Integer(0)};

    try {

      try {
        punch_mon.enter();

        oustanding_punches.add(wait_data);

      } finally {

        punch_mon.exit();
      }

      Map request = new HashMap();

      request.put("type", new Long(RT_PUNCH_REQUEST));

      request.put("target", target.getAddress().toString().getBytes());

      if (originator_client_data != null) {

        if (no_tunnel) {

          originator_client_data.put("_notunnel", new Long(1));
        }

        request.put("client_data", originator_client_data);
      }

      // for a message payload (i.e. no_tunnel) we double the initiator timeout to give
      // more chance for reasonable size messages to get through as they have to go through
      // 2 xfer processes

      Map response =
          sendRequest(rendezvous, request, no_tunnel ? TRANSFER_TIMEOUT * 2 : TRANSFER_TIMEOUT);

      if (response == null) {

        return (null);
      }

      if (((Long) response.get("type")).intValue() == RT_PUNCH_REPLY) {

        int result = ((Long) response.get("ok")).intValue();

        trace(
            "received "
                + (no_tunnel ? "message" : "punch")
                + " reply: "
                + (result == 0 ? "failed" : "ok"));

        if (result == 1) {

          // pick up port changes from the rendezvous

          Long indirect_port = (Long) response.get("port");

          if (indirect_port != null) {

            int transport_port = indirect_port.intValue();

            if (transport_port != 0) {

              InetSocketAddress existing_address = target.getTransportAddress();

              if (transport_port != existing_address.getPort()) {

                target.setTransportAddress(
                    new InetSocketAddress(existing_address.getAddress(), transport_port));
              }
            }
          }

          if (!no_tunnel) {

            // ping the target a few times to try and establish a tunnel

            UTTimerEvent event =
                timer.addPeriodicEvent(
                    3000,
                    new UTTimerEventPerformer() {
                      private int pings = 1;

                      public void perform(UTTimerEvent event) {
                        if (pings > 3) {

                          event.cancel();

                          return;
                        }

                        pings++;

                        if (sendTunnelOutbound(target)) {

                          event.cancel();
                        }
                      }
                    });

            if (sendTunnelOutbound(target)) {

              event.cancel();
            }

            // give the other end a few seconds to kick off some tunnel events to us

            if (wait_sem.reserve(10000)) {

              event.cancel();
            }
          }

          // routers often fiddle with the port when not mapped so we need to grab the right one to
          // use
          // for direct communication

          // first priority goes to direct tunnel messages received

          int transport_port = 0;

          try {
            punch_mon.enter();

            transport_port = ((Integer) wait_data[2]).intValue();

          } finally {

            punch_mon.exit();
          }

          if (transport_port != 0) {

            InetSocketAddress existing_address = target.getTransportAddress();

            if (transport_port != existing_address.getPort()) {

              target.setTransportAddress(
                  new InetSocketAddress(existing_address.getAddress(), transport_port));
            }
          }

          Map target_client_data = (Map) response.get("client_data");

          if (target_client_data == null) {

            target_client_data = new HashMap();
          }

          return (target_client_data);
        }
      }

      return (null);

    } catch (Throwable e) {

      log(e);

      return (null);

    } finally {

      try {
        punch_mon.enter();

        oustanding_punches.remove(wait_data);

      } finally {

        punch_mon.exit();
      }
    }
  }