实验四 Web服务器1-socket编程

实验四 Web服务器1-socket编程

基于华为鲲鹏云服务器CentOS中（或Ubuntu），使用Linux Socket实现：

  1. time服务器的客户端服务器，提交程序运行截图
  1. echo服务器的客户端服务器，提交程序运行截图，服务器把客户端传进来的内容加入“服务器进程pid 你的学号 姓名 echo :”返回给客户端
  1. 服务器部署到华为云服务器，客户端用Ubuntu虚拟机。
  1. 要用多线程或者多进程实现,至少连接两个客户端。
  1. 把服务器部署到试验箱。（加分项）

服务器server代码：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include<unistd.h>
#include<errno.h>
#include<pthread.h>
#include <time.h>

#define MAXCONN 2
#define ERRORCODE -1
#define BUFFSIZE 1024
int count_connect = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
struct pthread_socket
{
	int socket_d;
	pthread_t thrd;
};

struct sockaddr_in sockaddr; //定义IP地址结构

struct sockaddr_in accept_sockaddr; //定义accept IP地址结构
socklen_t addrlen = sizeof(accept_sockaddr);

static void* thread_recv(void *arg1)
{
	char buf[BUFFSIZE];
	struct pthread_socket *pt = (struct pthread_socket *) arg1;
	int sd = pt->socket_d;
	pthread_t thrd = pt->thrd;
    time_t clock;
    time(&clock);
	while (1)
	{
		memset(buf, 0, sizeof(buf));
		int rv = recv(sd, buf, sizeof(buf), 0); //是阻塞的
		if (rv < 0)
		{
			printf("recv error:%s \n", strerror(errno));
			break;
        }
        if (rv == 0) // 这种情况说明client已经关闭socket连接
        {
            break;
        }
        printf("echo服务器端接受来自客户端 %s 的内容:%s",inet_ntoa(accept_sockaddr.sin_addr), buf); //输出接受到内容
            char buf1[BUFFSIZE];
            sprintf(buf1,"姓名：20191317王鹏宇  echo服务器进程PID：%d  消息：%s\n当前时间：%s",getpid(),buf,ctime(&clock));
        send(sd, buf1, strlen(buf1), 0);
    }
    	pthread_cancel(thrd);
    	pthread_mutex_lock(&mutex);
    	count_connect--;
    	pthread_mutex_unlock(&mutex);
    	close(sd);
    	return NULL;
}
 
static int create_listen(int port)
{
 
    	int listen_st;
    	
    	int on = 1;
    	listen_st = socket(AF_INET, SOCK_STREAM, 0); //初始化socket
    	if (listen_st == -1)
    	{
        	printf("socket create error:%s \n", strerror(errno));
        	return ERRORCODE;
    	}
    	if (setsockopt(listen_st, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) == -1) //设置ip地址可重用
    	{
        	printf("setsockopt error:%s \n", strerror(errno));
        	return ERRORCODE;
    	}
    	sockaddr.sin_port = htons(port); //指定一个端口号并将hosts字节型传化成Inet型字节型（大端或或者小端问题）
    	sockaddr.sin_family = AF_INET;    //设置结构类型为TCP/IP
    	sockaddr.sin_addr.s_addr = htonl(INADDR_ANY);    //服务端是等待别人来连，不需要找谁的ip
    	//这里写一个长量INADDR_ANY表示server上所有ip，这个一个server可能有多个ip地址，因为可能有多块网卡
    	if (bind(listen_st, (struct sockaddr *) &sockaddr, sizeof(sockaddr)) == -1)
    	{
       		printf("bind error:%s \n", strerror(errno));
        	return ERRORCODE;
    	}
 
    	if (listen(listen_st, 5) == -1) //     服务端开始监听
    	{
        	printf("listen error:%s \n", strerror(errno));
        	return ERRORCODE;
    	}
    	return listen_st;
}
int run_server(int port)
{
    	int listen_st = create_listen(port);    //创建监听socket
    	pthread_t send_thrd, recv_thrd;
    	struct pthread_socket ps;
    	int accept_st;
    	memset(&accept_sockaddr, 0, addrlen);

    	if (listen_st == -1)
    	{
        	return ERRORCODE;
    	}
    	printf("server start \n");
      
	    
    	while (1)
    	{
        	
    	    accept_st = accept(listen_st, (struct sockaddr*) &accept_sockaddr,&addrlen);
    	    //accept 会阻塞直到客户端连接连过来 服务端这个socket只负责listen 是不是有客服端连接过来了
    	    //是通过accept返回socket通信的
    	    if (accept_st == -1)
    	    {
        	    printf("accept error:%s \n", strerror(errno));
        	    return ERRORCODE;
    	    }
            send(*(int *) &accept_st, "hello,welcome to you! \n", strlen("hello,welcome to you! \n"), 0);

        	if (count_connect >= MAXCONN)
        	{
            		printf("connect have already be full! \n");
            		close(accept_st);
            		continue;
        	}
        	pthread_mutex_lock(&mutex);
        	count_connect++;
        	pthread_mutex_unlock(&mutex);
            ps.socket_d = accept_st;
        	if (pthread_create(&recv_thrd, NULL, thread_recv, &ps) != 0)//创建接收信息线程
        	{
            		printf("create thread error:%s \n", strerror(errno));
            		break;
        	}
        	pthread_detach(recv_thrd); //设置线程为可分离，这样的话，就不用pthread_join
    	}
    close(accept_st);
    close(listen_st);
    return 0;
}
//server main
int main(int argc, char *argv[])
{
    	if (argc < 2)
    	{
        	printf("Usage:port,example:8080 \n");
        	return -1;
    	}
    	int port = atoi(argv[1]);
    	if (port == 0)
    	{
        	printf("port error! \n");
    	} 
	else
    	{
        	run_server(port);
    	}
    return 0;
}

客户端client代码：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include<unistd.h>
#include<errno.h>
#include<pthread.h>
 
#define BUFFSIZE 1024
#define ERRORCODE -1
 
static void *thread_send(void *arg)
{
	char buf[BUFFSIZE];
	int sd = *(int *) arg;
	while (1)
	{
		memset(buf, 0, sizeof(buf));
        //printf("客户端向服务器端发送内容：");
        
		read(STDIN_FILENO, buf, sizeof(buf));
		if (send(sd, buf, strlen(buf), 0) == -1)
		{
			printf("send error:%s \n", strerror(errno));
			break;
		}
	}
	return NULL;
}
static void *thread_recv(void *arg)
{
	char buf[BUFFSIZE];
	int sd = *(int *) arg;
	while (1)
	{
		memset(buf, 0, sizeof(buf));
		int rv = recv(sd, buf, sizeof(buf), 0);
		if (rv <= 0)
		{
			if(rv == 0) //server socket关闭情况
			{
				printf("server have already full !\n");
				exit(0);//退出整个客服端
			}
		    printf("recv error:%s \n", strerror(errno));
		    break;
		}
		printf("\n客户端受到来自服务器端发送的内容：\n%s", buf);//输出接收到的内容
	}	
	return NULL;
}
int run_client(char *ip_str, int port)
{
	int client_sd;
	int con_rv;
	pthread_t thrd1, thrd2;
	struct sockaddr_in client_sockaddr; //定义IP地址结构
	client_sd = socket(AF_INET, SOCK_STREAM, 0);
	if (client_sd == -1)
	{
		printf("socket create error:%s \n", strerror(errno));
		return ERRORCODE;
	}
	memset(&client_sockaddr, 0, sizeof(client_sockaddr));
	client_sockaddr.sin_port = htons(port); //指定一个端口号并将hosts字节型传化成Inet型字节型（大端或或者小端问题）
	client_sockaddr.sin_family = AF_INET; //设置结构类型为TCP/IP
	client_sockaddr.sin_addr.s_addr = inet_addr(ip_str);//将字符串的ip地址转换成int型,客服端要连接的ip地址
	con_rv = connect(client_sd, (struct sockaddr*) &client_sockaddr,
	sizeof(client_sockaddr));
	//调用connect连接到指定的ip地址和端口号,建立连接后通过socket描述符通信
	if (con_rv == -1)
	{
		printf("connect error:%s \n", strerror(errno));
		return ERRORCODE;
	}
	if (pthread_create(&thrd1, NULL, thread_send, &client_sd) != 0)
	{
		printf("thread error:%s \n", strerror(errno));
		return ERRORCODE;
	}
	if (pthread_create(&thrd2, NULL, thread_recv, &client_sd) != 0)
	{
		printf("thread error:%s \n", strerror(errno));
		return ERRORCODE;
	}
	pthread_join(thrd2, NULL);// 等待线程退出
	pthread_join(thrd1, NULL);
	close(client_sd);
	return 0;
}
int main(int argc, char *argv[])
{
	if (argc < 3)
	{
		printf("Usage:ip port,example:127.0.0.1 8080 \n");
		return ERRORCODE;
	}
	int port = atoi(argv[2]);
	char *ip_str = argv[1];
	run_client(ip_str,port);
	return 0;
}

将服务器部署到腾讯云服务器，因为华为云太贵了买不起，但是同样腾讯云也是centos

客户端向服务器发送信息，服务器收到后加上学号姓名将其返回以及进程号，服务器支持多线程，可以多个客户端同时连接

将服务器部署到实验箱

由于没有实验箱，这里使用树莓派进行代替，都是arm64架构

服务器启动

客户端启动

客户端收到服务器的回复

服务器收到客户端的消息
posted @ 2021-12-11 14:13  Bzrael  阅读(205)  评论(0)  编辑  收藏  举报