[SOLUCIONADO] Podrian indicarme si estoy usando mal recv o porque esta fallando?

tengo un problema con recv, no logro recibir la cadena de texto

estuve buscando como usar recv en asm, encontre en un blog como lo usaban en fasm, note que usaban dos veces la estructura sockaddr_in, una para bind guardaban eax y luego usaban la segunda estructura para usar accept con la longitud guaradada en bind

section .data

sockAddr    dw    AF_INET                     ; sockAddr Structure .. check API reference..
    sockAddrp    dw    ?
    sockAddrip    dd    0
    sockAddrZ    rb    8
    sockAddrSize    =    $-sockAddr                    ; Size of struct (16 bytes)
 
    remoAddr    dw    ?                        ; Another sockAddr Structure
    remoAddrp    dw    ?
    remoAddrip    dd    ?
    remoAddrZ    rb    8
    remoAddrSize    dd    ?


    invoke    bind, [hSocket], sockAddr, sockAddrSize  

    .accept_loop:
        mov    [remoAddrSize], sockAddrSize                ; Store our sockAddr structures size
        invoke    accept, [hSocket], remoAddr, remoAddrSize        ; Accept any incoming connections
        cmp    eax, -1                         ; Did we get one?
        je    .accept_loop                        ; Nah, keep trying
        mov    [hRemoteSocket], eax                    ; Yes we did, so store the new sockets handle
    .recv_loop:
        xor    eax, eax                        ; Clear eax (mov eax, 0)
        mov    dword [recvBuf], eax                    ; Zero recvBuf (otherwise it keeps thinking we have data)
        invoke    recv, [hRemoteSocket], recvBuf, 1024, 0         ; Try and recieve any data being sent
        cmp    eax, 0                            ; Did we get any?
        je    .end_recv_loop         

intente hacer lo mismo, pero no recibo nada, no se si estoy haciendo bien el uso de accept y bind, alguien sabe porque podria estar fallando?

tengo entendido que INADDR_ANY es 0x00000000, asi que en bind pongo 0x00000000 + puerto + AF_INET y en accept pongo 0x00 en todo para que acepte cualquier conexion, y recv uso buff como buff resb 50 en .bss

alguien podria indicarme si estoy haciendo algo mal y como podria usar recv?

push 0x00000000
push 0xB9220002
mov esi,esp
push byte 16
push esi
push dword[soadd]
call [binaddr]  <-- bind()

push lis
push dword [wsaddr]
call _GetProcAddress@8
mov [lisaddr], eax

push 2
push dword[soadd]
call [lisaddr] <-- listen()

push accp
push dword [wsaddr]
call _GetProcAddress@8
mov [accaddr], eax

ac_acp:
push 0x00000000
push 0x00000000
mov esi, esp
push byte 16
push dword[soadd]
call [accaddr] <--- accept()
cmp eax, -1
je ac_acp
mov [rsocket], eax <-- guardo en otro registro, no se si esto este bien pero asi lo vi en el codigo de arriba

push rec
push dword [wsaddr]
call _GetProcAddress@8
mov [recaddr], eax

loop_recv:
push 0
push 1024
push buff
push dword[rsocket]
call [recaddr]  <-- recv()
cmp eax, -1
je loop_recv

push eax
call _printf

bueno ya lo resolvi, era porque usaba buff como no inicializado en bss, lo puse en data y ya funciona, me manda el mensaje "hola mundo", pero obviamente finaliza y se cierran los dos

solo una duda, a ver que recomendacion me pueden dar, quiero hacer un while en recv y send para mandar y recibir datos y empezar a hacer cosas como el clasico abrir el cd-rom, apagar pantalla, crear archivos, etc, siento que con todo eso, lograre aprender a usar mejor ensamblador, ya que con mis tres semanas con esto hay muchas cosas que aun se me complica entender, y haciendo esto me a ayudado a practicar y aprender mas sobre asm

por el momento uso cmp y je que es como un if, pero como podria usar while para mantener activo recv y send, recuerdo que en C tenia que mandar algo con send() del cliente y regresar algo en send() con el servidor porque si intentaba mandar varias cosas con recv no se podia, la unica manera era, mandar con cliente, recibir con servidor - mandar servidor - recibir cliente

por ejemplo

cliente -> send = "abrir cd" - servidor -> recv  = "abrir cd"
sevidor -> send = "hecho" - cliente -> recv = "hecho"

de esa manera podia mandar varias cosas sin que se bloqueara send o recv, no se si tenga que hacer lo mismo en ensamblador, creo le llaman bloqueantes o semaforo en sockets

pero antes me gustaria saber como implementar while, porque cuando ejecuto en consola el server y despues en otra consola el cliente, se conecta y aparece en el server el mensaje de hola mundo

y hay un problema, cuando hago click en el server, se mantiene esperando la conexion, pero despues hago click sobre el cliente y aparece pero se cierra muy rapido, y solo me aparece en el server que se conecta pero no se manda ningun mensaje y el server se queda esperando algun dato, parece que solo funciona cuando es ejecutado en consola

entonces me imagino que tendre que hacer un loop para que se mande el mensaje y no se cierre el cliente, algo como en C con while

me podrian ayudar diciendome como lo podria hacer?

asi es como tengo recv()

loop_recv:
push 0
push 50
push buff
push dword[rsocket]
call [recaddr]  <-- recv()
cmp eax, -1
je loop_recv

y send lo tengo asi

push 0
push srelen
push sre
push dword[soadd]
call [senaddr]  <-- send()

de que forma podria implementar un while para mantener activo send y recv?

y que podria usar para que al ejecutar el server haciendo click no se cierre tan rapido, almenos que le de tiempo de mandar el mensaje antes de cerrarse?, aunque me imagino que con while ese problema se solucionaria

salu2
salu2

Hola,

Lo que te recomiendo es que trabajes cliente-servidor para empezar, donde el servidor es el que siempre está a la escucha y ejecuta las acciones enviadas por el cliente. Luego si quieres manejar respuestas ya te tocaría que justo cuando el cliente mande la petición al servidor se coloque en espera de recibir la respuesta del servidor y una vez terminada pues vuelve el servidor a escuchar y el cliente al prompt de lo que deseas enviar.

Y si todo lo puedes hacer dentro de un ciclo que valide el comando de salida.

Saludos.