Servidor TCP
Aceite conexões.
Servidor TCP é uma aula grátis de C Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C Academy inclui 4 aulas no total.
Criando um servidor TCP
Um servidor TCP aguarda clientes e aceita suas conexões. O ciclo de vida é: criar um socket, associá-lo a uma porta, aguardar conexões e então aceitá-las em um loop.
Etapa 1: criar o socket
Crie um socket de fluxo para TCP sobre IPv4. Um resultado negativo indica falha.
#include <sys/socket.h>
#include <stdio.h>
int make_server_socket(void) {
int fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd < 0) { perror("socket"); }
return fd;
}Etapa 2: permitir a reutilização do endereço
Por padrão, uma porta permanece em TIME_WAIT depois que o servidor para, bloqueando reinicializações. Defina SO_REUSEADDR com setsockopt para poder associar a porta novamente imediatamente.
#include <sys/socket.h>
void allow_reuse(int fd) {
int yes = 1;
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes);
}Etapa 3: associar a uma porta
bind() associa o socket a um endereço e uma porta locais. INADDR_ANY aguarda conexões em todas as interfaces de rede.
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
int bind_port(int fd, unsigned short port) {
struct sockaddr_in addr = {0};
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = INADDR_ANY;
addr.sin_port = htons(port);
if (bind(fd, (struct sockaddr *)&addr, sizeof addr) < 0) {
perror("bind"); return -1;
}
return 0;
}Etapa 4: aguardar conexões
listen() marca o socket como passivo (pronto para aceitar conexões). O argumento backlog define quantas conexões pendentes o núcleo pode colocar na fila.
#include <sys/socket.h>
#include <stdio.h>
int start_listen(int fd) {
if (listen(fd, 16) < 0) { /* backlog of 16 */
perror("listen"); return -1;
}
return 0;
}Etapa 5: aceitar conexões
accept() bloqueia até que um cliente se conecte e então retorna um socket novo para esse cliente. O socket original continua aguardando conexões.
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
int accept_one(int listen_fd) {
struct sockaddr_in cli;
socklen_t len = sizeof cli;
int conn = accept(listen_fd, (struct sockaddr *)&cli, &len);
if (conn < 0) perror("accept");
return conn;
}Dois sockets, duas funções
Depois de accept, você terá dois sockets:
- O socket de escuta continua aceitando novos clientes
- O socket de conexão se comunica com um cliente específico
Feche o socket de conexão quando terminar de atender esse cliente.
Lendo a solicitação
Use recv para ler os dados do cliente em um buffer. Um retorno de 0 significa que o cliente se desconectou; -1 significa um erro.
#include <sys/socket.h>
#include <stdio.h>
void handle(int conn) {
char buf[256];
ssize_t n = recv(conn, buf, sizeof buf - 1, 0);
if (n > 0) { buf[n] = 0; printf("got: %s\n", buf); }
}Enviando uma resposta
Responda com send. Para dados grandes, repita a operação até que todos os bytes sejam enviados, pois uma única chamada pode escrever apenas parte do buffer.
#include <sys/socket.h>
#include <string.h>
void reply(int conn) {
const char *msg = "hello from server\n";
size_t left = strlen(msg);
const char *p = msg;
while (left > 0) {
ssize_t n = send(conn, p, left, 0);
if (n <= 0) break;
p += n; left -= (size_t)n;
}
}O loop de aceitação
Um servidor iterativo simples aceita um cliente, atende-o, fecha a conexão e então volta ao início para aceitar o próximo. Ele atende os clientes um de cada vez.
#include <unistd.h>
void serve_loop(int listen_fd, int (*accept_one)(int), void (*handle)(int)) {
for (;;) {
int conn = accept_one(listen_fd);
if (conn < 0) continue;
handle(conn);
close(conn); /* done with this client */
}
}Encerramento ordenado
Feche o socket de escuta quando o servidor parar e trate SIGINT para sair do loop de forma limpa. Sempre feche os descritores para liberar os recursos do núcleo.
Verificação rápida
Teste sua compreensão dos servidores TCP.
Recapitulação
Você criou um servidor TCP passo a passo.
- socket, depois SO_REUSEADDR, depois bind, listen e accept
acceptretorna um novo socket para cada cliente- recv/send para se comunicar e depois fechar a conexão
- Use um loop para atender clientes; verifique todos os valores de retorno
Perguntas Frequentes
A aula “Servidor TCP” é grátis?
Sim — o texto completo de “Servidor TCP” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C Academy, atualize para CoddyKit PRO. O curso de C Academy inclui 4 aulas no total.
O que vou aprender em “Servidor TCP”?
Aceite conexões. Você pratica C Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar C Academy?
Nenhuma experiência prévia é necessária. C Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.
Quanto tempo leva a aula “Servidor TCP”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de C Academy?
Sim. Cada aula de C Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.