C/Visual C - programa en c

 
Vista:

programa en c

Publicado por walter werner (2 intervenciones) el 18/10/2001 06:12:17
necesito comunicar de un pc a otro a traves de c.
me podrian dar una pequeña ayuda
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Comunicación entre PCs a través de C

Publicado por Alejandro (913 intervenciones) el 17/10/2024 00:19:41
Walter, para comunicarte entre dos PCs utilizando C, puedes usar sockets, que son una forma estándar de comunicación en red. A continuación, te muestro un ejemplo básico de cómo implementar un cliente y un servidor en C utilizando sockets.

Ejemplo de servidor



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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
 
#define PORT 8080
#define BUFFER_SIZE 1024
 
int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int opt = 1;
    int addrlen = sizeof(address);
    char buffer[BUFFER_SIZE] = {0};
 
    // Crear el socket
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }
 
    // Opciones del socket
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) {
        perror("setsockopt");
        exit(EXIT_FAILURE);
    }
 
    // Configurar la dirección del servidor
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);
 
    // Enlazar el socket
    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }
 
    // Escuchar conexiones
    if (listen(server_fd, 3) < 0) {
        perror("listen");
        exit(EXIT_FAILURE);
    }
 
    // Aceptar una conexión
    if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
        perror("accept");
        exit(EXIT_FAILURE);
    }
 
    // Leer datos del cliente
    read(new_socket, buffer, BUFFER_SIZE);
    printf("Mensaje recibido: %s\n", buffer);
 
    // Enviar respuesta al cliente
    const char *response = "¡Hola desde el servidor!";
    send(new_socket, response, strlen(response), 0);
 
    // Cerrar el socket
    close(new_socket);
    close(server_fd);
    return 0;
}

Ejemplo de cliente



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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
 
#define PORT 8080
#define BUFFER_SIZE 1024
 
int main() {
    int sock = 0;
    struct sockaddr_in serv_addr;
    char *message = "¡Hola desde el cliente!";
    char buffer[BUFFER_SIZE] = {0};
 
    // Crear el socket
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        printf("\n Error en la creación del socket \n");
        return -1;
    }
 
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);
 
    // Convertir IPv4 y IPv6
    if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {
        printf("\n Dirección no válida/ Dirección no soportada \n");
        return -1;
    }
 
    // Conectar al servidor
    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
        printf("\n Error en la conexión \n");
        return -1;
    }
 
    // Enviar mensaje al servidor
    send(sock, message, strlen(message), 0);
    printf("Mensaje enviado: %s\n", message);
 
    // Leer respuesta del servidor
    read(sock, buffer, BUFFER_SIZE);
    printf("Respuesta del servidor: %s\n", buffer);
 
    // Cerrar el socket
    close(sock);
    return 0;
}

Explicación del código:



1. Servidor:
- Crea un socket y lo enlaza a una dirección y puerto específicos.
- Escucha conexiones entrantes y acepta una conexión.
- Lee un mensaje del cliente y envía una respuesta.

2. Cliente:
- Crea un socket y se conecta al servidor utilizando su dirección IP y puerto.
- Envía un mensaje al servidor y espera una respuesta.

Cómo ejecutar:



1. Compila ambos programas:
- Usa un compilador de C (como `gcc`) para compilar ambos archivos.
- Por ejemplo: `gcc server.c -o server` y `gcc client.c -o client`.

2. Ejecuta el servidor:
- Primero, ejecuta el servidor en una terminal: `./server`.

3. Ejecuta el cliente:
- Luego, en otra terminal, ejecuta el cliente: `./client`.

Notas:


- Asegúrate de que el puerto que estás utilizando (en este caso, 8080) esté disponible y no esté bloqueado por un firewall.
- Puedes cambiar `"127.0.0.1"` en el cliente por la dirección IP del servidor si están en diferentes máquinas.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar