Linux——http协议2

目录

Http的请求方法

GET方法

POST方法

 http状态码

 http常见header（报头属性）

Cookie和 Set Cookie

 Conection选项

http存在问题

 HttpServer.cc

 HttpServer.hpp

 Log.hpp

 Makefile

Sock.hpp

Usage.hpp

Util.hpp

 wwwroot

index.html

 a/b/404.html

---

 

Http的请求方法

 我们平时的上网行为其实就俩种。

1.从服务器端把资源数据拿下来，GET。      2.把客户端的数据提交到服务器，POST，GET。

 手动构造Http请求，用GET方法，请求/（默认首页），请求方法HTTP/1.1

表达：收集用户的数据，把数据推送给服务器，当用户想提交数据给服务器，必须依托于网页的表单，表达的作用提供输入框和提交按钮，之后表达中的数据会被转成http请求的一部分，表达是需要被提交的，提交的时候要指明提交方法。常见方法就是GET,POST。

GET方法

 得到了baidu的Http响应

 我们写一个简单的静态网页，该网页有登陆界面

 当我们点击登录时，GET会把用户数据返回给服务器

当点击登陆后，网址输入框会变为这样

/a/b/haha.html代表我们要把资源提交到这里

？后面的部分代表我们要提交的资源是什么

如访问百度，？后面是要提交的资源，把资源提交给了s这个服务

服务器收到了http请求

通过上面我们可以知道，GET通过URL会给服务端传参。

POST方法

 我们改成post方法

 post方法URL中并没有回显对应的参数

 服务端收到的请求，最后把参数放到了最下面的正文部分，POST通过http的正文提交参数。

 get通过URL传参，会回显输入的私密信息（在浏览器上面部分），可能会不太安全。

post方法是通过正文提交参数的，不会回显，私密性是有保证的。

get通过URL提参，post通过正文提参。

 http状态码

 状态码：表明本次请求状态的数字。

 最常见的状态码, 比如 200(OK), 404(Not Found), 403(Forbidden), 302(Redirect, 重定向), 504(Bad Gateway)。

重定向状态码：登录某个页面后，会出现网页跳转，这就叫重定向。

永久重定向 301和 临时重定向 302 or 307

临时重定向：不影响用户后续的请求策略。

永久重定向：影响用户后续的请求策略。

自己写一个重定向

 直接点击登录

 跳转到了腾讯官网

站内的跳转

 之后点击登录，直接跳转到重定向的页面

 http常见header（报头属性）

Content-Type: 数据类型(text/html等)
Content-Length: Body的长度
Host: 客户端告知服务器, 所请求的资源是在哪个主机的哪个端口上;
User-Agent: 声明用户的操作系统和浏览器版本信息;
referer: 当前页面是从哪个页面跳转过来的;
location: 搭配3xx状态码使用, 告诉客户端接下来要去哪里访问;
Cookie: 用于在客户端存储少量信息. 通常用于实现会话(session)的功能;

我们可以看到正文的字节数

 http的特征：

        1.简单快速 。

        2.无连接，虽然底层是TCP，但是TCP这层有连接，但在http这层无连接。

        3.无状态（http并不会记录一个用户上一次的请求，http协议不会对用户的行为做记录），但是我们登录一些网站，如CSDN时，第一次需要输入账户密码和信息，当我们关闭网页之后，再次打开CSDN就发现用户已经登陆好了，即免去了让用户频繁登录的行为。这是因为实际上我们在使用的时候，一般网站是会记录下我们的状态的。这种记录状态不是http提供的，而是上层业务维护的，http只关心客户要什么资源，然后把资源给客户，http只负责网络功能。

Cookie和 Set Cookie

        http协议虽然无状态，但网站为了支持常规的会话管理，在报头属性里面增加了Cookie和Set-Cookie，Cookie在请求中涵盖，Set-Cookie在响应中可以设置。我们上面所说的用户第二次免登录属于会话管理。

        Cookie向服务器提供信息，Set-Cookie对客户端响应信息。

         客户端输入用户名和密码发送给服务器，服务器进行验证，验证通过后会在客户端的文件or内存文件中保存这个用户名和密码，等到我们下次进行http请求的时候，本地保存的用户名和密码会被自动提取上来。

        这种在本地保存用户信息的文件称为cookie文件

        如果客户端被人为的植入了木马，找到了我们的cookie，然后把cookie文件发送给了黑客，黑客用我们的cookie以免密码的方式可以登录某网站，因此在现实生活中，这种方案不再被采取

        目前主流的方案，形成一个session id,这个id是唯一的。

        这种方案同样会面临上面的问题，如果cookie被盗，对方就能拿着cookie，以我们的身份去访问网站。虽然对方能登录，但是我们的个人信息不会被泄漏，如登录名和密码。但对方仍然可以用我们的方案去搞事情。

 先在服务器端写一个Set-Cookie

 

 客户端此时收到了一个cookie,默认到期时间是浏览会话结束时。

 我们在客户端点击登录，此时服务器拿到了一个Cookie

 Conection选项

上图中当我们点击登陆时，服务器显示的选项中有一个是Connection。

        Connection如果是close，则代表短链接（我们这里处理了一次http请求，就将连接close，这里一个连接只有一个http请求，处理完请求后就关闭），如果是keep-alive代表长连接(一个连接可以有好多个http请求)。

        一张完整的网页，是由非常多的资源构成的。

        fiddler：可以抓取我们本机的http全部请求。原理如下

        

http存在问题

        http容易被网络抓包，虽然我们用POST方法，但是还是会被一些抓包软件获取到我们的登录名和密码。因此单纯的http请求是不安全的，但我们可以用https。

 HttpServer.cc

#include <iostream>
#include <memory>
#include <cassert>
#include <fstream>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#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<std::string> vline;
    Util::cutString(buffer, "\n", &vline);

    std::vector<std::string> vblock;
    Util::cutString(vline[0], " ", &vblock);

    std::string file = vblock[1];
    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 302 Found\r\n";
        HttpResponse+="Location: https://120.78.126.148:8081/a/b/404.html/\r\n";//重定向的地址
    }
        else
        {
            HttpResponse = "HTTP/1.1 200 OK\r\n";
            HttpResponse+=("Content-Length："+std::to_string(content.size())+"\r\n");//长度
            HttpResponse+="Set-Cookie:这是一个cookie\r\n";
        }
    HttpResponse += "\r\n";
    HttpResponse += content;
        // std::cout << "####start################" << std::endl;
        // for(auto &iter : vblock)
        // {
        //     std::cout << "---" << iter << "\n" << std::endl;
        // }
        // std::cout << "#####end###############" << std::endl;

        // 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> httpserver(new HttpServer(atoi(argv[1]), HandlerHttpRequest));
    httpserver->Start();
    return 0;
}

 HttpServer.hpp

#pragma once

#include <iostream>
#include <signal.h>
#include <functional>
#include "Sock.hpp"

class HttpServer
{
public:
    using func_t = std::function<void(int)>;
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 <iostream>
#include <cstdio>
#include <cstdarg>
#include <ctime>
#include <string>

// 日志是有日志级别的
#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
    // va_list ap;
    // va_start(ap, format);
    // while()
    // int x = va_arg(ap, int);
    // va_end(ap); //ap=nullptr
    char stdBuffer[1024]; //标准部分
    time_t timestamp = time(nullptr);
    // struct tm *localtime = localtime(&timestamp);
    snprintf(stdBuffer, sizeof stdBuffer, "[%s] [%ld] ", gLevelMap[level], timestamp);

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

    FILE *fp = fopen(LOGFILE, "a");
    // printf("%s%s\n", stdBuffer, logBuffer);
    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 <iostream>
#include <string>
#include <cstring>
#include <cerrno>
#include <cassert>
#include <unistd.h>
#include <memory>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <ctype.h>
#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 <iostream>
#include <string>

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

Util.hpp

#pragma once

#include <iostream>
#include <vector>

class Util
{
public:
    // aaaa\r\nbbbbb\r\nccc\r\n\r\n
    static void cutString(std::string s, const std::string &sep, std::vector<std::string> *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));
    }
};

 wwwroot

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Linux课程</title>
</head>
<body>
    <h3>这个一个Linux课程</h3>
    <p>我是一个Linux的学习者，我正在进行http的测试工作！！</p>
    <p>我是一个Linux的学习者，我正在进行http的测试工作！！</p>
    <p>我是一个Linux的学习者，我正在进行http的测试工作！！</p>
    <p>我是一个Linux的学习者，我正在进行http的测试工作！！</p>
    <p>我是一个Linux的学习者，我正在进行http的测试工作！！</p>
    <p>我是一个Linux的学习者，我正在进行http的测试工作！！</p>
    <p>我是一个Linux的学习者，我正在进行http的测试工作！！</p>
</body>
</html>

 a/b/404.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>不存在</title>
</head>
<body>
    <h2>你访问的页面不存在</h2>
</body>
</html>