c语言linux网络编程
发表于：2022-03-14 |
字数统计: 1.9k | 阅读时长: 9分钟 | 阅读量：

[toc]

确定服务端和客户端

首先我是使用的虚拟机，

  1. 服务端为centos

    • 192.168.80.4 tcp 12345

    • 192.168.80.4 udp 1234

  2. 客户端为ubuntu

    • 192.168.80.16 tcp 12345
    • 192.168.80.16 udp 1234

开启相应的端口

我们要开启相应的服务端和客户端的端口，否则两者是无法进行通信的

  1. centos开启端口服务

    • firewall-cmd –zone=public –add-port=12345/tcp –permanent
    • firewall-cmd –zone=public –add-port=1234/udp –permanent

    开启后要重启防火墙，否则无法使用端口

    • firewall-cmd –reload
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
命令含义：

--zone #作用域

--add-port=12345/tcp #添加端口，格式为：端口/通讯协议

--permanent #永久生效，没有此参数重启后失效


systemctl status firewalld  检查防火墙状态
systemctl start firewalld  开启防火墙
systemctl stop firewalld.service  关闭防火墙

systemctl enable firewalld.service 设置开机启动防火墙

查看防火墙状态：
[root@centos7 ~]# firewall-cmd --state

查询有哪些端口是开启的：
[root@centos7 ~]# firewall-cmd --list-port

  1. 开启ubuntu的端口，否则同样无法进行通信

    • iptables -I INPUT -p tcp –dport 12345 -j ACCEPT
    • iptables -I INPUT -p udp –dport 1234 -j ACCEPT

    开启后同样需要保存规则

    • iptables-save
1
2
3
4
5
6
7
这样可以开放指定的端口，但是如果服务器重启，不会保存，所以我们需要对上述规则进行一下持续化操作

永久保存规则


netfilter-persistent save
netfilter-persistent reload

TCP

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
//tcp_server.c:

#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#define SERVER_PORT 12345


/*监听后，一直处于accept阻塞状态，直到有客户端连接，当客户端如数quit后，断开与客户端的连接*/
int main()
{
    int sock;
    //声明两个套接字sockaddr_in结构体变量，分别表示客户端和服务器
    struct sockaddr_in server_addr;
    struct sockaddr_in client_addr;
    int addr_len = sizeof(server_addr);
    int client;
    char buffer[1024];
    int DataNum;
    //socket函数，失败返回-1
    //int socket(int domain, int type, int protocol);
    //第一个参数表示使用的地址类型，一般都是ipv4，AF_INET
    //第二个参数表示套接字类型：tcp：面向连接的稳定数据传输SOCK_STREAM
    //第三个参数设置为0
    if((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        perror("socket");
        return 1;
    }
    bzero(&server_addr, sizeof(server_addr));
    //初始化服务器端的套接字，并用htons和htonl将端口和地址转成网络字节序
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(SERVER_PORT);
    //ip可以是本服务器的ip，也可以用宏INADDR_ANY代替，代表0.0.0.0，表明所有地址
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    //server_addr.sin_addr.s_addr = htonl("192.168.80.4");
    //对于bind，accept之类的函数，里面套接字参数都是需要强制转换成(struct sockaddr *)
    //bind三个参数：服务器端的套接字的文件描述符，
    if(bind(sock, (struct sockaddr *)&server_addr, addr_len) < 0)
    {
        perror("connect");
        return 1;
    }
    //设置服务器上的socket为监听状态
    if(listen(sock, 5) < 0)
    {
        perror("listen");
        return 1;
    }
    while(1)
    {
        printf("监听端口: %d\n", SERVER_PORT);
        //调用accept函数后，会进入阻塞状态
        //accept返回一个套接字的文件描述符，这样服务器端便有两个套接字的文件描述符，
        //sock和client。
        //sock仍然继续在监听状态，client则负责接收和发送数据
        //client_addr是一个传出参数，accept返回时，传出客户端的地址和端口号
        //addr_len是一个传入-传出参数，传入的是调用者提供的缓冲区的client_addr的长度，以避免缓冲区溢出。
        //传出的是客户端地址结构体的实际长度。
        //出错返回-1
        client = accept(sock, (struct sockaddr*)&client_addr, (socklen_t*)&addr_len);
        if(client < 0)
        {
            perror("accept");
            continue;
        }
        printf("等待消息...\n");
        //inet_ntoa ip地址转换函数，将网络字节序IP转换为点分十进制IP
        //表达式：char *inet_ntoa (struct in_addr);
        printf("IP is %s\n", inet_ntoa(client_addr.sin_addr));
        printf("Port is %d\n", htons(client_addr.sin_port));
        int n = 0;
        while(1)
        {
            DataNum = recv(client, buffer, 1024, 0);
            if(DataNum < 0)
            {
                perror("recv null");
                continue;
            }
            if(strcmp(buffer, "quit") == 0)
                break;
            printf("读取消息:%s\n",buffer);
            memset(buffer,0,sizeof(buffer));
        
            printf("发送消息:");
            fflush( stdout );
            n = read(0,buffer,1024);
            send(client, buffer, n, 0);
            printf("\n");
            if(strcmp(buffer, "quit") == 0)
                break;
        }
    }
    close(sock);
    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
//tcp_client.c:

#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#define SERVER_PORT 12345
/*连接到服务器后，会不停循环，等待输入，输入quit后，断开与服务器的连接*/
int main()
{
    //客户端只需要一个套接字文件描述符，用于和服务器通信
    int sock;

    //描述服务器的socket
    struct sockaddr_in server_addr;
    char buffer[1024];
    int DataNum;
    if((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        perror("socket");
        return 1;
    }
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(SERVER_PORT);

    //指定服务器端的ip，本地测试：127.0.0.1

    //inet_addr()函数，将点分十进制IP转换成网络字节序IP

    server_addr.sin_addr.s_addr = inet_addr("192.168.80.4");

    if(connect(sock, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0)
    {
        perror("connect");
        return 1;
    }
    int n = 0;
    while(1)
    {
        printf("发送消息:");
        fflush( stdout );
        n = read(0,buffer,1024);
        buffer[n++] = '\0';
        printf("\n");
        send(sock, buffer, n, 0);
        if(strcmp(buffer, "quit\n") == 0)
            break;
        memset(buffer,0,sizeof(buffer));
        DataNum = recv(sock, buffer, 1024, 0);
        printf("接收消息：%s\n", buffer);
        memset(buffer,0,sizeof(buffer));
    }
    close(sock);
    return 0;
}

UDP

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
/*udp_server.c*/
#include<stdio.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<string.h>
#include<unistd.h>
#include<netinet/in.h>
#include <arpa/inet.h>


//创建UDP实现服务器和客户端的通信

int main()
{
//创建socket连接
	int serfd=0;
	serfd=socket(AF_INET,SOCK_DGRAM,0);
	if(serfd<0)
	{
		perror("socke failed");
		return -1;
	}
	printf("socket success\n");
//绑定IP地址和端口信息
	int ret=0;
	struct sockaddr_in seraddr={0};
	seraddr.sin_family=AF_INET;
	seraddr.sin_addr.s_addr=inet_addr("192.168.80.4");
	seraddr.sin_port=htons(1234);
	
	ret=bind(serfd,(struct sockaddr *)&seraddr,sizeof(seraddr));
	if(ret<0)
	{
		perror("bind failed");
		close(serfd);
		return -1;
	}
	printf("bind success\n");
//接收发送自客户端的消息
while(1)
{
	int addrlen=0;
	char buf[1024]={0};
	struct sockaddr_in clientaddr={0};
	addrlen=sizeof(clientaddr);
	ret=recvfrom(serfd,buf,sizeof(buf),0,(struct sockaddr *)&clientaddr,&addrlen);
	if(ret<0)
	{
		perror("recvfrom failed");
		close(serfd);
		return -1;
	}
	printf("IP=%s,port=%u\n",inet_ntoa(clientaddr.sin_addr),ntohs(clientaddr.sin_port));
	printf("recvfrom success\n");
	printf("receive:  %s\n",buf);
//向客户端发送消息	
	memset(buf,0,sizeof(buf));
	gets(buf);
	ret=sendto(serfd,buf,strlen(buf),0,(struct sockaddr *)&clientaddr,addrlen);
	if(ret<0)
	{
		perror("sendto failed");
		close(serfd);
		return -1;
	}
	printf("sendto success\n");
}
	close(serfd);
	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
/*udp_client.c*/
#include<stdio.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<string.h>
#include<unistd.h>
#include<netinet/in.h>
#include <arpa/inet.h>


//创建UDP实现服务器和客户端的通信
//创建socket连接
int main()
{
//创建socket连接
	int clifd=0;
	clifd=socket(AF_INET,SOCK_DGRAM,0);
	if(clifd<0)
	{
		perror("socke failed");
		return -1;
	}
	printf("socket success\n");
//向服务器发送消息
while(1)
{
	int tolen=0;
	int ret=0;
	char buf[1024]={0};
	gets(buf);
	
	struct sockaddr_in seraddr={0};
	seraddr.sin_family=AF_INET;
	seraddr.sin_addr.s_addr=inet_addr("192.168.80.4");
	seraddr.sin_port=htons(1234);
	tolen=sizeof(seraddr);
	ret=sendto(clifd,buf,strlen(buf),0,(struct sockaddr *)&seraddr,tolen);
	if(ret<0)
	{
		perror("sendto failed");
		close(clifd);
		return -1;
	}
	printf("sendto success\n");
//接收发送自服务器的消息	
	ret=recvfrom(clifd,buf,sizeof(buf),0,NULL,NULL);
	if(ret<0)
	{
		perror("recvfrom failed");
		close(clifd);
		return -1;
	}
	printf("recvfrom success\n");
	printf("receive:  %s\n",buf);
}
	close(clifd);
	return 0;
}

总结

复习代码，忽略编译过程的警告即可

C语言
上一篇:
kd树和决策树
下一篇:
ctfshowweb终极考核
本文目录
本文目录
    •

    Copyright © 2019 - yangyang-linux | Powered by Hexo | Theme Bamboo

    本站总访问量： 次 |

    本博客已萌萌哒地运行