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 - SERVIDOR

Código de C/Visual C - SERVIDOR

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

SERVIDORgráfica de visualizaciones


C/Visual C

Publicado el 6 de Julio del 2022 por Hilario (122 códigos)
768 visualizaciones desde el 6 de Julio del 2022
/*
*********************
servidor_chat.c
*********************
Hilario Iglesias Martínez.
-------------------------
SERVIDOR.
----------------------------------
Volviendo hacía atrás a algunos
programas sobre sockes ya publicados.
He realizado este Sevidor para chat,
con el fin de poder interactuar
con el a través de dos consolas
Linux en el mismo ordenador,
utilizando la dirección Localhost (127.0.0.1),
u otra en la cual la configración del
cortafuegos lo permita.
Una vez abierto y a la escucha el servidor,
se podrán interactuar mensajes con él
a través del comando linux, por ejemplo
nc 127.0.0.1 5898, o utilizando el antiguo
telnet.
donde se coloca como atributo del comando
nc de linux la ip y el puerto establecido
en el servidor previamente.
En este ejemplo se puede ver, en un volcado
de memoria, como se dispone la ip y el puerto
en memoria según se su tratamiento.
formatos Big Endian, o Little Endian
Como en otros programas puestos aquí,
se podría hacer un seguimiento de
los mensajes con wireshark para analizar
los paquetes.
---------------------------
Salida del Servidor poniendo en consola
la frase.
hasta luego lucas
*********************************
Este programa ha sido realizado en.
LINUX Ubuntu 20.04.4 LTS.
Bajo el standard ANSI C.-C-11
Usado el IDE Sublime Text.
Consola de Linux.
*****************************
Compilacion.
$ gcc servidor_chat.c -o servidor_chat
Ejecucion.
+++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++
Salida por consola.
------------------------------
+++++++++++++++++++++++++++++++++++++++++++++++
Tu sistema es Little Endian
+++++++++++++++++++++++++++++++++++++++++++++++
Introduce una IP
127.0.0.1
++++++++++++++++
*******************
Introduce un Puerto:
+++++++++++++++++++
8767
-------------------
Valor de entrada: 8767
Socket creado con éxito
Tamaño de la strucServidor = 16
La IP local es: 127.0.0.1
El Puerto local de conexión es: 8767
----------------------------------------------
Disposición en memoria del Puerto y la IP
----------------------------------------------
02 00 22 3f 7f 00 00 01 00 00 00 00 00 00 00 00 || .."?............
c2 00 00 00 00 00 00 00 f7 a0 ba dc fc 7f 00 00 || ................
38 37 36 37 00 7f 00 00 ad 79 54 c1 92 55 00 00 || 8767.....yT..U..
e8 72 03 3b 66 7f 00 00 60 79 54 c1 92 55 00 00 || .r.;f...`yT..U..
31 32 37 2e 30 2e 30 2e 31 00 54 c1 92 55 00 00 || 127.0.0.1.T..U..
00 a2 ba dc fc 7f 00 00 00 a5 6b 08 1f 31 1f 71 || ..........k..1.q
00 00 00 00 00 00 00 00 83 a0 e6 3a || ...........:
----------------------------------------------
Socket enlazado con éxito.
El Servidor está preparado

Requerimientos

Este programa ha sido realizado en.
LINUX Ubuntu 20.04.4 LTS.
Bajo el standard ANSI C.-C-11
Usado el IDE Sublime Text.
Consola de Linux.

2.0

Publicado el 6 de Julio del 2022gráfica de visualizaciones de la versión: 2.0
769 visualizaciones desde el 6 de Julio 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
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
/*
*********************
servidor_chat.c
*********************
*/
 
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<netdb.h>
#define VERDE "\x1b[32m"
struct sockaddr;//Declaración de la estructura sockaddr contenidas en #include<netinet/in.h>
//Declaración de funciones
void SaberComoEs() //Saber como es el sistema.
{
   int16_t i = 1;
   int8_t *p = (int8_t *) &i;
   printf("+++++++++++++++++++++++++++++++++++++++++++++++\n");
     if (p[0] == 1) printf("Tu sistema es Little Endian\n");
 
   else           printf("Tu sistema es Big Endian\n");
printf("+++++++++++++++++++++++++++++++++++++++++++++++\n");
 
   return ;
}
 
//******************************************** 2 llamada Volcado de IP y puerto.
void dump(const unsigned char *datos_de_buffer, const unsigned int longitud)
 {
    unsigned char byte;
    unsigned int c, n;
    for(c=0; c < longitud; c++) {
    byte = datos_de_buffer[c];
    printf("%02x ", datos_de_buffer[c]);  // Mostrar bytes en  hexadecimal
    if(((c%16)==15) || (c==longitud-1)) {
    for(n=0; n < 15-(c%16); n++)
    printf("   ");
    printf("|| ");
    for(n=(c-(c%16)); n <= c; n++) {  // Imprimir bytes por linea
    byte = datos_de_buffer[n];
    if((byte > 31) && (byte < 127)) // Rangos de impresión en consola Linux
    printf(VERDE"%c", byte);
    else
    printf(".");
    }
    printf("\n"); // Al final de cada linea salto
    } // cierre de  if
    } // cierre de  for
} //cierre de función principal
 
//+++++++++++++++++++++++++++++++++++++++++++ 3 llamada
 
// Declaramos una función destinada para el chat cliente servidor.
void lafunc(int chatServClient)
{
    char buferIntercambio[90]; //Reserva de buffer para el intercambio de 90bytes write y read
    int h;
    // Este es un bucle  repetitivo read >-> write para el  chat interactivo
    for (;;) {
        bzero(buferIntercambio, 90);//borra los datos en los n bytes de la memoria
       //comenzando en la ubicación señalada , escribiendo ceros (bytes que contiene '\0') en esa área.
 
        // Leemos el mensaje del cliente y lo copiamos en buferIntermedio.
        read(chatServClient, buferIntercambio, sizeof(buferIntercambio));
 
        // Imprimimos el contenido del buffer del cliente.
        printf("Mensaje del cliente: %s\t : ", buferIntercambio);
        bzero( buferIntercambio,90);//volvemos a borrar datos
        h = 0;
        // Copiamos el mensaje del Servidor en el buffer.
        while ((buferIntercambio[h++] = getchar()) != '\n');
        //repetir bucle mientras no sea igual.
        //chatServClient es el nuevo descriptor de socket creado por aceppt.
        //Para cada cliente aceptado se crear'un nuevo Descriptor Socket
 
        //  Mandamos el contenido del bufer al client utilizando la función write().
        write(chatServClient, buferIntercambio, sizeof(buferIntercambio));
 
        // Si el mensaje contiene  "Exit" entonces el seridor sale y el chat termina.
        if (strncmp("hasta luego lucas", buferIntercambio, 16) == 0)
           // la llamada strncmp compara caracteres,
            //en este caso le decimos que compare 16.
            // si el servidor manda el mensaje "hasta luego lucas" 16 bytes --16) == 0)
            //el servidor saldrá de la conexión
         {
            printf("Salida del Servidor\n");
            break;
 
        }
        }
        }
 
// Inicio de main
 
 
int main()
{
 
/*Llamamos a esta función
para saber el tipo de alojamiento en tu sistema*/
SaberComoEs();
/*Hacemos la entrada de la ip con la función scanf*/
char IP[24];
printf("Introduce una IP\n");
scanf("%s",IP);
printf("++++++++++++++++\n");
    //char *ip = "127.0.0.1"; Esta sería otra forma de introducir ip estática.
    //declaracion de variables a estructuras.
    int sockDescriptor, chatServClient, Larg,lon_MiServ;
    struct sockaddr_in strucServidor, struCliente;
 
    // Creación del Socket y comprobación de su ejecución, si devuelve -1 el descriptor habrá error
    sockDescriptor = socket(AF_INET, SOCK_STREAM, 0);
    if (sockDescriptor == -1) {
        printf("La creación del socket no ha tenido exito\n");
        exit(0);
    }
    else
        //printf("Socket creado con éxito\n");
    bzero(&strucServidor, sizeof(strucServidor));
 
 /*En vez de pasar el puerto por argumento de main,
  lo hacemos por medio de la entrada standard scanf.*/
printf("*******************\n" );
printf("Introduce un Puerto:\n");
printf("+++++++++++++++++++\n");
char puerto [20];
scanf("%s",puerto);
printf("-------------------\n" );
int valor =atoi(puerto); //Esta función convierte el argumento de una cadena  en un número entero (tipo int).
printf("Valor de entrada: %i\n",valor );
 
    // assignaciones ip, puerto
    strucServidor.sin_family = AF_INET;
    strucServidor.sin_addr.s_addr = inet_addr(IP);
    strucServidor.sin_port = htons(valor);
    /*La función htons convierte un u_short de host
     a orden de bytes de red TCP/IP ( big-endian).*/
   printf("Socket creado con éxito\n");
    // Llamamos a la función bind() para crear socket.
    if ((bind(sockDescriptor, (struct sockaddr *)&strucServidor, sizeof(strucServidor))) != 0) {
        printf("No se ha podido asignar dirección. Bind ha fayado\n");
                exit(0);
    }
    else
 
 printf("Tamaño de la strucServidor = %li\n", sizeof(strucServidor));
 
lon_MiServ=sizeof(strucServidor);
getsockname (sockDescriptor,(struct sockaddr *)&strucServidor,&lon_MiServ);//hacemos un cast a (struct sockaddr *)
printf("La IP local es: %s\n", inet_ntoa(strucServidor.sin_addr));
printf("El Puerto local de conexión es: %d\n", (int) ntohs(strucServidor.sin_port));
printf("----------------------------------------------\n");
printf("Disposición en memoria del Puerto y la IP\n");
printf("----------------------------------------------\n");
   dump(&strucServidor, 108);
printf("----------------------------------------------\n");
// Ahora el Servidor está preparado para escuchar
printf("Socket enlazado con éxito.\n");
    if ((listen(sockDescriptor, 5)) != 0) { //Ponemos el socket a escuchar, y  una cola máxima de 5 clientes.
        printf("La escucha de Clientes ha fallado...\n");
        exit(0);
    }
    else
        printf("El Servidor está preparado\n");
    Larg = sizeof(struCliente);
 
    // Aceptamos datos del cliente.
chatServClient = accept(sockDescriptor, (struct sockaddr *)&struCliente, &Larg);//Nuevo socket abierto por aceppt()
        if (chatServClient < 0) {
        printf("El servidor no ha aceptado\n");
        exit(0);
    }
    else
    printf("El servidor acepta CLIENTE con nuevo SOCKET-Descriptor %d: \n",chatServClient);
   //dump(&strucServidor, 120);
    // Llamada a la función lafunc que trabajará con los buffer de mensajes
    lafunc(chatServClient);
 
    // El socket descriptor es cerrado
    close(sockDescriptor);
 
}//Cierre final



Comentarios sobre la versión: 2.0 (0)


No hay comentarios
 

Comentar la versión: 2.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/s7256