[LINUX] LIRE CLAVIER ET ECRIRE CONSOLE

Commentaire de sheorogath le 16/07/2006 20:34:53 administrateur CS

je suis ouvert a tout commentaire/blame/eloge/question
si vous voulez la liste des interruption linux j'ai un pdf (envoyez moi un mp avec votre mail)

je sais que le code est simple mais impossible de trouver un equivalent sur le net donc voila ^^

Commentaire de patatalo le 17/07/2006 01:30:21 administrateur CS

re,


a moins que la valeur a mettre dans edx ne soit un pointeur vers la taille mais je pense que la valeur devrait etre en dword et pas en byte à ce moment, c'est corrigé grace a l'alignement mais si tu met une autre déclaration dans le segment data, ça ne marche plus.

@++

Commentaire de sheorogath le 17/07/2006 10:20:30 administrateur CS

merci je regarde le tout merci bcp
ca va peut etre m'aider pour le probleme sur mon nouveau prog
asm :p

allez merci je regarde

++

Commentaire de necromagik le 25/07/2006 12:18:00

Salut

Pas forcément un dd, un dw peut aller.

Voilà les correspondances (je te met aussi l'équivalent en C..)

(unsigned char) - db: 1 octet - 256 valeurs
(unsigned short int) - dw: 2 octets - 65535 valeurs
(unsigned int) - dd: 4 octets - 4 milliards et quelques

Commentaire de _dune2_ le 25/07/2006 23:08:15

bonjour,
  je confirme le raisonnement de Patalo ainsi que de Necromagik.
Je souhaite juste apporter une précision au message de Necromagik :
edx est un registre 32bits. Pour cette raison, l'utilisation de "dd" pour reserver la variable semble plus adapté. Mais l'utilisation de "dw" reste possible, à la différence que c'est une reservation d'un mot 16bits et qu'il faudra utiliser l'intruction "movzx" comme le mentionnait Patalo pour 'étendre' (movzx = mov with zero extension) ta variable 16bits en 32bits dans le registre "edx" en complétant avec des zéro.

une autre solution à ton exemple pour se passer du stockage de la longueur est d'utiliser la soustraction de 2 pointeurs pour calculer la taille de celui-ci dans ton code au moment de la compilation :

; Instruction de compilation :
; NASM -f elf hello_world.asm
; ld -o hello_world hello_world.o
;segment .data ;               ; variables initialisées constantes
;   buflen: db 1024 ; taille du buffer
segment .bss
   buf:        resb    1024 ; buffer
   buflen:
; on utilisera la soustraction des 2 pointeurs buf et buflen pour calculer
; la taille de buf au moment de la compilation, ce qui évite tout risque
; de modification inattendu de buflen en mémoire
segment .text           ; équivalent de main() mais c'est pas une fonction
                        ;   global _start
_start:                 ; programme en lui même
   mov eax,3            ;syscall 3 => read
   mov ebx,0            ; 0 => lit le clavier
   mov ecx,buf          ;dans quoi on stock
   mov edx,buflen-buf   ;taille du buffer calculé à la compilation
   int 80h              ;on execute en appelant la syscall
   mov eax,4            ;syscall 4 => write
   mov ebx,1            ;1 => STDOUT
   mov ecx,buf          ; ecrire quoi ? buf
   mov edx,buflen-buf   ;taille du buffer calculé à la compilation
   int 80h              ;appel de syscall
   mov eax,1            ; 1 => exit
   mov ebx,0            ; 0 code de sortie
   int 80h              ;fin

dune2.

Commentaire de patatalo le 26/07/2006 15:49:32 administrateur CS

salut,




un dd est obligatoire dans le code de sheorogath étant donné qu'apparement, edx est un pointeur vers la taille.

si c'est la taille qui doit etre dans edx, il faut faire
mov edx,[buflen] ou comme precedement mov edx,buflen-buff avec le code donné par _DUNE2_

faudrait dejà connaitre les paramètres à passer a la fonction systeme eax=4, ensuite, faut voir...

@++

Commentaire de sheorogath le 26/07/2006 20:57:54 administrateur CS

woaw merci a tous !!!
je vais tout reprendre alors :s

merci encore
bonne soiree

Commentaire de _dune2_ le 27/07/2006 13:55:18

re :)

Aprés plusieurs essais, ... je reste perplexe :)
Je ne sais plus vraiement où se cache la vérité ....
Je m'explique :
- Code d'exemple :

monadresse: dd 0
_start:
        mov edx,monadresse
        mov edx,[monadresse]

        mov edx,monadresse
        mov edx,[edx]

        mov eax,1
        mov ebx,0
        int 80h

Et voilà le désassemblage de nasm (ndisasm -b32) :

00000083  00BA80800408      add [edx+0x8048080],bh  <- décalage de 1 byte ....
                                                       démarrage @00000084 = "mov edx,0x8048080"
00000089  8B1580800408      mov edx,[0x8048080]
0000008F  BA80800408        mov edx,0x8048080
00000094  8B12              mov edx,[edx]
00000096  B801000000        mov eax,0x1
0000009B  BB00000000        mov ebx,0x0
000000A0  CD80              int 0x80

Ce qui semble tout à fait exact.
Maintenant avec objdump :

8048084:       ba 80 80 04 08          mov    $0x8048080,%edx   <- @ de départ correct
8048089:       8b 15 80 80 04 08       mov    0x8048080,%edx
804808f:       ba 80 80 04 08          mov    $0x8048080,%edx
8048094:       8b 12                   mov    (%edx),%edx
8048096:       b8 01 00 00 00          mov    $0x1,%eax
804809b:       bb 00 00 00 00          mov    $0x0,%ebx
80480a0:       cd 80                   int    $0x80

Mais à priori une subtilité dans la notation porte à confusion, l'absence de '$' devant une adresse semble indiquer la présence d'un pointeur vers la valeur ....

Ceci explique ma confusion ... et donc confirme que l'utilisation de "mov edx,[buflen] est tout à fait correct, et j'en prend note ;)

Merci pour cette mise au point ;)