HTTP服务器
图片来源于网络，侵删。
前言
实现一个http 服务器项目，服务器启动后监听80端口的tcp 连接，当用户通过任意一款浏览器（IE、火狐和腾讯浏览器等）访问我们的http服务器，http服务器会查找用户访问的html页面是否存在，如果存在则通过http 协议响应客户端的请求，把页面返回给浏览器，浏览器显示html页面；如果页面不存在，则通知浏览器此页面不存在（404 NOT FOUND）
什么是HTML
全称Hypertext Markup Language，也就是"超文本链接标示语言"。HTML文本是由HTML命令组成的描述性文本。
HTTP协议
HTTP协议是Hyper Text Transfer Protocol(超文本传输协议)的缩写,是用于从万维网(WWW:World Wide Web ) 服务器传输超文本到本地浏览器的传送协议。
客户端发起请求
客户端发送一个HTTP请求到服务器的请求消息包括以下格式：请求行（request line）、请求头部（header）、空行和请求数据四个部分组成，下图给出了请求报文的一般格式。
示例:
GET /demo.html HTTP/1.1
Host: 12.120.162.171
Connection: keep-alive
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.26 Safari/537.36 Core/1.63.6788.400 QQBrowser/10.3.2767.400
Upgrade-Insecure-Requests: 1
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie:cna=BT0+EoVi1FACAXH3Nv5I7h6k;isg=BIOD99I03BNYvZDfE2FJUOsMB0ftUBZcBFi4E7VgYOJZdKOWPcvRinAl6kSfVG8y服务端响应
服务器响应客户端的HTTP请求也由四个部分组成:状态行、消息报头、空行和响应正文。
示例:
HTTP/1.0 200 OK
Server: ZYX Server
Content-Type: text/html
Connection: Close
Content-Length: 526
xxx
Mini HTTP服务器
执行流程
接收http请求——>解析http请求——>响应http请求
main.c
#include "minihttp.h"
#include <pthread.h>
int main(void) {
int sock;
struct sockaddr_in server_addr;
sock = socket(AF_INET, SOCK_STREAM, 0);
bzero(&server_addr, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
server_addr.sin_port = htons(SERVER_PORT);
bind(sock, (struct sockaddr*)&server_addr, sizeof(server_addr));
listen(sock, 128);
printf("Wait conecting......\n");
int done = 1;
while (done) {
struct sockaddr_in client;
int client_socket;
int len;
char client_ip[64];
char buf[256];
pthread_t id;//存储线程id
int* pclient_sock = NULL;
socklen_t client_addr_len;
client_addr_len = sizeof(client);
client_socket = accept(sock, (struct sockaddr*)&client, &client_addr_len);
printf("client address:%s\tport:%d\n", inet_ntop(AF_INET, &client.sin_addr.s_addr, client_ip, sizeof(client_ip)), ntohs(client.sin_port));
//处理Http请求，读取客户端发来的数据
//do_http_request(client_socket);
//启动线程，处理HTTP请求
pclient_sock = (int*)malloc(sizeof(int));
*pclient_sock = client_socket;
pthread_create(&id,NULL,do_http_request,(void*)pclient_sock);
}
close(sock);
return 0;
}minihttp.h
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <ctype.h>
#include <arpa/inet.h>
#include <errno.h>
#include <sys/stat.h>
#define SERVER_PORT 80 //端口
static int debug = 1;
//处理请求的每行数据
//返回值:-1读取出错，=0表示读到空行，>0表示成功读取。
int get_line(int sock, char* buf, int size);
//读取客户端发来的http请求
void* do_http_request(void* client_sock);
//根据请求返回内容
void do_http_response(int client_sock, const char* path);
//响应404
void not_found(int client_sock);
//返回请求头
int headers(int client_sock,FILE* resource);
//发送html文件中的内容
void cat(int client_sock,FILE* resource);
//服务器内部错误500
void iner_error(int client_sock);
//响应未定义的请求
void unimplemented(int client_sock); minihttp.c
#include "minihttp.h"
int get_line(int sock, char* buf, int size) {
int count = 0;
char ch = '\0';
int len = 0;
while ((count < size - 1) && ch != '\n') {
len = read(sock,&ch,1);
if (len == 1) {
if (ch == '\r') {
continue;
} else if (ch == '\n') {
break;//读取完毕
}
//这里处理一般的字符
buf[count] = ch;
count++;
} else if(len == -1){//读取出错
perror("read failed!");
count = -1;
break;
} else {//返回0——客户端关闭socket链接
fprintf(stderr,"clinet close\n");
count = -1;
break;
}
}
if (count >= 0) {
buf[count] = '\0';//添加字符串结束符
}
return count;
}
void* do_http_request(void* pclient_sock){
int len = 0;
char buf[256];
char method[64];
char url[256];
char path[256];
int client_sock = *(int*)pclient_sock;
struct stat st;
//读取请求行
len = get_line(client_sock, buf, sizeof(buf));
if (len > 0) {//读到了请求行数(第一行)
int i = 0;
int j = 0;
while (!isspace(buf[j]) && i <sizeof(method)-1) {
method[i] = buf[j];
i++;
j++;
}
method[i] = '\0';
printf("request method:%s\n",method);
if (strncasecmp(method, "GET", i) == 0) {//只处理get请求
if (debug) {
printf("method = GET\n");
}
//获取url
while (isspace(buf[j++])) {//跳过空格
i = 0;
}
while (!isspace(buf[j]) && i < sizeof(url) - 1) {
url[i] = buf[j];
i++;
j++;
}
url[i] = '\0';
if (debug) {
printf("url:%s\n", url);
}
//继续读取http头部
do
{
len = get_line(client_sock, buf, sizeof(buf));
if(debug){
printf("read:%s\n",buf);
}
} while (len>0);
//定位服务器本地的html文件
//处理url中的？，过滤掉？后面的内容
{
char* pos = strchr(url, '?');
if (pos) {
*pos = '\0';
printf("real url:%s\n",url);
}
}
sprintf(path,"./html_docs/%s",url);
if (debug) {
printf("path:%s\n", path);
}
//get请求服务端回复
//判断文件是否存在，如果存在就相应200 OK，同时发送相应的html文件
//如果不存在就相应404 not found
if (stat(path, &st) == -1) {//文件不存在或者出错
fprintf(stderr,"stat %s failed,reason:%s\n",path,strerror(errno));
not_found(client_sock);
} else {//文件存在
if (S_ISDIR(st.st_mode)) {//如果是目录,添加默认网页
strcat(path,"/index.html");
}
do_http_response(client_sock,path);
}
} else {//非get请求，读取http头部，并相应客户端501
fprintf(stderr,"warning! other rquest [%s]\n",method);
do
{
len = get_line(client_sock, buf, sizeof(buf));
} while (len>0);
unimplemented(client_sock);
}
} else {//请求格式有问题，出错处理。
not_found(client_sock);
}
close(client_sock);
if (pclient_sock) {
free(pclient_sock);
}
return NULL;
}
void do_http_response(int client_sock, const char* path) {
int ret = 0;
FILE *resource = NULL;
resource = fopen(path,"r");
if (resource == NULL) {
not_found(client_sock);
return;
}
//发送http头部
ret = headers(client_sock, resource);
if (!ret) {
//成功发送头部后
//发送http body
cat(client_sock, resource);
}
fclose(resource);
}
void not_found(int client_sock){
const char* reply = "HTTP/1.0 404 NOT FOUND\r\n\
Content - Type: text / html\r\n\
\r\n\
<HTML>\r\n\
<HEAD>\r\n\
<TITLE>NOT FOUND</TITLE>\r\n\
</HEAD>\r\n\
<BODY>\r\n\
<P>The server could not fulfill your request because the resource specified is unavailable or nonexistent.\r\n\
</BODY>\r\n\
</HTML>\r\n";
int len = write(client_sock,reply,strlen(reply));
if (len <= 0) {
fprintf(stderr,"send reply failed,reason:%s\n",strerror(errno));
}
//if (debug) {
// fprintf(stdout,reply);
//}
}
int headers(int client_sock, FILE* resource) {
struct stat st;
int fileid = 0;
char tmp[128];
char buf[1024] = { 0 };
strcpy(buf, "HTTP/1.0 200 OK\r\n");
strcat(buf, "Server: XUANXUAN Server\r\n");
strcat(buf, "Content-Type:text/html\r\n");
strcat(buf, "Connection: Close\r\n");
fileid = fileno(resource); //拿到文件fd——文件描述符
if (fstat(fileid, &st) == -1) {
iner_error(client_sock);
return -1;//失败
}
sprintf(tmp, "Content-Length:%ld\r\n\r\n", st.st_size);
strcat(buf, tmp);
if (debug) {
fprintf(stdout, "header:%s\n", buf);
}
if (send(client_sock, buf, strlen(buf), 0) < 0) {//如果发送失败
fprintf(stderr, "send failed.data:%s,reason:%s\n", buf, strerror(errno));
return -1;
}
return 0;
}
void cat(int client_sock, FILE* resource) {
char buf[1024];
fgets(buf,sizeof(buf),resource);
//没有到达文件尾部就一直读
while (!feof(resource)) {
int len = write(client_sock, buf, strlen(buf));
if (len < 0) {//发送body的过程中出现问题
fprintf(stderr,"send body error. reason:%s\n",strerror(errno));
break;
}
if (debug) {
fprintf(stdout,"%s",buf);
}
fgets(buf, sizeof(buf), resource);
}
}
void iner_error(int client_sock) {
const char* reply = "HTTP/1.0 500 Internal Sever Error\r\n\
Content - Type: text / html\r\n\
\r\n\
<HTML>\
<HEAD>\
<TITLE>inner_error</TITLE>\
</HEAD>\
<BODY>\
<P>Error prohibited CGI execution.\
</BODY>\
</HTML>";
int len = write(client_sock, reply, strlen(reply));
if (len <= 0) {
fprintf(stderr, "send reply failed,reason:%s\n", strerror(errno));
}
/*if (debug) {
fprintf(stdout, reply);
}*/
}
void unimplemented(int client_sock) {
const char* reply = "HTTP/1.0 404 NOT FOUND\r\n\
Content - Type: text / html\r\n\
\r\n\
<HTML>\r\n\
<HEAD>\r\n\
<TITLE>NO Implemented</TITLE>\r\n\
</HEAD>\r\n\
<BODY>\r\n\
<P>The server could not fulfill your request because the resource specified is unavailable or nonexistent.\r\n\
</BODY>\r\n\
</HTML>\r\n";
int len = write(client_sock, reply, strlen(reply));
if (len <= 0) {
fprintf(stderr, "send reply failed,reason:%s\n", strerror(errno));
}
}
并发
什么是并发?
通俗的并发通常是指同时能并行的处理多个任务。程序同时拥有两个或多个线程，如果程序在单核处理器上运行，多个线程将交替的换入或者换出内存，这些线程是同时"存在"的。同一时间点上，只能有一个线程执行。
每个线程都处于执行中的某个状态，如果运行在多核处理器上，此时，程序中的每个线程都将分配到一个处理器核上，因此可以同时运行。
高并发
高并发是互联网分布式系统架构设计中必须考虑的因素之一，它通常是指，通过设计保证系统能够 同时并行处理很多请求。
注意:
编译时记得加声明 -pthread
gcc minihttp.c main.c -pthread -o minihttp连不上记得使用root用户执行。
