XrdHttpReadRangeHandler.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// This file is part of XrdHTTP: A pragmatic implementation of the
// HTTP/WebDAV protocol for the Xrootd framework
//
// Copyright (c) 2013 by European Organization for Nuclear Research (CERN)
// Authors: Cedric Caffy <ccaffy@cern.ch>, David Smith
// File Date: Aug 2023
//------------------------------------------------------------------------------
// XRootD is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// XRootD is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with XRootD.  If not, see <http://www.gnu.org/licenses/>.
//------------------------------------------------------------------------------
 
#ifndef XROOTD_XRDHTTPREADRANGEHANDLER_HH
#define XROOTD_XRDHTTPREADRANGEHANDLER_HH
 
#include "XrdHttpUtils.hh"
#include <vector>
#include <string>
 
 
class XrdHttpReadRangeHandler {
public:
 
  static constexpr size_t READV_MAXCHUNKS    = 512;
  static constexpr size_t READV_MAXCHUNKSIZE = 512*1024;
  static constexpr size_t RREQ_MAXSIZE       = 8*1024*1024;
 
  struct Configuration {
    Configuration() : haveSizes(false) { }
 
    Configuration(const size_t vectorReadMaxChunkSize,
                  const size_t vectorReadMaxChunks,
                  const size_t rRequestMaxBytes)  :
      haveSizes(true), readv_ior_max(vectorReadMaxChunkSize),
      readv_iov_max(vectorReadMaxChunks), reqs_max(rRequestMaxBytes) { }
    
 
    bool haveSizes;
    size_t readv_ior_max; // max chunk size
    size_t readv_iov_max; // max number of chunks
    size_t reqs_max;      // max bytes in read or readv
  };
 
  struct Error {
    bool        errSet{false};
    int         httpRetCode{0};
    std::string errMsg;
 
    explicit operator bool() const { return errSet; }
 
    void        set(int rc, const std::string &m)
                 { httpRetCode = rc; errMsg = m; errSet = true;     }
 
    void reset() { httpRetCode = 0; errMsg.clear(); errSet = false; }
  };
 
  struct UserRange {
    bool start_set;
    bool end_set;
    off_t start;
    off_t end;
 
    UserRange() : start_set(false), end_set(false), start(0), end(0) { }
 
    UserRange(off_t st, off_t en) : start_set(true), end_set(true), start(st),
                                    end(en) { }
  };
 
  typedef std::vector<UserRange> UserRangeList;
 
  XrdHttpReadRangeHandler(const Configuration &conf)
  {
    rRequestMaxBytes_       = RREQ_MAXSIZE;
    vectorReadMaxChunkSize_ = READV_MAXCHUNKSIZE;
    vectorReadMaxChunks_    = READV_MAXCHUNKS;
 
    if( conf.haveSizes )
    {
      vectorReadMaxChunkSize_ = conf.readv_ior_max;
      vectorReadMaxChunks_    = conf.readv_iov_max;
      rRequestMaxBytes_       = conf.reqs_max;
    }
    reset();
  }
 
  static int    Configure(XrdSysError &Eroute, const char *const parms,
                          Configuration &cfg);
 
  const Error&  getError() const;
 
  size_t getMaxRanges() const;
 
  bool          isFullFile();
 
  bool          isSingleRange();
 
  const UserRangeList &ListResolvedRanges();
 
  const XrdHttpIOList &NextReadList();
 
  void          NotifyError();
 
  int           NotifyReadResult(const ssize_t ret,
                                 const UserRange** const urp,
                                 bool &start,
                                 bool &allend);
 
  void          ParseContentRange(const char* const line);
 
  void          reset();
 
  int           SetFilesize(const off_t sz);
 
private:
  int    parseOneRange(char* const str);
  int    rangeFig(const char* const s, bool &set, off_t &start);
  void   resolveRanges();
  void   splitRanges();
  void   trimSplit();
 
  Error  error_;
 
  UserRangeList rawUserRanges_;
 
  bool   rangesResolved_;
 
  UserRangeList resolvedUserRanges_;
 
  XrdHttpIOList splitRange_;
 
  // the position in resolvedUserRanges_ corresponding to all the
  // bytes notified via the NotifyReadResult() method
  size_t resolvedRangeIdx_;
  off_t  resolvedRangeOff_;
 
  // position of the method splitRanges() in within resolvedUserRanges_
  // from where it split ranges into chunks for sending to read/readv
  size_t splitRangeIdx_;
  off_t  splitRangeOff_;
 
  // the position in splitRange_ corresponding to all the
  // bytes notified via the NotifyReadResult() method
  size_t currSplitRangeIdx_;
  int    currSplitRangeOff_;
 
  off_t  filesize_;
 
  size_t vectorReadMaxChunkSize_;
  size_t vectorReadMaxChunks_;
  size_t rRequestMaxBytes_;
};
 
 
#endif //XROOTD_XRDHTTPREADRANGEHANDLER_HH