Пример #1
0
  public DHTSpeedTesterImpl(DHT _dht) {
    dht = _dht;

    plugin_interface = dht.getLogger().getPluginInterface();

    UTTimer timer = plugin_interface.getUtilities().createTimer("DHTSpeedTester:finder", true);

    timer.addPeriodicEvent(
        5000,
        new UTTimerEventPerformer() {
          public void perform(UTTimerEvent event) {
            findContacts();
          }
        });

    timer.addPeriodicEvent(
        1000,
        new UTTimerEventPerformer() {
          int tick_count;

          public void perform(UTTimerEvent event) {
            try {
              pingContacts(tick_count);

            } finally {

              tick_count++;
            }
          }
        });
  }
Пример #2
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));
  }
Пример #3
0
  public void start() {
    if (started) {

      return;
    }

    started = true;

    DHTTransport transport = dht.getTransport();

    transport.addListener(
        new DHTTransportListener() {
          public void localContactChanged(DHTTransportContact local_contact) {
            publish(false);
          }

          public void currentAddress(String address) {}

          public void reachabilityChanged(boolean reacheable) {
            publish(false);
          }
        });

    transport.registerTransferHandler(
        transfer_handler_key,
        new DHTTransportTransferHandler() {
          public String getName() {
            return ("NAT Traversal");
          }

          public byte[] handleRead(DHTTransportContact originator, byte[] key) {
            return (null);
          }

          public byte[] handleWrite(DHTTransportContact originator, byte[] key, byte[] value) {
            return (receiveRequest((DHTTransportUDPContact) originator, value));
          }
        });

    timer.addPeriodicEvent(
        REPUBLISH_TIME_MIN,
        new UTTimerEventPerformer() {
          public void perform(UTTimerEvent event) {
            publish(false);
          }
        });

    timer.addPeriodicEvent(
        RENDEZVOUS_SERVER_TIMEOUT / 2,
        new UTTimerEventPerformer() {
          public void perform(UTTimerEvent event) {
            long now = plugin_interface.getUtilities().getCurrentSystemTime();

            try {
              server_mon.enter();

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

              while (it.hasNext()) {

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

                long time = ((Long) entry[1]).longValue();

                boolean removed = false;

                if (time > now) {

                  // clock change, easiest approach is to remove it

                  it.remove();

                  removed = true;

                } else if (now - time > RENDEZVOUS_SERVER_TIMEOUT) {

                  // timeout

                  it.remove();

                  removed = true;
                }

                if (removed) {

                  log(
                      "Rendezvous "
                          + ((DHTTransportContact) entry[0]).getString()
                          + " removed due to inactivity");
                }
              }
            } finally {

              server_mon.exit();
            }
          }
        });

    publish(false);
  }
Пример #4
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();
      }
    }
  }