文章目录
一、HTTP协议
虽然我们说, 应用层协议是我们程序猿自己定的.
但实际上, 已经有大佬们定义了一些现成的, 又非常好用的应用层协议, 供我们直接参考使用. HTTP(超文本传输议)就是其中之一。
1.认识URL
平时我们俗称的 “网址” 其实就是说的 URL
2.urlencode和urldecode
像 / ? : 等这样的字符, 已经被url当做特殊意义理解了. 因此这些字符不能随意出现.
比如, 某个参数中需要带有这些特殊字符, 就必须先对特殊字符进行转义.
转义的规则如下:
将需要转码的字符转为16进制，然后从右到左，取4位(不足4位直接处理)，每2位做一位，前面加上%，编成%XY格式
“+” 被转义成了 “%2B”
urldecode就是urlencode的逆过程;
encode:对特殊符号和汉字编码为%XX
decode:服务器(软件)收到url请求–自己对特殊%XX进行解码
3.HTTP协议格式
HTTP请求
首行: [方法] + [url] + [版本]
Header: 请求的属性, 冒号分割的键值对;每组属性之间使用\n分隔;遇到空行表示Header部分结束
Body: 空行后面的内容都是Body. Body允许为空字符串. 如果Body存在, 则在Header中会有一个Content-Length属性来标识Body的长度;
HTTP响应
首行: [版本号] + [状态码] + [状态码解释]
Header: 请求的属性, 冒号分割的键值对;每组属性之间使用\n分隔;遇到空行表示Header部分结束
Body: 空行后面的内容都是Body. Body允许为空字符串. 如果Body存在, 则在Header中会有一个Content-Length属性来标识Body的长度; 如果服务器返回了一个html页面, 那么html页面内容就是在body中
状态码有200,400,302,307,500,404等等
状态码描述：404 -> Not Found 200 -> OK
1.请求和响应怎么保证应用层完整读取完毕了？
a.首先读取完整的一行
b.while(读取完整的一行)-所有的请求行+请求报头全部读完-直到空行
c.我们能保证把报头读完，报头有一个属性：Content-Length:XXX正文长度
d.解析出来内容长度，再根据内容长度，读取正文即可。
2.请求和响应是怎么做到序列化和反序列化的？
http自己实现的，第一行+请求/响应报头，只要按照\r\n将字符串1->n即可，正文则不需要做
响应的正文可以是html/css/js/图片/视频/音频等
4.HTTP的方法
其中最常用的就是GET方法和POST方法.
5.HTTP的状态码
最常见的状态码, 比如 200(OK), 404(Not Found), 403(Forbidden), 302(Redirect, 重定向), 504(Bad Gateway)
6.HTTP常见Header
Content-Type: 数据类型(text/html等)
Content-Length: Body的长度
Host: 客户端告知服务器, 所请求的资源是在哪个主机的哪个端口上;
User-Agent: 声明用户的操作系统和浏览器版本信息;
referer: 当前页面是从哪个页面跳转过来的;
location: 搭配3xx状态码使用, 告诉客户端接下来要去哪里访问;
Cookie: 用于在客户端存储少量信息. 通常用于实现会话(session)的功能;
7.重定向
我们使用手机或者浏览器的时候，屏幕什么也没有点，就跳转到了其他的页面，比如自动跳转到广告商等，这是通过重定向完成的。重定向分为临时重定向和永久重定向。
重定向过程：客户端向服务器发送http请求，服务器给客户端发送的http响应的状态码为3XX，附带一个新的url，然后客户端重新向新的服务器发起请求—临时重定向。假如一个公司的一个网站，因为各种原因(比如同时访问数量受限等)，所以重新写了一个网站，但是客户不知道新的网站链接，只知道老的链接，所以公司对老的链接进行永久重定向，客户在访问以前的网站的时候自动跳转到新的网站—永久重定向
8.长连接
其实我们看到的网页，实际上可能由多种元素构成，即一张完整的网页需要多次http请求
http网页中可能包含多个元素，如果频繁的发起http请求，http是基于TCP的，TCP是面向连接的，就会有频繁创建连接的问题(客户端和服务器都需要对连接进行管理，先描述再组织，会对连接创建对应的内核数据结构，对连接的管理就变成了对数据结构的管理，就会有时间和空间的成本)
所以就提出了长连接，长连接需要client和server都要支持，建立好一条连接，获取一份资源的时候，通过同一条连接来完成
Connection:Keep-alive --支持长连接
Connection:close --不支持长连接
9.会话保持
我们使用网页的bilibili的时候，我们登录一次之后，后面的一段时间都不需要我们重新进行登录了，关闭页面，然后重新点进去也不需要重新登录，这就是http的会话保持做到的
会话保持严格意义不是http天然具备的，而是后面使用发现需要的
http协议是无状态的，即http不关心上一次和下一次的请求，只负责当前请求的传输，但是用户需要，因为用户查看新的网页是常规操作，如果发送页面跳转，那么新的页面也就无法识别是哪一个用户了，为了让用户一经登录，可以在整个网站按照自己的身份进行随意访问，就需要会话保持。
我们看腾讯视频的时候，对于需要会员的视频，我们可以通过链接直接获取而不进行登录吗，答案是不行的，凡是对网页访问有权限要求的网页，在被获取之前，全部都要做判断，进行身份认证。
会话保持有两种方法：
第一种方案：我们在浏览器进行登录输入信息之后，浏览器会把我们用户输入的信息：用户名&&密码保持起来，这个被称为cookie数据。cookie分为cookie文件级数据和cookie内存级数据。往后只要访问同一个网站，浏览器就会自动推送历史保留信息给服务器
我们登录的时候，浏览器保存了cookie文件，每次请求账号密码都要进行推送，然后服务器再返回资源，但是这里有个问题，如果黑客在我们的电脑上种植了木马病毒，获取了我们的cookie文件，这样我们的账号密码就泄漏了，那么黑客使用他的浏览器登录我们的账号，此时服务器会误认为这个非法用户是你，如果是QQ，微信对我们就会造成很大的影响
第二种方案：我们进行登录的时候输入用户名和密码，此时服务器端会根据用户的信息形成一个session文件，它有唯一的名称：session id来进行唯一标识，然后将当前用户的session id返回给用户，此时浏览器的cookie文件中保存的是session id。此后用户发送http request 和session id给服务器，服务器根据session id进行鉴权，此时client保存了cookie，server保存了session。
如果黑客获取了用户的session，此时服务器还是会误认为这个非法用户是你，但是此时我们已经将矛盾转移了，此时黑客盗取的是公司的私密数据，有法律进行维护，此外还配合了其他的策略来缓解该类问题，比如我们在很短的时间内从一个地区到另一个地区，QQ就会提醒我们异地登录，需要重新进行登录等等
10.基本工具
这里介绍两个基本工具：postman 和 fiddler
postman不是抓包工具，而是一个模拟客户端—浏览器的行为的工具
fiddler是一个抓包工具，http工具
postman和fiddler的原理：
浏览器将请求发送给fiddler，此时fiddler可以作为代理服务器看待，然后就fiddler将请求转发给服务器，服务器响应的信息通过fiddler转发到用户的手中，而postman则就是相当于客户端向服务器发起请求
我们对下文的程序进行抓包：
我们可以看到，我们的账号和密码都是明文的，所以POST和GET都是不安全的，只有是否私密的区别，安全需要HTTPS来完成。
二、简单的HTTP服务器实现
1.err.hpp
#pragma once
enum
{
USAGE_ERR = 1,
SOCKET_ERR,
BIND_ERR,
LISTEN_ERR
};
2.log.hpp
#pragma once
#include <iostream>
#include <string>
#include <cstdarg>
#include <ctime>
#include <unistd.h>
#define DEBUG 0
#define NORMAL 1
#define WARNING 2
#define ERROR 3
#define FATAL 4
#define LOG_NORMAL "log.txt"
#define LOG_ERR "log.error"
#define NUM 1024
const char *to_levelstr(int level)
{
switch (level)
{
case DEBUG:
return "DEBUG";
case NORMAL:
return "NORMAL";
case WARNING:
return "WARNING";
case ERROR:
return "ERROR";
case FATAL:
return "FATAL";
default:
return nullptr;
}
}
void logMessage(int level, const char *format, ...)
{
char logprefix[NUM];
snprintf(logprefix, sizeof(logprefix), "[%s][%ld][pid: %d]",
to_levelstr(level), (long int)time(nullptr), getpid());
char logcontent[NUM];
va_list arg;
va_start(arg, format);
vsnprintf(logcontent, sizeof(logcontent), format, arg);
std::cout << logprefix << logcontent << std::endl;
FILE *log = fopen(LOG_NORMAL, "a");
FILE *error = fopen(LOG_ERR, "a");
if (log && error)
{
FILE *cur = nullptr;
if (level == DEBUG || level == NORMAL || level == WARNING)
cur = log;
if (level == ERROR || level == FATAL)
cur = error;
if (cur)
fprintf(cur, "%s%s\n", logprefix, logcontent);
fclose(log);
fclose(error);
}
}
3.procotol.hpp
#pragma once
#include <iostream>
#include <string>
#include <sstream>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include "Util.hpp"
const std::string sep = "\r\n";
const std::string default_root = "./wwwroot";
const std::string home_page = "index.html";
const std::string html_404 = "wwwroot/404.html";
class HttpRequest
{
public:
HttpRequest() {}
~HttpRequest() {}
public:
void parse()
{
// 1. 从inbuffer中拿到第一行，分隔符\r\n
std::string line = Util::getOneLine(inbuffer, sep);
if (line.empty())
return;
// 2. 从请求行中提取三个字段
// std::cout << "line: " << line << std::endl;
std::stringstream ss(line);
ss >> method >> url >> httpversion;
// 3. 添加web默认路径
path = default_root; // ./wwwroot,
path += url; //./wwwroot/a/b/c.html, ./wwwroot/
if (path[path.size() - 1] == '/')
path += home_page;
// 4.获取path对应资源的后缀
// ./wwwroot.index.html
// ./wwwroot.1.jpg
auto pos = path.rfind(".");
if (pos == std::string::npos)
suffix = ".html";
else
suffix = path.substr(pos);
// 5.得到资源的大小
struct stat st;
int n = stat(path.c_str(), &st);
if (n == 0)
size = st.st_size;
else
size = -1;
}
public:
std::string inbuffer;
std::string method;
std::string url;
std::string httpversion;
std::string path;
std::string suffix;
int size;
};
class HttpResponse
{
public:
std::string outbuffer;
};
4.Sock.hpp
#pragma once
#include <iostream>
#include <string>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "log.hpp"
#include "err.hpp"
static const int backlog = 5;
class Sock
{
public:
void Socket()
{
_listensock = socket(AF_INET, SOCK_STREAM, 0);
if (_listensock < 0)
{
logMessage(FATAL, "create socket error");
exit(SOCKET_ERR);
}
int opt = 1;
setsockopt(_listensock, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof opt);
logMessage(NORMAL, "create socket success");
}
void Bind(const uint16_t &port)
{
struct sockaddr_in local;
memset(&local, 0, sizeof local);
local.sin_family = AF_INET;
local.sin_addr.s_addr = INADDR_ANY;
local.sin_port = htons(port);
int n = bind(_listensock, (struct sockaddr *)&local, sizeof local);
if (n < 0)
{
logMessage(FATAL, "bind socket error");
exit(BIND_ERR);
}
logMessage(NORMAL, "bind socket success");
}
void Listen()
{
int n = listen(_listensock, backlog);
if (n < 0)
{
logMessage(FATAL, "listen socket error");
exit(LISTEN_ERR);
}
logMessage(NORMAL, "listen socket success");
}
int Accept()
{
struct sockaddr_in peer;
socklen_t len = sizeof(peer);
int sock = accept(_listensock, (struct sockaddr *)&peer, &len);
return sock;
}
int Fd()
{
return _listensock;
}
void Close()
{
if (_listensock > 0)
close(_listensock);
}
private:
int _listensock;
};
5.Util.hpp
#pragma once
#include <string>
#include <fstream>
class Util
{
public:
static std::string getOneLine(std::string &buffer, const std::string &sep)
{
auto pos = buffer.find(sep);
if (pos == std::string::npos)
return "";
std::string sub = buffer.substr(0, pos);
buffer.erase(0, sub.size() + sep.size());
return sub;
}
static bool readFile(const std::string resource, char *buffer, int size)
{
std::ifstream in(resource, std::ios::binary);
if (!in.is_open())
return false;
in.read(buffer, size);
in.close();
return true;
}
};
6.httpServer.hpp
#pragma once
#include <functional>
#include <sys/wait.h>
#include "Sock.hpp"
#include "protocol.hpp"
#include "log.hpp"
#include "err.hpp"
#include "Util.hpp"
namespace server
{
static const int defaultport = 8080;
using func_t = std::function<bool(const HttpRequest &, HttpResponse &)>;
class httpServer
{
public:
httpServer(const func_t func, const uint16_t &port = defaultport)
: _func(func), _port(port)
{
}
void initServer()
{
_sock.Socket();
_sock.Bind(_port);
_sock.Listen();
}
void handlerEvent(int sock)
{
// 1. 读到完整的http请求
// 2. 反序列化
// 3. httprequst, httpresponse, _func(req, resp)
// 4. resp序列化
// 5. send
char buffer[4096];
HttpRequest req;
HttpResponse resp;
size_t n = recv(sock, buffer, sizeof(buffer) - 1, 0);
if (n > 0)
{
buffer[n] = 0;
req.inbuffer = buffer;
req.parse();
_func(req, resp); // req -> resp
send(sock, resp.outbuffer.c_str(), resp.outbuffer.size(), 0);
}
}
void start()
{
for (;;)
{
int sock = _sock.Accept();
if (sock < 0)
continue;
pid_t id = fork();
if (id == 0)
{
_sock.Close();
if (fork() > 0)
exit(0);
handlerEvent(sock);
close(sock);
exit(0);
}
close(sock);
waitpid(id, nullptr, 0);
}
}
~httpServer()
{
}
private:
Sock _sock;
uint16_t _port;
func_t _func;
};
}
7.httpServer.cc
#include "httpServer.hpp"
#include <memory>
using namespace std;
using namespace server;
void Usage(std::string proc)
{
cerr << "Usage:\n\t" << proc << " port\r\n\r\n";
}
std::string suffixToDesc(const std::string suffix)
{
std::string ct = "Content-Type: ";
if (suffix == ".html")
ct += "text/html";
else if (suffix == ".jpg")
ct += "application/x-jpg";
ct += "\r\n";
return ct;
}
// 1. 服务器和网页分离，html
// 2. url -> / : web根目录
bool Get(const HttpRequest &req, HttpResponse &resp)
{
// for test
cout << "----------------------http start---------------------------" << endl;
cout << req.inbuffer;
std::cout << "method: " << req.method << std::endl;
std::cout << "url: " << req.url << std::endl;
std::cout << "httpversion: " << req.httpversion << std::endl;
std::cout << "path: " << req.path << std::endl;
std::cout << "suffix: " << req.suffix << std::endl;
std::cout << "size: " << req.size << "字节" << std::endl;
cout << "----------------------http end---------------------------" << endl;
// std::string respline = "HTTP/1.1 200 OK\r\n";
std::string respline = "HTTP/1.1 307 Permanent Redirect\r\n";
std::string respheader = suffixToDesc(req.suffix);
respheader += "Location: https://www.qq.com/\r\n";
std::string respblank = "\r\n";
// std::string body = "<html lang=\"en\"><head><meta charset=\"UTF-8\"><title>for test</title><h1>hello world</h1></head><body><p>多情只有春庭月，犹为离人照落花</p></body></html>";
std::string body;
body.resize(req.size + 1);
if (!Util::readFile(req.path, (char *)body.c_str(), req.size))
{
Util::readFile(html_404, (char *)body.c_str(), req.size);
}
respheader += "Content-Length: ";
respheader += to_string(body.size());
respheader += "\r\n";
resp.outbuffer += respline;
resp.outbuffer += respheader;
resp.outbuffer += respblank;
cout << "----------------------http response start---------------------------" << endl;
std::cout << "resp.outbuffer" << resp.outbuffer << std::endl;
cout << "----------------------http response end---------------------------" << endl;
resp.outbuffer += body;
return true;
}
// ./httpServer port
int main(int argc, char *argv[])
{
// if(argc != 2)
// {
// Usage(argv[0]);
// exit(0);
// }
// uint16_t port = atoi(argv[1]);
// unique_ptr<httpServer> httpsvr(new httpServer(Get, port));
unique_ptr<httpServer> httpsvr(new httpServer(Get));
httpsvr->initServer();
httpsvr->start();
return 0;
}
8.总结分析
一个用户看到的网页结果，可能是多个资源结合而成的，所以要获取一个网页效果，我们的浏览器一定会 发起多次http请求。
我们进行数据提交的时候，本质前端要通过form表单提交的，浏览器会自动将form表单中的内容转换成GET/POST方法请求
GET和POST的区别
如下是GET的方式
如下是POST的方式
二者的区别如下：
GET通过URL传递参数，具体：http://ip:port/XXX/YYY?name=value&name1=value1
POST提交参数通过http请求的正文提交参数
POST方法通过正文的提交参数，所以一般用户看不到，私密性更好，私密性 != 安全性，GET方法不私密
无论是GET还是POST方法，都不安全，要谈安全，必须加密 --https
通过URL传递参数，注定了不能太大
但是POST方法，通过正文，正文可以很大，甚至可以是其他的东西
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
