Soquetes TCP
Os processos se comunicam por meio de um endereço IP e de uma porta, como em 127.0.0.1:8080. O socket continua sendo representado por um descritor de arquivo criado pelo kernel. A diferença é que, agora, a comunicação pode ocorrer:
- Na mesma máquina.
- Entre máquinas diferentes da mesma rede.
- Pela internet.
O que é um socket TCP?
Um socket TCP é uma extremidade de comunicação que usa o TCP (Transmission Control Protocol). Ele oferece uma comunicação:
- Conectada.
- Bidirecional.
- Confiável.
- Ordenada.
- Baseada em um fluxo de bytes (stream).
Ou seja:
flowchart LR
A[Processo A]
B[TCP]
C[Processo B]
A <-.-> B <-.-> C
O TCP garante que os bytes entregues ao destino sejam apresentados na mesma ordem em que foram enviados.
Endereço TCP: IP e porta
Em um soquete de domínio Unix, o endereço pode ser um caminho, como /tmp/app.sock. No TCP, o endereço é composto por um IP e uma porta. Exemplos:
127.0.0.1:3000.192.168.22.46:8000.
IP
Identifica uma interface de rede. Exemplo: 192.168.22.40.
Porta
Identifica o serviço na máquina. Exemplos:
| Porta | Serviço |
|---|---|
| 22 | SSH |
| 80 | HTTP |
| 443 | HTTPS |
| 5432 | PostgreSQL |
| 6379 | Redis |
| 8000 | Muito usada em desenvolvimento |
Portanto, 127.0.0.1:8000 significa:
Conectar-se à própria máquina (localhost), no serviço que está em escuta na porta 8000.
Soquete de domínio Unix e soquete TCP
| Característica | Soquete de domínio Unix | Soquete TCP |
|---|---|---|
| Comunicação | Mesma máquina | Mesma máquina ou rede |
| Endereço | Caminho, como /tmp/app.sock |
IP e porta |
| Família | AF_UNIX |
AF_INET ou AF_INET6 |
| Estrutura | sockaddr_un |
sockaddr_in ou sockaddr_in6 |
| Uso comum | Daemon local, Docker e PostgreSQL local | Servidores web, APIs e banco remoto |
| Acesso remoto | Não | Sim |
No código, a principal mudança é esta:
// Soquete de domínio Unix.
int unix_sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
// Soquete TCP.
int tcp_sockfd = socket(AF_INET, SOCK_STREAM, 0);
Fluxo de um servidor TCP
Um servidor TCP executa as seguintes operações:
socket().bind().listen().accept().read()ewrite().close().
A ideia é a mesma de um soquete de domínio Unix, mas, agora, bind() associa o socket a um endereço IP local e a uma porta.
Fluxo:
socket(): cria o socket.bind(): associa o socket a um IP e a uma porta.listen(): coloca o socket no modo de escuta.accept(): espera que um cliente se conecte.read()ewrite(): trocam dados com o cliente.close(): fecha os descritores.
Fluxo de um cliente TCP
socket().connect().write().read().close().
Fluxo:
socket(): cria o socket.connect(): conecta-se ao IP e à porta do servidor.write(): envia dados.read(): recebe a resposta.close(): fecha a conexão.
A estrutura sockaddr_in
Para IPv4, usamos:
Ela representa AF_INET + porta + IP. Exemplo:
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(8000);
addr.sin_addr.s_addr = INADDR_ANY;
sin_family
Representa a família do endereço: AF_INET.
sin_port
Representa a porta. Usamos htons() para deixar no formato requerido (big-endian): htons(8000).
sin_addr
Representa o endereço IPv4. No servidor, podemos usar INADDR_ANY, que significa: aceite conexões em qualquer interface da máquina.
127.0.0.1 e 0.0.0.0
Quando um servidor usa 127.0.0.1, ele aceita conexões apenas da própria máquina, ou seja, somente programas locais podem acessá-lo. Isso é útil para testes.
Quando um servidor usa 0.0.0.0, ele aceita conexões por todas as interfaces disponíveis. Por exemplo:
- Loopback.
- Interface da rede local.
- Outras interfaces disponíveis.
Se uma máquina tiver o IP 192.168.0.10, um servidor em 0.0.0.0:8000 poderá aceitar conexões de outra máquina da rede, se o firewall permitir. Em C, usamos no servidor:
Isso é equivalente à ideia de 0.0.0.0.
Servidor TCP em C
Arquivo tcp_server.c:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#define PORT 8000
#define BUFFER_SIZE 1024
int main(void) {
int server_fd = socket(AF_INET, SOCK_STREAM, 0);
if (server_fd == -1) {
perror("socket");
return 1;
}
int opt = 1;
if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) == -1) {
perror("setsockopt");
close(server_fd);
return 1;
}
struct sockaddr_in addr;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(PORT);
addr.sin_addr.s_addr = INADDR_ANY;
if (bind(server_fd, (struct sockaddr *) &addr, sizeof(addr)) == -1) {
perror("bind");
close(server_fd);
return 1;
}
if (listen(server_fd, 10) == -1) {
perror("listen");
close(server_fd);
return 1;
}
printf("Servidor TCP escutando na porta %d...\n", PORT);
int client_fd = accept(server_fd, NULL, NULL);
if (client_fd == -1) {
perror("accept");
close(server_fd);
return 1;
}
printf("Cliente conectado.\n");
char buffer[BUFFER_SIZE];
ssize_t n = read(client_fd, buffer, sizeof(buffer) -1);
if (n == -1) {
perror("read");
close(client_fd);
close(server_fd);
return 1;
}
buffer[n] = '\0';
printf("Cliente enviou: %s\n", buffer);
const char *resp = "Mensagem recebida pelo servidor TCP.\n";
if (write(client_fd, resp, strlen(resp)) == -1) {
perror("write");
}
close(client_fd);
close(server_fd);
return 0;
}
Cliente TCP em C
Arquivo tcp_client.c:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#define PORT 8000
#define BUFFER_SIZE 1024
int main(void) {
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd == -1) {
perror("socket");
return 1;
}
struct sockaddr_in server_addr;
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(PORT);
if (inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr) <= 0) {
perror("inet_pton");
close(sockfd);
return 1;
}
if (connect(sockfd, (struct sockaddr *) &server_addr, sizeof(server_addr)) == -1) {
perror("connect");
close(sockfd);
return 1;
}
const char *msg = "Olá, servidor TCP!";
if (write(sockfd, msg, strlen(msg)) == -1) {
perror("write");
close(sockfd);
return 1;
}
char buffer[BUFFER_SIZE];
ssize_t n = read(sockfd, buffer, sizeof(buffer) -1);
if (n == -1) {
perror("read");
close(sockfd);
return 1;
}
buffer[n] = '\0';
printf("O servidor respondeu: %s\n", buffer);
close(sockfd);
return 0;
}
Explicação das funções principais
socket(AF_INET, SOCK_STREAM, 0)
Significa:
AF_INET -> IPv4
SOCK_STREAM -> fluxo conectado, ou seja, TCP
0 -> protocolo padrão para essa combinação
bind()
No servidor:
Associa o socket a: 0.0.0.0:8000.
listen()
Coloca o socket no modo passivo, à espera de conexões. O número 10 define o backlog, relacionado à fila de conexões pendentes. Em termos simples, ele limita quantas conexões podem aguardar enquanto o servidor ainda não chamou accept().
accept()
Espera que um cliente se conecte. Quando isso acontece, accept() retorna um novo descritor de arquivo.
server_fd: socket de escuta.client_fd: socket conectado a um cliente.
O servidor troca dados com o cliente usando apenas client_fd.
connect()
No cliente:
Solicita ao kernel: "Conecte este socket ao servidor 127.0.0.1:8000." Se o servidor estiver em escuta, a conexão será estabelecida.
TCP é fluxo de bytes
TCP não preserva mensagens. Se o cliente faz:
O servidor pode ler abcdef. TCP garante ordem dos bytes, mas não garante "uma mensagem por read()". O correto nesses casos é criar um protocolo.
inet_pton()
No cliente, usamos:
Isso converte uma string de IP, "127.0.0.1", para a forma binária que o kernel usa em struct sockaddr_in.
inet_pton significa presentation to network, ou seja: forma textual -> forma de rede.
send() e recv()
Além de read() e write(), podemos usar:
A diferença principal é:
read()ewrite()são genéricos para descritores de arquivo.recv()esend()são próprios para sockets e aceitam opções (flags) específicas.