Vous êtes sur la page 1sur 9

Université de Skikda Skikda, le 30/11/2008

Département d'informatique l'enseignant : BOUTINE Rachid


Module : Réseaux Informatique
Travail Pratique N°01

« La programmation réseaux sous Java network »


Les concepteurs des bibliothèques Java ont faciliter la programmation réseaux jusqu’à la rendre
similaire à des opérations de lecture ou écriture sur fichier,sauf que ce dernier se situé dans une machine
distante.
Le modèle de programmation utilise en java , encapsule la connexion réseaux (“socket”) dans un objet
stream, alors on utilise les mêmes méthodes qu’avec les autres streams. En plus , Java’s fournit des
bibliothèques dédiées pour la multi-threading qui rend possible l’établissement de plusieurs connections en
même temps.
Identification de Machines sur le réseau ?

A fin qu’une machine puisse communiquer avec une machine bien spécifique sur le réseau il est
impératif que la machine soit capable d’adresser d’une façon unique la machine réceptrice.
cependant, Java peut fonctionner sur Internet, qui nécessite un identification unique pour chaque
machine par rapport a toutes les autres à travers le monde. Ceci est accomplit par les adresses IP (Internet
Protocol) qui peuvent exister sous deux formes :
1. le DNS (Domain Name System) est un nom alphanumérique (exemple reseaux1.ifrance.com) qui engendre
après résolution une adresse IP unique .
2. alternativement , on peut utiliser la forme articulée , qui est quatre nombres séparés par des points, tel que
( 123.255.28.120).
dans les deux cas, l’adresse IP est représentée implicitement par un nombre 32-bits . Heureusement java
fournit un objet spécial pour représenter ce nombre :
 Type d’objet: InetAddress.
 Si nous connaissons le nom d’un ordinateur alors on peut récupérer sa adresse IP utilisant la méthode
static InetAddress.getByName( ) de la bibliothèque java.net.

Les outils indispensables pour programmer en java:


 Editeur de texte : pour écrire le fichier source (le nom de la classe nomClassMain.java )
 Le Compilateur de JDK : le JAVAC (nomClassMain.java  nomClassMain.class)
 L’interpréteur de JDK : le JAVA (nomClassMain.class  exécution directe)
 Ou éventuellement (JBuilder)

Mon premier programme java :


Soit le petit programme java suivant qui sert à afficher l’adresse IP d’un ordinateur a partir de son nom :

// le programme doit être appelé Quisuisje.java


// résultat l’adresse IP de votre ordinateur
import java.net.*;
public class Quisuisje {public static void main(String[] args)throws Exception {
if(args.length != 1) {
System.err.println("Usage: Quisuisje nom_de_MachineName");
System.exit(1);
}
InetAddress a = InetAddress.getByName(args[0]);
System.out.println(a);
}
}

par exemple si la machine est appelée “Univ-post1”, je tape java Quisuisje Univ-post1
je dois avoir par exemple le message suivant « Univ-post1/127.0.0.0 » (bien sure, l’adresse est différente a
chaque exécution ) si l’attribution d’adresse IP est dynamique:

peppy/199.190.87.75
If I tell my friend this address and I have a Web server running on my
computer, he can connect to it by going to the URL http://199.190.87.75
(only as long as I continue to stay connected during that session). This can

//: c15:JabberServer.java
// Very simple server that just
// echoes whatever the client sends.
import java.io.*;
import java.net.*;
public class JabberServer {
// Choose a port outside of the range 1­1024:
public static final int PORT = 8080;
public static void main(String[] args)
throws IOException {
ServerSocket s = new ServerSocket(PORT);
System.out.println("Started: " + s);
try {
// Blocks until a connection occurs:
Socket socket = s.accept();
try {
System.out.println(
"Connection accepted: "+ socket);
BufferedReader in =
new BufferedReader(
new InputStreamReader(
socket.getInputStream()));
// Output is automatically flushed
// by PrintWriter:
PrintWriter out =
new PrintWriter(
new BufferedWriter(
new OutputStreamWriter(
socket.getOutputStream())),true);
while (true) {
String str = in.readLine();
if (str.equals("END")) break;
System.out.println("Echoing: " + str);
out.println(str);
}
// Always close the two sockets...
} finally {
System.out.println("closing...");
socket.close();
}
} finally {
s.close();
}
}
} ///:~

//: c15:JabberClient.java
// Very simple client that just sends
// lines to the server and reads lines
// that the server sends.
import java.net.*;
import java.io.*;
public class JabberClient {
public static void main(String[] args)
throws IOException {
// Passing null to getByName() produces the
// special "Local Loopback" IP address, for
// testing on one machine w/o a network:
InetAddress addr =
InetAddress.getByName(null);
// Alternatively, you can use
// the address or name:
// InetAddress addr =
// InetAddress.getByName("127.0.0.1");
// InetAddress addr =
// InetAddress.getByName("localhost");
System.out.println("addr = " + addr);
Socket socket =
new Socket(addr, JabberServer.PORT);
// Guard everything in a try­finally to make
// sure that the socket is closed:
try {
System.out.println("socket = " + socket);
BufferedReader in =
new BufferedReader(
new InputStreamReader(socket.getInputStream()));
// Output is automatically flushed
// by PrintWriter:
PrintWriter out =
new PrintWriter(
new BufferedWriter(
new OutputStreamWriter(
socket.getOutputStream())),true);
for(int i = 0; i < 10; i ++) {
out.println("howdy " + i);
String str = in.readLine();
System.out.println(str);
}
out.println("END");
} finally {
System.out.println("closing...");
socket.close();
}
}
} ///:~

Enoncé N°01 : écrire un programme assembelur qui vous affiche la chaîne de caractères suivante"
BONJOUR,c'est mon premier programme"

Solution :
Title mon premier programme ; Titre
DOSSEG ; modèle de segmentation du système d'exploitation DOS
.MODEL SMALL ; petit modèle mémoire
.STACK 50 ; 50 octets pour la pile
.DATA ; segment de données
LIGNE DB "BONJOUR,c'est mon premier programme$"
.CODE ; segment de code
debut: MOV AX,@DATA ; transfère de l'adresse du segment de données
mov ds,ax ; dans le registre DS
mov ah,09h ; affichage de
mov dx,offset ligne ; la chaine de caractères ligne
int 21h ; par l'interruption 21h
mov ax,4c00h ; terminaison du programme
int 21h ; par l'interruption 21h
end debut

Enoncé N°02 : écrire un programme assembelur qui vous affiche la chaîne de caractères suivante,"tapez votre
nom SVP (max 12 caracteres):", et après la lectur en clavier de votre nom il affiche "Bon jour " suivi de votre
nom juste tapé, suivi dans la ligne suivante par la chaîne de caractère : "c'est votre programme en assembleur
qui vous parle".

Solution :

Title mon deuxieme programme ;Titre


assume cs:code,ds:data,ss:stack ; affectation des registres de segments aux
différents segments du programme.
stack segment stack ; debut segment pile
db 100h dup(0) ; 256 octets pour la pile initialisé à zéro
stack ends ; fin du sagement
data segment ; début sagement d donnée
question db 13,10,"tapez votre nom SVP (max 12 caractères):",13,10,"$" ; chaîne de caractères
phrase db "bonjour," ; chaîne de caractères
input db 13,14 dup(32) ; buffer qui reçoit le nom tapé
db "c'est votre programme en assembleur qui vous parle",13,14,"$"

data ends ; fin du sagement


code segment ;début sagement de code
begin proc near ; début d'une procedure
mov ax,data ; transfert de l'adresse de
mov ds,ax ; sagement de données en DS
mov ah,09H ; affichage de la chaine question
mov dx,offset question ; question
int 21h ;par l'interruption 21h
mov ah,0ch ; lecture en clavier
mov al,0ah ;dans le buffer
mov dx,offset input ;input
int 21h ; par l'interruption 21h
mov bl,byte ptr[input+1] ;
mov bh,0
mov word ptr[input]," "
mov byte ptr [input+2+bx],","
mov cx,12 ; repeater 12 fois
boucle : ; la phrase
mov ah,09h
mov dx,offset phrase
int 21h
loop boucle
mov ax,4c00h ; fin du programme
int 21h
begin endp
code ends
end begin

Université de Skikda Skikda, le 16/01/2006


Département d'informatique l'enseignant : BOUTINE Rachid
Module : Architecture I
Travaux Pratique N°04
Enoncé N°01
Soit le programme suivant qui fait l'addition de deux nombres entiers; lisez et comprenez bien ce
dernier.
Ensuite, tapez ce programme dans l'éditeur de texte EDIT, enregistrez le programme sous le nom
addition.asm , assemblez le fichier addition.asm pour obtenir le fichier objet addition.obj, enfin linkez le
fichier objet pour obtenir à le fin le fichier exécutable addition.exe

Title mon deuxieme programme ;titre


assume cs:code,ds:data,ss:stack ;affectation de registres pour segments de programme
;****************************segment pile**************************
stack segment stack ;début de segment de la pile
db 100h dup(0) ;réservez 256 octets pour la pile
stack ends ;fin du sagement pile
;**************************segment de données*********************
data segment ;début du segment de données
A Dw 0 ;réservez une variable double octets
B Dw 0 ;réservez une variable double octets
resultat db 10, "valeur1 + valeur2 =",10 ;réservez une variable chaîne de caractères
db " ",13,"$"
message db 10,"entrez la valeur1 ?",10 ;réservez une variable chaîne de caractères
db " ",13,"$"
message1 db 10,"entrez la valeur2 ?",10 ;réservez une variable chaîne de caractères
db " ",13,"$"
data ends ;fin du sagement de données
;**************************segment de code************************
code segment ;début du segment de code
begin : ;point d'entrée des programme
mov ax,data ;transférer l'adresse du sagement de données en AX
mov ds,ax ;transférer l'adresse du sagement de données en AX vers DS
;********************affichage de message 01*****************************
mov ah,09h ;utiliser l'interruption 21h pour l'affichage
mov dx,offset message ;d'une chaîne de caractères le code ah = 09h
int 21h ; et l'adresse du message 01 dans dx
;***********************************************************************
;* saisie du valeur numéro 01 *
;***********************************************************************
mov ah,01h ;utiliser l'interruption 21h pour la saisie sur
int 21h ;clavier d'un caractère le code ah = 01h
;et le retour en al
xor ah,ah ;ah=0
sub ax,48 ;transformer le code ascii vers la valeur décimale
mov word ptr[A],ax ;sauver la valeur de AX dans le variable [A]
suite2: ; étiquette suite2
mov ah,01h ;utiliser l'interruption 21h pour la saisie sur
int 21h ;clavier d'un caractère le code ah = 01h et le retour en al
xor ah,ah ;ah=0
cmp al,13 ;comparez la touche tapée avec la touche enter
je suit1 ;si égale fin de la saisie du valeur 01
xor ah,ah ;ah=0
sub ax,48 ;transformer le code ascii vers la valeur décimale
mov bx,ax ;sauver la valeur de AX dans BX
mov ax,word ptr[A] ;multiplier la valeur sauvegardée dans la variable A
mov cx,10 ;par 10
mul cx ;AX*CX=AX*10
add ax,bx ;ajouter le résultat avec la valeur tapée
mov word ptr[A],ax ;sauver le total dans la variable A
jmp suite2 ;allez a pour la saisie du nouveau chiffre
suit1:
;********************affichage de message 02*****************************
mov ah,09h ;utiliser l'interruption 21h pour l'affichage
mov dx,offset message1 ;d'une chaîne de caractères le code ah = 09h
int 21h ;et l'adresse du message 02 dans dx

;***********************************************************************
;* saisie du valeur numéro 02 *
;***********************************************************************
mov ah,01h ;utiliser l'interruption 21h pour la saisie sur
int 21h ;clavier d'un caractère le code ah = 01h
;et le retour en al
xor ah,ah ;ah=0
sub ax,48 ;transformer le code ascii vers la valeur décimale
mov word ptr[B],ax ;sauver la valeur de AX dans le variable [B]
suite3: ; étiquette suite3
mov ah,01h ;utiliser l'interruption 21h pour la saisie sur
int 21h clavier d'un caractère le code ah = 01h et le retour en al
xor ah,ah ;ah=0
cmp al,13 ;comparez la touche tapée avec la touche enter
je suit4 ;si égale fin de la saisie du valeur 02
xor ah,ah ;ah=0
sub ax,48 ;transformer le code ascii vers la valeur décimale
mov bx,ax ;sauver la valeur de AX dans BX
mov ax,word ptr[B] ;multiplier la valeur sauvée dans la variable B
mov cx,10 ;par 10
mul cx ;AX*CX=AX*10
add ax,bx ;ajouter le résultat avec la valeur tapée
mov word ptr[B],ax ;sauver le total dans la variable B
jmp suite3 ;allez a pour la saisie du nouveau chiffre
suit4:
;***********************affichage du message 03*******************************
mov ah,09h ;utiliser l'interruption 21h pour l'affichage
mov dx,offset resultat ;d'une chaîne de caractères le code ah = 09h
int 21h ;et l'adresse du message 02 dans dx
mov ax,word ptr[A] ;affecter la variable A dans AX
mov bx,word ptr[B] ;affecter la variable B dans BX
;****************************** Addition *************************************
add ax,bx ;AX+BX
;***********************affichage du résultat de l'addition************************
cmp ax,10000 ;comparer le résultat avec 10000
jge suit10000 ;si la valeur est supérieure a 10000
cmp ax,1000 ;comparer le résultat avec 1000
jge suit1000 ;si la valeur est supérieure a 1000
cmp ax,100 ;comparer le résultat avec 100
jge suit100 ;si la valeur est supérieure a 100
cmp ax,10 ;comparer le résultat avec 10
jge suit10 ;si la valeur est supérieure a 10
jb suit9 ;si la valeur est inférieure a 10

;**********************affichage de la position des 10000******************************


suit10000 :
mov cx,10000 ;transférer la valeur 10000 a cx
xor dx,dx ;dx=0
push ds ;empiler ds
pop es ;dépiler en es
push dx ;empiler dx
push ax ;empiler ax
div cx ;diviser la valeur trouver en AX par CX
jc depasse ;s'il y a un overflow
push ax ;empiler le quotient
mul cx ;multiplier le quotient par 10000
pop dx ;dépiler en DX
push ax ;empiler en résultat de la multiplication
;afficher le quotient
add dl,48 ;transformer la valeur décimale en code ascii
mov ah,06h ;utiliser l'interruption 21h pour l'affichage
int 21h ;d'un chiffre par le code ah = 06h
pop bx ;restaurer le quotient
pop ax ;et la valeur avant division
sub ax,bx ;reste=valeur originale - quotient*10000
;**********************affichage de la position des 1000*********************************
suit1000:
mov cx,1000 ;transférer la valeur 1000 a cx
xor dx,dx ;dx=0
push ds ;empiler ds;
pop es ;dépiler en es
push dx ;empiler dx
push ax ;empiler ax le reste dans ax
div cx ;diviser ax par 1000
jc depasse ;s'il y a un overflow
push ax ;empiler le quotient
mul cx ;multiplier le quotion par 1000
pop dx ;dépiler en DX
push ax ;empiler en résultat de la multiplication
;afficher le quotient
add dl,48 ;transformer la valeur décimale en code ascii
mov ah,06h ;utiliser l'interruption 21h pour l'affichage
int 21h ;d'un chiffre par le code ah = 06h
pop bx ;restaurer le quotient
pop ax ;et la valeur avant division
sub ax,bx ;reste=valeur originale - quotient*1000
;**********************affichage de la position des 100*********************************
suit100:
mov cl,100 ;transférer la valeur 100 a cx
xor dx,dx ;dx=0
push ds ;empiler ds
pop es ;dépiler en es
push dx ;empiler dx
push ax ;le reste dans ax
div cl ;diviser ax par 100
jc depasse ;s'il y a un overflow
push ax ;empiler le quotient
mul cl ;multiplier le quotient par 100

pop dx ;dépiler en DX
push ax ;empiler en résultat de la multiplication
;afficher le quotient
add dl,48 ;transformer la valeur décimale en code ascii
mov ah,06h ;utiliser l'interruption 21h pour l'affichage
int 21h ;d'un chiffre par le code ah = 06h
pop bx ;restaurer le quotient
pop ax ;et la valeur avant division
sub ax,bx ;reste=valeur originale - quotient*100
;**********************affichage de la position des 10*********************************
suit10:
mov cl,10 ;transférer la valeur 10 a cx
xor dx,dx ;dx=0
push ds ;empiler ds
pop es ;dépiler en es
push dx ;empiler dx
push ax ;le reste dans ax
div cl ;diviser ax par 10
jc depasse ;s'il y a un overflow
push ax ;empiler le quotient
mul cl ;multiplier le quotient par 10
pop dx ;dépiler en DX
push ax ;empiler en résultat de la multiplication
;afficher le quotient
add dl,48 ;transformer la valeur décimale en code ascii
mov ah,06h ;utiliser l'interruption 21h pour l'affichage
int 21h ;d'un chiffre par le code ah = 06h
pop bx ;restaurer le quotient
pop ax ;et la valeur avant division
sub ax,bx ;reste=valeur originale - quotient*10
;**********************affichage de la position des 1*********************************
suit9:
mov dl,al ;transférer la valeur de la position des unités dans dl
add dl,48 ;transformer la valeur décimale en code ascii
mov ah,06h ;utiliser l'interruption 21h pour l'affichage
int 21h ;d'un chiffre par le code ah = 06h
depasse:
mov ax,4c00h ;utilisant l'interruption 21h pour la terminaison
int 21h ;le code 4c00h dans ax
code ends ; fin du segment code
end begin ;fin du programme avec le point d'entrée 'begin'

Enoncé N°02 :
En se basant sur le listing ci-dessus donné , écrivez un programme assembleur qui calcule les
solutions d'une équation de deuxième degré .
A noter que le travail demandé doit être rendu avant le 28 février 2006 (un fichier assembleur sur
une disquette + le manuel technique décrivant la démarche suivie pendant le développement du programme
à partir de l'algorithme jusqu'à l'implémentation+une exposée durant les séances de TPs)

*********Bonne chance*********

Vous aimerez peut-être aussi