Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Código Fuente » C/Visual C » Código de C/Visual C - SOCKETPAIRS

Código de C/Visual C - SOCKETPAIRS

Volver
Agregar Código Fuente
<<>>
Imágen de perfil

SOCKETPAIRSgráfica de visualizaciones


C/Visual C

estrellaestrellaestrellaestrellaestrella(2)
Publicado el 10 de Octubre del 2022 por Hilario (144 códigos)
505 visualizaciones desde el 10 de Octubre del 2022
*************************************************************************
Dulce bellum inexpertis.
************************************************************************
Hilario Iglesias Martínez

************************************************************************
Socket_Pair.c
----------------------------------------------------------------------
Este programa fue realizado en una plataforma
LINUX Ubuntu 20.04.4 LTS.
Bajo el standard ANSI-C,
bajo una consola Linux.
*************************************************************************
En este programa trataremos la función socketpair
que realiza un mecanismo de comunicación entre procesos,
muy parecido al de la función pipes.
La diferencia fundamental con pipes, es que la comunicación
entre procesos es bidireccional.


Esta función se encuentra en la librería <sys/socket.h>

"int socketpair(int domain, int type, int protocol, int sv[2]);"

La función socketpair() crea un par de sockets del tipo especificado
que no tienen nombre y están conectados en el dominio indicado
y utilizando el protocolo especificado.

Argumentos descripción.
----------------------
dominio:(PF_UNIX, AF_UNIX, PF_LOCAL, AF_LOCAL)
El dominio: en el que abrir el socket.
Aunque se pueden obtener pares de sockets para sockets de dominio AF_INET,
se recomienda utilizar sockets de dominio:PF_UNIX, AF_UNIX para pares de sockets.

El tipo: de socket creado, ya sea SOCK_STREAM o SOCK_DGRAM.

Protocolo:El protocolo solicitado debe ser 0.
sv:Array, con los descriptores utilizados
para referirse a los sockets obtenidos.

-----------------------------------------------------------------
Para compilar el programa se puede utilizar la utilidad make, adjunta.
También se puede compilar directamente bajo consola de linux con el comando,
teniendo en cuenta que:
Socket_Pair.c
volcado.c
variables.h
deberán estar bajo el mismo directorio.


gcc -Wall -Werror -o Socket_Pair Socket_Pair.c volcado.c

Ejecutar:

./Socket_Pair



*/

Requerimientos

----------------------------------------------------------------------
Este programa fue realizado en una plataforma
LINUX Ubuntu 20.04.4 LTS.
Bajo el standard ANSI-C,
bajo una consola Linux.
*************************************************************************

Rv-0.
estrellaestrellaestrellaestrellaestrella(2)

Publicado el 10 de Octubre del 2022gráfica de visualizaciones de la versión: Rv-0.
506 visualizaciones desde el 10 de Octubre del 2022
estrellaestrellaestrellaestrellaestrella
estrellaestrellaestrellaestrella
estrellaestrellaestrella
estrellaestrella
estrella

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
/*
variables.h
*/
void Imprimir_Buffer ( unsigned char *Mi_Buffer , int Tama_Volcado);
 
-----------------------------------------------------------------------------------------------------
 
 
/*
volcado.c
*/
 
 
#include<stdio.h>
void Imprimir_Buffer ( unsigned char *Mi_Buffer , int Tama_Volcado)
{
 
char Codigo_ascii[17];
int i;
 
for (i = 0; i < Tama_Volcado; ++i) {
        printf("%02X ", ((unsigned char*)&Mi_Buffer)[i]);
        if (((unsigned char*)&Mi_Buffer)[i] >= ' ' && ((unsigned char*)&Mi_Buffer)[i] <= '~')
         {
            Codigo_ascii[i % 16] = ((unsigned char*)&Mi_Buffer)[i];
        } else {
            Codigo_ascii[i % 16] = '.';
        }
        if ((i+1) % 8 == 0 || i+1==Tama_Volcado) {
            printf(" ");
            if ((i+1) % 16 == 0) {
                printf(" |  %s \n", Codigo_ascii);
 
}}}
}
 
 
------------------------------------------------------------------------------------------------------------------
 
/*
Socket_Pair.c
*/
 
 
#include<sys/types.h>
#include<sys/socket.h>
#include<stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "variables.h"
 
#define MENSAJE1 "VERITAS FILIA TEMPORIS -SAECULA SAECULORUM"
#define MENSAJE2 "NO ENTIENDO MUY BIEN EL LATIN"
 
int main(int argc, char const *argv[])
{
 
int Socket_PADRE[2], Socket_HIJO;
unsigned char CONTENEDOR_BUFFER [1048];
 
/*
Función socketpair
*****************
#include <sys/socket.h>
 int socketpair(int domain, int type, int protocol, int sv[2]);
La función socketpair() crea un par de sockets del tipo especificado
que no tienen nombre y están conectados en el dominio indicado
y utilizando el protocolo especificado.
Argumentos descripción.
----------------------
dominio:(PF_UNIX,  AF_UNIX, PF_LOCAL, AF_LOCAL)
El dominio: en el que abrir el socket.
Aunque se pueden obtener pares de sockets para sockets de dominio AF_INET,
se recomienda utilizar sockets de dominio:PF_UNIX, AF_UNIX para pares de sockets.
El tipo: de socket creado, ya sea SOCK_STREAM o SOCK_DGRAM.
Protocolo:El protocolo solicitado debe ser 0.
sv:Array, con los descriptores utilizados
para referirse a los sockets obtenidos.
*/
if(socketpair(PF_UNIX,SOCK_STREAM,0,Socket_PADRE)<0) //SOCK_STREAM, orientado a conexión.
 
{
perror("Error abriendo los sockets");
exit(1);
}
 
/*Ahora  Socket_PADRE va a crear el proceso Socket_HIJO*/
 
if ((Socket_HIJO=fork())== -1)
perror("Error creando Socket_HIJO");
 
else if (Socket_HIJO)
{
 
/*Si el Socket_HIJO es creado cerraremos el primer
descriptor padre Socket_PADRE[0]*/
	close(Socket_PADRE[0]);
 
/*Comprobamos que el Socket_PADRE[1]-segundo descriptor lee el mensaje
de CONTENEDOR_BUFFER y lo imprimimos*/
 
if(read(Socket_PADRE[1],CONTENEDOR_BUFFER,1048)<0)
	perror("Error Socket_PADRE[1] leyendo el mensaje");
 
 
printf("Imprimimos CONTENEDOR_BUFFER de Socket_PADRE[1] \n");
printf("Dirección de inicio de Buffer Socket_PADRE[1]:[%p]\n",&CONTENEDOR_BUFFER );
printf("--------------------------------------------------------------------------\n");
Imprimir_Buffer(CONTENEDOR_BUFFER , 192); //Llamamos a la función de volcado.
printf("***************************************************************************\n" );
 
/*Ahora comprobamos que Socket_PADRE[1] puede leer el MENSAJE2*/
if(write(Socket_PADRE[1],MENSAJE2, strlen(MENSAJE2)+1)<0)
perror("Socket_PADRE[1] tuvo un error escribiendo el mensaje");
 
/* Cerramos el descriptor Socket_PADRE[1]*/
 
close(Socket_PADRE[1]);
}
 
else{
/* Pasamos al control del descriptor Socket_HIJO*/
 
if(write(Socket_PADRE[0],MENSAJE1,strlen(MENSAJE1)+1)<0)
	perror("Error Socket_HIJO escribiendo MENSAJE");
 
if(read(Socket_PADRE[0],CONTENEDOR_BUFFER,1048)<0)
perror("Error Socket_HIJO leyendo MENSAJE");
 
printf("Imprimimos CONTENEDOR_BUFFER de Socket_HIJO (cerrado Socket_PADRE[1]) \n");
printf("Dirección de inicio de Buffer Socket_HIJO:[%p]\n",&CONTENEDOR_BUFFER );
printf("*************************************************************************\n");
printf("\n");
Imprimir_Buffer(CONTENEDOR_BUFFER , 192); //Llamamos de nuevo a nuestra función de volcado.
 
 close(Socket_PADRE[0]);
 
 
}
exit(2);
}
 
--------------------------------------------------------------------------------------------------
 
                                        MAKEFILE
 
-----------------------------------------------------------------------------------------------------------
CC          = gcc
CFLAGS		= -c -Wall -Werror
LDFLAGS		= -lpcap
SOURCES		= Socket_Pair.c volcado.c
INCLUDES	= -I.
OBJECTS		= $(SOURCES:.c=.o)
TARGET		= Socket_Pair
 
all: $(SOURCES) $(TARGET)
 
$(TARGET): $(OBJECTS)
	$(CC) $(OBJECTS) $(LDFLAGS) -o $@
 
.c.o:
	$(CC) $(CFLAGS) $(INCLUDES) $< -o $@
 
clean:
	rm -rf $(OBJECTS) $(TARGET)



Comentarios sobre la versión: Rv-0. (2)

Tom
11 de Octubre del 2022
estrellaestrellaestrellaestrellaestrella
Hola. De acuerdo que es una "demo" pero hay algo que deberías incluir: Debes _siempre_ comprobar los valores devueltos por write() y por read() cuando usas sock_stream.
En primer lugar por seguridad y en segundo lugar porque no hay ninguna garantía de que puedas enviar todo el buffer de una vez ni de que leas todo el buffer de una vez (aunque generalmente es así).
En tu ejemplo la única manera de saber si has leído todo el mensaje es buscar un 0 al final del buffer leído, supongo que para eso escribes strlen() + 1 bytes, para incluir el 0.
Generalmente es conveniente usar una "cabecera" que lleve al menos el tamaño del mensaje.
Y, por simplicidad, mejor usar sock_dgram.
Responder
Imágen de perfil
Hilario
11 de Octubre del 2022
estrellaestrellaestrellaestrellaestrella
Gracias, Tom. Quizás hecho un poco apresurado. Excelente comentario.
Un saludo.
Responder

Comentar la versión: Rv-0.

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios...
CerrarCerrar
CerrarCerrar
Cerrar

Tienes que ser un usuario registrado para poder insertar imágenes, archivos y/o videos.

Puedes registrarte o validarte desde aquí.

Codigo
Negrita
Subrayado
Tachado
Cursiva
Insertar enlace
Imagen externa
Emoticon
Tabular
Centrar
Titulo
Linea
Disminuir
Aumentar
Vista preliminar
sonreir
dientes
lengua
guiño
enfadado
confundido
llorar
avergonzado
sorprendido
triste
sol
estrella
jarra
camara
taza de cafe
email
beso
bombilla
amor
mal
bien
Es necesario revisar y aceptar las políticas de privacidad
Acepto las políticas de privacidad

http://lwp-l.com/s7293