菜鸟追梦旅行

这个屌丝很懒，什么也没留下！

热门标签

linux 网络编程_linux网络编程

作者：菜鸟追梦旅行 | 2024-05-27 11:37:58

踩

linux网络编程

一. 网络编程概述

1. 概述

网络通信手段的一种，我们在之前学了进程间通信，包括管道、消息队列、共享内存、信号和信号量，这些通信方式有一个共同的特点，就是他们都是在依赖Linux内核在单机上进行进程的通信，而面对多机之间的通信，这些手段就远远不够了。所以我们引入网络，利用网络来实现多机之间的通信。

多机通信有好多例子，比如Linux服务器和Adroid、 IOS、C51、x86的Linux之间的通信。既然谈到网络编程，就一定需要地址，包括IP地址和端口号。IP地址用来标识一台设备，端口号用来标识一台设备上的进程。除了这个，还需要协议来作为支撑，包括TCP、UDP和HTTP协议等，协议作为一种规则，约定了通信双方的数据格式，就好比两个人必须都用中文才能听懂对方说话。

我们在这里主要用到的是Socket网络编程，也叫套接字网络编程，主要用到TCP和UDP协议。

2. TCP/UDP

1、TCP面向连接(如打电话要先拨号建立连接) ;UDP是无连接的，即发送数据之前不需要建立连接
2、TCP提供可靠的服务。也就是说，通过TCP连接传送的数据，无差错，不丢失，不重复，且按序到达;UDP尽最大努力交付，即不保证可靠交付
3、TCP面向字节流，实际上是TCP把数据看成一连串无结构的字节流;UDP是面向报文的UDP没有拥塞控制，因此网络出现拥塞不会使源主机的发送速率降低(对实时应用很有用，如IP电话，实时视频会议等)
4、每一条TCP连接只能是点到点的;UDP支持一对一，一对多，多对一和多对多的交互通信
5、TCP首部开销20字节;UDP的首部开销小，只有8个字节
6、TCP的逻辑通信信道是全双工的可靠信道，UDP则是不可靠信道

3. 端口号作用

一台拥有IP地址的主机可以提供许多服务，比如Web服务、FTP服务、SMTP服务等。

这些服务完全可以通过1个IP地址来实现。那么，主机是怎样区分不同的网络服务呢？显然不能只靠IP地址，因为IP 地址与网络服务的关系是一对多的关系。

实际上是通过“IP地址+端口号”来区分不同的服务的。端口提供了一种访问通道，服务器一般都是通过知名端口号来识别的。例如，对于每个TCP/IP实现来说，FTP服务器的TCP端口号都是21，每个Telnet服务器的TCP端口号都是23，每个TFTP(简单文件传送协议)服务器的UDP端口号都是69。3000以下的端口号一般是操作系统所使用的，用户一般使用5000到9000的端口号。

二. 字节序

字节序是指多字节数据在计算机内存中存储或者网络传输时各字节的存储顺序。
字节序分为小端字节序和大端字节序：

Little endian：将低序字节存储在起始地址
Big endian：将高序字节存储在起始地址

在这里插入图片描述
TCP/IP协议规定，网络数据流应采用大端字节序

为使网络程序具有可移植性，使同样的C代码在大端和小端计算机上编译后都能正常运行，可以调用以下库函数做网络字节序和主机字节序的转换:

#include <arpa/inet.h>
 
uint32_t htonl(uint32_t hostlong);
uint16_t htons(uint16_t hostshort);
uint32_t ntohl(uint32_t netlong);
uint16_t ntohs(uint16_t netshort);
//h表示host，n表示network，l表示32位长整数，s表示16位短整数。
//如果主机是小端字节序，这些函数将参数做相应的大小端转换然后返回，如果主机是大端字节序，这些函数不做转换，将参数原封不动地返回。
1
2
3
4
5
6
7
8

注意，网络字节序指的是大端字节序。

三. socket编程步骤

1. 创建套接字—socket()
2. 为套接字添加信息（IP地址和端口号）—bind()
3. 监听网络连接—listen()
4. 监听到有客户端接入，接受一个连接—accept()
5. 数据交互
6. 关闭套接字，断开连接

四. linux提供的API简析

1. 连接协议

int socket(int domain, int type, int protocol);
(1)domain:通常是AF_INET，指IPV4因特网域
(2)type:指定socket类型，SOCK_STREAM它使用TCP协议，SOCK_DGRAM使用UDP协议
(3)protocol:0默认选择type对应的协议
创建失败返回-1.
1
2
3
4
5

在这里插入图片描述

2. 连接地址

int bind(int sockfd, const struct sockaddr *maddr,socklen_t addrlen);
(1)sockfd:网络标识符
(2)struct sockaddr_in{
     sa_family_t sin_family;  //指定AF_***，表示使用什么协议族的ip格式
     in_port_in      sin_port;   //设置端口号
     struct in_addr  sin_addr;   //设置ip
     unsigned char sin_zero[8];
};
(3)结构体大小
1
2
3
4
5
6
7
8
9

在这里插入图片描述
其中：struct in_addr sin_addr; //设置ip 中struct in_addr结构体：

3. 地址转换API

把字符串形式的“192.168.1.123”转为网络能识别的格式：

int inet_aton(const char* straddr,struct in_addr *addrp);
1

网络格式的ip地址转为字符串形式：

char* inet_ntoa(struct in_addr inaddr); 
1

4. 监听

int listen(int sockfd,int backlog)

(1)sockfd:网络连接号
(2)backlog:指定请求队列中同时最大请求数 
1
2
3
4

在这里插入图片描述

5. 连接

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

(1)网络连接号
(2)客户端地址，NULL
(3)客户端地址长度,NULL（指针） 返回值是新建立的通道。
1
2
3
4
5

6. 数据收发

在这里插入图片描述

7. 客户端的connect函数

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

(1)目的服务器端口号
(2)服务器的IP地址和端口号的结构体
(3)地址长度
1
2
3
4
5

五. socket服务端编程

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

int main()
{
        int s_fd;

        //1.socket
        //int socket(int domain, int type, int protocol);
        /*
        int socket(int domain, int type, int protocol);
		(1)domain:通常是AF_INET，指IPV4因特网域
		(2)type:指定socket类型，SOCK_STREAM它使用TCP协议，SOCK_DGRAM使用UDP协议
		(3)protocol:0默认选择type对应的协议
		创建失败返回-1.
		*/
        s_fd = socket(AF_INET,SOCK_STREAM,0);
        if(s_fd == -1){
                perror("socket");
                exit(-1);
        }
		/*
		int bind(int sockfd, const struct sockaddr *maddr,socklen_t addrlen);
		(1)sockfd:网络标识符
		(2)struct sockaddr_in{
		     sa_family_t sin_family;  //指定AF_***，表示使用什么协议族的ip格式
		     in_port_in      sin_port;   //设置端口号
		     struct in_addr  sin_addr;   //设置ip
		     unsigned char sin_zero[8];
		};
		(3)结构体大小	
		*/
        struct sockaddr_in s_addr;
        s_addr.sin_family = AF_INET;
        s_addr.sin_port = htons(8989);
        //把字符串形式的“192.168.1.123”转为网络能识别的格式
        //int inet_aton(const char* straddr,struct in_addr *addrp);
        inet_aton("192.168.239.135",&s_addr.sin_addr);//ben ji

        //2.bind
        //int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
        bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));

        //3.listen
        /*
		int listen(int sockfd,int backlog)
		(1)sockfd:网络连接号
		(2)backlog:指定请求队列中同时最大请求数
		*/
        //int listen(int sockfd, int backlog);  
        listen(s_fd,10);

        //4.accept
        /*
        int accept(int sockfd,struct sockaddr *addr,socklen_t addrlen)
		(1)网络连接号
		(2)客户端地址，NULL
		(3)客户端地址长度,NULL（指针） 返回值是新建立的通道。
		*/
        //int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
        int c_fd = accept(s_fd,NULL,NULL);

        //5.read

        //6.write
        printf("connect!\n");
        while(1);
        return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

其中： inet_aton("192.168.239.135",&s_addr.sin_addr);中的192.168.239.135–另开端口使用指令查询：ifconfig
在这里插入图片描述
使用window的命令行窗口telnet 192.168.239.135 8989

已经成功连接！！！

//server.c
#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
//#include <linux/in.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

//int socket(int domain, int type, int protocol);
//int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
//int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

int main()
{
        int s_fd;
        int n_read;
        char readBuf[128];

        char *msg = "I get your message";
        struct sockaddr_in s_addr;
        struct sockaddr_in c_addr;

        memset(&s_addr,0,sizeof(struct sockaddr_in));
        memset(&c_addr,0,sizeof(struct sockaddr_in));

        //1.socket
        //1.创建套接字---socket()
        /*
        int socket(int domain, int type, int protocol);
		(1)domain:通常是AF_INET，指IPV4因特网域
		(2)type:指定socket类型，SOCK_STREAM它使用TCP协议，SOCK_DGRAM使用UDP协议
		(3)protocol:0默认选择type对应的协议
		创建失败返回-1.
		*/
        s_fd = socket(AF_INET, SOCK_STREAM,0);
        if(s_fd == -1){
                perror("socket");
                exit(-1);
        }
        s_addr.sin_family = AF_INET;//
        s_addr.sin_port = htons(8988);//转换大端字节序  //8988端口号
        inet_aton("192.168.3.250",&s_addr.sin_addr);//字符串格式转换为网络格式
        //2.bind
        //2.为套接字添加信息（IP地址和端口号）---bind()
        /*
		int bind(int sockfd, const struct sockaddr *maddr,socklen_t addrlen);
		(1)sockfd:网络标识符
		(2)struct sockaddr_in{
		     sa_family_t sin_family;  //指定AF_***，表示使用什么协议族的ip格式
		     in_port_in      sin_port;   //设置端口号
		     struct in_addr  sin_addr;   //设置ip
		     unsigned char sin_zero[8];
		};
		(3)结构体大小	
		*/
        bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));
        //3. listen
        //3.监听网络连接---listen()
        /*
		int listen(int sockfd,int backlog)
		(1)sockfd:网络连接号
		(2)backlog:指定请求队列中同时最大请求数
		*/
        listen(s_fd,10);//监听
        //4.accept
        //4.监听到有客户端接入，接受一个连接---accept()
         /*
        int accept(int sockfd,struct sockaddr *addr,socklen_t addrlen)
		(1)网络连接号
		(2)客户端地址，NULL
		(3)客户端地址长度,NULL（指针） 返回值是新建立的通道。
		*/
        int clen = sizeof(struct sockaddr_in);
        int c_fd = accept(s_fd,(struct sockaddr *)&c_addr,&clen);//
        if(c_fd == -1){
                perror("accept");
        }
        printf("get connect :%s\n",inet_ntoa(c_addr.sin_addr));//网络格式转换为字符串格式
        //5.read
        //5.数据交互
        n_read = read(c_fd,readBuf,128);
        if(n_read == -1 ){
                perror("read");
        }else{
                printf("get message:%d,%s\n",n_read,readBuf);
        }
        
        //6.write
        //数据交互
        write(c_fd,msg,strlen(msg));

        return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

运行结果：
在这里插入图片描述

六. socket客户端代码实现

//client.c
#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
//#include <linux/in.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

int main()
{
        int c_fd;
        int n_read;
        char readBuf[128];

        char *msg = "message from client";
        struct sockaddr_in c_addr;

        memset(&c_addr,0,sizeof(struct sockaddr_in));

        //1.socket
         //1.创建套接字---socket()
        /*
        int socket(int domain, int type, int protocol);
		(1)domain:通常是AF_INET，指IPV4因特网域
		(2)type:指定socket类型，SOCK_STREAM它使用TCP协议，SOCK_DGRAM使用UDP协议
		(3)protocol:0默认选择type对应的协议
		创建失败返回-1.
		*/
        c_fd = socket(AF_INET, SOCK_STREAM,0);
        if(c_fd == -1){
                perror("socket");
                exit(-1);
        }

        c_addr.sin_family = AF_INET;//
        c_addr.sin_port = htons(8988);//zhuanhua daduanzijiexu  //duankouhao
        inet_aton("192.168.3.250",&c_addr.sin_addr);
        //2.connect
        /*
        connect(int sockfd,const struct sockaddr *addr,socklen_t addrlen)
		(1)目的服务器端口号
		(2)服务器的IP地址和端口号的结构体
		(3)地址长度
		*/
        if(connect(c_fd,(struct sockaddr *)&c_addr,sizeof(struct sockaddr)) == -1){
                perror("connect");
                exit(-1);
        }

        //3.send
        write(c_fd,msg,strlen(msg));

        //4.read
        n_read = read(c_fd,readBuf,128);
        if(n_read == -1 ){
                perror("read");
        }else{
                printf("get message from :%d,%s\n",n_read,readBuf);
        }

        return 0;
}
//与server.c相互配合
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

在这里插入图片描述

七. 实现双方聊天

首先实现服务器不退出操作

############################## serve.c ##################################
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
//#include <linux/in.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>
#include <unistd.h>

int main(int argc,char **argv)
{
        int s_fd;
        int c_fd;
        int n_read;
        char readBuf[128];

        char *msg = "I get your message!";

        struct sockaddr_in s_addr;
        struct sockaddr_in c_addr;

        memset(&s_addr,0,sizeof(struct sockaddr_in));
        memset(&c_addr,0,sizeof(struct sockaddr_in));

        //1.socket
        //int socket(int domain, int type, int protocol);
        s_fd = socket(AF_INET,SOCK_STREAM,0);
        if(s_fd == -1){
                perror("socket");
                exit(-1);
        }

        s_addr.sin_family = AF_INET;
        s_addr.sin_port = htons(atoi(argv[2]));
        //int inet_aton(const char* straddr,struct in_addr *addrp);
        inet_aton(argv[1],&s_addr.sin_addr);//ben ji
        //2.bind
        //int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
        bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));

        //3.listen
        //int listen(int sockfd, int backlog);  
        listen(s_fd,10);

        //4.accept
        int clen = sizeof(struct sockaddr_in);
        while(1){
                //int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
                c_fd = accept(s_fd,(struct sockaddr *)&c_addr,&clen);
                if(c_fd == -1){
                        perror("accept");
                }

                //char* inet_ntoa(struct in_addr inaddr); 
                printf("get connect:%s\n",inet_ntoa(c_addr.sin_addr));

                if(fork() == 0){

                        //5.read
                        //ssize_t read(int fd, void *buf, size_t count);
                        n_read = read(c_fd,readBuf,128);
                        if(n_read == -1){
                                perror("read");
                        }else{
                                printf("get message:%d,%s\n",n_read,readBuf);
                        }
                        //6.write
                        //ssize_t write(int fd, const void *buf, size_t count);
                        write(c_fd,msg,strlen(msg));
                        break;
                }
        }
        return 0;
}

################################### client.c ####################################
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
//#include <linux/in.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>
#include <unistd.h>

int main(int argc,char **argv)
{
        int c_fd;
        int n_read;
        char readBuf[128];

        char *msg = "msg from client!";

        struct sockaddr_in c_addr;

        memset(&c_addr,0,sizeof(struct sockaddr_in));

        //1.socket
        //int socket(int domain, int type, int protocol);
        c_fd = socket(AF_INET,SOCK_STREAM,0);
        if(c_fd == -1){
                perror("socket");
                exit(-1);
        }

        c_addr.sin_family = AF_INET;
        c_addr.sin_port = htons(atoi(argv[2]));
        //int inet_aton(const char* straddr,struct in_addr *addrp);
        inet_aton(argv[1],&c_addr.sin_addr);//ben ji

        //2.connect
        //int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen)
        if(connect(c_fd,(struct sockaddr *)&c_addr,sizeof(struct sockaddr_in)) == -1){
                perror("connect");
                exit(-1);
        }

        //3.send
        //ssize_t write(int fd, const void *buf, size_t count);
        write(c_fd,msg,strlen(msg));

        //4.read
        //ssize_t read(int fd, void *buf, size_t count);
        n_read = read(c_fd,readBuf,128);
        if(n_read == -1){
                perror("read");
        }else{
                printf("get message from server:%d,%s\n",n_read,readBuf);
        }

        printf("connect!\n");
        return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

在这里插入图片描述
可见，服务端一直不退出，一直在接受消息！！！

//server.c
#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
//#include <linux/in.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

//int socket(int domain, int type, int protocol);
//int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
//int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

int main(int argc,char **argv)
{
        int s_fd;
        int c_fd;
        int n_read;
        char readBuf[128];

//      char *msg = "I get your message";
        char msg[128] = {0};
        struct sockaddr_in s_addr;
        struct sockaddr_in c_addr;

        if(argc != 3){
                printf("param is not good\n");
                exit(-1);
        }

        memset(&s_addr,0,sizeof(struct sockaddr_in));
        memset(&c_addr,0,sizeof(struct sockaddr_in));
        //1.socket
        s_fd = socket(AF_INET, SOCK_STREAM,0);
        if(s_fd == -1){
                perror("socket");
                exit(-1);
        }

        s_addr.sin_family = AF_INET;//
        s_addr.sin_port = htons(atoi(argv[2]));//zhuanhua daduanzijiexu  //duankouhao
        inet_aton(argv[1],&s_addr.sin_addr);

        //2.bind
        bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));

        //3. listen
        listen(s_fd,10);//jianting 10ge 
 //4.accept
        int clen = sizeof(struct sockaddr_in);
        while(1){

                c_fd = accept(s_fd,(struct sockaddr *)&c_addr,&clen);//
                if(c_fd == -1){
                        perror("accept");
                }

                printf("get connect :%s\n",inet_ntoa(c_addr.sin_addr));//wangluo zhaunhua  zifuchuan

                if(fork() == 0){//zijincheng

                        if(fork() == 0){
                                while(1){
                                        memset(msg,0,sizeof(msg));
                                        printf("input: ");
                                        gets(msg);
                                        //6.write
                                        write(c_fd,msg,strlen(msg));
                                        }
                                }
                        //5.read
                        while(1){
                                memset(readBuf,0,sizeof(readBuf));
                                n_read = read(c_fd,readBuf,128);
                                if(n_read == -1 ){
                                        perror("read");
                                }else{
                                        printf("get message:%d,%s\n",n_read,readBuf);
                                }
                        }
                        break;
                }
        }
        return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

//client.c
#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
//#include <linux/in.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

//int socket(int domain, int type, int protocol);
//int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
//int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

int main(int argc,char **argv)
{
        int c_fd;
        int n_read;
        char readBuf[128];

        //      char *msg = "message from client";
        char msg[128] = {0};

        struct sockaddr_in c_addr;
        if(argc != 3){
                printf("param is not good\n");
                exit(-1);
        }
        memset(&c_addr,0,sizeof(struct sockaddr_in));

        //1.socket
        c_fd = socket(AF_INET, SOCK_STREAM,0);
        if(c_fd == -1){
                perror("socket");
                exit(-1);
        }
 		c_addr.sin_family = AF_INET;//
        c_addr.sin_port = htons(atoi(argv[2]));//zhuanhua daduanzijiexu  //duankouhao
        inet_aton(argv[1],&c_addr.sin_addr);

        //2.connect
        if(connect(c_fd,(struct sockaddr *)&c_addr,sizeof(struct sockaddr)) == -1){
                perror("connect");
                exit(-1);
        }
		while(1){

                if(fork() == 0 ){
                        while(1){
                                memset(msg,0,sizeof(msg));
                                printf("input: ");
                                gets(msg);
                                //3.send
                                write(c_fd,msg,strlen(msg));
                        }
                }
                while(1){
                        memset(readBuf,0,sizeof(readBuf));
                        //4.read
                        n_read = read(c_fd,readBuf,128);
                        if(n_read == -1 ){
                                perror("read");
                        }else{
                                printf("get message from :%d,%s\n",n_read,readBuf);
                        }
                }
        }


        return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

在这里插入图片描述
双方开始沟通交流！！！

八. 多方信息收发

实现了服务端和客户端双方的聊天，但是我们遇到一个问题，就是当我们多开一个客户端的时候，客户端可以给服务端发消息，但是服务端给客户端发消息的时候，就会产生不确定的情况。就是当有多个客户端访问服务端的时候，服务端不知道把消息发送给谁，其无法解决精准的一对一的通信问题，经过一番研究发现，其实不是因为服务端无法对接客户端进程的问题，而是因为服务端输入发送内容时的光标无法解析发给谁的问题，下面对服务端代码做了一些改进，验证了能够实现服务端和客户端能够一对一精准通信的问题。

//server.c
#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
//#include <linux/in.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

//int socket(int domain, int type, int protocol);
//int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
//int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

int main(int argc,char **argv)
{
        int s_fd;
        int c_fd;
        int n_read;
        char readBuf[128];
		int mark = 0;
//      char *msg = "I get your message";
        char msg[128] = {0};
        struct sockaddr_in s_addr;
        struct sockaddr_in c_addr;

        if(argc != 3){
                printf("param is not good\n");
                exit(-1);
        }

        memset(&s_addr,0,sizeof(struct sockaddr_in));
        memset(&c_addr,0,sizeof(struct sockaddr_in));
        //1.socket
        s_fd = socket(AF_INET, SOCK_STREAM,0);
        if(s_fd == -1){
                perror("socket");
                exit(-1);
        }

        s_addr.sin_family = AF_INET;//
        s_addr.sin_port = htons(atoi(argv[2]));//zhuanhua daduanzijiexu  //duankouhao
        inet_aton(argv[1],&s_addr.sin_addr);

        //2.bind
        bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));

        //3. listen
        listen(s_fd,10);//jianting 10ge 
 //4.accept
        int clen = sizeof(struct sockaddr_in);
        while(1){

                c_fd = accept(s_fd,(struct sockaddr *)&c_addr,&clen);//
                if(c_fd == -1){
                        perror("accept");
                }
				mark ++;
                printf("get connect :%s\n",inet_ntoa(c_addr.sin_addr));//wangluo zhaunhua  zifuchuan

                if(fork() == 0){//zijincheng

                        if(fork() == 0){
                                while(1){
                                        memset(msg,0,sizeof(msg));
                              			sprintf(msg,"Welcome NO.%d client",mark);
                                        //6.write
                                        write(c_fd,msg,strlen(msg));
                                        sleep(3);
                                        }
                                }
                        //5.read
                        while(1){
                                memset(readBuf,0,sizeof(readBuf));
                                n_read = read(c_fd,readBuf,128);
                                if(n_read == -1 ){
                                        perror("read");
                                }else{
                                        printf("get message:%d,%s\n",n_read,readBuf);
                                }
                        }
                        break;
                }
        }
        return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

九. 搭建服务器存取文件

客户端：
1.获取服务器文件 get xxx 功能2.0
2.展示服务器有哪些文件 ls 功能1.0
3.进入服务器文件夹 cd xx 功能3.0
4.上传文件到服务器 put xx 功能4.0
本地：
1.lls 查看客户端本地文件功能5.0
2.lcd 进入客户端文件夹功能5.0

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/631725