Código de C/Visual C - SERVIDOR-CHAT-MEJORADO

Imágen de perfil

SERVIDOR-CHAT-MEJORADOgráfica de visualizaciones


C/Visual C

Publicado el 4 de Agosto del 2022 por Hilario (21 códigos)
136 visualizaciones desde el 4 de Agosto del 2022
/*
*********************
servidor_chat.c
*********************
Hilario Iglesias Martínez.
-------------------------
SERVIDOR.
----------------------------------
Volviendo hacía atrás a algunos
programas sobre sockes ya publicados,
se ha 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.
Deberemos de colocar como atributo del comando
nc de linux la ip y el puerto establecido
en el servidor previamente.
El programa hace una llamada al inicio al comando de linux
a ifconfig, con el fin de probar el mismo
con las Ips, idoneas.
------------------------------------------
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 y entender su proceso.
---------------------------
*********************************
Este programa ha sido realizado en.
LINUX Ubuntu 20.04.4 LTS.
Bajo el standard ANSI C.-C-11
Consola de Linux.
*****************************
Compilacion.
$ gcc servidor_chat.c -o servidor_chat
//**************************************

Ejecucion y un posible ejemplo de salida por
consola. Para interrmpir el programa
utilizar CONTRO C.
+++++++++++++++++++++++++++++++++++++
./servidor_chat
++++++++++++++++++++++++++++++++++
IMPRIME 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
Consola de Linux.

2.0

Publicado el 4 de Agosto del 2022gráfica de visualizaciones de la versión: 2.0
136 visualizaciones desde el 4 de Agosto 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
188
189
190
191
192
193
194
/*
*********************
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"
//#define AZUL   "\x1b[34m"
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 ;
}
 
 
/*Declaramos una función destinada para el chat cliente servidor.
donde se establece el buffer para el intercambio*/
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()
{
    char Codigo_ascii[17];
    size_t i, j;
    int  salida;    /* Salida del comando */
    char comando[60];   /* Comando a ejecutar */
 //**********************************
printf ( "LLAMADA (ifconfig) con system.\n");
sprintf (comando, "ifconfig ");
salida = system (comando);
 
  //********************************
 
/*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(Mejor,superior a 1000):\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");
 
 
//Rutina de volcado para ver posición en memoria del puerto e IP
 
for (i = 0; i < 123; ++i) {
        printf("%02X ", ((unsigned char*)&strucServidor)[i]);
        if (((unsigned char*)&strucServidor)[i] >= ' ' && ((unsigned char*)&strucServidor)[i] <= '~')
         {
            Codigo_ascii[i % 16] = ((unsigned char*)&strucServidor)[i];
        } else {
            Codigo_ascii[i % 16] = '.';
        }
        if ((i+1) % 8 == 0 || i+1==123) {
            printf(" ");
            if ((i+1) % 16 == 0) {
                printf(" |  %s \n", Codigo_ascii);
            }
            }
            }
 
 
// Ahora el Servidor está preparado para escuchar
printf("\n");
printf("***********************************************\n");
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);  //Llamada a lafun
 
    // El socket descriptor es cerrado
    close(sockDescriptor);
 }



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

http://lwp-l.com/s7263