SoloCodigo

Saludos.
he estado haciendo algunas pruebas con esta syscall (read) pero tengo una duda la cual es:
como podria comprobar que no se leean mas de los bytes reservados..

read, devuelve los bytes leidos en %eax, y se podria hacer simplemente con un comprobacion simple
es justamente lo q tengo en este pequeño programa de prueba

(disculpen la suciedad del codigo, aun soy novato )

.section .data
##MENU##
   l1:   .string "1. Leer de un fichero\n"
   l1l   = . - l1

   l2:   .string "2. Sumar dos Numeros\n"
   l2l   = . - l2
########
##PEDIR OPCION##
   opcion:   .string   "Opcion: "
   oplen = . - opcion
##MENSAJES DE ERROR##
   m_no_option:   .string "Opcion invalida\n"
   m_no_option_len = . - m_no_option
########
##CONSTANTES##
   .equ STDIN, 0
   .equ STDOUT, 1
   .equ STDERR, 2
   .equ L_SYSCALL, 0x80

   .equ EXIT, 1
   .equ READ, 3
   .equ WRITE, 4
   
   .section .bss
##Buffer donde se leera la respuesta
   .equ B_SIZE, 4
   .lcomm B_DATA, B_SIZE

.section .text
##POSICIONES EN EL STACK PARA WRITE
   .equ _FD, 16
   .equ _LEN, 12
   .equ _POINT, 8
   
.globl _start
.globl _write

_start:   
      pushl $STDOUT
      pushl $l1l               #Argumentos para imprimer mensaje 1
      pushl $l1
      call _write
      addl $12, %esp
      
      pushl $STDOUT
      pushl $l2l               #Argumentos para imprimer mensaje 2
      pushl $l2
      call _write
      addl $12, %esp
      
      
      pushl $STDOUT
      pushl $oplen               #Argumentos para pedir forlmamente una opcion
      pushl $opcion
      call _write
      addl $12, %esp
         
      pushl $STDIN               #llamar a la funcion para leer
      pushl $B_SIZE
      pushl $B_DATA
      call _read
      addl $12, %esp
      
      cmpl $3, %eax               #mensaje de error si mide mas de 2 bytes
      jge error_input
      
      movl B_DATA, %ebx            #en el buffer de datos, se encuentra lo q leimos con _read
      cmpb $0x31, %bl               #0x31 representa el valor hexa en ascii para 1
      je op_1                  #si es la opcioen 1, salte   
      cmpb $0x32, %bl               #0x32 representa el valor hexa en ascii para 2
      je op_2                  #si es la opcioen 2, salta
      
      jmp error_input               #si no cumple las condiciones anteriores
                        #ir al mensaje de error de entrada
      
   end_program:
      movl $EXIT, %eax
      int $L_SYSCALL

op_1:
      jmp end_program
op_2:
      jmp end_program

_write:
      pushl %ebp
      movl %esp, %ebp
      movl _LEN(%ebp), %edx
      movl _POINT(%ebp), %ecx
      movl _FD(%ebp), %ebx
      movl $WRITE, %eax
      int $L_SYSCALL
   
      movl %ebp, %esp
      popl %ebp
      ret
   
_read:
      pushl %ebp
      movl %esp, %ebp
      movl _LEN(%ebp), %edx
      movl _POINT(%ebp), %ecx
      movl _FD(%ebp), %ebx
      movl $READ, %eax
      int $L_SYSCALL
      
      movl %ebp, %esp
      popl %ebp
      ret
error_input:
      pushl $STDOUT
      pushl $m_no_option_len
      pushl $m_no_option
      call _write
      addl $12, %esp
      jmp end_program

se puede ver claramente la comprobación, q no se pase de 2 bytes, pero.. cuando corro el programa.
ocurre un efecto gracioso , algo como:

]:~/Desktop$ ./menu
1. Leer de un fichero
2. Sumar dos Numeros
Opcion: 4000000
Opcion invalida
:~/Desktop$ 000
bash: 000: command not found
]:~/Desktop$

se ve claramente lo q sucede , alguien me podria ayudar con un consejo para q no ocurra eso
Gracias de antemano

una pequeña duda mas..
 

teniendo lo siguiente:

.data
nombre: .byte 255
.section .text
   .globl _start
_start:
   mov $255, %edx
   mov $nombre, %ecx
   mov $0, %ebx
   mov $3, %eax
   int $0x80
   
   mov (nombre),%ebx             #esto carga lo q hay en la dirección apuntada por  nombre
   mov $1, %eax
   int $0x80

el dato q se entra con stdin se supone q se guarda en nombre, no ?
al ejecutar el programa da lo siguiente:

~/Desktop$ ./stdinasm
5
~/Desktop$ echo $?
53

y con el debugger ald me muestra esto al mover el resultado a %ebx:

0804808A                      8B1D98900408         mov ebx, dword [+0x8049098]

eax = 0x00000002 ebx = 0x732E0A35 ecx = 0x08049098 edx = 0x000000FF
esp = 0xBFE89F70 ebp = 0x00000000 esi = 0x00000000 edi = 0x00000000
ds  = 0x007B es  = 0x007B fs  = 0x0000 gs  = 0x0000
ss  = 0x007B cs  = 0x0073 eip = 0x08048090 eflags = 0x00200292

Flags: AF SF IF ID

no entiendo porq me carga una direccion de memoria :S
me podrian guiar un poco en esto ?
Gracias de antemano

Saludos, este es mi primer post en este foro, y espero hacerlo bien.

la duda que tengo, es como puedo utilizar esta syscall de linux utilizando asm con sintaxis at&t
ya se q se puede hacer una llamada a scanf y todo muy facil.
simplemente quiero aprender

al hacer un man read
la sinopsis es esta:

 ssize_t read(int fd, void *buf, size_t nbytes);

pues si, fd, el descriptor, osea 0 para stdin, void *buf, supongo q sera la variable q almacenara
lo q entra por stdin, no se si estare muy perdido, la duda me llega con el ultimo argumento, size_t nbytes
se supone q es la longitud de lo q se pasa con stdin, pero como lo calculo :S
e ahi el problema y la mayor duda

intente algo como:

.data
x:  .int 0
lx = . -x
.text
   .globl _start
_start:
   movl $lx, %ebx
   movl $x, %ecx
   movl $0, %ebx
   movl $3, %eax
   int $0x80
   
salir:   movl $1, %eax
   int $0x80

si ensambla y enlaza bien. pero no da..
muchas gracias por la ayuda