Lesson11:http协议

前言 

• 应用层:就是程序员基于socket接口之上编写的具体逻辑,做了很多工作,都是和文本处理有关的--- 协议分析与处理
• http协议,一定会具有大量的文体分析和协议处理

---

 

•  如果用户想再url中包含url本身用来作为特殊字符的字符,url形式的时候,浏览器会自动给我们进行编码encode
• 一般服务端收到之后,需要进行转回特殊字符 

快速构建http请求和响应的报文格式 

HttpServer.cc

#include 
#include 
#include 
#include 
#include 
#include 
#include 

#include "HttpServer.hpp"
#include "Usage.hpp"
#include "Util.hpp"

// 一般http都要有自己的web根目录
#define ROOT "./wwwroot" // ./wwwroot/index.html
// 如果客户端只请求了一个/,我们返回默认首页
#define HOMEPAGE "index.html"

void HandlerHttpRequest(int sockfd)
{
    // 1. 读取请求 for test
    char buffer[10240];
    ssize_t s = recv(sockfd, buffer, sizeof(buffer) - 1, 0);
    if (s > 0)
    {
        buffer[s] = 0;
        // std::cout << buffer << "--------------------\n" << std::endl;
    }

    std::vector vline;
    Util::cutString(buffer, "\n", &vline);

    std::vector vblock;
    Util::cutString(vline[0], " ", &vblock);// 拿到请求行

    std::string file = vblock[1];// cilent想要的文件名
    std::string target = ROOT;

    if(file == "/") file = "/index.html";
    target += file;
    std::cout << target << std::endl;

    // 打开这个文件,再从这个文件中拿数据
    std::string content;
    std::ifstream in(target);
    if(in.is_open())
    {
        std::string line;
        while(std::getline(in, line))
        {
            content += line;
        }
        in.close();
    }

    std::string HttpResponse;
    if(content.empty()) {
        HttpResponse = "HTTP/1.1 404 NotFound\r\n";
    }
    else {
        HttpResponse = "HTTP/1.1 200 OK\r\n";
    }
    HttpResponse += "\r\n";
    HttpResponse += content;
    
    // 2. 试着构建一个http的响应
    send(sockfd, HttpResponse.c_str(), HttpResponse.size(), 0);
}

int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        Usage(argv[0]);
        exit(0);
    }
    std::unique_ptr httpserver(new HttpServer(atoi(argv[1]), HandlerHttpRequest));
    httpserver->Start();
    return 0;
}

HttpServer.hpp

#pragma once

#include 
#include 
#include 
#include "Sock.hpp"

class HttpServer
{
public:
    using func_t = std::function;// 包装器->函数
private:
    int listensock_;// 监听
    uint16_t port_;
    Sock sock;// 套接字
    func_t func_;
public:
    HttpServer(const uint16_t &port, func_t func): port_(port),func_(func)
    {
        listensock_ = sock.Socket();
        sock.Bind(listensock_, port_);// 绑定
        sock.Listen(listensock_);// 监听
    }
    void Start()
    {
        signal(SIGCHLD, SIG_IGN);// 解决父进程需要进程等待的问题
        for( ; ; )
        {
            std::string clientIp;
            uint16_t clientPort = 0;
            int sockfd = sock.Accept(listensock_, &clientIp, &clientPort);
            if(sockfd < 0) continue;
            if(fork() == 0)
            {
                close(listensock_);
                func_(sockfd);
                close(sockfd);
                exit(0);
            }
            close(sockfd);
        }
    }
    ~HttpServer()
    {
        if(listensock_ >= 0) close(listensock_);
    }
};

Log.hpp

#pragma once

#include 
#include 
#include 
#include 
#include 

// 日志是有日志级别的
#define DEBUG   0
#define NORMAL  1
#define WARNING 2
#define ERROR   3
#define FATAL   4

const char *gLevelMap[] = {
    "DEBUG",
    "NORMAL",
    "WARNING",
    "ERROR",
    "FATAL"
};

#define LOGFILE "./calculator.log"

// 完整的日志功能，至少: 日志等级 时间 支持用户自定义(日志内容, 文件行，文件名)
void logMessage(int level, const char *format, ...)
{
#ifndef DEBUG_SHOW
    if(level== DEBUG) return;
#endif
    char stdBuffer[1024]; //标准部分
    time_t timestamp = time(nullptr);
    snprintf(stdBuffer, sizeof stdBuffer, "[%s] [%ld] ", gLevelMap[level], timestamp);

    char logBuffer[1024]; //自定义部分
    va_list args;
    va_start(args, format);
    vsnprintf(logBuffer, sizeof logBuffer, format, args);
    va_end(args);

    FILE *fp = fopen(LOGFILE, "a");
    fprintf(fp, "%s%s\n", stdBuffer, logBuffer);
    fclose(fp);
}

makefile

HttpServer:HttpServer.cc
	g++ -o $@ $^ -std=c++11 -lpthread

.PHONY:clean
clean:
	rm -f HttpServer

Sock.hpp 

#pragma once

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "Log.hpp"

class Sock
{
private:
    const static int gbacklog = 20;

public:
    Sock() {}
    // 创建套接字
    int Socket()
    {
        int listensock = socket(AF_INET, SOCK_STREAM, 0);
        if (listensock < 0)
        {
            logMessage(FATAL, "create socket error, %d:%s", errno, strerror(errno));
            exit(2);
        }
        logMessage(NORMAL, "create socket success, listensock: %d", listensock);
        return listensock;
    }
    // 绑定
    void Bind(int sock, uint16_t port, std::string ip = "0.0.0.0")
    {
        struct sockaddr_in local;
        memset(&local, 0, sizeof local);
        local.sin_family = AF_INET;
        local.sin_port = htons(port);
        inet_pton(AF_INET, ip.c_str(), &local.sin_addr);
        if (bind(sock, (struct sockaddr *)&local, sizeof(local)) < 0)
        {
            logMessage(FATAL, "bind error, %d:%s", errno, strerror(errno));
            exit(3);
        }
    }
    // 监听
    void Listen(int sock)
    {
        if (listen(sock, gbacklog) < 0)
        {
            logMessage(FATAL, "listen error, %d:%s", errno, strerror(errno));
            exit(4);
        }

        logMessage(NORMAL, "init server success");
    }
    // 一般经验
    // const std::string &: 输入型参数
    // std::string *: 输出型参数
    // std::string &: 输入输出型参数
    int Accept(int listensock, std::string *ip, uint16_t *port)
    {
        struct sockaddr_in src;
        socklen_t len = sizeof(src);
        int servicesock = accept(listensock, (struct sockaddr *)&src, &len);
        if (servicesock < 0)
        {
            logMessage(ERROR, "accept error, %d:%s", errno, strerror(errno));// 转移
            return -1;
        }
        if(port) *port = ntohs(src.sin_port);
        if(ip) *ip = inet_ntoa(src.sin_addr);
        return servicesock;
    }
    // 连接
    bool Connect(int sock, const std::string &server_ip, const uint16_t &server_port)
    {
        struct sockaddr_in server;
        memset(&server, 0, sizeof(server));
        server.sin_family = AF_INET;
        server.sin_port = htons(server_port);
        server.sin_addr.s_addr = inet_addr(server_ip.c_str());

        if(connect(sock, (struct sockaddr*)&server, sizeof(server)) == 0) return true;
        else return false;
    }
    ~Sock() {}
};

Usage.hpp

#pragma once

#include 
#include 

void Usage(std::string proc)
{
    std::cout << "\nUsage: " << proc <<  " port\n" << std::endl;
}

Util.hpp

#pragma once

#include 
#include 

class Util
{
public:
    // aaaa\r\nbbbbb\r\nccc\r\n\r\n
    // 按sep分割符,分割字符
    static void cutString(std::string s, const std::string &sep, std::vector *out)
    {
        std::size_t start = 0;
        while (start < s.size())
        {
            auto pos = s.find(sep, start);
            if (pos == std::string::npos) break;
            std::string sub = s.substr(start, pos - start);
            // std::cout << "----" << sub << std::endl;
            out->push_back(sub);
            start += sub.size();
            start += sep.size();
        }
        if(start < s.size()) {
            out->push_back(s.substr(start));
        }
    }
};

HTTP协议格式

HTTP请求

•  get方法通过url传参,回显输入的私密信息,不够私密
• post方法通过正文提交参数,不会回显,一般私密性是有保证的
• 注: 私密性不是安全,加密和解密才是安全
• Connection: keep-alive 长连接
• Connection:close 短连接

 HTTP响应

HTTP的状态码

 

•  301是永久重定向,302和307是临时重定向

会话管理 

•  http的特征:1.简单快速,2.无连接,3.无状态
• 虽然http没有状态,但是tpc套接字是有状态的
•  在我们使用网站并登上账号的时候,cookie会记录我们的信息,并通过算法形成唯一的ID

HTTPS协议介绍 

•  HTTPS实际就是在应用层和传输层协议之间加了一层加密层（SSL&TLS），
• 这层加密层本身也是属于应用层的，它会对用户的个人信息进行各种程度的加密。
• HTTPS在交付数据时先把数据交给加密层，由加密层对数据加密后再交给传输层。

 对称加密 vs 非对称加密

• 采用单钥密码系统的加密方法，同一个密钥可以同时用作信息的加密和解密，这种加密方法称为对称加密。
• 采用公钥和私钥来进行加密和解密，用其中一个密钥进行加密就必须用另一个密钥进行解密，这种加密方法称为非对称加密

各种加密方案 

 

 

MITL攻击 

 

 CA证书

当服务端申请CA证书的时候,CA机构会对该服务器进行审核,并专门为该网站形成数字签名,过程如下 

1. CA机构拥有非对称加密的私钥A和公钥A`
2. CA机构对服务端申请的证书明文数据进行hash,形成数据摘要
3. 然后对数据摘要用CA私钥A`加密,得到数字签名S

 非对称加密 + 对称加密 + CA认证