Linux c编程之TCP通信

最新推荐文章于 2024-05-14 21:52:42 发布
最新推荐文章于 2024-05-14 21:52:42 发布
阅读量997 收藏 3
点赞数
分类专栏： Linux C网络编程实践 文章标签： linux tcp c connect bind
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/szkbsgy/article/details/128139054
版权

一、说明

TCP（Transmission Control Protocol），由RFC 793定义，中文名为传输控制协议，是一种面向连接的、可靠的、基于字节流的传输层通信协议。
TCP是常用的网络传输协议之一，该协议是面向连接、可靠传输的字节流协议。在Linux C网络程序中广泛使用，如http/https、ftp等。
TCP通信分为客户端和服务端，传输数据前需要客户端向服务端发起建立连接，数据传输完成后，双方可以断开连接。

二、常用API介绍

2.1 socket()

   #include <sys/types.h>
   #include <sys/socket.h>

   int socket(int domain, int type, int protocol);

作用： 用来创建一个通信的终端实例
参数说明：
  domain: 协议族，用AF_INET表示IPv4
  type: 传输方式，常用的有以下两种
    SOCK_STREAM： TCP
    SOCK_DGRAM： UDP
  protol: 特殊协议，实际应用中都是写为0
返回值：
  成功时返回一个socket文件描述符，失败时返回-1，errno会被设置，可以通过errno值获取错误码

2.2 bind()

   #include <sys/types.h>
   #include <sys/socket.h>

   int bind(int sockfd, const struct sockaddr *addr,
            socklen_t addrlen);

作用：绑定网络地址（IP/PORT)到socket
参数说明：
  sockfd: socket()返回的描述符
  addr： 绑定的地址
  addrlen: 绑定的地址结构长度
返回值：
  成功时返回0，失败时返回-1，errno会被设置，可以通过errno值获取错误码

2.3 connect()

   #include <sys/types.h>      
   #include <sys/socket.h>

   int connect(int sockfd, const struct sockaddr *addr,
               socklen_t addrlen);

作用：连接到服务端
参数说明：
  sockfd: socket()返回的描述符
  addr: 服务端的地址
  addrlen: 服务端的地址结构长度
返回值：
  成功时返回0，失败时返回-1，errno会被设置，可以通过errno值获取错误码

2.4 listen()

   #include <sys/types.h>
   #include <sys/socket.h>

   int listen(int sockfd, int backlog);

作用：监听客户端的连接请求
参数说明：
  sockfd: socket()返回的描述符
  backlog: 待处理的客户端连接请求的队列最大长度，如果待处理的队列满了，则收到客户端请求会返回
返回值:
  成功时返回0，失败时返回-1，errno会被设置，可以通过errno值获取错误码

2.5 accept()

   #include <sys/types.h>
   #include <sys/socket.h>

   int accept(int sockfd, struct sockaddr *addr,
               socklen_t *addrlen);

作用：接受客户端的连接请求
参数说明：
  sockfd: socket()返回的描述符
  addr: 服务端的地址
  addrlen: 服务端的地址结构长度
返回值：
  成功时返回对应客户端连接的socket描述符，失败时返回-1，errno会被设置，可以通过errno值获取错误码

2.6 read()和write()

#include <unistd.h>
ssize_t write(int fd, const void *buf, size_t count);

#include <unistd.h>
ssize_t read(int fd, void *buf, size_t count);

作用：
  可以通过系统的write/read函数发送/接收网络数据，其中fd对应socket文件描述符
参数说明：
  fd: socket()返回的网络描述符
  buf:接收或发送缓冲区
  count:发送的字节数或接收的缓冲区大小
返回值：
  大于0时，表示读取或写入的字节数； －1表示错误

2.7 close()

#include <unistd.h>
int close(int fd);

作用：
  关闭一个描述符（文件/socket)

三、实际应用分析

3.1 基本TCP通信

server_tcp.c:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>

#define SERVER_PORT 9999

int server_tcp()
{
    int ret = 0;
    int socket_fd = -1;
    int client_fd = -1;
    int addr_len = 0;    
    unsigned int value = 1;
    char buf[1024] = {0};
    int read_len = 0;
    struct sockaddr_in server_addr;
    struct sockaddr_in client_addr;

    socket_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (socket_fd < 0) {
        printf("%s: socket failed\n", __FUNCTION__);
        goto on_error;
    }

    if (setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR,
            (void *)&value, sizeof(value)) < 0) {
        printf("%s: Fail to setsockopt\n", __FUNCTION__);
        goto on_error;
    }

    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(SERVER_PORT);
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);

    addr_len = sizeof(server_addr);
    ret = bind(socket_fd, (const struct sockaddr *)&server_addr, addr_len);
    if (ret < 0) {
        printf("%s: bind failed\n", __FUNCTION__);
        goto on_error;
    }

    ret = listen(socket_fd, 5);
    if (ret < 0) {
        printf("%s: listen failed\n", __FUNCTION__);
        goto on_error;
    }

    client_fd = accept(socket_fd
            , (struct sockaddr *)&client_addr, &addr_len);
    if (client_fd < 0) {
        printf("%s: invalid client fd[%d]\n", __FUNCTION__, client_fd);
        return -1;
    }
    printf("client fd[%d] connect\n", client_fd);

    while (1) {
        read_len = read(client_fd, buf, 1024);
        if (read_len > 0) {
            printf("recv data[%s] from client\n", buf);
            write(client_fd, buf, read_len);
            printf("send data[%s] to client\n", buf);
        } else if (read_len < 0) {
            printf("errno:%d\n", errno);
            break;
        } else if (0 == read_len) {
            printf("client fd[%d] disconnect\n", client_fd);
            break;
        }
    }

    close(socket_fd);
    close(client_fd);

    return 0;

on_error:

    close(socket_fd);
    close(client_fd);

    return -1;
}

int main(int argc, char *argv[])
{
    int ret = -1;

    ret = server_tcp();
    if (ret < 0) {
        printf("%s: server tcp failed\n", __FUNCTION__);
        return -1;
    }

    return 0;
}

client_tcp.c:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>

#define SERVER_IP "127.0.0.1"
#define SERVER_PORT 9999

int client_tcp(char *server_ip, int server_port, char *data)
{
    int ret = 0;
    int socket_fd = -1;
    int addr_len = 0;
    char buf[1024] = {0};
    struct sockaddr_in server_addr;

    socket_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (socket_fd < 0) {
        printf("%s: socket failed\n", __FUNCTION__);
        return 0;
    }

    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(server_port);
    server_addr.sin_addr.s_addr = inet_addr(server_ip);

    addr_len = sizeof(server_addr);
    ret = connect(socket_fd, (struct sockaddr *)&server_addr, addr_len);
    if (ret < 0) {
        printf("%s: connect failed, errno:%d, %s\n", __FUNCTION__, errno, strerror(errno));
        goto on_error;
    }

    ret = write(socket_fd, data, strlen(data));
    printf("send data[%s] to server\n", data);

    ret = read(socket_fd, buf, sizeof(buf));
    if (ret > 0) {
        printf("recv data[%s] from server\n", buf);
    } else if (ret < 0) {
        printf("%s: errno:%d\n", __FUNCTION__, errno);
    } else if (0 == ret) {
        printf("server fd[%d] disconnect\n", socket_fd);
    }

    close(socket_fd);

    return 0;

on_error:

    close(socket_fd);

    return -1;
}

int main(int argc, char *argv[])
{
    if (argc < 4) {
        printf("usage: %s 127.0.0.1 9999 hello\n", argv[0]);
        return -1;
    }

    client_tcp(argv[1], atoi(argv[2]), argv[3]);

    return 0;
}

Makefile:

all:
	gcc -o server server_tcp.c
	gcc -o client client_tcp.c
clean:
	-@rm server client

编译：
make
运行：

$ ./server
client fd[4] connect
recv data[helloworld] from client
send data[helloworld] to client
client fd[4] disconnect


$ ./client 127.0.0.1 9999 helloworld
send data[helloworld] to server
recv data[helloworld] from server

服务端不启动时，客户端连接失败，如下：

$ ./client 127.0.0.1 9999 helloworld
client_tcp: connect failed, errno:111, Connection refused

服务端启动时，可以看见监听的端口，如下：

$ netstat -antp | grep server
tcp        0      0 0.0.0.0:9999            0.0.0.0:*               LISTEN      36467/server

已经有服务端启动时，再启动服务端bind()接口会失败：

$ ./server
bind failed, errno:98, Address already in use

3.2 服务端支持IO复用

为了使服务端能够多次处理连接，使用epoll函数管理socket描述符。
源码：
server_tcp.c:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/epoll.h>
#include <errno.h>

#define SERVER_PORT 9999


int g_listen_fd = -1;
int g_epoll_fd = -1;

int server_tcp()
{
    int ret = 0;
    long socket_fd = -1;
    int addr_len = 0;    
    unsigned int value = 1;
    struct epoll_event event;
    struct sockaddr_in server_addr;

    socket_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (socket_fd < 0) {
        printf("%s: socket failed\n", __FUNCTION__);
        goto on_error;
    }

    if (setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR,
            (void *)&value, sizeof(value)) < 0) {
        printf("%s: Fail to setsockopt\n", __FUNCTION__);
        goto on_error;
    }

    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(SERVER_PORT);
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);

    addr_len = sizeof(server_addr);
    ret = bind(socket_fd, (const struct sockaddr *)&server_addr, addr_len);
    if (ret < 0) {
        printf("%s: bind failed\n", __FUNCTION__);
        goto on_error;
    }

    ret = listen(socket_fd, 5);
    if (ret < 0) {
        printf("%s: listen failed\n", __FUNCTION__);
        goto on_error;
    }

    event.events =  EPOLLIN;
    event.data.fd = socket_fd;
    ret = epoll_ctl(g_epoll_fd, EPOLL_CTL_ADD, socket_fd, &event);
    if(ret < 0) {
        printf("epoll_ctl failure:%s\n", strerror(errno));
        close(g_epoll_fd);
        return -1;
    }

    g_listen_fd = socket_fd;

    return 0;

on_error:

    close(socket_fd);

    return -1;
}

int main(int argc, char *argv[])
{
    int ret = -1;
    int num = 0;
    int i = 0;
    int client_fd = 0;
    int addr_len = 0;
    int read_len = 0;
    char buf[1024] = {0};
    struct epoll_event event;
    struct sockaddr_in client_addr;
    struct epoll_event events_array[10];

    g_epoll_fd = epoll_create(10);
    if (g_epoll_fd < 0) {
        printf("epoll_create failure:%s\n", strerror(errno));
        return -1;
    }

    ret = server_tcp();
    if (ret < 0) {
        printf("%s: server tcp failed\n", __FUNCTION__);
        return -1;
    }

    while (1) {
        num = epoll_wait(g_epoll_fd, events_array, 10, -1);
        if (num < 0) {
            printf("epoll_wait failure:%s\n", strerror(errno));
            close(g_epoll_fd);
            break;
        } else if (num == 0) {
            printf("eopll_wait timeout!\n");
            continue;
        }

        for (i = 0; i < num; i++) {
            if(events_array[i].events == EPOLLIN) {
                if (events_array[i].data.fd == g_listen_fd) {
                    client_fd = accept(events_array[i].data.fd,
                            (struct sockaddr *)&client_addr, &addr_len);
                    if (client_fd < 0) {
                        printf("%s: invalid client fd[%d]\n", __FUNCTION__, client_fd);
                        return -1;
                    }

                    printf("client %s:%d fd[%d] connect\n",
                                    inet_ntoa(client_addr.sin_addr),
                                    ntohs(client_addr.sin_port), client_fd);

                    event.events =  EPOLLIN;
                    event.data.fd = client_fd;
                    ret = epoll_ctl(g_epoll_fd, EPOLL_CTL_ADD, client_fd, &event);
                    if(ret < 0) {
                        printf("epoll_ctl failure:%s\n", strerror(errno));
                        return -1;
                    }
                } else {
                    memset(buf, 0, sizeof(buf));
                    read_len = read(events_array[i].data.fd, buf, 1024);
                    if (read_len > 0) {
                        printf("recv data[%s] from client fd[%d]\n",
                                buf, events_array[i].data.fd);
                    } else if (read_len < 0) {
                        epoll_ctl(g_epoll_fd, EPOLL_CTL_DEL, events_array[i].data.fd, NULL);
                        close(events_array[i].data.fd);
                    } else if (0 == read_len) {
                        printf("client fd[%d] disconnect\n",
                                events_array[i].data.fd);
                        epoll_ctl(g_epoll_fd, EPOLL_CTL_DEL, events_array[i].data.fd, NULL);
                        close(events_array[i].data.fd);
                    }
                }
            }

        }
    }

    return 0;
}

client_tcp.c:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int client_tcp(char *server_ip, int server_port, char *data)
{
    int ret = 0;
    int socket_fd = -1;
    int addr_len = 0;
    struct sockaddr_in server_addr;

    socket_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (socket_fd < 0) {
        printf("%s: socket failed\n", __FUNCTION__);
        return 0;
    }

    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(server_port);
    server_addr.sin_addr.s_addr = inet_addr(server_ip);

    addr_len = sizeof(server_addr);
    ret = connect(socket_fd, (struct sockaddr *)&server_addr, addr_len);
    if (ret < 0) {
        printf("%s: connect failed\n", __FUNCTION__);
        goto on_error;
    }

    ret = write(socket_fd, data, strlen(data));

    close(socket_fd);

    return 0;

on_error:

    close(socket_fd);

    return -1;
}

int main(int argc, char *argv[])
{
    if (argc < 4) {
        printf("usage: %s 127.0.0.1 9999 hello\n", argv[0]);
        return -1;
    }

    client_tcp(argv[1], atoi(argv[2]), argv[3]);

    return 0;
}

Makefile:

all:
	gcc -o server server_tcp.c
	gcc -o client client_tcp.c
clean:
	-@rm server client

客户端端口变化问题

$  ./server
client 127.0.0.1:50280 fd[5] connect
recv data[hello] from client fd[5]
client fd[5] disconnect
client 127.0.0.1:50281 fd[5] connect
recv data[hello] from client fd[5]
client fd[5] disconnect
client 127.0.0.1:50282 fd[5] connect
recv data[hello] from client fd[5]
client fd[5] disconnect

客户端端口变化是由于没有绑定指定的端口，系统每次随机分配了一个端口。

memset(&client_addr, 0, sizeof(client_addr));                                                                                        
    client_addr.sin_family = AF_INET;
    client_addr.sin_port = htons(10000);
    client_addr.sin_addr.s_addr = inet_addr(“127.0.0.1”);
    addr_len = sizeof(client_addr);

    ret = bind(socket_fd, (const struct sockaddr *)&client_addr, addr_len);
    if (ret < 0) {
        printf("%s: bind failed\n", __FUNCTION__);
        close(socket_fd);
        return 0;
    }

测试：
多次启动客户端，均为同一个端口10000

$ ./server
client 127.0.0.1:10000 fd[5] connect
recv data[hello] from client fd[5]
client fd[5] disconnect
client 127.0.0.1:10000 fd[5] connect
recv data[hello] from client fd[5]
client fd[5] disconnect

###3.3 绑定失败问题

$ ./client 127.0.0.1 9999 hello
$ ./client 127.0.0.1 9999 hello
client_tcp: bind failed, errno:98, Address already in use

$ netstat -antp | grep 10000
tcp        0      0 127.0.0.1:10000         127.0.0.1:9999          TIME_WAIT

原因是之前的连接还没有完全释放，可以在调用bind()接口前将socket设置为地址可重复使用，对客户端、服务端同样适用。

socket_fd = socket(AF_INET, SOCK_STREAM, 0); 
    if (socket_fd < 0) {
        printf("%s: socket failed\n", __FUNCTION__);
        return 0;
    }   

    unsigned int value = 1;
    if (setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR,
            (void *)&value, sizeof(value)) < 0) {
        printf("%s: Fail to setsockopt\n", __FUNCTION__);
        goto on_error;
    }   

    memset(&client_addr, 0, sizeof(client_addr));
    client_addr.sin_family = AF_INET;
    client_addr.sin_port = htons(CLINET_PORT);
    client_addr.sin_addr.s_addr = inet_addr(CLINET_IP);

测试：

$ ./client 127.0.0.1 9999 hello
$ ./client 127.0.0.1 9999 hello
$ ./client 127.0.0.1 9999 hello

这时就没有绑定问题了

3.4 服务端监听地址问题

  1. server监听在本地回环地址127.0.0.1
$ ./server 127.0.0.1 9999
client 127.0.0.1:10000 fd[5] connect
recv data[hello] from client fd[5]
client fd[5] disconnect

在同一台机器，运行client可以访问

$ ./client 127.0.0.1 9999 hello

但是在另外一台机器，是连接不上的，因为127.0.0.1是本地回环地址，只能在同一台机器内使用，如下：

$ ./client 127.0.0.1 9999 hello
client_tcp: connect failed

因此，server端需要绑定其它机器可以访问的地址。比如server 端所在机器是192.168.0.29，可以绑定在192.168.0.29。
测试结果：

$ ./server 192.168.0.29 9999
client 192.168.0.132:10000 fd[5] connect
recv data[hello] from client fd[5]
client fd[5] disconnect

$ ./client 192.168.0.29 9999 hello

同时，同一台机器也可以通过127.0.0.1连接

$ ./server 192.168.0.29 9999
client 127.0.0.1:10000 fd[5] connect
recv data[hello] from client fd[5]
client fd[5] disconnect

$ ./client 192.168.0.29 9999 hello

但是在实际环境中，比如云服务器，主机上一般都有多块网上、多个IP,如本地回环地址127.0.0.1、局域网IP（也称私网地址）、公网IP等，如下某主机IP地址情况：
本地回环地址：127.0.0.1
私有IP：192.168.0.5， 192.168.1.5
公网地址：36.87.80.2，36.78.90.3

如果服务端监听在192.168.0.5地址，客户端192.168.0.x可以连接，但客户端192.168.1.x连接不上;如果服务端监听在192.168.1.5地址，客户端192.168.1.x可以连接，但客户端192.168.0.x连接不上。
有一种方法是同时监听需要监听的地址，常用于公网服务器。另一种方法是直接监听在0.0.0.0地址，即表示监听主机的所有IP地址，这也是非常常用的方法。

四、关键说明

  • TCP是常用的网络层传输协议，最经典的应用场景是HTTP协议
  • TCP通信有重传机制，是可靠传输
浪游东戴河
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Linux C ： TCP/IP 和 网络编程
superSmart_Dong的博客
11-23 4676
创建socket； 绑定socket和端口号； 监听端口号； (UDP省略) 接收来自客户端的连接请求；(UDP省略) 从socket中读取字符； 发送消息回客户机。 客户端套接字编程步骤如下 创建socket； 连接指定计算机的端口； （UDP省略） 向socket中写入信息； 从服务器接收消息。...
Linux C语言网络编程(学习笔记二)：socket实现网络通信(tcp和udp)
ssz__的博客
04-25 4413
在日常应用中有很多关于socket网络通信的例子，例如局域网内打游戏，使用浏览器看视频，用QQ软件聊天等。可以说socket是底层抽象给应用层所使用的一套接口。网络通信的传输方式有两种，一种是基于TCP（数据可靠传输）,另一种是基于UDP（数据不可靠，一般用于实时视频传输）。
C C++最全Linux下TCP IP编程--TCP实战_linux tcp，2024最新网易C C++面试题目
最新发布
2401_84973304的博客
05-14 660
/客户端请求处理函数。//客户端地址信息结构体。//服务器地址信息结构体。//客户端结构体变量。//socket描述符。#define BACKLOG 5 //listen队列等待的连接数。//socket描述符。#define PORT 6666 //服务器端口。//处理客户端链接的接收工作*//使用pthread线程库。
基于LinuxC语言实现的TCP多线程/进程服务器
m0_72847002的博客
08-30 1045
【代码】基于LinuxC语言实现的TCP多线程/进程服务器。
Linux C++使用TCP通信实现本地客户端与服务端传输文件数据（亲测可用）
ssz__的博客
05-07 2648
这个项目是在本地完成客户端与服务端的数据传输，做这个小项目的目的是为了引出下一个项目在同一局域网条件下，电脑和工控机进行远程无线通信。此时电脑为客户端，工控机为服务端。
【嵌入式】Linux C编程——网络编程（2）
a_qwq_a的博客
06-08 140
TCP/IP和套接字
头歌Linux系统编程之c编程入门
11-20
【头歌Linux系统编程之C编程入门】是一个关于在Linux环境下进行C语言编程学习的教程。这个教程覆盖了从基础的C语言编程到更高级的Linux系统编程技术，旨在帮助初学者逐步掌握在Linux系统中编写C程序的能力。 1. **...
Linux网络通信编程socket
11-21
通过学习为后续Linux网络编程奠定基础。首先介绍网络编程的概念，即网络协议分层，旨在帮助读者对网络建立初步的、全面立体的认识，其次介绍包括协议、端口、地址等；最后介绍应用非常广泛的传输控制协议...
linux_tcp-udp.rar_linux并发编程_tcp
09-19
在Linux系统中，网络编程是开发服务端应用的基础，它主要涉及到套接字（socket）接口，这是进程间通信（IPC）的一种方式，特别适用于网络通信。本资源提供了基于TCP和UDP协议的简单网络编程示例，涵盖了并发处理和...
linux网络编程和TCP-IP详解
04-28
在IT领域，Linux网络编程和...无论是开发网络服务、优化通信性能，还是排查网络故障，对Linux网络编程和TCP/IP的理解都是必不可少的。通过阅读提供的PDF文档，你可以深入到网络编程的细节中，逐步提升自己的专业技能。
tcp.rar_linux TCP 封装_linux tcp通信库
09-24
总结，"tcp.rar_linux TCP 封装_linux tcp通信库"是一个专为Linux环境设计的TCP通信库，它封装了TCP协议的核心操作，简化了用户空间应用程序的网络编程。通过学习和使用这个库，开发者可以更好地理解和利用TCP协议，...
【高并发网络通信架构】1.Linux下实现单客户连接的tcp服务端
weixin_43729127的博客
07-07 1794
异步I/O（Asynchronous I/O）：通过使用异步I/O操作，可以在所有I/O操作之后返回，而不会阻塞当前线程。这将创建一个新的套接字，用于和客户端进行通信，而原始的监听套接字继续监听新的连接请求。这将创建一个新的套接字，用于和客户端进行通信，而原始的监听套接字继续监听新的连接请求。进行数据通信（Communicate）：使用已连接的套接字进行数据的读取和写入。监听连接请求（Listen）：将套接字置于监听状态，等待客户端的连接请求，使用。关闭套接字（Close）：当通信结束后，使用。
Linux网络通信——TCP通信流程
梅山
04-09 6715
1、TCP通信流程 TCP是一个面向连接的，安全的，流式传输协议，这个协议是一个传输层协议。 面向连接：是一个双向连接，通过三次握手完成，断开连接需要通过四次挥手完成。 安全：tcp通信过程中，会对发送的每一数据包都会进行校验, 如果发现数据丢失, 会自动重传 流式传输：发送端和接收端处理数据的速度，数据的量都可以不一致 4.1 服务器端通信流程 创建用于监听的套接字, 这个套接字是一个文件描述符 int lfd = socket(); 将得到的监听的文件描述符和本地的IP 端口进行绑定 bind()
linux C - TCP数据接收和发送示例
m0_74282605的博客
03-01 485
3，以上，在Linux下分别gcc编译，先运行server程序，然后运行client程序，server端等待client的连接，一旦连接并完成数据发送，server关闭。4，示例程序的server只能连接一个client端，并且未进行数据收发的正确性验证。如果是在client中发送数据，只需将read修改为write即可。如果是在server端接收数据，只需将write修改为read即可。1.client端（读）2.server（发送）
Linux&C语言简单实现TCP客户端和服务器通信recv/ send-网络编程
qq_47355554的博客
05-12 1029
这里写目录标题TCP客户端和服务器通信流程字节序转换函数IP地址转换的函数：将套接字和网络信息结构体绑定bind代码实现01server.c02client.c执行结果![在这里插入图片描述](https://img-blog.csdnimg.cn/c5968c4e84154675b0e4cfd14345e744.png)6. 非原创 TCP客户端和服务器通信 基于C语言实现，TCP练习——用recv（ ）/ send（ ） 命令行输入指定IP、端口 流程 服务器： 1.创建流式套接字 socket
Linux网络编程之TCP文件传输
qq_53928256的博客
03-13 1987
客户端向服务端发送‘download test2.txt’指令，服务端收到‘download test2.txt’指令后，打印指令，并打开resource文件夹中中test2.txt文件，读取文件信息，打包成数据包发送到客户端；读取内容，发现内容为空，故不发送文件内容数据包。客户端向服务端发送‘download test3.txt’指令，服务端收到‘download test3.txt’指令后，打印指令，并打开resource文件夹中中test3.txt文件，读取内容与文件信息，打包成数据包发送到客户端。
Linux C/C++ 多线程TCP/UDP服务器 (监控系统状态)
chen1415886044的博客
02-19 2244
Linux环境中实现并发TCP/IP服务器。多线程在解决方案中提供了并发性。由于并发性，它允许多个客户端同时连接到服务器并与服务器交互。
Linux的tcp服务器连接的几种方式（线程、select、poll、epoll）
qq_57177980的博客
04-15 757
一连接一线程：在实际场景里，一万个连接可能就几个连接在收发数据，而剩下的的线程就处于等待状态，系统开销大且浪费。select：将需要处理的io集合拷贝进系统内核里遍历，然后将需要处理的io分成不同的集合返回。poll：poll和select的处理方式类似，但是相比select的接口更少。epoll：每当有一个io连接时就将其打包进系统内核，而系统内核只需要将需要事件处理的io返回即可，无需每次都将所有io集合拷贝进内核。（注意当io连接断开时，一定要将该io从内核中清除避免产生未知错误）
Linux下C语言编程（4）：TCP/IP 网络通信
张一西的博客
06-24 1387
Linux下C语言编程（4）：TCP/IP 网络通信
linux-网络编程应用分享
09-21
网络编程是指通过计算机网络进行数据传输和通信的编程技术，而在Linux环境下，TCP/UDP是常用的网络协议。本资源将深入讲解TCP/UDP网络编程的使用，解析每个相关函数的含义与用法，并通过实例展现，帮助读者更好地...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

浪游东戴河

你就是这个世界的唯一

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值