ipfs_url.cc

Go to the documentation of this file.

/*
 * Copyright (C) Max Dymond, <cmeister2@gmail.com>, et al.
 *
 * SPDX-License-Identifier: curl
 */

 
#include "proto_fuzzer/ipfs_url.h"
 
#include <string_view>
 
namespace proto_fuzzer {
 
namespace {
 
// libcurl has no ipfs:// handler: curl's command-line tool rewrites those
// schemes onto an HTTP gateway before configuring its easy handle. The runner
// mirrors that rewrite against a fixed loopback authority; CONNECT_TO and
// OPENSOCKET still confine the resulting HTTP GET to the in-process
// MockServer, so no gateway process, DNS lookup, or external port is involved.
constexpr char kIpfsGatewayBaseUrl[] = "http://127.0.1.127:8080";

std::string RemoveDotSegments(std::string_view path) {
  std::string input(path);
  std::string output;
  while (!input.empty()) {
    if (input.rfind("../", 0) == 0) {
      input.erase(0, 3);
    } else if (input.rfind("./", 0) == 0) {
      input.erase(0, 2);
    } else if (input.rfind("/./", 0) == 0) {
      input.replace(0, 3, "/");
    } else if (input == "/.") {
      input = "/";
    } else if (input.rfind("/../", 0) == 0) {
      input.replace(0, 4, "/");
      const std::size_t slash = output.rfind('/');
      output.erase(slash == std::string::npos ? 0 : slash);
    } else if (input == "/..") {
      input = "/";
      const std::size_t slash = output.rfind('/');
      output.erase(slash == std::string::npos ? 0 : slash);
    } else if (input == "." || input == "..") {
      input.clear();
    } else {
      const std::size_t segment_start = (input[0] == '/') ? 1 : 0;
      const std::size_t segment_end = input.find('/', segment_start);
      if (segment_end == std::string::npos) {
        output += input;
        input.clear();
      } else {
        output += input.substr(0, segment_end);
        input.erase(0, segment_end);
      }
    }
  }
  return output;
}

std::string NormalizeIpfsHostPath(std::string_view host_path) {
  const std::size_t suffix_start = host_path.find_first_of("/?#");
  if (suffix_start == std::string_view::npos) {
    return std::string(host_path);
  }
  const std::string_view identifier = host_path.substr(0, suffix_start);
  const std::string_view suffix = host_path.substr(suffix_start);
  const std::size_t path_end = suffix.find_first_of("?#");
  const std::string_view path = (path_end == std::string_view::npos) ? suffix : suffix.substr(0, path_end);
  const std::string_view query_fragment =
      (path_end == std::string_view::npos) ? std::string_view() : suffix.substr(path_end);
  std::string result(identifier);
  result += RemoveDotSegments(path);
  result += query_fragment;
  return result;
}
 
}  // namespace

std::string BuildIpfsGatewayUrl(curl::fuzzer::proto::Scheme scheme, const std::string& host_path) {
  const char* prefix = scheme == curl::fuzzer::proto::SCHEME_IPNS ? "ipns" : "ipfs";
  return std::string(kIpfsGatewayBaseUrl) + "/" + prefix + "/" + NormalizeIpfsHostPath(host_path);
}
 
}  // namespace proto_fuzzer