nghttp2/src/HtmlParser.cc

/*
 * nghttp2 - HTTP/2 C Library
 *
 * Copyright (c) 2012 Tatsuhiro Tsujikawa
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
#include "HtmlParser.h"

#include <libxml/uri.h>

#include "util.h"

namespace nghttp2 {

ParserData::ParserData(const std::string &base_uri) : base_uri(base_uri) {}

HtmlParser::HtmlParser(const std::string &base_uri)
    : base_uri_(base_uri), parser_ctx_(nullptr), parser_data_(base_uri) {}

HtmlParser::~HtmlParser() { htmlFreeParserCtxt(parser_ctx_); }

namespace {
const char *get_attr(const xmlChar **attrs, const char *name) {
  if (attrs == nullptr) {
    return nullptr;
  }
  for (; *attrs; attrs += 2) {
    if (util::strieq(reinterpret_cast<const char *>(attrs[0]), name)) {
      return reinterpret_cast<const char *>(attrs[1]);
    }
  }
  return nullptr;
}
} // namespace

namespace {
void add_link(ParserData *parser_data, const char *uri, RequestPriority pri) {
  auto u = xmlBuildURI(
      reinterpret_cast<const xmlChar *>(uri),
      reinterpret_cast<const xmlChar *>(parser_data->base_uri.c_str()));
  if (u) {
    parser_data->links.push_back(
        std::make_pair(reinterpret_cast<char *>(u), pri));
    free(u);
  }
}
} // namespace

namespace {
void start_element_func(void *user_data, const xmlChar *name,
                        const xmlChar **attrs) {
  auto parser_data = static_cast<ParserData *>(user_data);
  if (util::strieq(reinterpret_cast<const char *>(name), "link")) {
    auto rel_attr = get_attr(attrs, "rel");
    auto href_attr = get_attr(attrs, "href");
    if (!href_attr) {
      return;
    }
    if (util::strieq(rel_attr, "shortcut icon")) {
      add_link(parser_data, href_attr, REQ_PRI_LOWEST);
    } else if (util::strieq(rel_attr, "stylesheet")) {
      add_link(parser_data, href_attr, REQ_PRI_MEDIUM);
    }
  } else if (util::strieq(reinterpret_cast<const char *>(name), "img")) {
    auto src_attr = get_attr(attrs, "src");
    if (!src_attr) {
      return;
    }
    add_link(parser_data, src_attr, REQ_PRI_LOWEST);
  } else if (util::strieq(reinterpret_cast<const char *>(name), "script")) {
    auto src_attr = get_attr(attrs, "src");
    if (!src_attr) {
      return;
    }
    add_link(parser_data, src_attr, REQ_PRI_LOW);
  }
}
} // namespace

namespace {
xmlSAXHandler saxHandler = {
    nullptr,             // internalSubsetSAXFunc
    nullptr,             // isStandaloneSAXFunc
    nullptr,             // hasInternalSubsetSAXFunc
    nullptr,             // hasExternalSubsetSAXFunc
    nullptr,             // resolveEntitySAXFunc
    nullptr,             // getEntitySAXFunc
    nullptr,             // entityDeclSAXFunc
    nullptr,             // notationDeclSAXFunc
    nullptr,             // attributeDeclSAXFunc
    nullptr,             // elementDeclSAXFunc
    nullptr,             // unparsedEntityDeclSAXFunc
    nullptr,             // setDocumentLocatorSAXFunc
    nullptr,             // startDocumentSAXFunc
    nullptr,             // endDocumentSAXFunc
    &start_element_func, // startElementSAXFunc
    nullptr,             // endElementSAXFunc
    nullptr,             // referenceSAXFunc
    nullptr,             // charactersSAXFunc
    nullptr,             // ignorableWhitespaceSAXFunc
    nullptr,             // processingInstructionSAXFunc
    nullptr,             // commentSAXFunc
    nullptr,             // warningSAXFunc
    nullptr,             // errorSAXFunc
    nullptr,             // fatalErrorSAXFunc
    nullptr,             // getParameterEntitySAXFunc
    nullptr,             // cdataBlockSAXFunc
    nullptr,             // externalSubsetSAXFunc
    0,                   // unsigned int initialized
    nullptr,             // void * _private
    nullptr,             // startElementNsSAX2Func
    nullptr,             // endElementNsSAX2Func
    nullptr,             // xmlStructuredErrorFunc
};
} // namespace

int HtmlParser::parse_chunk(const char *chunk, size_t size, int fin) {
  if (!parser_ctx_) {
    parser_ctx_ =
        htmlCreatePushParserCtxt(&saxHandler, &parser_data_, chunk, size,
                                 base_uri_.c_str(), XML_CHAR_ENCODING_NONE);
    if (!parser_ctx_) {
      return -1;
    } else {
      if (fin) {
        return parse_chunk_internal(nullptr, 0, fin);
      } else {
        return 0;
      }
    }
  } else {
    return parse_chunk_internal(chunk, size, fin);
  }
}

int HtmlParser::parse_chunk_internal(const char *chunk, size_t size, int fin) {
  int rv = htmlParseChunk(parser_ctx_, chunk, size, fin);
  if (rv == 0) {
    return 0;
  } else {
    return -1;
  }
}

const std::vector<std::pair<std::string, RequestPriority>> &
HtmlParser::get_links() const {
  return parser_data_.links;
}

void HtmlParser::clear_links() { parser_data_.links.clear(); }

} // namespace nghttp2