HTTP协议

url

HTTP和HTTPS的作用

既然获取的是文件资源, C/C++又提供了文件打开读取等功能.

那么获取文件资源的过程其实就是, 接收到请求之后 根据提供的文件路径文件名找到文件, 然后打开.

打开之后, 读取文件内容, 再将文件内容响应回客户端就可以了

urlencode和urldecode

1. 针对ASCII码表中的符号, 可以直接转换成16进制, 然后从右到左，取4位(不足4位直接处理)，每2位当作1位，前面加上%，编码成%XY格式
2. 针对非ASCII码表中的符号、文字等, 先 其它规则进行编码 再对其他规则的编码16进制结果的每字节数据前加上%. 编码成多个%XY的格式

HTTP协议请求格式

1. 第一行自成一部分:

   请求行, 内容是 请求方法 url HTTP协议版本

   这里的url可以只是完整url中资源的路径, 也可以是一个完整的url

2. 第二部分由多行组成:

   请求报头, 内容是请求的各种属性. 每行结构为:key: value.

3. 第三部分是单独一行的\r\n

   用来表示报头部分读取完毕:

4. 第四部分则是需要请求的资源的有效载荷, 也是请求资源的正文部分

HTTP协议响应格式

1. 第一行自成一部分:

   响应行, 内容是 HTTP协议版本 状态码 状态码描述

   状态码即为, 请求的状态. 状态码描述即为, 对状态码的解释

2. 第二部分同样由多行组成:

   响应报头, 内容是响应正文的各种属性. 每行结构为:key: value.

3. 第三部分是单独一行的\r\n

   用来表示报头部分读取完毕:

4. 第四部分则是需要响应回客户端的资源的有效载荷, 也是资源的正文部分

查看HTTP协议格式

1. 使用这些代码, 可以看到请求的内容:

   logMessage:

   #pragma once
   
   #include <cassert>
   #include <cerrno>
   #include <cstdarg>
   #include <cstdio>
   #include <cstdlib>
   #include <cstring>
   #include <ctime>
   #include <fcntl.h>
   #include <sys/stat.h>
   #include <sys/types.h>
   #include <unistd.h>
   
   // 宏定义 四个日志等级
   #define DEBUG 0
   #define NOTICE 1
   #define WARINING 2
   #define FATAL 3
   
   const char* log_level[] = {"DEBUG", "NOTICE", "WARINING", "FATAL"};
   
   // 日志消息打印接口
   void logMessage(int level, const char* format, ...) {
       // 通过可变参数实现, 传入日志等级, 日志内容格式, 日志内容相关参数
   
       // 确保日志等级正确
       assert(level >= DEBUG);
       assert(level <= FATAL);
   
       // 获取当前用户名
       char* name = getenv("USER");
   
       // 简单的定义log缓冲区
       char logInfo[1024];
   
       // 定义一个指向可变参数列表的指针
       va_list ap;
       // 将 ap 指向可变参数列表中的第一个参数, 即 format 之后的第一个参数
       va_start(ap, format);
   
       // 此函数 会通过 ap 遍历可变参数列表, 然后根据 format 字符串指定的格式,
       // 将ap当前指向的参数以字符串的形式 写入到logInfo缓冲区中
       vsnprintf(logInfo, sizeof(logInfo) - 1, format, ap);
   
       // ap 使用完之后, 再将 ap置空
       va_end(ap); // ap = NULL
   
       // 通过判断日志等级, 来选择是标准输出流还是标准错误流
       FILE* out = (level == FATAL) ? stderr : stdout;
   
       // 获取本地时间
       time_t tm = time(nullptr);
       struct tm* localTm = localtime(&tm);
       char* localTmStr = asctime(localTm);
       char* nC = strstr(localTmStr, "\n");
       if (nC) {
           *nC = '\0';
       }
       fprintf(out, "%s | %s | %s | %s\n", log_level[level], localTmStr,
               name == nullptr ? "unknow" : name, logInfo);
   
       // 将C缓冲区的内容 刷入系统
       fflush(out);
       // 将系统缓冲区的内容 刷入文件
       fsync(fileno(out));
   }

   tcpServer.hpp:

   #pragma once
   
   #include <iostream>
   #include <string>
   #include <cstdlib>
   #include <cstring>
   #include <unistd.h>
   #include <signal.h>
   #include <pthread.h>
   #include <sys/wait.h>
   #include <sys/types.h>
   #include <sys/socket.h>
   #include <netinet/in.h>
   #include <arpa/inet.h>
   
   #include "logMessage.hpp"
   
   #define SOCKET_ERR 1
   #define BIND_ERR 2
   #define LISTEN_ERR 3
   #define USE_ERR 4
   #define CONNECT_ERR 5
   #define FORK_ERR 6
   #define WAIT_ERR 7
   
   void handlerHttpRequest(int sock) {
       char buffer[1024];
       ssize_t s = read(sock, buffer, sizeof buffer - 1);
       if (s > 0) {
           std::cout << buffer << std::endl;
       }
   }
   
   class tcpServer {
   public:
       tcpServer(uint16_t port, const std::string& ip = "")
           : _port(port)
           , _ip(ip)
           , _listenSock(-1) {}
   
       ~tcpServer() {
           if (_listenSock >= 0)
               close(_listenSock);
       }
   
       void init() {
           // 先创建套接字文件描述符
           _listenSock = socket(AF_INET, SOCK_STREAM, 0);
   
           if (_listenSock < 0) {
               logMessage(FATAL, "socket() faild:: %s : %d", strerror(errno), _listenSock);
               exit(SOCKET_ERR); // 创建套接字失败 以 SOCKET_ERR 退出
           }
           logMessage(DEBUG, "socket create success: %d", _listenSock);
   
           struct sockaddr_in local;
           std::memset(&local, 0, sizeof(local));
   
           // 填充网络信息
           local.sin_family = AF_INET;
           local.sin_port = htons(_port);
           _ip.empty() ? (local.sin_addr.s_addr = htonl(INADDR_ANY))
                       : (inet_aton(_ip.c_str(), &local.sin_addr));
   
           // 绑定网络信息到主机
           if (bind(_listenSock, (const struct sockaddr*)&local, sizeof(local)) == -1) {
               // 绑定失败
               logMessage(FATAL, "bind() faild:: %s : %d", strerror(errno), _listenSock);
               exit(BIND_ERR);
           }
           logMessage(DEBUG, "socket bind success : %d", _listenSock);
           // 监听是否有其他主机发来连接请求, 需要用到接口 listen()
           if (listen(_listenSock, 5) == -1) {
               logMessage(FATAL, "listen() faild:: %s : %d", strerror(errno), _listenSock);
               exit(LISTEN_ERR);
           }
           logMessage(DEBUG, "listen success : %d", _listenSock);
       }
   
       // 服务器初始化完成之后, 就可以启动了
       void loop() {
           while (true) {
               struct sockaddr_in peer;          // 输出型参数 接受所连接主机客户端网络信息
               socklen_t peerLen = sizeof(peer); // 输入输出型参数
   
               // 使用 accept() 接口, 接受来自其他网络客户端的连接
               int serviceSock = accept(_listenSock, (struct sockaddr*)&peer, &peerLen);
               if (serviceSock == -1) {
                   logMessage(WARINING, "accept() faild:: %s : %d", strerror(errno), serviceSock);
                   continue;
               }
               // 连接成功之后, 就可以获取到连接客户端的网络信息了:
               uint16_t peerPort = ntohs(peer.sin_port);
               std::string peerIP = inet_ntoa(peer.sin_addr);
               logMessage(DEBUG, "accept success: [%s: %d] | %d ", peerIP.c_str(), peerPort, serviceSock);
   
               pid_t id = fork();
               if (id == 0) {
                   close(_listenSock);
   
                   if (fork() > 0)
                       exit(0);
   
                   handlerHttpRequest(serviceSock);
                   exit(0);
               }
               waitpid(id, nullptr, 0);
   
               close(serviceSock);
           }
       }
   
   private:
       uint16_t _port; // 端口号
       std::string _ip;
       int _listenSock; // 服务器套接字文件描述符
   };

   tcpServer.cc:

   #include "tcpServer.hpp"
   
   void Usage(std::string proc) {
       std::cerr << "Usage:: \n\t" << proc << " port ip" << std::endl;
       std::cerr << "example:: \n\t" << proc << " 8080 127.0.0.1" << std::endl;
   }
   
   int main(int argc, char* argv[]) {
       if (argc != 3 && argc != 2) {
           Usage(argv[0]);
           exit(USE_ERR);
       }
       uint16_t port = atoi(argv[1]);
       std::string ip;
       if (argc == 3) {
           ip = argv[2];
       }
   
       tcpServer svr(port, ip);
   
       svr.init();
       svr.loop();
   
       return 0;
   }

   编译tcpServer.cc, 并运行可执行程序之后.

   在浏览器输入IP地址 和 端口号, 就可以看到服务器进程接收到了请求, 并打印了出来:

   其格式为:

   1. 第一行:

      请求方法:GET、url:/、HTTP协议版本:HTTP/1.1

   2. 之后, 则为请求报头相关内容

   3. 最后添加了一个\r\n空行

2. 还可以使用telnet连接到服务器之后, 向服务器发送请求, 然后可以看到 响应的内容:

   这里相应的有效载荷其实就是百度首页的html文件内容

给服务器添加HTTP响应

响应html文本

1. 网页编码: utf-8
2. 网页title: HELLO
3. 内容1级标题: 标题 HELLO WORLD
4. 段落: 段落 hello world

现在的浏览器都会自动识别一些常用的格式类型

响应文件内容

1. 服务器接收到 文件资源的请求
2. 服务器从请求中获取文件路径
3. 服务器打开文件
4. 服务器读取文件内容
5. 服务器把文件内容添加在响应中
6. 服务器响应客户端

1. 如何获取文件路径?

   这个简单, HTTP协议的请求中, 第一行的第二个字段一般就表示需要请求的文件资源的路径

2. 如何读取文件的内容?

   这个也很简单, 无论是C语言还是C++ 都提供有文件的相关操作. 只需要按照一定的格式打开并读取就可以了

这里的图片, 使用的是图床中的图片.

如果要使用本地图片, 需要对图片的二进制内容进行base64编码, 然后再进行传输

还需要对不同类型的文件进行不同的报文添加.

如果是html, Content-Type: text/html

如果是jpg图片, Content-Type: image/jpeg

如果是png图片, Content-Type: image/png

具体的文件对应的Content-Type, 可以在网上搜一下 有非常的多.

GET与POST方法

1. 需要把远端服务器的资源 获取到本地

   此行为, 就是上面我们使用GET获取服务器文件等内容的行为, 涉及到GET方法

2. 需要把输入的属性字段, 提交到远端服务器

   就比如在某些网页需要登录账号时, 就需要把输入的内容字段, 提交到远端的服务器中.

   而此行为, 可以通过两个方法实现:GET和POST

GET与POST方法, 可以将输入的属性字段提交到远端服务器

一般情况下就是输入账号密码等内容.

这就要提到 表单. 表单 是html的一个元素, 也是一种 允许用户在页面输入数据并将数据提交到服务器进行处理 的一种机制

基本的语法是:

<form action="submit_url" method="post">
</form>

form即为一个表单, 属性可以设置:

1. action: 需要提交到的服务器资源的url
2. method: 需要使用的提交方法

内容则是一些表单元素, 用来供用户输入信息, 并提交

GET方法

所以可以在使用百度网盘加密分享资源时, 直接在url后拼接上密码进行分享

但, 这并不意味着在这个场景中就是使用的GET方法, 只是兼容了GET方法

POST方法

GET与POST对比

1. GET方法, 通过url传参
2. POST方法, 通过正文传参
3. GET方法, 传参不私密
4. POST方法, 传参相对更私密
5. HTTP中, 这两个方法都是明文传参, 都不安全
6. 因为POST通过正文传参, 所以较大较多的内容都用POST方法传参

其他HTTP协议方法

HTTP协议 状态码

1. 1xx

   一般在请求处理较慢时响应. 告诉客户端请求依然正在处理, 并没有出错, 只是较慢 还没有处理完成

2. 2xx

   就是成功了, 比如200, 状态码描述是OK

3. 3xx

   重定向相关状态码, 具体情况下面介绍

4. 4xx

   出现4xx一般是客户端的请求存在错误. 比如404(NOT FOUND), 找不到请求的资源, 并不是服务器处理的问题, 而是因为请求出错, 请求的资源根本就没有. 不能赖服务器.

5. 5xx

   这个才是服务器处理请求出错时响应的状态码. 比如, 正确接收到了请求, 在打开文件时出错了? 或者处理时出错了? 或者传输时出错了? 这些问题, 响应的状态码都是5xx. 比如: 504(Bad Gateway), 网关超时 一看就是服务器在处理时出现了问题.

市面上的浏览器, 由于各种内核各种版本. 很可能对协议的支持都不同, 浏览器针对各种页面的渲染效果也可能不同.

而对状态码的解释识别也有可能不同, 所以 服务器的状态码很多没有按照标准设置. 所以还有可能出现 超过5xx的状态码 都不稀奇

HTTP常见报头属性

1. Content-Type: value, 用来设置本次请求或响应资源的类型
2. Content-Length: value, HTTP协议是字符串协议. 这个报头属性用来设置, 报文的正文长度

1. Host: value, 用于客户端, 告知服务器, 所请求的资源是在哪个主机的哪个端口上

2. User-Agent: value, 声明用户的操作系统和浏览器版本信息等

   这个属性有什么用呢?

   使用不同的设备, 访问同一个网页时:

   PC访问 QQ音乐下载页

   Android访问 QQ音乐下载页

   某些网页, 会根据设备的不同展示不同的内容. 而设备信息, 就是通过User-Agent获取的.

3. referer: value, 用来说明 当前页面是从哪个页面跳转过来的

   什么意思呢?

Location: value 重定向

如果Location不是一个完整的携带协议的url, Location就会被看做是一个路径, 此时重定向 是获取原服务器的本地资源.

1. 临时重定向

   表示请求的资源已经暂时移动到了另一个url.

   这时, 浏览器会跳转到新的url. 但是, 并不代表旧的url以后就无法使用了. 浏览器会继续为原始url进行排名，同时将重定向的url视为一个临时的副本. 浏览器会自动跳转到新的url，但会保留原始url.

   一般用于, 原服务器维护 需要使用另外的临时服务器的情况

2. 永久重定向

   表示请求的资源已经永久移动到了另一个url

   这时, 浏览器同样会跳转到新的url. 不过, 此时浏览器会将重定向的url视为原始url的替代品，并将其用于排名目的. 浏览器会自动跳转到新的url，并且不会保留原始url

Cookie **

现在Chrome115之后好像没有办法查看Cookie的具体内容了.

只能在请求中看到

Cookie + Session

磁盘上的Cookie可以长时间的保存, 浏览器内存中的Cookie会在浏览器关闭时被释放而清除

HTTP特性 - 无连接

长连接时, 服务器一般按照发送到请求的顺序进行处理并响应

一次TCP连接可以发送多个 请求和响应. 就会存在接收到的报文是否完整的问题.

这时候就需要根据Content-Length: value字段, 来判断此次接收到的报文是否完整了