Java

 
 
import java.net.*;
import java.io.*;
public class servidorudp {
   public static void main(String argv[]) {
 
      DatagramSocket socket;
      boolean fin = false;
      //Creamos un objeto de tipo DatagrmaPacket para recibir un paquete del cliente
      DatagramPacket paquete;
      //Creamos paquete de vuelta para el cliente
      DatagramPacket paquete2;
      //Declaramos una variable de tipo string donde guardaremos el mensaje recibido
      //por el lciente
      String mensaje ="";
      //Declaramos una variable string para la cadena que le mandaremos al cliente
      String MensajeSalida ="";
 
      try {
 
    	 //Abrimos un socket en el puerto 6000
    	  //A través de este socket enviaremos paquetes de tipo Datagrama
         socket = new DatagramSocket(6000);
 
         //Nos preparamos para recibir una mensaje de 256 bytes
    	 byte[] mensaje_bytes = new byte[256];
    	 mensaje_bytes = new byte[256];
         //Creamos un contenedor de datagrama, el buffer será el array mensaje_bytes
    	 paquete = new DatagramPacket(mensaje_bytes,256);
 
 
         do {
 
            mensaje_bytes = new byte[256];
 
            //Creamos un contenedor de datagrama, el buffer será el array mensaje_bytes
            paquete = new DatagramPacket(mensaje_bytes,256);
 
            //Esperamos a recibir un paquete
            socket.receive(paquete);
 
           //Convertimos el mensaje recibido en un string
        	mensaje = new String(mensaje_bytes).trim();
 
           //Imprimimos el paquete recibido
           System.out.println(mensaje);  
 
 
           //Condiciones encadenadas para mandar la información
           //dependiendo del dato recibido
           if (mensaje.startsWith("HELLO")) {
 
          	   MensajeSalida = "HELLO";
           }
           else if (mensaje.startsWith("ALL")) {
 
        	   MensajeSalida = "ALL BUR:250;CHE:300; BIG:540; PAT:380; SAL:240; BEV:210; DIE:0; COF:0; DES:300";
           	System.out.println(MensajeSalida);
 
           }
           else if(mensaje.startsWith("BUR"))
           {
        	   MensajeSalida = "BUR 250";
           	System.out.println(MensajeSalida);
           }
           else if (mensaje.startsWith("CHE")) {
        	   MensajeSalida = "CHE 300";
           	System.out.println(MensajeSalida);
           }
           else if (mensaje.startsWith("BIG")) {
        	   MensajeSalida= "BIG 540";
           	System.out.println(MensajeSalida);
           }
           else if (mensaje.startsWith("PAT")) {
        	   MensajeSalida= "PAT 380";
           	System.out.println(MensajeSalida);
           }
           else if (mensaje.startsWith("SAL")) {
        	   MensajeSalida= "SAL 240";
           	System.out.println(MensajeSalida);
           }
           else if (mensaje.startsWith("BEV")) {
        	   MensajeSalida= "SAL 210";
           	System.out.println(MensajeSalida);
           }
           else if (mensaje.startsWith("DIE")) {
        	   MensajeSalida= "DIE 0";
           	System.out.println(MensajeSalida);
           }
           else if (mensaje.startsWith("COF")) {
        	   MensajeSalida= "COF 0";
           	System.out.println(MensajeSalida);
           }
           else if (mensaje.startsWith("DES")) {
        	   MensajeSalida= "DES 300";
           	System.out.println(MensajeSalida);
           }
           else if (mensaje.startsWith("fin")) {
        	   MensajeSalida= "fin";
       	    System.out.println(MensajeSalida);
       	    fin=true;
           }
           else{
        	   MensajeSalida = "ERROR";	
           	   System.out.println(MensajeSalida);
           }
 
 
           //Nº de puerto desde donde se envió  
           int puerto = paquete.getPort();  
           //Dirección de Internet desde donde se envió
           InetAddress address = paquete.getAddress();
           //Preparamos el formato que le vamos a mandar
           byte[] mensaje2_bytes = new byte[256];
           //Guardamos en mensaje2_bytes el mensaje de salida formateado
           mensaje2_bytes = MensajeSalida.getBytes();
           //Generamos el paquete de vuelta, usando los datos  
           // del remitente del paquete original
           paquete2 = new DatagramPacket(mensaje2_bytes,MensajeSalida.length(),address,puerto);
           // Enviamos  
           socket.send(paquete2);
 
         } while (!fin);
      }
      catch (Exception e) {
         System.err.println(e.getMessage());
         System.exit(1);
      }
   }
}

//Practica3 Yolanda_Jimenez_Anaya
 
import java.net.*;
import java.io.*;
public class servidor3udp {
 
	public static void main(String argv[]) {
 
 
		if (argv.length != 1) {
	         System.err.println("java servidor3udp ");
	         System.exit(1);}
 
        //CUANDO SE HACE REFERENCIA AL SERVIDOR2, ES A LA CLASE servidorudp.java
		//Declaración de variables
		DatagramSocket socket;
	    DatagramSocket socketCli;
	    DatagramPacket paquet;
	    DatagramPacket paquetServidor;
	    DatagramPacket paquetServidor2;
	    InetAddress address;
	    byte[] mensaje_bytes = new byte[256];
	    byte[] mensajeServidor_bytes = new byte[256];
	    byte[] mensajeServidor2_bytes = new byte[256];
	    byte[] Pedido1_bytes = new byte[256];
	    byte[] Pedido2_bytes = new byte[256];
	    byte[] mensaje3_bytes = new byte[256];
	    String mensaje="HELLO";
	    String mensajeServidor,mensajeServidor2, mensaje3  = "";
	    int iCaloriaPeiddo2,  iCaloriaPeiddo1, longMensaje, pos, port,iTotalCalorias=0;
	    String Pedido2, Pedido1, CaloriaPedido2, CaloriaPedido1 ="";
 
 
	    try {
 
	    	//Creamos un socket para comunicarnos con el servidor 
	 	    socket = new DatagramSocket();
	 	    //Obtenemos la dirección de destino
	        address=InetAddress.getByName(argv[0]);
	        mensaje = "HELLO";
		    mensaje_bytes = mensaje.getBytes();
		    //Creamos el paquete que vamos a enviar
	        paquet = new DatagramPacket(mensaje_bytes,mensaje.length(),address,6000);
	        socket.send(paquet);
 
 
	        //Recibimos el paquete que nos devuelve el servidor2
		    mensajeServidor_bytes = new byte[256];
		    paquetServidor = new DatagramPacket(mensajeServidor_bytes,256);
	        socket.receive(paquetServidor);
 
		    mensajeServidor = new String(mensajeServidor_bytes).trim();
	        System.out.println(mensajeServidor);
	        //Bucle para que el servidor siempre este esperando una entrada
	        socketCli =  new  DatagramSocket(6001);
 
	        do{
 
	        	 mensaje_bytes = new byte[256];
				 paquet = new DatagramPacket(mensaje_bytes,256);
 
				 //Recibimos un paquete del cliente
				 socketCli.receive(paquet);
				 mensaje = new String(mensaje_bytes).trim();
 
				 //Obtenemos la dirección y el puerto del cliente
	       		 address = paquet.getAddress();
			     port = paquet.getPort();
 
 
 
			     if (mensaje.startsWith("HELLO")) {
			    	 //Si se ha recibido la palabra HELLO del cliente, le contestaremos
 
			    	 paquetServidor = new DatagramPacket(mensaje_bytes,mensaje.length(),address,port);
			         socketCli.send(paquetServidor); 
			     }
			     else{
			    	 System.out.println(mensaje);
 
					 //Limpiamos las variables utilizadas.
					 iCaloriaPeiddo2=0;
					 iCaloriaPeiddo1=0;
					 longMensaje=0;
 
					  //Para separar las dos descipciones calcularemos el tamaño de la cadena
					  //y buscaremos un espacio que las separa, después cogeremos la segunda cadena
					  //emepzando por la posición +1, para poder saltar el espacio en blanco
 
					  longMensaje = mensaje.length();
					  pos= mensaje.indexOf(' ');
 
					  if (pos > 0) {
 
						//Si es mayor que cero se han recibido dos palabras  
						//Separamos el contenido enviado para calcular la suma de calorias  
 
						//Obtenemos la descripción de los dos pedidos  
 
						//Segundo pedido  
						Pedido2 = mensaje.substring(pos+1, longMensaje); 
 
					    //Primer pedido
					    Pedido1 = mensaje.substring(0,pos);
 
 
					    //Calculamos las calorias del pedido2
					    Pedido2_bytes = Pedido2.getBytes();
					    paquet = new DatagramPacket(Pedido2_bytes,Pedido2.length(),address,6000);
					    socket.send(paquet);
 
					    mensajeServidor2_bytes = new byte[256];
						paquetServidor2 = new DatagramPacket(mensajeServidor2_bytes,256);
					    socket.receive(paquetServidor2);
						mensajeServidor2 = new String(mensajeServidor2_bytes).trim();
 
 
						//Se calcula el tamaño del resultado del Pedido2
						longMensaje = mensajeServidor2.length();
						pos= mensajeServidor2.indexOf(' ');
 
					    if ((pos < 0) || mensajeServidor2.startsWith("ERROR") || mensajeServidor2.startsWith("ALL")){
					    	//Si se ha recibido del servidor2 la palabra error, o la palabra ALL, las calorias serán 99999
					    	CaloriaPedido2 = "ERROR";
					    	mensajeServidor2 = Pedido2 + " " + "ERROR";
					    	iCaloriaPeiddo2 = 9999;
					    }
					    else{
					       //Separamos las calorias del pedido2
						   CaloriaPedido2 = mensajeServidor2.substring(pos+1, longMensaje);
						   //Valor numérico de las calorias del pedido2
						   iCaloriaPeiddo2 = Integer.parseInt(CaloriaPedido2.trim());
					    }
 
						//Calculamos las calorias del pedido1
					    Pedido1_bytes = Pedido1.getBytes();
					    //Le mandamos al servidor2 el literal del Pedido1
					    paquet = new DatagramPacket(Pedido1_bytes,Pedido1.length(),address,6000);
					    socket.send(paquet);
 
					    mensajeServidor_bytes = new byte[256];
						paquetServidor = new DatagramPacket(mensajeServidor_bytes,256);
					    socket.receive(paquetServidor);
						mensajeServidor = new String(mensajeServidor_bytes).trim();
 
 
						//Se calcula el tamaño del resultado del Pedido2
						longMensaje = mensajeServidor.length();
						pos= mensajeServidor.indexOf(' ');
 
					    if ((pos < 0) || mensajeServidor.startsWith("ERROR") || mensajeServidor.startsWith("ALL")){
					    	//Si se ha recibido del servidor2 la palabra error, o la palabra ALL, las calorias serán 99999
					    	CaloriaPedido1 = "ERROR";
					    	mensajeServidor = Pedido1 + " " + "ERROR";
					    	iCaloriaPeiddo1 = 9999;
					    }
					    else{
					       //Separamos las calorias del pedido1
						   CaloriaPedido1 = mensajeServidor.substring(pos+1, longMensaje);
						   //Valor numérico de las calorias del pedido2
						   iCaloriaPeiddo1 = Integer.parseInt(CaloriaPedido1.trim());
					    }
 
 
						//Calculamos el total de las calorias
						if(iCaloriaPeiddo2 == 9999 || iCaloriaPeiddo1 == 9999){
							//Si uno de los dos pedidos es erroneo el total de calorias será 9999
							iTotalCalorias = 9999;
						}
						else
						  iTotalCalorias = iCaloriaPeiddo1 + iCaloriaPeiddo2;
 
						System.out.println(mensajeServidor);
						System.out.println(mensajeServidor2);
						//Se crea el mensaje final con los dos pedidos y la suma de sus calorias.
						 mensaje3 = Pedido1 + " " + Pedido2 + " " + iCaloriaPeiddo1 + " " + iCaloriaPeiddo2 + " = " + iTotalCalorias;
 
						//Imprimimos en el servidor3 el total
						 System.out.println(mensaje3);
						 mensaje3_bytes = mensaje3.getBytes();
						//Le mandamos al cliente el total de calorias de los dos productos.
						 paquetServidor = new DatagramPacket(mensaje3_bytes,mensaje3.length(),address,port);
				         socketCli.send(paquetServidor);
 
 
					  }
					  else{
						 //Si es menor que 0 solo se habrá recibido una palabra 
						 //Le mandamos al servidor2 la descripción
 
					     //Enviamos al servidor la palabra recibida
						 paquet = new DatagramPacket(mensaje_bytes,mensaje.length(),address,6000);
					     socket.send(paquet);
 
					     mensajeServidor_bytes = new byte[256];
						 paquetServidor = new DatagramPacket(mensajeServidor_bytes,256);
					     socket.receive(paquetServidor);
 
 
						 mensajeServidor = new String(mensajeServidor_bytes).trim();
					     System.out.println(mensajeServidor);
 
 
					     //El resultado se lo mandamos al cliente
					     paquetServidor = new DatagramPacket(mensajeServidor_bytes,mensajeServidor.length(),address,port);
				         socketCli.send(paquetServidor);
 
					  }
			     }
 
	        }while (1>0);
 
	    }
	   catch (Exception e) {
	   System.err.println(e.getMessage());
	   System.exit(1);}
}
}

 
import java.net.*;
import java.io.*;
 
public class clienteudp {
   public static void main(String argv[]) {
 
	   if (argv.length == 0) {
         System.err.println("java clienteudp servidor");
         System.exit(1);
      }
 
      BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
 
      DatagramSocket socket;
      InetAddress address;
      byte[] mensaje_bytes = new byte[256];
      byte[] MensajeServidor_bytes = new byte[256];
      String mensaje="";
      String mensajeServidor="";
      //Paquete para enviar al servidor
      DatagramPacket paquete;
      //Creamos el objeto paquete2 de tipo DaragramPacket para recibir del servidor
      DatagramPacket paquete2;
      mensaje_bytes=mensaje.getBytes();
 
      try {
 
    	  //Creamos el socket
    	  socket = new DatagramSocket();
 
         // Leemos el primer parámetro, donde debe ir la dirección  
         // IP del servidor 
         address=InetAddress.getByName(argv[0]);
 
         mensaje = "HELLO";
         mensaje_bytes = mensaje.getBytes();
         //Creamos paquete
         paquete = new DatagramPacket(mensaje_bytes,mensaje.length(),address,6001);
         //Mandamos el paquete
 
         socket.send(paquete);
 
         //El mensaje recibido vendrá en bytes
         MensajeServidor_bytes = new byte[256];
         //Esperamos a recibir un paquete
         paquete2 = new DatagramPacket(MensajeServidor_bytes,256);
         socket.receive(paquete2);
         //Convertimos el mensaje recibido en un string
 		 mensajeServidor = new String(MensajeServidor_bytes).trim();
 		 //Imprimimos el paquete recibido
 		 System.out.println(mensajeServidor);  
 
         do {
 
        	//Lee los caracteres introducidos por pantalla 
            mensaje = in.readLine();
            mensaje_bytes = mensaje.getBytes();
 
            //Creamos paquete
            paquete = new DatagramPacket(mensaje_bytes,mensaje.length(),address,6001);
 
            //Mandamos el paquete
            socket.send(paquete);
 
 
            //El mensaje recibido vendrá en bytes
            MensajeServidor_bytes = new byte[256];
 
            //Esperamos a recibir un paquete
            paquete2 = new DatagramPacket(MensajeServidor_bytes,256);
            socket.receive(paquete2);
 
            //Convertimos el mensaje recibido en un string
    		mensajeServidor = new String(MensajeServidor_bytes).trim();
 
    		//Imprimimos el paquete recibido
    		System.out.println(mensajeServidor);  
 
 
         } while (!mensaje.startsWith("fin"));
      }
      catch (Exception e) {
         System.err.println(e.getMessage());
         System.exit(1);
      }
   }
}

 
import java.io.*;
import java.net.*;
 
public class Cliente_uoc {
 
public static void main(String args[]) {
	Socket cliente = null;
	DataInputStream entrada = null;
	DataOutputStream salida = null;
 
	String ipServidor ="127.0.0.1";	  
	//nos conectamos al localhost a traves de esta dirección IP
 
	//if (cliente != null && salida != null && entrada!= null) {	
try {	
 
	cliente = new Socket(ipServidor, 2017);  
	//asignamos este numero de puerto
	entrada = new DataInputStream(cliente.getInputStream());
	// será lo que enviaremos al servidor	
	salida = new DataOutputStream(cliente.getOutputStream());
	// será lo que nos devuelva el servidor	
 
}
catch (UnknownHostException excepcion) {
	System.err.println("El servidor no está levantado");
}
catch (Exception e) {
	System.err.println("Error: " + e );
}
 
try {
	String linea_recibida;
	salida.writeBytes("Frase que envio al servidor\n");
	linea_recibida = entrada.readLine();
	System.out.println("SERVIDOR DICE: " + linea_recibida);
	salida.close();
	entrada.close();
	cliente.close();
}
catch (UnknownHostException excepcion) {
	System.err.println("No encuentro el servidor en la dirección" + ipServidor);
}
catch (IOException excepcion) {
	System.err.println("Error de entrada/salida");
}
catch (Exception e) {
	System.err.println("Error: " + e );
 
}
}
}

 
import java.io.*;
import java.net.*;
public class Servidor_uoc {
public static void main(String args[]) {
ServerSocket mi_servicio = null;
String linea_recibida;
DataInputStream entrada;
PrintStream salida;
Socket socket_conectado = null;
try {
mi_servicio = new ServerSocket(2017);
}
catch (IOException excepcion) {
System.out.println(excepcion);
}
try {
socket_conectado = mi_servicio.accept();
entrada = new DataInputStream(socket_conectado.getInputStream());
salida = new PrintStream(socket_conectado.getOutputStream());
linea_recibida = entrada.readLine();
salida.println("Te reenvio lo que he recibido:" + linea_recibida );
salida.close();
entrada.close();
socket_conectado.close();
}
catch (IOException excepcion) {
System.out.println(excepcion);
}}
}