C/C++编程：http_cookie类实现

Love The Way You Lie 2022-09-04 08:47 166阅读 0赞

*  [前置知识：C/C++编程：客户端识别技术----cookie][C_C_----cookie]

# 编程技巧： #

## 编程技巧：返回容器成员变量的引用 ##

const std::list<HTTP_PARAM*>& getParams(void) const;
    
    private:
    	std::list<HTTP_PARAM*> params_;

## 编程技巧：用\\0代替NULL返回 ##

我们知道，C/C++中返回NULL是很危险的，比如说：

printf("%s", NULL);

就会出现段错误。

但是有时候某个**不可能为空字符串**的属性，这种属性有两种状态：

*  设置了：一定不为空
 *  没有设置：理论上应该是NULL

但是返回NULL是很危险的，这个时候我们可以用`\0`来替代返回：

class HttpCookie
    {
        
    public:
    
        /**
    	 * 获得 cookie 名称，取决于构建函数输入值
    	 * @return {const char*} 为长度大于 0 的字符串，永远非空指针
    	 * 注：用户必须在调用 HttpCookie(const char*, const char*) 构造
    	 *     或调用 setCookie(const char*) 成功后才可以调用该函数，
    	 *     否则返回的数据是 "\0"
    	 */
    	const char* getName(void) const;
    private: 
        char  dummy_[1];
    	char* name_;
    	char* value_;

HttpCookie::HttpCookie(
    	name_     = NULL;
    	value_    = NULL;
    	dummy_[0] = 0;
    }
    
    const char* HttpCookie::getValue(void) const
    {
        
    	if (value_ == NULL) {
        
    		return dummy_;
    	}
    	return value_;
    }

# 版本1：cookie0实现 #

## 源码 ##

`cookies版本0(Netscape)`语法为：  
![在这里插入图片描述][4fed0d52e1ca4552bbef935a08b529a7.png]

*  从上面可以看出，value 格式：`xxx=xxx; domain=xxx; expires=xxx; path=xxx; secure`，也就是说value有一系列以`;`分隔的间隔符组成，因此：`std::list<HTTP_PARAM*> params_`来存储。

#ifndef OCEANSTAR_HTTP_http_cookie_H
    #define OCEANSTAR_HTTP_http_cookie_H
    #include <list>
    #include <string>
    struct HTTP_PARAM
    {
        
        char* name;
        char* value;
    };
    namespace oceanstar{
        
        class http_cookie{
        
        public:
            ~http_cookie(void);
            /**
             * @param name {const char*} 属性名
             * @param value {const char*} 属性值
             * @return {http_cookie&} 返回本对象的引用，便于用户连续操作
             */
            http_cookie& add(const char* name, const char* value);
            
        private:
            std::list<HTTP_PARAM*> params_;
            static void myfree(HTTP_PARAM* param);
        };
    }
    
    #endif //OCEANSTAR_HTTP_http_cookie_H

#include <string.h>
    #include <cstdlib>
    #include "http_cookie.h"
    
    namespace oceanstar{
        
        void http_cookie::myfree(HTTP_PARAM* param){
        
            free(param->name);
            if(param->value && *param->value){
        
                free(param->value);
            }
            free(param);
        }
        http_cookie::~http_cookie(){
        
            for(auto param: params_){
        
                myfree(param);
            }
        }
        
        http_cookie& http_cookie::add(const char* name, const char* value)
        {
        
            if (name == NULL || *name == 0 || value == NULL) {
        
                return *this;
            }
    
            HTTP_PARAM* param = (HTTP_PARAM*) malloc(sizeof(HTTP_PARAM));
            param->name  = strdup(name);
            param->value = strdup(value);
            params_.push_back(param);
            return *this;
        }
    }

## 测试 ##

int main(void){
        
        http_cookie cookie;
    
        cookie.add("tasty_cookie", "xxxx");
        cookie.add("domain", "origin");
        cookie.add("path", "/docs");
        cookie.add("expires", "expires=Wednesday, 09-Nov-99 23:13:40 GMT");
        return 0;
    }

# 版本2 #

## 源码 ##

*  通常 xxx=xxx 和 domain=xxx; expires=xxx; path=xxx; secure…是两个不同的部分，一个xxx=xxx是cookie的真正值，`domain=xxx; expires=xxx; path=xxx; secure...`是cookie值的属性；也就是说cookie相当于一个**值**键值对+不定长的**属性**键值对构成，因此用成员变量`name_`和`value_`表示**值**键值对（cookie值），`std::list<HTTP_PARAM*> params_`来存储属性键值对（其他值）
 *  用一个**标志位**来表示**值键值对**没有被设置时不返回NULL

//
    // Created by oceanstar on 2021/8/12.
    //
    
    #ifndef OCEANSTAR_HTTP_http_cookie_H
    #define OCEANSTAR_HTTP_http_cookie_H
    #include <list>
    #include <string>
    struct http_param
    {
        
        char* name;
        char* value;
    };
    namespace oceanstar{
        
        class http_cookie{
        
        public:
            /**
             * 当使用该构造函数时，可以使用 setCookie 来添加 cookie 项
             */
            explicit http_cookie();
    
            /**
             * 构造函数
             * @param name {const char*} cookie 名，为非空字符串且字符串长度 > 0
             * @param value {const char*} cookie 值，指针非空，字符串长度可以为 0
             * 注：如果输入的两个参数不符合条件，内部将会产生断言
             */
            explicit http_cookie(const char* name, const char* value);
    
            /**
             * 拷贝构造函数
             * @param cookie {const HttpCookie*} 非 NULL， 内部将复制拷贝其成员变量
             */
            explicit http_cookie(const http_cookie* cookie);
    
            ~http_cookie(void);
            /**
             * 对于 Set-Cookie: xxx=xxx; domain=xxx; expires=xxx; path=xxx; max-age=xxx; ...
             * 类的数据进行分析
             * @param value {const char*} 类似于 xxx=xxx; domain=xxx; ... 内容
             * @return {bool} 传入的数据是否合法
             */
            bool setCookie(const char* value);
            /**
             * 添加与该 cookie 对象其它属性值(非cookie值)
             * @param name {const char*} 属性名
             * @param value {const char*} 属性值
             * @return {http_cookie&} 返回本对象的引用，便于用户连续操作
             */
            http_cookie& add(const char* name, const char* value);
    
            /**
             * 动态创建的类对象通过此函数释放
             */
            void destroy();
            /**
             * 设置 cookie 的作用域
             * @param domain {const char*} cookie 作用域
             * @return {HttpCookie&} 返回本对象的引用，便于用户连续操作
             */
            http_cookie& setDomain(const char* domain);
            /**
             * 设置 cookie 的 path 字段
             * @param path {const char*} path 字段值
             * @return {HttpCookie&} 返回本对象的引用，便于用户连续操作
             */
            http_cookie& setPath(const char* path);
            /**
             * 设置 cookie 的过期时间截字符串
             * @param expires {const char*} 过期时间截
             * @return {HttpCookie&} 返回本对象的引用，便于用户连续操作
             */
            http_cookie& setExpires(const char* expires);
    
            /**
             * 设置 cookie 的过期时间段，即用当前时间加输入的时间即为 cookie
             * 的过期时间
             * @param timeout {time_t} 过期时间值(单位为秒)，当前时间加该时间
             * 即 cookie 的过期时间
             * @return {HttpCookie&} 返回本对象的引用，便于用户连续操作
             */
            http_cookie& setExpires(time_t timeout);
            /**
             * 设置 cookie 的生存周期
             * @param max_age {int} 生存秒数
             * @return {HttpCookie&} 返回本对象的引用，便于用户连续操作
             */
            http_cookie& setMaxAge(int max_age);
    
            /**
             * 获得 cookie 名称，取决于构建函数输入值
             * @return {const char*} 为长度大于 0 的字符串，永远非空指针
             * 注：用户必须在调用 HttpCookie(const char*, const char*) 构造
             *     或调用 setCookie(const char*) 成功后才可以调用该函数，
             *     否则返回的数据是 "\0"
             */
            const char* getName(void) const;
    
            /**
             * 获得 cookie 值，取决于构造函数输入值
             * @return {const char*} 非空指针，有可能是空字符串("\0")
             */
            const char* getValue(void) const;
            /**
    	 * 获得字符串格式的过期时间
    	 * @return {const char*} 非空指针，返回值为 "\0" 表示不存在
    	 */
            const char* getExpires(void) const;
    
            /**
             * 获得 cookie 作用域
             * @return {const char*} 非空指针，返回值为 "\0" 表示不存在
             */
            const char* getDomain(void) const;
    
            /**
             * 获得 cookie 的存储路径
             * @return {const char*} 非空指针，返回值为 "\0" 表示不存在
             */
            const char* getPath(void) const;
            /**
             * 获得 cookie 的生存周期
             * @return {int} 返回 -1 时表示没有该 Max-Age 字段
             */
            int  getMaxAge(void) const;
            /**
             * 获得对应参数名的参数值
             * @param name {const char*} 参数名
             * @param case_insensitive {bool} 是否区分大小写，true 表示
             *  不区分大小写
             * @return {const char*} 非空指针，返回值为 "\0" 表示不存在
             */
            const char* getParam(const char* name, bool case_insensitive = true) const;
            /**
             * 获得该 cookie 对象的除 cookie 名及 cookie 值之外的
             * 所有属性及属性值
             * @return {const std::list<http_param*>&}
             */
            const std::list<http_param*>& getParams(void) const;
        private:
            char  dummy_[1]{
        };
            char* name_;
            char* value_;
            std::list<http_param*> params_;
    
            static void myfree(http_param* param);
            bool splitNameValue(char* data, http_param* param);
        };
    }
    
    #endif //OCEANSTAR_HTTP_http_cookie_H

//
    // Created by oceanstar on 2021/8/12.
    //
    
    
    #include <string.h>
    #include <cstdlib>
    #include <memory/acl_argv.h>
    #include <assert.h>
    #include <log.h>
    #include "http_cookie.h"
    
    namespace oceanstar{
        
    #define RFC1123_STRFTIME "%a, %d %b %Y %H:%M:%S GMT"
    
        static const char *http_mkrfc1123(char *buf, size_t size, time_t t)
        {
        
    #ifdef ACL_WINDOWS
            # if _MSC_VER >= 1500
    	struct tm gmt_buf, *gmt = &gmt_buf;
    
    	if (gmtime_s(gmt, &t) != 0)
    		gmt = NULL;
    # else
    	struct tm *gmt = gmtime(&t);
    # endif
    #else
            struct tm gmt_buf, *gmt = gmtime_r(&t, &gmt_buf);
    #endif
    
            buf[0] = 0;
    
            if (gmt != NULL)
                strftime(buf, size - 1, RFC1123_STRFTIME, gmt);
            return (buf);
        }
    }
    
    namespace oceanstar{
        
        void http_cookie::myfree(http_param* param){
        
            free(param->name);
            if(param->value && *param->value){
        
                free(param->value);
            }
            free(param);
        }
    
        http_cookie::http_cookie(){
        
            name_ = NULL;
            value_ = NULL;
            dummy_[0] = 0;
        }
    
        http_cookie::http_cookie(const char* name, const char* value){
        
            assert(name && *name && value);
            name_     = strdup(name);
            value_    = strdup(value);
            dummy_[0] = 0;
        }
    
        http_cookie::http_cookie(const http_cookie* cookie){
        
            dummy_[0] = 0;
            assert(cookie);
    
            if (cookie->name_) {
        
                name_ = strdup(cookie->name_);
            }else{
        
                name_ = NULL;
            }
    
            if (cookie->value_) {
        
                value_ = strdup(cookie->value_);
            } else {
        
                value_ = NULL;
            }
    
            std::list<http_param*>::const_iterator cit = cookie->params_.begin();
            for (; cit != cookie->params_.end(); ++cit) {
        
                http_param* param = (http_param*)malloc(sizeof(http_param));
                param->name  = strdup((*cit)->name);
                param->value = strdup((*cit)->value);
                params_.push_back(param);
            }
    
        }
    
        http_cookie::~http_cookie(){
        
            for(auto param: params_){
        
                myfree(param);
            }
            free(name_);
            if (value_ && *value_){
        
                free(value_);
            }
        }
    
        bool http_cookie::splitNameValue(char* data, http_param* param){
        
    #define SKIP_SPECIAL(x) {
           while (*(x) == ' ' || *(x) == '\t' || *(x) == '=') (x)++; }
    #define SKIP_WHILE(cond, x) {
           while(*(x) && (cond)) (x)++; }
    
            // 开始解析过程
            param->name = data;   // xxx = xxx
    
            // 去掉开头无用的特殊字符
            SKIP_SPECIAL(param->name);
            if (*(param->name) == 0) {
        
                return false;
            }
    
            // 找到 '='
            param->value = param->name;  //  xxx = xxx
            SKIP_WHILE(*(param->value) != '=', param->value);
            if (*(param->value) != '=') {
           // = xxx
                return false;
            }
    
            // 去掉 '=' 前面的空格
            char* ptr       = param->value - 1;   // ptr指向'='之前的前一个字符
            *param->value++ = 0;  // '='变成0，也就是切断[xxx = xxx ---> xxx  xxx]，并且param->value指向=号之后的下一个字符
            while (ptr > param->name && (*ptr == ' ' || *ptr == '\t')) {
        
                *ptr-- = 0;
            }
    
            // 去掉 value 开始的无效字符
            SKIP_SPECIAL(param->value);
    
            // 找到 value 值的结束位置
            // 允许 value = "\0"
            ptr = param->value + strlen(param->value) - 1;   // 指向最末尾的那个字符
            while (ptr >= param->value && (*ptr == ' ' || *ptr == '\t')) {
           // 去掉无效字符
                *ptr-- = 0;
            }
    
            return true;
        }
    
        // xxx=xxx; domain=xxx; expires=xxx; path=xxx; max-age=xxx; ...
        bool http_cookie::setCookie(const char* value){
        
            if (value == NULL || *value == 0) {
           // 不能是NULL，也不能为""
                return false;
            }
    
            ACL_ARGV* tokens = acl_argv_split(value, ";");
            assert(tokens->argc > 0);
    
            http_param param;
    
            // 从第一个 name=value 字段中取得 cookie 名及 cookie 值
            if (!splitNameValue((char *) tokens->argv[0].c_str(), &param)) {
        
                acl_argv_free(tokens);
                return false;
            }
    
            name_ = strdup(param.name);
            value_ = strdup(param.value);
    
            for (int i = 1; i < tokens->argc; i++) {
        
                if (!splitNameValue((char *) tokens->argv[i].c_str(), &param)) {
        
                    continue;
                }
                if (*(param.value) == 0) {
          //不能为""
                    continue;
                }
                if (strcasecmp(param.name, "domain") == 0) {
           //忽略大小写比较字符串
                    setDomain(param.value);
                } else if (strcasecmp(param.name, "expires") == 0) {
        
                    setExpires(param.value);
                } else if (strcasecmp(param.name, "path") == 0) {
        
                    setPath(param.value);
                } else {
        
                    add(param.name, param.value);
                }
            }
    
            acl_argv_free(tokens);
            return true;
        }
    
    
        http_cookie& http_cookie::add(const char* name, const char* value)
        {
        
            if (name == NULL || *name == 0 || value == NULL) {
        
                return *this;
            }
    
            http_param* param = (http_param*) malloc(sizeof(http_param));
            param->name  = strdup(name);
            param->value = strdup(value);
            params_.push_back(param);
            return *this;
        }
    
        void http_cookie::destroy(void)
        {
        
            delete this;
        }
    
        http_cookie& http_cookie::setDomain(const char* domain)
        {
        
            add("Domain", domain);
            return *this;
        }
        http_cookie& http_cookie::setPath(const char* path)
        {
        
            add("Path", path);
            return *this;
        }
    
        http_cookie& http_cookie::setExpires(const char* expires)
        {
        
            add("Expires", expires);
            return *this;
        }
    
        http_cookie& http_cookie::setExpires(time_t timeout){
        
            if (timeout > 0) {
        
                time_t n = time(NULL);
                n += timeout;
    
                char buf[64];
                const char* ptr = http_mkrfc1123(buf, sizeof(buf), n);
                if (*ptr == 0) {
        
                    logger_error("gmtime error %s", strerror(errno));
                }
                add("Expires", buf);
            }
            return *this;
        }
    
    
        http_cookie& http_cookie::setMaxAge(int max_age)
        {
        
            char tmp[20];
            snprintf(tmp, sizeof(tmp), "%d", max_age);
            add("Max-Age", tmp);
            return *this;
        }
        const char* http_cookie::getName(void) const
        {
        
            if (name_ == NULL) {
        
                return dummy_;
            }
            return name_;
        }
    
        const char* http_cookie::getValue(void) const
        {
        
            if (value_ == NULL) {
        
                return dummy_;
            }
            return value_;
        }
    
        const char* http_cookie::getExpires(void) const
        {
        
            return getParam("Expires");
        }
    
        const char* http_cookie::getDomain(void) const
        {
        
            return getParam("Domain");
        }
    
        const char* http_cookie::getPath(void) const
        {
        
            return getParam("Path");
        }
        int http_cookie::getMaxAge(void) const
        {
        
            const char* ptr = getParam("Max-Age");
            if (ptr == NULL || *ptr == 0) {
        
                return -1;
            }
            return atoi(ptr);
        }
        const char* http_cookie::getParam(const char* name, bool case_insensitive /* = true */) const
        {
        
            std::list<http_param*>::const_iterator cit = params_.begin();
            for (; cit != params_.end(); ++cit) {
        
                if (case_insensitive) {
        
                    if (strcasecmp((*cit)->name, name) == 0) {
        
                        return (*cit)->value;
                    }
                } else if (strcasecmp((*cit)->name, name) == 0) {
        
                    return (*cit)->value;
                }
            }
            return dummy_;
        }
        const std::list<http_param*>& http_cookie::getParams(void) const
        {
        
            return params_;
        }
    }

## 测试 ##

#include <fcntl.h>
    #include "http/http_cookie.h"
    using namespace oceanstar;
    
    
    
    int main(void){
        
        http_cookie *cookie = new http_cookie();
        cookie->setCookie("xxx=xxx; domain=orgin; expires=xxx; path=/a/b; max-age=263;");
    
        auto params = cookie->getParams();
        printf("%s=%s;", cookie->getName(), cookie->getValue());
        for(auto param : params){
        
            printf("%s=%s;", param->name, param->value);
        }
        printf("\n========================================\n");
    
       http_cookie cookie1(cookie);
    
       cookie->destroy();
    
       printf("%s=%s;", cookie1.getName(), cookie1.getValue());
       printf("domain=%s;", cookie1.getParam("domain"));
       printf("Expires=%s;", cookie1.getParam("Expires"));
       printf("Path=%s;", cookie1.getPath());
       printf("max-age=%d;\n", cookie1.getMaxAge());
        printf("========================================\n");
       time_t now = 1235663;
       http_cookie cookie2("test", "frdssfghytresdfgh");
       cookie2.add("domain", "www.ocean.com");
       cookie2.setExpires(now);
       cookie2.setMaxAge(3600);
       params = cookie2.getParams();
        printf("%s=%s;", cookie2.getName(), cookie2.getValue());
        for(auto param : params){
        
            printf("%s=%s;", param->name, param->value);
        }
    
    
    
    
    
    
        return 0;
    }

# 测试 #

#include <stdio.h>
    #include <zlib.h>
    #include <cstring>
    #include <http/http_cookie.h>
    #include "zlib_stream.h"
    
    using namespace oceanstar;
    
    int main(void)
    {
        
        const char* data = "U_TRS1=000000f6.66721803.4fd1681c.8c48b73a; path=/; expires=Mon, 06-Jun-22 02:49:00 GMT; domain=.sina.com.cn";
        http_cookie* cookie = new http_cookie();
    
        printf("Set-Cookie: %s\r\n", data);
    
        if (!cookie->setCookie(data))
        {
        
            printf("parse cookie(%s) error\r\n", data);
            cookie->destroy();
            return -1;
        }
    
        printf("cookie name: %s\r\n", cookie->getName());
        printf("cookie value: %s\r\n", cookie->getValue());
        printf("domain: %s\r\n", cookie->getDomain());
        printf("path: %s\r\n", cookie->getPath());
        printf("max-age: %d\r\n", cookie->getMaxAge());
    
        const std::list<http_param*>& params = cookie->getParams();
        std::list<http_param*>::const_iterator cit = params.begin();
        for (; cit != params.end(); ++cit)
            printf(">>%s=%s\r\n", (*cit)->name, (*cit)->value);
    
        cookie->destroy();
        return 0;
    }

![在这里插入图片描述][4a5855a37de04bb6821c25fe80edbada.png]

测试内存： valgrind --tool=memcheck --leak-check=yes -v ./oceanstar\_http

[C_C_----cookie]: https://blog.csdn.net/zhizhengguan/article/details/119641224
[4fed0d52e1ca4552bbef935a08b529a7.png]: /images/20220829/b1dd69d26f014e518254178e28e6b109.png
[4a5855a37de04bb6821c25fe80edbada.png]: /images/20220829/9fcd9d71243143319d51b475ac700fd2.png