Linux C Socket

最新推荐文章于 2024-01-28 17:48:12 发布
最新推荐文章于 2024-01-28 17:48:12 发布
阅读量445 收藏
点赞数 1
分类专栏： Linux C 文章标签： socket c语言 linux tcp 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuxingbusi/article/details/53700149
版权

Linux C Socket

TCP/UDP 服务器和客户端的动作

动作TCPUDP客户端
建立套接字(socket)YYY
绑定IP地址和端口号(bind)YYY
监听(listen)YNN
接受请求(accept)YNN
连接(connect)NNY

字节序转换
机器有大端字节序和小端字节序
而网络字节序是大端的
ntohl, ntohs 网络字节序转换为主机字节序
htonl, htons 主机字节序转换为网络字节序
网络地址转换
inet_ntoa sockaddr_in结构体中sin_addr参数转换为IP地址字符串
inet_addr IP地址字符串转换为sockaddr_in结构体中sin_addr参数

简单的TCP服务器

TCP需要先用accept接收客户端的套接字, 在处理完一个客户机的消息后才能处理下一个客户机的消息.

服务器端(server.c)
c code

#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <strings.h>

#include <errno.h>
#include <stdlib.h>
#include <stdio.h>

#define TCP SOCK_STREAM
#define UDP SOCK_DGRAM

#define MAXLINE 80

void if_error(int status_code, char *err_msg)
{
    if (status_code < 0) {
        perror(err_msg);
        exit(errno);
    }
}

int net_setup(int sock_type, char *ip_addr, int port, int max_connect)
{
    struct sockaddr_in serv_addr;
    int sock_fd, ret;

    /* socket */
    sock_fd = socket(AF_INET, sock_type, 0);
    if_error(sock_fd, "socket");

    /* bind */
    bzero(&serv_addr, sizeof(serv_addr));

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(port);
    serv_addr.sin_addr.s_addr = (NULL == ip_addr ? INADDR_ANY : inet_addr(ip_addr));

    ret = bind(sock_fd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
    if_error(ret, "bind");

    /* TCP listen */
    if (sock_type == TCP) {
        ret = listen(sock_fd, max_connect);
        if_error(ret, "listen");
    }
    return sock_fd;
}

int main(int argc, char **argv)
{
    int sock_fd, acc_fd, recv_bytes;
    char buf[MAXLINE];

    struct sockaddr_in cli_addr = {0};
    socklen_t cli_addr_len = sizeof(struct sockaddr);

    /* setup tcp socket */
    sock_fd = net_setup(TCP, NULL, 8080, 10);

    while (1) {
        /* accept */
        acc_fd = accept(sock_fd, (struct sockaddr*)&cli_addr, &cli_addr_len);
        if_error(acc_fd, "accept");
        /* print conn msg */
        printf("ip(%s), port(%d), client connect !\n",
                inet_ntoa(cli_addr.sin_addr), ntohs(cli_addr.sin_port));
        /* deal with cli msg */
        while (1) {
            /* recv msg */
            recv_bytes = recv(acc_fd, buf, sizeof(buf), 0);
            if_error(recv_bytes, "recv");

            /* cli exit */
            if (recv_bytes == 0) break;

            /* print cli msg */
            buf[recv_bytes] = '\0';
            printf("from ip(%s), port(%d), client message: %s",
                    inet_ntoa(cli_addr.sin_addr), ntohs(cli_addr.sin_port), buf);
        }
        /* close accept fd */
        close(acc_fd);
        /* print disconn msg */
        printf("ip(%s), port(%d), client disconnect !\n",
                inet_ntoa(cli_addr.sin_addr), ntohs(cli_addr.sin_port));
    }
    close(sock_fd);
    return 0;
}

客户端(client.c)
c code

#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <strings.h>

#include <errno.h>
#include <stdlib.h>
#include <stdio.h>

#define TCP SOCK_STREAM
#define UDP SOCK_DGRAM

#define MAXLINE 80

void if_error(int status_code, char *err_msg)
{
    if (status_code < 0) {
        perror(err_msg);
        exit(errno);
    }
}

int net_conn(int sock_type, char *ip_addr, int port)
{
    struct sockaddr_in server_addr;
    int sock_fd, ret;

    /* socket */
    sock_fd = socket(AF_INET, sock_type, 0);
    if_error(sock_fd, "socket");

    /* bind */
    bzero(&server_addr, sizeof(server_addr));

    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(port);
    server_addr.sin_addr.s_addr = (NULL == ip_addr ? INADDR_ANY : inet_addr(ip_addr));

    /* connect */
    ret = connect(sock_fd, (struct sockaddr*)&server_addr, sizeof(server_addr));
    if_error(ret, "connect");

    return sock_fd;
}

int main(int argc, char **argv)
{
    int sock_fd, send_bytes;
    char buf[MAXLINE];

    /* connect tcp server */
    sock_fd = net_conn(TCP, "127.0.0.1", 8080);

    while (1) {
        /* get msg from kbd */
        fgets(buf, sizeof(buf), stdin);
        if (strncmp(buf, "exit", 4) == 0) break;

        /* send msg */
        send_bytes = send(sock_fd, buf, sizeof(buf), 0);
        if_error(send_bytes, "send");
    }
    close(sock_fd);
    return 0;
}

UDP服务器

客户端的代码只需在连接时改成UDP, 其他不变.
sock_fd = net_conn(UDP, "127.0.0.1", 8080);

UDP不需要accept, 所以可以循环处理多个客户端的消息.

服务器端(server.c)
c code

#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <strings.h>

#include <errno.h>
#include <stdlib.h>
#include <stdio.h>

#define TCP SOCK_STREAM
#define UDP SOCK_DGRAM

#define MAXLINE 80

void if_error(int status_code, char *err_msg)
{
    if (status_code < 0) {
        perror(err_msg);
        exit(errno);
    }
}

int net_setup(int sock_type, char *ip_addr, int port, int max_connect)
{
    struct sockaddr_in serv_addr;
    int sock_fd, ret;

    /* socket */
    sock_fd = socket(AF_INET, sock_type, 0);
    if_error(sock_fd, "socket");

    /* bind */
    bzero(&serv_addr, sizeof(serv_addr));

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(port);
    serv_addr.sin_addr.s_addr = (NULL == ip_addr ? INADDR_ANY : inet_addr(ip_addr));

    ret = bind(sock_fd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
    if_error(ret, "bind");

    /* TCP listen */
    if (sock_type == TCP) {
        ret = listen(sock_fd, max_connect);
        if_error(ret, "listen");
    }
    return sock_fd;
}

int main(int argc, char **argv)
{
    int sock_fd, recv_bytes;
    char buf[MAXLINE];

    struct sockaddr_in cli_addr = {0};
    socklen_t cli_addr_len = sizeof(struct sockaddr);

    /* setup udp socket */
    sock_fd = net_setup(UDP, NULL, 8080, 0);

    while (1) {
        /* recv msg */
        recv_bytes = recvfrom(sock_fd, buf, sizeof(buf), 0,
                            (struct sockaddr*)&cli_addr, &cli_addr_len);
        if_error(recv_bytes, "recvfrom");

        /* cli exit */
        if (recv_bytes == 0) continue;

        /* print cli msg */
        buf[recv_bytes] = '\0';
        printf("from ip(%s), port(%d), client message: %s",
                inet_ntoa(cli_addr.sin_addr), ntohs(cli_addr.sin_port), buf);
    }
    close(sock_fd);
    return 0;
}

TCP服务器如何处理多个客户机

可以使用线程/进程来处理多个客户机的消息, 这里使用进程.
使用2次fork避免僵尸进程
客户端代码不变
服务器端(server.c)
c code

#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <strings.h>

#include <unistd.h>

#include <errno.h>
#include <stdlib.h>
#include <stdio.h>

#define TCP SOCK_STREAM
#define UDP SOCK_DGRAM

#define MAXLINE 80

void if_error(int status_code, char *err_msg)
{
    if (status_code < 0) {
        perror(err_msg);
        exit(errno);
    }
}

int net_setup(int sock_type, char *ip_addr, int port, int max_connect)
{
    struct sockaddr_in serv_addr;
    int sock_fd, ret;

    /* socket */
    sock_fd = socket(AF_INET, sock_type, 0);
    if_error(sock_fd, "socket");

    /* bind */
    bzero(&serv_addr, sizeof(serv_addr));

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(port);
    serv_addr.sin_addr.s_addr = (NULL == ip_addr ? INADDR_ANY : inet_addr(ip_addr));

    ret = bind(sock_fd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
    if_error(ret, "bind");

    /* TCP listen */
    if (sock_type == TCP) {
        ret = listen(sock_fd, max_connect);
        if_error(ret, "listen");
    }
    return sock_fd;
}

int main(int argc, char **argv)
{
    int sock_fd, acc_fd, recv_bytes;
    char buf[MAXLINE];

    pid_t chi_pid, grand_chi_pid;

    struct sockaddr_in cli_addr = {0};
    socklen_t cli_addr_len = sizeof(struct sockaddr);

    /* setup tcp socket */
    sock_fd = net_setup(TCP, NULL, 8080, 10);

    while (1) {
        /* accept */
        acc_fd = accept(sock_fd, (struct sockaddr*)&cli_addr, &cli_addr_len);
        if_error(acc_fd, "accept");

        /* print conn msg */
        printf("ip(%s), port(%d), client connect !\n",
                inet_ntoa(cli_addr.sin_addr), ntohs(cli_addr.sin_port));

        /* chi process deal with cli msg */
        chi_pid = fork();
        if_error(chi_pid, "fork");

        if (chi_pid == 0) {
        /* child process */
            grand_chi_pid = fork();
            if_error(grand_chi_pid, "fork");

            if (grand_chi_pid == 0) {
            /* grand child process */
                while (1) {
                    /* recv msg */
                    recv_bytes = recv(acc_fd, buf, sizeof(buf), 0);
                    if_error(recv_bytes, "recv");

                    /* cli exit */
                    if (recv_bytes == 0) break;

                    /* print msg */
                    buf[recv_bytes] = '\0';
                    printf("child pid(%d), from ip(%s), port(%d), client message: %s",
                            getpid(), inet_ntoa(cli_addr.sin_addr), ntohs(cli_addr.sin_port), buf);
                }
                /* close accept fd */
                close(acc_fd);
                /* print disconn msg */
                printf("ip(%s), port(%d), client disconnect !\n",
                        inet_ntoa(cli_addr.sin_addr), ntohs(cli_addr.sin_port));
                exit(0);
            }
            /* chi process exit */
            exit(0);
        } else {
            chi_pid = wait(NULL);
            if_error(chi_pid, "wait");
        }
    }
    close(sock_fd);
    return 0;
}

I/O复用TCP服务器

TCP服务器利用select完成处理多个客户机
服务器端(server.c)
c code

#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <strings.h>

#include <errno.h>
#include <stdlib.h>
#include <stdio.h>

#define TCP SOCK_STREAM
#define UDP SOCK_DGRAM

#define MAXLINE 80

void if_error(int status_code, char *err_msg)
{
    if (status_code < 0) {
        perror(err_msg);
        exit(errno);
    }
}

int net_setup(int sock_type, char *ip_addr, int port, int max_connect)
{
    struct sockaddr_in serv_addr;
    int sock_fd, ret;

    /* socket */
    sock_fd = socket(AF_INET, sock_type, 0);
    if_error(sock_fd, "socket");

    /* bind */
    bzero(&serv_addr, sizeof(serv_addr));

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(port);
    serv_addr.sin_addr.s_addr = (NULL == ip_addr ? INADDR_ANY : inet_addr(ip_addr));

    ret = bind(sock_fd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
    if_error(ret, "bind");

    /* TCP listen */
    if (sock_type == TCP) {
        ret = listen(sock_fd, max_connect);
        if_error(ret, "listen");
    }
    return sock_fd;
}

int main(int argc, char **argv)
{
    int sock_fd, acc_fd, recv_bytes;
    char buf[MAXLINE];

    fd_set reads, reads_init;
    struct timeval timeout, timeout_init;

    int i, fd_max, fd_num;

    struct sockaddr_in cli_addr = {0};
    socklen_t cli_addr_len = sizeof(struct sockaddr);

    /* setup tcp socket */
    sock_fd = net_setup(TCP, NULL, 8080, 10);

    /* monitor serv socket */
    FD_ZERO(&reads_init);
    FD_SET(sock_fd, &reads_init);
    fd_max = sock_fd;

    /* set timeout time */
    timeout_init.tv_sec = 5;
    timeout_init.tv_usec= 0;

    while (1) {
        /* init reads & timeout for select */
        reads = reads_init;
        timeout = timeout_init;

        /* select */
        fd_num = select(fd_max+1, &reads, NULL, NULL, &timeout);
        if_error(fd_num, "select");

        /* no change */
        if (fd_num == 0) {
            printf("timeout!\n");
            continue;
        }

        for (i = 0; i <= fd_max; i++) {
            /* if changed */
            if (FD_ISSET(i, &reads)) {
                /* serv socket */
                if (i == sock_fd) {
                    acc_fd = accept(sock_fd, (struct sockaddr*)&cli_addr, &cli_addr_len);
                    if_error(acc_fd, "accept");

                    /* add cli socket to fd set */
                    FD_SET(acc_fd, &reads_init);
                    if (fd_max < acc_fd) fd_max = acc_fd;
                    printf("client %d connected .\n", acc_fd);
                } else {
                    /* cli socket, recv msg */
                    recv_bytes = recv(i, buf, sizeof(buf), 0);
                    if_error(recv_bytes, "recv");

                    /* remove socket from set */
                    if (recv_bytes == 0) {
                        FD_CLR(i, &reads_init);
                        close(i);
                        printf("client %d disconnected .\n", i);
                    } else {
                        buf[recv_bytes] = '\0';
                        printf("client %d message: %s", i, buf);
                    }
                }
            }
        }
    }
    close(sock_fd);
    return 0;
}
jit-hakase
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux C++ UDP Socket（超详细）_c+
ZZdjajf13131的博客
04-28 996
通常，在一个SOCK_STREAM套接字接收连接之前，必须通过bind()函数用本地地址为套接字命名。sin_family表示地址类型，对于基于TCP/IP传输协议的通信，该值只能是AF_INET；recvfrom: 用于接收数据。
Linux C Socket多路复用
vjjjjjta的专栏
07-23 3448
1. 循环服务器:UDP服务器UDP循环服务器的实现非常简单:UDP服务器每次从套接字上读取一个客户端的请求,处理, 然后将结果返回给客户机.可以用下面的算法来实现.   socket(...);   bind(...);   while(1)    {         recv
linux C/C++ socket编程
qq_37026934的博客
09-04 3898
socket
linux c语言 socket编程
m0_57046226的博客
01-02 844
socket
C/C++ Linux Socket网络编程 TCP 与 UDP
cpp_learner的博客
02-01 9749
详细介绍Linux环境C/C++如何使用socket通信，TCP与UDP；
Linux之C++ socket通信编程
ZONGXP的博客
03-30 6732
服务端：服务器端先初始化socket，然后与端口绑定，对端口进行监听，调用accept阻塞，等待客户端连接。 客户端：客户端先初始化socket，然后与服务端连接，服务端监听成功则连接建立完成
Linux下用C++实现Socket通信
weixin_48068319的博客
07-05 266
自用。
Linux Socket编程
qq_43505188的博客
01-08 42
上面我们已经知道网络中的进程是通过socket来通信的，那什么是socket呢？socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，都可以用“打开open –> 读写write/read –> 关闭close”模式来操作。我的理解就是Socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭），这些函数我们在后面进行介绍。
linux c socket api
01-07
在Linux系统中，C语言的Socket API是进行网络通信的核心工具，它允许程序员创建和管理套接字，实现客户端和服务器之间的数据交换。本篇将深入探讨Linux C Socket API的关键概念、常用函数以及其实现机制。 一、...
linux C语言 socket通信聊天小程序
05-05
本项目涉及的"Linux C语言 socket通信聊天小程序"是一个基础的网络聊天应用，支持群聊和私聊功能。 首先，我们需要理解什么是Socket。Socket是网络编程的一个接口，它提供了进程间通信（IPC）的能力，特别是在网络...
基于嵌入式linux c socket通信
12-05
总之，嵌入式Linux中的C语言socket通信涉及到网络编程的基本概念，包括socket创建、地址配置、连接与监听、数据交换以及资源释放。熟悉并掌握这些知识点对于开发嵌入式网络应用至关重要。通过实践和不断调试，开发者...
Linux环境Socket发包工具
05-24
在Linux系统中，我们可以使用C语言的socket库来创建和管理Socket，但对于快速开发和测试，Python提供了一个更加便捷的平台。Python的socket模块封装了底层的socket接口，使得编写Socket程序变得更加简单。 XML...
linux下c语言使用socket进行线程间的通信
qq_37760746的博客
05-24 2157
   socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，都可以用“打开open –> 读写write/read –> 关闭close”模式来操作。Socket就是该模式的一个实现， socket即是一种特殊的文件，一些socket函数就是对...
Linux下C/C++ Socket服务器的简单实现和详细解析
qq_42702222的博客
11-21 921
在linux系统下用C/C++ Socket实现最简单的服务器，并解释使用到的函数。
在Linux中用C语言实现Socket通信
最新发布
weixin_40763897的博客
01-28 1707
stdio.h ： 这个文件头文件是标准的输入输出，StandardInputOutput。这个头文件主要涉及文件相关的输入输出操作。典型的方法printf() ， scanf()，getc(), putc()。怎么理解这里文件呢？在Linux，有一个基本的原则，键盘、显示等这些操作都会作为文件来对待。事实上，键盘输入是默认的stdin文件流，显示输出是默认的stdout文件流。StandardL。
Linux_C例程(Socket)
连想的博客
04-07 861
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 系列文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的
linux 网络编程socket
Qurry的博客
01-27 4251
Socket=（IP地址：端口号），套接字的表示方法是点分十进制的lP地址后面写上端口号，中间用冒号或逗号隔开。每一个传输层连接唯一地被通信两端的两个端点所确定。
linux C语言 socket的server、client 实现
坛城的博客
09-13 1474
你可以将上述代码分别保存为 server.c 和 client.c，并分别编译成可执行文件，然后在两个不同的终端窗口中运行它们。如果你使用的是不同的编程语言或开发环境，编译步骤可能会有所不同。通常，你需要指定套接字的类型（例如，SOCK_STREAM表示TCP套接字）和地址族（例如，AF_INET表示IPv4地址族）。在实际应用中，不可能像实例一中，server只接收一次，client只向server发送一次。// 关闭套接字, 只要关闭client，server端的recv就不会阻塞了，返回0！
linux C语言socket
07-27
在Linux C语言中，使用Socket可以实现应用层与TCP/IP协议族通信的中间软件抽象层。Socket提供了一组接口，隐藏了复杂的TCP/IP协议族，对用户来说，只需要使用一组简单的接口就可以进行通信，让Socket去组织数据，以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值