//basic java commands
import java.util.*;
import java.io.*;
import java.net.*;
public class bcommand
{
	public static void main(String args[]) throws Exception
	{
	BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	System.out.println("Enter command:");
	String com = br.readLine();
	Process p = Runtime.getRuntime().exec(com);
	p.waitFor();
	BufferedReader reader = new BufferedReader(new InputStreamReader(p.getInputStream()));
	String line = reader.readLine();
	while(line!=null)
	{
	System.out.println(line);
	line=reader.readLine();
	}
	System.out.println("done!!");
	}
}

----
//name and ip of computer
import java.io.*;
import java.net.*;
import java.util.*;
public class bcommand
{
	public static void main(String args[])throws Exception
	{
		System.out.println("Enter the PC name: ");
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String str = br.readLine();
		InetAddress add=InetAddress.getByName(str);
		System.out.println("Local Host Information:");
		System.out.println("HostName: "+add.getHostName());
		System.out.println("IP: "+add.getHostAddress());
		}
}

------
//ipadd and all ipadd
import java.io.*;
import java.util.*;
import java.net.*;
public class bcommand
{
	public static void main(String args[])throws Exception
	{
		System.out.println(InetAddress.getByName("www.google.com"));
		InetAddress[] inetaddress = InetAddress.getAllByName("www.microsoft.com");
		for(InetAddress ipaddress:inetaddress)
		{
			System.out.println(ipaddress);
		}
	}
}

-----
//NetworkInterface
import java.io.*;
import java.util.*;
import java.net.*;
	public class bcommand
	{
		public static void main(String args[])throws Exception
		{
			Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
			if(interfaces == null)
			{
				System.out.println("no interfaces found");
			}
			else
			{
				for(NetworkInterface netif:Collections.list(interfaces))
				{
					System.out.println("Name:"+netif.getName());
					System.out.println("DisplayName:"+netif.getDisplayName());
					System.out.println();
				}
			}
		}
	}

------
//nslookup
import java.io.*;
import java.util.*;
import java.net.*;
public class bcommand
{
	public static void main(String args[])throws Exception
	{
		System.out.println("Enter the host name: ");
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String cmd=br.readLine();
		Process p =Runtime.getRuntime().exec("nslookup "+cmd);
		p.waitFor();
		BufferedReader reader = new BufferedReader(new InputStreamReader(p.getInputStream()));
		String line=reader.readLine();
		while(line!=null)
		{
			System.out.println(line);
			line=reader.readLine();
		}
	}
}

-----
//download http
import java.io.*;
	import java.net.*;
	public class GetJavaUrl
	{
	  public static void main(String[] args)
	     {
	       URL u;
	       InputStream is=null;
	       DataInputStream dis;
	       String s;
	       try
		   {
		     u=new URL("ftp://10.30.2.53");
		     is=u.openStream();
		     dis = new DataInputStream(new BufferedInputStream(is));
		     while((s=dis.readLine())!=null)
		      {
		        System.out.println(s);
		      }
		    }
	       catch(MalformedURLException mue)
		    {
		      System.out.println("404: Error NOT FOUND");
		      mue.printStackTrace();
		      System.exit(1);
		    }
	       catch(IOException ioe)
		    {
		      System.out.println("404: Error NOT FOUND");
		      ioe.printStackTrace();
		      System.exit(1);
		    }
	      finally
		    {
		       try
		           {
		             is.close();
		           }
		       catch(IOException ioe)
		           {
		           }
		    }
	    }

}
import java.util.*;
import java.io.*;
import java.net.*;
public class bcommand {
public static void main(String args[])throws Exception
{
URL url;
File file=new File("a.txt");
try{
url=new URL("http://www.vit.ac.in");
InputStream input=url.OpenStream();
InputStreamReader reader=new InputStreamReader(input);
StreamReader(input);
BufferedReader breader=new BufferedReader(reader);
String line;
FileWriter writer=new FileWriter(file);
while((line=breader.readline())!=null)
{
writer.append(line);
System.out.println(line);
}
writer.close();
breader.close();
reader.close();
}

    catch(Exception e)
    {
        System.out.println(e);
    }}

}
-------
TCP

//list all port hosting tcp
import java.net.Socket;
import java.net.*;

public class bcommand
{
public static void main(String[] args) throws Exception
{
	try {
		for(int i=0;i<1024;i++)
		{
			Socket s=new Socket("localhost",i);
			System.out.println(i);
		}
	}
	catch(Exception e)
	{
		System.out.println(e);
	}
}
}

----
//echo tcp
server:
import java.io.*;
import java.net.*;
public class servertcp
{
public static void main(String args[]) throws Exception
{
try
{
int Port;
BufferedReader Buf =new BufferedReader(new InputStreamReader(System.in));
System.out.print(" Enter the Port Address : " );
Port=Integer.parseInt(Buf.readLine());
ServerSocket sok =new ServerSocket(Port);
System.out.println(" Server is Ready To Receive a Message. ");
System.out.println(" Waiting ..... ");
Socket so=sok.accept();
if(so.isConnected()==true)
            System.out.println(" Client Socket is Connected Succecfully. ");
InputStream in=so.getInputStream();
OutputStream ou=so.getOutputStream();
PrintWriter pr=new PrintWriter(ou);
BufferedReader buf=new BufferedReader(new InputStreamReader(in));
String str=buf.readLine();
System.out.println(" Message Received From Client : " + str);
System.out.println(" This Message is Forwarded To Client. ");
pr.println(str);
pr.flush();
}
 catch(Exception e)
{
  System.out.println(" Error : " + e.getMessage());
}
}
}
client:
import java.io.*;
import java.net.*;
public class clienttcp
{
public static void main(String args[]) throws Exception
{
try {
int Port;
BufferedReader Buf =new BufferedReader(new InputStreamReader(System.in));
System.out.print(" Enter the Port Address : " );
Port=Integer.parseInt(Buf.readLine());
Socket sok=new Socket("localhost",Port);
if(sok.isConnected()==true)
            System.out.println(" Server Socket is Connected Succecfully. ");
InputStream in=sok.getInputStream();
OutputStream ou=sok.getOutputStream();
PrintWriter pr=new PrintWriter(ou);
BufferedReader buf1=new BufferedReader(new InputStreamReader(System.in));
BufferedReader buf2=new BufferedReader(new InputStreamReader(in));
String str1,str2;
System.out.print(" Enter the Message : ");
str1=buf1.readLine();
pr.println(str1);
pr.flush();
System.out.println(" Message Send Successfully. ");
str2=buf2.readLine();
System.out.println(" Message From Server : " + str2);
}
  catch(Exception e)
  {
   System.out.println(" Error : " + e.getMessage());
  }
}
}

-----
//date tcp
server:
import java.net.*;
import java.io.*;
import java.util.*;

class DateServer
{
    public static void main(String args[]) throws Exception
    {
        ServerSocket s=new ServerSocket(5217);
        while(true)
        {
            System.out.println("Waiting For Connection ...");
            Socket soc=s.accept();
            DataOutputStream out=new DataOutputStream(soc.getOutputStream());
            out.writeBytes("Server Date" + (new Date()).toString() + "\n");
            out.close();
            soc.close();
        }
    }
}
client:
import java.io.*;
import java.net.*;

class DateClient
{
    public static void main(String args[]) throws Exception
    {
        Socket soc=new Socket(InetAddress.getLocalHost(),5217);
        BufferedReader in=new BufferedReader( new InputStreamReader(soc.getInputStream()));
        System.out.println(in.readLine());
    }
}

------
//messagebased transfer tcp
server:
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class servertcp
{
    private static Socket socket;
    public static void main(String[] args)
    {
        try
        {
            int port = 25000;
            ServerSocket serverSocket = new ServerSocket(port);
            System.out.println("Server Started and listening to the port 25000");
            while(true)
            {
                socket = serverSocket.accept();
                InputStream is = socket.getInputStream();
                InputStreamReader isr = new InputStreamReader(is);
                BufferedReader br = new BufferedReader(isr);
                String number = br.readLine();
                System.out.println("Message received from client is "+number);
             	String returnMessage;
                try
                {
                    int numberInIntFormat = Integer.parseInt(number);
                    int returnValue = numberInIntFormat*2;
                    returnMessage = String.valueOf(returnValue) + "\n";
                }
                catch(NumberFormatException e)
                {
                    returnMessage = "Please send a proper number\n";
                }
                OutputStream os = socket.getOutputStream();
                OutputStreamWriter osw = new OutputStreamWriter(os);
                BufferedWriter bw = new BufferedWriter(osw);
                bw.write(returnMessage);
                System.out.println("Message sent to the client is "+returnMessage);
                bw.flush();
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            try
            {
                socket.close();
            }
            catch(Exception e){}
       }
    }
}
client:
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.InetAddress;
import java.net.Socket;

public class clienttcp
{
    private static Socket socket;
    public static void main(String args[])
    {
        try
        {
            String host = "localhost";
            int port = 25000;
            InetAddress address = InetAddress.getByName(host);
            socket = new Socket(address, port);
            OutputStream os = socket.getOutputStream();
            OutputStreamWriter osw = new OutputStreamWriter(os);
            BufferedWriter bw = new BufferedWriter(osw);
            String number = "2";
            String sendMessage = number + "\n";
            bw.write(sendMessage);
            bw.flush();
            System.out.println("Message sent to the server : "+sendMessage);
            InputStream is = socket.getInputStream();
            InputStreamReader isr = new InputStreamReader(is);
            BufferedReader br = new BufferedReader(isr);
            String message = br.readLine();
            System.out.println("Message received from the server : " +message);
        }
        catch (Exception exception)
        {
            exception.printStackTrace();
        }
        finally
        {
            try
            {
                socket.close();
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }
        }
    }
}

-------
//tcp text file transfer
server:
import java.io.*;
import java.net.*;

class TCPServer {
    public static void main(String args[]) throws Exception {
        int firsttime = 1;
        while (true) {
            String clientSentence;
            String capitalizedSentence="";
            ServerSocket welcomeSocket = new ServerSocket(3248);
            Socket connectionSocket = welcomeSocket.accept();
            BufferedReader inFromClient = new BufferedReader(new InputStreamReader(connectionSocket.getInputStream()));
            DataOutputStream outToClient = new DataOutputStream(connectionSocket.getOutputStream());
            clientSentence = inFromClient.readLine();
            //System.out.println(clientSentence);
            if (clientSentence.equals("set")) {
                outToClient.writeBytes("connection is ");
                System.out.println("running here");
                //welcomeSocket.close();
                //outToClient.writeBytes(capitalizedSentence);
            }
            capitalizedSentence = clientSentence.toUpperCase() + "\n";
            //if(!clientSentence.equals("quit"))
            outToClient.writeBytes(capitalizedSentence+"enter the message or command: ");
            System.out.println("passed");
            //outToClient.writeBytes("enter the message or command: ");
            welcomeSocket.close();
            System.out.println("connection terminated");
        }
    }
}
client:
import java.io.*;
import java.net.*;

class TCPClient {
 public static void main(String args[]) throws Exception {

        String sentence;
        String modifiedSentence;
        BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));
        Socket clientSocket = new Socket("127.0.0.1", 6789);
        DataOutputStream outToServer = new DataOutputStream(clientSocket.getOutputStream());
        BufferedReader inFromServer = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
        sentence = inFromUser.readLine();
        outToServer.writeBytes(sentence + "\n");
        modifiedSentence = inFromServer.readLine();
        System.out.println("FROM SERVER:" + modifiedSentence);
        clientSocket.close();
    }
}

-----
//chat tcp
server:
import java.io.*;
import java.net.*;

public class servertcp
{
  public static void main(String[] args) throws Exception
  {
      ServerSocket sersock = new ServerSocket(3000);
      System.out.println("Server  ready for chatting");
      Socket sock = sersock.accept( );
      // reading from keyboard (keyRead object)
      BufferedReader keyRead = new BufferedReader(new InputStreamReader(System.in));
      // sending to client (pwrite object)
      OutputStream ostream = sock.getOutputStream();
      PrintWriter pwrite = new PrintWriter(ostream, true);
      // receiving from server ( receiveRead  object)
      InputStream istream = sock.getInputStream();
      BufferedReader receiveRead = new BufferedReader(new InputStreamReader(istream));
      String receiveMessage, sendMessage;
      while(true)
      {
        if((receiveMessage = receiveRead.readLine()) != null)
        {
           System.out.println(receiveMessage);
        }
        sendMessage = keyRead.readLine();
        pwrite.println(sendMessage);
        pwrite.flush();
      }
    }
}
client:
import java.io.*;
import java.net.*;

public class clienttcp
{
  public static void main(String[] args) throws Exception
  {
     Socket sock = new Socket("127.0.0.1", 3000);
     // reading from keyboard (keyRead object)
     BufferedReader keyRead = new BufferedReader(new InputStreamReader(System.in));
     // sending to client (pwrite object)
     OutputStream ostream = sock.getOutputStream();
     PrintWriter pwrite = new PrintWriter(ostream, true);
     // receiving from server ( receiveRead  object)
     InputStream istream = sock.getInputStream();
     BufferedReader receiveRead = new BufferedReader(new InputStreamReader(istream));
     System.out.println("Start the chitchat, type and press Enter key");
     String receiveMessage, sendMessage;
     while(true)
     {
        sendMessage = keyRead.readLine();  // keyboard reading
        pwrite.println(sendMessage);       // sending to server
        pwrite.flush();                    // flush the data
        if((receiveMessage = receiveRead.readLine()) != null) //receive from server
        {
            System.out.println(receiveMessage); // displaying at DOS prompt
        }
      }
    }
}

-----
//username validation
server:
import java.io.*;
import java.net.*;

class servertcp
{

  public static void main(String argv[]) throws Exception
    {
      String username;
      String password;
      String auth;

      ServerSocket welcomeSocket = new ServerSocket(6789);

      while(true) {

            Socket connectionSocket = welcomeSocket.accept();

           BufferedReader inFromClient =
              new BufferedReader(new
              InputStreamReader(connectionSocket.getInputStream()));



           DataOutputStream  outToClient =
             new DataOutputStream(connectionSocket.getOutputStream());

           username = inFromClient.readLine();
	   password = inFromClient.readLine();


           if (username.equals("Admin")){
		if (password.equals("root")){
			auth = "Login Successful!";
		}else{
			auth = "Wrong Password";
		}
	   }else{
		auth = "Wrong Username";
	   }

           outToClient.writeBytes(auth);
	   connectionSocket.close();
        }
    }
}
client:
import java.io.*;
import java.net.*;
class clienttcp
{

    public static void main(String argv[]) throws Exception
    {
        String username;
        String password;
	String auth;

        BufferedReader inFromUser =
          new BufferedReader(new InputStreamReader(System.in));

        Socket clientSocket = new Socket("localhost", 6789);

        DataOutputStream outToServer =
          new DataOutputStream(clientSocket.getOutputStream());

                BufferedReader inFromServer =
          new BufferedReader(new
          InputStreamReader(clientSocket.getInputStream()));

	System.out.print("Username :");
        username = inFromUser.readLine();

	System.out.print("Password :");
	password = inFromUser.readLine();


        outToServer.writeBytes(username + '\n' + password + '\n' );

        auth = inFromServer.readLine();

        System.out.println("FROM SERVER: " + auth);

        clientSocket.close();

    }
}

----
//Arp in tcp/ip
Server:
import java.io.*;
import java.net.*;

class tcparpserver {

  public static void main(String argv[]) throws Exception
    {
      String logicAdd;


      ServerSocket welcomeSocket = new ServerSocket(6789);

      while(true) {

            Socket connectionSocket = welcomeSocket.accept();

           BufferedReader inFromClient =
              new BufferedReader(new
              InputStreamReader(connectionSocket.getInputStream()));


          String logical[] = {"172.16.27.34","195.24.54.204", "10.10.137.1"};
	  String physical[] = {"8E:AE:08:AA","0A:78:6C:AD", "d4:6d:50:84:db:c8"};

           DataOutputStream  outToClient =
             new DataOutputStream(connectionSocket.getOutputStream());

           logicAdd = inFromClient.readLine();
	for(int i=0;i<logical.length;i++)
	{
		if (logicAdd.equals(logical[i]))
		{
			outToClient.writeBytes(physical[i] + "\n");
			connectionSocket.close();
		}
	}


        }
    }
}

Client:
import java.io.*;
import java.net.*;
class tcparpclient {

    public static void main(String argv[]) throws Exception
    {
        String logicAdd;
        String phyAdd;

        BufferedReader inFromUser =
          new BufferedReader(new InputStreamReader(System.in));

        Socket clientSocket = new Socket("localhost", 6789);

        DataOutputStream outToServer =
          new DataOutputStream(clientSocket.getOutputStream());

                BufferedReader inFromServer =
          new BufferedReader(new
          InputStreamReader(clientSocket.getInputStream()));

	System.out.println("Enter logical address of host");
        logicAdd = inFromUser.readLine();

        outToServer.writeBytes(logicAdd + '\n');

        phyAdd = inFromServer.readLine();

        System.out.println("FROM SERVER: Physical Address " + phyAdd);

        clientSocket.close();

    }
}

---------

//RARP in tcp

Server:
import java.io.*;
import java.net.*;

class tcprarpserver {

  public static void main(String argv[]) throws Exception
    {
      String phyAdd;


      ServerSocket welcomeSocket = new ServerSocket(6789);

      while(true) {

            Socket connectionSocket = welcomeSocket.accept();

           BufferedReader inFromClient =
              new BufferedReader(new
              InputStreamReader(connectionSocket.getInputStream()));


          String logical[] = {"172.16.27.34","195.24.54.204", "10.10.137.1"};
          String physical[] = {"8E:AE:08:AA","0A:78:6C:AD", "d4:6d:50:84:db:c8"};

           DataOutputStream  outToClient =
             new DataOutputStream(connectionSocket.getOutputStream());

           phyAdd = inFromClient.readLine();
        for(int i = 0; i < physical.length; i++)
        {
                if (phyAdd.equals(physical[i]))
                {
                        outToClient.writeBytes(logical[i] + "\n");
                        connectionSocket.close();
                }
        }


        }
    }
}

Client:
import java.io.*;
import java.net.*;
class tcprarpclient {

    public static void main(String argv[]) throws Exception
    {
        String logicAdd;
        String phyAdd;

        BufferedReader inFromUser =
          new BufferedReader(new InputStreamReader(System.in));

        Socket clientSocket = new Socket("localhost", 6789);

        DataOutputStream outToServer =
          new DataOutputStream(clientSocket.getOutputStream());

                BufferedReader inFromServer =
          new BufferedReader(new
          InputStreamReader(clientSocket.getInputStream()));

        System.out.println("Enter Physical address of host");
        phyAdd = inFromUser.readLine();

        outToServer.writeBytes(phyAdd + '\n');

        logicAdd = inFromServer.readLine();

        System.out.println("FROM SERVER: Logical Address " + logicAdd);

        clientSocket.close();

    }
}

-----

//DNS in Tcp/ip

Server:
import java.io.*;
import java.net.*;

class tcpdnsserver {

  public static void main(String argv[]) throws Exception
    {
      String addr;


      ServerSocket welcomeSocket = new ServerSocket(6789);

      while(true) {

            Socket connectionSocket = welcomeSocket.accept();

           BufferedReader inFromClient =
              new BufferedReader(new
              InputStreamReader(connectionSocket.getInputStream()));


          String hostaddr[] = {"157.240.7.35","216.58.197.68", "10.10.1.55"};
	  String hostname[] = {"www.facebook.com","www.google.com", "www.vit.ac.in"};

           DataOutputStream  outToClient =
             new DataOutputStream(connectionSocket.getOutputStream());

           addr = inFromClient.readLine();
	for(int i = 0; i < hostaddr.length; i++)
	{
		if (addr.equals(hostaddr[i]))
		{
			outToClient.writeBytes(hostname[i] + "\n");
			connectionSocket.close();
		}
	}


        }
    }
}

Client:
import java.io.*;
import java.net.*;
class tcpdnsclient {

    public static void main(String argv[]) throws Exception
    {
        String hostaddr;
        String hostname;

        BufferedReader inFromUser =
          new BufferedReader(new InputStreamReader(System.in));

        Socket clientSocket = new Socket("localhost", 6789);

        DataOutputStream outToServer =
          new DataOutputStream(clientSocket.getOutputStream());

                BufferedReader inFromServer =
          new BufferedReader(new
          InputStreamReader(clientSocket.getInputStream()));

	System.out.println("Enter Host Address :");
        hostaddr = inFromUser.readLine();

        outToServer.writeBytes(hostaddr + '\n');

        hostname = inFromServer.readLine();

        System.out.println("FROM SERVER: Host Name: " + hostname);

        clientSocket.close();

    }
}

-------

//Factorial in tcp/ip

Server:
import java.io.*;
import java.net.*;
class tcpfacserver {
 public static void main(String argv[]) throws Exception
 {
  String clientSentence;
  String capitalizedSentence;
  ServerSocket welcomeSocket = new ServerSocket(6788);
   Socket connectionSocket = welcomeSocket.accept();
   BufferedReader inFromClient = new BufferedReader(new InputStreamReader(connectionSocket.getInputStream()));
   DataOutputStream outToClient = new DataOutputStream (connectionSocket.getOutputStream());
   clientSentence = inFromClient.readLine();
   int num = Integer.parseInt(clientSentence);
   int fact=1;
   for(int i=1;i<=num;i++)
    fact=fact*i;
   System.out.println("Factorial : "+fact);
   capitalizedSentence = String.valueOf(fact);
   //capitalizedSentence = clientSentence.toUpperCase() + '\n';
   outToClient.writeBytes(capitalizedSentence);
 }
}

Client:
import java.io.*;
import java.net.*;
class tcpfacclient {
 public static void main(String argv[]) throws Exception
 {
  String sentence;
  String modifiedSentence;
  BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));
  Socket clientSocket = new Socket("localhost", 6788);
  DataOutputStream outToServer = new DataOutputStream(clientSocket.getOutputStream());
  BufferedReader inFromServer = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
  System.out.println("Enter a number - ");
  sentence = inFromUser.readLine();
  outToServer.writeBytes(sentence + '\n');
  modifiedSentence = inFromServer.readLine();
  System.out.println ("Factorial: " + modifiedSentence );
  clientSocket.close();
 }
}

---------

//class of ip using tcp/ip

Server:
import java.io.*;
import java.net.*;

class tcpclassserver {

  public static void main(String argv[]) throws Exception
    {
      String ip;
        int fbyte;
        String ipclass = "Invalid";


      ServerSocket welcomeSocket = new ServerSocket(6789);

      while(true) {

            Socket connectionSocket = welcomeSocket.accept();

           BufferedReader inFromClient =
              new BufferedReader(new
              InputStreamReader(connectionSocket.getInputStream()));


           DataOutputStream  outToClient =
             new DataOutputStream(connectionSocket.getOutputStream());

           ip = inFromClient.readLine();
           int index;
           index = ip.indexOf(".");
           ip = ip.substring(0, index);


           fbyte = Integer.parseInt(ip);
        if (fbyte >= 0 && fbyte <= 127)
                ipclass = "Class A";
        else if (fbyte >= 128 && fbyte <= 191)
                ipclass = "Class B";
        else if (fbyte >= 192 && fbyte <= 223)
                ipclass = "Class C";
        else if (fbyte >= 224 && fbyte <= 239)
                ipclass = "Class D";
        else if (fbyte >= 240 && fbyte <= 255)
                ipclass = "Class E";

        outToClient.writeBytes(ipclass + "\n");
        connectionSocket.close();

        }
    }
}

Client:
import java.io.*;
import java.net.*;
class tcpclassclient {

    public static void main(String argv[]) throws Exception
    {
        String ip;
        String ipclass;

        BufferedReader inFromUser =
          new BufferedReader(new InputStreamReader(System.in));

        Socket clientSocket = new Socket("localhost", 6789);

        DataOutputStream outToServer =
          new DataOutputStream(clientSocket.getOutputStream());

                BufferedReader inFromServer =
          new BufferedReader(new
          InputStreamReader(clientSocket.getInputStream()));

        System.out.println("Enter an IP address: ");
        ip = inFromUser.readLine();

        outToServer.writeBytes(ip + '\n');

        ipclass = inFromServer.readLine();

        System.out.println("FROM SERVER: Class for IP: "+ ip + " is : " + ipclass);

        clientSocket.close();

    }
}

---------------
udp
--------------
/Echo client/Server using udp

Server:
import java.net.*;
import java.io.*;
public class udpechoserver
{
 public static void main(String args[])
 {
 int port = 8000;
 DatagramSocket serverDatagramSocket = null;
 try
 {
 serverDatagramSocket = new DatagramSocket(port);
/*System.out.println("Created UDP Echo Server on port
 "+port);*/
 }
 catch(IOException e)
 {
 System.out.println(e);
 System.exit(1);
 }
 try
 {
 byte buffer[] = new byte[1024];
 DatagramPacket datagramPacket = new DatagramPacket(buffer, buffer.length);
 String input;
 while(true)
 {
 // listen for datagram packets
 serverDatagramSocket.receive(datagramPacket);
 input = new String(datagramPacket.getData(), 0, datagramPacket.getLength());
 System.out.println("Received from server: "+input);
 // send received packet back to the client
 serverDatagramSocket.send(datagramPacket);
 }
 }
 catch(IOException e)
 {
 System.out.println(e);
 }
 }
}

client:
import java.net.*;
import java.io.*;
public class udpechoclient
{
 public static class UDPEchoReader extends Thread
 {
 public UDPEchoReader(DatagramSocket socket)
 {
 datagramSocket = socket;
 active = true;
 }
 public void run()
 {
 byte[] buffer = new byte[1024];
 DatagramPacket incoming = new DatagramPacket(buffer,buffer.length);
 String receivedString;
 while(active)
 {
 try
 {
 // listen for incoming datagram packet
 datagramSocket.receive(incoming);
 // print out received string
 receivedString = new String(incoming.getData(), 0, incoming.getLength());
 System.out.println("Received from server:"+receivedString);
 }
 catch(IOException e)
 {
 System.out.println(e);
 active = false;
 }
 }
 }
 public boolean active;
 public DatagramSocket datagramSocket;
 }
 public static void main(String[] args)
 {
 InetAddress address = null;
 int port = 8000;
 DatagramSocket datagramSocket = null;
 BufferedReader keyboardReader = null;
 // Create a Datagram Socket...
 try
 {
 address = InetAddress.getByName("127.0.0.1");
 datagramSocket = new DatagramSocket();
 keyboardReader = new BufferedReader(new
 InputStreamReader(System.in));
 }
 catch (IOException e)
 {
 System.out.println(e);
 System.exit(1);
 }
 // Start the listening thread...
 UDPEchoReader reader = new UDPEchoReader(datagramSocket);
 reader.setDaemon(true);
 reader.start();
 System.out.println("Ready to send your messages...");
 try
 {
 String input;
 while (true)
 {
 // read input from the keyboard
 input = keyboardReader.readLine();
 // send datagram packet to the server
 DatagramPacket datagramPacket = new DatagramPacket
 (input.getBytes(), input.length(), address, port);
 datagramSocket.send(datagramPacket);
 }
 }
 catch(IOException e)
 {
 System.out.println(e);
 }
 }
}

-----------

//text message transfer in udp

Server:
import java.net.DatagramPacket;
import java.net.DatagramSocket;
public class udpchatserver
{
        public static void main(String args[])
        {
                int server_port = 1111;
                System.out.println("UDP Server Listening in " + server_port);
                try
                {
                        // DatagramSocket created and listening in Port 1111
                        DatagramSocket socket = new DatagramSocket(server_port);
                        byte[] msgBuffer = new byte[1024];

                        // DatagramPacket for receiving the incoming data from UDP Client
                        DatagramPacket packet = new DatagramPacket(msgBuffer, msgBuffer.length);

                        while (true)
                        {
                                socket.receive(packet);
                                String message = new String(msgBuffer, 0, packet.getLength());
                                System.out.println("UDPServer: Message received = " + message);
                                packet.setLength(msgBuffer.length);
                        }
                }
                catch (Exception e)
                {
                        e.printStackTrace();
                        System.out.println("Error in getting the Data from UDP Client");
                }
        }
}

Client:
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.io.*;
import java.net.*;

public class udpchatclient
{
        public static void main(String args[])
        {
                try
                {
                        BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));
                        String server_address = "localhost";
                        int server_port = 1111;
 String message = inFromUser.readLine();
                        InetAddress address = InetAddress.getByName(server_address);
                        DatagramPacket packet = new DatagramPacket(message.getBytes(), message.getBytes().length, address, server_port);
                        DatagramSocket socket = new DatagramSocket();
                        socket.send(packet);

                        System.out.println("UDPClient: Sent data to Server ; Message = " + message);
                        socket.close();
                }
                catch (Exception e)
                {
                        e.printStackTrace();
                        System.out.println("Error in sending the Data to UDP Server");
                }
        }
}

--------

//chat client/server in udp

Server:
import java.io.*;
import java.net.*;

public class udpchatserver {
	public static void main(String args[]) throws Exception
	{
		DatagramSocket serverSocket = new DatagramSocket(6789);

		BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));
		String reply;
		while(true)
		{
			byte[] receiveData = new byte[1024];
			byte[] sendData = new byte[1024];
			DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
			serverSocket.receive(receivePacket);

			String msg = new String(receivePacket.getData());
			System.out.println("Message Received: " + msg);

			InetAddress IPAddress = receivePacket.getAddress();
			int port = receivePacket.getPort();

			System.out.printf("Enter reply: ");
			reply = inFromUser.readLine();
			if (reply.equals("bye"))
			{
				System.out.printf("Exiting Chat!");
				serverSocket.close();
				break;
			}
			sendData = reply.getBytes();
			DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, port);
			serverSocket.send(sendPacket);
		}

	}
}

Client:
import java.io.*;
import java.net.*;

public class udpchatclient {
	public static void main(String args[]) throws Exception
	{
		BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));

		InetAddress IPAddress = InetAddress.getByName("localhost");

		String msg = "";
		while(true)
		{
			byte[] sendData = new byte[1024];
			byte[] receiveData = new byte[1024];
			DatagramSocket clientSocket = new DatagramSocket();
			System.out.printf("Send a Message: ");
			msg = inFromUser.readLine();
			if (msg.equals("bye"))
			{
				System.out.printf("Exiting Chat!");
				clientSocket.close();
				break;
			}
			sendData = msg.getBytes();

			DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, 6789);
			clientSocket.send(sendPacket);

			DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
			clientSocket.receive(receivePacket);

			String reply = new String(receivePacket.getData());
			System.out.println("Reply: " + reply);
			clientSocket.close();
		}
	}
}

---------

//DNS client-server using udp

Server:
import java.io.*;
import java.net.*;
import java.util.*;
class udpdnsserver
{
public static void main(String args[])
{
try
{
DatagramSocket server=new DatagramSocket(1309);
while(true)
{
byte[] sendbyte=new byte[1024];
byte[] receivebyte=new byte[1024];
DatagramPacket receiver=new DatagramPacket(receivebyte,receivebyte.length);
server.receive(receiver);
String str=new String(receiver.getData());
String s=str.trim();
//System.out.println(s);
InetAddress addr=receiver.getAddress();
int port=receiver.getPort();
String ip[]={"165.165.80.80","165.165.79.1"};
String name[]={"www.google.com","www.yahoo.com"};
for(int i=0;i<ip.length;i++)
{
if(s.equals(ip[i]))
{
sendbyte=name[i].getBytes();
DatagramPacket sender=new DatagramPacket(sendbyte,sendbyte.length,addr,port);
server.send(sender);
break;
}
else if(s.equals(name[i]))
{
sendbyte=ip[i].getBytes();
DatagramPacket sender=new DatagramPacket(sendbyte,sendbyte.length,addr,port);
server.send(sender);
break;
}}
break;
}
}
catch(Exception e)
{
System.out.println(e);
}
}
}

Client:
import java.io.*;
import java.net.*;
import java.util.*;
class udpdnsclient
{
public static void main(String args[])
{
try
{
DatagramSocket client=new DatagramSocket();
InetAddress addr=InetAddress.getByName("127.0.0.1");
byte[] sendbyte=new byte[1024];
byte[] receivebyte=new byte[1024];
BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter the DOMAIN NAME or IP adress:");
String str=in.readLine();
sendbyte=str.getBytes();
DatagramPacket sender=new DatagramPacket(sendbyte,sendbyte.length,addr,1309);
client.send(sender);
DatagramPacket receiver=new DatagramPacket(receivebyte,receivebyte.length);
client.receive(receiver);
String s=new String(receiver.getData());
System.out.println("IP address or DOMAIN NAME: "+s.trim());
client.close();
}
catch(Exception e)
{
System.out.println(e);
}
}
}

----------

//Logical add when physical is known(rarp) using udp

Server:
import java.io.*;
import java.net.*;
import java.util.*;
class rarpserver
{
public static void main(String args[])
{
try
{
DatagramSocket server=new DatagramSocket(1309);
while(true)
{
byte[] sendbyte=new byte[1024];
byte[] receivebyte=new byte[1024];
DatagramPacket receiver=new DatagramPacket(receivebyte,receivebyte.length);
server.receive(receiver);
String str=new String(receiver.getData());
String s=str.trim();
InetAddress addr=receiver.getAddress();
int port=receiver.getPort();
String ip[]={"165.165.80.80","165.165.79.1"};
String mac[]={"6A:08:AA:C2","8A:BC:E3:FA"};
for(int i=0;i<mac.length;i++)
{
if(s.equals(mac[i]))
{
sendbyte=ip[i].getBytes();
DatagramPacket sender=new DatagramPacket(sendbyte,sendbyte.length,addr,port);
server.send(sender);
break;
}
}
break;
}
}
catch(Exception e)
{
System.out.println(e);
}
}
}

Client:
import java.io.*;
import java.net.*;
import java.util.*;
class rarpclient
{
public static void main(String args[])
{
try
{
DatagramSocket client=new DatagramSocket();
InetAddress addr=InetAddress.getByName("127.0.0.1");
byte[] sendbyte=new byte[1024];
byte[] receivebyte=new byte[1024];
BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter the Physical Address:");
String str=in.readLine();
sendbyte=str.getBytes();
DatagramPacket sender=new DatagramPacket(sendbyte,sendbyte.length,addr,1309);
client.send(sender);
DatagramPacket receiver=new DatagramPacket(receivebyte,receivebyte.length);
client.receive(receiver);
String s=new String(receiver.getData());
System.out.println("The Logical Address is(IP): "+s.trim());
client.close();
}
catch(Exception e)
{
System.out.println(e);
}
}
}
 ---------

//physical add when logical add is known(ARP)

Server:
import java.io.*;
import java.net.*;
import java.util.*;
class arpserver
{
public static void main(String args[])
{
try
{
DatagramSocket server=new DatagramSocket(1309);
while(true)
{
byte[] sendbyte=new byte[1024];
byte[] receivebyte=new byte[1024];
DatagramPacket receiver=new DatagramPacket(receivebyte,receivebyte.length);
server.receive(receiver);
String str=new String(receiver.getData());
String s=str.trim();
InetAddress addr=receiver.getAddress();
int port=receiver.getPort();
String ip[]={"165.165.80.80","165.165.79.1"};
String mac[]={"6A:08:AA:C2","8A:BC:E3:FA"};
for(int i=0;i<ip.length;i++)
{
if(s.equals(ip[i]))
{
sendbyte=mac[i].getBytes();
DatagramPacket sender=new DatagramPacket(sendbyte,sendbyte.length,addr,port);
server.send(sender);
break;
}
}
break;
}
}
catch(Exception e)
{
System.out.println(e);
}
}
}

client:
import java.io.*;
import java.net.*;
import java.util.*;
class arpclient
{
public static void main(String args[])
{
try
{
DatagramSocket client=new DatagramSocket();
InetAddress addr=InetAddress.getByName("127.0.0.1");
byte[] sendbyte=new byte[1024];
byte[] receivebyte=new byte[1024];
BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter the logical address (IP):");
String str=in.readLine();
sendbyte=str.getBytes();
DatagramPacket sender=new DatagramPacket(sendbyte,sendbyte.length,addr,1309);
client.send(sender);
DatagramPacket receiver=new DatagramPacket(receivebyte,receivebyte.length);
client.receive(receiver);
String s=new String(receiver.getData());
System.out.println("The Physical Address is(MAC): "+s.trim());
client.close();
}
catch(Exception e)
{
System.out.println(e);
}
}
}

-------

//client-server date using udp

Server:
import java.net.*;
import java.io.*;
import java.util.*;

class udpdateserver
{
public static void main(String args[]) throws Exception
{
ServerSocket s=new ServerSocket(5217);
while(true)
{
System.out.println("Waiting For Connection ...");
Socket soc=s.accept();
DataOutputStream out=new DataOutputStream(soc.getOutputStream());
out.writeBytes("Server Date" + (new Date()).toString() + "\n");
out.close();
soc.close();
}
}
}

Client:
import java.io.*;
import java.net.*;

class udpdateclient
{
public static void main(String args[]) throws Exception
{
Socket soc=new Socket(InetAddress.getLocalHost(),5217);
BufferedReader in=new BufferedReader( new InputStreamReader(soc.getInputStream()));
System.out.println(in.readLine());
}
}

=====