utils.h

// MinIO C++ Library for Amazon S3 Compatible Cloud Storage
// Copyright 2022 MinIO, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#ifndef _MINIO_UTILS_H
#define _MINIO_UTILS_H
 
#include <openssl/buffer.h>
#include <openssl/evp.h>
 
#include <cmath>
#include <cstring>
#include <curlpp/cURLpp.hpp>
#include <list>
#include <regex>
#include <set>
 
#include "error.h"
 
namespace minio {
namespace utils {
inline constexpr unsigned int kMaxMultipartCount = 10000;  // 10000 parts
inline constexpr unsigned long kMaxObjectSize =
    5L * 1024 * 1024 * 1024 * 1024;                                     // 5TiB
inline constexpr unsigned long kMaxPartSize = 5L * 1024 * 1024 * 1024;  // 5GiB
inline constexpr unsigned int kMinPartSize = 5 * 1024 * 1024;           // 5MiB
 
// FormatTime formats time as per format.
std::string FormatTime(const std::tm* time, const char* format);
 
// StringToBool converts string to bool.
bool StringToBool(std::string_view str);
 
// BoolToString converts bool to string.
inline const char* const BoolToString(bool b) { return b ? "true" : "false"; }
 
// Trim trims leading and trailing character of a string.
std::string Trim(std::string_view str, char ch = ' ');
 
// CheckNonemptystring checks whether string is not empty after trimming
// whitespaces.
bool CheckNonEmptyString(std::string_view str);
 
// ToLower converts string to lower case.
std::string ToLower(std::string str);
 
// StartsWith returns whether str starts with prefix or not.
bool StartsWith(std::string_view str, std::string_view prefix);
 
// EndsWith returns whether str ends with suffix or not.
bool EndsWith(std::string_view str, std::string_view suffix);
 
// Contains returns whether str has ch.
bool Contains(std::string_view str, char ch);
 
// Contains returns whether str has substr.
bool Contains(std::string_view str, std::string_view substr);
 
// Join returns a string of joined values by delimiter.
std::string Join(std::list<std::string> values, std::string delimiter);
 
// Join returns a string of joined values by delimiter.
std::string Join(std::vector<std::string> values, std::string delimiter);
 
// EncodePath does URL encoding of path. It also normalizes multiple slashes.
std::string EncodePath(std::string_view path);
 
// Sha256hash computes SHA-256 of data and return hash as hex encoded value.
std::string Sha256Hash(std::string_view str);
 
// Base64Encode encodes string to base64.
std::string Base64Encode(std::string_view str);
 
// Md5sumHash computes MD5 of data and return hash as Base64 encoded value.
std::string Md5sumHash(std::string_view str);
 
error::Error CheckBucketName(std::string_view bucket_name, bool strict = false);
error::Error ReadPart(std::istream& stream, char* buf, size_t size,
                      size_t& bytes_read);
error::Error CalcPartInfo(long object_size, size_t& part_size,
                          long& part_count);
 
class Time {
 private:
  struct timeval tv_;
  bool utc_;
 
 public:
  Time();
  Time(std::time_t tv_sec, suseconds_t tv_usec, bool utc);
  std::tm* ToUTC();
  std::string ToSignerDate();
  std::string ToAmzDate();
  std::string ToHttpHeaderValue();
  static Time FromHttpHeaderValue(const char* value);
  std::string ToISO8601UTC();
  static Time FromISO8601UTC(const char* value);
  static Time Now();
  operator bool() const { return tv_.tv_sec != 0 && tv_.tv_usec != 0; }
};  // class Time
 
class Multimap {
 private:
  std::map<std::string, std::set<std::string>> map_;
  std::map<std::string, std::set<std::string>> keys_;
 
 public:
  Multimap();
  Multimap(const Multimap& headers);
  void Add(std::string key, std::string value);
  void AddAll(const Multimap& headers);
  std::list<std::string> ToHttpHeaders();
  std::string ToQueryString();
  operator bool() const { return !map_.empty(); }
  bool Contains(std::string_view key);
  std::list<std::string> Get(std::string_view key);
  std::string GetFront(std::string_view key);
  std::list<std::string> Keys();
  void GetCanonicalHeaders(std::string& signed_headers,
                           std::string& canonical_headers);
  std::string GetCanonicalQueryString();
};  // class Multimap
 
struct Url {
  bool is_https;
  std::string host;
  std::string path;
  std::string query_string;
 
  operator bool() const { return !host.empty(); }
  std::string String();
};  // struct Url
 
struct CharBuffer : std::streambuf {
  CharBuffer(char* buf, size_t size) { this->setg(buf, buf, buf + size); }
 
  pos_type seekoff(off_type off, std::ios_base::seekdir dir,
                   std::ios_base::openmode which = std::ios_base::in) override {
    if (dir == std::ios_base::cur)
      gbump(off);
    else if (dir == std::ios_base::end)
      setg(eback(), egptr() + off, egptr());
    else if (dir == std::ios_base::beg)
      setg(eback(), eback() + off, egptr());
    return gptr() - eback();
  }
 
  pos_type seekpos(pos_type sp, std::ios_base::openmode which) override {
    return seekoff(sp - pos_type(off_type(0)), std::ios_base::beg, which);
  }
};  // struct CharBuffer
}  // namespace utils
}  // namespace minio
 
#endif  // #ifndef _MINIO_UTILS_H