Sockets TCP, Linux, C: Ejemplo servidor secuencial . Breve teoría.

00:38:12
https://www.youtube.com/watch?v=zFHjKCVwS48

الملخص

TLDREste extenso vídeo tutorial ofrece una guía paso a paso sobre la construcción de un servidor TCP secuencial utilizando sockets en el lenguaje C, ejecutándose en un sistema Linux. Se cubren aspectos teóricos y prácticos: los sockets TCP como mecanismo de comunicación entre procesos, las diferencias entre sockets stream y datagram, y el uso del protocolo TCP para garantizar la entrega de datos. La implementación se realiza con hardcoding de direcciones IP usando un entorno virtualizado, con herramientas como Wireshark para monitorear la red, y uso de llamadas al sistema como socket(), bind(), listen(), y accept() para configurar y manejar conexiones. Ideal para desarrolladores que buscan profundizar en la programación de redes en C.

الوجبات الجاهزة

  • 📡 Vantagens dos sockets TCP: garantem a entrega de dados e são orientados à conexão.
  • 🔠 Diferentes tipos de sockets: stream, datagram e raw, cada um com funcionalidades específicas.
  • 🌐 Sockets TCP se comunicam entre máquinas diferentes na Internet.
  • 💻 Implementação prática do servidor TCP em C no Linux.
  • 🏁 Hardcoding de parâmetros de servidor pode ser substituído por configurações dinâmicas.
  • 📦 Uso de ferramentas como Wireshark para monitorar o tráfego de rede.
  • 🏗 Importância das chamadas de sistema: criar socket, bind, listen, accept, connect.
  • 🛑 Implementação de backlogs para filas de clientes no servidor.
  • 📥 Uso de buffers para transmissão e recepção de dados entre cliente e servidor.
  • 🔄 Procedimento para teste e depuração do código usando máquina virtual.

الجدول الزمني

  • 00:00:00 - 00:05:00

    O vídeo fala sobre a construção de um servidor TCP sequencial, que atende clientes um de cada vez. Ele começará com uma introdução teórica sobre o que é um socket, TCP e o design do servidor, seguido pela construção do código desse servidor em C no Linux, usando IP versão 4.

  • 00:05:00 - 00:10:00

    Os sockets permitem a troca de dados entre processos em máquinas diferentes, como em um domínio Unix para processos na mesma máquina, ou domínio da internet para processos em máquinas separadas. No TCP, garante-se que os dados não se percam, diferentemente dos sockets de datagrama onde isso não é garantido.

  • 00:10:00 - 00:15:00

    Explica-se como o servidor utiliza um socket passivo para ouvir conexões, enquanto o cliente usa um socket ativo para conectar-se ao servidor. O processo do cliente envolve a criação do socket e a tentativa de se conectar ao servidor, e encerra a conexão com a chamada do sistema close.

  • 00:15:00 - 00:20:00

    O trecho detalha a implementação do servidor TCP sequencial incluindo a criação do socket, atribuição de IP e porta, estabelecimento do socket passivo com listen, e seu bloqueio com accept para esperar conexões. Quando uma conexão é aceita, permite-se operações de leitura e escrita entre cliente e servidor.

  • 00:20:00 - 00:25:00

    A parte explica a implementação do cliente em C, que se conecta ao servidor, envia uma mensagem e aguarda uma resposta. O cliente utiliza a chamada de sistema connect e troca dados com read/write antes de fechar o socket. Em caso de erro, ele terminará o programa após exibir a falha.

  • 00:25:00 - 00:30:00

    Descreve-se a configuração do ambiente de teste, incluindo instalação de Ubuntu em uma virtual box, definição de IP estático e rede bridge para comunicação direta. Inclui explicações sobre o código servidor em C e suas estruturas usadas para definir parâmetros, endereço IP e número de porta.

  • 00:30:00 - 00:38:12

    A demonstração inclui o uso do Wireshark para monitorar tráfego entre servidor e cliente, filtrando pacotes por IP fonte e destino. Após execução, visualizam-se pacotes enviados e recebidos, mostrando a comunicação texto entre cliente e servidor. Código será disponibilizado no GitHub para referência.

اعرض المزيد

الخريطة الذهنية

فيديو أسئلة وأجوبة

  • O que é um servidor TCP sequencial?

    É um servidor que atende um cliente por vez, aguardando a conclusão de cada um para atender o próximo.

  • Quais são os tipos de sockets mencionados no vídeo?

    Tipos de sockets incluem stream (TCP), datagram (UDP) e raw (para protocolos personalizados).

  • Por que o tutorial utiliza C e Linux para implementação?

    C é uma linguagem de baixo nível com controle direto sobre as chamadas de sistema, e o Linux oferece um sistema robusto para programação de sockets.

  • Qual ferramenta foi mencionada para monitorar o tráfego de rede?

    Wireshark foi a ferramenta mencionada para fazer sniffing do tráfego de rede.

  • Como é garantida a entrega de dados nos sockets TCP?

    A entrega de dados é garantida através do protocolo TCP, que é orientado à conexão e assegura que os dados sejam recebidos na ordem correta.

عرض المزيد من ملخصات الفيديو

احصل على وصول فوري إلى ملخصات فيديو YouTube المجانية المدعومة بالذكاء الاصطناعي!
الترجمات
es
التمرير التلقائي:
  • 00:00:00
    este vídeo tratará sobre sockets tcp y
  • 00:00:03
    en concreto se va a ver cómo se
  • 00:00:05
    construye un servidor tcp secuencial con
  • 00:00:09
    esto de secuencial se quiere decir que
  • 00:00:12
    el servidor atiende en primer lugar a un
  • 00:00:14
    cliente y una vez ha terminado con este
  • 00:00:17
    entonces atiende al siguiente cliente
  • 00:00:20
    en el vídeo se va a ver por un lado una
  • 00:00:23
    breve introducción teórica de que es un
  • 00:00:25
    socket que es tcp diseño de servidor que
  • 00:00:29
    hay y en segundo lugar se verá cómo se
  • 00:00:33
    construye el código para este servidor
  • 00:00:35
    de cepes secuencial y se hará en ce bajo
  • 00:00:39
    linux y para la dirección para la
  • 00:00:43
    versión 4 de la dirección ip
  • 00:00:47
    los sockets son un mecanismo de
  • 00:00:50
    comunicación entre procesos es decir los
  • 00:00:53
    sockets permiten que los procesos
  • 00:00:56
    intercambien datos entre ellos otro
  • 00:01:00
    ejemplo de mecanismo de comunicación
  • 00:01:01
    podría ser una cola de mensajes un
  • 00:01:03
    message o un pipe una tubería
  • 00:01:08
    en el caso de los sockets tcp las
  • 00:01:11
    aplicaciones que intercambian datos
  • 00:01:13
    están en dos máquinas diferentes
  • 00:01:16
    separadas por la red por internet
  • 00:01:18
    entonces desde el punto de vista de
  • 00:01:21
    dónde están esos procesos que
  • 00:01:23
    intercambian datos se definen dos
  • 00:01:26
    dominios se llaman dominios de perdón de
  • 00:01:29
    comunicación por un lado está el dominio
  • 00:01:31
    unics en el cual las aplicaciones están
  • 00:01:34
    corriendo dentro de la misma máquina y
  • 00:01:36
    está el dominio de internet donde las
  • 00:01:40
    aplicaciones que se están intercambiando
  • 00:01:42
    datos corren en máquinas que están
  • 00:01:45
    conectadas a través de la red en el caso
  • 00:01:47
    de sockets tcp
  • 00:01:51
    este es el dominio en el que están
  • 00:01:54
    nuestras máquinas en el internet en
  • 00:01:57
    función de cómo se realice la entrega de
  • 00:01:59
    datos podemos definir varios tipos de
  • 00:02:01
    sockets en primer lugar en los streams
  • 00:02:04
    sockets y con esto de stream se quiere
  • 00:02:07
    decir flujo o corriente de datos en
  • 00:02:10
    segundo lugar estaría los data ground
  • 00:02:13
    sockets los data gramas y en tercer
  • 00:02:15
    lugar y no lo escrito aquí estarían los
  • 00:02:18
    rockets o sockets crudos para definir tu
  • 00:02:20
    propio protocolo de transporte en primer
  • 00:02:23
    lugar los streams la recepción de los
  • 00:02:27
    datos está aquí garantizada no se
  • 00:02:30
    pierden pero no hay concepto de mensaje
  • 00:02:34
    y con esto para entenderlo se puede
  • 00:02:37
    comparar con un pipe en un país un
  • 00:02:40
    proceso va escribiendo bytes no mensajes
  • 00:02:42
    sino va escribiendo bytes y conforme lo
  • 00:02:44
    va haciendo el proceso que va leyendo de
  • 00:02:46
    ese país pues va leyendo esos bytes pero
  • 00:02:50
    no hay una frontera entre el mensaje 1
  • 00:02:52
    entre el mensaje 2
  • 00:02:54
    también
  • 00:02:56
    se definen como orientados a conexión y
  • 00:02:59
    en el caso de que estemos en el dominio
  • 00:03:01
    de internet es decir en el caso de que
  • 00:03:04
    las aplicaciones que están utilizando
  • 00:03:06
    sockets para comunicarse estén en
  • 00:03:08
    máquinas separadas conectadas por
  • 00:03:11
    internet los vamos a llamar sockets tcp
  • 00:03:15
    aquí te
  • 00:03:16
    c
  • 00:03:19
    en el caso de los data gr más así que
  • 00:03:23
    hay concepto de mensaje y estos mensajes
  • 00:03:25
    se llaman data gramas
  • 00:03:28
    la transmisión de datos en este caso no
  • 00:03:30
    está garantizada pueden llegar pueden no
  • 00:03:33
    llegar pueden llegar duplicados y si
  • 00:03:36
    estamos en el dominio de internet los
  • 00:03:38
    vamos a llamar vp
  • 00:03:42
    bien
  • 00:03:44
    bueno el ejemplo que veremos
  • 00:03:47
    será sobre sockets tcp en este caso el
  • 00:03:51
    tercer caso que he comentado se escribe
  • 00:03:53
    así r o w
  • 00:03:56
    nada que ver con este sería el tercer
  • 00:03:58
    caso que son los sockets crudos
  • 00:04:04
    bueno volviendo al título principal del
  • 00:04:06
    vídeo sockets tcp por socket vamos
  • 00:04:08
    entender mecanismo de comunicación y
  • 00:04:11
    cuando se habla de tcp vamos a entender
  • 00:04:13
    que las aplicaciones que se están
  • 00:04:15
    intercambiando datos corren en máquinas
  • 00:04:18
    diferentes que están conectadas por la
  • 00:04:20
    red y utilizan como protocolo tcp bien
  • 00:04:25
    por esto por usar tcp la entrega de
  • 00:04:29
    datos va a estar garantizada
  • 00:04:32
    en función de cómo se comporte el socket
  • 00:04:35
    a la hora de
  • 00:04:37
    y establecer una conexión se definirá
  • 00:04:39
    como pasivo o activo
  • 00:04:43
    en el caso de un servidor se utilizará
  • 00:04:46
    un socket pasivo que estará escuchando y
  • 00:04:49
    manteniéndose a la espera de que un
  • 00:04:52
    socket activo un cliente trate de
  • 00:04:54
    conectarse a él
  • 00:04:56
    el cliente utilizará un socket activo
  • 00:05:00
    que tratará activamente de conectarse a
  • 00:05:03
    un servidor
  • 00:05:08
    para implementar tanto el servidor como
  • 00:05:10
    el cliente debemos utilizar una serie de
  • 00:05:13
    llamadas al sistema para poder trabajar
  • 00:05:15
    con los sockets en el caso del servidor
  • 00:05:19
    en primer lugar vamos a crear el socket
  • 00:05:23
    y con ello para ello se usa la llamada
  • 00:05:27
    al sistema socket está llamada el
  • 00:05:30
    sistema tiene una serie de argumentos de
  • 00:05:31
    entrada que luego vamos a ver
  • 00:05:36
    una vez creado ese socket se le asigna
  • 00:05:39
    una dirección ip y un número de puerto
  • 00:05:43
    esto se hace con la llamada al sistema
  • 00:05:46
    20
  • 00:05:48
    después vamos a marcar es eso que está
  • 00:05:51
    creado que ya tiene ip y número de
  • 00:05:53
    puerto asociado como socket pasivo y
  • 00:05:57
    para ello se usa la llamada al sistema
  • 00:05:59
    listen también tiene argumentos de
  • 00:06:02
    entrada que luego los vemos bien
  • 00:06:07
    con la llamada al sistema accept aceptar
  • 00:06:10
    el él
  • 00:06:16
    el servidor va a estar esperando aquí
  • 00:06:19
    hasta que un cliente trate de conectarse
  • 00:06:25
    esto es por el lado del servidor
  • 00:06:27
    entonces por el lado de del cliente el
  • 00:06:31
    proceso cliente
  • 00:06:33
    tiene que crear primero el socket
  • 00:06:35
    también con la llamada al sistema
  • 00:06:36
    sockets con sus argumentos
  • 00:06:39
    una vez creado vamos a llamar a connect
  • 00:06:44
    para que conecte eso para que trate de
  • 00:06:47
    conectar ese socket creado a una
  • 00:06:49
    dirección ip en concreto que será la
  • 00:06:53
    dirección ip del servidor bien cuando el
  • 00:06:56
    servidor vea
  • 00:06:58
    que hay una petición entrante de
  • 00:07:02
    conexión de un cliente si puede es decir
  • 00:07:06
    si no está ahora mismo teniendo otro
  • 00:07:08
    cliente porque el servidor que vamos a
  • 00:07:11
    diseñar es secuencial primero un cliente
  • 00:07:13
    el otro cliente bueno en caso de que
  • 00:07:15
    pueda aceptar esa petición
  • 00:07:19
    y llamar al sistema accept del servidor
  • 00:07:22
    se desbloqueará y nos va a devolver un
  • 00:07:24
    file de escritor un descriptor de
  • 00:07:27
    archivo con el que podremos realizar
  • 00:07:30
    operaciones de escritura y lectura es
  • 00:07:33
    decir
  • 00:07:35
    el cliente y el servidor podrán
  • 00:07:38
    intercambiarse ya los datos por la parte
  • 00:07:40
    del proceso cliente también usaría ready
  • 00:07:43
    right para escribir y leer datos lo que
  • 00:07:45
    sea necesario una vez se haya terminado
  • 00:07:49
    de este intercambio de datos cerraremos
  • 00:07:53
    los descriptores de archivo
  • 00:07:56
    correspondientes con la llamada al
  • 00:07:57
    sistema close por la parte del servidor
  • 00:07:59
    y por la parte del cliente bueno antes
  • 00:08:02
    de pasar a ver directamente el código
  • 00:08:04
    fuente veamos una idea general de lo que
  • 00:08:07
    se quiere hacer aquí vamos a construir
  • 00:08:10
    un programa servidor y lo vamos a
  • 00:08:13
    instalar en esta máquina
  • 00:08:15
    en este computador tengo windows
  • 00:08:18
    instalado de manera nativa en la versión
  • 00:08:20
    10 y sobre el mismo una máquina virtual
  • 00:08:22
    virtual box que tiene a su vez instalado
  • 00:08:26
    ubuntu vale además voy a utilizar el
  • 00:08:29
    programa white hart que está instalado
  • 00:08:31
    en windows para que veamos el tráfico de
  • 00:08:33
    red para hacer sniffing bien el programa
  • 00:08:37
    servidor correrá aquí sobre ubuntu y en
  • 00:08:42
    esta máquina y definida una ip estática
  • 00:08:45
    que es ésta vale es decir para que el
  • 00:08:48
    cliente se conecta al servidor tendrá
  • 00:08:51
    que llamar a ésta tendrá que conectarse
  • 00:08:53
    a esta ip y el puerto que utilice el
  • 00:08:57
    servidor es el 8 1080 vale por otro lado
  • 00:09:00
    y para testear que el servidor realmente
  • 00:09:03
    funciona vamos a construir un cliente de
  • 00:09:05
    prueba por lo tanto el servidor
  • 00:09:06
    comerciantes son de prueba porque hacen
  • 00:09:08
    cosas muy sencillas bien entonces para
  • 00:09:10
    el cliente voy a utilizar una
  • 00:09:12
    computadora en la que tenía instalado
  • 00:09:13
    ubuntu una versión bastante antigua pero
  • 00:09:15
    todavía funciona bastante bien y aquí
  • 00:09:18
    están a mi cliente de test y este bueno
  • 00:09:21
    pues tiene la una ip dinámica que es
  • 00:09:25
    asignada por el router bien es el mis
  • 00:09:27
    router wi-fi y éste es mi red de área
  • 00:09:30
    local
  • 00:09:32
    es decir las dos máquinas esta y estas
  • 00:09:35
    se encuentran en esta red bueno tengo
  • 00:09:38
    aquí el código de
  • 00:09:42
    del servidor secuencial en c
  • 00:09:46
    respecto a los incluidos que necesitamos
  • 00:09:49
    el de los símbolos standard
  • 00:09:53
    esto sin clubes para los sockets y estos
  • 00:09:57
    porque voy a realizar printemps para que
  • 00:10:00
    en la consola se nos indique tanto que
  • 00:10:02
    ha habido éxito que algo funciona como
  • 00:10:04
    para indicar errores que incluyes
  • 00:10:08
    necesitamos
  • 00:10:10
    en esto nos puede ayudar la página del
  • 00:10:14
    manual de linux por ejemplo si voy a
  • 00:10:17
    utilizar la llamada al sistema socket
  • 00:10:20
    busco aquí en este campo de búsqueda
  • 00:10:25
    me dirán necesitas éstos incluyen
  • 00:10:28
    entonces voy y los copio así con todo si
  • 00:10:32
    no pongo los suficientes no compilará ya
  • 00:10:34
    está
  • 00:10:36
    bueno el siguiente paso es definir de
  • 00:10:40
    alguna manera los parámetros del
  • 00:10:41
    servidor yo lo he hecho de manera
  • 00:10:43
    llamada hard code y jordi es decir los
  • 00:10:46
    codificados de manera que son constantes
  • 00:10:50
    no se pueden modificar hay otras maneras
  • 00:10:53
    de hacerlo también he elegido el puerto
  • 00:10:56
    del servidor el 8080 no para más
  • 00:11:01
    información
  • 00:11:03
    la wikipedia por ejemplo el puerto 8080
  • 00:11:07
    se conoce por ser un alternativo para
  • 00:11:10
    usar el http vale y hay otras
  • 00:11:14
    aplicaciones que también lo usan yo
  • 00:11:18
    simplemente lo he utilizado para mi
  • 00:11:20
    servidor de prueba lo siguiente hay que
  • 00:11:23
    definir la dirección ip de mi servidor
  • 00:11:29
    entonces yo he elegido esta que es la he
  • 00:11:31
    configurado de manera estática en mi
  • 00:11:33
    máquina como he dicho antes este
  • 00:11:35
    servidor va a funcionar va a dar soporte
  • 00:11:37
    solamente a la versión 4 de la ip ipv4
  • 00:11:42
    para ipv6 habría que realizar
  • 00:11:44
    modificaciones aquí
  • 00:11:46
    respecto a esta ip bien si estás en
  • 00:11:48
    ubuntu como yo y estás en una máquina
  • 00:11:51
    virtual también bien estoy utilizando
  • 00:11:53
    esta conexión de aquí la n 0 s 9 le doy
  • 00:11:58
    a settings
  • 00:12:00
    ipv4 y la he configurado de manera
  • 00:12:03
    manual para que no para que no cambie
  • 00:12:06
    así el cliente sabe a quien tiene que
  • 00:12:09
    conectarse bueno aquí está y aquí está
  • 00:12:12
    la máscara de red correspondiente que
  • 00:12:15
    también es pues la máscara de mi red
  • 00:12:18
    bien estoy en una máquina virtual
  • 00:12:21
    entonces
  • 00:12:24
    voy a ir a los settings
  • 00:12:26
    aquí en los settings de vm virtualbox me
  • 00:12:31
    voy
  • 00:12:33
    settings network y el adaptador 3 el 1 y
  • 00:12:37
    el 2 los he definido para otras cosas y
  • 00:12:40
    el 3 es el que voy a utilizar ahora es
  • 00:12:42
    de tipo bridge adapter
  • 00:12:45
    es decir que voy de alguna manera a
  • 00:12:47
    puentear la tarjeta de red y voy a
  • 00:12:51
    enviar y recibir datos directamente a
  • 00:12:53
    través de ella
  • 00:12:54
    defino el tamaño de búfer 100 el tamaño
  • 00:12:58
    de búfer para la red para leer datos
  • 00:12:59
    como para enviar datos y el backlog
  • 00:13:03
    luego veremos un poco mejor en qué
  • 00:13:05
    llamada sistema se utiliza le doy el
  • 00:13:07
    valor a 5 el backlog es el número máximo
  • 00:13:10
    de clientes que pueden estar esperando a
  • 00:13:13
    conectarse al servidor como es
  • 00:13:16
    secuencial solo sirve un cliente está
  • 00:13:19
    atendido y cuando éste termine de ser
  • 00:13:21
    atendido
  • 00:13:22
    el cliente que esté esperando en la cola
  • 00:13:25
    siguiente será atendido en ese momento
  • 00:13:28
    con un número máximo de clientes que
  • 00:13:29
    pueden esperar
  • 00:13:30
    ese es el backlog bien ahora paso a
  • 00:13:33
    definir el main ahora mismo estos
  • 00:13:35
    argumentos de entrada no los voy a
  • 00:13:37
    utilizar
  • 00:13:39
    podría por ejemplo definir como
  • 00:13:40
    argumento de entrada el número de
  • 00:13:42
    puertos en lugar de hacer un hard coding
  • 00:13:45
    y meterlo como parámetro ahora cuando
  • 00:13:50
    ejecuta el programa parámetro de entrada
  • 00:13:52
    quiero decir vale defino dos variables
  • 00:13:55
    de tipo entero que van a ser los
  • 00:13:57
    descriptores del archivo uno va a ser el
  • 00:14:01
    escritor de archivo del socket
  • 00:14:05
    que está escuchando para recibir
  • 00:14:07
    conexiones de clientes y otro descriptor
  • 00:14:12
    de archivo que va a ser de ese socket
  • 00:14:13
    que se crea cuando un cliente ya se
  • 00:14:17
    conecta con ese país descriptor podremos
  • 00:14:20
    leer y escribir datos al cliente bueno
  • 00:14:25
    una variable de tipo un sign de entero
  • 00:14:28
    sin signo llamada ley que va a ser la
  • 00:14:31
    longitud de la dirección del cliente
  • 00:14:34
    bien y 2
  • 00:14:39
    dos variables de este tipo es una
  • 00:14:41
    estructura llamadas así de esta manera
  • 00:14:43
    una para el servidor y otra por el
  • 00:14:46
    cliente ahora vemos que es la copio i
  • 00:14:51
    lo meto en el manual de linux
  • 00:14:56
    y busco en esta estructura se nos define
  • 00:15:00
    el formato de la dirección es una
  • 00:15:04
    estructura que contiene varios campos y
  • 00:15:06
    en el que definimos de qué familia es
  • 00:15:09
    ese socket es a efe y net se definan si
  • 00:15:13
    es un tcp socket es un tcp implica
  • 00:15:15
    internet y lo definimos así luego otro
  • 00:15:19
    campo que define el puerto y otro que
  • 00:15:22
    define la dirección este formato es para
  • 00:15:25
    ip address es para direcciones ip
  • 00:15:28
    versión 4 para versión 6 utilizaríamos
  • 00:15:31
    otra cosa
  • 00:15:33
    bien para el servidor y para el cliente
  • 00:15:37
    bueno necesito dos variables de tipo
  • 00:15:39
    entero una para la longitud recibida y
  • 00:15:42
    otra para longitud transmitida das
  • 00:15:44
    inicial hizo con el valor cero y ahora
  • 00:15:47
    dos woofers uno para transmisión y otro
  • 00:15:50
    para recepción el de transmisión es
  • 00:15:52
    decir los datos que el servidor envía al
  • 00:15:55
    cliente
  • 00:15:55
    bueno pues les voy a definir este este
  • 00:15:59
    string que sí que diga hola cliente soy
  • 00:16:01
    el servidor este es el mensaje o los
  • 00:16:03
    datos que el servidor va a transmitir al
  • 00:16:05
    cliente y en recepción en este búfer se
  • 00:16:10
    cargarán los los bytes que yo leo que me
  • 00:16:13
    está enviando el cliente bueno en primer
  • 00:16:16
    lugar
  • 00:16:18
    y si volvemos a
  • 00:16:21
    al diagrama del principio el servidor
  • 00:16:25
    tiene que crear un socket y lo hace con
  • 00:16:27
    esta llamada al sistema socket bien
  • 00:16:30
    vuelve a la máquina virtual
  • 00:16:32
    ok esta es la llamada al sistema el
  • 00:16:36
    primer argumento
  • 00:16:39
    es el dominio es internet es un socket
  • 00:16:44
    tcp el segundo argumento es el tipo de
  • 00:16:50
    socket
  • 00:16:51
    recordemos que teníamos los streams
  • 00:16:53
    sockets y los data gran sockets y el tcp
  • 00:16:56
    corresponde a socket stream y el tercero
  • 00:16:58
    argumento tiene que ver con el protocolo
  • 00:17:00
    especificado aquí vamos a usar tcp y
  • 00:17:02
    pongo un cero no sea quiero decir con él
  • 00:17:06
    con el socket de tipo tcp se utiliza el
  • 00:17:09
    protocolo tcp entonces aquí no
  • 00:17:11
    especificamos nada
  • 00:17:13
    bien entonces esto nos va a crear un
  • 00:17:17
    zoquete el primer socket y nos devuelve
  • 00:17:18
    este file d escriptors si ha habido un
  • 00:17:20
    error en la llamada al sistema de volver
  • 00:17:22
    a -1 no sé
  • 00:17:25
    imprimirá cuál es el error y nos
  • 00:17:28
    devuelve un -1 el corto a la línea al
  • 00:17:31
    final voy a dejar todo el código en
  • 00:17:33
    github y abajo en la dirección
  • 00:17:36
    la url
  • 00:17:38
    bueno y si ha habido éxitos y esteso que
  • 00:17:41
    de fede tiene un valor válido entonces
  • 00:17:43
    nos dirá el socket se ha creado con
  • 00:17:45
    éxito bueno en siguiente en siguiente
  • 00:17:47
    lugar vamos a crear esa estructura ese
  • 00:17:50
    address format que hemos visto y lo
  • 00:17:53
    vamos a inicializar con ceros para eso
  • 00:17:55
    utilizo mem set que inicializa con ceros
  • 00:17:58
    pues cada uno de los bytes de esta
  • 00:18:01
    estructura del the address format para
  • 00:18:04
    el servidor 1 está inicializa a todo
  • 00:18:07
    clear vamos a asignarle vamos a definir
  • 00:18:10
    sus campos la familia
  • 00:18:13
    del sockets dominio internet o sea sera
  • 00:18:16
    efe
  • 00:18:21
    la dirección y p
  • 00:18:24
    es esa que hemos definido arriba 192
  • 00:18:28
    puntos 68 puntos 0.1
  • 00:18:34
    convierte este string porque estos son
  • 00:18:38
    string
  • 00:18:40
    en el formato
  • 00:18:44
    necesario
  • 00:18:47
    y por último el campo del puerto del
  • 00:18:49
    servidor que es este que hemos definido
  • 00:18:51
    de manera constante y utilizo la función
  • 00:18:55
    h tns que lo que hace es convertir este
  • 00:19:02
    valor en él
  • 00:19:04
    o sea que lo que hace es que esté este
  • 00:19:07
    valor tenga la ordenación de bytes que
  • 00:19:09
    debe tener en la red
  • 00:19:11
    es decir la ordenación de cómo se
  • 00:19:14
    guardan los bytes en memoria depende de
  • 00:19:15
    la arquitectura de cada computador y
  • 00:19:19
    y hay que enviarlos en una en un formato
  • 00:19:23
    determinado por la red para que máquinas
  • 00:19:25
    de arquitecturas diferentes se
  • 00:19:26
    comprendan de ahí que utilizamos esta
  • 00:19:29
    función h toms bien ya tenemos nuestra
  • 00:19:32
    estructura con los campos con los
  • 00:19:34
    valores de configuración de nuestros
  • 00:19:37
    servidores cargados y ahora y ahora lo
  • 00:19:40
    que vamos a hacer es asignar el el
  • 00:19:43
    sockets a
  • 00:19:47
    una dirección ip y un puerto es el
  • 00:19:51
    número de puertos le llaman al sistema
  • 00:19:53
    20
  • 00:19:55
    el primer argumento el file descriptor
  • 00:19:57
    de socket que es el que nos ha devuelto
  • 00:19:59
    la llamada sistema socket que es la que
  • 00:20:02
    ha creado el socket el siguiente
  • 00:20:05
    argumento es un puntero a esta
  • 00:20:09
    estructura que hemos definido con los
  • 00:20:11
    campos del servidor y el último
  • 00:20:13
    argumento es el tamaño en bytes de esa
  • 00:20:16
    estructura
  • 00:20:17
    entonces si 20 nos devuelve un número
  • 00:20:20
    mayor a 0 significa que hemos podido
  • 00:20:22
    asociar asignar a ese socket una
  • 00:20:25
    dirección ip y un puerto si hay un error
  • 00:20:29
    bueno nos indicará en pantalla cuál es
  • 00:20:32
    el error y si todo va bien nos dirá
  • 00:20:35
    tuviste éxito
  • 00:20:38
    ahora vamos con la llamada al sistema
  • 00:20:39
    listen que es la que hace que es eso que
  • 00:20:43
    hemos creado al principio se vuelva
  • 00:20:45
    pasivo pasivo que es decir que esté
  • 00:20:48
    escuchando pendiente de si hay
  • 00:20:49
    peticiones entrantes de clientes que
  • 00:20:51
    quieren conectarse a nuestro servidor el
  • 00:20:53
    primer argumento el file de escritor del
  • 00:20:55
    socket y segundo el el backlog que es el
  • 00:20:57
    número máximo de conexiones pendientes
  • 00:21:00
    que puede haber haciendo cola esperando
  • 00:21:02
    que las atendamos buenos y listen
  • 00:21:05
    devuelve un valor diferente de 0 imprime
  • 00:21:08
    un error en pantalla y si no hemos
  • 00:21:11
    tenido éxito
  • 00:21:13
    bueno antes de entrar a el look que nos
  • 00:21:15
    va a ir aceptando los clientes
  • 00:21:16
    sucesivamente
  • 00:21:19
    cargo en esta variable el en el tamaño
  • 00:21:22
    en bytes de esa estructura para el agro
  • 00:21:26
    es formato del del cliente esto
  • 00:21:28
    simplemente el tamaño vale entonces wild
  • 00:21:31
    truck mientras para siempre va aceptando
  • 00:21:34
    data de los sockets que va entrando y
  • 00:21:37
    vamos a ver el diagrama otra vez
  • 00:21:40
    hoy
  • 00:21:42
    aquí
  • 00:21:44
    vale ahora estamos aquí hemos hecho
  • 00:21:46
    hemos creado el socket lo hemos asignado
  • 00:21:48
    una ip hemos marcado como pasivo y ahora
  • 00:21:51
    vamos a quedarnos en accept esta llamada
  • 00:21:54
    al sistema va a permitir que los
  • 00:21:56
    clientes se conecte un cliente se
  • 00:21:58
    conecte y va a bloquear se va a esperar
  • 00:22:00
    ahí hasta que pues es un cliente tarde
  • 00:22:02
    trate de conectarse bien y cuando ese
  • 00:22:05
    cliente se conecte se creará un nuevo
  • 00:22:07
    socket ya bueno esta es la llamada al
  • 00:22:10
    sistema accept a la que le metemos
  • 00:22:12
    primer argumento el descriptor de
  • 00:22:14
    archivo de ese socket pasivo segundo
  • 00:22:17
    argumento es un puntero a esas
  • 00:22:20
    estructuras o padres que hemos declarado
  • 00:22:24
    al principio para el cliente y entonces
  • 00:22:27
    cuando la función cuando la llama del
  • 00:22:29
    sistema accept retorne en esta
  • 00:22:33
    estructura se nos cargarán los valores
  • 00:22:35
    de dirección ip puerto y dominio del
  • 00:22:39
    cliente que se ha conectado vale y por
  • 00:22:42
    último un puntero la variable leen que
  • 00:22:45
    aquí la habíamos inicial izado con el
  • 00:22:48
    tamaño
  • 00:22:49
    esa estructura son padres para el
  • 00:22:52
    cliente y bueno es un argumento de
  • 00:22:54
    entrada/salida que a la entrada le damos
  • 00:22:56
    que ese valor cuando llamamos accept y
  • 00:22:58
    cuando accept retorne aquí se nos
  • 00:23:00
    devolverá el tamaño de la dirección del
  • 00:23:03
    socket cliente
  • 00:23:06
    bien acepta
  • 00:23:10
    se bloqueará aquí el programa y nos
  • 00:23:12
    devolverá un file descriptor
  • 00:23:17
    de un nuevo socket ese socket que
  • 00:23:20
    permite la conexión al al cliente y que
  • 00:23:23
    a través de ese file descriptor
  • 00:23:24
    escribiremos y leeremos ya datos al
  • 00:23:26
    entonces y ese fue el descriptor es
  • 00:23:28
    válido bueno si es menor que cero si es
  • 00:23:31
    inválido imprimes un error en pantalla y
  • 00:23:34
    terminas
  • 00:23:38
    y si es válido en un bucle vamos a leer
  • 00:23:42
    datos del cliente hasta que este cierre
  • 00:23:44
    entonces lo primero que va a hacer el
  • 00:23:46
    servidor es leer si hay datos del
  • 00:23:50
    cliente vale para eso utilizo en la
  • 00:23:53
    función red y el primer argumento de red
  • 00:23:55
    será este file descriptor de este
  • 00:23:59
    de este shock que acabamos de crear con
  • 00:24:01
    el haccp el segundo el buffer de
  • 00:24:04
    recepción donde se van a cargar los
  • 00:24:06
    datos leídos y el tercero bueno el
  • 00:24:08
    tamaño de este buffer para que como
  • 00:24:11
    máximo se serían esos datos
  • 00:24:14
    si la longitud recibida es menos 1 ha
  • 00:24:16
    habido un error imprime los y la
  • 00:24:18
    longitud recibida es igual a 0 esto
  • 00:24:21
    significa que el socket cliente ha
  • 00:24:24
    cerrado entonces diremos el cliente es
  • 00:24:27
    el socket cliente a cerrar o cerrado y
  • 00:24:30
    el servidor debe cerrar ese file
  • 00:24:33
    descriptor correspondiente a ese socket
  • 00:24:36
    que estaba conectado con el cliente
  • 00:24:38
    y ya saldríamos de este bucle con este
  • 00:24:41
    break y si red devuelve un valor mayor
  • 00:24:45
    que 0 entonces ahí estamos
  • 00:24:48
    comunicándonos eso significa que hemos
  • 00:24:51
    leído algo y que lo vamos a imprimir
  • 00:24:54
    aquí el buffer de recepción y además le
  • 00:24:57
    vamos a enviar algo con raid
  • 00:25:00
    paraguay primer argumento el file
  • 00:25:01
    descriptor de esa conexión el segundo el
  • 00:25:05
    buffer de transmisión que dice algo así
  • 00:25:07
    como hola cliente soy el servidor y el
  • 00:25:09
    tercero es el tamaño de esos datos que
  • 00:25:12
    vamos a enviar entonces estaríamos en
  • 00:25:15
    este while true mientras el cliente pues
  • 00:25:19
    siga queriendo enviar y recibir datos
  • 00:25:21
    cuando el cliente cierre la conexión
  • 00:25:25
    este rey recibirá un 0 y el servidor
  • 00:25:30
    también cerrará la conexión y en ese
  • 00:25:33
    momento
  • 00:25:34
    volveremos a ver si se ve
  • 00:25:39
    en ese momento aquí estamos leyendo y
  • 00:25:42
    escribiendo
  • 00:25:43
    a un cliente y cuando el cliente cierre
  • 00:25:47
    el servidor cierra ese file descriptor y
  • 00:25:50
    tenemos aquí este bucle entonces aquí
  • 00:25:54
    estoy haciendo
  • 00:25:55
    entonces aceptaremos si es que
  • 00:25:58
    volveremos a la llamada al sistema
  • 00:26:00
    accept que si hay un cliente que está
  • 00:26:03
    esperando en cola ya para ser atendido
  • 00:26:04
    pues se creará un nuevo socket para
  • 00:26:07
    conectarse a ese cliente y si no pues
  • 00:26:11
    puedes esperar a bloquear aquí el
  • 00:26:13
    programa hasta aquí a un cliente que
  • 00:26:14
    quiera quieras saber algo del servidor
  • 00:26:16
    bueno y así sucesivamente cliente a
  • 00:26:19
    cliente
  • 00:26:20
    lo teníais aquí
  • 00:26:24
    etc el nombre de este archivo que es
  • 00:26:26
    server secuencial ce y el nombre del
  • 00:26:29
    ejecutable - hoy el nombre de ejecutable
  • 00:26:31
    que quiero darle y ese vale
  • 00:26:36
    server voy a ejecutar este programa el
  • 00:26:39
    programa servidor entonces el socket ha
  • 00:26:42
    sido creado es eso que va a escuchar el
  • 00:26:46
    socket ha sido 20 combined lo asocia
  • 00:26:50
    vamos a la dirección ip y al puerto y al
  • 00:26:54
    puerto 8080 y ahora el socket se han
  • 00:26:58
    marcado como pasivo y este mensaje nos
  • 00:27:01
    acabe esa instrucción
  • 00:27:03
    dice estoy escuchando en el puerto 8 mil
  • 00:27:06
    80 vale aquí el programa está bloqueado
  • 00:27:10
    en este accept que hemos visto esperando
  • 00:27:13
    que un cliente trate de conectarse
  • 00:27:17
    bueno ahora vamos a ver brevemente el
  • 00:27:19
    código del cliente si volvemos al
  • 00:27:21
    diagrama rápidamente el cliente lo que
  • 00:27:24
    tiene que hacer es crear un socket con
  • 00:27:26
    esta llamada al sistema y con la llamada
  • 00:27:28
    al sistema connect tratará de conectar
  • 00:27:30
    ese socket a una dirección ip es decir
  • 00:27:33
    la dirección ip del servidor una vez
  • 00:27:35
    conectado con red y raid realizaremos
  • 00:27:38
    ese intercambio de datos con el servidor
  • 00:27:40
    y cuando termines con el close cierras
  • 00:27:44
    ese descriptor de archivo y cierras esa
  • 00:27:46
    conexión entonces el servidor se da
  • 00:27:48
    cuenta de que el cliente ha cerrado y
  • 00:27:51
    puede atender a un siguiente cliente
  • 00:27:54
    bueno ahora vamos con el código del
  • 00:27:56
    cliente brevemente
  • 00:27:59
    aunque luego hay que compilar lo y
  • 00:28:01
    ejecutarlo en otra máquina bueno yo lo
  • 00:28:03
    voy a hacer así una para el servidor
  • 00:28:05
    otra para el cliente y estarán
  • 00:28:06
    conectadas por una red de área local
  • 00:28:10
    en este cliente lo que va a hacer es se
  • 00:28:12
    conecta al servidor del socket al socket
  • 00:28:15
    del servidor le va a enviar un texto
  • 00:28:18
    predefinido lee lo que el servidor le
  • 00:28:21
    responde y desconecta cierra la conexión
  • 00:28:24
    bueno incluso es necesario se puede leer
  • 00:28:27
    en el manual
  • 00:28:29
    ahora vamos a definir
  • 00:28:31
    cuál es la ip de la de la y en la
  • 00:28:35
    dirección ip del servidor al que nos
  • 00:28:36
    vamos a conectar y el puerto de fino 2
  • 00:28:39
    buffer uno el de transmisión los datos
  • 00:28:42
    que el cliente envía el servidor algo
  • 00:28:44
    tan simple con un texto que diga hola
  • 00:28:46
    servidor soy un cliente y un búfer para
  • 00:28:50
    que podamos leer esos datos que vienen
  • 00:28:53
    del servidor el tamaño va a ser 100 es
  • 00:28:56
    decir una operación de lectura podemos
  • 00:28:58
    cargar en ese arroyo máximo 100 bytes
  • 00:29:02
    vamos con el programa principal sin
  • 00:29:05
    argumentos de entrada defino un
  • 00:29:08
    descriptor para un descriptor de archivo
  • 00:29:11
    un file descriptor para el socket que va
  • 00:29:14
    a utilizar el cliente bien y ahora una
  • 00:29:17
    estructura de este tipo como hemos visto
  • 00:29:19
    antes en el servidor
  • 00:29:20
    el programa servidor esta estructura
  • 00:29:23
    será para
  • 00:29:25
    para la dirección del servidor su puerto
  • 00:29:29
    y su dominio cada uno de sus campos bien
  • 00:29:32
    creamos el socket con la llamada al
  • 00:29:35
    sistema socket igual que antes primer
  • 00:29:37
    argumento dominio segundo el tipo de
  • 00:29:39
    socket y tercero un cero porque vamos a
  • 00:29:42
    utilizar aquí el protocolo tcp nada
  • 00:29:44
    diferente si está llamando al sistema
  • 00:29:46
    nos devuelve un -1 esto significa error
  • 00:29:49
    es eso que no se ha creado imprimo en la
  • 00:29:51
    consola un mensajito de error y terminó
  • 00:29:54
    el programa si ese descriptor de archivo
  • 00:29:57
    tiene un valor válido estaremos acá
  • 00:29:59
    vemos en este el pse y decimos en
  • 00:30:01
    pantalla el socket ha sido creado
  • 00:30:04
    satisfactoriamente bien ahora
  • 00:30:08
    esta estructura con esos campos para el
  • 00:30:12
    servidor la vamos a inicializar con todo
  • 00:30:14
    ceros en dos utiliza la función mmmm set
  • 00:30:17
    y voy a poner un cero en cada uno de los
  • 00:30:20
    bytes de esta estructura un clear bien
  • 00:30:26
    ahora una vez lo tengo todo a cero en el
  • 00:30:30
    campo dominio escribo el dominio a efe y
  • 00:30:33
    net internet
  • 00:30:34
    en el segundo dirección ip teníamos esta
  • 00:30:37
    dirección ip 192 punto algo sé que la
  • 00:30:42
    del servidor y esta función y net y un
  • 00:30:45
    bajo a ddr como hemos visto antes para
  • 00:30:47
    darle el formato adecuado a esto que
  • 00:30:50
    hemos definido aquí está esta dirección
  • 00:30:54
    en forma de screen
  • 00:30:55
    vale el siguiente el campo del puerto
  • 00:30:59
    utilizando h toms para adaptar el byte
  • 00:31:03
    order al necesario el orden de los bytes
  • 00:31:05
    al de la red igual que antes ahora esto
  • 00:31:10
    es nuevo nos vamos a tratar de conectar
  • 00:31:13
    el socket del cliente se va a tratar de
  • 00:31:15
    conectar al socket del servidor
  • 00:31:17
    elementos utilizar llamar al sistema
  • 00:31:19
    connect primer argumento el file
  • 00:31:22
    descriptor de ese socket que hemos
  • 00:31:23
    creado para el cliente segundo esa
  • 00:31:26
    estructura con sus campos un puntero a
  • 00:31:28
    esta estructura para el servidor y el
  • 00:31:31
    tercer argumento
  • 00:31:33
    es un
  • 00:31:35
    el valor de los bytes que mide los bytes
  • 00:31:40
    que tiene esta estructura si connect es
  • 00:31:43
    diferente a 0 si devuelve un valor
  • 00:31:45
    distinto de 0 ha habido un error
  • 00:31:47
    y primos en pantalla la conexión ha
  • 00:31:50
    fallado con el servidor y este es este
  • 00:31:53
    cliente es un poco tonto y termina el
  • 00:31:55
    programa no vuelva a intentarlo
  • 00:31:58
    si hemos tenido éxito es decir si
  • 00:32:00
    conecte nos devuelve un cero e
  • 00:32:03
    imprimimos un mensaje que diga conectado
  • 00:32:05
    al servidor y ahora vamos a enviar datos
  • 00:32:09
    entonces con la función rights vamos a
  • 00:32:12
    el cliente va a enviar un dato o unos
  • 00:32:15
    datos al servidor primer argumento el
  • 00:32:17
    file descriptor de s socket el segundo
  • 00:32:19
    argumento la información es el buffer de
  • 00:32:22
    transmisión que contiene ese string que
  • 00:32:25
    dice hola servidor soy un cliente y en
  • 00:32:28
    tercer lugar el número de bytes que
  • 00:32:29
    enviamos vale
  • 00:32:33
    luego vamos a leer que nos responde él
  • 00:32:37
    el servidor primer argumento el file
  • 00:32:40
    descriptor del socket segundo el buffer
  • 00:32:42
    en el que vamos a almacenar esos texto
  • 00:32:45
    esos datos que nos va a enviar y en
  • 00:32:46
    tercer lugar el número máximo de bytes
  • 00:32:49
    que vamos a leer bien aquí en con el
  • 00:32:53
    print efe
  • 00:32:56
    se nos va a indicar se los va a sacar
  • 00:32:58
    por pantalla qué mensaje hemos recibido
  • 00:33:00
    del servidor el cliente recibe esto
  • 00:33:02
    bueno en realidad después del reich
  • 00:33:05
    debería comprobar que he leído he leído
  • 00:33:07
    datos antes de poner este mensaje sin
  • 00:33:11
    más
  • 00:33:12
    por último lugar vamos a cerrar el
  • 00:33:13
    socket con close cerramos de ese
  • 00:33:16
    descriptor de archivo entonces el socket
  • 00:33:19
    del cliente se desconecta el servidor lo
  • 00:33:22
    va a detectar y el servidor por su parte
  • 00:33:24
    también cerrará su file descriptor de su
  • 00:33:26
    socket y podrá atender esto es un
  • 00:33:29
    servidor secuencial podrá atender al
  • 00:33:30
    siguiente cliente el servidor lo había
  • 00:33:33
    creo fijado previamente ejecutándose
  • 00:33:36
    había creado el socket
  • 00:33:38
    estaría asociado a esa dirección ip y al
  • 00:33:42
    puerto y estaba escuchando en ese puerto
  • 00:33:44
    esperando a nuevos clientes
  • 00:33:46
    primero voy a abrir wireshark que es el
  • 00:33:48
    programa para hacer sniffing de paquetes
  • 00:33:51
    wizard que lo tengo instalado en windows
  • 00:33:53
    y luego ejecutar el cliente entonces al
  • 00:33:59
    servidor el cliente los tengo conectado
  • 00:34:00
    aquí bueno aparecen una serie de
  • 00:34:02
    conexiones es ésta la que aparece wifi y
  • 00:34:04
    de hecho nos indica que aquí hay tráfico
  • 00:34:06
    y esta es la dirección ip de la tarjeta
  • 00:34:12
    de windows ah pero como he dicho antes
  • 00:34:15
    es virtual box está en modo bridge con
  • 00:34:17
    esta tarjeta así que todas funcionan muy
  • 00:34:19
    bien bien y estos son los paquetes que
  • 00:34:22
    hay en nuestra red pero estos sean todos
  • 00:34:24
    los dispositivos que hay conectados en
  • 00:34:25
    mi red y yo lo que quiero hacer es
  • 00:34:27
    filtrar solamente datos de mi servidor y
  • 00:34:31
    de mí
  • 00:34:33
    de mi cliente lo que necesito aquí es
  • 00:34:35
    definir un filtro para que sólo se
  • 00:34:39
    display en los solo aparezcan los las
  • 00:34:42
    ips que yo quiero vale entonces aplicar
  • 00:34:44
    este filtro
  • 00:34:49
    vale no le puedo dar zoom pero lo que
  • 00:34:51
    quiero es que solamente aparezcan los
  • 00:34:54
    paquetes que provienen de la ip punto
  • 00:34:56
    src ip source de esta o sea del servidor
  • 00:35:00
    que sean iguales a este y cuyo destino
  • 00:35:03
    sea ese
  • 00:35:06
    es el cliente del cliente yo sé que
  • 00:35:07
    tiene esta ip porque lo he mirado o que
  • 00:35:11
    la dirección destino este es el símbolo
  • 00:35:14
    lógico del por que la dirección ip
  • 00:35:18
    fuente sea la del cliente y la de
  • 00:35:20
    destino a la del servidor vale para eso
  • 00:35:22
    se introduce este filtro bueno todavía
  • 00:35:24
    no se muestra tráfico porque el servidor
  • 00:35:27
    está esperando y el cliente lo tengo ahí
  • 00:35:30
    lo tengo lo tengo que compilar en la
  • 00:35:34
    otra máquina y ejecutarlo
  • 00:35:39
    bueno en este momento que hemos
  • 00:35:42
    ejecutado el cliente del cliente se ha
  • 00:35:43
    ejecutado y ya ha terminado porque
  • 00:35:45
    después porque solo se ha conectado ha
  • 00:35:48
    enviado un texto y ha leído un texto del
  • 00:35:50
    servidor bueno
  • 00:35:51
    aquí están todas esas todos los paquetes
  • 00:35:54
    del protocolo tcp que se han enviado
  • 00:35:56
    desde el cliente al servidor que es el
  • 00:35:59
    que intenta hacer la conexión y luego lo
  • 00:36:01
    que el servidor le contesta al cliente
  • 00:36:03
    donde están los datos esos esos datos
  • 00:36:05
    esos textos que hemos enviado pues aquí
  • 00:36:08
    si hago doble clic veo que el pei lotes
  • 00:36:10
    pues sus ciertos estos el código nas y
  • 00:36:14
    de su texto que enviado no hago doble
  • 00:36:16
    clic y bueno aquí me parece de
  • 00:36:18
    codificada toda esa secuencia de números
  • 00:36:19
    y esto es lo que ha enviado el cliente
  • 00:36:22
    vale y el cliente dice hola servidor soy
  • 00:36:25
    un cliente entonces bueno está el áfrica
  • 00:36:27
    correspondiente y el servidor dice hola
  • 00:36:30
    cliente soy el servidor el cliente
  • 00:36:32
    después cierra el archivo de el fight
  • 00:36:35
    descriptor y termina la conexión y el
  • 00:36:38
    cliente ahora o sea perdone el servidor
  • 00:36:43
    lo que ocurre es bueno esto ya lo
  • 00:36:45
    habíamos visto el socket se crea se
  • 00:36:48
    asocia esa dirección ip se escucha en un
  • 00:36:50
    puerto y en el momento en el que yo he
  • 00:36:52
    ejecutado el cliente
  • 00:36:54
    se imprime el mensaje que el cliente ha
  • 00:36:59
    enviado a lo que el servidor ha recibido
  • 00:37:01
    entonces el servidor le dé ese socket o
  • 00:37:04
    la servidor soy un cliente y el servidor
  • 00:37:08
    responde bueno imprimido aquí esa
  • 00:37:11
    respuesta del servidor al cliente y
  • 00:37:14
    cuando detecta que el cliente ha cerrado
  • 00:37:16
    ese file descriptor
  • 00:37:19
    el servidor imprime ese mensaje el
  • 00:37:21
    cliente ha terminado y entonces el
  • 00:37:24
    servidor estaría preparado para atender
  • 00:37:26
    al próximo cliente voy a volver a
  • 00:37:28
    ejecutar el cliente
  • 00:37:35
    y vuelve a ocurrir lo mismo el cliente
  • 00:37:38
    se conecta el servidor lee ese mensaje
  • 00:37:43
    es esos datos que ha recibido del
  • 00:37:44
    cliente o la servidor soy un cliente y
  • 00:37:46
    luego se cierra
  • 00:37:48
    bueno aquí termina este vídeo si hay
  • 00:37:50
    errores que puedes indicarlo en los en
  • 00:37:53
    los comentarios de abajo voy a dejar el
  • 00:37:55
    código fuente en github dejo la
  • 00:37:57
    dirección también abajo y si voy viendo
  • 00:38:00
    errores lo sigue corrigiendo completando
  • 00:38:02
    el código comentándolo etcétera y bueno
  • 00:38:06
    si te ha gustado le das un like y si no
  • 00:38:08
    pues después nada
الوسوم
  • Sockets TCP
  • Servidor Secuencial
  • Sockets en C
  • Comunicación entre Procesos
  • Linux
  • Intercambio de Datos
  • Arquitectura de Red
  • TCP versus UDP
  • Programación de Redes
  • VirtualBox