Originally posted by Flavia

Se vuoi e se trovo tempo, ti scrivo il codice che ho fatto io all'esame!
:ciao:

Originally posted by Flavia
Se vuoi e se trovo tempo, ti scrivo il codice che ho fatto io all'esame!
:ciao:

Originally posted by urcodiaz
Da quello che ho capito la programmazione c'è solo in java...ovvio che bisogna sapere anche quella in c, ma di codice vero e proprio da scrivere c'è solo java...confermate?

Originally posted by urcodiaz
-Secondo, terzo e quarto modulo: scrittura del CODICE che esegue una particolare richiesta. La richiesta è la stessa per tutti e quattro i turni dell'esame, solo che due di questi dovranno implementarla in UDP, due in TCP.

Ok, ma il server multithread utilizza il protocollo tcp, quindi chi ha avuto l'udp era solo per l'esercizio di completamento...giusto?

Originally posted by Flavia
Se vuoi e se trovo tempo, ti scrivo il codice che ho fatto io all'esame!
:ciao: [/B]

Originally posted by mt661588
ho voluto solo postarlo se qualcuno lo controlla è meglio credo di averlo fatto giusto, magari può essere utile a qualcuno ciao

Originally posted by mt661588

ho voluto solo postarlo se qualcuno lo controlla è meglio credo di averlo fatto giusto, magari può essere utile a qualcuno ciao

Originally posted by urcodiaz

scusate ma se uno non ha mai programmato in java, come fa, una volta sistemata la struttura del client e del server, a scrivere il codice con le richieste effettive del client e le risposte del server?
Invento al momento?
E' fondamentale che sia giusto tutto o l'importante è solo che la struttura client server sia corretta?

Originally posted by mt661588
ho voluto solo postarlo se qualcuno lo controlla è meglio credo di averlo fatto giusto, magari può essere utile a qualcuno ciao

Originally posted by mt661588
ho voluto solo postarlo se qualcuno lo controlla è meglio credo di averlo fatto giusto, magari può essere utile a qualcuno ciao

Originally posted by Flavia
Si, un server multithread che fa "partire" tanti thread diversi associati a vari processi!
Ovvero nella classe server avrai solamente una cosa del genere:
{
.....
Socket socket;
while(true) {
ServerThread t= new ServerThread(socket);
t.start();}
..}

e tutte le funzioni/operazioni le implementi nella classe

class ServerThread extends Thread

che implementerà un costruttore ServerThread e un metodo run che svolge proprio le fuznioni richieste (calcolare una somma ad esempio!).

Chiaro?Quindi il server "normale" si preoccupa solo di far partire un thread, non esegue nessun altra operazione o calcola, quindi "sbologna" tutto il lavoro al thread "t", che è un oggetto di tipo ServerThread.
Le sue azioni e il costruttore verranno indi implementate in una nuova classe, "ServerThread" che estende la classe Thread!
:-D

Se vuoi e se trovo tempo, ti scrivo il codice che ho fatto io all'esame!
:ciao:

Originally posted by josh
Ragazzi sono ancora alla prese con il capitolo 3 del libro in italiano, ero arrivato verso la fine vi chiedo chiaramente e prego a chi lo saa di rispondermi..

L'atm va fatti?
il 3.7 (compresi tutti quei sottoparagrafi incasinati)??

Thanks...

ps: risrivo la mia domanda di prima, è il compito (parte teorica) sarà solo a crocettE?


helpp

Originally posted by francesco2
Ma sapete se in qualche turno degli esami passati ( gli ultimi 2 ) è stato richiesto di implementare un client ed un server Udp? Fino ad ora si è sempre parlato solo di tcp multithread, vero?

Originally posted by francesco2
non lo sapevo... pensavo ci fosse da scrivere solo client e server tcp.
Anche perchè l'udp non è multithread.

Originally posted by josh
scusa luna mentre il 3.7 e tutti i suoi sotto paragrafi...
grazie per la risposta precedente...

Originally posted by papousek
mmm..quello che mi chiedo ormai da molto..e a cui nn ne vengo a capo è questo...

allora...nell esame ormai è risaputo cio che chiede

1)domande su c
2)client (TCP/UDP a seconda del turno)
3)serverthread (TCP/UDP a seconda del turno)
4)server multithread (TCP/UDP a seconda del turno)

ecco...

mi chiede il client..ok va bene..compilo secondo le richieste...
mi chiede il server thread...ok..creo il server...con il thread...creo il server thread con il costruttore e il metodo run che svolge le richieste datemi dal prof...

ma al server multithread che devo fare???io di esempi nn ho visti...nel codice..che devo scrivere??

AIUTATEMI VE NE PREGO...

Originally posted by papousek
guarda...io l atm....l ho studiato tutto...nn sapendo se andava fatto o meno...

per cui ti direi di leggerlo....

Originally posted by francesco2
Ne prendo un pò in giro:

Tutte domande sulle primitive, tipo:
- quali parametri della primitiva socket()devo usare per creare una socket UDP?
- cosa fa la primitiva listen(20)?


Dove si possono trovare le info riguardanti le domande di teoria?

Originally posted by boban
:?:?Ma nelle diapositive di Cassiano UDP e JAVA....quando crea l'oggetto QuoteServerThread...da dove la tira fuori questo tipo di oggetto? non esiste nelle api java....grazie
qualcuno che me lo sa spiegare??

Originally posted by papousek
guarda...io l atm....l ho studiato tutto...nn sapendo se andava fatto o meno...

per cui ti direi di leggerlo....

Originally posted by Flavia
Le slide di Cassiano dal sito reti.dico.unimi.it sono 3:
-UDP e JAVA
-Imparare il C in tre ore
-Socket programming in C with TCP

Originally posted by Flavia
Ovvero nella classe server avrai solamente una cosa del genere:
{
.....
Socket socket;
while(true) {
ServerThread t= new ServerThread(socket);
t.start();}
..}

e tutte le funzioni/operazioni le implementi nella classe

class ServerThread extends Thread

che implementerà un costruttore ServerThread e un metodo run che svolge proprio le fuznioni richieste (calcolare una somma ad esempio!).

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

class client {
public static void main (String args[]) throws Exception {
String operazione=" 2 + 5";
// è importante mettere gli spazi tra i numeri e il segno di operazione perchè poi useremo la classe Stringtokenizer
int risultato; //il risultato che riceverà dal server
String pari-dispari=" ";
Socket s=new Socket ("localhost", 1234); //1234 è la porta

//creo le variabili rispettivamente per leggere dalla socket e scrivere dalla socket
BufferedReader inFromServer = new BufferedReader (new InputStreamReader(s.getInputStream()));
DataOutputStream outToServer = new DataOutputStream (s.getOutputStream());

//la invio al server
outToServer.writeBytes(operazione);

//ricevo il risultato dal server
risultato=inFromServer.read();

//L'operatore % calcola il resto della divisione
if ((risultato % 2)= 0)
pari-dispari= "Pari";
else
pari-dispari= "Dispari";

// Invio al server nuovamente
outToServer.writeBytes(pari-dispari);

//chiudo la connessione con la serversocket
s.close();
}
}

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

class server {
public static void main (String args[]) throws Exception
ServerSocket server=new ServerSocket(4567, 300);
/* creo la serversocket dove 4567 è la porta e 300 è il # max di connessioni che può accettare contemporaneamente*/


//inizio a creare l'oggetto serverthread
while (true) {
//servizio prende la connessione effettuata sul server
Socket servizio=server.accept();
System.out.println("connessione accettata\n");
//passo i parametri al thread e successivamente lo lancio
Serverthread t = new serverthread (servizio);
t.start();
System.out.println("Thread lanciato\n");
}
}

class serverthread extends Thread {
Socket s=null;
String daClient, versoClient;

//Costruttore: semplicmente dice che la coket su cui deve andare in ascolto è quella che gli è stata passata come parametro quando il costruttore è stato invocato nel server
public Serverthread (Socket servizio) {
//metto nella socket s del thread il valore della socket servizio passata dal server
this.s=servizio;
}

public void run() {
try {
System.out.println("Thread in esecuzione\n");
//creo le variabili per leggere e scrivere dalla socket s
BufferedReader inFromClient = new BufferedReader (new InputStreamReader(s.getInputStream()));
DataOutputStream outToClient = new DataOutputStream (s.getOutputStream());

//leggo la stringa inviata dal client
daClient=inFromClient.readLine();

//Uso la classe StringTokenizer per suddividere la stringa che mi è stata inviata in 3 "token", ovvero in tre pezzi: i due addendi e il segno di operazione
StringTokenizer tokenizedLine= new StringTokenizer(daClient);
int a;
int b;
String operatore;
double risultato;
a = getInt.tokenizedLine.nextToken(); //Il primo numero è il primo token
operatore = tokenizedLine.nextToken(); //Il segno di operazione è il secondo token, cioè il secondo pezzo
b = getInt.tokenizedLine.nextToken(); // il secondo numero è il terzo token, cioè il token ancora successivo

//Non ricordo assolutamente se il metodo per trasformare una stringa in intero fosse GetInt..in ogni caso, controllatevi il metodo giusto sul sito della Sun. N.B.:la classe StringTokenizer divide una stringa in tante sottostringhe, quindi i numeri presenti in una stringa vengono considerati STRINGHE, non numeri, chiaro?

switch(operatore) // Io non so che segno di operazione abbia usato il client
case("+"):
risultato=a + b;
case("-"):
risultato=a - b;
case("*"):
risultato=a * b;
case("/"):
risultato=a / b;


outToClient.write(risultato);

//Ricevo il risultato del pari-dispari
String pari-dispari;
inFromClient.readline(pari-dispari);
System.out.println ("Il risultato è un numero +" pari-dispari);

//chiudo la connessione col client
s.close();

}
}

Originally posted by Flavia
allora, prendendo come riferimento la richeista dell'appello del 1 marzo in TCP: scrivi un client che invii una stringa con una operazione al server; il server fa partire un thread che gestirà le funzioni; la classe serverthread calcolerà il risultato dell'operazione e lo restituirà al client; il client ritornerà al server se il risultato è pari o dispari.

Ecco come ho fatto io all'esame:







Macheranno di sicuro qualche parentesi e qualcosa sarà errato perchè ho fatto tutto di fretta..comunque il senso è quello!
All'esame è anche possibile consultare la documentazione online dei metodi di Java..quindi se avreste dubbi su come convertire una stringa in intero, su come usare la classe StringTokenizer, su come funziona il DataOutputStream..non preoccupatevi..avete la documentazione (almeno all'ultimo esame era così!!!)
:-D

Originally posted by papousek
io ancora nn capisco....quando ti chiede di sviluppare il server gli mandi il txt della classe Server....quando ti chiede di sviluppare il serverthread gli mandi il txt con la classe ServerThread extends Thread e balle varie...

..ma quando ti chiede di sviluppare il multithread che gli mandi??nn vedo classi Multithread...boh...

ciau

Originally posted by urcodiaz
ma se trovo da svolgere il server multithread in UDP, devo realizzarlo utilizzando la classe Multicast? Così creo un gruppo a cui invio gli stessi pacchetti...però mi sorge un dubbio...così facendo è come se gestissi più client alla volta? Non avevamo detto che il server multithread per UDP non esisteva??

Altra domanda per le risposte in c: il primo parametro di ogni system call è "int sd" che sarebbe il descrittore della socket...ma è un numero o è il nome della socket? listen(20) vuol dire che si scegle la socket 20 della lista per essere accettata oppure indica il numero di client nella coda e quindi il baclog?

grazie a tutti!

code:

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

class engine extends Thread {

	byte incoming[];
	SocketAddress sender;
	
	public engine(byte[] b, SocketAddress s) {
		incoming = b;
		sender = s;
		}
	
	public void run() {

		//...fˆ qualcosa coi dati in incoming

		byte tbuf[] = new byte[256];

		String response = //...scrive la risposta
		tbuf = response.getBytes();
		try{
			//invia la risposta

			DatagramSocket tsock = new DatagramSocket();
			DatagramPacket tpack = new DatagramPacket(tbuf, tbuf.length, sender);
			tsock.send(tpack);
			System.out.println("pacchetto inviato");
			tsock.close();
			}catch(Exception e){}
		
		
		}
	}
public class udp_calc_multiser {

    public static void main (String args[]) {
		byte buf[] = new byte[256];
		DatagramPacket pack = new DatagramPacket(buf, buf.length);
		try{
			DatagramSocket UDPsocklistener = new DatagramSocket(4444);
			while(true){
				UDPsocklistener.receive(pack);
				new engine(pack.getData(), pack.getSocketAddress()).start();
				}
		}catch(Exception e){}
    }
}

Originally posted by Vale
scusate la domanda ma le domande su C sono a risposta multipla anche quelle o sono aperte?

Originally posted by Vale

io per l'UDP ho fatto così che ne pensate?

code:

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

public class clientUDP {
	public static void main(String args[]) throws Exception {
		String operazione,frase_server;
		DatagramSocket client;
		InetAddress indirizzo;
		DatagramPacket pacchetto_send, pacchetto_recv;
		byte[] buffer = new byte[1024];

		client = new DatagramSocket();
		System.out.println("Inserisci l'operazione (num1 op num2) dove op e' l'operatore:");
		BufferedReader from_client = new BufferedReader(new InputStreamReader(System.in));
		operazione = from_client.readLine();
		buffer = operazione.getBytes();
		indirizzo = InetAddress.getByName("localhost");
		pacchetto_send = new DatagramPacket(buffer, buffer.length, indirizzo, 7000);
		client.send(pacchetto_send);
		pacchetto_recv = new DatagramPacket(buffer, buffer.length);
		client.receive(pacchetto_recv);
		frase_server = new String(pacchetto_recv.getData());
		System.out.println("Il risultato dell'operazione e':" + frase_server);
		client.close();
	}
}

code:

public class serverUDP {
	public static void main(String args[]) throws Exception {
		ThreadUDP t;
		t = new ThreadUDP();
		t.start();
	}
}

code:

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

public class ThreadUDP extends Thread {
	DatagramSocket server;
	DatagramPacket pacchetto_send, pacchetto_recv;
	InetAddress indirizzo;
	byte[] dati_recv = new byte[1024];
	byte[] dati_send = new byte[1024];
	String operazione,op;
	StringTokenizer operazione_spezzata;
    int a,b,risultato,porta_client;

	public void run() {
		try
		{
		while(true)
		{
			server = new DatagramSocket(7000);
			pacchetto_recv = new DatagramPacket(dati_recv, dati_recv.length);
			server.receive(pacchetto_recv);
			operazione = new String(pacchetto_recv.getData());

			operazione_spezzata = new StringTokenizer(operazione);
			a = Integer.parseInt(operazione_spezzata.nextToken());
			op = operazione_spezzata.nextToken();
			b = Integer.parseInt(operazione_spezzata.nextToken());
			if (op.equals("+"))
				risultato = a + b;
			else
				if (op.equals("-"))
					risultato = a - b;
				else
					if (op.equals("/"))
						risultato = a / b;
					else
				risultato = a * b;

			dati_send = (Integer.toString(risultato)).getBytes();
			indirizzo = pacchetto_recv.getAddress();
			porta_client = pacchetto_recv.getPort();
			pacchetto_send = new DatagramPacket(dati_send, dati_send.length, indirizzo, porta_client);
			server.send(pacchetto_send);
			server.close();
		}
	}
		catch (Exception e) {}
	}
}

Originally posted by Sir Punk
guarda non cercare di capire perche non va, copia tutto come un robot rincoglionito e prega che sia abbastanza per passare questo maledetto esame inutile

Originally posted by Sir Punk
guarda non cercare di capire perche non va, copia tutto come un robot rincoglionito e prega che sia abbastanza per passare questo maledetto esame inutile

Intervento del moderatore:
si,siete decisamente OT!Tornate in topic!:)

Originally posted by ~paolo~
ciao, posto il codice di client e server UDP relativi all'esame del 1° marzo in cui veniva richiesto di controllare una stringa contenente un'operazione e visualizzando il risultato ( misono per ora fermato a qst punto senza considerare la parità)..

non riesco a capire perchè qnd lo mando in esecuzione rimane bloccato sulla stringa inserita e il server si sconnette

cleintUDP.java

code:

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

public class clientUDP {
	public static void main(String args[]) throws Exception {
		String operazione,frase_server;
		DatagramSocket client;
		InetAddress indirizzo;
		DatagramPacket pacchetto_send, pacchetto_recv;
		byte[] buffer = new byte[1024];

		client = new DatagramSocket();
		System.out.println("Inserisci l'operazione (num1 op num2) dove op e' l'operatore:");
		BufferedReader from_client = new BufferedReader(new InputStreamReader(System.in));
		operazione = from_client.readLine();
		buffer = operazione.getBytes();
		indirizzo = InetAddress.getByName("localhost");
		pacchetto_send = new DatagramPacket(buffer, buffer.length, indirizzo, 7000);
		client.send(pacchetto_send);
		pacchetto_recv = new DatagramPacket(buffer, buffer.length);
		client.receive(pacchetto_recv);
		frase_server = new String(pacchetto_recv.getData());
		System.out.println("Il risultato dell'operazione e':" + frase_server);
		client.close();
	}
}

serverUDP.java

code:

public class serverUDP {
	public static void main(String args[]) throws Exception {
		ThreadUDP t;
		t = new ThreadUDP();
		t.start();
	}
}

ThreadUDP.java

code:

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

public class ThreadUDP extends Thread {
	DatagramSocket server;
	DatagramPacket pacchetto_send, pacchetto_recv;
	InetAddress indirizzo;
	byte[] dati_recv = new byte[1024];
	byte[] dati_send = new byte[1024];
	String operazione,op;
	StringTokenizer operazione_spezzata;
    int a,b,risultato,porta_client;

	public void run() {
		try
		{
		while(true)
		{
			server = new DatagramSocket(7000);
			pacchetto_recv = new DatagramPacket(dati_recv, dati_recv.length);
			server.receive(pacchetto_recv);
			operazione = new String(pacchetto_recv.getData());

			operazione_spezzata = new StringTokenizer(operazione);
			a = Integer.parseInt(operazione_spezzata.nextToken());
			op = operazione_spezzata.nextToken();
			b = Integer.parseInt(operazione_spezzata.nextToken());
			if (op.equals("+"))
				risultato = a + b;
			else
				if (op.equals("-"))
					risultato = a - b;
				else
					if (op.equals("/"))
						risultato = a / b;
					else
				risultato = a * b;

			dati_send = (Integer.toString(risultato)).getBytes();
			indirizzo = pacchetto_recv.getAddress();
			porta_client = pacchetto_recv.getPort();
			pacchetto_send = new DatagramPacket(dati_send, dati_send.length, indirizzo, porta_client);
			server.send(pacchetto_send);
			server.close();
		}
	}
		catch (Exception e) {}
	}
}

se riuscite a capire l'errore mi fate un grosso favore :(
grazie in anticipo.
ciao ciao

Paolo

Originally posted by urcodiaz
quindi devo usare la classe engine?