private final void socketrun() {
   do {
     if (link.socketport != 0) {
       try {
         Socket socket =
             new Socket(InetAddress.getByName(getCodeBase().getHost()), link.socketport);
         socket.setSoTimeout(30000);
         socket.setTcpNoDelay(true);
         link.s = socket;
       } catch (Exception _ex) {
         link.s = null;
       }
       link.socketport = 0;
     }
     if (link.runme != null) {
       Thread thread = new Thread(link.runme);
       thread.setDaemon(true);
       thread.start();
       link.runme = null;
     }
     if (link.iplookup != null) {
       String s = "unknown";
       try {
         s = InetAddress.getByName(link.iplookup).getHostName();
       } catch (Exception _ex) {
       }
       link.host = s;
       link.iplookup = null;
     }
     try {
       Thread.sleep(100L);
     } catch (Exception _ex) {
     }
   } while (true);
 }
示例#2
1
  private String detectAgentUrl(
      HttpServer pServer, JolokiaServerConfig pConfig, String pContextPath) {
    serverAddress = pServer.getAddress();
    InetAddress realAddress;
    int port;
    if (serverAddress != null) {
      realAddress = serverAddress.getAddress();
      if (realAddress.isAnyLocalAddress()) {
        try {
          realAddress = NetworkUtil.getLocalAddress();
        } catch (IOException e) {
          try {
            realAddress = InetAddress.getLocalHost();
          } catch (UnknownHostException e1) {
            // Ok, ok. We take the original one
            realAddress = serverAddress.getAddress();
          }
        }
      }
      port = serverAddress.getPort();
    } else {
      realAddress = pConfig.getAddress();
      port = pConfig.getPort();
    }

    return String.format(
        "%s://%s:%d%s", pConfig.getProtocol(), realAddress.getHostAddress(), port, pContextPath);
  }
 /** A helper api to add remote IP address */
 static void addRemoteIP(StringBuilder b) {
   InetAddress ip = Server.getRemoteIp();
   // ip address can be null for testcases
   if (ip != null) {
     add(Keys.IP, ip.getHostAddress(), b);
   }
 }
示例#4
0
    @Override
    protected Void doInBackground(Void... params) {

      try {
        Enumeration<NetworkInterface> networkInterfaces = NetworkInterface.getNetworkInterfaces();
        while (networkInterfaces.hasMoreElements()) {

          NetworkInterface thisInterface = networkInterfaces.nextElement();
          Enumeration<InetAddress> inetAddresses = thisInterface.getInetAddresses();
          if (inetAddresses.hasMoreElements()) {
            String niInfo = thisInterface.getDisplayName() + "\n";

            while (inetAddresses.hasMoreElements()) {
              InetAddress thisAddress = inetAddresses.nextElement();
              niInfo += "---\n";
              niInfo += "Address: " + thisAddress.getAddress() + "\n";
              niInfo += "CanonicalHostName: " + thisAddress.getCanonicalHostName() + "\n";
              niInfo += "HostAddress: " + thisAddress.getHostAddress() + "\n";
              niInfo += "HostName: " + thisAddress.getHostName() + "\n";
            }

            publishProgress(niInfo);
          }
        }
      } catch (SocketException e) {
        e.printStackTrace();
      }
      return null;
    }
示例#5
0
  /**
   * Connects this CDDB instance to the CDDB server running on the supplied host using the specified
   * port.
   *
   * <p><b>Note well:</b> you must close a CDDB connection once you are done with it, otherwise the
   * socket connection will remain open and pointlessly consume machine resources.
   *
   * @param hostname The host to which to connect.
   * @param port The port number on which to connect to the host.
   * @exception IOException Thrown if a network error occurs attempting to connect to the host.
   * @exception CDDBException Thrown if an error occurs after identifying ourselves to the host.
   * @return The message supplied with the succesful connection response.
   * @see #close
   */
  public String connect(String hostname, int port) throws IOException, CDDBException {
    // obtain the necessary information we'll need to identify
    // ourselves to the CDDB server
    String localhost = InetAddress.getLocalHost().getHostName();
    String username = System.getProperty("user.name");
    if (username == null) {
      username = "anonymous";
    }

    // establish our socket connection and IO streams
    InetAddress addr = InetAddress.getByName(hostname);
    _sock = new Socket(addr, port);
    _in = new BufferedReader(new InputStreamReader(_sock.getInputStream()));
    _out = new PrintStream(new BufferedOutputStream(_sock.getOutputStream()));

    // first read (and discard) the banner string
    _in.readLine();

    // send a hello request
    StringBuilder req = new StringBuilder("cddb hello ");
    req.append(username).append(" ");
    req.append(localhost).append(" ");
    req.append(CLIENT_NAME).append(" ");
    req.append(CLIENT_VERSION);

    Response rsp = request(req.toString());

    // confirm that the response was a successful one
    if (CDDBProtocol.codeFamily(rsp.code) != CDDBProtocol.OK
        && rsp.code != 402 /* already shook hands */) {
      throw new CDDBException(rsp.code, rsp.message);
    }

    return rsp.message;
  }
示例#6
0
  /**
   * Special Yahoo connect routines. We resolve hostname IP address and try each one until connected
   *
   * @param account
   * @param store
   * @return
   * @throws java.net.UnknownHostException
   */
  private static int yahooConnect(
      Account account, IMAPStore store, boolean specialYahooConnectEnabled)
      throws UnknownHostException, MessagingException {
    int connectionAttempts = 0;
    store.SetIDCommand(
        "ID (\"vendor\" \"Zimbra\" \"os\" \"Windows XP\" \"os-version\" \"5.1\" \"guid\" \"4062-5711-9195-4050\")");

    if (specialYahooConnectEnabled) {
      InetAddress[] addresses = InetAddress.getAllByName(account.getReceiveHost());

      for (InetAddress address : addresses) {
        try {
          store.connect(address.getHostAddress(), account.getLoginName(), account.getPassword());

          connectionAttempts++;

          break;
        } catch (Throwable t) {
        }
      }
    } else {
      store.connect(account.getReceiveHost(), account.getLoginName(), account.getPassword());

      connectionAttempts++;
    }

    return connectionAttempts;
  }
示例#7
0
  /**
   * Add a standardised amount of information about an interface. This is in the form:
   *
   * <pre>
   *     [interfaces]
   *       |
   *       |
   *       +--[ id ] (branch)
   *       |   |
   *       |   +-- "order"  (integer metric: 1 .. 2 ..)
   *       |   +-- "FQDN" (string metric: the host's FQDN, as presented by the door)
   *       |   +-- "address" (string metric: the host's address; e.g., "127.0.0.1")
   *       |   +-- "address-type"    (string metric: "IPv4", "IPv6" or "unknown")
   *       |   +-- "scope"    (string metric: "IPv4", "IPv6" or "unknown")
   *       |
   * </pre>
   *
   * @param update The StateUpdate to append the new metrics.
   * @param parentPath the path that the id branch will be added.
   * @param lifetime how long the created metrics should last.
   */
  private void addInterfaceInfo(
      StateUpdate update, StatePath parentPath, InetAddress address, long lifetime) {
    StatePath pathToInterfaceBranch = parentPath.newChild(address.getHostAddress());

    String hostName = address.getHostName();
    update.appendUpdate(
        pathToInterfaceBranch.newChild("FQDN"), new StringStateValue(hostName, lifetime));

    String urlName = (isInetAddress(hostName)) ? toUriString(address) : hostName;
    update.appendUpdate(
        pathToInterfaceBranch.newChild("url-name"), new StringStateValue(urlName, lifetime));

    update.appendUpdate(
        pathToInterfaceBranch.newChild("address"),
        new StringStateValue(address.getHostAddress(), lifetime));
    update.appendUpdate(
        pathToInterfaceBranch.newChild("address-type"),
        new StringStateValue(
            (address instanceof Inet4Address)
                ? "IPv4"
                : (address instanceof Inet6Address) ? "IPv6" : "unknown",
            lifetime));
    update.appendUpdate(
        pathToInterfaceBranch.newChild("scope"),
        new StringStateValue(NetworkUtils.InetAddressScope.of(address).toString().toLowerCase()));
  }
示例#8
0
文件: ArpPacket.java 项目: sjroot/lab
 @Override
 public String toString() {
   if (isRequest())
     return String.format(
         "Who has %s? Tell %s", targetIp.getHostAddress(), senderIp.getHostAddress());
   else return String.format("%s is at %s", senderIp.getHostAddress(), senderMac);
 }
示例#9
0
  public static String getIPAddress(boolean useIPv4) throws SocketException {
    List<NetworkInterface> interfaces = Collections.list(NetworkInterface.getNetworkInterfaces());
    for (NetworkInterface intf : interfaces) {
      List<InetAddress> addrs = Collections.list(intf.getInetAddresses());
      for (InetAddress addr : addrs) {
        if (!addr.isLoopbackAddress()) {
          String sAddr = addr.getHostAddress().toUpperCase();
          boolean isIPv4 = InetAddressUtils.isIPv4Address(sAddr);

          if (useIPv4) {
            if (isIPv4) return sAddr;
          } else {
            if (!isIPv4) {
              if (sAddr.startsWith("fe80")
                  || sAddr.startsWith("FE80")) // skipping link-local addresses
              continue;
              int delim = sAddr.indexOf('%'); // drop ip6 port suffix
              return delim < 0 ? sAddr : sAddr.substring(0, delim);
            }
          }
        }
      }
    }

    return "";
  }
  @Override
  public DiscoveryResult createResult(ServiceInfo service) {

    if (service.getApplication().contains("mieleathome")) {
      ThingUID uid = getThingUID(service);

      if (uid != null) {
        Map<String, Object> properties = new HashMap<>(2);

        InetAddress[] addresses = service.getInetAddresses();
        if (addresses.length > 0 && addresses[0] != null) {
          properties.put(MieleBindingConstants.HOST, addresses[0].getHostAddress());

          Socket socket = null;
          try {
            socket = new Socket(addresses[0], 80);
            InetAddress ourAddress = socket.getLocalAddress();
            properties.put(MieleBindingConstants.INTERFACE, ourAddress.getHostAddress());
          } catch (IOException e) {
            logger.error(
                "An exception occurred while connecting to the Miele Gateway : '{}'",
                e.getMessage());
          }
        }

        return DiscoveryResultBuilder.create(uid)
            .withProperties(properties)
            .withRepresentationProperty(uid.getId())
            .withLabel("Miele XGW3000 Gateway")
            .build();
      }
    }
    return null;
  }
  private Core() {
    boolean f = false;
    try {
      for (Enumeration en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements(); ) {
        NetworkInterface intf = (NetworkInterface) en.nextElement();
        for (Enumeration enumIpAddr = intf.getInetAddresses(); enumIpAddr.hasMoreElements(); ) {
          InetAddress inetAddress = (InetAddress) enumIpAddr.nextElement();
          if (!inetAddress.isLoopbackAddress() && inetAddress instanceof Inet4Address) {
            String ipAddress = inetAddress.getHostAddress().toString();
            this.ip = inetAddress;
            f = true;
            break;
          }
        }
        if (f) break;
      }
    } catch (SocketException ex) {
      ex.printStackTrace();
      System.exit(1);
    }
    this.teams = new HashMap<String, Team>();
    this.judges = new HashMap<String, Judge>();
    this.problems = new HashMap<String, ProblemInfo>();
    this.scheduler = new Scheduler();
    this.timer = new ContestTimer(300 * 60);

    try {
      readConfigure();
    } catch (FileNotFoundException e) {
      e.printStackTrace();
      System.exit(1);
    }
    this.scoreBoardHttpServer = new ScoreBoardHttpServer(this.scoreBoardPort);
  }
示例#12
0
  private NetworkInterface GetExternalNetworkInterface() {
    try {
      // iterate over the network interfaces known to java
      Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
      OUTER:
      for (NetworkInterface interface_ : Collections.list(interfaces)) {
        // we shouldn't care about loopback addresses
        if (interface_.isLoopback()) continue;

        // if you don't expect the interface to be up you can skip this
        // though it would question the usability of the rest of the code
        if (!interface_.isUp()) continue;

        // iterate over the addresses associated with the interface
        Enumeration<InetAddress> addresses = interface_.getInetAddresses();
        for (InetAddress address : Collections.list(addresses)) {
          // look only for ipv4 addresses
          if (address instanceof Inet6Address) continue;

          // use a timeout big enough for your needs
          if (!address.isReachable(3000)) continue;

          return interface_;
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
    return null;
  }
示例#13
0
  static void readConfig() {
    tracker_ip = COConfigurationManager.getStringParameter("Tracker IP", "");

    tracker_ip = UrlUtils.expandIPV6Host(tracker_ip);

    String override_ips = COConfigurationManager.getStringParameter("Override Ip", "");

    StringTokenizer tok = new StringTokenizer(override_ips, ";");

    Map new_override_map = new HashMap();

    while (tok.hasMoreTokens()) {

      String ip = tok.nextToken().trim();

      if (ip.length() > 0) {

        new_override_map.put(AENetworkClassifier.categoriseAddress(ip), ip);
      }
    }

    override_map = new_override_map;

    InetAddress bad = NetworkAdmin.getSingleton().getSingleHomedServiceBindAddress();

    if (bad == null || bad.isAnyLocalAddress()) {

      bind_ip = "";

    } else {

      bind_ip = bad.getHostAddress();
    }
  }
示例#14
0
文件: UUID.java 项目: nmvr2600/citrus
  /** 取得local host的地址,如果有可能,取得物理MAC地址。 */
  private static byte[] getLocalHostAddress() {
    Method getHardwareAddress;

    try {
      getHardwareAddress = NetworkInterface.class.getMethod("getHardwareAddress");
    } catch (Exception e) {
      getHardwareAddress = null;
    }

    byte[] addr;

    try {
      InetAddress localHost = InetAddress.getLocalHost();

      if (getHardwareAddress != null) {
        addr =
            (byte[])
                getHardwareAddress.invoke(
                    NetworkInterface.getByInetAddress(localHost)); // maybe null
      } else {
        addr = localHost.getAddress();
      }
    } catch (Exception e) {
      addr = null;
    }

    if (addr == null) {
      addr = new byte[] {127, 0, 0, 1};
    }

    return addr;
  }
示例#15
0
 public MockConnectionInfo(IPv4Addr addr, int port) throws UnknownHostException {
   super(null, ConnectionType.ACTIVE);
   this.remoteAddr = InetAddress.getByAddress(addr.toBytes());
   this.remotePort = port;
   this.localAddr = InetAddress.getLocalHost();
   this.localPort = new Random().nextInt(1000) + 51000;
 }
示例#16
0
  public static String getIPaddress() {
    try {
      for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces();
          en.hasMoreElements(); ) {

        NetworkInterface interf = en.nextElement();

        for (Enumeration<InetAddress> enumIpAddr = interf.getInetAddresses();
            enumIpAddr.hasMoreElements(); ) {

          InetAddress inetAddress = enumIpAddr.nextElement();

          if (!inetAddress.isLoopbackAddress()) {

            String ipAddres = inetAddress.getHostAddress().toString();
            Log.e("ip address: ", ipAddres);
            return ipAddres;
          }
        }
      }
    } catch (SocketException ex) {
      Log.e("SOCKET EXCEPTION in get IP ADDDRESs", ex.toString());
    }
    return null;
  }
  /** Creates the server. */
  public static void main(String args[]) {
    client = null;
    ServerSocket server = null;

    try {
      System.out.print("\nCreating Server...\n");
      // creates the server
      server = new ServerSocket(8008);
      System.out.print("Created\n");
      // get the ip Address and the host name.
      InetAddress localAddr = InetAddress.getLocalHost();
      System.out.println("IP address: " + localAddr.getHostAddress());
      System.out.println("Hostname: " + localAddr.getHostName());

    } catch (IOException e) {
      // sends a
      System.out.println("IO" + e);
    }

    // constantly checks for a new aocket trying to attach itself to the trhead
    while (true) {
      try {
        client = server.accept();
        // create a new thread.
        FinalMultiThread thr = new FinalMultiThread(client);
        System.out.print(client.getInetAddress() + " : " + thr.getUserName() + "\n");
        CliList.add(thr);
        current++;
        thr.start();
      } catch (IOException e) {
        System.out.println(e);
      }
    }
  }
示例#18
0
  // 获得IP地址
  public static String getIpAddr(HttpServletRequest request) {
    String ipAddress = null;
    ipAddress = request.getHeader("x-forwarded-for");
    if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
      ipAddress = request.getHeader("Proxy-Client-IP");
    }
    if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
      ipAddress = request.getHeader("WL-Proxy-Client-IP");
    }
    if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
      ipAddress = request.getRemoteAddr();
      if (ipAddress.equals("127.0.0.1")) {
        // 根据网卡取本机配置的IP
        InetAddress inet = null;
        try {
          inet = InetAddress.getLocalHost();
        } catch (UnknownHostException e) {
          e.printStackTrace();
        }
        ipAddress = inet.getHostAddress();
      }
    }

    // 对于通过多个代理的情况,第一个IP为客户端真实IP,多个IP按照','分割
    if (ipAddress != null && ipAddress.length() > 15) { // "***.***.***.***".length()
      // = 15
      if (ipAddress.indexOf(",") > 0) {
        ipAddress = ipAddress.substring(0, ipAddress.indexOf(","));
      }
    }
    return ipAddress;
  }
  private DatagramChannel connectClient() throws IOException {
    final DatagramChannel client =
        address.isMulticastAddress()
            ? DatagramChannel.open(address.getAddress().length == 4 ? INET : INET6)
            : DatagramChannel.open();

    final InetSocketAddress hostAddress = new InetSocketAddress(port);
    client.configureBlocking(false);
    if (address.isMulticastAddress()) {
      client.setOption(SO_REUSEADDR, true);
      client.bind(hostAddress);
      if (networkInterface != null) {
        // This is probably not needed, because client socket doesn't send datagrams,
        // but since EVERYBODY on the internet configures this for any channels, and
        // I don't see any harm this config could make, I leave it here
        client.setOption(IP_MULTICAST_IF, networkInterface);
        client.join(address, networkInterface);
      } else {
        client.join(address, NetworkInterface.getByInetAddress(hostAddress.getAddress()));
      }
      if (LOG.isDebugEnabled()) LOG.debug("Connecting via multicast, group=" + address);
    } else {
      client.bind(hostAddress);
    }

    if (LOG.isDebugEnabled()) LOG.debug("Listening on port " + port);
    closeables.add(client);
    return client;
  }
示例#20
0
 // ------------------------------------------------------------
 private void extractPacketData(StorageServer serv, DatagramPacket receivePacket)
     throws IOException {
   try {
     byte[] temp = new byte[4];
     System.arraycopy(receivePacket.getData(), 3, temp, 0, 4);
     serv.IP = InetAddress.getByAddress(temp).getHostAddress();
     // System.out.println("serv.ip: " + serv.IP);
     // serv.IP = receivePacket.getAddress().getHostAddress();
     // System.out.println("serv.ip: " + serv.IP);
     // System.out.println("inetaddress.getbyname() : " +
     // InetAddress.getByName(gwIP))
     /*
      * serv.IP = String.valueOf(receivePacket.getData()[3]) + "." +
      * String.valueOf(receivePacket.getData()[4]) + "." +
      * String.valueOf(receivePacket.getData()[5]) + "." +
      * String.valueOf(receivePacket.getData()[6]);
      */ serv.port = (int) (receivePacket.getData()[7] << 8) + receivePacket.getData()[8];
     System.out.println("Connecting to: " + serv.IP + ":" + serv.port);
     Socket s = new Socket(InetAddress.getByName(serv.IP), serv.port);
     serv.sock = s;
   } catch (IOException e) {
     System.out.println(
         "BIG PROBLEM HERE BECAUSE YOU CANNOT CONNECT " + "BACK!!!!!!!! Trying other address");
     try {
       serv.IP = receivePacket.getAddress().getHostAddress();
       System.out.println("Connecting to: " + serv.IP + ":" + serv.port);
       Socket s = new Socket(InetAddress.getByName(serv.IP), serv.port);
       serv.sock = s;
     } catch (IOException f) {
       System.out.println("cannot connect here aswell\n");
       throw new IOException(f);
     }
   }
 }
  /**
   * Returns if the host is currently reachable.
   *
   * <p>If the host is unreachable, this method will not try again for up to 30 seconds.
   *
   * @return If the host is reachable.
   */
  public boolean isAvailable() {
    if (!UpnpDiscoverer.getDevicePingDetection()) return true;

    // We are not protected from the remote address suddenly changing.
    InetAddress remoteAddress = this.remoteAddress;
    if (remoteAddress != null) {
      if (System.currentTimeMillis() > timeout) {
        try {
          boolean returnValue = remoteAddress.isReachable(UpnpDiscoverer.getDevicePingTimeout());

          if (returnValue) {
            return true;
          } else {
            logger.warn("Unable to ping the remote address {}.", remoteAddress.toString());
          }
        } catch (Exception e) {
          logger.error("Unable to ping the remote address {} => ", remoteAddress.toString(), e);
        }

        // Set the timeout for 30 seconds from now. This way when multiple capture devices
        // on one host are unavailable we don't waste time finding out what we already know
        // for at least 30 more seconds which should be more than enough time to find a
        // better capture device or come back to this one and try to use it anyway.
        timeout = System.currentTimeMillis() + 30000;
      }
      return false;
    }

    return true;
  }
示例#22
0
 public boolean isReachable(InetAddress addr, int timeout, NetworkInterface netif, int ttl)
     throws IOException {
   byte[] ifaddr = null;
   int scope = -1;
   int netif_scope = -1;
   if (netif != null) {
     /*
      * Let's make sure we bind to an address of the proper family.
      * Which means same family as addr because at this point it could
      * be either an IPv6 address or an IPv4 address (case of a dual
      * stack system).
      */
     java.util.Enumeration<InetAddress> it = netif.getInetAddresses();
     InetAddress inetaddr = null;
     while (it.hasMoreElements()) {
       inetaddr = it.nextElement();
       if (inetaddr.getClass().isInstance(addr)) {
         ifaddr = inetaddr.getAddress();
         if (inetaddr instanceof Inet6Address) {
           netif_scope = ((Inet6Address) inetaddr).getScopeId();
         }
         break;
       }
     }
     if (ifaddr == null) {
       // Interface doesn't support the address family of
       // the destination
       return false;
     }
   }
   if (addr instanceof Inet6Address) scope = ((Inet6Address) addr).getScopeId();
   return isReachable0(addr.getAddress(), scope, timeout, ifaddr, ttl, netif_scope);
 }
 private void findMachinesBasedOnLocalIp() {
   Optional<InetAddress> localhost = getLocalAddress();
   if (localhost.isPresent()) {
     InetAddress inetAddress = localhost.get();
     myIp = inetAddress.getAddress();
     scanningThreadPool.submit(
         new Runnable() {
           @Override
           public void run() {
             if (!isCancelled()) {
               searchForIp(myIp);
             }
           }
         });
     for (int i = 1; i <= MAX_IPS; i++) {
       final int finalI = i;
       scanningThreadPool.submit(
           new Runnable() {
             @Override
             public void run() {
               if (!isCancelled()) {
                 searchForIp(createSubnetAddress(myIp, (byte) finalI));
               }
             }
           });
     }
   }
 }
  public RConQueryThread(IServer par1IServer) {
    queryPort = ModuleSnooper.port;
    serverHostname = ModuleSnooper.hostname;
    serverPort = par1IServer.getPort();
    queryHostname = "0.0.0.0";
    server = par1IServer;

    if (0 != serverHostname.length() && !queryHostname.equals(serverHostname)) {
      queryHostname = serverHostname;
    } else {
      serverHostname = "0.0.0.0";

      try {
        InetAddress var2 = InetAddress.getLocalHost();
        queryHostname = var2.getHostAddress();
      } catch (UnknownHostException var3) {
        logWarning(
            "Unable to determine local host IP, please set server-ip/hostname in the snooper config : "
                + var3.getMessage());
      }
    }

    if (0 == queryPort) {
      queryPort = serverPort;
      logInfo("Setting default query port to " + queryPort);
    }

    field_72644_p = new HashMap();

    queryClients = new HashMap();
    time = (new Date()).getTime();
  }
示例#25
0
 /**
  * Get IP address from first non-localhost interface
  *
  * @param ipv4 true=return ipv4, false=return ipv6
  * @return address or empty string
  */
 public static String getIPAddress(boolean useIPv4) {
   try {
     List<NetworkInterface> interfaces = Collections.list(NetworkInterface.getNetworkInterfaces());
     for (NetworkInterface intf : interfaces) {
       List<InetAddress> addrs = Collections.list(intf.getInetAddresses());
       for (InetAddress addr : addrs) {
         if (!addr.isLoopbackAddress()) {
           String sAddr = addr.getHostAddress().toUpperCase();
           boolean isIPv4 = InetAddressUtils.isIPv4Address(sAddr);
           if (useIPv4) {
             if (isIPv4) return sAddr;
           } else {
             if (!isIPv4) {
               int delim = sAddr.indexOf('%'); // drop ip6 port
               // suffix
               return delim < 0 ? sAddr : sAddr.substring(0, delim);
             }
           }
         }
       }
     }
   } catch (Exception ex) {
   } // for now eat exceptions
   return "";
 }
示例#26
0
 public static boolean validateProxy(HttpHost p) {
   if (localAddr == null) {
     logger.error("cannot get local IP");
     return false;
   }
   boolean isReachable = false;
   Socket socket = null;
   try {
     socket = new Socket();
     socket.bind(new InetSocketAddress(localAddr, 0));
     InetSocketAddress endpointSocketAddr =
         new InetSocketAddress(p.getAddress().getHostAddress(), p.getPort());
     socket.connect(endpointSocketAddr, 3000);
     logger.debug(
         "SUCCESS - connection established! Local: "
             + localAddr.getHostAddress()
             + " remote: "
             + p);
     isReachable = true;
   } catch (IOException e) {
     logger.warn(
         "FAILRE - CAN not connect! Local: " + localAddr.getHostAddress() + " remote: " + p);
   } finally {
     if (socket != null) {
       try {
         socket.close();
       } catch (IOException e) {
         logger.warn("Error occurred while closing socket of validating proxy", e);
       }
     }
   }
   return isReachable;
 }
 private void setupProxy(
     ConnectivitySettings cs, int connectionType, InetSocketAddress inetSocketAddress) {
   cs.setConnectionType(connectionType);
   InetAddress address = inetSocketAddress.getAddress();
   cs.setProxyHost((address != null) ? address.getHostAddress() : inetSocketAddress.getHostName());
   cs.setProxyPort(inetSocketAddress.getPort());
 }
示例#28
0
 /**
  * 根据网卡取本机配置的内网IP 如果是双网卡的,则取出内网IP
  *
  * @return String 内网IP地址
  */
 public static String getLocalIp() {
   String localip = null; // 本地IP,如果没有配置外网IP则返回它
   try {
     Enumeration<NetworkInterface> netInterfaces = NetworkInterface.getNetworkInterfaces();
     InetAddress ip = null;
     boolean finded = false; // 是否找到外网IP
     while (netInterfaces.hasMoreElements() && !finded) {
       NetworkInterface ni = netInterfaces.nextElement();
       Enumeration<InetAddress> address = ni.getInetAddresses();
       while (address.hasMoreElements()) {
         ip = address.nextElement();
         if (ip.isSiteLocalAddress()
             && !ip.isLoopbackAddress()
             && ip.getHostAddress().indexOf(":") == -1) {
           localip = ip.getHostAddress();
           finded = true;
           break;
         }
       }
     }
   } catch (SocketException e) {
     logger.error(e);
   }
   return localip;
 }
示例#29
0
 /**
  * The name for this host.
  *
  * @see #HOSTNAME
  * @see <a href="http://trac.bigdata.com/ticket/886" >Provide workaround for bad reverse DNS
  *     setups</a>
  */
 public static final String getCanonicalHostName() {
   String s = System.getProperty(HOSTNAME);
   if (s != null) {
     // Trim whitespace.
     s = s.trim();
   }
   if (s != null && s.length() != 0) {
     log.warn("Hostname override: hostname=" + s);
   } else {
     try {
       /*
        * Note: This should be the host *name* NOT an IP address of a
        * preferred Ethernet adaptor.
        */
       s = InetAddress.getLocalHost().getCanonicalHostName();
     } catch (Throwable t) {
       log.warn("Could not resolve canonical name for host: " + t);
     }
     try {
       s = InetAddress.getLocalHost().getHostName();
     } catch (Throwable t) {
       log.warn("Could not resolve name for host: " + t);
       s = "localhost";
     }
   }
   return s;
 }
示例#30
0
 /**
  * 取得本机IP地址 (多网卡主机返回其中一张网卡的IP)
  *
  * @param isInter 是否返回内网IP(默认网段为19.2.)
  * @return 本机ip地址
  */
 public static synchronized String getLocalIP(boolean isInter) {
   // 初始化本地地址列表
   if (localAddressList == null) {
     localAddressList = getLocalAddresses();
   }
   String localIP = "";
   for (InetAddress ia : localAddressList) {
     String ip = ia.getHostAddress();
     // 忽略ipv6地址和loopback地址
     if (ia instanceof Inet6Address || ip.startsWith("127")) {
       continue;
     }
     // 记录找到的第一个ipv4地址
     if (StringUtil.isNullOrBlank(localIP)) {
       localIP = ip;
     }
     if (isInter && ip.startsWith("19.")) {
       return ip;
     }
     if (!isInter && !ip.startsWith("19.")) {
       return ip;
     }
   }
   return localIP;
 }