C/C++编程：url解析

深碍√TFBOYSˉ_ 2022-09-02 14:58 413阅读 0赞

url解析

源码

  1. //
  2. // Created by oceanstar on 2021/8/6.
  3. //
  5. #ifndef OCEANSTAR_HTTP_HTTP_UTILS_H
  6. #define OCEANSTAR_HTTP_HTTP_UTILS_H
  8. #include <cstdio>
  9. #include "global.h"
  10. namespace oceanstar {
  12.     class  http_utils{
  14.     public:
  15.         http_utils() {
  16.     }
  17.         ~http_utils() {
  18.     }
  19.         /**
  20.         * 从完整的 url 中获得 WEB 服务器 IP 地址及端口号
  21.         * @param url {const char*} HTTP url，非空
  22.         * @param domain {char*} 存储域名
  23.         * @param size {size_t} domain 内存大小
  24.         * @param port {unsigned short*} 存储端口号大小
  25.         * @return {bool} 是否成功获得
  26.         */
  27.         static bool get_addr(const char* url, char* domain, size_t size,
  28.                              unsigned short* port);
  29.         /**
  30.          * 从完整的 url 中获得 WEB 服务器地址，格式：domain:port
  31.          * @param url {const char*} HTTP url，非空
  32.          * @param addr {char*} 存储结果，存储格式：domain:port
  33.          * @param size {size_t} out 缓冲区大小
  34.          * @return {bool} 是否成功获得
  35.          */
  36.         static bool get_addr(const char* url, char* addr, size_t size);
  38.     };
  39. };
  42. namespace oceanstar{
  44.     using namespace std;
  45.     class  http_url {
  47.             public:
  48.             http_url(void);
  49.             ~http_url(void) {
  50.     }
  52.             bool parse(const char* url);
  54.             public:
  55.             /**
  56.              * 返回 URL 中的协议类型：http 或 https
  57.              * @return {const char*}
  58.              */
  59.             const char* get_proto(void) const {
  61.                 return proto_;
  62.             }
  64.             /**
  65.              * 返回 URL 中的域名字段
  66.              * @return {const char*} 返回空串则表示没有该字段
  67.              */
  68.             const char* get_domain(void) const {
  70.                 return domain_.c_str();
  71.             }
  73.             /**
  74.              * 返回根据 URL 提取的 HTTP 协议服务端端口号，内部缺省值为 80
  75.              * @return {unsigned short}
  76.              */
  77.             unsigned short get_port(void) const {
  79.                 return port_;
  80.             }
  82.             /**
  83.              * 返回根据 URL 提取的相对路径部分（不含 ? 后面的参数）
  84.              * @return {const char*}
  85.              */
  86.             const char* get_url_path(void) const {
  88.                 return url_path_.c_str();
  89.             }
  91.             /**
  92.              * 返回从 URL 中提取的参数字段
  93.              * @return {const char*}
  94.              */
  95.             const char* get_url_params(void) const {
  97.                 return url_params_.c_str();
  98.             }
  100.             /**
  101.              * 清理解析过程中的中间状态，以便重复使用该类对象解析下一个 URL
  102.              */
  103.             void reset(void);
  105.             private:
  106.             char proto_[16];
  107.             string domain_;
  108.             unsigned short port_;
  109.             string url_path_;
  110.             string url_params_;
  112.             bool parse_url_part(const char* url);
  113.             const char* parse_domain(const char* url);
  114.     };
  115. };
  117. #endif //OCEANSTAR_HTTP_HTTP_UTILS_H
  119. //
  120. // Created by oceanstar on 2021/8/6.
  121. //
  123. #include <iostream>
  124. #include <string.h>
  125. #include "http_utils.h"
  128. namespace oceanstar{
  130. #define    HTTP_PREFIX    "http://"
  131. #define    HTTPS_PREFIX    "https://"
  133.     bool http_utils::get_addr(const char* url, char* domain, size_t size,
  134.                               unsigned short* pport)
  135.     {
  137.         const char* ptr;
  138.         unsigned short default_port;
  140.         if (!strncasecmp(url, HTTP_PREFIX, sizeof(HTTP_PREFIX) - 1)) {
  142.             ptr = url + sizeof(HTTP_PREFIX) - 1;
  143.             default_port = 80;
  144.         } else if (!strncasecmp(url, HTTPS_PREFIX, sizeof(HTTPS_PREFIX) - 1)) {
  146.             ptr = url + sizeof(HTTPS_PREFIX) - 1;
  147.             default_port = 443;
  148.         } else {
  150.             logger_error("invalid url: %s", url);
  151.             return false;
  152.         }
  154.         if (*ptr == 0) {
  156.             logger_error("invalid url: %s", url);
  157.             return false;
  158.         }
  160.         char buf[256];
  161.         strncpy(buf, ptr, sizeof(buf));
  163.         char* slash = strchr(buf, '/');
  164.         if (slash) {
  166.             *slash = 0;
  167.         }
  169.         unsigned short port;
  171.         char* col = strchr(buf, ':');
  172.         if (col == NULL) {
  174.             port = default_port;
  175.         } else {
  177.             *col++ = 0;
  178.             port = (unsigned short) atoi(col);
  179.             if (port == 0 || port == 65535) {
  181.                 port = default_port;
  182.             }
  183.         }
  185.         if (pport) {
  187.             *pport = port;
  188.         }
  189.         strncpy(domain, buf, size);
  190.         return true;
  191.     }
  194.     bool http_utils::get_addr(const char* url, char* addr, size_t size)
  195.     {
  197.         char  buf[256];
  198.         unsigned short port;
  200.         if (!get_addr(url, buf, sizeof(buf), &port)) {
  202.             return false;
  203.         }
  204.         snprintf(addr, size, "%s:%d", buf, port);
  205.         return true;
  206.     }
  207. }
  209. namespace oceanstar{
  211.     http_url::http_url(void) {
  213.         strncpy(proto_, "http", sizeof(proto_));
  214.         port_ = 80;
  215.     }
  216.     void http_url::reset(void) {
  218.         strncpy(proto_, "http", sizeof(proto_));
  219.         port_ = 80;
  220.         domain_.clear();
  221.         url_path_.clear();
  222.         url_params_.clear();
  223.     }
  225.     const char* http_url::parse_domain(const char *url) {
  227.         if (*url == '/') {
  229.             logger_error("invalid url: %s", url);
  230.             return NULL;
  231.         }
  232.         const char* ptr = strchr(url, '/');
  233.         if (ptr == NULL) {
  235.             domain_ = url;
  236.             return NULL;
  237.         }
  239.         char buf[256];
  240.         size_t size = ptr - url + 1;
  241.         if (size > sizeof(buf)) {
  242.      // xxx: sanity check
  243.             size = sizeof(buf);
  244.         }
  245.         strncpy(buf, url, size);
  247.         // fixme: Is it error if buf contains IPV6 Addr ---zsx
  248.         char* col = strchr(buf, ':');
  249.         if (col != NULL) {
  251.             *col++ = 0;
  252.             port_ = (unsigned short) atoi(col);
  253.             if (port_ == 0 || port_ == 65535) {
  255.                 port_ = 80;
  256.             }
  257.         }
  258.         domain_ = buf;
  259.         return ptr;
  260.     }
  263.     bool http_url::parse(const char *url) {
  265.         const char* ptr;
  267.         if (!strncasecmp(url, HTTP_PREFIX, sizeof(HTTP_PREFIX) - 1)) {
  269.             ptr = url + sizeof(HTTP_PREFIX) - 1;
  270.         } else if (!strncasecmp(url, HTTPS_PREFIX, sizeof(HTTPS_PREFIX) - 1)) {
  272.             ptr = url + sizeof(HTTPS_PREFIX) - 1;
  273.             port_ = 443;
  274.             strncpy(proto_, "https", sizeof(proto_));
  275.         } else if (*url == '/'){
  277.             ptr = url;
  278.         } else {
  280.             logger_error("invalid url: %s", url);
  281.             return false;
  282.         }
  284.         if (*ptr == 0) {
  286.             logger_error("invalid url: %s", url);
  287.             return false;
  288.         }
  290.         if (ptr == url) {
  292.             // 说明是仅含相对路径的 url
  293.             return parse_url_part(url);
  294.         } else {
  296.             // 说明包含有完整路径的 url，下面先提取域名字段，再提取相对 url
  297.             ptr = parse_domain(ptr);
  298.             if (ptr == NULL) {
  300.                 url_path_ = "/";
  301.                 return true;
  302.             }
  303.             return parse_url_part(ptr);
  304.         }
  305.     }
  307. #define SKIP_WHILE(cond, ptr) {
  308.        while(*ptr && (cond)) ptr++; }
  310.     bool http_url::parse_url_part(const char *url) {
  312.         if (*url != '/') {
  314.             logger_error("invalid url: %s", url);
  315.             return false;
  316.         }
  318.         const char* ptr = url;
  319.         SKIP_WHILE(*ptr == '/', ptr);
  320.         if (*ptr == 0) {
  322.             url_path_ = "/";
  323.             return true;
  324.         }
  326.         const char* qm = strchr(ptr, '?');
  327.         if (qm == NULL) {
  329.             url_path_ = url;
  330.             return true;
  331.         }
  332.         char buf[strlen(url)];
  333.         strncpy(buf, url, qm - url);
  334.         url_path_ = buf;
  335.         ++qm;
  336.         if (*qm != 0) {
  338.             url_params_ = qm;
  339.         }
  340.         return true;
  341.     }
  343. }

使用

例子

  1. #include <cstring>
  2. #include "http_utils.h"
  5. using namespace oceanstar;
  6. int main(int argc, char *argv[])
  7. {
  9.     unsigned short port ;
  10.     char host[256];
  11.     memset(host,  0, sizeof(host));
  12.     std::string url = "http://www.gmail.com:443/path/test.cgi?name=value&name2=value2 ";
  13.     if(http_utils::get_addr(url.c_str(), host, sizeof(host), &port)){
  15.         logger_info("host: %s, port: %d", host, port);
  16.     }else{
  18.         logger_error("s(%d): url invalid ", __FUNCTION__ , __LINE__);
  19.     }
  22.     char addr[256];
  23.     memset(addr,  0, sizeof(addr));
  25.     if(http_utils::get_addr(url.c_str(), addr, sizeof(addr))){
  27.         logger_info("addr: %s", addr);
  28.     }else{
  30.         logger_error("s(%d): url invalid ", __FUNCTION__ , __LINE__);
  31.     }
  33.     return (0);
  34. }

在这里插入图片描述

例子

  1. #include <cstring>
  2. #include "http_utils.h"
  5. using namespace oceanstar;
  6. int main(int argc, char *argv[])
  7. {
  9.     unsigned short port ;
  10.     char host[256];
  11.     memset(host,  0, sizeof(host));
  12.     std::string url = "http://www.gmail.com:443/path/test.cgi?name=value&name2=value2 ";
  15.     http_url httpUrl;
  17.     if(!httpUrl.parse(url.c_str())){
  19.         exit(0);
  20.     }
  22.     logger_info("proto: %s", httpUrl.get_proto());
  23.     logger_info("domain: %s", httpUrl.get_domain());
  24.     logger_info("port: %d", httpUrl.get_port());
  25.     logger_info("url_path: %s", httpUrl.get_url_path());
  26.     logger_info("url_params: %s", httpUrl.get_url_params());
  28.     printf("\n\n");
  30.     httpUrl.reset();
  33.     url = "http://127.0.0.1:443/path/test.cgi";
  34.     if(!httpUrl.parse(url.c_str())){
  36.         exit(0);
  37.     }
  39.     logger_info("proto: %s", httpUrl.get_proto());
  40.     logger_info("domain: %s", httpUrl.get_domain());
  41.     logger_info("port: %d", httpUrl.get_port());
  42.     logger_info("url_path: %s", httpUrl.get_url_path());
  43.     logger_info("url_params: %s", httpUrl.get_url_params());
  45.     return (0);
  46. }

在这里插入图片描述

通过127.0.0.1:80解析中获取host和port

  1. #include <cstring>
  2. #include "http_utils.h"
  5. using namespace oceanstar;
  7. // s必须是堆内存
  8. static char  *acl_split_at_right(char *s, int delimiter)
  9. {
  11.     char   *cp;
  13.     if ((cp = strrchr(s, delimiter)) != 0){
  15.         *cp = 0;
  16.         cp++;
  17.     }
  19.     return cp;
  20. }
  22. static const char *acl_host_port(char *buf, char **host, char *def_host,char **port)
  23. {
  25.     char *cp = buf;
  27.     /* host:port, host:, host, :port */
  28.     if ((cp = acl_split_at_right(buf, ':')) != 0) {
  30.         *host = *buf ? buf : def_host;
  31.         *port = *cp ? cp : NULL;
  32.     }
  34.     if (*host == 0)
  35.         return "missing host information";
  38.     return NULL;
  39. }
  42. static int host_port(char *buf, char **host, char **port)
  43. {
  45.     char *def_host = "";
  46.     const char *ptr = acl_host_port(buf, host, def_host, port);
  48.     if (ptr != NULL) {
  50.         logger_error("%s(%d), %s: invalid addr %s, %s",
  51.                      __FILE__, __LINE__, __FUNCTION__, buf, ptr);
  52.         return -1;
  53.     }
  55.     if (*port != NULL && atoi(*port) < 0) {
  57.         logger_error("%s(%d), %s: invalid port: %s, addr: %s",
  58.                      __FILE__, __LINE__, __FUNCTION__,
  59.                      *port ? *port : "null", buf);
  60.         return -1;
  61.     }
  63.     if (*host && **host == 0)
  64.         *host = 0;
  65.     if (*host == NULL)
  66.         *host = "0";
  68.     return 0;
  69. }
  71. int main(int argc, char *argv[])
  72. {
  75.     char *addr = strdup("127.0.0.0:80");
  76.     char *host = NULL, *port = NULL;
  77.     if (host_port(addr, &host, &port) < 0) {
  79.         printf("formet error");
  80.         free(addr);
  81.         return NULL;
  82.     }
  84.     printf("host: %s, port: %s", host, port);
  85.     free(addr);
  88.     return (0);
  89. }

通过url获取host【版本1】

  1. #include <iostream>
  2. /* data: "http://www.gmail.com:443/path/test.cgi?name=value&name2=value2 */
  3. static void __get_host_from_url(char *buf, size_t size, const char *url)
  4. {
  6.     const char *ptr1, *ptr2;
  7.     size_t n;
  9.     buf[0] = 0;
  10.     if (strncasecmp(url, "http://", sizeof("http://") - 1) == 0)
  11.         ptr1 = url + sizeof("http://") - 1;
  12.     else if (strncasecmp(url, "https://", sizeof("https://") - 1) == 0)
  13.         ptr1 = url + sizeof("https://") - 1;
  14.     else
  15.         ptr1 = url;
  17.     if (ptr1 == NULL || *ptr1 == 0 || *ptr1 == '/')
  18.         return;
  20.     ptr2 = strchr(ptr1, '/');
  21.     if (ptr2)
  22.         n = ptr2 - ptr1;
  23.     else
  24.         n = strlen(ptr1);
  26.  //   n++;
  28.     if (n > size)
  29.         n = size;
  31.     strncpy(buf, ptr1, (int) n);
  32. }
  34. int main() {
  36.     char host[256];
  37.     memset(host,  0, sizeof(host));
  38.     __get_host_from_url(host, sizeof(host), "http://www.gmail.com:443/path/test.cgi?name=value&name2=value2 ");
  39.     std::cout << host << std::endl;
  40. }

在这里插入图片描述

发表评论

表情：
评论列表 （有 0 条评论，413人围观）

还没有评论，来说两句吧...

相关阅读