^-^
后端技术_http服务器的实现
最近更新：2024-09-23   |   字数总计：1k   |   阅读估时：5分钟   |   阅读量：次
  1. 使用浏览器直接访问reactor框架得到Http报文
  2. http服务器实现
    1. KV封装（用于存储http头）
    2. 改写send及recv回调
    3. response & request
  3. http服务器总结
    1. http服务器最最基础必须具备功能
    2. 该版本缺陷

使用浏览器直接访问reactor框架得到Http报文

1
2
3
4
5
6
7
8
9
10
listen port: 8000
clientfd: 5
rbuffer: GET / HTTP/1.1
Host: ***.***.***.***:8000
Connection: keep-alive
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36 Edg/121.0.0.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6

http服务器实现

KV封装（用于存储http头）

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
// reactor_http.c
##define KEY_MAX_LENGTH 128
##define VALUE_MAX_LENGTH 512
##define MAX_KEY_COUNT 128

typedef struct zv_kvpair_s
{
	char key[KEY_MAX_LENGTH]; // 整块分配，放置频繁malloc产生大量碎片
	char value[KEY_MAX_LENGTH];
} zv_kvpair_t;

typedef struct zv_kvstore_s
{
	struct zv_kvpair_s *table;
	int maxpairs;
	int numpairs;
} zv_kvstore_t;

int init_kvpair(zv_kvstore_t *kvstore)
{
	if (!kvstore)
		return -1;
	kvstore->table = calloc(MAX_KEY_COUNT, sizeof(zv_kvpair_t));
	if (!kvstore->table)
		return -2;
	kvstore->maxpairs = MAX_KEY_COUNT;
	kvstore->numpairs = 0;
}

int put_kvpair(zv_kvstore_t *kvstore, const char *key, const char *val)
{
	if (!kvstore || !kvstore->table || !key || !val)
		return -1;

	// 考虑线程安全
	// lock
	strncpy(kvstore->table[kvstore->numpairs].key, key, KEY_MAX_LENGTH);
	strncpy(kvstore->table[kvstore->numpairs].value, val, VALUE_MAX_LENGTH);

	kvstore->numpairs++;
	// unlock

	return 0;
}

char *get_kvpair(zv_kvstore_t *kvstore, const char *key)
{
	int i = 0;
	for (i = 0; i < kvstore->numpairs; i++)
	{
		if (strcmp(kvstore->table[kvstore->numpairs].key, key) == 0)
		{
			return kvstore->table[kvstore->numpairs].value;
		}
	}
	return NULL;
}

int dest_kvpair(zv_kvstore_t *kvstore)
{
	if (!kvstore)
		return -1;
	if (kvstore->table)
		free(kvstore->table);
	return 0;
}

改写send及recv回调

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

typedef struct zv_connect_s
{
	int fd;

	ZVCALLBACK cb;

	char rbuffer[BUFFER_LENGTH]; // channel
	int rc;
	int count;
	char wbuffer[BUFFER_LENGTH]; // channel
	int wc;

	char resource[BUFFER_LENGTH];  // 增加请求资源存储
	int enable_sendfile; // 是否启用sendfile

	struct zv_kvstore_s *kvheader; // 存储http头信息

} zv_connect_t;

int send_cb(int fd, int event, void *arg)
{

	// printf("send_cb\n");

	zv_reactor_t *reactor = (zv_reactor_t *)arg;
	zv_connect_t *conn = zv_connect_idx(reactor, fd);

	// 处理response
	zv_http_response(conn);

	send(fd, conn->wbuffer, conn->wc, 0);

	if (conn->enable_sendfile)
	{
		// 使用sendfile方式时，发送完头再发送body
		// int out_fd, int in_fd, off_t *offset, size_t count
		// *** DMA机制，实现0拷贝
		int filefd = open(conn->resource, O_RDONLY);
		if (filefd == -1)
		{
			printf("open file %s failed!\n", conn->resource);
			return -1;
		}
		struct stat stat_buf;
		fstat(filefd, &stat_buf);
		int ret = sendfile(fd, filefd, NULL, stat_buf.st_size);
		if (ret == -1)
		{
			printf("errno: %d\n", errno);
		}
		close(filefd);
	}

	conn->cb = recv_cb;

	//
	struct epoll_event ev;
	ev.events = EPOLLIN; //
	ev.data.fd = fd;
	epoll_ctl(reactor->epfd, EPOLL_CTL_MOD, fd, &ev);
}

int recv_cb(int fd, int event, void *arg)
{

	zv_reactor_t *reactor = (zv_reactor_t *)arg;
	zv_connect_t *conn = zv_connect_idx(reactor, fd);

	int ret = recv(fd, conn->rbuffer + conn->rc, conn->count, 0);
	if (ret < 0)
	{
	}
	else if (ret == 0)
	{

		//
		conn->fd = -1;
		conn->rc = 0;
		conn->wc = 0;

		//
		epoll_ctl(reactor->epfd, EPOLL_CTL_DEL, fd, NULL);

		close(fd);

		return -1;
	}
	else
	{
		conn->rc += ret;
		printf("rbuffer: %s, ret: %d\n", conn->rbuffer, conn->rc);

		// echo功能
		// memcpy(conn->wbuffer, conn->rbuffer, conn->rc);
		// conn->wc = conn->rc;

		// 处理http请求
		zv_http_request(conn);

		conn->cb = send_cb;

		//
		struct epoll_event ev;
		ev.events = EPOLLOUT;
		ev.data.fd = fd;
		epoll_ctl(reactor->epfd, EPOLL_CTL_MOD, fd, &ev);
	}
}

response & request

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
// 工具函数
int readline(char *allbuf, int idx, char *linebuf)
{
	int len = strlen(allbuf);

	for (; idx < len; idx++)
	{
		if (allbuf[idx] == '\r' && allbuf[idx + 1] == '\n')
			return idx + 2;
		else
			*(linebuf++) = allbuf[idx];
	}
	return -1;
}

##define HTTP_WEB_ROOT "/home/ubuntu/server_test/2_4_http/resource"

int zv_http_response(zv_connect_t *conn)
{
	printf("response resource: %s\n", conn->resource);

	int filefd = open(conn->resource, O_RDONLY);
	if (filefd == -1)
	{
		printf("open file %s failed!\n", conn->resource);
		return -1;
	}

	// fseed(, SEEK_END)
	struct stat stat_buf;
	fstat(filefd, &stat_buf);

	int len = sprintf(conn->wbuffer,
					  "HTTP/1.1 200 OK\r\n"
					  "Accept-Ranges: bytes\r\n"
					  "Content-Length: %ld\r\n"
					  "Content-Type: text/html\r\n"   // 返回png时，这里需要image/png
					  "Date: Sat, 06 Aug 2022 13:16:46 GMT\r\n\r\n",
					  stat_buf.st_size);

	if (!conn->enable_sendfile)
	{ // 使用buffer方式发送，把文件内容读进buffer再发送
		len += read(filefd, conn->wbuffer + len, BUFFER_LENGTH - len);
	}
	else
	{ // 使用sendfile方式发送，先发头，再发body
	}

	conn->wc = len;

	close(filefd);
}

int zv_http_request(zv_connect_t *conn)
{
	printf("http --> request:\n %s \n", conn->rbuffer);
	char linebuffer[1024] = {0};

	int idx = readline(conn->rbuffer, 0, linebuffer);

	printf("line: %s\n", linebuffer);

	if (strstr(linebuffer, "GET"))
	{
		// GET / HTTP/1.1
		int i = 0;
		while (linebuffer[sizeof("GET ") + i] != ' ')
			i++;
		linebuffer[sizeof("GET ") + i] = '\0'; // 去掉后面的内容

		// printf("resource: %s\n", linebuffer + 4); // GET 是协议固定的
		sprintf(conn->resource, "%s/%s", HTTP_WEB_ROOT, linebuffer + sizeof("GET "));
		conn->enable_sendfile = 1;
	}
	memset(linebuffer, 0, 1024);
	while((idx = readline(conn->rbuffer, idx, linebuffer)) != -1)
	{
		char *key = linebuffer;
		int i = 0;
		while(key[i++] != ':');
		key[i] = '\0';
		char *value = linebuffer + i + 1;
		put_kvpair(conn->kvheader, key, value);
		printf("key : %s, value : %s\n" , key, value);
		memset(linebuffer, 0, 1024);
	}
}

http服务器总结

http服务器最最基础必须具备功能

  1. reactor作为网络基础封装
  2. 处理response和request
  3. 测并发量
  4. 至少需要能够正确返回html及png格式
  5. 对http header处理（KV存储）

该版本缺陷

  • 存在大量预先分配的整块内存，如何进行内存管理？（内存池）
2024-01-27 该篇文章被 Cleofwine 归为分类: 服务端

上一篇：后端技术_Reactor总结与优化策略 下一篇：音视频开发_FFmpeg QT 播放器实现
© 2023-2026 Cleofwine / Email / GitHub / 浙ICP备2024136127号
🌙赠我弯弯一枚月，也赠予我晚星⭐ 本站由Hexo驱动｜使用Hexo-theme-A4主题