Linux网络编程 -- 创建套接字进行通信

最新推荐文章于 2024-09-28 23:21:36 发布

原创最新推荐文章于 2024-09-28 23:21:36 发布 · 711 阅读

1 ·

CC 4.0 BY-SA版权

Linux 专栏收录该内容

11 篇文章

订阅专栏

本文介绍了一个简单的TCP服务器程序实现，该程序能够接收客户端连接，并将客户端发送的信息转换为大写后回传。文章详细展示了服务器端的初始化过程，包括套接字创建、绑定、监听等步骤。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

server.c

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <ctype.h>
#include <strings.h>
#include <sys/wait.h>

#include "wrap.h"

#define SERV_PORT 8888


int main()
{
    int i;
    int n;
    int cfd;
    int listenfd;   //文件描述符
    char buf[BUFSIZ];       //存放读取到的客户端的数据
    char clie_IP[BUFSIZ];   //用来存放客户端IP
    socklen_t clie_addr_len;
    struct sockaddr_in serv_addr, clie_addr;

    //参数1： AF_INET ->ipv4 AF_INET6 ->ipv6 
    //参数2：SOCK_STREAM -> TCP SOCK_DGRAM -> UDP
    //参数3：传0 表示使用默认协议。
    listenfd = Socket(AF_INET, SOCK_STREAM, 0);

    bzero(&serv_addr, sizeof(serv_addr))    
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(SERV_PORT);  //主机字节序转换为网络字节序  大端模式 小端模式
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); //网络地址为INADDR_ANY，这个宏表示本地的任意IP地址
    Bind(listenfd, (struct sockaddr *)serv_addr, sizeof(serv_addr));   //由于历史原因，需强制转换为 struct sockaddr * 类型

    Listen(listenfd, 128);  //允许同时监听的客户端请求， 最大128

    clie_addr_len = sizeof(clie_addr);
    cfd = Accept(listenfd, (struct sockaddr *)&clie_addr, &clie_addr_len);

    printf("Client IP: %s, Port: %d\n",
            inet_ntop(AF_INET, &clie_addr.sin_addr.s_addr, clie_IP, sizeof(clie_IP)),
            ntohs(clie_addr.sin_port));

    while (1)
    {
        n = Read(cfd, buf, sizeof(buf));
        if (0 == n)
        {
            Close(cfd);
            return 0;
        }
        else
        {
            for (i = 0; i < n; ++i)
            {
                buf[i] = toupper(buf[i]);
            }

            Write(cfd, buf, n);
        }

    }

    return 0;
}

封装函数

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>

//输出错误信息并退出
void perr_exit(const char *str)
{
    perror(str);
    exit(-1);
}    

//创建套接字 带出错处理  哈哈
int Socket(int family, int type, int protocol)
{
    int n;

    n = socket(family, type, protocol);
    if (n < 0)
    {
        perr_exit("socket error");
    }

    return n;
}


int Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{
    int n;

    n = bind(fd, sa, salen);
    if (n < 0)
    {
        perr_exit("bing error");
    }

    return n;
}

int Listen(int fd, int backlog)
{
    int n;

    n = listen(fd, backlog);
    if (n < 0)
    {
        perr_exit("listen error");
    }

    return n;
}

int Connect(int fd, const struct sockaddr *sa, socklen_t salen)
{
    int n;

    n = connect(fd, sa, salen);
    if (n < 0)
    {
        perr_exit("connect error");
    }

    return n;
}

int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr)
{
    int n;

again:
    n = accept(fd, sa, salenptr);
    if (n < 0)
    {
        if (errno == ECONNABORTED || errno == EINTR)
        {
            goto again;
        }
        else
        {
            perr_exit("accept error");
        }
    }
}

ssize_t Read(int fd, void *ptr, size_t nbytes)
{
    ssize_t n;

again:
    n = read(fd, ptr, nbytes);
    if (-1 == n)
    {
        if (EINTR == errno)
        {
            goto again;
        }
        else
        {
            return -1;
        }
    }

    return n;
}

ssize_t Write(int fd, const void *ptr, size_t nbytes)
{
    ssize_t n;

again:
    n = write(fd, ptr, nbytes);
    if (-1 == n)
    {
        if (EINTR == errno)
        {
            goto again;
        }
        else
        {
            return -1;
        }
    }

    return n;
}

int Close(int fd)
{
    int n;

    n = close(fd);
    if (-1 == n)
    {
        perr_exit("close error");
    }

    return n;
}