# DNS Name auf Vorhandensein überprüfen



## Wäscheleine (1. Mrz 2017)

Hallo,
ich möchte gerne IP Adressen auflösen und eine Exception ob dies funktioniert oder nicht.
Aber das will irgendwie nicht funktionieren:


```
if (!inet.isReachable(500)){
          byte[] address = {first, second, third, fourth};
    
        try {
            
               
InetAddress byAddress = InetAddress.getByAddress(address);
                  System.out.println("byAddress= " + byAddress.getHostName());
             
              
              
    } catch (final UnknownHostException e) {
          jTextArea1.append(inet + " Error\n");
          System.err.println(e);
    
    }  
}
```

Output:
byAddress= 192.168.50.1
byAddress= pcName1.abc.local
byAddress= pcName2.abc.local
byAddress= 192.168.50.7
byAddress= 192.168.50.18
byAddress= 192.168.50.20


Ich möchte ihm nur folgendes sagen: Wenn IP ist nicht erreichbar dann versuche den DNS Namen herrauszufinden, ist dies nicht möglich bzw ist kein Name vorhanden dann System.out.println("Juhuuu!");

Kann ich die PC Namen im Output irgendwie rausfiltern? Die möchte ich garnicht sehen.


Gruß


----------



## VfL_Freak (1. Mrz 2017)

Moin,

Du könntest die Ausgabe vor dem Ausgeben mit einem RegEx prüfen !
Mal schnell gegooglet: http://stackoverflow.com/questions/5284147/validating-ipv4-addresses-with-regexp

Gruß Klaus


----------



## krgewb (1. Mrz 2017)

Sind das zwei verschiedene Fragen?


Wäscheleine hat gesagt.:


> ich möchte gerne IP Adressen auflösen und eine Exception ob dies funktioniert oder nicht.
> Aber das will irgendwie nicht funktionieren


und


Wäscheleine hat gesagt.:


> Kann ich die PC Namen im Output irgendwie rausfiltern? Die möchte ich garnicht sehen.


----------



## Wäscheleine (2. Mrz 2017)

Hallo,
eigentlich schon da ich mir nicht anders zu helfen weiß momentan.

Ich habe auch schon folgendes versucht: 

```
private static boolean isHostname(String ipaddr) {
   System.err.println(ipaddr);
  
    char[] ca = ipaddr.toCharArray();
    for (int i = 0; i < ca.length; i++) {
      if (!Character.isDigit(ca[i])) {  
        if (ca[i] != '.') {
            return true;
        }
        }
      }
    return false;
  }
```

Allerdings ist es so das ich als Ergebnisse eine IP mit einem Slash vorne dran bekomme.
Also sowas wie /192.168.1.5

Natürlich erkennt Java dann daraus keinen Digit mehr. :/


----------



## VfL_Freak (2. Mrz 2017)

Moin,

kannst Du das erste Zeichen nicht einfach überspringen ??
_for (int i = *1*; i < (ca.length-1); i++)_

Gruß Klaus


----------



## Wäscheleine (2. Mrz 2017)

Ich poste am besten mal den ganzen try Block, kann sein dass der Code an vielen Stellen nicht optimal ist aber ich habe viel rumprobiert:

```
try {
         
      //IP Adresse in einzelne Oktette
      int FSTOKK = 192;
      int SNDOKK = 168;
      int THDOKK = Integer.parseInt(txtFld1.getText());
      int FOUOKK = Integer.parseInt(txtFld2.getText());
      int MAX_IP = Integer.parseInt(txtFld4.getText());
      //Zähler für Progressbar
      int zaehler = 0;
      //Punkt in der IP Adresse
      String Punkt = ".";
     
      //Berechnung Progressbar
      double Differenz = MAX_IP - FOUOKK;
     //Solange IP VON-BIS
      while(FOUOKK <= MAX_IP){
      //Hochzählen
      zaehler++;
      //IP zusammenbauen
      String ipAddress = FSTOKK+Punkt+SNDOKK+Punkt+THDOKK+Punkt+FOUOKK++;
      InetAddress inet = InetAddress.getByName(ipAddress);
     
      String IPADRESSE = inet.getHostAddress();
      //System.err.println (IPADRESSE);
      IPADRESSE = inet.getHostName();
      //System.err.println(IPADRESSE);
     
     
       //IP in Byte umwandeln
       byte first =(byte)FSTOKK;
       byte second =(byte)SNDOKK;
       byte third =(byte)THDOKK;
       byte fourth =(byte)FOUOKK;
       //IP aus Bytes zusammensetzen
       byte[] address = {first, second, third, fourth}; 
     
       //Progressbar %
       double Fortschritt;
    
        //Progressbar berechnung
        Fortschritt = Math.round(100 * zaehler / (Differenz + 1));
        int Fort = (int) Fortschritt;
        jProgressBar1.setValue(Fort);
        String FortZwei = Integer.toString(Fort);
        jProgressBar1.setString(FortZwei + "%");
        jProgressBar1.update(jProgressBar1.getGraphics());
       
            //WENN IP IST NICHT ERREICHBAR
            if (!inet.isReachable(5000)){
                System.out.println(inet.getHostAddress()+ " Get Host Address\n");
                //DANN versuchen hostname aufzulösen
                if (isHostname(IPADRESSE)) {
                     System.out.println("Zweit if in isReachable");
                   
                    for (int i = 0; i < address.length; i++) {
                    int unsignedByte = address[i] < 0 ? address[i] + 256
                    : address[i];
                    System.out.print(unsignedByte + ".");
                   
      }
            System.out.println();
    }       else { // Es ist eine IP
                    try {
                       
                    System.out.println(InetAddress.getByName(IPADRESSE));
      }             catch (UnknownHostException e) {
                    System.out.println("Name konnte nicht aufgelöst werden:  " + inet.toString());
      }
         
      
    }
       
       
      }
      }
      }
       
      catch ( Exception e ) {
      System.out.println("Exception:" + e.getMessage());
      JOptionPane.showMessageDialog(null, e, "Fehler", JOptionPane.ERROR_MESSAGE);
      }
        jTextArea1.append(("Ende"));
      
   
      
    }                                       
private static boolean isHostname(String IPADRESSE) {
   System.err.println(IPADRESSE);
  
    char[] ca = IPADRESSE.toCharArray();
    for (int i = 1; i < (ca.length-1); i++) {
      if (!Character.isDigit(ca[i])) {
          System.out.println ("ipHostname if 1");
        if (ca[i] != '/') {
            System.out.println(IPADRESSE + " Boolean is Hostname != /");
            return true;
           
        }
        }
      }
    System.out.println("return false");
    return false;
  }
```


Bei diesem Beispielprogramm hier bekomme ich beispielsweise immer IP und Hostname ausgegeben. Wenn der Hostname nicht aufgelöst werden kann dann erscheint die IP:


```
package testapp;
import java.net.InetAddress;
import java.net.UnknownHostException;

public class TestApp
{
public static void main(String[] args)
  {
    String  host = "192.168.50.1";
    new TestApp().resolve(host); 
  }
  public void resolve(String host)
  {
    try
    {
       
      InetAddress inetAddress = InetAddress.getByName(host);

      System.out.println("Host: " +
          inetAddress.getHostName());
      System.out.println("IP Address: " +
          inetAddress.getHostAddress());
    }
    catch (UnknownHostException e)
    {
      e.printStackTrace();
    }
  }

 

}
```


Output:
Host: 192.168.50.1
IP Address: 192.168.50.1


----------

