[nasm] ligne de commande Résolu

Question

Bonjour :),

Je suis débutant en assembleur, j'utilise nasm sous linux.

J'ai cherché partout un exemple de code source qui me permettrait de récupérer les arguments d'un programme en ligne de commande. Je n'ai pas encore assez d'expérience pour en implémenté un moi même. Je suis conscient du fait qu'il s'agit d'un problème 'concret' que le règlement du site réprouve, mais je ne sais pas vers qui me tourner, personne ne connais l'assembleur dans mon entourage et la documentation que j'ai pu trouver ne m'a pas aidé sur ce sujet. Je sais que ça n'est pas un code court, je ne demande pas qu'on le poste ici, mais si l'un de vous a une adresse ou un conseil à me donner je suis preneur. Voilà désolé si ma question est déplacée, je m'excuse, déranger n'est pas mon souhait.

Merci.

cs_Kevin68 · Accepted Answer

Bonjour,

Des excuses s'imposent. Je suis sincèrement désolé d'avoir mis autant de temps à remercier les personnes qui m'ont aidé. Il s'est écoulé presque un mois avant que je donne signe de vie. C'est donc avec humilité que je vous présente mes plus plates excuses. Je aussi suis venu donner la solution de mon problème afin que cela profite à ceux qui, comme moi, ont débuté en assembleur et qui souhaite exploiter la ligne de commande, plus particulièrement avec nasm.

Tout d'abord, un grand merci à BruNews, patatalo et dune2 pour votre accueil et vos réponses. Concrètement, vos réponses n'ont pas pu aider le débutant que je suis ^^. J'avais besoin d'un exemple de code. directement utilisable. Je n'ai, depuis mon premier message, fait que 2 à 3 heures d'asm, mais je commence maintenant à comprendre un peu mieux.

Maintenant, je remet le code ente les mains des débutant en espérant que ça leur servira.

Le code suivant affiche les arguments envoyés par la ligne de commande dans la console. Un argument par ligne. J'ai rappelé les instructions de compilation dans le code, pour un assemblage sous linux (donc le format d'exécutable ELF). Je recommande à ce propos de mettre des instruction dans un script (qu'on nommera par exemple 'assemble.sh') cela simplifie les choses.


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; PARSE.ASM (nasm)
;
; définition:
; -----------
;
; Affiche les arguments envoyés par la ligne de commande
;
; instructions de compilation:
; ----------------------------
;
; nasm -f elf -o parse.o parse.asm
; ld -O0 -o parse parse.o
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

section .data

new_line_char:
    db    0x0A
 
section .text
    global    _start
    align    4

_start:
    mov    ebp,esp    ; store esp in ebp

again:
    add    esp,4        ; esp ---> next parameter on stack
    mov    eax,[esp]    ; move next parameter into eax
    test    eax,eax        ; eax (parameter) == NULL pointer?
    jz    end_again    ; get out of loop if yes
    call    putstring    ; output parameter to stdout.
    jmp    again        ; repeat loop

end_again:
    xor    eax,eax        ; eax = 0
    inc    eax        ; eax = 1, system call _exit ()
    xor    ebx,ebx        ; ebx = 0, normal program exit.
    int    0x80        ; execute _exit () system call

    ; prints string to stdout
putstring:
    push    ebp
    mov    ebp,esp
    mov    ecx,[ebp+8]
    xor    edx,edx

count_chars:
    mov    al,[ecx+edx]
    test    al,al
    jz    done_count_chars
    inc    edx
    jmp    count_chars

done_count_chars:
    mov    eax,4
    xor    ebx,ebx
    inc    ebx
    int    0x80
    mov    eax,4
    mov    ecx,new_line_char
    xor    edx,edx
    inc    edx
    int    0x80
    mov    esp,ebp
    pop    ebp
    ret


Ce code n'est peut-être pas parfait. Cependant, c'est à mon humble avis une base suffisante, vous devriez pouvoir vous débrouiller avec.

Pour ceux qui veullent aller plus loin, vous serez comblez par 'The Art of Assembly', une référence en la matière, disponible en anglais à l'adresse :

http://courses.ece.uiuc.edu/ece390/books/artofasm/artofasm.html

Je crois que tous ce qu'on a besoin de savoir ce trouve là, à mettre dans les favoris ^^. Plus précisément, le chapitre 13.3.12 traite de la ligne de commande et des arguments :

http://courses.ece.uiuc.edu/ece390/books/artofasm/CH13/CH13-9.html

Sur ce, je renouvelles mes excuses pour mon manque de politesse et de rapidité, et souhaite à tous les développeurs assembleur une très bonne continuation.

Kevin68

BruNews · Answer

Demande tout à fait normale, un forum est aussi là pour obtenir de l'info.
Sous Windows, je t'aurais indiqué GetCommandLine() mais je ne pratique pas Linux.

ciao...
BruNews, MVP VC++

cs_patatalo · Answer

salut,

pas assez calé non plus, regarde ça:
http://linuxgazette.net/issue84/hawk.html
@++

_dune2_ · Answer

Salut,

Lors de l'éxecution de ton binaire, dés le début la pile est constituée comme suit (chaque donnée de la pile est sur 4 octets en mode 32bits) :

[    ARGC   ] -> nb arguments

[ @ARGV0 ] -> ptr vers le 1er octet de la chaine terminée par NULL du premier argument
[ @ARGV1 ] -> ptr vers le 1er octet de la chaine terminée par NULL du second argument
.... etc autant de fois que d'argument
[  NULL     ] -> ptr NULL pour indiquer la fin des ARGV

[ @ENVP0 ] -> ptr vers la chaine terminée par NULL de la première variable d'environnement
[ @ENVP1 ] -> ptr vers la chaine terminée par NULL de la seconde variable d'environnement

... etc autant de fois que de variable d'environnement
[ NULL ] -> ptr NULL pour indiquer la fin des ENVP

ex: le 1er "pop ECX" te retournera ARGC, le suivant ARGV[0], le suivant ARGV[1] ... etc

Voilà, j'espère que cela va te permettre d'avancer ;)

Gentoo... que du bonheur ...

cs_patatalo · Answer

re,

oui, c'est juste int main(int argc,char * argv[]) c'est expliqué ici http://members.save-net.com/jko@save-net.com/asm/h_code_tut.htm

@++

[nasm] ligne de commande

5 réponses

Votre réponse

Discussions similaires