Q1. Write a program to download the contents associated with a HTTP URL and save it in a file.

import java.io.BufferedInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.*;
import java.io.*;


public class cs2q1 {

	    public static void downloadUsingStream(String urlStr, String file) throws IOException{
        URL url = new URL(urlStr);
        BufferedInputStream bis = new BufferedInputStream(url.openStream());
        FileOutputStream fis = new FileOutputStream(file);
        byte[] buffer = new byte[1024];
        int count=0;
        while((count = bis.read(buffer,0,1024)) != -1)
        {
            fis.write(buffer, 0, count);
        }
        fis.close();
        bis.close();
    }

    public static void main(String[] args) {
        String url = "https://en.wikipedia.org/wiki/Triangle_(2009_British_film)";

        try {
            cs2q1 a = new cs2q1();
            a.downloadUsingStream(url, "./demo.txt");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}


======================================================

Q2. Write an application to analyse the details of HTTP header using the classes and methods supported by java API.

import java.io.*;

public class IPHeader {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Please enter the Hex Dump:");
        String input = br.readLine();

        String IPVer = input.substring(0,1);
        if(IPVer.equals("4"))
            System.out.println("IP Version: 4");
        if(IPVer.equals("6"))
            System.out.println("IP Version: 6");

        String h_len = input.substring(1,2);
        System.out.println("Header Length: " + (4 * Integer.parseInt(h_len,16)));

        String s_type = input.substring(2,4);
        String s_t_bin = Integer.toBinaryString(Integer.parseInt(s_type,16));
        while(s_t_bin.length() < 8)
            s_t_bin = "0" + s_t_bin;
        System.out.println("Precedence: " + Integer.parseInt(s_t_bin.substring(0,3),2));
        if(s_t_bin.charAt(3) == '1')
            System.out.println("Minimize Delay Requested");
        if(s_t_bin.charAt(4) == '1')
            System.out.println("Maximize Throughput Requested");
        if(s_t_bin.charAt(5) == '1')
            System.out.println("Maximize Reliability Requested");
        if(s_t_bin.charAt(6) == '1')
            System.out.println("Minimize Cost Requested");

        String tot_len = input.substring(4,8);
        System.out.println("Total Length: " + Integer.parseInt(tot_len,16) + " Bytes");

        String id = input.substring(8,12);
        System.out.println("Identification: " + Integer.parseInt(id,16));

        String frag = input.substring(12,16);
        String frag_bin = Integer.toBinaryString(Integer.parseInt(frag,16));
        while(frag_bin.length() < 16)
            frag_bin = "0" + frag_bin;
        String frag_flags = frag_bin.substring(0,3);
        if(frag_flags.charAt(1) == '1')
            System.out.println("Do not Fragment Packet");
        else
            System.out.println("Can be Fragmented");
        if(frag_flags.charAt(2) == '1')
            System.out.println("More Fragments pending");
        else
            System.out.println("No more Fragments pending");


        System.out.println("Fragmentation Offset: " + ((8 * Integer.parseInt(frag_bin.substring(3, 16),2)) - (4 * Integer.parseInt(h_len,16))));

        String ttl = input.substring(16,18);
        System.out.println("Time to live: " + Integer.parseInt(ttl,16) + " Hops");

        String protocol = input.substring(18,20);
        System.out.print("Protocol: ");
        if(Integer.parseInt(protocol,16) == 1)
            System.out.println("ICMP");
        if(Integer.parseInt(protocol,16) == 2)
            System.out.println("IGMP");
        if(Integer.parseInt(protocol,16) == 89)
            System.out.println("OSPF");
        if(Integer.parseInt(protocol,16) == 6)
            System.out.println("TCP");
        if(Integer.parseInt(protocol,16) == 17)
            System.out.println("UDP");

        String checksum = input.substring(20,24);
        System.out.println("Header Checksum: " + Integer.parseInt(checksum,16));

        String s_ip = input.substring(24,32);
        String s_ip_bin = Long.toBinaryString(Long.parseLong(s_ip,16));
        while(s_ip_bin.length() < 32)
            s_ip_bin = "0" + s_ip_bin;
        System.out.print("Source IP Address: ");
        System.out.print(Integer.parseInt(s_ip_bin.substring(0,8),2) + ".");
        System.out.print(Integer.parseInt(s_ip_bin.substring(8,16),2) + ".");
        System.out.print(Integer.parseInt(s_ip_bin.substring(16,24),2) + ".");
        System.out.println(Integer.parseInt(s_ip_bin.substring(24,32),2));

        String d_ip = input.substring(32,40);
        String d_ip_bin = Long.toBinaryString(Long.parseLong(d_ip,16));
        while(d_ip_bin.length() < 32)
            d_ip_bin = "0" + d_ip_bin;
        System.out.print("Destination IP Address: ");
        System.out.print(Integer.parseInt(d_ip_bin.substring(0,8),2) + ".");
        System.out.print(Integer.parseInt(d_ip_bin.substring(8,16),2) + ".");
        System.out.print(Integer.parseInt(d_ip_bin.substring(16,24),2) + ".");
        System.out.println(Integer.parseInt(d_ip_bin.substring(24,32),2));
    }

}



====================================================

Q3. Write a client server program to get an array of 10 integers in client side pass it to server and sort the array in descending order on server side and display the sorted array

import java.io.*;
import java.net.*;
import java.util.*;
class ServerSort
{
	public static void main(String[] args)throws Exception
	{
		ServerSocket ss = new ServerSocket(7898);
		Socket cs = ss.accept();
		Scanner in = new Scanner(cs.getInputStream());
		//PrintStream out = new PrintStream(cs.getOutputStream());
		//BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String s; int y;int temp;
		s=in.next();
		y=Integer.parseInt(s);
		System.out.print("Size of the Received from Clients :- " + y);
		int x[] = new int[y];
		for(int i=0;i<y;i++)
		{
		s=in.next();
		x[i]=Integer.parseInt(s);
		//System.out.println(x[i]);
		}

		System.out.println("\nElements of Array Received from Client :- ");
		for(int u=0;u<y;u++)
		{
			System.out.print(x[u]+" ");
		}
		for(int a = 0;a<y;a++)
		{
			for(int b=0;b<y;b++)
			{
				if(x[a]<x[b])
				{
					temp=x[b];
					x[b]=x[a];
					x[a]=temp;
				}
			}
		}
		System.out.println("\nArray After Sorting :- ");
		for(int u=0;u<y;u++)
		{
			System.out.print(x[u]+" ");
		}
		System.out.println();
		ss.close();cs.close();in.close();//out.close();
	}
}


import java.io.*;
import java.net.*;
import java.util.*;
class ClientSort
{
	public static void main(String[] args)throws Exception
	{
		Socket cs = new Socket("localhost",7898);
		DataInputStream in = new DataInputStream(cs.getInputStream());
		PrintStream out = new PrintStream(cs.getOutputStream());
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String s; int k;
		Scanner sc = new Scanner(System.in);
		System.out.println("Enter size of the array :- ");
		k=sc.nextInt();
		int n[] = new int[k];
		s=""+k;
		out.println(s);
		System.out.println("Enter a list of numbers :- ");
		for(int i=0;i<k;i++)
		{
			n[i]=sc.nextInt();
			s=""+n[i];
			out.println(s);
		}

		out.close();in.close();cs.close();br.close();
	}
}

------------------

UDP KOSHISH

userver:

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

class userver{
	public static void main(String[] args) throws Exception{
		DatagramSocket serverSocket=new DatagramSocket(6700);
		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());

			String s; int y=3;int temp;
			/*s=new String(receivePacket.getData());
			y=Integer.parseInt(s);
			System.out.print("Size of the Received from Clients :- " + y);*/
			//int y=10;
			int x[] = new int[y];
			for(int i=0;i<y;i++)
			{
				s=new String(receivePacket.getData());
			x[i]=Integer.parseInt(s);

			}

			System.out.println("\nElements of Array Received from Client :- ");
			for(int u=0;u<y;u++)
			{
				System.out.print(x[u]+" ");
			}
			for(int a = 0;a<y;a++)
			{
				for(int b=0;b<y;b++)
				{
					if(x[a]<x[b])
					{
						temp=x[b];
						x[b]=x[a];
						x[a]=temp;
					}
				}
			}
			System.out.println("\nArray After Sorting :- ");
			for(int u=0;u<y;u++)
			{
				System.out.print(x[u]+" ");
			}
			System.out.println();
			serverSocket.close();
		}
	}
}


uclient:

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

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

		InetAddress address=InetAddress.getByName("localhost");
		//String msg="";
		while(true){
			byte[] receiveData=new byte[1024];
			byte[] sendData=new byte[1024];
			DatagramSocket clientSocket=new DatagramSocket(6789);

			String s; int k=3;
			//Scanner sc = new Scanner(System.in);
			/*System.out.println("Enter size of the array :- ");
			k=infromuser.read();*/
			int n[] = new int[k];
			//s=""+k;
			//msg=infromuser.readLine();
			/*sendData=s.getBytes();
			DatagramPacket sendPacket=new DatagramPacket(sendData, sendData.length, address, 6700);
			clientSocket.send(sendPacket);*/

			//out.println(s);
			System.out.println("Enter a list of numbers :- ");
			for(int i=0;i<k;i++)
			{
				n[i]=infromuser.read();
				s=""+n[i];
				//out.println(s);
				sendData=s.getBytes();
				DatagramPacket sendPacket=new DatagramPacket(sendData, sendData.length, address, 6700);
				clientSocket.send(sendPacket);
			}

			clientSocket.close();



			/*System.out.println("send msg:");

			DatagramPacket receivePacket=new DatagramPacket(receiveData, receiveData.length);
			clientSocket.receive(receivePacket);
			String reply=new String(receivePacket.getData());
			System.out.println("reply from server:"+reply);
			*/
		}
	}
}

======================================================================


Q4. Write a client server program to get an array of 10 strings in client side pass it to server and sort the array of strings in server side and display the sorted array

TCP

import java.io.*;
import java.net.*;
import java.util.*;
class ClientStringSort
{
	public static void main(String[] args)throws Exception
	{
		Socket cs = new Socket("localhost",7998);
		DataInputStream in = new DataInputStream(cs.getInputStream());
		PrintStream out = new PrintStream(cs.getOutputStream());
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String s; int k;
		Scanner sc = new Scanner(System.in);
		System.out.println("Enter size of the array :- ");
		k=sc.nextInt();
		String n[] = new String[k];
		s=""+k;
		out.println(s);
		System.out.println("Enter elements of the array :- ");
		for(int i=0;i<k;i++)
		{
			n[i]=sc.next();
			out.println(n[i]);
		}

		out.close();in.close();cs.close();br.close();
	}
}

import java.io.*;
import java.net.*;
import java.util.*;
class ServerStringSort
{
	public static void main(String[] args)throws Exception
	{
		ServerSocket ss = new ServerSocket(7998);
		Socket cs = ss.accept();
		Scanner in = new Scanner(cs.getInputStream());
		PrintStream out = new PrintStream(cs.getOutputStream());
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String s; int y;String temp;
		s=in.next();
		y=Integer.parseInt(s);
		System.out.print("Size of the Received from Clients :- " + y);
		String x[] = new String[y];
		for(int i=0;i<y;i++)
		{
		x[i]=in.next();
		//System.out.println(x[i]);
		}

		System.out.println("\nElements of Array Received from Client :- ");
		for(int u=0;u<y;u++)
		{
			System.out.print(x[u]+" ");
		}
		for(int a = 0;a<y;a++)
		{
			for(int b=0;b<y;b++)
			{
				if((x[a].compareTo(x[b]))<0)
				{
					temp=x[b];
					x[b]=x[a];
					x[a]=temp;
				}
			}
		}
		System.out.println("\nArray After Sorting :- ");
		for(int u=0;u<y;u++)
		{
			System.out.print(x[u]+" ");
		}
		System.out.println();
		ss.close();cs.close();in.close();out.close();
	}
}

-------------

UDP

server
import java.io.*;
import java.net.*;

public class udpsts {
	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)
		{
			String x[]=new String[3];
			byte[] receiveData = new byte[10];
			byte[] sendData = new byte[10];
			String temp;
			for(int i=0;i<3;i++)
			{
			DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
			serverSocket.receive(receivePacket);
			String msg = new String(receivePacket.getData());
			//System.out.println("Message Received: " + msg);
			x[i]=msg;
			InetAddress IPAddress = receivePacket.getAddress();
			int port = receivePacket.getPort();
			}


			for(int u=0;u<3;u++)
			{
				System.out.println(x[u]+" ");
			}
			for(int a = 0;a<3;a++)
			{
				for(int b=0;b<3;b++)
				{
					if((x[a].compareTo(x[b]))<0)
					{
						temp=x[b];
						x[b]=x[a];
						x[a]=temp;
					}
				}
			}
			System.out.println("\nArray After Sorting :- ");
			for(int u=0;u<3;u++)
			{
				System.out.println(x[u]+" ");
			}
			System.out.println();







			//System.out.println("Enter reply: ");
			//reply = inFromUser.readLine();
			char reply[]=new char[30];
			//reply=msg.toCharArray();
        	//for(int i=0;i<msg.length();i++)
        	{
        	//	reply[i]++;
        	}

			sendData = new String(reply).getBytes("UTF-8");
			//DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, port);
		//	serverSocket.send(sendPacket);
		}

	}
}

client

import java.io.*;
import java.net.*;

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

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

		String msg[]=new String[3] ;
		while(true)
		{
			byte[] sendData = new byte[10];
			byte[] receiveData = new byte[10];
			DatagramSocket clientSocket = new DatagramSocket();
			//System.out.println("enter the size of array: ");
			for(int i=0;i<3;i++)
			{
			msg[i] = inFromUser.readLine();
			sendData = msg[i].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();
		}
	}
}
======================================================

Q5. Develop an application to illustrate Java mail API

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;

public class SendEmail {

   public static void main(String [] args) {
      // Recipient's email ID needs to be mentioned.
      String to = "abcd@gmail.com";

      // Sender's email ID needs to be mentioned
      String from = "web@gmail.com";

      // Assuming you are sending email from localhost
      String host = "localhost";

      // Get system properties
      Properties properties = System.getProperties();

      // Setup mail server
      properties.setProperty("mail.smtp.host", host);

      // Get the default Session object.
      Session session = Session.getDefaultInstance(properties);

      try {
         // Create a default MimeMessage object.
         MimeMessage message = new MimeMessage(session);

         // Set From: header field of the header.
         message.setFrom(new InternetAddress(from));

         // Set To: header field of the header.
         message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));

         // Set Subject: header field
         message.setSubject("This is the Subject Line!");

         // Send the actual HTML message, as big as you like
         message.setContent("<h1>This is actual message</h1>", "text/html");

         // Send message
         Transport.send(message);
         System.out.println("Sent message successfully....");
      }catch (MessagingException mex) {
         mex.printStackTrace();
      }
   }
}

========================================


RMI


Adder.java

import java.rmi.*;
public interface Adder extends Remote{

public int add(int x,int y)throws RemoteException;
}

---------------

AdderRemote.java

import java.rmi.*;
import java.rmi.server.*;

public class AdderRemote extends UnicastRemoteObject implements Adder{

AdderRemote()throws RemoteException{
super();
}

public int add(int x,int y){return x+y;}

}

-----------

MyClient.java

import java.rmi.*;

public class MyClient{

public static void main(String args[]){
try{

Adder stub=(Adder)Naming.lookup("rmi://localhost:5000/sonoo");
System.out.println(stub.add(34,4));

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

}

-----------

MyServer.java

import java.rmi.*;
import java.rmi.registry.*;

public class MyServer{

public static void main(String args[]){
try{

Adder stub=new AdderRemote();
Naming.rebind("rmi://localhost:5000/sonoo",stub);

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

}


============================================================
============================================================

Datagram channel chat client/server

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;
public class DCchatClient {
  public static void main(String[] args) throws Exception {
    DatagramChannel client = null;
    client = DatagramChannel.open();

    client.bind(null);
    BufferedReader infromuser=new BufferedReader(new InputStreamReader(System.in));
    while(true){
    String msg = infromuser.readLine();
    ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
    InetSocketAddress serverAddress = new InetSocketAddress("localhost",8989);

    client.send(buffer, serverAddress);
    buffer.clear();
    ByteBuffer buff = ByteBuffer.allocate(1024);
    client.receive(buff);
    buff.flip();
    int limits = buff.limit();
    byte bytes[] = new byte[limits];
    buff.get(bytes, 0, limits);
    String response = new String(bytes);
    System.out.println("Server  responded: " + response);
    buff.clear();
    //client.close();
  }}
}


import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;
public class DCchatServer {
  public static void main(String[] args) throws Exception {
    DatagramChannel server = null;
    server = DatagramChannel.open();
    InetSocketAddress sAddr = new InetSocketAddress("localhost", 8989);
    server.bind(sAddr);
    BufferedReader infromuser=new BufferedReader(new InputStreamReader(System.in));
    ByteBuffer buffer = ByteBuffer.allocate(1024);

    while (true) {
      System.out.println("Waiting for a  message  from"
          + "  a  remote  host at " + sAddr);
      SocketAddress remoteAddr = server.receive(buffer);
      buffer.flip();
      int limits = buffer.limit();
      byte bytes[] = new byte[limits];
      buffer.get(bytes, 0, limits);
      String msg = new String(bytes);

      System.out.println("Client at " + remoteAddr + "  says: " + msg);
      buffer.clear();
      String reply = infromuser.readLine();
      ByteBuffer buff = ByteBuffer.wrap(reply.getBytes());
      server.send(buff, remoteAddr);
      buff.clear();
      /*String reply = infromuser.readLine();
      ByteBuffer buff = ByteBuffer.wrap(msg.getBytes());
      server.send(buff, remoteAddr);
      buffer.clear();*/
    }
    //server.close();
  }
}

--------------------------------

Datagram channel echo client/server

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;
public class DCechoClient {
  public static void main(String[] args) throws Exception {
    DatagramChannel client = null;
    client = DatagramChannel.open();

    client.bind(null);
    BufferedReader infromuser=new BufferedReader(new InputStreamReader(System.in));
    String msg = infromuser.readLine();
    ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
    InetSocketAddress serverAddress = new InetSocketAddress("localhost",8989);

    client.send(buffer, serverAddress);
    buffer.clear();
    //ByteBuffer buff = ByteBuffer.allocate(1024);
    client.receive(buffer);
    buffer.flip();
    int limits = buffer.limit();
    byte bytes[] = new byte[limits];
    buffer.get(bytes, 0, limits);
    String response = new String(bytes);
    System.out.println("Server  responded: " + response);
    buffer.clear();
    client.close();
  }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;
public class DCechoServer {
  public static void main(String[] args) throws Exception {
    DatagramChannel server = null;
    server = DatagramChannel.open();
    InetSocketAddress sAddr = new InetSocketAddress("localhost", 8989);
    server.bind(sAddr);
   // BufferedReader infromuser=new BufferedReader(new InputStreamReader(System.in));
    ByteBuffer buffer = ByteBuffer.allocate(1024);
    System.out.println("Waiting for a  message  from"
            + "  a  remote  host at " + sAddr);
    while (true) {

      SocketAddress remoteAddr = server.receive(buffer);
      buffer.flip();
      int limits = buffer.limit();
      byte bytes[] = new byte[limits];
      buffer.get(bytes, 0, limits);
      String msg = new String(bytes);

      System.out.println("Client at " + remoteAddr + "  says: " + msg);
      buffer.rewind();
      server.send(buffer, remoteAddr);
      buffer.clear();
    }
    //server.close();
  }
}

-------------------------------

UDP MULTICAST CLIENT/SERVER (ONLY ONE TIME MESSAGE SENDING)

import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.MulticastSocket;
public class UDPMulticastC {
  public static void main(String[] args) throws Exception {
    int mcPort = 12345;
    String mcIPStr = "230.1.1.1";
    MulticastSocket mcSocket = null;
    InetAddress mcIPAddress = null;
    mcIPAddress = InetAddress.getByName(mcIPStr);
    mcSocket = new MulticastSocket(mcPort);
    System.out.println("Multicast Receiver running at:"
        + mcSocket.getLocalSocketAddress());
    mcSocket.joinGroup(mcIPAddress);

    DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);

    System.out.println("Waiting for a  multicast message...");
    mcSocket.receive(packet);
    String msg = new String(packet.getData(), packet.getOffset(),
        packet.getLength());
    System.out.println("[Multicast  Receiver] Received:" + msg);

    mcSocket.leaveGroup(mcIPAddress);
    mcSocket.close();
  }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class UDPMulticastS {
  public static void main(String[] args) throws Exception {
    int mcPort = 12345;
    String mcIPStr = "230.1.1.1";
    DatagramSocket udpSocket = new DatagramSocket();
    InetAddress mcIPAddress = InetAddress.getByName(mcIPStr);
    BufferedReader infromuser=new BufferedReader(new InputStreamReader(System.in));
    String reply = infromuser.readLine();
    byte[] msg = reply.getBytes();
    DatagramPacket packet = new DatagramPacket(msg, msg.length);
    packet.setAddress(mcIPAddress);
    packet.setPort(mcPort);
    udpSocket.send(packet);

    System.out.println("Sent a  multicast message.");
    System.out.println("Exiting application");
    udpSocket.close();
  }
}

--------------------------

Sethi UDP Multicast (Choose your own port)

server

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;
public class UDPMulticastS {
  public static void main(String[] args) throws Exception {

    int mcPort = 0;
    Scanner sc=new Scanner(System.in);
    mcPort=sc.nextInt();
    String mcIPStr = "230.1.1.1";
    DatagramSocket udpSocket = new DatagramSocket();
    InetAddress mcIPAddress = InetAddress.getByName(mcIPStr);
    BufferedReader infromuser=new BufferedReader(new InputStreamReader(System.in));
    String reply = infromuser.readLine();
    byte[] msg = reply.getBytes();
    DatagramPacket packet = new DatagramPacket(msg, msg.length);
    packet.setAddress(mcIPAddress);
    packet.setPort(mcPort);
    udpSocket.send(packet);

    System.out.println("Sent a  multicast message.");
    System.out.println("Exiting application");
    udpSocket.close();
  }
}


client

import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.MulticastSocket;
import java.util.Scanner;
public class UDPMulticastC {
  public static void main(String[] args) throws Exception {
    int mcPort = 0;
    Scanner sc=new Scanner(System.in);
    mcPort=sc.nextInt();
    String mcIPStr = "230.1.1.1";
    MulticastSocket mcSocket = null;
    InetAddress mcIPAddress = null;
    mcIPAddress = InetAddress.getByName(mcIPStr);
    mcSocket = new MulticastSocket(mcPort);
    System.out.println("Multicast Receiver running at:"
        + mcSocket.getLocalSocketAddress());
    mcSocket.joinGroup(mcIPAddress);

    DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);

    System.out.println("Waiting for a  multicast message...");
    mcSocket.receive(packet);
    String msg = new String(packet.getData(), packet.getOffset(),
        packet.getLength());
    System.out.println("[Multicast  Receiver] Received:" + msg);

    mcSocket.leaveGroup(mcIPAddress);
    mcSocket.close();
  }
}

-----------------------------

Datagram Channel Time client/server (not working code)

import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.DatagramChannel;
public class DCTimeC {

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

    DatagramChannel channel = DatagramChannel.open();
    // port 0 selects any available port
    SocketAddress address = new InetSocketAddress(0);
    DatagramSocket socket = channel.socket();
    socket.setSoTimeout(5000);
    socket.bind(address);

    SocketAddress server = new InetSocketAddress("time.nist.gov", 37);
    ByteBuffer buffer = ByteBuffer.allocate(8192);
    // time protocol always uses big-endian order
    buffer.order(ByteOrder.BIG_ENDIAN);
    // Must put at least one byte of data in the buffer;
    // it doesn't matter what it is.
    buffer.put((byte) 65);
    buffer.flip();

    channel.send(buffer, server);

    buffer.clear();
    buffer.put((byte) 0).put((byte) 0).put((byte) 0).put((byte) 0);
    channel.receive(buffer);
    buffer.flip();
    long secondsSince1970 = buffer.getLong();

    System.out.println(secondsSince1970);
    channel.close();

  }
}

import java.io.IOException;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.DatagramChannel;
public class DCTimeS {

  public final static int DEFAULT_PORT = 37;

  public static void main(String[] args) throws IOException {

    int port = 37;

    ByteBuffer in = ByteBuffer.allocate(8192);
    ByteBuffer out = ByteBuffer.allocate(8);
    out.order(ByteOrder.BIG_ENDIAN);
    SocketAddress address = new InetSocketAddress(port);
    DatagramChannel channel = DatagramChannel.open();
    DatagramSocket socket = channel.socket();
    socket.bind(address);
    System.err.println("bound to " + address);
    while (true) {
      try {
        in.clear();
        SocketAddress client = channel.receive(in);
        System.err.println(client);
        long secondsSince1970 = System.currentTimeMillis();
        out.clear();
        out.putLong(secondsSince1970);
        out.flip();

        out.position(4);
        channel.send(out, client);
      } catch (Exception ex) {
        System.err.println(ex);
      }
    }
  }
}

---------------------------------

============================================================
==========================================
============================================================
==========================================
============================================================




1.	Write a Java program to display the server’s date and time details at the client end.

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());
    }
}

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();
        }
    }
}



 2. Write a Java program to display the client’s address at the server end.

CODE:
Server:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;


public class gs{

	public static void main(String[] args) throws Exception {
		ServerSocket sersock=new ServerSocket(3000);
		System.out.println("Server retreiving hostname...");
		Socket sock=sersock.accept();

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

		OutputStream ostream=sock.getOutputStream();
		PrintWriter pwrite=new PrintWriter(ostream,true);

		InputStream istream=sock.getInputStream();
		BufferedReader receiveread= new BufferedReader(new InputStreamReader(istream));

		String Sendmsg,receivemsg;
		while(true)
		{
			if((receivemsg=receiveread.readLine())!=null)
			{
				System.out.println(receivemsg);
			}
			Sendmsg=keyread.readLine();
			pwrite.println(Sendmsg);
			pwrite.flush();
		}


	}
}

Client:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;


public class gc{

	public static void main(String[] args) throws Exception {
		InetAddress addr= InetAddress.getLocalHost();
		//InetAddress add= InetAddress.getHostName(addr);
		Socket sock=new Socket(addr,3000);

		//BufferedReader keyread=new BufferedReader(new InputStreamReader(System.in));

		OutputStream ostream=sock.getOutputStream();
		PrintWriter pwrite=new PrintWriter(ostream,true);

		InputStream istream=sock.getInputStream();
		BufferedReader receiveread= new BufferedReader(new InputStreamReader(istream));
		System.out.println("Client is ready");
		String Sendmsg,receivemsg;
		pwrite.println(addr.getHostAddress());

	}
}


3.Implement echo server and client in java using UDP sockets.

import java.io.*;
import java.net.*;

public class EServer
{
 public static void main(String[] args) throws IOException
 {

  ServerSocket S = new ServerSocket(3000);

  while(true)
  {
   Socket Client = S.accept();

   InputStream in = Client.getInputStream();

   DataInputStream Dis = new DataInputStream(in);

   System.out.println(Dis.readUTF());

   Client = new Socket("localhost",4000);

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

   String Str = buff.readLine();

   OutputStream out = Client.getOutputStream();

   DataOutputStream Dos = new DataOutputStream(out);

   Str = "Server Says :: " + Str;

   Dos.writeUTF(Str);

   Client.close();

  }

 }

}



//client
import java.io.*;
import java.net.*;
import java.util.*;

public class EClient
{
 public static void main(String[] args) throws IOException
 {
  Socket C = new Socket("localhost",3000);
  BufferedReader buff = new BufferedReader(new InputStreamReader (System.in));
  String Str = buff.readLine();

  OutputStream out = C.getOutputStream();

  DataOutputStream Dos = new DataOutputStream(out);

  Dos.writeUTF("Client Say :: " + Str);
  Dos.flush();

  ServerSocket S = new ServerSocket(4000);
  Socket Client = S.accept();
  InputStream in = Client.getInputStream();
  DataInputStream Dis = new DataInputStream(in);
  System.out.println(Dis.readUTF());
  Client.close();
 }
}


4.	Write a Java program to develop a simple Chat application.

Server:
import java.io.*;
import java.net.*;
public class chatserver
{
  public static void main(String[] args) throws Exception
  {
      ServerSocket sersock = new ServerSocket(3000);
      Socket sock = sersock.accept( );
      BufferedReader keyRead = new BufferedReader(new InputStreamReader(System.in));

      OutputStream ostream = sock.getOutputStream();
      PrintWriter pwrite = new PrintWriter(ostream, true);
      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 chatclient
{
  public static void main(String[] args) throws Exception
  {
     Socket sock = new Socket("127.0.0.1", 3000);
     BufferedReader keyRead = new BufferedReader(new InputStreamReader(System.in));

     OutputStream ostream = sock.getOutputStream();
     PrintWriter pwrite = new PrintWriter(ostream, true);
     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();
        pwrite.println(sendMessage);
        pwrite.flush();
        if((receiveMessage = receiveRead.readLine()) != null)
        {
            System.out.println(receiveMessage);
        }
      }
    }
}


5. The message entered in the client is sent to the server and the server encodes the message and returns it to the client. Encoding is done by replacing a character by the character next to it i.e. a as b, b as c …z as a. This process is done using the TCP/IP protocol. Write a Java program for the above.

Server:
import java.io.*;
import java.net.*;
public class GossipServer
{
  public static void main(String[] args) throws Exception
  {
      ServerSocket sersock = new ServerSocket(3000);
      System.out.println("Server retreiving data....");
      Socket sock = sersock.accept( );
                              // reading from keyboard (keyRead object)
                      // 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);
        	char r[]=new char[12];
        	r=receiveMessage.toCharArray();
        	for(int i=0;i<receiveMessage.length();i++)
        	{
        		r[i]++;
        	}
            pwrite.println(r);
            pwrite.flush();
        }
      }
    }
}

Client:
import java.io.*;
import java.net.*;
public class GossipClient
{
  public static void main(String[] args) throws Exception
  {
	  InetAddress addr = InetAddress.getLocalHost();
     Socket sock = new Socket(addr, 3000);

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

     OutputStream ostream = sock.getOutputStream();
     PrintWriter pwrite = new PrintWriter(ostream, true);


     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();
        pwrite.println(sendMessage);
 pwrite.flush();
        if((receiveMessage = receiveRead.readLine()) != null)
  {
            System.out.println(receiveMessage);
        }
      }
    }
}


6. The message entered in the client is sent to the server and the server encodes the message and returns it to the client. Encoding is done by replacing a character by the character next to it i.e. a as b, b as c …z as a. This process is done using UDP. Write a Java program for the above.

Server:
public class udpens {
	public static void main(String args[]) throws Exception
	{
		DatagramSocket serverSocket = new DatagramSocket(6788);


		BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));
		//String reply;
		while(true)
		{
			byte[] receiveData = new byte[10];
			byte[] sendData = new byte[10];
			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.println("Enter reply: ");
			//reply = inFromUser.readLine();
			char reply[]=new char[30];
			reply=msg.toCharArray();
        	for(int i=0;i<msg.length();i++)
        	{
        		reply[i]++;
        	}

			sendData = new String(reply).getBytes("UTF-8");
			DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, port);
			serverSocket.send(sendPacket);
		}

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

public class udpen {
	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[10];
			byte[] receiveData = new byte[10];
			DatagramSocket clientSocket = new DatagramSocket();
			System.out.println("Send a Message: ");
			msg = inFromUser.readLine();
			if (msg.equals("bye"))
			{
				System.out.println("Exiting Chat!");
				clientSocket.close();
				break;
			}
			sendData = msg.getBytes();

			DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, 6788);
			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();
		}
	}
}


7. Write a Java program to display the name and address of the computer that we are currently working on.
CODE:
import java.net.*;
public class ques7 {
public static void main (String[] args) {
try {
InetAddress address = InetAddress.getLocalHost();
System.out.println(address);
}
catch (UnknownHostException ex) {
System.out.println("Could not find this computer's address.");
}
}
}



8. The client accepts IP header information in hexadecimal and sends to the server. The server receives those details and examines its checksum field. Write a Java program for this scenario.

import java.net.*;

import java.util.*;

public class demo
{
public long calculateChecksum(byte[] buf) {
    int length = buf.length;
    int i = 0;

    long sum = 0;
    long data;

    while (length > 1) {

      data = (((buf[i] << 8) & 0xFF00) | ((buf[i + 1]) & 0xFF));
      sum += data;
      // 1's complement carry bit correction in 16-bits (detecting sign extension)
      if ((sum & 0xFFFF0000) > 0) {
        sum = sum & 0xFFFF;
        sum += 1;
      }

      i += 2;
      length -= 2;
    }

    // Handle remaining byte in odd length buffers
    if (length > 0) {
      sum += (buf[i] << 8 & 0xFF00);
      // 1's complement carry bit correction in 16-bits (detecting sign extension)
      if ((sum & 0xFFFF0000) > 0) {
        sum = sum & 0xFFFF;
        sum += 1;
      }
    }

    // Final 1's complement value correction to 16-bits
    sum = ~sum;
    sum = sum & 0xFFFF;
    return sum;


--------

GOssip Client:


import java.io.*;
import java.net.*;
public class GossipClient
{
  public static void main(String[] args) throws Exception
  {
	  InetAddress addr=InetAddress.getLocalHost();
     Socket sock = new Socket(addr, 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;
	String sendMessage;

    	 String version;
    	 byte[] b = addr.getAddress();
        if(addr instanceof InetAddress)
        {
        	version="IPV4";
        }else
        {
        	version="IPV6";
        }

        long sum= calculateChecksum(b);

 System.out.println("Version: "+version);
 System.out.println("Checksum: "+sum);

      sendMessage = version;
        pwrite.println(sendMessage+"\n"+sum);
       // pwrite.println(sum);							// sending to server
        pwrite.flush();                    // flush the data
        if((receiveMessage = receiveRead.readLine()) != null) //receive from server
        {
            System.out.println(receiveMessage); // displaying at DOS prompt
        }
      }


private static long calculateChecksum(byte[] buf) {

   	 int length = buf.length;
   	 int i = 0;
   	 long sum = 0;
   	 long data;
   	 while (length > 1) {
   	 data = (((buf[i] << 8) & 0xFF00) | ((buf[i + 1]) & 0xFF));
   	 sum += data;
   	 // 1's complement carry bit correction in 16-bits (detecting sign extension)
   	 if ((sum & 0xFFFF0000) > 0) {
   	 sum = sum & 0xFFFF;
   	 sum += 1;
   	 }
   	 i += 2;
   	 length -= 2;
   	 }
   	 // Handle remaining byte in odd length buffers
   	 if (length > 0) {
   	 sum += (buf[i] << 8 & 0xFF00);
   	 // 1's complement carry bit correction in 16-bits (detecting sign extension)
   	 if ((sum & 0xFFFF0000) > 0) {
   	 sum = sum & 0xFFFF;
   	 sum += 1;
   	 }
   	 }
   	 //Final 1's complement value correction to 16-bits
   	 sum = ~sum;
   	 sum = sum & 0xFFFF;
   	 return sum;
   	 }

}




Gossip Server:

import java.io.*;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.*;
public class GossipServer
{
  public static void main(String[] args) throws Exception
  {
      ServerSocket sersock = new ServerSocket(3000);
      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();*/
      }
    }
}


--------



 9. Using threading concepts, write a Java program to create a daemon process.

CODE:
public class TestDaemonThread extends Thread{
 public void run(){
  if(Thread.currentThread().isDaemon()){
   System.out.println("daemon thread work");
  }
  else{
  System.out.println("user thread work");
 }
 }
 public static void main(String[] args){
  TestDaemonThread t1=new TestDaemonThread();
  TestDaemonThread t2=new TestDaemonThread();
  TestDaemonThread t3=new TestDaemonThread();

  t1.setDaemon(true);
  t2.setDaemon(true);
  t1.start();
  t2.start();
  t3.start();
 }
}


10. A server should run for 10 secs and generate numbers continuously. The client connecting to it should read data and find out the sum of the data thus read. Write a Java program to implement this scenario.

Server:
import java.net.*;
import java.io.*;
import java.util.*;
public class RandomServer
{
public static void main(String args[]) throws Exception
    {
ServerSocket s=new ServerSocket(5217);
		Date d = new Date();
		Random r = new Random();
		Socket soc=s.accept();
		int n=1;
		OutputStream out = soc.getOutputStream();
			PrintWriter pr=new PrintWriter(out);
			while(soc.isConnected() && n != -1)
			{
				long t= System.currentTimeMillis();
		long end = t+10000;
		//System.out.println("hello");
while((System.currentTimeMillis() < end))

        {
			int x=15;
			 n = r.nextInt(10);
			pr.println(n);
			pr.flush();
        }
		pr.flush();
		n=-1;
		pr.println(n);
out.close();
			soc.close();
		}
    }
}

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

public class RandomClient
{
public static void main(String args[]) throws Exception
    {
        Socket soc=new Socket(InetAddress.getLocalHost(),5217);
		int sum = 0;
BufferedReader in=new BufferedReader(new InputStreamReader(soc.getInputStream()));
		int count =0;
		int n=1;
		while(n!=-1)
		{
try{
		n = Integer.parseInt(in.readLine());
		System.out.println(n);
		sum = sum + n;
		count ++;
		}catch(Exception e)
		{
			n=-1;
		}
		}
		soc.close();
		System.out.println("Sum " + sum);
    }
}




11. DAEMON THREAD

public class TestDaemonThread extends Thread{
 public void run(){
  if(Thread.currentThread().isDaemon()){//checking for daemon thread
   System.out.println("daemon thread work");
  }
  else{
  System.out.println("user thread work");
 }
 }
 public static void main(String[] args){
  TestDaemonThread t1=new TestDaemonThread();//creating thread
  TestDaemonThread t2=new TestDaemonThread();
  TestDaemonThread t3=new TestDaemonThread();

  t1.setDaemon(true);//now t1 is daemon thread
  //t2.setDaemon(true);


  t1.start();//starting threads
  try{
	  t1.join();
	  }
	  catch(Exception e){}

  t2.start();
  t3.start();
 }
}


12. TCP CHAT AND ECHO DATE

Server:

import java.io.*;
import java.net.*;
import java.util.Date;
import java.io.*;
public class server
{
  public static void main(String[] args) throws Exception
  {
      ServerSocket sersock = new ServerSocket(3000);
      System.out.println("Server  ready for chatting");
      Socket sock = sersock.accept( );
      //BufferedReader keyRead = new BufferedReader(new InputStreamReader(System.in));
      OutputStream ostream = sock.getOutputStream();
      PrintWriter pwrite = new PrintWriter(ostream, true);
      InputStream istream = sock.getInputStream();
      BufferedReader receiveRead = new BufferedReader(new InputStreamReader(istream));
      DataOutputStream ostreams=new DataOutputStream(ostream);


      String receiveMessage, sendMessage;
      while(true)
      {
        if((receiveMessage = receiveRead.readLine()) != null)
        {
           System.out.println(receiveMessage);
           //if(receiveMessage.equals("date"))
           ostreams.writeBytes("Server Date: " + (new Date()).toString() + "\n");
        }
       // sendMessage = keyRead.readLine();
        pwrite.println(receiveMessage);
        pwrite.flush();
      }
    }
}






===================================================================
===================================================================
===================================================================


UDP CHAT 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();
		}
	}
}



UDP CHAT 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);
		}

	}
}




TCP CHAT Server

import java.io.*;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.*;
public class GossipServer
{
  public static void main(String[] args) throws Exception
  {
      ServerSocket sersock = new ServerSocket(3000);
      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();
      }
    }
}


TCP CHAT CLIENT

import java.io.*;
import java.net.*;
public class GossipClient
{
  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
        }
      }
    }
}





Q2 Write a Java program to run the basic networking commands.

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

}
}


Q3 Write a program to display the name of the computer and its IP address that you are currently working on

import java.net.*;
import java.io.*;
public class cm
{
public static void main(String args[])
{
try
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter the url which you want to find ip address and host name");
String str=br.readLine();
InetAddress add=InetAddress.getByName(str);
System.out.println("Local Host Information");
System.out.println("Host Name:"+add.getHostName());
System.out.println("IP address:"+add.getHostAddress());
}
catch(Exception e)
{
System.out.println(e);
}
}



Q4 Write a program to print the IP address of  “www.google.com” all IP addresses of  “www.microsoft.com”.




import java.net.*;
import java.io.*;
public class ip
{
public static void main(String args[])
throws UnknownHostException {
        System.out.println(InetAddress.getByName("www.google.com"));
        InetAddress[] inetAddresses=InetAddress.getAllByName("www.microsoft.com");
        for(InetAddress ipAddress:inetAddresses)
        {
                System.out.println(ipAddress);
        }
}
}



Q5 Write a program to print all Network Interfaces of “localhost”.

import java.net.*;
import java.util.*;
import java.io.*;
public class ni
{
public static void main(String args[]) throws UnknownHostException,SocketException
{

	Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
if(interfaces==null)
{
System.out.println("No network interfaces found");
}
else
{
for(NetworkInterface netIf:Collections.list(interfaces))
{
System.out.println("Display Name:" + netIf.getDisplayName());
System.out.println("Name : " + netIf.getName());
System.out.println();
}
}
}
}


Q6 Implement the simple version of “nslookup” utility

import java.net.*;
import java.io.*;
import java.util.*;
public class nslook
{
public static void main(String args[]) throws Exception
{
	BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	System.out.println("Enter the hostname");
	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();
	}
	System.out.println("Done");
}
}


Q7 Write a program to download the contents associated with a HTTP URL and save it in a file.



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)
		           {
		           }
		    }
	    }

}




cyclesheet2


Q1 Write a program to list all ports hosting a TCP server in a specified host and identify available servers in well-known ports?


import java.net.Socket;
import java.net.*;

public class A {
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);
	}
}
}



Q2 Implement echo server and client in java using TCP sockets.

server

import java.io.*;

import java.net.*;



public class EchoServer

{

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 EchoClient

{

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());

  }

}

}


Q3 Implement date server and client in java using TCP sockets


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());

    }

}



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();

        }



    }

}


Q4,Q6
Implement a chat server and client in java using TCP sockets.
Write a program to implement a simple message transfer from client to server process using TCP/IP.


SERVER

import java.io.*;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.*;
public class GossipServer
{
  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();
      }
    }
}


CLINET

import java.io.*;
import java.net.*;
public class GossipClient
{
  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
        }
      }
    }
}



Q7 Implement a TCP based server program to authenticate the client’s User Name and Password. The validity of the client must be sent as the reply message to the client and display it on the standard output.

CLIENT

import java.io.*;
import java.net.*;
class TCPClientAuth {

    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();

    }
}

SERVER


import java.io.*;
import java.net.*;

class TCPServerAuth {

  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();
        }
    }
}

************************************************

CYCLESHEET 2

Q8.Find the physical address of a host when its logical address is known (ARP protocol) using TCP/IP.

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

public class q8client
{
public static void main(String[] args)
{
try
{
Socket s = new Socket("localhost",5555);
BufferedReader b = new BufferedReader(new InputStreamReader(System.in));
DataOutputStream dout = new DataOutputStream(s.getOutputStream());
DataInputStream din = new DataInputStream(s.getInputStream());
System.out.println("Enter the logical address: ");
String str = b.readLine();
dout.writeBytes(str + "\n");
String str1 = din.readLine();
System.out.println("Physical Address of str: " + str1);
s.close();
}
catch (Exception e)
{
}
}}

SERVER:

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

public class q8server
{
public static void main(String[] args)
{
try
{
ServerSocket ss = new ServerSocket(5555);
Socket s = ss.accept();
BufferedReader b = new BufferedReader(new InputStreamReader(System.in));
DataOutputStream dout = new DataOutputStream(s.getOutputStream());
DataInputStream din = new DataInputStream(s.getInputStream());
String str = din.readLine();
String logical[] = {"172.16.27.34","195.24.54.204"};
String physical[] = {"8E:AE:08:AA","0A:78:6C:AD"};
for(int i=0;i<logical.length;i++)
{
if (str.equals(logical[i]))
{
dout.writeBytes(physical[i] + "\n");
break;
}
}
s.close();
}
catch (Exception e)
{
}
}
}


OUTPUT:


=====================================================





Q9.Find the logical address of a host when its physical address is known (RARP protocol) using TCP/IP.

CLIENT:
import java.io.*;
import java.net.*;
class TCPLogClient {

    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();

    }
}

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

class TCPLogServer {

  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();
		}
	}


        }
    }
}

=======================================


10.Implement Domain Name System (DNS) using TCP/IP

SERVER:
import java.io.*;
import java.net.*;
class TCPLoServer {
 public static void main(String argv[]) throws Exception
    {
      String D;
       ServerSocket welcomeSocket = new ServerSocket(6789);
    while(true) {
   Socket connectionSocket = welcomeSocket.accept();
BufferedReader inFromClient =
              new BufferedReader(new
              InputStreamReader(connectionSocket.getInputStream()));
String hostaddr[] = {"172.16.27.34","195.24.54.204", "10.10.137.1"};
	  String DNS[] = {"www.google.com","www.facebook.com", "www.vit.ac.in"};
           DataOutputStream  outToClient =
             new DataOutputStream(connectionSocket.getOutputStream());
   D = inFromClient.readLine();
for(int i = 0; i < hostaddr.length; i++)
	{
		if (D.equals(hostaddr[i]))
		{
			outToClient.writeBytes(DNS[i] + "\n");
			connectionSocket.close();
		}
	}


        }
    }
}



CLIENT:
import java.io.*;
import java.net.*;
class TCPLoClient {

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

        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 IP address of host");
        DNS = inFromUser.readLine();

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

       hostaddr = inFromServer.readLine();

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

        clientSocket.close();

    }
}



*************************************************

11.Implement a TCP/IP based Server program in Java to compute the factorial of a number (can contain arbitrary number of digits). Write a client program to test the working of the same.

CLIENT:
import java.io.*;
import java.net.*;
class client {
 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", 2222);
  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();
 }
}
SREVER:

import java.io.*;
import java.net.*;
class serv {
 public static void main(String argv[]) throws Exception
 {
  String clientSentence;
  String capitalizedSentence;
  ServerSocket welcomeSocket = new ServerSocket(2222);
   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);
 }
}

******************************************************

Ques12.Find the class of the IP address using TCP/IP.
import java.io.*;
import java.net.*;

class TCPIpclassServer {

  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 TCPIpclassClient {

    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();

    }
}

*************************************************


CYCLESHEET 3


1.Implement echo server and client in java using UDP sockets.

import java.io.*;
import java.net.*;

public class EServer
{
 public static void main(String[] args) throws IOException
 {

  ServerSocket S = new ServerSocket(3000);

  while(true)
  {
   Socket Client = S.accept();

   InputStream in = Client.getInputStream();

   DataInputStream Dis = new DataInputStream(in);

   System.out.println(Dis.readUTF());

   Client = new Socket("localhost",4000);

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

   String Str = buff.readLine();

   OutputStream out = Client.getOutputStream();

   DataOutputStream Dos = new DataOutputStream(out);

   Str = "Server Says :: " + Str;

   Dos.writeUTF(Str);

   Client.close();

  }

 }

}



//client
import java.io.*;
import java.net.*;
import java.util.*;

public class EClient
{
 public static void main(String[] args) throws IOException
 {
  Socket C = new Socket("localhost",3000);
  BufferedReader buff = new BufferedReader(new InputStreamReader (System.in));
  String Str = buff.readLine();

  OutputStream out = C.getOutputStream();

  DataOutputStream Dos = new DataOutputStream(out);

  Dos.writeUTF("Client Say :: " + Str);
  Dos.flush();

  ServerSocket S = new ServerSocket(4000);
  Socket Client = S.accept();
  InputStream in = Client.getInputStream();
  DataInputStream Dis = new DataInputStream(in);
  System.out.println(Dis.readUTF());
  Client.close();
 }
}

OUTPUT:


***************************************************



2.Write a program to implement a text based message transfer from client to server process using UDP.

//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 Server
{

    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");

            //Server is running always. This is done using this while(true) loop
            while(true)
            {
                //Reading the message from the client
                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);

                //Multiplying the number by 2 and forming the return message
                String returnMessage;
                try
                {
                    int numberInIntFormat = Integer.parseInt(number);
                    int returnValue = numberInIntFormat*2;
                    returnMessage = String.valueOf(returnValue) + "\n";
                }
                catch(NumberFormatException e)
                {
                    //Input was not a number. Sending proper message back to client.
                    returnMessage = "Please send a proper number\n";
                }

                //Sending the response back to the client.
                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 Client
{

    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);

            //Send the message to the server
            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);

            //Get the return message from the server
            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
        {
            //Closing the socket
            try
            {
                socket.close();
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }
        }
    }
}

OUTPUT:






**********************************************





3.Implement a chat server and client in java using UDP sockets.

//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();
		}
	}
}


****************************************



4. Implement a DNS server and client in java using UDP sockets.

//server
import java.io.*;
import java.net.*;
import java.util.*;
class Serverdns12
{

            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.aptitudeguru.com","www.downloadcyclone.blogspot.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 Clientdns12
{
            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);
            }
            }
}

***************************





5. Find the logical address of a host when its physical address is known (RARP protocol) using UDP.

//SERVER
import java.io.*;
import java.net.*;

public class UDPRARPServer {
	public static void main(String args[]) throws Exception
	{
		DatagramSocket serverSocket = new DatagramSocket(6789);
		byte[] receiveData = new byte[1024];
		byte[] sendData = new byte[1024];

		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"};
		String reply = "";

		while(true)
		{
			DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
			serverSocket.receive(receivePacket);

			String phyaddr = new String(receivePacket.getData());
			System.out.println("Physical Address received: " + phyaddr);
			phyaddr = phyaddr.trim();
			InetAddress IPAddress = receivePacket.getAddress();
			int port = receivePacket.getPort();

			for(int i = 0; i < physical.length; i++)
			{
				if (phyaddr.equals(physical[i]))
				{
					reply = logical[i];
					sendData = reply.getBytes();
					DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, port);
					serverSocket.send(sendPacket);
				}
			}

		}
	}
}










//CLIENT
import java.io.*;
import java.net.*;

public class UDPRARPClient {
	public static void main(String args[]) throws Exception
	{
		BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));
		DatagramSocket clientSocket = new DatagramSocket();
		InetAddress IPAddress = InetAddress.getByName("localhost");
		byte[] sendData = new byte[1024];
		byte[] receiveData = new byte[1024];

		System.out.printf("Enter Physical address: ");
		String phyaddr = inFromUser.readLine();
		sendData = phyaddr.getBytes();

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

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

		String logaddr = new String(receivePacket.getData());
		System.out.println("Logical Address:" + logaddr);
		clientSocket.close();
	}
}


********************************


6.Find the physical address of a host when its logical address is known (ARP protocol) using UDP.

//server
import java.io.*;
import java.net.*;
import java.util.*;
class Serverarp12
{
            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 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 Clientarp12
{
            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);
            }
            }
}



*********************************


7.Implement Client - Server communication to access Date using UDP in Java.


//server
import java.io.*;
import java.net.*;
import java.util.*;

public class UDPDateServer {
	public static void main(String args[]) throws Exception
	{
		DatagramSocket serverSocket = new DatagramSocket(6789);
		byte[] receiveData = new byte[1024];
		byte[] sendData = new byte[1024];
		String GetDate = "";
		while(true)
		{
			DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
			serverSocket.receive(receivePacket);

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

			InetAddress IPAddress = receivePacket.getAddress();
			int port = receivePacket.getPort();
			msg = msg.trim();
			if (msg.equals("date"))
			{
				Date d = new Date();
				GetDate = d.toString();
			}

			sendData = GetDate.getBytes();
			DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, port);
			serverSocket.send(sendPacket);
		}
	}
}



//client

import java.io.*;
import java.net.*;


public class UDPDateClient {
	public static void main(String args[]) throws Exception
	{
		BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));
		DatagramSocket clientSocket = new DatagramSocket();
		InetAddress IPAddress = InetAddress.getByName("localhost");
		byte[] sendData = new byte[1024];
		byte[] receiveData = new byte[1024];

		System.out.printf("Enter Request: ");
		String msg = inFromUser.readLine();
		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("FROM SERVER:" + reply);
		clientSocket.close();
	}
}




7 USING UDP

import java.net.*;
import java.io.*;

public class Clientnew {

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

    System.out.println("Server Time >>>>");

    DatagramSocket cs=new DatagramSocket();

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

    byte[] rd=new byte[100];
    byte[] sd=new byte[100];

    DatagramPacket sp=new DatagramPacket(sd,sd.length,ip,1234);

    DatagramPacket rp=new DatagramPacket(rd,rd.length);

    cs.send(sp);

    cs.receive(rp);

    String time=new String(rp.getData());

    System.out.println(time);

    cs.close();

}

}



==============================

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

public class Server {

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

DatagramSocket ss=new DatagramSocket(1234);

while(true){

System.out.println("Server is up....");

byte[] rd=new byte[100];
byte[] sd=new byte[100];

DatagramPacket rp=new DatagramPacket(rd,rd.length);

ss.receive(rp);

InetAddress ip= rp.getAddress();

int port=rp.getPort();

Date d=new Date();   // getting system time

String time= d + "";  // converting it to String

sd=time.getBytes();   // converting that String to byte

DatagramPacket sp=new DatagramPacket(sd,sd.length,ip,port);

ss.send(sp);

rp=null;

System.out.println("Done !! ");

}

}

}



////
sethi broad


clinet


import java.io.IOException;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.MulticastSocket;
import java.net.UnknownHostException;
import java.util.Scanner;

public class MulticastSocketClient {

    final static String INET_ADDR = "224.0.0.3";

    public static void main(String[] args) throws UnknownHostException {
        // Get the address that we are going to connect to.
        InetAddress address = InetAddress.getByName(INET_ADDR);
        int p = 0;
        Scanner sc=new Scanner(System.in);
        p=sc.nextInt();

        // Create a buffer of bytes, which will be used to store
        // the incoming bytes containing the information from the server.
        // Since the message is small here, 256 bytes should be enough.
        byte[] buf = new byte[256];

        // Create a new Multicast socket (that will allow other sockets/programs
        // to join it as well.
        try {
        	MulticastSocket clientSocket = new MulticastSocket(p);
            //Joint the Multicast group.
            clientSocket.joinGroup(address);

            while (true) {
                // Receive the information and print it.
                DatagramPacket msgPacket = new DatagramPacket(buf, buf.length);
                clientSocket.receive(msgPacket);

                String msg = new String(buf, 0, buf.length);
                System.out.println("Socket 1 received msg: " + msg);
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}



server


import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Scanner;

public class MulticastSocketServer {

    final static String INET_ADDR = "224.0.0.3";

    public static void main(String[] args) throws UnknownHostException, InterruptedException {
        // Get the address that we are going to connect to.
        InetAddress addr = InetAddress.getByName(INET_ADDR);
        int p = 0;
        Scanner sc=new Scanner(System.in);
        p=sc.nextInt();
        // Open a new DatagramSocket, which will be used to send the data.
         try {
        	 DatagramSocket serverSocket = new DatagramSocket();
            for (int i = 0; i < 5; i++) {
                String msg = "Sent message no " + i;

                // Create a packet that will contain the data
                // (in the form of bytes) and send it.
                DatagramPacket msgPacket = new DatagramPacket(msg.getBytes(),
                        msg.getBytes().length, addr, p);
                serverSocket.send(msgPacket);

                System.out.println("Server sent packet with msg: " + msg);
                Thread.sleep(500);
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}


///ssl server jalaj

import java.io.*;
import java.util.*;
import java.net.*;
import javax.net.ssl.*;

public class serprac {
  public static void main (String[] main){
	  try{

		  SSLServerSocketFactory fact = (SSLServerSocketFactory) SSLServerSocketFactory.getDefault();
		  SSLServerSocket ss = (SSLServerSocket) fact.createServerSocket(5000);
		  SSLSocket s = (SSLSocket) ss.accept();
		  String[] supported = s.getSupportedCipherSuites();
		  s.setEnabledCipherSuites(supported);
		  BufferedReader keyred = new BufferedReader(new InputStreamReader(System.in));
		  OutputStream os = s.getOutputStream();
		  PrintWriter pw = new PrintWriter(os);
		  BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
		  String send="",recv = "";
		  while(true){
			  if((recv = br.readLine())!=null){
				  System.out.println("server msg received : "+recv);
			  }
			  send = keyred.readLine();
			  pw.println(send);
			  pw.flush();
		  }

	  }catch(Exception e){
		  e.printStackTrace();
	  }
  }
}


client


package labprog;
import java.util.*;
import java.io.*;
import java.net.*;

import javax.net.SocketFactory;
import javax.net.ssl.*;

public class clientprac {
	public static void main (String[] main){
		  try{


			  SSLServerSocketFactory fact = (SSLServerSocketFactory) SSLServerSocketFactory.getDefault();
			  SocketFactory sf = SSLSocketFactory.getDefault();

			  SSLSocket s = (SSLSocket) sf.createSocket("127.0.0.1",5000);
			  String[] supported = s.getSupportedCipherSuites();
			  s.setEnabledCipherSuites(supported);
			  BufferedReader keyred = new BufferedReader(new InputStreamReader(System.in));
			  OutputStream os = s.getOutputStream();
			  PrintWriter pw = new PrintWriter(os);
			  BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
			  String send="",recv = "";
			  while(true){
				  send = keyred.readLine();
				  pw.println(send);
				  pw.flush();

				  if((recv = br.readLine())!=null){
					  System.out.println("client msg recv : "+recv);
				  }

			  }

		  }catch(Exception e){
			  e.printStackTrace();
		  }
	  }
}




//// rmi sethi

rmiserver

import java.io.*;
import java.net.*;
import java.rmi.*;
import java.rmi.registry.LocateRegistry;
import java.rmi.server.*;
public class rmiServer
{
	public static void main(String[] args) throws RemoteException
	{
		LocateRegistry.createRegistry(1906);
		try
		{
			inter_tp ob = new inter_tp();
			//Naming.bind("fact",ob);
			Naming.rebind("rmi://localhost:1906"+
                    "/fact",ob);
		}
		catch(Exception e)
		{
			System.out.println(e);
		}
	}
}


rmiclient


import java.rmi.*;
import java.rmi.server.*;
import java.io.*;
class rmiClient
{
	public static void main(String[] args)
	{
		try
		{
			inter ob1 = (inter)Naming.lookup("rmi://localhost:1906/fact");
			System.out.println(ob1.fact(3));
		}
		catch(Exception e)
		{
			System.out.println(e);
		}
	}
}


inter

import java.util.*;
import java.io.*;
import java.net.*;
import java.rmi.*;
public interface inter extends Remote
{
	public int fact(int n) throws RemoteException;
}




inter tp


import java.util.*;
import java.io.*;
import java.net.*;
import java.rmi.*;
import java.rmi.server.*;
class inter_tp extends UnicastRemoteObject implements inter
{
	inter_tp() throws RemoteException
	{
		//super();
	}
	public int fact(int n) throws RemoteException
	{

		int p=1;
		for(int i=1 ; i<=n ; i++)
			p*=i;
		return p;

	}
}


/// rmi atif

inter

import java.util.*;
import java.io.*;
import java.net.*;
import java.rmi.*;
public interface inter extends Remote
{
	public int fact(int n) throws RemoteException;
}


inter_tp

import java.util.*;
import java.io.*;
import java.net.*;
import java.rmi.*;
import java.rmi.server.*;
class inter_tp extends UnicastRemoteObject implements inter
{
	inter_tp() throws RemoteException
	{
		//super();
	}
	public int fact(int n) throws RemoteException
	{

		int p=1;
		for(int i=1 ; i<=n ; i++)
			p*=i;
		return p;

	}
}

rmiServer

import java.io.*;
import java.net.*;
import java.rmi.*;
import java.rmi.server.*;
public class rmiServer
{
	public static void main(String[] args)
	{
		try
		{
			inter_tp ob = new inter_tp();
			Naming.bind("fact",ob);
		}
		catch(Exception e)
		{
			System.out.println(e);
		}
	}
}

rmiClient

import java.rmi.*;
import java.rmi.server.*;
import java.io.*;
class rmiClient
{
	public static void main(String[] args)
	{
		try
		{
			inter ob1 = (inter)Naming.lookup("rmi://127.0.0.1/fact");
			System.out.println(ob1.fact(3));
		}
		catch(Exception e)
		{
			System.out.println(e);
		}
	}
}