示例#1
0
  protected void logAlert(int type, String resource, String[] params) {
    String text =
        plugin_interface
            .getUtilities()
            .getLocaleUtilities()
            .getLocalisedMessageText(resource, params);

    log.logAlertRepeatable(type, text);
  }
示例#2
0
  protected void updateIgnoreList() {
    try {
      String param = "";

      if (ignore_bad_devices.getValue()) {

        PluginConfig pc = plugin_interface.getPluginconfig();

        Map ignored = pc.getPluginMapParameter("upnp.device.ignorelist", new HashMap());

        Iterator it = ignored.entrySet().iterator();

        while (it.hasNext()) {

          Map.Entry entry = (Map.Entry) it.next();

          Map value = (Map) entry.getValue();

          param += "\n    " + entry.getKey() + ": " + new String((byte[]) value.get("Location"));
        }

        if (ignored.size() > 0) {

          log.log("Devices currently being ignored: " + param);
        }
      }

      String text =
          plugin_interface
              .getUtilities()
              .getLocaleUtilities()
              .getLocalisedMessageText("upnp.ignorebaddevices.info", new String[] {param});

      ignored_devices_list.setLabelText(text);

    } catch (Throwable e) {

      Debug.printStackTrace(e);
    }
  }
示例#3
0
  protected void ignoreDevice(String USN, URL location) {
    // only take note of this if enabled to do so

    if (ignore_bad_devices.getValue()) {

      try {
        PluginConfig pc = plugin_interface.getPluginconfig();

        Map ignored = pc.getPluginMapParameter("upnp.device.ignorelist", new HashMap());

        Map entry = (Map) ignored.get(USN);

        if (entry == null) {

          entry = new HashMap();

          entry.put("Location", location.toString().getBytes());

          ignored.put(USN, entry);

          pc.setPluginMapParameter("upnp.device.ignorelist", ignored);

          updateIgnoreList();

          String text =
              plugin_interface
                  .getUtilities()
                  .getLocaleUtilities()
                  .getLocalisedMessageText(
                      "upnp.ignorebaddevices.alert", new String[] {location.toString()});

          log.logAlertRepeatable(LoggerChannel.LT_WARNING, text);
        }
      } catch (Throwable e) {

        Debug.printStackTrace(e);
      }
    }
  }
示例#4
0
  public void initialize(PluginInterface _plugin_interface) {
    plugin_interface = _plugin_interface;

    log = plugin_interface.getLogger().getTimeStampedChannel("UPnP");
    log.setDiagnostic();
    log.setForce(true);

    UIManager ui_manager = plugin_interface.getUIManager();

    final BasicPluginViewModel model = ui_manager.createBasicPluginViewModel("UPnP");
    model.setConfigSectionID(UPNP_PLUGIN_CONFIGSECTION_ID);

    BasicPluginConfigModel upnp_config =
        ui_manager.createBasicPluginConfigModel(
            ConfigSection.SECTION_PLUGINS, UPNP_PLUGIN_CONFIGSECTION_ID);

    // NATPMP

    BasicPluginConfigModel natpmp_config =
        ui_manager.createBasicPluginConfigModel(
            UPNP_PLUGIN_CONFIGSECTION_ID, NATPMP_PLUGIN_CONFIGSECTION_ID);

    natpmp_config.addLabelParameter2("natpmp.info");

    ActionParameter natpmp_wiki =
        natpmp_config.addActionParameter2("Utils.link.visit", "MainWindow.about.internet.wiki");

    natpmp_wiki.setStyle(ActionParameter.STYLE_LINK);

    natpmp_wiki.addListener(
        new ParameterListener() {
          public void parameterChanged(Parameter param) {
            try {
              plugin_interface.getUIManager().openURL(new URL("http://wiki.vuze.com/w/NATPMP"));

            } catch (Throwable e) {

              e.printStackTrace();
            }
          }
        });

    natpmp_enable_param =
        natpmp_config.addBooleanParameter2("natpmp.enable", "natpmp.enable", false);

    nat_pmp_router =
        natpmp_config.addStringParameter2("natpmp.routeraddress", "natpmp.routeraddress", "");

    natpmp_enable_param.addListener(
        new ParameterListener() {
          public void parameterChanged(Parameter param) {
            setNATPMPEnableState();
          }
        });

    natpmp_enable_param.addEnabledOnSelection(nat_pmp_router);

    // UPNP

    upnp_config.addLabelParameter2("upnp.info");
    upnp_config.addHyperlinkParameter2("upnp.wiki_link", "http://wiki.vuze.com/w/UPnP");

    upnp_enable_param = upnp_config.addBooleanParameter2("upnp.enable", "upnp.enable", true);

    grab_ports_param = upnp_config.addBooleanParameter2("upnp.grabports", "upnp.grabports", false);

    release_mappings_param =
        upnp_config.addBooleanParameter2("upnp.releasemappings", "upnp.releasemappings", true);

    ActionParameter refresh_param =
        upnp_config.addActionParameter2("upnp.refresh.label", "upnp.refresh.button");

    refresh_param.addListener(
        new ParameterListener() {
          public void parameterChanged(Parameter param) {
            UPnPPlugin.this.refreshMappings();
          }
        });

    // Auto-refresh mappings every minute when enabled.
    final BooleanParameter auto_refresh_on_bad_nat_param =
        upnp_config.addBooleanParameter2(
            "upnp.refresh_on_bad_nat", "upnp.refresh_mappings_on_bad_nat", false);
    plugin_interface
        .getUtilities()
        .createTimer("upnp mapping auto-refresh", true)
        .addPeriodicEvent(
            1 * 60 * 1000,
            new UTTimerEventPerformer() {
              private long last_bad_nat = 0;

              public void perform(UTTimerEvent event) {
                if (upnp == null) {
                  return;
                }
                if (!auto_refresh_on_bad_nat_param.getValue()) {
                  return;
                }
                if (!upnp_enable_param.getValue()) {
                  return;
                }
                int status = plugin_interface.getConnectionManager().getNATStatus();
                if (status == ConnectionManager.NAT_BAD) {
                  // Only try to refresh the mappings if this is the first bad NAT
                  // message we've been given in the last 15 minutes - we don't want
                  // to endlessly retry performing the mappings
                  long now = plugin_interface.getUtilities().getCurrentSystemTime();
                  if (last_bad_nat + (15 * 60 * 1000) < now) {
                    last_bad_nat = now;
                    log.log(
                        LoggerChannel.LT_WARNING,
                        "NAT status is firewalled - trying to refresh UPnP mappings");
                    refreshMappings(true);
                  }
                }
              }
            });

    upnp_config.addLabelParameter2("blank.resource");

    alert_success_param =
        upnp_config.addBooleanParameter2("upnp.alertsuccess", "upnp.alertsuccess", false);

    alert_other_port_param =
        upnp_config.addBooleanParameter2(
            "upnp.alertothermappings", "upnp.alertothermappings", true);

    alert_device_probs_param =
        upnp_config.addBooleanParameter2(
            "upnp.alertdeviceproblems", "upnp.alertdeviceproblems", true);

    selected_interfaces_param =
        upnp_config.addStringParameter2("upnp.selectedinterfaces", "upnp.selectedinterfaces", "");
    selected_addresses_param =
        upnp_config.addStringParameter2("upnp.selectedaddresses", "upnp.selectedaddresses", "");

    ignore_bad_devices =
        upnp_config.addBooleanParameter2("upnp.ignorebaddevices", "upnp.ignorebaddevices", true);

    ignored_devices_list = upnp_config.addLabelParameter2("upnp.ignorebaddevices.info");

    ActionParameter reset_param =
        upnp_config.addActionParameter2(
            "upnp.ignorebaddevices.reset", "upnp.ignorebaddevices.reset.action");

    reset_param.addListener(
        new ParameterListener() {
          public void parameterChanged(Parameter param) {
            PluginConfig pc = plugin_interface.getPluginconfig();

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

              String key = "upnp.device.stats." + STATS_KEYS[i];

              pc.setPluginMapParameter(key, new HashMap());
            }

            pc.setPluginMapParameter("upnp.device.ignorelist", new HashMap());

            updateIgnoreList();
          }
        });

    trace_to_log =
        upnp_config.addBooleanParameter2("upnp.trace_to_log", "upnp.trace_to_log", false);

    final boolean enabled = upnp_enable_param.getValue();

    upnp_enable_param.addEnabledOnSelection(alert_success_param);
    upnp_enable_param.addEnabledOnSelection(grab_ports_param);
    upnp_enable_param.addEnabledOnSelection(refresh_param);
    upnp_enable_param.addEnabledOnSelection(alert_other_port_param);
    upnp_enable_param.addEnabledOnSelection(alert_device_probs_param);
    upnp_enable_param.addEnabledOnSelection(release_mappings_param);
    upnp_enable_param.addEnabledOnSelection(selected_interfaces_param);
    upnp_enable_param.addEnabledOnSelection(selected_addresses_param);
    upnp_enable_param.addEnabledOnSelection(ignore_bad_devices);
    upnp_enable_param.addEnabledOnSelection(ignored_devices_list);
    upnp_enable_param.addEnabledOnSelection(reset_param);
    upnp_enable_param.addEnabledOnSelection(trace_to_log);

    natpmp_enable_param.setEnabled(enabled);

    model.getStatus().setText(enabled ? "Running" : "Disabled");

    upnp_enable_param.addListener(
        new ParameterListener() {
          public void parameterChanged(Parameter p) {
            boolean e = upnp_enable_param.getValue();

            natpmp_enable_param.setEnabled(e);

            model.getStatus().setText(e ? "Running" : "Disabled");

            if (e) {

              startUp();

            } else {

              closeDown(true);
            }

            setNATPMPEnableState();
          }
        });

    model.getActivity().setVisible(false);
    model.getProgress().setVisible(false);

    log.addListener(
        new LoggerChannelListener() {
          public void messageLogged(int type, String message) {
            model.getLogArea().appendText(message + "\n");
          }

          public void messageLogged(String str, Throwable error) {
            model.getLogArea().appendText(error.toString() + "\n");
          }
        });

    // startup() used to be called on initializationComplete()
    // Moved to delayed task because rootDeviceFound can take
    // a lot of CPU cycle.  Let's hope nothing breaks
    DelayedTask dt =
        plugin_interface
            .getUtilities()
            .createDelayedTask(
                new Runnable() {
                  public void run() {
                    if (enabled) {

                      updateIgnoreList();

                      startUp();
                    }
                  }
                });
    dt.queue();

    plugin_interface.addListener(
        new PluginListener() {
          public void initializationComplete() {}

          public void closedownInitiated() {
            if (services.size() == 0) {

              plugin_interface.getPluginconfig().setPluginParameter("plugin.info", "");
            }
          }

          public void closedownComplete() {
            closeDown(true);
          }
        });
  }