Loading...
Searching...
No Matches
XrdClHttpFilePlugIn.cc
Go to the documentation of this file.
#include "XrdClHttp/XrdClHttpFilePlugIn.hh"
#include <unistd.h>
#include <cassert>
#include "XrdClHttp/XrdClHttpPlugInUtil.hh"
#include "XrdClHttp/XrdClHttpPosix.hh"
#include "XrdCl/XrdClDefaultEnv.hh"
#include "XrdCl/XrdClLog.hh"
#include "XrdCl/XrdClStatus.hh"
#include "XrdOuc/XrdOucCRC.hh"
namespace {
int MakePosixOpenFlags(XrdCl::OpenFlags::Flags flags) {
int posix_flags = 0;
if (flags & XrdCl::OpenFlags::New) {
posix_flags |= O_CREAT | O_EXCL;
}
if (flags & XrdCl::OpenFlags::Delete) {
posix_flags |= O_CREAT | O_TRUNC;
}
if (flags & XrdCl::OpenFlags::Read) {
posix_flags |= O_RDONLY;
}
if (flags & XrdCl::OpenFlags::Write) {
posix_flags |= O_WRONLY;
}
if (flags & XrdCl::OpenFlags::Update) {
posix_flags |= O_RDWR;
}
return posix_flags;
}
} // namespace
namespace XrdCl {
Davix::Context *root_davix_context_ = NULL;
Davix::DavPosix *root_davix_client_file_ = NULL;
HttpFilePlugIn::HttpFilePlugIn()
: davix_fd_(nullptr),
curr_offset(0),
is_open_(false),
filesize(0),
url_(),
properties_(),
logger_(DefaultEnv::GetLog()) {
SetUpLogging(logger_);
logger_->Debug(kLogXrdClHttp, "HttpFilePlugin constructed.");
std::string origin = getenv("XRDXROOTD_PROXY")? getenv("XRDXROOTD_PROXY") : "";
if ( origin.empty() || origin.find("=") == 0) {
davix_context_ = new Davix::Context();
davix_client_ = new Davix::DavPosix(davix_context_);
}
else {
if (root_davix_context_ == NULL) {
root_davix_context_ = new Davix::Context();
if (getenv("DAVIX_LOAD_GRID_MODULE_IN_XRD"))
root_davix_context_->loadModule("grid");
root_davix_client_file_ = new Davix::DavPosix(root_davix_context_);
}
davix_context_ = root_davix_context_;
davix_client_ = root_davix_client_file_;
}
}
HttpFilePlugIn::~HttpFilePlugIn() noexcept {
if (root_davix_context_ == NULL) {
delete davix_client_;
delete davix_context_;
}
}
XRootDStatus HttpFilePlugIn::Open(const std::string &url,
OpenFlags::Flags flags, Access::Mode /*mode*/,
ResponseHandler *handler, uint16_t timeout) {
if (is_open_) {
logger_->Error(kLogXrdClHttp, "URL %s already open", url.c_str());
return XRootDStatus(stError, errInvalidOp);
}
if (XrdCl::URL(url).GetProtocol().find("https") == 0)
isChannelEncrypted = true;
else
isChannelEncrypted = false;
avoid_pread_ = false;
if (getenv(HTTP_FILE_PLUG_IN_AVOIDRANGE_ENV) != NULL)
avoid_pread_ = true;
else {
XrdCl::URL::ParamsMap CGIs = XrdCl::URL(url).GetParams();
auto search = CGIs.find(HTTP_FILE_PLUG_IN_AVOIDRANGE_CGI);
if (search != CGIs.end())
avoid_pread_ = true;
}
Davix::RequestParams params;
if (timeout != 0) {
struct timespec ts = {timeout, 0};
params.setOperationTimeout(&ts);
}
if (flags & (OpenFlags::Write | OpenFlags::Update | OpenFlags::New)) {
auto full_path = XrdCl::URL(url).GetLocation();
auto pos = full_path.find_last_of('/');
auto base_dir =
pos != std::string::npos ? full_path.substr(0, pos) : full_path;
auto mkdir_status =
Posix::MkDir(*davix_client_, base_dir, XrdCl::MkDirFlags::MakePath,
XrdCl::Access::None, timeout);
if (mkdir_status.IsError()) {
logger_->Error(kLogXrdClHttp,
"Could not create parent directories when opening: %s",
url.c_str());
return mkdir_status;
}
}
if (((flags & OpenFlags::Write) || (flags & OpenFlags::Update)) &&
(flags & OpenFlags::Delete)) {
auto stat_info = new StatInfo();
auto status = Posix::Stat(*davix_client_, url, timeout, stat_info);
if (status.IsOK()) {
auto unlink_status = Posix::Unlink(*davix_client_, url, timeout);
if (unlink_status.IsError()) {
logger_->Error(
kLogXrdClHttp,
"Could not delete existing destination file: %s. Error: %s",
url.c_str(), unlink_status.GetErrorMessage().c_str());
return unlink_status;
}
}
delete stat_info;
}
else if (flags & OpenFlags::Read) {
auto stat_info = new StatInfo();
auto status = Posix::Stat(*davix_client_, url, timeout, stat_info);
if (status.IsOK()) {
filesize = stat_info->GetSize();
}
delete stat_info;
}
auto posix_open_flags = MakePosixOpenFlags(flags);
logger_->Debug(kLogXrdClHttp,
"Open: URL: %s, XRootD flags: %d, POSIX flags: %d",
url.c_str(), flags, posix_open_flags);
// res == std::pair<fd, XRootDStatus>
auto res = Posix::Open(*davix_client_, url, posix_open_flags, timeout);
if (!res.first) {
logger_->Error(kLogXrdClHttp, "Could not open: %s, error: %s", url.c_str(),
res.second.ToStr().c_str());
return res.second;
}
davix_fd_ = res.first;
logger_->Debug(kLogXrdClHttp, "Opened: %s", url.c_str());
is_open_ = true;
url_ = url;
auto status = new XRootDStatus();
handler->HandleResponse(status, nullptr);
return XRootDStatus();
}
XRootDStatus HttpFilePlugIn::Close(ResponseHandler *handler,
uint16_t /*timeout*/) {
if (!is_open_) {
logger_->Error(kLogXrdClHttp,
"Cannot close. URL hasn't been previously opened");
return XRootDStatus(stError, errInvalidOp);
}
logger_->Debug(kLogXrdClHttp, "Closing davix fd: %p", (void*)davix_fd_);
auto status = Posix::Close(*davix_client_, davix_fd_);
if (status.IsError()) {
logger_->Error(kLogXrdClHttp, "Could not close davix fd: %p, error: %s",
(void*)davix_fd_, status.ToStr().c_str());
return status;
}
is_open_ = false;
url_.clear();
handler->HandleResponse(new XRootDStatus(), nullptr);
return XRootDStatus();
}
XRootDStatus HttpFilePlugIn::Stat(bool /*force*/, ResponseHandler *handler,
uint16_t timeout) {
if (!is_open_) {
logger_->Error(kLogXrdClHttp,
"Cannot stat. URL hasn't been previously opened");
return XRootDStatus(stError, errInvalidOp);
}
auto stat_info = new StatInfo();
auto status = Posix::Stat(*davix_client_, url_, timeout, stat_info);
// A file that is_open_ = true should not retune 400/3011. the only time this
// happen is a newly created file. Davix doesn't issue a http PUT so this file
// won't show up for Stat(). Here we fake a response.
if (status.IsError() && status.code == 400 && status.errNo == 3011) {
std::ostringstream data;
data << 140737018595560 << " " << filesize << " " << 33261 << " " << time(NULL);
stat_info->ParseServerResponse(data.str().c_str());
}
else if (status.IsError()) {
logger_->Error(kLogXrdClHttp, "Stat failed: %s", status.ToStr().c_str());
return status;
}
logger_->Debug(kLogXrdClHttp, "Stat-ed URL: %s", url_.c_str());
auto obj = new AnyObject();
obj->Set(stat_info);
handler->HandleResponse(new XRootDStatus(), obj);
return XRootDStatus();
}
XRootDStatus HttpFilePlugIn::Read(uint64_t offset, uint32_t size, void *buffer,
ResponseHandler *handler,
uint16_t /*timeout*/) {
if (!is_open_) {
logger_->Error(kLogXrdClHttp,
"Cannot read. URL hasn't previously been opened");
return XRootDStatus(stError, errInvalidOp);
}
// DavPosix::pread will return -1 if the pread goes beyond the file size
size = (offset + size > filesize)? filesize - offset : size;
std::pair<int, XRootDStatus> res;
if (! avoid_pread_) {
res = Posix::PRead(*davix_client_, davix_fd_, buffer, size, offset);
}
else {
offset_locker.lock();
if (offset == curr_offset) {
res = Posix::Read(*davix_client_, davix_fd_, buffer, size);
}
else {
res = Posix::PRead(*davix_client_, davix_fd_, buffer, size, offset);
}
}
if (res.second.IsError()) {
logger_->Error(kLogXrdClHttp, "Could not read URL: %s, error: %s",
url_.c_str(), res.second.ToStr().c_str());
if (avoid_pread_) offset_locker.unlock();
return res.second;
}
int num_bytes_read = res.first;
curr_offset = offset + num_bytes_read;
if (avoid_pread_) offset_locker.unlock();
logger_->Debug(kLogXrdClHttp, "Read %d bytes, at offset %llu, from URL: %s",
num_bytes_read, (unsigned long long) offset, url_.c_str());
auto status = new XRootDStatus();
auto chunk_info = new ChunkInfo(offset, num_bytes_read, buffer);
auto obj = new AnyObject();
obj->Set(chunk_info);
handler->HandleResponse(status, obj);
return XRootDStatus();
}
class PgReadSubstitutionHandler : public XrdCl::ResponseHandler {
private:
XrdCl::ResponseHandler *realHandler;
bool isChannelEncrypted;
public:
// constructor
PgReadSubstitutionHandler(XrdCl::ResponseHandler *a,
bool isHttps) : realHandler(a), isChannelEncrypted(isHttps) {}
// Response Handler
void HandleResponse(XrdCl::XRootDStatus *status,
XrdCl::AnyObject *rdresp) {
if( !status->IsOK() )
{
realHandler->HandleResponse( status, rdresp );
delete this;
return;
}
//using namespace XrdCl;
ChunkInfo *chunk = 0;
rdresp->Get(chunk);
std::vector<uint32_t> cksums;
if( isChannelEncrypted )
{
size_t nbpages = chunk->length / XrdSys::PageSize;
if( chunk->length % XrdSys::PageSize )
++nbpages;
cksums.reserve( nbpages );
size_t size = chunk->length;
char *buffer = reinterpret_cast<char*>( chunk->buffer );
for( size_t pg = 0; pg < nbpages; ++pg )
{
size_t pgsize = XrdSys::PageSize;
if( pgsize > size ) pgsize = size;
uint32_t crcval = XrdOucCRC::Calc32C( buffer, pgsize );
cksums.push_back( crcval );
buffer += pgsize;
size -= pgsize;
}
}
PageInfo *pages = new PageInfo(chunk->offset, chunk->length, chunk->buffer, std::move(cksums));
delete rdresp;
AnyObject *response = new AnyObject();
response->Set( pages );
realHandler->HandleResponse( status, response );
delete this;
}
};
XRootDStatus HttpFilePlugIn::PgRead(uint64_t offset, uint32_t size, void *buffer,
ResponseHandler *handler,
uint16_t timeout) {
ResponseHandler *substitHandler = new PgReadSubstitutionHandler( handler, isChannelEncrypted );
XRootDStatus st = Read(offset, size, buffer, substitHandler, timeout);
return st;
}
XRootDStatus HttpFilePlugIn::Write(uint64_t offset, uint32_t size,
const void *buffer, ResponseHandler *handler,
uint16_t timeout) {
if (!is_open_) {
logger_->Error(kLogXrdClHttp,
"Cannot write. URL hasn't previously been opened");
return XRootDStatus(stError, errInvalidOp);
}
// res == std::pair<int, XRootDStatus>
auto res =
Posix::PWrite(*davix_client_, davix_fd_, offset, size, buffer, timeout);
if (res.second.IsError()) {
logger_->Error(kLogXrdClHttp, "Could not write URL: %s, error: %s",
url_.c_str(), res.second.ToStr().c_str());
return res.second;
}
else
filesize += res.first;
logger_->Debug(kLogXrdClHttp, "Wrote %d bytes, at offset %llu, to URL: %s",
res.first, (unsigned long long) offset, url_.c_str());
handler->HandleResponse(new XRootDStatus(), nullptr);
return XRootDStatus();
}
//------------------------------------------------------------------------
//------------------------------------------------------------------------
XRootDStatus HttpFilePlugIn::PgWrite( uint64_t offset,
uint32_t size,
const void *buffer,
std::vector<uint32_t> &cksums,
ResponseHandler *handler,
uint16_t timeout )
{ (void)cksums;
return Write(offset, size, buffer, handler, timeout);
}
XRootDStatus HttpFilePlugIn::Sync(ResponseHandler *handler, uint16_t timeout) {
(void)handler;
(void)timeout;
logger_->Debug(kLogXrdClHttp, "Sync is a no-op for HTTP.");
return XRootDStatus();
}
XRootDStatus HttpFilePlugIn::VectorRead(const ChunkList &chunks, void *buffer,
ResponseHandler *handler,
uint16_t /*timeout*/) {
if (!is_open_) {
logger_->Error(kLogXrdClHttp,
"Cannot read. URL hasn't previously been opened");
return XRootDStatus(stError, errInvalidOp);
}
const auto num_chunks = chunks.size();
std::vector<Davix::DavIOVecInput> input_vector(num_chunks);
std::vector<Davix::DavIOVecOuput> output_vector(num_chunks);
for (size_t i = 0; i < num_chunks; ++i) {
input_vector[i].diov_offset = chunks[i].offset;
input_vector[i].diov_size = chunks[i].length;
input_vector[i].diov_buffer = chunks[i].buffer;
}
// res == std::pair<int, XRootDStatus>
auto res = Posix::PReadVec(*davix_client_, davix_fd_, chunks, buffer);
if (res.second.IsError()) {
logger_->Error(kLogXrdClHttp, "Could not vectorRead URL: %s, error: %s",
url_.c_str(), res.second.ToStr().c_str());
return res.second;
}
int num_bytes_read = res.first;
logger_->Debug(kLogXrdClHttp, "VecRead %d bytes, from URL: %s",
num_bytes_read, url_.c_str());
char *output = static_cast<char *>(buffer);
for (size_t i = 0; i < num_chunks; ++i) {
std::memcpy(output + input_vector[i].diov_offset,
output_vector[i].diov_buffer, output_vector[i].diov_size);
}
auto status = new XRootDStatus();
auto read_info = new VectorReadInfo();
read_info->SetSize(num_bytes_read);
read_info->GetChunks() = chunks;
auto obj = new AnyObject();
obj->Set(read_info);
handler->HandleResponse(status, obj);
return XRootDStatus();
}
bool HttpFilePlugIn::IsOpen() const { return is_open_; }
bool HttpFilePlugIn::SetProperty(const std::string &name,
const std::string &value) {
properties_[name] = value;
return true;
}
bool HttpFilePlugIn::GetProperty(const std::string &name,
std::string &value) const {
const auto p = properties_.find(name);
if (p == std::end(properties_)) {
return false;
}
value = p->second;
return true;
}
} // namespace XrdCl
ts
static std::string ts()
timestamp output for logging messages
Definition XrdCephOss.cc:53
XrdClDefaultEnv.hh
XrdClHttpFilePlugIn.hh
HTTP_FILE_PLUG_IN_AVOIDRANGE_ENV
#define HTTP_FILE_PLUG_IN_AVOIDRANGE_ENV
Definition XrdClHttpFilePlugIn.hh:25
HTTP_FILE_PLUG_IN_AVOIDRANGE_CGI
#define HTTP_FILE_PLUG_IN_AVOIDRANGE_CGI
Definition XrdClHttpFilePlugIn.hh:27
XrdClHttpPlugInUtil.hh
XrdClHttpPosix.hh
XrdClLog.hh
XrdClStatus.hh
XrdOucCRC.hh
XrdCl::AnyObject
Definition XrdClAnyObject.hh:33
XrdCl::AnyObject::Set
void Set(Type object, bool own=true)
Definition XrdClAnyObject.hh:59
XrdCl::AnyObject::Get
void Get(Type &object)
Retrieve the object being held.
Definition XrdClAnyObject.hh:78
XrdCl::DefaultEnv
Definition XrdClDefaultEnv.hh:47
XrdCl::HttpFilePlugIn::PgRead
virtual XRootDStatus PgRead(uint64_t offset, uint32_t size, void *buffer, ResponseHandler *handler, uint16_t timeout) override
Definition XrdClHttpFilePlugIn.cc:344
XrdCl::HttpFilePlugIn::PgWrite
virtual XRootDStatus PgWrite(uint64_t offset, uint32_t size, const void *buffer, std::vector< uint32_t > &cksums, ResponseHandler *handler, uint16_t timeout) override
Definition XrdClHttpFilePlugIn.cc:383
XrdCl::HttpFilePlugIn::Sync
virtual XRootDStatus Sync(ResponseHandler *handler, uint16_t timeout) override
Definition XrdClHttpFilePlugIn.cc:393
XrdCl::HttpFilePlugIn::Stat
virtual XRootDStatus Stat(bool force, ResponseHandler *handler, uint16_t timeout) override
Definition XrdClHttpFilePlugIn.cc:206
XrdCl::HttpFilePlugIn::Write
virtual XRootDStatus Write(uint64_t offset, uint32_t size, const void *buffer, ResponseHandler *handler, uint16_t timeout) override
Definition XrdClHttpFilePlugIn.cc:352
XrdCl::HttpFilePlugIn::Read
virtual XRootDStatus Read(uint64_t offset, uint32_t size, void *buffer, ResponseHandler *handler, uint16_t timeout) override
Definition XrdClHttpFilePlugIn.cc:239
XrdCl::HttpFilePlugIn::VectorRead
virtual XRootDStatus VectorRead(const ChunkList &chunks, void *buffer, XrdCl::ResponseHandler *handler, uint16_t timeout) override
Definition XrdClHttpFilePlugIn.cc:403
XrdCl::HttpFilePlugIn::~HttpFilePlugIn
virtual ~HttpFilePlugIn() noexcept
Definition XrdClHttpFilePlugIn.cc:77
XrdCl::HttpFilePlugIn::Open
virtual XRootDStatus Open(const std::string &url, OpenFlags::Flags flags, Access::Mode mode, ResponseHandler *handler, uint16_t timeout) override
Definition XrdClHttpFilePlugIn.cc:84
XrdCl::HttpFilePlugIn::GetProperty
virtual bool GetProperty(const std::string &name, std::string &value) const override
Definition XrdClHttpFilePlugIn.cc:460
XrdCl::HttpFilePlugIn::Close
virtual XRootDStatus Close(ResponseHandler *handler, uint16_t timeout) override
Definition XrdClHttpFilePlugIn.cc:181
XrdCl::HttpFilePlugIn::SetProperty
virtual bool SetProperty(const std::string &name, const std::string &value) override
Definition XrdClHttpFilePlugIn.cc:454
XrdCl::HttpFilePlugIn::IsOpen
virtual bool IsOpen() const override
Definition XrdClHttpFilePlugIn.cc:452
XrdCl::HttpFilePlugIn::HttpFilePlugIn
HttpFilePlugIn()
Definition XrdClHttpFilePlugIn.cc:48
XrdCl::PgReadSubstitutionHandler
Definition XrdClHttpFilePlugIn.cc:287
XrdCl::PgReadSubstitutionHandler::HandleResponse
void HandleResponse(XrdCl::XRootDStatus *status, XrdCl::AnyObject *rdresp)
Definition XrdClHttpFilePlugIn.cc:297
XrdCl::PgReadSubstitutionHandler::PgReadSubstitutionHandler
PgReadSubstitutionHandler(XrdCl::ResponseHandler *a, bool isHttps)
Definition XrdClHttpFilePlugIn.cc:293
XrdCl::ResponseHandler
Handle an async response.
Definition XrdClXRootDResponses.hh:1127
XrdCl::ResponseHandler::HandleResponse
virtual void HandleResponse(XRootDStatus *status, AnyObject *response)
Definition XrdClXRootDResponses.hh:1156
XrdCl::StatInfo
Object stat info.
Definition XrdClXRootDResponses.hh:401
XrdCl::URL
URL representation.
Definition XrdClURL.hh:31
XrdCl::URL::ParamsMap
std::map< std::string, std::string > ParamsMap
Definition XrdClURL.hh:33
XrdCl::URL::GetLocation
std::string GetLocation() const
Get location (protocol://host:port/path).
Definition XrdClURL.cc:344
XrdCl::URL::GetParams
const ParamsMap & GetParams() const
Get the URL params.
Definition XrdClURL.hh:244
XrdCl::VectorReadInfo
Vector read info.
Definition XrdClXRootDResponses.hh:1062
XrdCl::XRootDStatus
Request status.
Definition XrdClXRootDResponses.hh:219
XrdOucCRC::Calc32C
static uint32_t Calc32C(const void *data, size_t count, uint32_t prevcs=0)
Definition XrdOucCRC.cc:190
Posix::PReadVec
std::pair< int, XrdCl::XRootDStatus > PReadVec(Davix::DavPosix &davix_client, DAVIX_FD *fd, const XrdCl::ChunkList &chunks, void *buffer)
Definition XrdClHttpPosix.cc:453
Posix::PWrite
std::pair< int, XrdCl::XRootDStatus > PWrite(Davix::DavPosix &davix_client, DAVIX_FD *fd, uint64_t offset, uint32_t size, const void *buffer, uint16_t timeout)
Definition XrdClHttpPosix.cc:480
Posix::PRead
std::pair< int, XRootDStatus > PRead(Davix::DavPosix &davix_client, DAVIX_FD *fd, void *buffer, uint32_t size, uint64_t offset)
Definition XrdClHttpPosix.cc:448
Posix::Unlink
XRootDStatus Unlink(Davix::DavPosix &davix_client, const std::string &url, uint16_t timeout)
Definition XrdClHttpPosix.cc:405
XrdCl
Definition XrdClAction.hh:34
XrdCl::Read
ReadImpl< false > Read(Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout=0)
Factory for creating ReadImpl objects.
Definition XrdClFileOperations.hh:273
XrdCl::MkDir
MkDirImpl< false > MkDir
Definition XrdClFileSystemOperations.hh:427
XrdCl::stError
const uint16_t stError
An error occurred that could potentially be retried.
Definition XrdClStatus.hh:32
XrdCl::Stat
StatImpl< false > Stat(Ctx< File > file, Arg< bool > force, uint16_t timeout=0)
Definition XrdClFileOperations.hh:535
XrdCl::Close
CloseImpl< false > Close(Ctx< File > file, uint16_t timeout=0)
Factory for creating CloseImpl objects.
Definition XrdClFileOperations.hh:482
XrdCl::errInvalidOp
const uint16_t errInvalidOp
Definition XrdClStatus.hh:51
XrdCl::root_davix_context_
Davix::Context * root_davix_context_
Definition XrdClHttpFilePlugIn.cc:45
XrdCl::ChunkList
std::vector< ChunkInfo > ChunkList
List of chunks.
Definition XrdClXRootDResponses.hh:1056
XrdCl::root_davix_client_file_
Davix::DavPosix * root_davix_client_file_
Definition XrdClHttpFilePlugIn.cc:46
XrdCl::SetUpLogging
void SetUpLogging(Log *logger)
Definition XrdClHttpPlugInUtil.cc:15
XrdCl::kLogXrdClHttp
static const uint64_t kLogXrdClHttp
Definition XrdClHttpPlugInUtil.hh:16
XrdCl::Open
OpenImpl< false > Open(Ctx< File > file, Arg< std::string > url, Arg< OpenFlags::Flags > flags, Arg< Access::Mode > mode=Access::None, uint16_t timeout=0)
Factory for creating ReadImpl objects.
Definition XrdClFileOperations.hh:215
XrdCl::value
Response NullRef< Response >::value
Definition XrdClOperationHandlers.hh:128
XrdSys::PageSize
static const int PageSize
Definition XrdSysPageSize.hh:36
XrdCl::Access::Mode
Mode
Access mode.
Definition XrdClFileSystem.hh:122
XrdCl::Access::None
@ None
Definition XrdClFileSystem.hh:123
XrdCl::ChunkInfo
Describe a data chunk for vector read.
Definition XrdClXRootDResponses.hh:918
XrdCl::ChunkInfo::buffer
void * buffer
length of the chunk
Definition XrdClXRootDResponses.hh:951
XrdCl::ChunkInfo::length
uint32_t length
offset in the file
Definition XrdClXRootDResponses.hh:950
XrdCl::ChunkInfo::offset
uint64_t offset
Definition XrdClXRootDResponses.hh:949
XrdCl::MkDirFlags::MakePath
@ MakePath
create the entire directory tree if it doesn't exist
Definition XrdClFileSystem.hh:145
XrdCl::OpenFlags::Flags
Flags
Open flags, may be or'd when appropriate.
Definition XrdClFileSystem.hh:76
XrdCl::OpenFlags::Delete
@ Delete
Definition XrdClFileSystem.hh:80
XrdCl::OpenFlags::Read
@ Read
Open only for reading.
Definition XrdClFileSystem.hh:95
XrdCl::OpenFlags::New
@ New
Definition XrdClFileSystem.hh:86
XrdCl::OpenFlags::Write
@ Write
Open only for writing.
Definition XrdClFileSystem.hh:97
XrdCl::OpenFlags::Update
@ Update
Open for reading and writing.
Definition XrdClFileSystem.hh:96
XrdCl::PageInfo
Definition XrdClXRootDResponses.hh:957
XrdCl::Status::IsOK
bool IsOK() const
We're fine.
Definition XrdClStatus.hh:124