[assembly] syscall

[Teo@Unix]

ciao, ho una domanda semplice...

in assembly quando utilizzo le syscall per sistemare gli argomenti in molti casi vedo che devo sistemare questi nei registri, altre volte nello stack.... con push

con che criterio alcune volte nei registri altre nello stack? dipende dalla syscall?
mi chiarite un attimo le idee? :)

grazie.

[Teo@Unix]

mi pare di aver capito che se sono in user mode è necessario che io li passi nei registri, invece in kernelmode vanno passati nello stack...

quindi... io posso scrivere un listato assembly dove gli argomenti li passo nello stack?:rolleyes:

[cdimauro]

Dipende esclusivamente dal sistema operativo e dall'architettura del processore.

Ad esempio, con AmigaOS alle chiamate di sistema si passavano tutti gli argomenti nei registri del 68000 (ne aveva 16).

[Teo@Unix]

a ecco grazie!

difatti...
sto programmando su un debian... e stavo scrivendo passando gli argomenti nello stack.... li ho sempre passati nei registri... quindi deduco che il codice non funzionerà..... nè?:D

[cdimauro]

Chiaro. Se li aspetta nello stack, vedrai i fuochi d'artificio. :D

[Teo@Unix]

... :rolleyes: ... però trovo esempi dove vengono usati registri e argomenti nello stack, ad esempio questo dovrebbe utilizzare la syscall socketcall che è la numero 102.

push byte 0x0
push byte 0x1
push byte 0x2

mov eax, 0x66
mov ebx, 0x1
mov ecx, esp
int 0x80

percè ci sono quei push??

se volessi usare i registri la farei così: (perdona la sintassi :D)

movl $0x6, %edx // 3° argomento
movl $0x1, %ecx // 2° argomento
movl $0x2, %ebx // 1° argomento
mov $0x66, %al // Sistemo 102 (_NR_socketcall) in AL
int $0x80 // socket()

difatti la mia per ora mi pare che non funziona....
che mi sfugge?:confused:

[Teo@Unix]

a ok, ho capito....:doh: ........ leggersi la doc. serve a qualcosa...:fagiano:

socketcall ha la sintassi seguente:
int socketcall(int call, unsigned long *args);

quindi a seconda di call chiamo la funzione della famiglia che voglio (socket(), bind() ecc...) e gli argomenti me li metto da qualche parte e faccio riferimento ad essi con un puntatore che passo a socketcall().

... dovrebbe essere così... ora provo a riscrivermi il tutto ..... mi confermate?:stordita:

[Teo@Unix]

ok.... quindi dovrei aver risolto....

mi rimane un solo problema... la syscall dup2()... che non so perchè non ne vuole sapere di andare...:muro:

ma non vedo proprio che ci può essere di sbagliato...

questo è il pezzo di codice che mi da problemi:
[ .............]
int $0x80 // accept()

xorl %ebx, %ebx // effettuo un controllo sul risultato di accept()
cmpl %eax, %ebx
jb end
movl %eax, %ebx // Nuovo socket, sarà il 1° argomento di dup2

xorl %eax, %eax
movl %edx, %ebx // socket
movb $6, %al // Sistemo 6 (_NR_close) in AL
int $0x80 // close()

xorl %eax, %eax // Azzero EAX
xorl %ecx, %ecx // Azzero ECX, il 2° argomento di dup2 (stdin)
movb $0x3f, %al // Sistemo 63 (_NR_dup2) in AL
int $0x80 // dup2()

xorl %eax, %eax // Azzero EAX
incl %ecx // ora stdout
movb $0x3f, %al // Sistemo 63 (_NR_dup2) in AL
int $0x80 // dup2()

xorl %eax, %eax // Azzero EAX
incl %ecx // ora stderr
movb $0x3f, %al // Sistemo 63 (_NR_dup2) in AL
int $0x80 // dup2()

xorl %eax, %eax //Azzero eax
[......................]

se bypasso le chiamate a dup2 il programma funziona, altrimenti termina inspiegabilmente.... c'è qualcosa che mi impedisce di effettuare queste chiamate?

ci sto impazzendo:stordita: grazie mille!

[cdimauro]

Da quel che leggo, dup2 vuole come primo parametro il vecchio fd e come secondo il nuovo fd da utilizzare.

Nel tuo codice vedo che il primo argomento (il vecchio fd) è sempre 63, mentre il secondo (il nuovo fd) è 0, 1 e 1 rispettivamente (quest'ultimo dovrebbe essere 2 per stderr, quindi già qui ci sarebbe un errore).

Non mi suona bene. Esattamente cosa vorresti ottenere con quel pezzo di codice?

Inoltre potresti provare intanto con una sola dup2, e vedere cosa ti restituisce in uscita.

[Teo@Unix]

praticamente dovrei redirigere i canali standard di comunicazione sul socket,

dup2 è la syscall numero 63, che infatti metto in AL, non centra nulla con gli argomenti.

Poi il primo argomento è in EBX, che sarebbe il socket ritornato da accept.
E il secondo argomento sono gli fd 0, 1 ,2 stdin, stdout e stderr.

l'equivalente in C:
cli=accept(soc,0,0); //#define __NR_socketcall 102
dup2(cli,0); //#define __NR_dup2 63
dup2(cli,1);
dup2(cli,2);

ho tolto la close() per ora perchè ho visto che vi era un errore.

ho provato anche ad eliminare le ultime due dup2 ma anche la prima sembra provocare l'errore.

...... ma aspetta! ti sembra corretto il controllo del valore di ritorno di accept?

[Teo@Unix]

sembrerebbe sia la accept ora a darmi problemi...:doh:

ti posto il codice con la accept:

xorl %eax, %eax // Azzero EAX
incl %eax
pushl %eax // 1 nello stack
pushl %edx // socket
movl %esp, %ecx
movb $0x4, %bl // n° socketcall listen
movb $0x66, %al // Sistemo 102 (_NR_socketcall) in AL
int $0x80 // listen()

xorl %eax, %eax // Azzero...
xorl %ebx, %ebx
pushl %eax // 0 nello stack, 2° arg. di accept()
pushl %eax // 0 nello stack, 3° arg. di accept()
pushl %edx // socket, 1° arg.
movl %esp, %ecx // *args
movb $0x5, %bl // n° socketcall accept
movb $0x66, %al // Sistemo 102 (_NR_socketcall) in AL
int $0x80 // accept()

xorl %ebx, %ebx // effettuo un controllo sul risultato di accept()
cmpl %eax, %ebx
jb end
movl %eax, %ebx // Nuovo socket, sarà il 1° argomento di dup2

xorl %eax, %eax // Azzero EAX
xorl %ecx, %ecx // Azzero ECX, il 2° argomento di dup2 (stdin)
push $0x3f
pop %eax // Sistemo 63 (_NR_dup2) in AL
int $0x80 // dup2()

xorl %eax, %eax // Azzero EAX
incl %ecx // ora stdout
push $0x3f
pop %eax // Sistemo 63 (_NR_dup2) in AL
int $0x80 // dup2()

xorl %eax, %eax // Azzero EAX
incl %ecx // ora stderr
push $0x3f
pop %eax // Sistemo 63 (_NR_dup2) in AL
int $0x80 // dup2()

[cdimauro]

Francamente non riesco a vedere dove potrebbe essere il problema. :boh:

[Teo@Unix]

alla fine sono risalito al problema...

era il controllo del valore di ritorno di accept. Non ho capito però esattamente. Come se il salto non fosse corretto, ma non credo sia nemmeno questo perché anche se inteso come salto corto doveva funzionare... fatto sta che ora funziona con questa versione:
..............
xorl %eax, %eax // Azzero...
xorl %ebx, %ebx
pushl %eax // 0 nello stack, 2° arg. di accept()
pushl %eax // 0 nello stack, 3° arg. di accept()
pushl %edx // socket, 1° arg.
movl %esp, %ecx // Posiziono puntatore arg.
movb $0x5, %bl // n° socketcall accept
movb $0x66, %al // Sistemo 102 (_NR_socketcall) in AL
int $0x80 // interrupt accept()

movl %eax, %ebx // New socket

// int dup2(int oldfd, int newfd);

xorl %eax, %eax // Azzero EAX
xorl %ecx, %ecx // Azzero ECX, il 2° argomento di dup2 (stdin)
push $0x3f //
pop %eax // Sistemo 63 (_NR_dup2) in AL
int $0x80 // interrupt dup2()
.............
grazie. Ciao.