Freebox V5 ADSL

Ce petit programme Java permet de vérifier ce bug, pour ceux qui ont un JDK 5 ou plus :

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.InetSocketAddress;
import java.net.MulticastSocket;
import java.net.SocketAddress;
import java.net.SocketTimeoutException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;

public class QuietControlPoint implements Runnable {

  private static final Logger LOGGER = Logger.getLogger(QuietControlPoint.class.getName());
  private static final String CHARSET_NAME = "UTF-8";
  private static final String SSDP_IP = "239.255.255.250";
  private static final int SSDP_PORT = 1900;
  private static final SocketAddress SSDP_ADDRESS = new InetSocketAddress(SSDP_IP, SSDP_PORT);
  private static final int BUF_SIZE = 16 * 1024;
  private static final int PACKET_LENGTH = 2 * 1024;
  private static final int SO_TIMEOUT = 250;
  private final ExecutorService queue = Executors.newSingleThreadExecutor();
  private MulticastSocket socket;
  private byte[] buffer = new byte[BUF_SIZE];
  private int offset = 0;
  private DatagramPacket input = new DatagramPacket(buffer, offset, PACKET_LENGTH);

  public void run() {
      try {
          try {
              init();
              while (System.in.available() == 0) {
                  try {
                      receive();
                  } catch (final SocketTimeoutException ignore) {
                      continue;
                  }
              }
          } finally {
              try {
                  close();
              } catch (final IOException ignore) {
                  LOGGER.log(Level.SEVERE, "", ignore);
              }
          }
      } catch (final Throwable ignore) {
          LOGGER.log(Level.SEVERE, "", ignore);
      }
  }

  private void init() throws IOException {
      socket = new MulticastSocket(new InetSocketAddress(SSDP_PORT));
      socket.setSoTimeout(SO_TIMEOUT);
      socket.setLoopbackMode(false);
      socket.joinGroup(SSDP_ADDRESS, null);
  }

  protected void receive() throws IOException {
      socket.receive(input);
      queue.submit(new Parser(input));

      offset = input.getOffset() + input.getLength();
      if ((BUF_SIZE - PACKET_LENGTH) < offset) {
          buffer = new byte[BUF_SIZE];
          offset = 0;
      }
      input = new DatagramPacket(buffer, offset, PACKET_LENGTH);
  }

  private void close() throws IOException {
      socket.leaveGroup(SSDP_ADDRESS, null);
      socket.close();
      socket = null;
      queue.shutdown();
  }

  private static class Parser implements Runnable {

      private final long now = System.currentTimeMillis();
      private final DatagramPacket packet;

      private Parser(final DatagramPacket packet) {
          this.packet = packet;
      }

      public void run() {
          try {
              final String string = new String(packet.getData(), packet.getOffset(), packet.getLength(),
                      CHARSET_NAME);
              final StringBuilder builder = new StringBuilder();
              builder.append(packet.getSocketAddress()).append("\n").append(string);
              final LogRecord record = new LogRecord(Level.INFO, builder.toString());
              record.setMillis(now);
              LOGGER.log(record);
          } catch (final Throwable ignore) {
              LOGGER.log(Level.SEVERE, "", ignore);
          }
      }
  }

  public static void main(final String[] args) {
      final Thread thread = new Thread(new QuietControlPoint());
      thread.setName(QuietControlPoint.class.getSimpleName());
      thread.start();
  }

}

Oh, rapide ! :)
J’aime ! :)

Merci bien.

Le plus long a été de trouver où signaler ce bug.

Oui, maintenant, depuis la 1.5.5 c’est impeccable : le IGD est reconnu en permanence.

Merci ! :)