XrdCl Namespace Reference

Classes
struct	Access
	Access mode. More...
struct	Action
	Action. More...
class	ActionExecutor
	Executes an action registered in the csv file. More...
struct	ActionMetrics
	Metrics struct storing all timing and IO information of an action. More...
class	AnyObject
class	AppendFileImpl
	AppendFile operation (. More...
class	Arg
class	Arg< std::string >
class	ArgBase
	Base class for Arg. More...
class	AssignLastURLHandler
	Wrapper class used to assign last URL. More...
class	AssignLBHandler
	Wrapper class used to assign a load balancer. More...
class	AsyncDiscardReader
	Object for discarding data. More...
class	AsyncHSReader
	Utility class encapsulating reading hand-shake response logic. More...
class	AsyncHSWriter
	Utility class encapsulating writing hand-shake request logic. More...
class	AsyncMsgReader
	Utility class encapsulating reading response message logic. More...
class	AsyncMsgWriter
	Utility class encapsulating writing request logic. More...
class	AsyncPageReader
	Object for reading out data from the PgRead response. More...
class	AsyncRawReader
	Object for reading out data from the kXR_read response. More...
class	AsyncRawReaderIntfc
	Base class for any message's body reader. More...
class	AsyncSocketHandler
class	AsyncVectorReader
	Object for reading out data from the VectorRead response. More...
class	barrier_t
struct	BindPrefSelector
class	Buffer
	Binary blob representation. More...
class	BufferPool
	Buffer pool - to limit memory consumption. More...
class	Channel
	A communication channel between the client and the server. More...
class	ChannelEventHandler
	Channel event handler. More...
class	ChannelHandlerList
	A helper for handling channel event handlers. More...
class	CheckpointImpl
	Checkpoint operation (. More...
class	CheckSumHelper
	Check sum helper for stdio. More...
class	CheckSumManager
	Manage the checksum calc objects. More...
class	ChkptWrtImpl
	Checkpointed write operation (. More...
class	ChkptWrtVImpl
	Checkpointed WriteV operation (. More...
class	ChModImpl
	ChMod operation (. More...
class	ChunkHandler
struct	ChunkInfo
	Describe a data chunk for vector read. More...
class	ClassicCopyJob
struct	CloseAction
	Close action. More...
class	CloseArchiveImpl
	CloseArchive operation (. More...
class	CloseFileImpl
	CloseFile operation (. More...
class	CloseImpl
	Close operation (. More...
class	ConcreteOperation
struct	ConnErrJob
class	CopyJob
	Copy job. More...
class	CopyProcess
	Copy the data from one point to another. More...
struct	CopyProcessImpl
class	CopyProgressHandler
	Interface for copy progress notification. More...
struct	Ctx
	Utility class for storing a pointer to operation context. More...
class	DeepLocateImpl
	DeepLocate operation (. More...
class	DefaultEnv
class	DelXAttrBulkImpl
	DelXAttr bulk operation (. More...
class	DelXAttrFsBulkImpl
	DelXAttr bulk operation (. More...
class	DelXAttrFsImpl
	DelXAttr operation (. More...
class	DelXAttrImpl
	DelXAttr operation (. More...
class	DirectoryList
	Directory list. More...
struct	DirListFlags
	DirList flags. More...
class	DirListImpl
	DirList operation (. More...
class	DlgEnv
class	EcHandler
class	EcPgReadResponseHandler
class	EcPlugInFactory
	Plugin factory. More...
class	Env
class	ExOpenFuncWrapper
	Lambda wrapper. More...
struct	FcntlAction
	Fcntl action. More...
class	FcntlImpl
	Fcntl operation (. More...
class	File
	A file. More...
struct	FileImpl
class	FileOperation
class	FilePlugIn
	An interface for file plug-ins. More...
class	FileStateHandler
	Handle the stateful operations. More...
class	FileSystem
	Send file/filesystem queries to an XRootD cluster. More...
struct	FileSystemData
struct	FileSystemImpl
	Implementation holding the data members. More...
class	FileSystemOperation
class	FileSystemPlugIn
	An interface for file plug-ins. More...
class	FileSystemUtils
class	FileTimer
	Task generating timeout events for FileStateHandlers in recovery mode. More...
class	FinalOperation
class	ForkHandler
class	FreeSpace
class	FSExecutor
	Execute queries given as a commandline. More...
class	FunctionWrapper
class	FunctionWrapper< void >
class	FutureWrapper
class	FutureWrapper< void >
	A wrapper handler for a std::promise / std::future, overload for void type. More...
class	FutureWrapperBase
struct	Fwd
struct	FwdStorage
class	GetXAttrBulkImpl
	GetXAttr bulk operation (. More...
class	GetXAttrFsBulkImpl
	GetXAttr bulk operation (. More...
class	GetXAttrFsImpl
	GetXAttr operation (. More...
class	GetXAttrImpl
	GetXAttr operation (. More...
class	HandleRspJob
struct	HandShakeData
	Data structure that carries the handshake information. More...
struct	HostInfo
class	HttpFilePlugIn
class	HttpFileSystemPlugIn
struct	InMessageHelper
class	InQueue
	A synchronize queue for incoming data. More...
class	Job
	Interface for a job to be run by the job manager. More...
class	JobManager
	A synchronized queue. More...
class	ListXAttrFsImpl
	ListXAttr bulk operation (. More...
class	ListXAttrImpl
	ListXAttr bulk operation (. More...
class	LocalFileHandler
class	LocalFileTask
class	LocateImpl
	Locate operation (. More...
class	LocationInfo
	Path location info. More...
class	Log
	Handle diagnostics. More...
class	LogOut
	Interface for logger outputs. More...
class	LogOutCerr
	Write log messages to stderr. More...
class	LogOutFile
	Write log messages to a file. More...
class	Message
	The message representation used throughout the system. More...
struct	MessageSendParams
class	MessageUtils
class	MetalinkOpenHandler
class	MetalinkReadHandler
class	MetalinkRedirector
struct	MkDirFlags
	MkDir flags. More...
class	MkDirImpl
	MkDir operation (. More...
class	Monitor
	An abstract class to describe the client-side monitoring plugin interface. More...
class	MsgHandler
	Message handler. More...
class	MvImpl
	Mv operation (. More...
class	mytimer_t
	Timer helper class. More...
struct	None
	none object for initializing empty Optional More...
struct	NullRef
class	NullResponseHandler
struct	OpenAction
	Open action. More...
class	OpenArchiveImpl
	OpenArchive operation (. More...
class	OpenFileImpl
	OpenFile operation (. More...
struct	OpenFlags
	Open flags, may be or'd when appropriate. More...
class	OpenImpl
	Open operation (. More...
class	OpenInfo
	Information returned by file open operation. More...
class	Operation
class	operation_expired
class	Optional
class	OutQueue
	A synchronized queue for the outgoing data. More...
struct	PageInfo
struct	PageInfoImpl
class	ParallelOperation
struct	PathID
struct	PgReadAction
struct	PgReadFlags
	PgRead flags. More...
class	PgReadImpl
	PgRead operation (. More...
class	PgReadSubstitutionHandler
struct	PgWriteAction
class	PgWriteImpl
	PgWrite operation (. More...
class	PingImpl
	Ping operation (. More...
class	Pipeline
class	PipelineException
	Pipeline exception, wrapps an XRootDStatus. More...
class	PipelineHandler
class	PlugInFactory
	Plugin factory. More...
class	PlugInManager
	Manage client-side plug-ins and match them agains URLs. More...
struct	PluginUnloadHandler
struct	PolicyExecutor
class	Poller
	Interface for socket pollers. More...
class	PollerBuiltIn
	A poller implementation using the build-in XRootD poller. More...
class	PollerFactory
	Helper for creating poller objects. More...
class	PostMaster
	A hub for dispatching and receiving messages. More...
struct	PostMasterImpl
struct	PrepareFlags
	Prepare flags. More...
class	PrepareImpl
	Prepare operation (. More...
class	PropertyList
	A key-value pair map storing both keys and values as strings. More...
class	ProtocolImpl
	Protocol operation (. More...
class	ProtocolInfo
	Protocol response. More...
struct	QueryCode
	XRootD query request codes. More...
class	QueryImpl
	Query operation (. More...
class	RawWrapper
	Wrapper class for raw response handler (ResponseHandler). More...
struct	ReadAction
	Read action. More...
class	ReadImpl
	Read operation (. More...
struct	ReadTrait
	RdWithRsp: factory for creating ReadImpl/PgReadImpl objects. More...
struct	ReadTrait< ChunkInfo >
struct	ReadTrait< PageInfo >
class	Recorder
class	RecorderFactory
	XrdCl recorder plug-in factory. More...
struct	RedirectEntry
class	RedirectJob
	A job class for redirect handling in the thread-pool. More...
class	RedirectorRegistry
	Singleton access to URL to virtual redirector mapping. More...
class	ReplayArgs
	Args parse for XrdClReplay. More...
class	RequestSync
	A helper running a fixed number of requests at a given time. More...
struct	Resp
struct	Resp< void >
struct	RespBase
class	ResponseHandler
	Handle an async response. More...
class	ResponseJob
	Call the user callback. More...
struct	RetryInfo
struct	RetryInfoImpl
class	RmDirImpl
	RmDir operation (. More...
class	RmImpl
	Rm operation (. More...
class	ScopedDescriptor
	Smart descriptor - closes the descriptor on destruction. More...
class	SendInfoImpl
	SendInfo operation (. More...
struct	seq_gen
struct	seq_gen< 0, Ns... >
struct	seq_gen< I, Ns... >
struct	sequence
class	ServerSpaceInfo
class	SetXAttrBulkImpl
	SetXAttr bulk operation (. More...
class	SetXAttrFsBulkImpl
	SetXAttr bulk operation (. More...
class	SetXAttrFsImpl
	SetXAttr operation (. More...
class	SetXAttrImpl
	SetXAttr operation (. More...
class	SIDManager
	Handle XRootD stream IDs. More...
class	SIDMgrPool
	Pool of SID manager objects. More...
class	Socket
	A network socket. More...
class	SocketHandler
	Interface. More...
struct	StatAction
	Stat action. More...
class	StatFsImpl
	Stat operation (. More...
class	StatImpl
	Stat operation (. More...
class	StatInfo
	Object stat info. More...
struct	StatInfoImpl
class	StatInfoVFS
	VFS stat info. More...
struct	Status
	Procedure execution status. More...
class	StatVFSImpl
	StatVS operation (. More...
class	Stream
	Stream. More...
struct	StreamQuery
struct	StreamSelector
	Selects less loaded stream for read operation over multiple streams. More...
struct	SubStreamData
struct	SyncAction
	Sync action. More...
class	SyncImpl
	Sync operation (. More...
class	SyncQueue
	A synchronized queue. More...
class	SyncResponseHandler
	Synchronize the response. More...
class	Task
	Interface for a task to be run by the TaskManager. More...
class	TaskManager
class	TaskWrapper
class	TaskWrapper< void, Return >
class	ThirdPartyCopyJob
class	TickGeneratorTask
class	Timeout
class	Tls
	TLS layer for socket connection. More...
class	TPFallBackCopyJob
class	TransportHandler
	Perform the handshake and the authentication for each physical stream. More...
class	TransportManager
	Manage transport handler objects. More...
struct	TransportQuery
struct	TruncateAction
	Truncate action. More...
class	TruncateFsImpl
	Truncate operation (. More...
class	TruncateImpl
	Truncate operation (. More...
class	UnpackXAttr
	Helper class for unpacking single XAttr from bulk response. More...
class	UnpackXAttrStatus
	Helper class for unpacking single XAttrStatus from bulk response. More...
class	URL
	URL representation. More...
class	Utils
	Random utilities. More...
struct	VectorReadAction
	VectorRead action. More...
class	VectorReadImpl
	VectorRead operation (. More...
class	VectorReadInfo
	Vector read info. More...
struct	VectorWriteAction
	Vector Write action. More...
class	VectorWriteImpl
	VectorWrite operation (. More...
class	VirtualRedirector
	An interface for metadata redirectors. More...
class	VisaImpl
	Visa operation (. More...
struct	WriteAction
	Write action. More...
class	WriteImpl
	Write operation (. More...
class	WriteVImpl
	WriteV operation (. More...
struct	XAttr
	Extended attributes with status. More...
struct	XAttrStatus
	Extended attribute operation status. More...
class	XCpCtx
class	XCpSrc
struct	XRootDChannelInfo
	Information holder for xrootd channels. More...
class	XRootDMsgHandler
	Handle/Process/Forward XRootD messages. More...
struct	XRootDQuery
	XRootD related protocol queries. More...
class	XRootDStatus
	Request status. More...
struct	XRootDStreamInfo
	Information holder for XRootDStreams. More...
class	XRootDTransport
	XRootD transport handler. More...
class	ZipArchive
class	ZipCache
	Utility class for inflating a compressed buffer. More...
struct	ZipError
	An exception for carrying the XRootDStatus of InflCache. More...
class	ZipListHandler
class	ZipListImpl
	ZipList operation (. More...
class	ZipOperation
class	ZipReadFromImpl
	Read operation (. More...
class	ZipReadImpl
	Read operation (. More...
class	ZipStatImpl
	ZipStat operation (. More...
class	ZipWriteImpl
	Write operation (. More...

Typedefs
using	action_list = std::multimap<double, ActionExecutor>
	List of actions: start time - action.
typedef Buffer	BinaryDataInfo
	Binary buffer.
typedef ChModImpl< false >	ChMod
typedef std::vector< ChunkInfo >	ChunkList
	List of chunks.
typedef CloseFileImpl< false >	CloseFile
typedef DeepLocateImpl< false >	DeepLocate
typedef DirListImpl< false >	DirList
typedef FcntlImpl< false >	Fcntl
typedef FinalOperation	Final
typedef std::vector< HostInfo >	HostList
typedef LocateImpl< false >	Locate
typedef MkDirImpl< false >	MkDir
typedef MvImpl< false >	Mv
typedef PingImpl< false >	Ping
typedef PrepareImpl< false >	Prepare
typedef ProtocolImpl< false >	Protocol
typedef QueryImpl< false >	Query
typedef std::function< Operation< true > *(const XRootDStatus &)>	rcvry_func
	Type of the recovery function to be provided by the user.
typedef RmImpl< false >	Rm
typedef RmDirImpl< false >	RmDir
typedef SendInfoImpl< false >	SendInfo
typedef StatVFSImpl< false >	StatVFS
typedef VisaImpl< false >	Visa
typedef std::tuple< std::string, std::string >	xattr_t
	Extended attribute key - value pair.

Enumerations
enum	{   xattr_name = 0 ,   xattr_value = 1 }
	Tuple indexes of name and value fields in xattr_t. More...
enum	ChkPtCode {   BEGIN = kXR_ckpBegin ,   COMMIT = kXR_ckpCommit ,   ROLLBACK = kXR_ckpRollback }
	Checkpoint operation code. More...

Functions
AppendFileImpl< false >	AppendFile (Ctx< ZipArchive > zip, Arg< std::string > fn, Arg< uint32_t > crc32, Arg< uint32_t > size, Arg< const void * > buffer, uint16_t timeout=0)
	Factory for creating ArchiveReadImpl objects.
template<typename FUNC, typename ... ARGs>
static auto	Apply (FUNC &&func, std::tuple< ARGs... > &tup) -> decltype(tuple_call_impl(func, tup, typename seq_gen< sizeof...(ARGs)>::type{}))
template<typename METH, typename OBJ, typename ... ARGs>
static auto	Apply (METH &&method, OBJ &obj, std::tuple< ARGs... > &tup) -> decltype(Apply(std::bind(method, &obj, std::placeholders::_1, std::placeholders::_2), tup))
bool	AssureFile (const std::string &url, uint64_t size, bool viatruncate, bool verify)
	AssureFile creates input data files on the fly if required.
std::future< XRootDStatus >	Async (Pipeline pipeline, uint16_t timeout=0)
CheckpointImpl< false >	Checkpoint (Ctx< File > file, Arg< ChkPtCode > code, uint16_t timeout=0)
	Factory for creating ReadImpl objects.
ChkptWrtImpl< false >	ChkptWrt (Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< const void * > buffer, uint16_t timeout=0)
	Factory for creating ReadImpl objects.
ChkptWrtVImpl< false >	ChkptWrtV (Ctx< File > file, Arg< uint64_t > offset, Arg< std::vector< iovec > > iov, uint16_t timeout=0)
	Factory for creating ChkptWrtVImpl objects.
CloseImpl< false >	Close (Ctx< File > file, uint16_t timeout=0)
	Factory for creating CloseImpl objects.
CloseArchiveImpl< false >	CloseArchive (Ctx< ZipArchive > zip, uint16_t timeout=0)
	Factory for creating CloseFileImpl objects.
void	DeallocArgs (XRootDStatus *status, AnyObject *response, HostList *hostList)
DelXAttrImpl< false >	DelXAttr (Ctx< File > file, Arg< std::string > name)
DelXAttrBulkImpl< false >	DelXAttr (Ctx< File > file, Arg< std::vector< std::string > > attrs)
DelXAttrFsImpl< false >	DelXAttr (Ctx< FileSystem > fs, Arg< std::string > path, Arg< std::string > name)
DelXAttrFsBulkImpl< false >	DelXAttr (Ctx< FileSystem > fs, Arg< std::string > path, Arg< std::vector< std::string > > attrs)
std::thread	ExecuteActions (std::unique_ptr< File > file, action_list &&actions, double t0, double speed, ActionMetrics &metric, bool simulate)
EcHandler *	GetEcHandler (const URL &headnode, const URL &redirurl)
template<typename Response>
Response *	GetResponse (AnyObject *rsp)
template<typename Response>
Response *	GetResponse (XRootDStatus *status, AnyObject *rsp)
GetXAttrImpl< false >	GetXAttr (Ctx< File > file, Arg< std::string > name)
GetXAttrBulkImpl< false >	GetXAttr (Ctx< File > file, Arg< std::vector< std::string > > attrs)
GetXAttrFsImpl< false >	GetXAttr (Ctx< FileSystem > fs, Arg< std::string > path, Arg< std::string > name)
GetXAttrFsBulkImpl< false >	GetXAttr (Ctx< FileSystem > fs, Arg< std::string > path, Arg< std::vector< std::string > > attrs)
bool	InitTLS ()
ZipListImpl< false >	List (Ctx< ZipArchive > zip)
	Factory for creating ZipStatImpl objects.
ListXAttrImpl< false >	ListXAttr (Ctx< File > file)
ListXAttrFsImpl< false >	ListXAttr (Ctx< FileSystem > fs, Arg< std::string > path)
template<typename T, typename... Args>
std::shared_ptr< FwdStorage< T > >	make_fwd (Args &&... args)
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.
OpenArchiveImpl< false >	OpenArchive (Ctx< ZipArchive > zip, Arg< std::string > fn, Arg< OpenFlags::Flags > flags, uint16_t timeout=0)
	Factory for creating OpenArchiveImpl objects.
OpenFileImpl< false >	OpenFile (Ctx< ZipArchive > zip, Arg< std::string > fn, Arg< OpenFlags::Flags > flags=OpenFlags::None, Arg< uint64_t > size=0, Arg< uint32_t > crc32=0, uint16_t timeout=0)
	Factory for creating OpenFileImpl objects.
template<class Container>
ParallelOperation< false >	Parallel (Container &&container)
	Factory function for creating parallel operation from a vector.
template<typename ... Operations>
ParallelOperation< false >	Parallel (Operations &&... operations)
std::unordered_map< File *, action_list >	ParseInput (const std::string &path, double &t0, double &t1, std::unordered_map< File *, std::string > &filenames, std::unordered_map< File *, double > &synchronicity, std::unordered_map< File *, size_t > &responseerrors, const std::vector< std::string > &option_regex)
PgReadImpl< false >	PgRead (Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout=0)
	Factory for creating PgReadImpl objects.
PgWriteImpl< false >	PgWrite (Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, Arg< std::vector< uint32_t > > cksums, uint16_t timeout=0)
	Factory for creating PgReadImpl objects.
PgWriteImpl< false >	PgWrite (Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout=0)
	Factory for creating PgReadImpl objects.
void	PipesToVec (std::vector< Pipeline > &)
	Helper function for converting parameter pack into a vector.
template<typename ... Others>
void	PipesToVec (std::vector< Pipeline > &v, Operation< false > &operation, Others &... others)
template<typename ... Others>
void	PipesToVec (std::vector< Pipeline > &v, Operation< true > &operation, Others &... others)
template<typename ... Others>
void	PipesToVec (std::vector< Pipeline > &v, Pipeline &pipeline, Others &... others)
template<>
std::string	PropertyList::Get< std::string > (const std::string &name) const
template<>
bool	PropertyList::Get< std::string > (const std::string &name, std::string &item) const
template<>
bool	PropertyList::Get< std::vector< std::string > > (const std::string &name, std::vector< std::string > &item) const
template<>
void	PropertyList::Set< std::vector< std::string > > (const std::string &name, const std::vector< std::string > &item)
template<typename RSP>
ReadTrait< RSP >::RET	RdWithRsp (Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout=0)
template<>
ReadImpl< false >	RdWithRsp< ChunkInfo > (Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout)
template<>
PgReadImpl< false >	RdWithRsp< PageInfo > (Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout)
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.
ZipReadImpl< false >	Read (Ctx< ZipArchive > zip, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout=0)
	Factory for creating ArchiveReadImpl objects.
ZipReadFromImpl< false >	ReadFrom (Ctx< ZipArchive > zip, Arg< std::string > fn, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout=0)
	Factory for creating ArchiveReadImpl objects.
template<typename RSP>
XRootDStatus	ReadFromImpl (ZipArchive &me, const std::string &fn, uint64_t relativeOffset, uint32_t size, void *usrbuff, ResponseHandler *usrHandler, uint16_t timeout)
void	SetUpLogging (Log *logger)
SetXAttrImpl< false >	SetXAttr (Ctx< File > file, Arg< std::string > name, Arg< std::string > value)
SetXAttrBulkImpl< false >	SetXAttr (Ctx< File > file, Arg< std::vector< xattr_t > > attrs)
SetXAttrFsImpl< false >	SetXAttr (Ctx< FileSystem > fs, Arg< std::string > path, Arg< std::string > name, Arg< std::string > value)
SetXAttrFsBulkImpl< false >	SetXAttr (Ctx< FileSystem > fs, Arg< std::string > path, Arg< std::vector< xattr_t > > attrs)
StatImpl< false >	Stat (Ctx< File > file, Arg< bool > force, uint16_t timeout=0)
StatFsImpl< false >	Stat (Ctx< FileSystem > fs, Arg< std::string > path)
ZipStatImpl< false >	Stat (Ctx< ZipArchive > zip)
	Factory for creating ZipStatImpl objects.
SyncImpl< false >	Sync (Ctx< File > file, uint16_t timeout=0)
	Factory for creating SyncImpl objects.
template<typename T>
T &	To (AnyObject &any)
static std::string	to_lower (std::string str)
std::vector< std::string >	ToColumns (const std::string &row)
	Split a row into columns.
TruncateImpl< false >	Truncate (Ctx< File > file, Arg< uint64_t > size, uint16_t timeout)
TruncateFsImpl< false >	Truncate (Ctx< FileSystem > fs, Arg< std::string > path, Arg< uint64_t > size)
template<typename FUNC, typename TUPL, int ... INDICES>
static auto	tuple_call_impl (FUNC &func, TUPL &args, sequence< INDICES... >) -> decltype(func(std::move(std::get< INDICES >(args))...))
VectorReadImpl< false >	VectorRead (Ctx< File > file, Arg< ChunkList > chunks, Arg< void * > buffer, uint16_t timeout=0)
	Factory for creating VectorReadImpl objects.
VectorReadImpl< false >	VectorRead (Ctx< File > file, Arg< ChunkList > chunks, uint16_t timeout=0)
VectorWriteImpl< false >	VectorWrite (Ctx< File > file, Arg< ChunkList > chunks, uint16_t timeout=0)
	Factory for creating VectorWriteImpl objects.
XRootDStatus	WaitFor (Pipeline pipeline, uint16_t timeout=0)
WriteImpl< false >	Write (Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< const void * > buffer, uint16_t timeout=0)
	Factory for creating WriteImpl objects.
ZipWriteImpl< false >	Write (Ctx< ZipArchive > zip, Arg< uint32_t > size, Arg< const void * > buffer, uint16_t timeout=0)
	Factory for creating ArchiveReadImpl objects.
WriteVImpl< false >	WriteV (Ctx< File > file, Arg< uint64_t > offset, Arg< std::vector< iovec > > iov, uint16_t timeout=0)
	Factory for creating WriteVImpl objects.

Variables
const uint64_t	AppMsg = 0x0000000000000001ULL
const uint64_t	AsyncSockMsg = 0x0000000000000200ULL
const int	DefaultAioSignal = 0
const char *const	DefaultClConfDir = ""
const char *const	DefaultClConfFile = ""
const char *const	DefaultClientMonitor = ""
const char *const	DefaultClientMonitorParam = ""
const int	DefaultConnectionRetry = 5
const int	DefaultConnectionWindow = 120
const int	DefaultCPChunkSize = 8388608
const int	DefaultCPInitTimeout = 600
const int	DefaultCPParallelChunks = 4
const int	DefaultCpRetry = 0
const char *const	DefaultCpRetryPolicy = "force"
const char *const	DefaultCpTarget = ""
const int	DefaultCPTimeout = 0
const int	DefaultCPTPCTimeout = 1800
const int	DefaultCpUsePgWrtRd = 1
const int	DefaultDataServerTTL = 300
const char *const	DefaultGlfnRedirector = ""
const int	DefaultIPNoShuffle = 0
const int	DefaultLoadBalancerTTL = 1200
const int	DefaultLocalMetalinkFile = 0
const int	DefaultMaxMetalinkWait = 60
const int	DefaultMetalinkProcessing = 1
const int	DefaultMultiProtocol = 0
const char *const	DefaultNetworkStack = "IPAuto"
const int	DefaultNoDelay = 1
const int	DefaultNotAuthorizedRetryLimit = 3
const int	DefaultNoTlsOK = 0
const char *const	DefaultOpenRecovery = "true"
const int	DefaultParallelEvtLoop = 10
const char *const	DefaultPlugIn = ""
const char *const	DefaultPlugInConfDir = ""
const char *const	DefaultPollerPreference = "built-in"
const int	DefaultPreferIPv4 = 0
const int	DefaultPreserveLocateTried = 1
const int	DefaultPreserveXAttrs = 0
const char *const	DefaultReadRecovery = "true"
const int	DefaultRedirectLimit = 16
const int	DefaultRequestTimeout = 1800
const int	DefaultRetryWrtAtLBLimit = 3
const int	DefaultRunForkHandler = 1
const int	DefaultStreamErrorWindow = 1800
const int	DefaultStreamTimeout = 60
const int	DefaultSubStreamsPerChannel = 1
const int	DefaultTCPKeepAlive = 0
const int	DefaultTCPKeepAliveInterval = 75
const int	DefaultTCPKeepAliveProbes = 9
const int	DefaultTCPKeepAliveTime = 7200
const int	DefaultTimeoutResolution = 15
const char *const	DefaultTlsDbgLvl = "OFF"
const int	DefaultTlsMetalink = 0
const int	DefaultTlsNoData = 0
const int	DefaultWantTlsOnNoPgrw = 0
const int	DefaultWorkerThreads = 3
const char *const	DefaultWriteRecovery = "true"
const int	DefaultXCpBlockSize = 134217728
const int	DefaultXRateThreshold = 0
const int	DefaultZipMtlnCksum = 0
const uint16_t	errAuthFailed = 204
const uint16_t	errCheckSumError = 305
const uint16_t	errConfig = 6
	System misconfigured.
const uint16_t	errConnectionError = 108
const uint16_t	errCorruptedHeader = 307
const uint16_t	errDataError = 14
	data is corrupted
const uint16_t	errErrorResponse = 400
const uint16_t	errFcntl = 4
	failed manipulate file descriptor
const uint16_t	errHandShakeFailed = 202
const uint16_t	errInProgress = 10
const uint16_t	errInternal = 7
	Internal error.
const uint16_t	errInvalidAddr = 101
const uint16_t	errInvalidArgs = 9
const uint16_t	errInvalidMessage = 201
const uint16_t	errInvalidOp = 3
const uint16_t	errInvalidRedirectURL = 302
const uint16_t	errInvalidResponse = 303
const uint16_t	errInvalidSession = 109
const uint16_t	errLocalError = 402
const uint16_t	errLoginFailed = 203
const uint16_t	errNoMoreFreeSIDs = 301
const uint16_t	errNoMoreReplicas = 16
	No more replicas to try.
const uint16_t	errNone = 0
	No error.
const uint16_t	errNotFound = 304
const uint16_t	errNotImplemented = 15
	Operation is not implemented.
const uint16_t	errNotSupported = 13
const uint16_t	errOperationExpired = 206
const uint16_t	errOperationInterrupted = 207
const uint16_t	errOSError = 12
const uint16_t	errPipelineFailed = 17
	Pipeline failed and operation couldn't be executed.
const uint16_t	errPoll = 5
	error while polling descriptors
const uint16_t	errPollerError = 105
const uint16_t	errQueryNotSupported = 205
const uint16_t	errRedirect = 401
const uint16_t	errRedirectLimit = 306
const uint16_t	errResponseNegative = 500
	Query response was negative.
const uint16_t	errRetry = 1
	Try again for whatever reason.
const uint16_t	errSocketDisconnected = 104
const uint16_t	errSocketError = 102
const uint16_t	errSocketOptError = 106
const uint16_t	errSocketTimeout = 103
const uint16_t	errStreamDisconnect = 107
const uint16_t	errThresholdExceeded = 208
const uint16_t	errTlsError = 110
const uint16_t	errUninitialized = 11
const uint16_t	errUnknown = 2
	Unknown error.
const uint16_t	errUnknownCommand = 8
const uint64_t	ExDbgMsg = 0x0000000000001000ULL
const uint64_t	FileMsg = 0x0000000000000004ULL
const uint64_t	FileSystemMsg = 0x0000000000000100ULL
const uint64_t	JobMgrMsg = 0x0000000000000400ULL
static const uint64_t	kLogXrdClHttp = std::numeric_limits<std::uint64_t>::max()
static struct XrdCl::None	none
template<typename Response>
Response	NullRef< Response >::value
const uint64_t	PlugInMgrMsg = 0x0000000000000800ULL
const uint64_t	PollerMsg = 0x0000000000000008ULL
const uint64_t	PostMasterMsg = 0x0000000000000010ULL
Davix::Context *	root_ctx_ = NULL
Davix::DavPosix *	root_davix_client_ = NULL
Davix::DavPosix *	root_davix_client_file_ = NULL
Davix::Context *	root_davix_context_ = NULL
const uint16_t	stError = 0x0001
	An error occurred that could potentially be retried.
const uint16_t	stFatal = 0x0003
	Fatal error, it's still an error.
const uint16_t	stOK = 0x0000
	Everything went OK.
const uint16_t	suAlreadyDone = 4
const uint16_t	suContinue = 1
const uint16_t	suDone = 0
const uint16_t	suNotStarted = 5
const uint16_t	suPartial = 3
const uint16_t	suRetry = 2
const uint64_t	TaskMgrMsg = 0x0000000000000040ULL
static std::unordered_map< std::string, int >	theDefaultInts
static std::unordered_map< std::string, std::string >	theDefaultStrs
const uint64_t	TlsMsg = 0x0000000000002000ULL
const uint64_t	UtilityMsg = 0x0000000000000002ULL
const uint64_t	XRootDMsg = 0x0000000000000080ULL
const uint64_t	XRootDTransportMsg = 0x0000000000000020ULL
const uint64_t	ZipMsg = 0x0000000000004000ULL

Detailed Description

When the envar XRD_CLIENTMONITOR is set to the libpath/libname.so that holds the monitoring object, it is automatically loaded. The following "C" external symbols must exist in the monitor plug-in shared library. It is called to obtain an instance of the XrdCl::Monitor object.

Parameters

exec	full path name to executable provided by XrdSysUtils::ExecName
parms	Value of XRD_CLIENTMONITOPARAM envar or null if it is not set.

Returns

Pointer to an instance of XrdCl::Monitor or null which causes monitoring to be disabled.

extern "C" { XrdCl::Monitor *XrdClGetMonitor(const char *exec, const char *parms); }

This file is part of XrdClHttp

---

Class Documentation

XrdCl::CopyProcessImpl

struct XrdCl::CopyProcessImpl

Definition at line 202 of file XrdClCopyProcess.cc.

Collaboration diagram for XrdCl::CopyProcessImpl:

Class Members
vector< PropertyList >	pJobProperties
vector< PropertyList * >	pJobResults
vector< CopyJob * >	pJobs

XrdCl::None

struct XrdCl::None

none object for initializing empty Optional

Definition at line 35 of file XrdClOptional.hh.

Collaboration diagram for XrdCl::None:

XrdCl::ReadTrait

struct XrdCl::ReadTrait

template<typename RSP>
struct XrdCl::ReadTrait< RSP >

RdWithRsp: factory for creating ReadImpl/PgReadImpl objects.

Definition at line 342 of file XrdClFileOperations.hh.

Collaboration diagram for XrdCl::ReadTrait< RSP >:

XrdCl::ReadTrait< ChunkInfo >

struct XrdCl::ReadTrait< ChunkInfo >

Definition at line 344 of file XrdClFileOperations.hh.

Collaboration diagram for XrdCl::ReadTrait< ChunkInfo >:

Class Members
typedef ReadImpl< false >	RET ReadImpl<false>

XrdCl::ReadTrait< PageInfo >

struct XrdCl::ReadTrait< PageInfo >

Definition at line 346 of file XrdClFileOperations.hh.

Collaboration diagram for XrdCl::ReadTrait< PageInfo >:

Class Members
typedef PgReadImpl< false >	RET PgReadImpl<false>

XrdCl::seq_gen

struct XrdCl::seq_gen

template<int ... Ns>
struct XrdCl::seq_gen< Ns >

Definition at line 32 of file XrdClApply.hh.

Collaboration diagram for XrdCl::seq_gen< Ns >:

XrdCl::seq_gen< 0, Ns... >

struct XrdCl::seq_gen< 0, Ns... >

template<int ... Ns>
struct XrdCl::seq_gen< 0, Ns... >

Definition at line 43 of file XrdClApply.hh.

Collaboration diagram for XrdCl::seq_gen< 0, Ns... >:

Class Members
typedef sequence< Ns... >	type sequence<Ns...>

XrdCl::seq_gen< I, Ns... >

struct XrdCl::seq_gen< I, Ns... >

template<int I, int ... Ns>
struct XrdCl::seq_gen< I, Ns... >

Definition at line 36 of file XrdClApply.hh.

Collaboration diagram for XrdCl::seq_gen< I, Ns... >:

Class Members
typedef typename type	type typename seq_gen<I - 1, I - 1, Ns...>::type

XrdCl::sequence

struct XrdCl::sequence

template<int ... Is>
struct XrdCl::sequence< Is >

Definition at line 29 of file XrdClApply.hh.

Collaboration diagram for XrdCl::sequence< Is >:

Typedef Documentation

action_list

using XrdCl::action_list = std::multimap<double, ActionExecutor>

List of actions: start time - action.

Definition at line 898 of file XrdClReplay.cc.

BinaryDataInfo

typedef Buffer XrdCl::BinaryDataInfo

Binary buffer.

Definition at line 336 of file XrdClXRootDResponses.hh.

ChMod

typedef ChModImpl<false> XrdCl::ChMod

Definition at line 521 of file XrdClFileSystemOperations.hh.

ChunkList

typedef std::vector<ChunkInfo> XrdCl::ChunkList

List of chunks.

Definition at line 1056 of file XrdClXRootDResponses.hh.

CloseFile

typedef CloseFileImpl<false> XrdCl::CloseFile

Definition at line 475 of file XrdClZipOperations.hh.

DeepLocate

typedef DeepLocateImpl<false> XrdCl::DeepLocate

Definition at line 184 of file XrdClFileSystemOperations.hh.

DirList

typedef DirListImpl<false> XrdCl::DirList

Definition at line 746 of file XrdClFileSystemOperations.hh.

Fcntl

typedef FcntlImpl<false> XrdCl::Fcntl

Definition at line 922 of file XrdClFileOperations.hh.

Final

typedef FinalOperation XrdCl::Final

Definition at line 67 of file XrdClFinalOperation.hh.

HostList

typedef std::vector<HostInfo> XrdCl::HostList

Definition at line 1121 of file XrdClXRootDResponses.hh.

Locate

typedef LocateImpl<false> XrdCl::Locate

Definition at line 136 of file XrdClFileSystemOperations.hh.

MkDir

typedef MkDirImpl<false> XrdCl::MkDir

Definition at line 427 of file XrdClFileSystemOperations.hh.

Mv

typedef MvImpl<false> XrdCl::Mv

Definition at line 232 of file XrdClFileSystemOperations.hh.

Ping

typedef PingImpl<false> XrdCl::Ping

Definition at line 560 of file XrdClFileSystemOperations.hh.

Prepare

typedef PrepareImpl<false> XrdCl::Prepare

Definition at line 843 of file XrdClFileSystemOperations.hh.

Protocol

typedef ProtocolImpl<false> XrdCl::Protocol

Definition at line 698 of file XrdClFileSystemOperations.hh.

Query

typedef QueryImpl<false> XrdCl::Query

Definition at line 280 of file XrdClFileSystemOperations.hh.

rcvry_func

typedef std::function<Operation<true>*(const XRootDStatus&)> XrdCl::rcvry_func

Type of the recovery function to be provided by the user.

Definition at line 161 of file XrdClOperations.hh.

Rm

typedef RmImpl<false> XrdCl::Rm

Definition at line 378 of file XrdClFileSystemOperations.hh.

RmDir

typedef RmDirImpl<false> XrdCl::RmDir

Definition at line 473 of file XrdClFileSystemOperations.hh.

SendInfo

typedef SendInfoImpl<false> XrdCl::SendInfo

Definition at line 793 of file XrdClFileSystemOperations.hh.

StatVFS

typedef StatVFSImpl<false> XrdCl::StatVFS

Definition at line 658 of file XrdClFileSystemOperations.hh.

Visa

typedef VisaImpl<false> XrdCl::Visa

Definition at line 961 of file XrdClFileOperations.hh.

xattr_t

typedef std::tuple<std::string, std::string> XrdCl::xattr_t

Extended attribute key - value pair.

Definition at line 289 of file XrdClXRootDResponses.hh.

Enumeration Type Documentation

anonymous enum

anonymous enum

Tuple indexes of name and value fields in xattr_t.

Enumerator
xattr_name
xattr_value

Definition at line 280 of file XrdClXRootDResponses.hh.

  {
    xattr_name  = 0,
    xattr_value = 1
  };

ChkPtCode

enum XrdCl::ChkPtCode

Checkpoint operation code.

Enumerator
BEGIN
COMMIT
ROLLBACK

Definition at line 18 of file XrdClCheckpointOperation.hh.

  {
    BEGIN = kXR_ckpBegin, COMMIT = kXR_ckpCommit, ROLLBACK = kXR_ckpRollback
  };

Function Documentation

AppendFile()

AppendFileImpl< false > XrdCl::AppendFile ( Ctx< ZipArchive > zip, Arg< std::string > fn, Arg< uint32_t > crc32, Arg< uint32_t > size, Arg< const void * > buffer, uint16_t timeout = 0 )

inline

Factory for creating ArchiveReadImpl objects.

Definition at line 421 of file XrdClZipOperations.hh.

  {
    return AppendFileImpl<false>( std::move( zip ), std::move( fn ), std::move( crc32 ),
                                  std::move( size ), std::move( buffer ) ).Timeout( timeout );
  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Here is the call graph for this function:

Apply() [1/2]

template<typename FUNC, typename ... ARGs>

auto XrdCl::Apply ( FUNC && func, std::tuple< ARGs... > & tup ) -> decltype( tuple_call_impl( func, tup, typename seq_gen<sizeof...(ARGs)>::type{} ) )

inlinestatic

Definition at line 64 of file XrdClApply.hh.

                                                                               {} ) )
  {
      return tuple_call_impl( func, tup, typename seq_gen<sizeof...(ARGs)>::type{} );
  }

Referenced by Apply().

Here is the caller graph for this function:

Apply() [2/2]

template<typename METH, typename OBJ, typename ... ARGs>

auto XrdCl::Apply ( METH && method, OBJ & obj, std::tuple< ARGs... > & tup ) -> decltype( Apply( std::bind( method, &obj, std::placeholders::_1, std::placeholders::_2 ), tup ) )

inlinestatic

Definition at line 80 of file XrdClApply.hh.

  {
    return Apply( std::bind( method, &obj, std::placeholders::_1, std::placeholders::_2 ), tup );
  }

References Apply().

Here is the call graph for this function:

AssureFile()

bool XrdCl::AssureFile	(	const std::string &	url,
		uint64_t	size,
		bool	viatruncate,
		bool	verify )

AssureFile creates input data files on the fly if required.

Definition at line 216 of file XrdClReplay.cc.

{
  OpenFlags::Flags flags   = OpenFlags::Read;
  Access::Mode     mode    = Access::None;
  uint16_t         timeout = 60;
 
  {
    // deal with existing files
    auto         file   = std::make_unique<XrdCl::File>(false);
    XRootDStatus status = file->Open(url, flags, mode, timeout);
    if (status.IsOK())
    {
      StatInfo* statinfo;
      // file exists already, verify the size
      status = file->Stat(false, statinfo, timeout);
      if (status.IsOK())
      {
        if (statinfo->GetSize() < size)
        {
          std::cerr
            << "Error: file size is not sufficient, but I won't touch the file - aborting ...";
          return false;
        }
        else
        {
          std::cout << "# ---> info: file exists and has sufficient size" << std::endl;
          return true;
        }
      }
    }
  }
 
  if (verify)
  {
    std::cerr << "Verify: file is missing or inaccessible: " << url << std::endl;
    return false;
  }
 
  {
    // deal with non-existing file
    OpenFlags::Flags wflags = OpenFlags::New | OpenFlags::Write | OpenFlags::MakePath;
    Access::Mode     wmode  = Access::UR | Access::UW | Access::UX;
    auto             file   = std::make_unique<XrdCl::File>(false);
    XRootDStatus     status = file->Open(url, wflags, wmode, timeout);
    if (status.IsOK())
    {
      if (viatruncate)
      {
        // create a file via truncation
        status = file->Truncate(size, timeout);
        if (!status.IsOK())
        {
          std::cerr << "Error: " << status.ToString() << " - empty file might be left behind!"
                    << std::endl;
          return false;
        }
        return true;
      }
      else
      {
        // create a file via writes
        using buffer_t = std::vector<uint64_t>;  //< data buffer
        buffer_t buffer(32768);
        size_t   nbytes = 0;
 
        while (nbytes < size)
        {
          size_t towrite = size - nbytes;
          if (towrite > (buffer.size() * sizeof(uint64_t)))
            towrite = buffer.size() * sizeof(uint64_t);
          for (size_t i = 0; i < buffer.size(); ++i)
          {
            // we write the offset in this buffer
            buffer[i] = nbytes / sizeof(uint64_t) + i;
          }
          status = file->Write(nbytes, towrite, buffer.data(), timeout);
          if (!status.IsOK())
          {
            std::cerr << "Error: " << status.ToString() << " - failed to write file at offset "
                      << nbytes << " - incomplete file might be left behind!" << std::endl;
            return false;
          }
          nbytes += towrite;
        }
      }
      return true;
    }
    else
    {
      std::cerr << "Error: " << status.ToString() << " - failed to create file!" << std::endl;
    }
  }
  return false;
}

References XrdCl::StatInfo::GetSize(), XrdCl::Status::IsOK(), XrdCl::OpenFlags::MakePath, XrdCl::OpenFlags::New, XrdCl::Access::None, XrdCl::OpenFlags::Read, XrdCl::Status::ToString(), XrdCl::Access::UR, XrdCl::Access::UW, XrdCl::Access::UX, and XrdCl::OpenFlags::Write.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

Async()

std::future< XRootDStatus > XrdCl::Async ( Pipeline pipeline, uint16_t timeout = 0 )

inline

Helper function, schedules execution of given pipeline

Parameters

pipeline	: the pipeline to be executed
timeout	: the pipeline timeout

Returns

: future status of the operation

Definition at line 487 of file XrdClOperations.hh.

  {
    pipeline.Run( timeout );
    return std::move( pipeline.ftr );
  }

Referenced by XrdEc::Reader::Close(), XrdCl::ZipArchive::CloseArchive(), DoStat(), XrdCl::ActionExecutor::Execute(), XrdEc::Reader::Open(), XrdEc::StrmWriter::Open(), XrdCl::ZipArchive::OpenArchive(), XrdCl::ZipArchive::ReadFromImpl, and WaitFor().

Here is the caller graph for this function:

Checkpoint()

CheckpointImpl< false > XrdCl::Checkpoint ( Ctx< File > file, Arg< ChkPtCode > code, uint16_t timeout = 0 )

inline

Factory for creating ReadImpl objects.

Definition at line 72 of file XrdClCheckpointOperation.hh.

  {
    return CheckpointImpl<false>( std::move( file ), std::move( code ) ).Timeout( timeout );
  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by XrdCl::ZipArchive::CloseArchive().

Here is the call graph for this function:

Here is the caller graph for this function:

ChkptWrt()

ChkptWrtImpl< false > XrdCl::ChkptWrt ( Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< const void * > buffer, uint16_t timeout = 0 )

inline

Factory for creating ReadImpl objects.

Definition at line 129 of file XrdClCheckpointOperation.hh.

  {
    return ChkptWrtImpl<false>( std::move( file ), std::move( offset ),
                                std::move( size ), std::move( buffer ) ).Timeout( timeout );
  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Here is the call graph for this function:

ChkptWrtV()

ChkptWrtVImpl< false > XrdCl::ChkptWrtV ( Ctx< File > file, Arg< uint64_t > offset, Arg< std::vector< iovec > > iov, uint16_t timeout = 0 )

inline

Factory for creating ChkptWrtVImpl objects.

Definition at line 197 of file XrdClCheckpointOperation.hh.

  {
    return ChkptWrtVImpl<false>( std::move( file ), std::move( offset ),
                                 std::move( iov ) ).Timeout( timeout );
  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Here is the call graph for this function:

Close()

CloseImpl< false > XrdCl::Close ( Ctx< File > file, uint16_t timeout = 0 )

inline

Factory for creating CloseImpl objects.

Definition at line 482 of file XrdClFileOperations.hh.

  {
    return CloseImpl<false>( std::move( file ) ).Timeout( timeout );
  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by XrdCl::HttpFilePlugIn::Close(), XrdCl::ZipArchive::CloseArchive(), and XrdCl::ActionExecutor::Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

CloseArchive()

CloseArchiveImpl< false > XrdCl::CloseArchive ( Ctx< ZipArchive > zip, uint16_t timeout = 0 )

inline

Factory for creating CloseFileImpl objects.

Definition at line 621 of file XrdClZipOperations.hh.

  {
    return CloseArchiveImpl<false>( std::move( zip ) ).Timeout( timeout );
  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by XrdEc::Reader::Close().

Here is the call graph for this function:

Here is the caller graph for this function:

DeallocArgs()

void XrdCl::DeallocArgs	(	XRootDStatus *	status,
		AnyObject *	response,
		HostList *	hostList )

Definition at line 32 of file XrdClMetalinkRedirector.cc.

  {
    delete status;
    delete response;
    delete hostList;
  }

Referenced by XrdCl::MetalinkReadHandler::HandleResponse(), and XrdCl::MetalinkOpenHandler::HandleResponseWithHosts().

Here is the caller graph for this function:

DelXAttr() [1/4]

DelXAttrImpl< false > XrdCl::DelXAttr ( Ctx< File > file, Arg< std::string > name )

inline

Factory for creating DelXAttrImpl objects (as there is another DelXAttr in FileSystem there would be a clash of typenames).

Definition at line 1256 of file XrdClFileOperations.hh.

  {
    return DelXAttrImpl<false>( std::move( file ), std::move( name ) );
  }

DelXAttr() [2/4]

DelXAttrBulkImpl< false > XrdCl::DelXAttr ( Ctx< File > file, Arg< std::vector< std::string > > attrs )

inline

Factory for creating DelXAttrBulkImpl objects (as there is another DelXAttr in FileSystem there would be a clash of typenames).

Definition at line 1312 of file XrdClFileOperations.hh.

  {
    return DelXAttrBulkImpl<false>( std::move( file ), std::move( attrs ) );
  }

DelXAttr() [3/4]

DelXAttrFsImpl< false > XrdCl::DelXAttr ( Ctx< FileSystem > fs, Arg< std::string > path, Arg< std::string > name )

inline

Factory for creating DelXAttrFsImpl objects (as there is another DelXAttr in File there would be a clash of typenames).

Definition at line 1143 of file XrdClFileSystemOperations.hh.

  {
    return DelXAttrFsImpl<false>( std::move( fs ), std::move( path ), std::move( name ) );
  }

DelXAttr() [4/4]

DelXAttrFsBulkImpl< false > XrdCl::DelXAttr ( Ctx< FileSystem > fs, Arg< std::string > path, Arg< std::vector< std::string > > attrs )

inline

Factory for creating DelXAttrFsBulkImpl objects (as there is another DelXAttr in FileSystem there would be a clash of typenames).

Definition at line 1201 of file XrdClFileSystemOperations.hh.

  {
    return DelXAttrFsBulkImpl<false>( std::move( fs ), std::move( path ), std::move( attrs ) );
  }

ExecuteActions()

std::thread XrdCl::ExecuteActions	(	std::unique_ptr< File >	file,
		action_list &&	actions,
		double	t0,
		double	speed,
		ActionMetrics &	metric,
		bool	simulate )

Execute list of actions against given file

Parameters

file	: the file object
actions	: list of actions to be executed
t0	: offset to add to each start time to determine when to ru an action

Returns

: thread that will executed the list of actions

Definition at line 1020 of file XrdClReplay.cc.

{
  std::thread t(
    [file{ std::move(file) },
     actions{ std::move(actions) },
     t0,
     &metric,
     simulate,
     &speed]() mutable
    {
      XrdSysSemaphore endsem(0);
      XrdSysSemaphore closesem(0);
      auto            ending  = std::make_shared<barrier_t>(endsem);
      auto            closing = std::make_shared<barrier_t>(closesem);
 
      for (auto& p : actions)
      {
        auto& action = p.second;
 
        auto tdelay = t0 ? ((p.first + t0) - XrdCl::Action::timeNow()) : 0;
        if (tdelay > 0)
        {
          tdelay /= speed;
          metric.delays[action.Name() + "::tloss"] += tdelay;
          std::this_thread::sleep_for(std::chrono::milliseconds((int) (tdelay * 1000)));
        }
        else
        {
          metric.delays[action.Name() + "::tgain"] += tdelay;
        }
 
        mytimer_t timer;
        action.Execute(ending, closing, metric, simulate);
        metric.addDelays(action.Name(), "tnomi", action.NominalDuration());
        metric.addDelays(action.Name(), "texec", timer.elapsed());
      }
      ending.reset();
      closing.reset();
      endsem.Wait();
      file->GetProperty("LastURL", metric.url);
      file.reset();
    });
  return t;
}

References XrdCl::ActionMetrics::addDelays(), XrdCl::ActionMetrics::delays, XrdCl::mytimer_t::elapsed(), XrdCl::Action::timeNow(), XrdCl::ActionMetrics::url, and XrdSysSemaphore::Wait().

Here is the call graph for this function:

GetEcHandler()

EcHandler * XrdCl::GetEcHandler	(	const URL &	headnode,
		const URL &	redirurl )

Definition at line 166 of file XrdClEcHandler.cc.

  {
    const URL::ParamsMap &params = redirurl.GetParams();
    // make sure all the xrdec. tokens are present and the values are sane
    URL::ParamsMap::const_iterator itr = params.find( "xrdec.nbdta" );
    if( itr == params.end() ) return nullptr;
    uint8_t nbdta = std::stoul( itr->second );
 
    itr = params.find( "xrdec.nbprt" );
    if( itr == params.end() ) return nullptr;
    uint8_t nbprt = std::stoul( itr->second );
 
    itr = params.find( "xrdec.blksz" );
    if( itr == params.end() ) return nullptr;
    uint64_t blksz = std::stoul( itr->second );
 
    itr = params.find( "xrdec.plgr" );
    if( itr == params.end() ) return nullptr;
    std::vector<std::string> plgr;
    Utils::splitString( plgr, itr->second, "," );
    if( plgr.size() < nbdta + nbprt ) return nullptr;
 
    itr = params.find( "xrdec.objid" );
    if( itr == params.end() ) return nullptr;
    std::string objid = itr->second;
 
    itr = params.find( "xrdec.format" );
    if( itr == params.end() ) return nullptr;
    size_t format = std::stoul( itr->second );
    if( format != 1 ) return nullptr; // TODO use constant
 
    std::vector<std::string> dtacgi;
    itr = params.find( "xrdec.dtacgi" );
    if( itr != params.end() )
    {
      Utils::splitString( dtacgi, itr->second, "," );
      if( plgr.size() != dtacgi.size() ) return nullptr;
    }
 
    std::vector<std::string> mdtacgi;
    itr = params.find( "xrdec.mdtacgi" );
    if( itr != params.end() )
    {
      Utils::splitString( mdtacgi, itr->second, "," );
      if( plgr.size() != mdtacgi.size() ) return nullptr;
    }
 
    itr = params.find( "xrdec.cosc" );
    if( itr == params.end() ) return nullptr;
    std::string cosc_str = itr->second;
    if( cosc_str != "true" && cosc_str != "false" ) return nullptr;
    bool cosc = cosc_str == "true";
 
    std::string ckstype;
    itr = params.find( "xrdec.cksum" );
    if( cosc && itr == params.end() ) return nullptr;
    if( cosc )
      ckstype = itr->second;
 
    std::string chdigest;
    itr = params.find( "xrdec.chdigest" );
    if( itr == params.end() )
      chdigest = "crc32c";
    else
      chdigest = itr->second;
    bool usecrc32c = ( chdigest == "crc32c" );
 
    bool nomtfile = false;
    itr = params.find( "xrdec.nomtfile" );
    if( itr != params.end() )
      nomtfile = ( itr->second == "true" );
 
    XrdEc::ObjCfg *objcfg = new XrdEc::ObjCfg( objid, nbdta, nbprt, blksz / nbdta, usecrc32c );
    objcfg->plgr     = std::move( plgr );
    objcfg->dtacgi   = std::move( dtacgi );
    objcfg->mdtacgi  = std::move( mdtacgi );
    objcfg->nomtfile = nomtfile;
 
    std::unique_ptr<CheckSumHelper> cksHelper( cosc ? new CheckSumHelper( "", ckstype ) : nullptr );
    if( cksHelper )
    {
      auto st = cksHelper->Initialize();
      if( !st.IsOK() ) return nullptr;
    }
 
    return new EcHandler( headnode, objcfg, std::move( cksHelper ) );
  }

References XrdEc::ObjCfg::dtacgi, XrdCl::URL::GetParams(), XrdCl::Status::IsOK(), XrdEc::ObjCfg::mdtacgi, XrdEc::ObjCfg::nomtfile, XrdEc::ObjCfg::plgr, and XrdCl::Utils::splitString().

Here is the call graph for this function:

GetResponse() [1/2]

template<typename Response>

Response * XrdCl::GetResponse ( AnyObject * rsp )

inline

Unpack response

Parameters

rsp	: AnyObject holding response

Returns

: the response

Definition at line 137 of file XrdClOperationHandlers.hh.

  {
    Response *ret = nullptr;
    rsp->Get( ret );
    return ret;
  }

References XrdCl::AnyObject::Get().

Referenced by GetResponse(), XrdCl::FutureWrapper< Response >::HandleResponse(), XrdCl::TaskWrapper< Response, Return >::HandleResponse(), and XrdCl::FunctionWrapper< Response >::HandleResponseWithHosts().

Here is the call graph for this function:

Here is the caller graph for this function:

GetResponse() [2/2]

template<typename Response>

Response * XrdCl::GetResponse ( XRootDStatus * status, AnyObject * rsp )

inline

Unpack response

Parameters

rsp	: AnyObject holding response
status	:

Returns

: the response

Definition at line 152 of file XrdClOperationHandlers.hh.

  {
    if( !status->IsOK() ) return &NullRef<Response>::value;
    return GetResponse<Response>( rsp );
  }

References GetResponse(), XrdCl::Status::IsOK(), and XrdCl::NullRef< Response >::value.

Here is the call graph for this function:

GetXAttr() [1/4]

GetXAttrImpl< false > XrdCl::GetXAttr ( Ctx< File > file, Arg< std::string > name )

inline

Factory for creating GetXAttrImpl objects (as there is another GetXAttr in FileSystem there would be a clash of typenames).

Definition at line 1139 of file XrdClFileOperations.hh.

  {
    return GetXAttrImpl<false>( std::move( file ), std::move( name ) );
  }

GetXAttr() [2/4]

GetXAttrBulkImpl< false > XrdCl::GetXAttr ( Ctx< File > file, Arg< std::vector< std::string > > attrs )

inline

Factory for creating GetXAttrBulkImpl objects (as there is another GetXAttr in FileSystem there would be a clash of typenames).

Definition at line 1195 of file XrdClFileOperations.hh.

  {
    return GetXAttrBulkImpl<false>( std::move( file ), std::move( attrs ) );
  }

GetXAttr() [3/4]

GetXAttrFsImpl< false > XrdCl::GetXAttr ( Ctx< FileSystem > fs, Arg< std::string > path, Arg< std::string > name )

inline

Factory for creating GetXAttrFsImpl objects (as there is another GetXAttr in File there would be a clash of typenames).

Definition at line 1023 of file XrdClFileSystemOperations.hh.

  {
    return GetXAttrFsImpl<false>( std::move( fs ), std::move( path ), std::move( name ) );
  }

GetXAttr() [4/4]

GetXAttrFsBulkImpl< false > XrdCl::GetXAttr ( Ctx< FileSystem > fs, Arg< std::string > path, Arg< std::vector< std::string > > attrs )

inline

Factory for creating GetXAttrFsBulkImpl objects (as there is another GetXAttr in FileSystem there would be a clash of typenames).

Definition at line 1079 of file XrdClFileSystemOperations.hh.

  {
    return GetXAttrFsBulkImpl<false>( std::move( fs ), std::move( path ), std::move( attrs ) );
  }

InitTLS()

bool XrdCl::InitTLS

(

)

Initialize TLS context, returns false on failure

Definition at line 96 of file XrdClTls.cc.

  {
    static std::mutex tls_mutex;
    std::lock_guard<std::mutex> tls_lock(tls_mutex);
 
    if (tlsContext)
      return true;
 
    XrdCl::Env *env = XrdCl::DefaultEnv::GetEnv();
    XrdCl::Log *log = XrdCl::DefaultEnv::GetLog();
 
    int notls = false;
    env->GetInt("NoTlsOK", notls);
 
    if (notls)
      return false;
 
    const char *cadir  = getenv("X509_CERT_DIR");
    const char *cafile = getenv("X509_CERT_FILE");
 
    if (!cadir && !cafile)
      cadir = "/etc/grid-security/certificates";
 
    const char *msg;
    const mode_t camode = S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
 
    if (cadir && (msg = XrdOucUtils::ValPath(cadir, camode, true))) {
      log->Error(XrdCl::TlsMsg, "Failed to initialize TLS context: CA directory %s", msg);
      env->PutInt("NoTlsOK", 1);
      return false;
    }
 
    std::string emsg = "unknown error";
    tlsContext = std::make_unique<XrdTlsContext>(nullptr, nullptr, cadir, cafile, 0ul, &emsg);
 
    if (!tlsContext || !tlsContext->isOK()) {
      tlsContext.reset(nullptr);
      log->Error(XrdCl::TlsMsg, "Failed to initialize TLS context: %s", emsg.c_str());
      env->PutInt("NoTlsOK", 1);
      return false;
    }
 
    return true;
  }

References emsg(), XrdCl::Log::Error(), XrdCl::DefaultEnv::GetEnv(), XrdCl::Env::GetInt(), XrdCl::DefaultEnv::GetLog(), XrdCl::Env::PutInt(), tlsContext, TlsMsg, and XrdOucUtils::ValPath().

Referenced by XrdCl::Tls::Tls().

Here is the call graph for this function:

Here is the caller graph for this function:

List()

ZipListImpl< false > XrdCl::List ( Ctx< ZipArchive > zip )

inline

Factory for creating ZipStatImpl objects.

Definition at line 574 of file XrdClZipOperations.hh.

  {
    return ZipListImpl<false>( std::move( zip ) );
  }

ListXAttr() [1/2]

ListXAttrImpl< false > XrdCl::ListXAttr ( Ctx< File > file )

inline

Factory for creating ListXAttrImpl objects (as there is another ListXAttr in FileSystem there would be a clash of typenames).

Definition at line 1361 of file XrdClFileOperations.hh.

  {
    return ListXAttrImpl<false>( std::move( file ) );
  }

ListXAttr() [2/2]

ListXAttrFsImpl< false > XrdCl::ListXAttr ( Ctx< FileSystem > fs, Arg< std::string > path )

inline

Factory for creating ListXAttrFsImpl objects (as there is another ListXAttr in FileSystem there would be a clash of typenames).

Definition at line 1257 of file XrdClFileSystemOperations.hh.

  {
    return ListXAttrFsImpl<false>( std::move( fs ), std::move( path ) );
  }

make_fwd()

template<typename T, typename... Args>

std::shared_ptr< FwdStorage< T > > XrdCl::make_fwd ( Args &&... args )

inline

Definition at line 245 of file XrdClFwd.hh.

  {
    return std::make_shared<FwdStorage<T>>( std::forward<Args>( args )... );
  }

Open()

OpenImpl< false > XrdCl::Open ( Ctx< File > file, Arg< std::string > url, Arg< OpenFlags::Flags > flags, Arg< Access::Mode > mode = Access::None, uint16_t timeout = 0 )

inline

Factory for creating ReadImpl objects.

Definition at line 215 of file XrdClFileOperations.hh.

  {
    return OpenImpl<false>( std::move( file ), std::move( url ), std::move( flags ),
                            std::move( mode ) ).Timeout( timeout );
  }

References XrdCl::Access::None, and XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by XrdCl::ActionExecutor::Execute(), XrdCl::HttpFilePlugIn::Open(), and XrdCl::ZipArchive::OpenArchive().

Here is the call graph for this function:

Here is the caller graph for this function:

OpenArchive()

OpenArchiveImpl< false > XrdCl::OpenArchive ( Ctx< ZipArchive > zip, Arg< std::string > fn, Arg< OpenFlags::Flags > flags, uint16_t timeout = 0 )

inline

Factory for creating OpenArchiveImpl objects.

Definition at line 123 of file XrdClZipOperations.hh.

  {
    return OpenArchiveImpl<false>( std::move( zip ), std::move( fn ),
                                   std::move( flags ) ).Timeout( timeout );
  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by XrdEc::Reader::Open(), and XrdEc::StrmWriter::Open().

Here is the call graph for this function:

Here is the caller graph for this function:

OpenFile()

OpenFileImpl< false > XrdCl::OpenFile ( Ctx< ZipArchive > zip, Arg< std::string > fn, Arg< OpenFlags::Flags > flags = OpenFlags::None, Arg< uint64_t > size = 0, Arg< uint32_t > crc32 = 0, uint16_t timeout = 0 )

inline

Factory for creating OpenFileImpl objects.

Definition at line 184 of file XrdClZipOperations.hh.

  {
    return OpenFileImpl<false>( std::move( zip ), std::move( fn ), std::move( flags ),
        std::move( size ), std::move( crc32 ) ).Timeout( timeout );
  }

References XrdCl::OpenFlags::None, and XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Here is the call graph for this function:

Parallel() [1/2]

template<class Container>

ParallelOperation< false > XrdCl::Parallel ( Container && container )

inline

Factory function for creating parallel operation from a vector.

Definition at line 510 of file XrdClParallelOperation.hh.

  {
    return ParallelOperation<false>( container );
  }

Referenced by XrdEc::Reader::Close(), DoRm(), DoStat(), XrdEc::Reader::Open(), XrdEc::StrmWriter::Open(), and Parallel().

Here is the caller graph for this function:

Parallel() [2/2]

template<typename ... Operations>

ParallelOperation< false > XrdCl::Parallel ( Operations &&... operations )

inline

Factory function for creating parallel operation from a given number of operations (we use && reference since due to reference collapsing this will fit both r- and l-value references)

Definition at line 573 of file XrdClParallelOperation.hh.

  {
    constexpr size_t size = sizeof...( operations );
    std::vector<Pipeline> v;
    v.reserve( size );
    PipesToVec( v, operations... );
    return Parallel( v );
  }

References Parallel(), and PipesToVec().

Here is the call graph for this function:

ParseInput()

std::unordered_map< File *, action_list > XrdCl::ParseInput	(	const std::string &	path,
		double &	t0,
		double &	t1,
		std::unordered_map< File *, std::string > &	filenames,
		std::unordered_map< File *, double > &	synchronicity,
		std::unordered_map< File *, size_t > &	responseerrors,
		const std::vector< std::string > &	option_regex )

Parse input file

Parameters

path	: path to the input csv file

Definition at line 904 of file XrdClReplay.cc.

{
  std::unordered_map<File*, action_list> result;
  std::unique_ptr<std::ifstream>        fin( path.empty() ? nullptr : new std::ifstream( path, std::ifstream::in ) );
  std::istream                          &input = path.empty() ? std::cin : *fin;
  std::string                            line;
  std::unordered_map<uint64_t, File*>    files;
  std::unordered_map<uint64_t, double>   last_stop;
  std::unordered_map<uint64_t, double>   overlaps;
  std::unordered_map<uint64_t, double>   overlaps_cnt;
 
  t0 = 10e99;
  t1 = 0;
  while (input.good())
  {
    std::getline(input, line);
    if (line.empty())
      continue;
    std::vector<std::string> tokens = ToColumns( line );
    if (tokens.size() == 6)
      tokens.emplace_back();
    if (tokens.size() != 7)
    {
      throw std::invalid_argument("Invalid input file format.");
    }
 
    uint64_t    id     = std::stoull(tokens[0]);  // file object ID
    std::string action = tokens[1];               // action name (e.g. Open)
    double      start  = std::stod(tokens[2]);    // start time
    std::string args   = tokens[3];               // operation arguments
    double      stop   = std::stod(tokens[4]);    // stop time
    std::string status = tokens[5];               // operation status
    std::string resp   = tokens[6];               // server response
 
    if (option_regex.size())
    {
      for (auto& v : option_regex)
      {
        std::vector<std::string> tokens;
        Utils::splitString(tokens, v, ":=");
        std::regex src(tokens[0]);
        if (tokens.size() != 2)
        {
          std::cerr
            << "Error: invalid regex for argument replacement - must be format like <oldstring>:=<newstring>"
            << std::endl;
          exit(EINVAL);
        }
        else
        {
          // write the results to an output iterator
          args = std::regex_replace(args, src, tokens[1]);
        }
      }
    }
 
    if (start < t0)
      t0 = start;
    if (stop > t1)
      t1 = stop;
 
    if (!files.count(id))
    {
      files[id] = new File(false);
      files[id]->SetProperty("BundledClose", "true");
      filenames[files[id]] = args;
      filenames[files[id]].erase(args.find(";"));
      overlaps[id]     = 0;
      overlaps_cnt[id] = 0;
      last_stop[id]    = stop;
    }
    else
    {
      overlaps_cnt[id]++;
      if (start > last_stop[id])
      {
        overlaps[id]++;
      }
      last_stop[id] = stop;
    }
 
    last_stop[id]           = stop;
    double nominal_duration = stop - start;
 
    if (status != "[SUCCESS]")
    {
      responseerrors[files[id]]++;
    }
    else
    {
      result[files[id]].emplace(
        start, ActionExecutor(*files[id], action, args, status, resp, nominal_duration));
    }
  }
 
  for (auto& it : overlaps)
  {
    // compute the synchronicity of requests
    synchronicity[files[it.first]] = 100.0 * (it.second / overlaps_cnt[it.first]);
  }
  return result;
}

References File, XrdCl::Utils::splitString(), and ToColumns().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

PgRead()

PgReadImpl< false > XrdCl::PgRead ( Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout = 0 )

inline

Factory for creating PgReadImpl objects.

Definition at line 331 of file XrdClFileOperations.hh.

  {
    return PgReadImpl<false>( std::move( file ), std::move( offset ), std::move( size ),
                            std::move( buffer ) ).Timeout( timeout );
  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by XrdCl::ActionExecutor::Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

PgWrite() [1/2]

PgWriteImpl< false > XrdCl::PgWrite ( Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, Arg< std::vector< uint32_t > > cksums, uint16_t timeout = 0 )

inline

Factory for creating PgReadImpl objects.

Definition at line 420 of file XrdClFileOperations.hh.

  {
    return PgWriteImpl<false>( std::move( file ), std::move( offset ), std::move( size ),
                               std::move( buffer ), std::move( cksums ) ).Timeout( timeout );
  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by XrdCl::ActionExecutor::Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

PgWrite() [2/2]

PgWriteImpl< false > XrdCl::PgWrite ( Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout = 0 )

inline

Factory for creating PgReadImpl objects.

Definition at line 432 of file XrdClFileOperations.hh.

  {
    std::vector<uint32_t> cksums;
    return PgWriteImpl<false>( std::move( file ), std::move( offset ), std::move( size ),
                               std::move( buffer ), std::move( cksums ) ).Timeout( timeout );
  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Here is the call graph for this function:

PipesToVec() [1/4]

void XrdCl::PipesToVec ( std::vector< Pipeline > & )

inline

Helper function for converting parameter pack into a vector.

Definition at line 518 of file XrdClParallelOperation.hh.

  {
    // base case
  }

Referenced by Parallel(), PipesToVec(), PipesToVec(), and PipesToVec().

Here is the caller graph for this function:

PipesToVec() [2/4]

template<typename ... Others>

void XrdCl::PipesToVec ( std::vector< Pipeline > & v, Operation< false > & operation, Others &... others )

inline

Definition at line 543 of file XrdClParallelOperation.hh.

  {
    v.emplace_back( operation );
    PipesToVec( v, others... );
  }

References PipesToVec().

Here is the call graph for this function:

PipesToVec() [3/4]

template<typename ... Others>

void XrdCl::PipesToVec ( std::vector< Pipeline > & v, Operation< true > & operation, Others &... others )

inline

Definition at line 551 of file XrdClParallelOperation.hh.

  {
    v.emplace_back( operation );
    PipesToVec( v, others... );
  }

References PipesToVec().

Here is the call graph for this function:

PipesToVec() [4/4]

template<typename ... Others>

void XrdCl::PipesToVec ( std::vector< Pipeline > & v, Pipeline & pipeline, Others &... others )

inline

Definition at line 559 of file XrdClParallelOperation.hh.

  {
    v.emplace_back( std::move( pipeline ) );
    PipesToVec( v, others... );
  }

References PipesToVec().

Here is the call graph for this function:

PropertyList::Get< std::string >() [1/2]

template<>

std::string XrdCl::PropertyList::Get< std::string > ( const std::string & name ) const

inline

Definition at line 201 of file XrdClPropertyList.hh.

  {
    PropertyMap::const_iterator it;
    it = pProperties.find( name );
    if( it == pProperties.end() )
      return std::string();
    return it->second;
  }

References XrdCl::PropertyList::Get().

Here is the call graph for this function:

PropertyList::Get< std::string >() [2/2]

template<>

bool XrdCl::PropertyList::Get< std::string > ( const std::string & name, std::string & item ) const

inline

Definition at line 189 of file XrdClPropertyList.hh.

  {
    PropertyMap::const_iterator it;
    it = pProperties.find( name );
    if( it == pProperties.end() )
      return false;
    item = it->second;
    return true;
  }

References XrdCl::PropertyList::Get().

Here is the call graph for this function:

PropertyList::Get< std::vector< std::string > >()

template<>

bool XrdCl::PropertyList::Get< std::vector< std::string > > ( const std::string & name, std::vector< std::string > & item ) const

inline

Definition at line 301 of file XrdClPropertyList.hh.

  {
    std::string tmp;
    item.clear();
    for( int i = 0; HasProperty( name, i ); ++i )
    {
      if( !Get( name, i, tmp ) )
        return false;
      item.push_back( tmp );
    }
    return true;
  }

References XrdCl::PropertyList::Get().

Here is the call graph for this function:

PropertyList::Set< std::vector< std::string > >()

template<>

void XrdCl::PropertyList::Set< std::vector< std::string > > ( const std::string & name, const std::vector< std::string > & item )

inline

Definition at line 287 of file XrdClPropertyList.hh.

  {
    std::vector<std::string>::const_iterator it;
    int i = 0;
    for( it = item.begin(); it != item.end(); ++it, ++i )
      Set( name, i, *it );
  }

References XrdCl::PropertyList::Set().

Here is the call graph for this function:

RdWithRsp()

template<typename RSP>

ReadTrait< RSP >::RET XrdCl::RdWithRsp ( Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout = 0 )

inline

Referenced by XrdCl::ZipArchive::ReadFromImpl.

Here is the caller graph for this function:

RdWithRsp< ChunkInfo >()

template<>

ReadImpl< false > XrdCl::RdWithRsp< ChunkInfo > ( Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout )

inline

Definition at line 349 of file XrdClFileOperations.hh.

  {
    return Read( std::move( file ), std::move( offset ), std::move( size ),
                 std::move( buffer ), timeout );
  }

RdWithRsp< PageInfo >()

template<>

PgReadImpl< false > XrdCl::RdWithRsp< PageInfo > ( Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout )

inline

Definition at line 349 of file XrdClFileOperations.hh.

  {
    return PgRead( std::move( file ), std::move( offset ), std::move( size ),
                   std::move( buffer ), timeout );
  }

Read() [1/2]

ReadImpl< false > XrdCl::Read ( Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout = 0 )

inline

Factory for creating ReadImpl objects.

Definition at line 273 of file XrdClFileOperations.hh.

  {
    return ReadImpl<false>( std::move( file ), std::move( offset ), std::move( size ),
                            std::move( buffer ) ).Timeout( timeout );
  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by XrdCl::ActionExecutor::Execute(), XrdCl::ZipArchive::OpenArchive(), and XrdCl::HttpFilePlugIn::Read().

Here is the call graph for this function:

Here is the caller graph for this function:

Read() [2/2]

ZipReadImpl< false > XrdCl::Read ( Ctx< ZipArchive > zip, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout = 0 )

inline

Factory for creating ArchiveReadImpl objects.

Definition at line 244 of file XrdClZipOperations.hh.

  {
    return ZipReadImpl<false>( std::move( zip ), std::move( offset ), std::move( size ),
                               std::move( buffer ) ).Timeout( timeout );
  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Here is the call graph for this function:

ReadFrom()

ZipReadFromImpl< false > XrdCl::ReadFrom ( Ctx< ZipArchive > zip, Arg< std::string > fn, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout = 0 )

inline

Factory for creating ArchiveReadImpl objects.

Definition at line 302 of file XrdClZipOperations.hh.

  {
    return ZipReadFromImpl<false>( std::move( zip ), std::move( fn ), std::move( offset ),
                                   std::move( size ), std::move( buffer ) ).Timeout( timeout );
  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Here is the call graph for this function:

ReadFromImpl()

template<typename RSP>

XRootDStatus XrdCl::ReadFromImpl	(	ZipArchive &	me,
		const std::string &	fn,
		uint64_t	relativeOffset,
		uint32_t	size,
		void *	usrbuff,
		ResponseHandler *	usrHandler,
		uint16_t	timeout )

Definition at line 44 of file XrdClZipArchive.cc.

  {
    if( me.openstage != ZipArchive::Done || !me.archive.IsOpen() )
      return XRootDStatus( stError, errInvalidOp );
 
    Log *log = DefaultEnv::GetLog();
 
    auto cditr = me.cdmap.find( fn );
    if( cditr == me.cdmap.end() )
      return XRootDStatus( stError, errNotFound,
                           errNotFound, "File not found." );
 
    CDFH *cdfh = me.cdvec[cditr->second].get();
 
    // check if the file is compressed, for now we only support uncompressed and inflate/deflate compression
    if( cdfh->compressionMethod != 0 && cdfh->compressionMethod != Z_DEFLATED )
      return XRootDStatus( stError, errNotSupported,
                           0, "The compression algorithm is not supported!" );
 
    // Now the problem is that at the beginning of our
    // file there is the Local-file-header, which size
    // is not known because of the variable size 'extra'
    // field, so we need to know the offset of the next
    // record and shift it by the file size.
    // The next record is either the next LFH (next file)
    // or the start of the Central-directory.
    uint64_t cdOffset = me.zip64eocd ? me.zip64eocd->cdOffset : me.eocd->cdOffset;
    uint64_t nextRecordOffset = ( cditr->second + 1 < me.cdvec.size() ) ?
                                CDFH::GetOffset( *me.cdvec[cditr->second + 1] ) : cdOffset;
    uint64_t filesize = cdfh->compressedSize;
    if( filesize == std::numeric_limits<uint32_t>::max() && cdfh->extra )
      filesize = cdfh->extra->compressedSize;
    uint16_t descsize = cdfh->HasDataDescriptor() ?
                        DataDescriptor::GetSize( cdfh->IsZIP64() ) : 0;
    uint64_t fileoff  = nextRecordOffset - filesize - descsize;
    uint64_t offset   = fileoff + relativeOffset;
    uint64_t uncompressedSize = cdfh->uncompressedSize;
    if( uncompressedSize == std::numeric_limits<uint32_t>::max() && cdfh->extra )
      uncompressedSize = cdfh->extra->uncompressedSize;
    uint64_t sizeTillEnd = relativeOffset > uncompressedSize ?
                           0 : uncompressedSize - relativeOffset;
    if( size > sizeTillEnd ) size = sizeTillEnd;
 
    // if it is a compressed file use ZIP cache to read from the file
    if( cdfh->compressionMethod == Z_DEFLATED )
    {
      log->Dump( ZipMsg, "[%p] Reading compressed data.", (void*)&me );
      // check if respective ZIP cache exists
      bool empty = me.zipcache.find( fn ) == me.zipcache.end();
      // if the entry does not exist, it will be created using
      // default constructor
      ZipCache &cache = me.zipcache[fn];
 
      if( relativeOffset > uncompressedSize )
      {
        // we are reading past the end of file,
        // we can serve the request right away!
        RSP *r = new RSP( relativeOffset, 0, usrbuff );
        AnyObject *rsp = new AnyObject();
        rsp->Set( r );
        usrHandler->HandleResponse( new XRootDStatus(), rsp );
        return XRootDStatus();
      }
 
      uint32_t sizereq = size;
      if( relativeOffset + size > uncompressedSize )
        sizereq = uncompressedSize - relativeOffset;
      cache.QueueReq( relativeOffset, sizereq, usrbuff, usrHandler );
 
      // if we have the whole ZIP archive we can populate the cache
      // straight away
      if( empty && me.buffer)
      {
        auto begin = me.buffer.get() + fileoff;
        auto end   = begin + filesize ;
        buffer_t buff( begin, end );
        cache.QueueRsp( XRootDStatus(), 0, std::move( buff ) );
        return XRootDStatus();
      }
 
      // if we don't have the data we need to issue a remote read
      if( !me.buffer )
      {
        if( relativeOffset > filesize ) return XRootDStatus(); // there's nothing to do,
                                                                           // we already have all the data locally
        uint32_t rdsize = size;
        // check if this is the last read (we reached the end of
        // file from user perspective)
        if( relativeOffset + size >= uncompressedSize )
        {
          // if yes, make sure we readout all the compressed data
          // Note: In a patological case the compressed size may
          //       be greater than the uncompressed size
          rdsize = filesize > relativeOffset ?
                   filesize - relativeOffset :
                   0;
        }
        // make sure we are not reading past the end of
        // compressed data
        if( relativeOffset + size > filesize )
          rdsize = filesize - relativeOffset;
 
 
        // now read the data ...
        auto rdbuff = std::make_shared<ZipCache::buffer_t>( rdsize );
        Pipeline p = XrdCl::RdWithRsp<RSP>( me.archive, offset, rdbuff->size(), rdbuff->data() ) >>
                       [relativeOffset, rdbuff, &cache, &me]( XRootDStatus &st, RSP &rsp )
                       {
                         Log *log = DefaultEnv::GetLog();
                         log->Dump( ZipMsg, "[%p] Read %u bytes of remote data at offset %llu.",
                                            (void*)&me, rsp.GetLength(), (unsigned long long) rsp.GetOffset() );
                         cache.QueueRsp( st, relativeOffset, std::move( *rdbuff ) );
                       };
        Async( std::move( p ), timeout );
      }
 
      return XRootDStatus();
    }
 
    // check if we have the whole file in our local buffer
    if( me.buffer || size == 0 )
    {
      if( size )
      {
        memcpy( usrbuff, me.buffer.get() + offset, size );
        log->Dump( ZipMsg, "[%p] Serving read from local cache.", (void*)&me );
      }
 
      if( usrHandler )
      {
        XRootDStatus *st  = ZipArchive::make_status();
        RSP          *rsp = new RSP( relativeOffset, size, usrbuff );
        ZipArchive::Schedule( usrHandler, st, rsp );
      }
      return XRootDStatus();
    }
 
    Pipeline p = XrdCl::RdWithRsp<RSP>( me.archive, offset, size, usrbuff ) >>
                   [=, &me]( XRootDStatus &st, RSP &r )
                   {
                     log->Dump( ZipMsg, "[%p] Read %u bytes of remote data at "
                                        "offset %llu.", (void*)&me, r.GetLength(), (unsigned long long) r.GetOffset() );
                     if( usrHandler )
                     {
                       XRootDStatus *status = ZipArchive::make_status( st );
                       RSP          *rsp    = nullptr;
                       if( st.IsOK() )
                         rsp = new RSP( relativeOffset, r.GetLength(), r.GetBuffer() );
                       usrHandler->HandleResponse( status, ZipArchive::PkgRsp( rsp ) );
                     }
                   };
    Async( std::move( p ), timeout );
    return XRootDStatus();
  }

SetUpLogging()

void XrdCl::SetUpLogging

(

Log *

logger

)

Definition at line 15 of file XrdClHttpPlugInUtil.cc.

                               {
  // Assert that there is no existing topic
  std::call_once(logging_topic_init, [logger] {
      if (logger) {
        logger->SetTopicName(kLogXrdClHttp, "XrdClHttp");
      }
    });
}

References kLogXrdClHttp, logging_topic_init, and XrdCl::Log::SetTopicName().

Referenced by XrdCl::HttpFilePlugIn::HttpFilePlugIn(), and XrdCl::HttpFileSystemPlugIn::HttpFileSystemPlugIn().

Here is the call graph for this function:

Here is the caller graph for this function:

SetXAttr() [1/4]

SetXAttrImpl< false > XrdCl::SetXAttr ( Ctx< File > file, Arg< std::string > name, Arg< std::string > value )

inline

Factory for creating SetXAttrImpl objects (as there is another SetXAttr in FileSystem there would be a clash of typenames).

Definition at line 1021 of file XrdClFileOperations.hh.

  {
    return SetXAttrImpl<false>( std::move( file ), std::move( name ), std::move( value ) );
  }

References NullRef< Response >::value.

SetXAttr() [2/4]

SetXAttrBulkImpl< false > XrdCl::SetXAttr ( Ctx< File > file, Arg< std::vector< xattr_t > > attrs )

inline

Factory for creating SetXAttrBulkImpl objects (as there is another SetXAttr in FileSystem there would be a clash of typenames).

Definition at line 1077 of file XrdClFileOperations.hh.

  {
    return SetXAttrBulkImpl<false>( std::move( file ), std::move( attrs ) );
  }

SetXAttr() [3/4]

SetXAttrFsImpl< false > XrdCl::SetXAttr ( Ctx< FileSystem > fs, Arg< std::string > path, Arg< std::string > name, Arg< std::string > value )

inline

Factory for creating SetXAttrFsImpl objects (as there is another SetXAttr in File there would be a clash of typenames).

Definition at line 904 of file XrdClFileSystemOperations.hh.

  {
    return SetXAttrFsImpl<false>( std::move( fs ), std::move( path ), std::move( name ),
                                  std::move( value ) );
  }

References NullRef< Response >::value.

SetXAttr() [4/4]

SetXAttrFsBulkImpl< false > XrdCl::SetXAttr ( Ctx< FileSystem > fs, Arg< std::string > path, Arg< std::vector< xattr_t > > attrs )

inline

Factory for creating SetXAttrFsBulkImpl objects (as there is another SetXAttr in FileSystem there would be a clash of typenames).

Definition at line 961 of file XrdClFileSystemOperations.hh.

  {
    return SetXAttrFsBulkImpl<false>( std::move( fs ), std::move( path ), std::move( attrs ) );
  }

Stat() [1/3]

StatImpl< false > XrdCl::Stat ( Ctx< File > file, Arg< bool > force, uint16_t timeout = 0 )

inline

Factory for creating StatImpl objects (as there is another Stat in FileSystem there would be a clash of typenames).

Definition at line 535 of file XrdClFileOperations.hh.

  {
    return StatImpl<false>( std::move( file ), std::move( force ) ).Timeout( timeout );
  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by DoStat(), XrdCl::HttpFilePlugIn::Open(), XrdCl::HttpFilePlugIn::Stat(), and XrdCl::HttpFileSystemPlugIn::Stat().

Here is the call graph for this function:

Here is the caller graph for this function:

Stat() [2/3]

StatFsImpl< false > XrdCl::Stat ( Ctx< FileSystem > fs, Arg< std::string > path )

inline

Definition at line 608 of file XrdClFileSystemOperations.hh.

  {
    return StatFsImpl<false>( std::move( fs ), std::move( path ) );
  }

Stat() [3/3]

ZipStatImpl< false > XrdCl::Stat ( Ctx< ZipArchive > zip )

inline

Factory for creating ZipStatImpl objects.

Definition at line 523 of file XrdClZipOperations.hh.

  {
    return ZipStatImpl<false>( std::move( zip ) );
  }

Sync()

SyncImpl< false > XrdCl::Sync ( Ctx< File > file, uint16_t timeout = 0 )

inline

Factory for creating SyncImpl objects.

Definition at line 639 of file XrdClFileOperations.hh.

  {
    return SyncImpl<false>( std::move( file ) ).Timeout( timeout );
  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by XrdCl::ActionExecutor::Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

To()

template<typename T>

T & XrdCl::To ( AnyObject & any )

inline

Helper function for extracting an object from AnyObject

Parameters

any	: an instance of AnyObject

Returns

: the underlying value of type T

Definition at line 151 of file XrdClAnyObject.hh.

  {
    T* object;
    any.Get( object );
    return *object;
  }

References XrdCl::AnyObject::Get().

Here is the call graph for this function:

to_lower()

std::string XrdCl::to_lower ( std::string str )

inlinestatic

Definition at line 116 of file XrdClConstants.hh.

  {
    std::transform( str.begin(), str.end(), str.begin(), ::tolower );
    return str;
  }

ToColumns()

std::vector< std::string > XrdCl::ToColumns

(

const std::string &

row

)

Split a row into columns.

loop over all the columns in the row

Definition at line 826 of file XrdClReplay.cc.

{
  std::vector<std::string> columns;
  size_t quotecnt = 0;
  size_t pos = 0;
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  while( pos != std::string::npos && pos < row.size() )
  {
    if( row[pos] == '"' ) // we are handling a quoted column
    {
      if( quotecnt > 0 ) // this is a closing quote
      {
        if( pos + 1 < row.size() && row[pos + 1] != ',' ) // if it is not the last character in the row it should be followed by a comma
          throw std::runtime_error( "Parsing error: missing comma" );
        --quotecnt; // strip the quote
        ++pos; // move to the comma or end of row
        continue;
      }
      else // this is a opening quote
      {
        ++quotecnt;
        auto b = std::next( row.begin(), pos + 1 ); // iterator to the beginning of our column
        size_t posend = row.find( "\",", pos + 1 ); // position of the cursor to the end of our column
        if( posend == std::string::npos && row[row.size() - 1] == '"' )
          posend = row.size() - 1;
        else if( posend == std::string::npos )
          throw std::runtime_error( "Parsing error: missing closing quote" );
        auto e = std::next( row.begin(), posend ); // iterator to the end of our column
        columns.emplace_back( b, e ); // add the column to the result
        pos = posend; // move to the next column
        continue;
      }
    }
    else if( row[pos] == ',' ) // we are handling a column separator
    {
      if( pos + 1 < row.size() && row[pos + 1] == '"' ) // check if the column is quoted
      {
        ++pos; // if yes we will handle this with the logic reserved for quoted columns
        continue;
      }
      auto b = std::next( row.begin(), pos + 1 ); // iterator to the beginning of our column
      size_t posend = row.find( ',', pos + 1 ); // position of the cursor to the end of our column
      if( posend == std::string::npos )
        posend = row.size();
      auto e = std::next( row.begin(), posend ); // iterator to the end of our column
      columns.emplace_back( b, e ); // add the column to the result
      pos = posend; // move to the next column
      continue;
    }
    else if( pos == 0 ) // we are handling the 1st column if not quoted
    {
      size_t posend = row.find( ',', pos + 1 ); // position of the cursor to the end of our column
      if( posend == std::string::npos )
        posend = row.size();
      auto end = std::next( row.begin(), posend ); // iterator to the end of our column
      columns.emplace_back( row.begin(), end ); // add the column to the result
      pos = posend;  // move to the next column
      continue;
    }
    else
    {
      throw std::runtime_error( "Parsing error: invalid input file." );
    }
  }
  return columns;
}

Referenced by ParseInput().

Here is the caller graph for this function:

Truncate() [1/2]

TruncateImpl< false > XrdCl::Truncate ( Ctx< File > file, Arg< uint64_t > size, uint16_t timeout )

inline

Factory for creating TruncateImpl objects (as there is another Stat in FileSystem there would be a clash of typenames).

Definition at line 692 of file XrdClFileOperations.hh.

  {
    return TruncateImpl<false>( std::move( file ), std::move( size ) ).Timeout( timeout );
  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by XrdCl::ActionExecutor::Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Truncate() [2/2]

TruncateFsImpl< false > XrdCl::Truncate ( Ctx< FileSystem > fs, Arg< std::string > path, Arg< uint64_t > size )

inline

Definition at line 329 of file XrdClFileSystemOperations.hh.

  {
    return TruncateFsImpl<false>( std::move( fs ), std::move( path ), std::move( size ) );
  }

tuple_call_impl()

template<typename FUNC, typename TUPL, int ... INDICES>

auto XrdCl::tuple_call_impl ( FUNC & func, TUPL & args, sequence< INDICES... >  ) -> decltype( func( std::move( std::get<INDICES>( args ) )... ) )

inlinestatic

Definition at line 49 of file XrdClApply.hh.

  {
      return func( std::move( std::get<INDICES>( args ) )... );
  }

VectorRead() [1/2]

VectorReadImpl< false > XrdCl::VectorRead ( Ctx< File > file, Arg< ChunkList > chunks, Arg< void * > buffer, uint16_t timeout = 0 )

inline

Factory for creating VectorReadImpl objects.

Definition at line 747 of file XrdClFileOperations.hh.

  {
    return VectorReadImpl<false>( std::move( file ), std::move( chunks ), std::move( buffer ) ).Timeout( timeout );
  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by XrdCl::ActionExecutor::Execute(), and XrdEc::Reader::VectorRead().

Here is the call graph for this function:

Here is the caller graph for this function:

VectorRead() [2/2]

VectorReadImpl< false > XrdCl::VectorRead ( Ctx< File > file, Arg< ChunkList > chunks, uint16_t timeout = 0 )

inline

Definition at line 753 of file XrdClFileOperations.hh.

  {
    return VectorReadImpl<false>( std::move( file ), std::move( chunks ), nullptr ).Timeout( timeout );
  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Here is the call graph for this function:

VectorWrite()

VectorWriteImpl< false > XrdCl::VectorWrite ( Ctx< File > file, Arg< ChunkList > chunks, uint16_t timeout = 0 )

inline

Factory for creating VectorWriteImpl objects.

Definition at line 807 of file XrdClFileOperations.hh.

  {
    return VectorWriteImpl<false>( std::move( file ), std::move( chunks ) ).Timeout( timeout );
  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by XrdCl::ZipArchive::CloseArchive(), and XrdCl::ActionExecutor::Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

WaitFor()

XRootDStatus XrdCl::WaitFor ( Pipeline pipeline, uint16_t timeout = 0 )

inline

Helper function, schedules execution of given pipeline and waits for the status

Parameters

pipeline	: the pipeline to be executed
timeout	: the pipeline timeout

Returns

: status of the operation

Definition at line 502 of file XrdClOperations.hh.

  {
    return Async( std::move( pipeline ), timeout ).get();
  }

References Async().

Referenced by DoRm(), and XrdCl::ActionExecutor::Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Write() [1/2]

WriteImpl< false > XrdCl::Write ( Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< const void * > buffer, uint16_t timeout = 0 )

inline

Factory for creating WriteImpl objects.

Definition at line 591 of file XrdClFileOperations.hh.

  {
    return WriteImpl<false>( std::move( file ), std::move( offset ), std::move( size ),
                             std::move( buffer ) ).Timeout( timeout );
  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by XrdCl::ZipArchive::CloseArchive(), and XrdCl::ActionExecutor::Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Write() [2/2]

ZipWriteImpl< false > XrdCl::Write ( Ctx< ZipArchive > zip, Arg< uint32_t > size, Arg< const void * > buffer, uint16_t timeout = 0 )

inline

Factory for creating ArchiveReadImpl objects.

Definition at line 361 of file XrdClZipOperations.hh.

  {
    return ZipWriteImpl<false>( std::move( zip ), std::move( size ),
                                std::move( buffer ) ).Timeout( timeout );
  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Here is the call graph for this function:

WriteV()

WriteVImpl< false > XrdCl::WriteV ( Ctx< File > file, Arg< uint64_t > offset, Arg< std::vector< iovec > > iov, uint16_t timeout = 0 )

inline

Factory for creating WriteVImpl objects.

Definition at line 872 of file XrdClFileOperations.hh.

  {
    return WriteVImpl<false>( std::move( file ), std::move( offset ),
                              std::move( iov ) ).Timeout( timeout );
  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Here is the call graph for this function:

Variable Documentation

AppMsg

const uint64_t XrdCl::AppMsg = 0x0000000000000001ULL

Definition at line 32 of file XrdClConstants.hh.

Referenced by XrdCl::FSExecutor::AddCommand(), DoCache(), DoCat(), DoCD(), DoChMod(), DoLocate(), DoLS(), DoMkDir(), DoMv(), DoPrepare(), DoQuery(), DoRm(), DoRmDir(), DoSpaceInfo(), DoStat(), DoStatVFS(), DoTail(), DoTruncate(), DoXAttr(), XrdCl::ActionExecutor::Execute(), XrdCl::FSExecutor::Execute(), IndexRemote(), main(), and ProcessStatQuery().

AsyncSockMsg

const uint64_t XrdCl::AsyncSockMsg = 0x0000000000000200ULL

Definition at line 41 of file XrdClConstants.hh.

Referenced by XrdCl::AsyncSocketHandler::CheckHSWait(), XrdCl::AsyncSocketHandler::Close(), XrdCl::AsyncSocketHandler::Connect(), XrdCl::AsyncSocketHandler::DoTlsHandShake(), XrdCl::AsyncSocketHandler::HandleHandShake(), XrdCl::AsyncSocketHandler::OnConnectionReturn(), XrdCl::AsyncSocketHandler::OnFault(), XrdCl::AsyncSocketHandler::OnFaultWhileHandshaking(), XrdCl::AsyncHSReader::Read(), XrdCl::AsyncMsgReader::Read(), XrdCl::Socket::Send(), XrdCl::AsyncHSWriter::Write(), and XrdCl::AsyncMsgWriter::Write().

DefaultAioSignal

const int XrdCl::DefaultAioSignal = 0

Definition at line 84 of file XrdClConstants.hh.

DefaultClConfDir

const char* const XrdCl::DefaultClConfDir = ""

Definition at line 111 of file XrdClConstants.hh.

DefaultClConfFile

const char* const XrdCl::DefaultClConfFile = ""

Definition at line 112 of file XrdClConstants.hh.

DefaultClientMonitor

const char* const XrdCl::DefaultClientMonitor = ""

Definition at line 102 of file XrdClConstants.hh.

Referenced by XrdCl::DefaultEnv::GetMonitor().

DefaultClientMonitorParam

const char* const XrdCl::DefaultClientMonitorParam = ""

Definition at line 103 of file XrdClConstants.hh.

Referenced by XrdCl::DefaultEnv::GetMonitor().

DefaultConnectionRetry

const int XrdCl::DefaultConnectionRetry = 5

Definition at line 53 of file XrdClConstants.hh.

Referenced by XrdCl::Stream::Stream().

DefaultConnectionWindow

const int XrdCl::DefaultConnectionWindow = 120

Definition at line 52 of file XrdClConstants.hh.

Referenced by XrdCl::Stream::Stream().

DefaultCPChunkSize

const int XrdCl::DefaultCPChunkSize = 8388608

Definition at line 61 of file XrdClConstants.hh.

Referenced by XrdCl::MetalinkReadHandler::MetalinkReadHandler(), XrdCl::CopyProcess::AddJob(), XrdCl::MetalinkReadHandler::HandleResponse(), XrdCl::MetalinkOpenHandler::HandleResponseWithHosts(), and main().

DefaultCPInitTimeout

const int XrdCl::DefaultCPInitTimeout = 600

Definition at line 65 of file XrdClConstants.hh.

Referenced by XrdCl::CopyProcess::AddJob().

DefaultCPParallelChunks

const int XrdCl::DefaultCPParallelChunks = 4

Definition at line 62 of file XrdClConstants.hh.

Referenced by XrdCl::CopyProcess::AddJob(), and main().

DefaultCpRetry

const int XrdCl::DefaultCpRetry = 0

Definition at line 97 of file XrdClConstants.hh.

DefaultCpRetryPolicy

const char* const XrdCl::DefaultCpRetryPolicy = "force"

Definition at line 114 of file XrdClConstants.hh.

DefaultCpTarget

const char* const XrdCl::DefaultCpTarget = ""

Definition at line 113 of file XrdClConstants.hh.

DefaultCPTimeout

const int XrdCl::DefaultCPTimeout = 0

Definition at line 67 of file XrdClConstants.hh.

Referenced by XrdCl::CopyProcess::AddJob().

DefaultCPTPCTimeout

const int XrdCl::DefaultCPTPCTimeout = 1800

Definition at line 66 of file XrdClConstants.hh.

Referenced by XrdCl::CopyProcess::AddJob().

DefaultCpUsePgWrtRd

const int XrdCl::DefaultCpUsePgWrtRd = 1

Definition at line 98 of file XrdClConstants.hh.

DefaultDataServerTTL

const int XrdCl::DefaultDataServerTTL = 300

Definition at line 63 of file XrdClConstants.hh.

Referenced by XrdCl::XRootDTransport::IsStreamTTLElapsed().

DefaultGlfnRedirector

const char* const XrdCl::DefaultGlfnRedirector = ""

Definition at line 109 of file XrdClConstants.hh.

DefaultIPNoShuffle

const int XrdCl::DefaultIPNoShuffle = 0

Definition at line 94 of file XrdClConstants.hh.

Referenced by XrdCl::Utils::GetHostAddresses().

DefaultLoadBalancerTTL

const int XrdCl::DefaultLoadBalancerTTL = 1200

Definition at line 64 of file XrdClConstants.hh.

Referenced by XrdCl::XRootDTransport::IsStreamTTLElapsed().

DefaultLocalMetalinkFile

const int XrdCl::DefaultLocalMetalinkFile = 0

Definition at line 75 of file XrdClConstants.hh.

DefaultMaxMetalinkWait

const int XrdCl::DefaultMaxMetalinkWait = 60

Definition at line 86 of file XrdClConstants.hh.

Referenced by XrdCl::XRootDMsgHandler::Process().

DefaultMetalinkProcessing

const int XrdCl::DefaultMetalinkProcessing = 1

Definition at line 74 of file XrdClConstants.hh.

Referenced by XrdCl::URL::IsMetalink().

DefaultMultiProtocol

const int XrdCl::DefaultMultiProtocol = 0

Definition at line 72 of file XrdClConstants.hh.

DefaultNetworkStack

const char* const XrdCl::DefaultNetworkStack = "IPAuto"

Definition at line 101 of file XrdClConstants.hh.

Referenced by XrdCl::Stream::Stream().

DefaultNoDelay

const int XrdCl::DefaultNoDelay = 1

Definition at line 82 of file XrdClConstants.hh.

Referenced by XrdCl::Socket::Initialize().

DefaultNotAuthorizedRetryLimit

const int XrdCl::DefaultNotAuthorizedRetryLimit = 3

Definition at line 88 of file XrdClConstants.hh.

DefaultNoTlsOK

const int XrdCl::DefaultNoTlsOK = 0

Definition at line 90 of file XrdClConstants.hh.

Referenced by XrdCl::XRootDTransport::NeedEncryption().

DefaultOpenRecovery

const char* const XrdCl::DefaultOpenRecovery = "true"

Definition at line 108 of file XrdClConstants.hh.

DefaultParallelEvtLoop

const int XrdCl::DefaultParallelEvtLoop = 10

Definition at line 73 of file XrdClConstants.hh.

DefaultPlugIn

const char* const XrdCl::DefaultPlugIn = ""

Definition at line 105 of file XrdClConstants.hh.

Referenced by XrdCl::PlugInManager::ProcessEnvironmentSettings().

DefaultPlugInConfDir

const char* const XrdCl::DefaultPlugInConfDir = ""

Definition at line 104 of file XrdClConstants.hh.

Referenced by XrdCl::PlugInManager::ProcessEnvironmentSettings().

DefaultPollerPreference

const char* const XrdCl::DefaultPollerPreference = "built-in"

Definition at line 100 of file XrdClConstants.hh.

Referenced by XrdCl::PostMaster::Initialize().

DefaultPreferIPv4

const int XrdCl::DefaultPreferIPv4 = 0

Definition at line 85 of file XrdClConstants.hh.

Referenced by XrdCl::Utils::GetHostAddresses().

DefaultPreserveLocateTried

const int XrdCl::DefaultPreserveLocateTried = 1

Definition at line 87 of file XrdClConstants.hh.

Referenced by XrdCl::MessageUtils::RewriteCGIAndPath().

DefaultPreserveXAttrs

const int XrdCl::DefaultPreserveXAttrs = 0

Definition at line 89 of file XrdClConstants.hh.

Referenced by main().

DefaultReadRecovery

const char* const XrdCl::DefaultReadRecovery = "true"

Definition at line 106 of file XrdClConstants.hh.

DefaultRedirectLimit

const int XrdCl::DefaultRedirectLimit = 16

Definition at line 59 of file XrdClConstants.hh.

Referenced by XrdCl::MessageUtils::ProcessSendParams().

DefaultRequestTimeout

const int XrdCl::DefaultRequestTimeout = 1800

Definition at line 54 of file XrdClConstants.hh.

Referenced by XrdCl::ZipListHandler::ZipListHandler(), XrdCl::FileStateHandler::PgWrite(), and XrdCl::MessageUtils::ProcessSendParams().

DefaultRetryWrtAtLBLimit

const int XrdCl::DefaultRetryWrtAtLBLimit = 3

Definition at line 96 of file XrdClConstants.hh.

DefaultRunForkHandler

const int XrdCl::DefaultRunForkHandler = 1

Definition at line 58 of file XrdClConstants.hh.

Referenced by child(), parent(), and prepare().

DefaultStreamErrorWindow

const int XrdCl::DefaultStreamErrorWindow = 1800

Definition at line 57 of file XrdClConstants.hh.

Referenced by XrdCl::Stream::Stream().

DefaultStreamTimeout

const int XrdCl::DefaultStreamTimeout = 60

Definition at line 55 of file XrdClConstants.hh.

Referenced by XrdCl::XRootDTransport::IsStreamBroken().

DefaultSubStreamsPerChannel

const int XrdCl::DefaultSubStreamsPerChannel = 1

Definition at line 51 of file XrdClConstants.hh.

Referenced by XrdCl::XRootDTransport::InitializeChannel().

DefaultTCPKeepAlive

const int XrdCl::DefaultTCPKeepAlive = 0

Definition at line 68 of file XrdClConstants.hh.

Referenced by XrdCl::AsyncSocketHandler::Connect().

DefaultTCPKeepAliveInterval

const int XrdCl::DefaultTCPKeepAliveInterval = 75

Definition at line 70 of file XrdClConstants.hh.

Referenced by XrdCl::AsyncSocketHandler::Connect().

DefaultTCPKeepAliveProbes

const int XrdCl::DefaultTCPKeepAliveProbes = 9

Definition at line 71 of file XrdClConstants.hh.

Referenced by XrdCl::AsyncSocketHandler::Connect().

DefaultTCPKeepAliveTime

const int XrdCl::DefaultTCPKeepAliveTime = 7200

Definition at line 69 of file XrdClConstants.hh.

Referenced by XrdCl::AsyncSocketHandler::Connect().

DefaultTimeoutResolution

const int XrdCl::DefaultTimeoutResolution = 15

Definition at line 56 of file XrdClConstants.hh.

Referenced by XrdCl::AsyncSocketHandler::AsyncSocketHandler(), XrdCl::Channel::Channel(), XrdCl::FileTimer::Run(), and XrdCl::TickGeneratorTask::Run().

DefaultTlsDbgLvl

const char* const XrdCl::DefaultTlsDbgLvl = "OFF"

Definition at line 110 of file XrdClConstants.hh.

DefaultTlsMetalink

const int XrdCl::DefaultTlsMetalink = 0

Definition at line 92 of file XrdClConstants.hh.

DefaultTlsNoData

const int XrdCl::DefaultTlsNoData = 0

Definition at line 91 of file XrdClConstants.hh.

Referenced by XrdCl::XRootDTransport::SubStreamNumber().

DefaultWantTlsOnNoPgrw

const int XrdCl::DefaultWantTlsOnNoPgrw = 0

Definition at line 95 of file XrdClConstants.hh.

DefaultWorkerThreads

const int XrdCl::DefaultWorkerThreads = 3

Definition at line 60 of file XrdClConstants.hh.

Referenced by XrdCl::PostMasterImpl::PostMasterImpl().

DefaultWriteRecovery

const char* const XrdCl::DefaultWriteRecovery = "true"

Definition at line 107 of file XrdClConstants.hh.

DefaultXCpBlockSize

const int XrdCl::DefaultXCpBlockSize = 134217728

Definition at line 77 of file XrdClConstants.hh.

Referenced by XrdCl::CopyProcess::AddJob(), and main().

DefaultXRateThreshold

const int XrdCl::DefaultXRateThreshold = 0

Definition at line 76 of file XrdClConstants.hh.

Referenced by XrdCl::CopyProcess::AddJob().

DefaultZipMtlnCksum

const int XrdCl::DefaultZipMtlnCksum = 0

Definition at line 93 of file XrdClConstants.hh.

Referenced by XrdCl::Utils::InferChecksumType().

errAuthFailed

const uint16_t XrdCl::errAuthFailed = 204

Definition at line 88 of file XrdClStatus.hh.

errCheckSumError

const uint16_t XrdCl::errCheckSumError = 305

Definition at line 101 of file XrdClStatus.hh.

Referenced by XrdCl::Utils::GetLocalCheckSum(), XrdCl::Utils::GetRemoteCheckSum(), XrdCl::CheckSumHelper::Initialize(), XrdCl::ClassicCopyJob::Run(), and XrdCl::ThirdPartyCopyJob::Run().

errConfig

const uint16_t XrdCl::errConfig = 6

System misconfigured.

Definition at line 55 of file XrdClStatus.hh.

Referenced by XrdCl::Utils::ProcessConfig().

errConnectionError

const uint16_t XrdCl::errConnectionError = 108

Definition at line 78 of file XrdClStatus.hh.

Referenced by XrdCl::FileStateHandler::Close(), and XrdCl::AsyncSocketHandler::OnConnectionReturn().

errCorruptedHeader

const uint16_t XrdCl::errCorruptedHeader = 307

Definition at line 103 of file XrdClStatus.hh.

Referenced by XrdCl::AsyncSocketHandler::OnRead(), XrdCl::AsyncDiscardReader::Read(), XrdCl::AsyncMsgReader::Read(), XrdCl::AsyncRawReader::Read(), and XrdCl::AsyncVectorReader::Read().

errDataError

const uint16_t XrdCl::errDataError = 14

data is corrupted

Definition at line 63 of file XrdClStatus.hh.

Referenced by XrdEc::block_t::fail_missing(), XrdCl::XRootDTransport::GetMore(), XrdCl::ChunkHandler::HandleResponse(), XrdCl::XRootDMsgHandler::InspectStatusRsp(), XrdCl::ZipArchive::OpenArchive(), XrdCl::FileStateHandler::PgWrite(), XrdEc::block_t::read(), XrdCl::ClassicCopyJob::Run(), XrdCl::XRootDTransport::UnMarchalStatusMore(), and XrdCl::XRootDTransport::UnMarshalStatusBody().

errErrorResponse

const uint16_t XrdCl::errErrorResponse = 400

Definition at line 105 of file XrdClStatus.hh.

Referenced by Fatal(), XrdSsiUtils::GetErr(), XrdCl::XRootDMsgHandler::Process(), Posix::Rename(), XrdPosixMap::Result(), XrdSsiUtils::SetErr(), and XrdCl::XRootDStatus::ToStr().

errFcntl

const uint16_t XrdCl::errFcntl = 4

failed manipulate file descriptor

Definition at line 53 of file XrdClStatus.hh.

Referenced by XrdCl::Socket::Initialize().

errHandShakeFailed

const uint16_t XrdCl::errHandShakeFailed = 202

Definition at line 86 of file XrdClStatus.hh.

errInProgress

const uint16_t XrdCl::errInProgress = 10

Definition at line 59 of file XrdClStatus.hh.

Referenced by XrdCl::FileStateHandler::Close(), and XrdCl::FileStateHandler::Open().

errInternal

const uint16_t XrdCl::errInternal = 7

Internal error.

Definition at line 56 of file XrdClStatus.hh.

Referenced by Posix::_PRead(), XrdCl::Socket::ClassifyErrno(), Posix::Close(), Posix::DirList(), XrdCl::XRootDTransport::GetHeader(), XrdCl::Utils::GetLocalCheckSum(), XrdCl::Utils::GetRemoteCheckSum(), XrdCl::XRootDTransport::GetSignature(), XrdCl::ChunkHandler::HandleResponse(), XrdCl::FutureWrapper< Response >::HandleResponse(), XrdCl::MetalinkReadHandler::HandleResponse(), XrdCl::MetalinkOpenHandler::HandleResponseWithHosts(), XrdCl::XRootDTransport::HandShake(), XrdCl::CheckSumHelper::Initialize(), XrdCl::XCpCtx::Initialize(), Posix::MkDir(), XrdCl::AsyncSocketHandler::OnRead(), XrdCl::AsyncSocketHandler::OnReadWhileHandshaking(), XrdCl::AsyncSocketHandler::OnWrite(), Posix::PReadVec(), Posix::PWrite(), XrdCl::XRootDTransport::Query(), XrdCl::AsyncRawReader::Read(), XrdCl::AsyncVectorReader::Read(), XrdCl::EcHandler::Read(), Posix::Rename(), Posix::RmDir(), XrdCl::Operation< HasHndl >::Run(), XrdCl::AsyncSocketHandler::SendHSMsg(), Posix::Unlink(), XrdCl::MessageUtils::WaitForResponse(), XrdCl::EcHandler::Write(), XrdCl::FileStateHandler::Write(), XrdCl::FileStateHandler::Write(), and XrdCl::XRootDMsgHandler::WriteMessageBody().

errInvalidAddr

const uint16_t XrdCl::errInvalidAddr = 101

Definition at line 71 of file XrdClStatus.hh.

Referenced by DoCat(), DoTail(), DoXAttr(), and XrdCl::Utils::GetHostAddresses().

errInvalidArgs

const uint16_t XrdCl::errInvalidArgs = 9

Definition at line 58 of file XrdClStatus.hh.

Referenced by XrdCl::CopyProcess::AddJob(), BuildPath(), XrdCl::Socket::ClassifyErrno(), ConvertMode(), XrdCl::MessageUtils::CreateXAttrVec(), XrdCl::MessageUtils::CreateXAttrVec(), DoCache(), DoCat(), DoCD(), DoChMod(), DoLocate(), DoLS(), DoMkDir(), DoMv(), DoPrepare(), DoQuery(), DoRm(), DoRmDir(), DoSpaceInfo(), DoStat(), DoStatVFS(), DoTail(), DoTruncate(), DoXAttr(), XrdCl::CheckSumHelper::GetRawCheckSum(), XrdCl::FileStateHandler::Open(), XrdCl::FileStateHandler::PgReadRetry(), XrdCl::EcHandler::PgWrite(), XrdCl::FileStateHandler::PgWrite(), XrdCl::CopyProcess::Prepare(), ProcessStatQuery(), XrdCl::ClassicCopyJob::Run(), and XrdEc::Reader::VectorRead().

errInvalidMessage

const uint16_t XrdCl::errInvalidMessage = 201

Definition at line 85 of file XrdClStatus.hh.

Referenced by XrdCl::XRootDTransport::GetMore(), XrdCl::XRootDMsgHandler::Process(), XrdCl::XRootDTransport::UnMarchalStatusMore(), XrdCl::XRootDTransport::UnMarshallBody(), and XrdCl::XRootDTransport::UnMarshalStatusBody().

errInvalidOp

const uint16_t XrdCl::errInvalidOp = 3

The operation cannot be performed in the given circumstances

Definition at line 51 of file XrdClStatus.hh.

Referenced by XrdCl::ZipArchive::AppendFile(), XrdCl::FileStateHandler::Checkpoint(), XrdCl::FileStateHandler::ChkptWrt(), XrdCl::FileStateHandler::ChkptWrtV(), XrdCl::FileStateHandler::Close(), XrdCl::HttpFilePlugIn::Close(), XrdCl::ZipArchive::CloseFile(), XrdCl::Socket::Connect(), XrdCl::Socket::ConnectToAddress(), XrdCl::FileStateHandler::DelXAttr(), XrdCl::FileStateHandler::Fcntl(), XrdCl::PostMaster::ForceDisconnect(), XrdCl::PostMaster::ForceReconnect(), XrdCl::ZipArchive::GetCRC32(), XrdCl::Socket::GetFlags(), XrdCl::XRootDTransport::GetMore(), XrdCl::ZipArchive::GetOffset(), XrdCl::XRootDTransport::GetSignature(), XrdCl::Socket::GetSockOpt(), XrdCl::FileStateHandler::GetXAttr(), XrdCl::Socket::Initialize(), XrdCl::ZipArchive::List(), XrdCl::FileStateHandler::ListXAttr(), main(), XrdCl::FileStateHandler::Open(), XrdCl::HttpFilePlugIn::Open(), xrdcl_proxy::ProxyPrefixFile::Open(), XrdCl::ZipArchive::OpenArchive(), XrdCl::ZipArchive::OpenFile(), XrdCl::ZipArchive::PgRead(), XrdCl::FileStateHandler::PgReadImpl(), XrdCl::FileStateHandler::PgWriteImpl(), XrdCl::Socket::Poll(), XrdCl::PostMaster::QueryTransport(), XrdCl::FileStateHandler::Read(), XrdCl::HttpFilePlugIn::Read(), XrdCl::ZipArchive::Read(), XrdEc::block_t::read(), XrdCl::ZipArchive::ReadFromImpl, XrdCl::Socket::ReadRaw(), XrdCl::FileStateHandler::ReadV(), XrdCl::PostMaster::Redirect(), XrdCl::Socket::SetFlags(), XrdCl::Socket::SetSockOpt(), XrdCl::FileStateHandler::SetXAttr(), XrdCl::EcHandler::Stat(), XrdCl::FileStateHandler::Stat(), XrdCl::HttpFilePlugIn::Stat(), XrdCl::ZipArchive::Stat(), XrdCl::ZipArchive::Stat(), XrdCl::FileStateHandler::Sync(), XrdCl::Socket::TlsHandShake(), XrdCl::FileStateHandler::Truncate(), XrdCl::FileStateHandler::TryOtherServer(), XrdCl::ZipArchive::UpdateMetadata(), XrdCl::FileStateHandler::VectorRead(), XrdCl::HttpFilePlugIn::VectorRead(), XrdCl::FileStateHandler::VectorWrite(), XrdCl::FileStateHandler::Visa(), XrdCl::FileStateHandler::Write(), XrdCl::HttpFilePlugIn::Write(), XrdCl::ZipArchive::Write(), XrdCl::Socket::WriteRaw(), and XrdCl::FileStateHandler::WriteV().

errInvalidRedirectURL

const uint16_t XrdCl::errInvalidRedirectURL = 302

Definition at line 98 of file XrdClStatus.hh.

Referenced by XrdCl::XRootDMsgHandler::Process().

errInvalidResponse

const uint16_t XrdCl::errInvalidResponse = 303

Definition at line 99 of file XrdClStatus.hh.

Referenced by XrdCl::Utils::GetRemoteCheckSum(), XrdCl::AsyncDiscardReader::GetResponse(), XrdCl::AsyncRawReader::GetResponse(), XrdCl::AsyncVectorReader::GetResponse(), XrdCl::FileSystemUtils::GetSpaceInfo(), and XrdCl::XRootDMsgHandler::Process().

errInvalidSession

const uint16_t XrdCl::errInvalidSession = 109

Definition at line 79 of file XrdClStatus.hh.

Referenced by XrdCl::FileStateHandler::Close(), and XrdCl::Stream::Send().

errLocalError

const uint16_t XrdCl::errLocalError = 402

Definition at line 107 of file XrdClStatus.hh.

Referenced by XrdCl::LocalFileHandler::Close(), XrdCl::LocalFileHandler::DelXAttr(), XrdCl::LocalFileHandler::GetXAttr(), XrdCl::LocalFileHandler::ListXAttr(), XrdCl::LocalFileHandler::MkdirPath(), XrdCl::LocalFileHandler::Open(), XrdCl::LocalFileHandler::Read(), XrdCl::LocalFileHandler::ReadV(), XrdCl::LocalFileHandler::SetXAttr(), XrdCl::LocalFileHandler::Stat(), XrdCl::LocalFileHandler::Sync(), XrdCl::LocalFileHandler::Truncate(), XrdCl::LocalFileHandler::VectorRead(), XrdCl::LocalFileHandler::VectorWrite(), XrdCl::LocalFileHandler::Write(), and XrdCl::LocalFileHandler::WriteV().

errLoginFailed

const uint16_t XrdCl::errLoginFailed = 203

Definition at line 87 of file XrdClStatus.hh.

errNoMoreFreeSIDs

const uint16_t XrdCl::errNoMoreFreeSIDs = 301

Definition at line 97 of file XrdClStatus.hh.

Referenced by XrdCl::SIDManager::AllocateSID().

errNoMoreReplicas

const uint16_t XrdCl::errNoMoreReplicas = 16

No more replicas to try.

Definition at line 65 of file XrdClStatus.hh.

Referenced by XrdCl::XCpCtx::GetChunk().

errNone

const uint16_t XrdCl::errNone = 0

No error.

Definition at line 48 of file XrdClStatus.hh.

Referenced by XrdCl::Status::Status().

errNotFound

const uint16_t XrdCl::errNotFound = 304

Definition at line 100 of file XrdClStatus.hh.

Referenced by XrdCl::FileSystem::DirList(), XrdCl::ZipArchive::GetCRC32(), XrdCl::ZipArchive::GetOffset(), XrdCl::ZipArchive::OpenFile(), XrdCl::ZipArchive::ReadFromImpl, and XrdCl::ZipArchive::Stat().

errNotImplemented

const uint16_t XrdCl::errNotImplemented = 15

Operation is not implemented.

Definition at line 64 of file XrdClStatus.hh.

Referenced by XrdCl::FileSystemPlugIn::ChMod(), XrdCl::FilePlugIn::Close(), XrdCl::FileSystemPlugIn::DeepLocate(), XrdCl::FileSystemPlugIn::DelXAttr(), XrdCl::FileSystemPlugIn::DirList(), XrdCl::FilePlugIn::Fcntl(), XrdCl::FileSystemPlugIn::GetXAttr(), XrdCl::FileSystemPlugIn::ListXAttr(), XrdCl::FileSystemPlugIn::Locate(), XrdCl::FileSystemPlugIn::MkDir(), XrdCl::FileSystemPlugIn::Mv(), XrdCl::FilePlugIn::Open(), XrdCl::FilePlugIn::PgRead(), XrdCl::FilePlugIn::PgWrite(), XrdCl::FileSystemPlugIn::Ping(), XrdCl::FileSystemPlugIn::Prepare(), XrdCl::FileSystemPlugIn::Protocol(), XrdCl::FileSystemPlugIn::Query(), XrdCl::FilePlugIn::Read(), XrdCl::FilePlugIn::Read(), XrdCl::FileSystemPlugIn::Rm(), XrdCl::FileSystemPlugIn::RmDir(), XrdCl::FileSystemPlugIn::SendInfo(), XrdCl::FileSystemPlugIn::SetXAttr(), XrdCl::FilePlugIn::Stat(), XrdCl::FileSystemPlugIn::Stat(), XrdCl::FileSystemPlugIn::StatVFS(), XrdCl::FilePlugIn::Sync(), XrdCl::FilePlugIn::Truncate(), XrdCl::FileSystemPlugIn::Truncate(), XrdCl::FilePlugIn::VectorRead(), XrdCl::FilePlugIn::VectorWrite(), XrdCl::FilePlugIn::Visa(), XrdCl::FilePlugIn::Write(), XrdCl::FilePlugIn::Write(), XrdCl::FilePlugIn::Write(), and XrdCl::FilePlugIn::WriteV().

errNotSupported

const uint16_t XrdCl::errNotSupported = 13

Definition at line 62 of file XrdClStatus.hh.

Referenced by XrdCl::Utils::CheckTPC(), XrdCl::Utils::CheckTPCLite(), XrdCl::EcHandler::Close(), XrdCl::File::DelXAttr(), XrdCl::FileSystem::DelXAttr(), XrdCl::FileSystem::DirList(), XrdCl::LocalFileHandler::ExecRequest(), XrdCl::LocalFileHandler::Fcntl(), XrdCl::ZipArchive::GetOffset(), XrdCl::File::GetXAttr(), XrdCl::FileSystem::GetXAttr(), XrdCl::File::ListXAttr(), XrdCl::FileSystem::ListXAttr(), XrdCl::EcHandler::Open(), XrdCl::PostMaster::QueryTransport(), XrdCl::ZipArchive::ReadFromImpl, XrdCl::PostMaster::RegisterEventHandler(), XrdCl::PostMaster::RemoveEventHandler(), XrdCl::TPFallBackCopyJob::Run(), XrdCl::PostMaster::Send(), XrdCl::Socket::Send(), XrdCl::File::SetXAttr(), XrdCl::FileSystem::SetXAttr(), XrdCl::XRootDTransport::UnMarchalStatusMore(), XrdCl::LocalFileHandler::Visa(), and XrdCl::EcHandler::Write().

errOperationExpired

const uint16_t XrdCl::errOperationExpired = 206

Definition at line 90 of file XrdClStatus.hh.

Referenced by XrdCl::ZipListHandler::HandleResponse(), XrdCl::FileStateHandler::PgWrite(), XrdCl::XRootDMsgHandler::Process(), XrdCl::InQueue::ReportTimeout(), XrdCl::ClassicCopyJob::Run(), XrdCl::Operation< HasHndl >::Run(), XrdCl::TPFallBackCopyJob::Run(), XrdCl::Stream::Tick(), and XrdCl::FileStateHandler::TimeOutRequests().

errOperationInterrupted

const uint16_t XrdCl::errOperationInterrupted = 207

Definition at line 91 of file XrdClStatus.hh.

Referenced by XrdCl::Channel::ForceDisconnect(), and XrdCl::ClassicCopyJob::Run().

errOSError

const uint16_t XrdCl::errOSError = 12

Definition at line 61 of file XrdClStatus.hh.

Referenced by XrdCl::Utils::GetDirectoryEntries(), XrdCl::Utils::ProcessConfig(), XrdCl::CopyProcess::Run(), and XrdCl::LocalFileHandler::Sync().

errPipelineFailed

const uint16_t XrdCl::errPipelineFailed = 17

Pipeline failed and operation couldn't be executed.

Definition at line 66 of file XrdClStatus.hh.

Referenced by XrdCl::FutureWrapperBase< Response >::~FutureWrapperBase().

errPoll

const uint16_t XrdCl::errPoll = 5

error while polling descriptors

Definition at line 54 of file XrdClStatus.hh.

Referenced by XrdCl::Socket::Poll().

errPollerError

const uint16_t XrdCl::errPollerError = 105

Definition at line 75 of file XrdClStatus.hh.

Referenced by XrdCl::FileStateHandler::Close(), XrdCl::AsyncSocketHandler::Connect(), XrdCl::AsyncSocketHandler::DisableUplink(), XrdCl::AsyncSocketHandler::EnableUplink(), and XrdCl::AsyncSocketHandler::OnConnectionReturn().

errQueryNotSupported

const uint16_t XrdCl::errQueryNotSupported = 205

Definition at line 89 of file XrdClStatus.hh.

Referenced by XrdCl::Stream::Query(), and XrdCl::XRootDTransport::Query().

errRedirect

const uint16_t XrdCl::errRedirect = 401

Definition at line 106 of file XrdClStatus.hh.

Referenced by XrdCl::FileStateHandler::OnStateError(), and XrdCl::XRootDMsgHandler::Process().

errRedirectLimit

const uint16_t XrdCl::errRedirectLimit = 306

Definition at line 102 of file XrdClStatus.hh.

Referenced by XrdCl::XRootDMsgHandler::Process().

errResponseNegative

const uint16_t XrdCl::errResponseNegative = 500

Query response was negative.

Definition at line 109 of file XrdClStatus.hh.

Referenced by ProcessStatQuery().

errRetry

const uint16_t XrdCl::errRetry = 1

Try again for whatever reason.

Definition at line 49 of file XrdClStatus.hh.

Referenced by XrdCl::ClassicCopyJob::Run().

errSocketDisconnected

const uint16_t XrdCl::errSocketDisconnected = 104

Definition at line 74 of file XrdClStatus.hh.

Referenced by XrdCl::FileStateHandler::Close(), XrdCl::Socket::Poll(), and XrdCl::Socket::ReadRaw().

errSocketError

const uint16_t XrdCl::errSocketError = 102

Definition at line 72 of file XrdClStatus.hh.

Referenced by XrdCl::Socket::ClassifyErrno(), XrdCl::FileStateHandler::Close(), XrdCl::Socket::ConnectToAddress(), XrdCl::Socket::GetFlags(), XrdCl::Socket::Initialize(), XrdCl::AsyncSocketHandler::OnHeaderCorruption(), XrdCl::AsyncSocketHandler::OnWrite(), XrdCl::Socket::Poll(), XrdCl::Socket::Read(), XrdCl::Socket::ReadRaw(), XrdCl::Socket::ReadV(), XrdCl::Socket::SetFlags(), and XrdCl::Socket::WriteRaw().

errSocketOptError

const uint16_t XrdCl::errSocketOptError = 106

Definition at line 76 of file XrdClStatus.hh.

Referenced by XrdCl::FileStateHandler::Close(), XrdCl::Socket::Cork(), XrdCl::Socket::GetSockOpt(), XrdCl::AsyncSocketHandler::OnConnectionReturn(), XrdCl::Socket::SetSockOpt(), and XrdCl::Socket::Uncork().

errSocketTimeout

const uint16_t XrdCl::errSocketTimeout = 103

Definition at line 73 of file XrdClStatus.hh.

Referenced by XrdCl::Socket::ConnectToAddress(), XrdCl::AsyncSocketHandler::HandleHandShake(), XrdCl::XRootDTransport::IsStreamBroken(), XrdCl::AsyncSocketHandler::OnTimeoutWhileHandshaking(), XrdCl::Socket::Poll(), XrdCl::Socket::ReadRaw(), and XrdCl::Socket::WriteRaw().

errStreamDisconnect

const uint16_t XrdCl::errStreamDisconnect = 107

Definition at line 77 of file XrdClStatus.hh.

errThresholdExceeded

const uint16_t XrdCl::errThresholdExceeded = 208

Definition at line 92 of file XrdClStatus.hh.

Referenced by XrdCl::ClassicCopyJob::Run().

errTlsError

const uint16_t XrdCl::errTlsError = 110

Definition at line 80 of file XrdClStatus.hh.

Referenced by XrdCl::Socket::TlsHandShake().

errUninitialized

const uint16_t XrdCl::errUninitialized = 11

Definition at line 60 of file XrdClStatus.hh.

Referenced by XrdCl::Stream::Initialize(), XrdCl::MessageUtils::RedirectMessage(), and XrdCl::MessageUtils::SendMessage().

errUnknown

const uint16_t XrdCl::errUnknown = 2

Unknown error.

Definition at line 50 of file XrdClStatus.hh.

Referenced by Posix::PReadVec().

errUnknownCommand

const uint16_t XrdCl::errUnknownCommand = 8

Definition at line 57 of file XrdClStatus.hh.

Referenced by XrdCl::FSExecutor::Execute().

ExDbgMsg

const uint64_t XrdCl::ExDbgMsg = 0x0000000000001000ULL

Definition at line 44 of file XrdClConstants.hh.

Referenced by XrdCl::XRootDMsgHandler::XRootDMsgHandler(), XrdCl::XRootDMsgHandler::~XRootDMsgHandler(), XrdCl::InQueue::AssignTimeout(), XrdCl::XRootDMsgHandler::Examine(), XrdCl::InQueue::GetHandlerForMessage(), XrdCl::XRootDMsgHandler::Process(), and XrdCl::InQueue::RemoveMessageHandler().

FileMsg

const uint64_t XrdCl::FileMsg = 0x0000000000000004ULL

Definition at line 34 of file XrdClConstants.hh.

Referenced by XrdCl::FileSystem::FileSystem(), XrdCl::FileStateHandler::AfterForkChild(), XrdCl::FileStateHandler::Checkpoint(), XrdCl::FileStateHandler::ChkptWrt(), XrdCl::FileStateHandler::ChkptWrtV(), XrdCl::FileStateHandler::Close(), XrdCl::LocalFileHandler::Close(), XrdCl::FileStateHandler::DelXAttr(), XrdCl::FileStateHandler::Fcntl(), XrdCl::FileStateHandler::GetXAttr(), XrdCl::FileStateHandler::ListXAttr(), XrdCl::FileStateHandler::OnClose(), XrdCl::FileStateHandler::OnOpen(), XrdCl::FileStateHandler::OnStateError(), XrdCl::FileStateHandler::OnStateResponse(), XrdCl::File::Open(), XrdCl::FileStateHandler::Open(), XrdCl::FileStateHandler::PgRead(), XrdCl::FileStateHandler::PgReadImpl(), XrdCl::FileStateHandler::PgWrite(), XrdCl::FileStateHandler::PgWriteImpl(), XrdCl::FileStateHandler::Read(), XrdCl::LocalFileHandler::Read(), XrdCl::FileStateHandler::ReadV(), XrdCl::LocalFileHandler::ReadV(), XrdCl::FileStateHandler::SetXAttr(), XrdCl::FileStateHandler::Stat(), XrdCl::LocalFileHandler::Stat(), XrdCl::FileStateHandler::Sync(), XrdCl::LocalFileHandler::Sync(), XrdCl::FileStateHandler::TimeOutRequests(), XrdCl::FileStateHandler::Truncate(), XrdCl::LocalFileHandler::Truncate(), XrdCl::FileStateHandler::TryOtherServer(), XrdCl::FileStateHandler::VectorRead(), XrdCl::LocalFileHandler::VectorRead(), XrdCl::FileStateHandler::VectorWrite(), XrdCl::LocalFileHandler::VectorWrite(), XrdCl::FileStateHandler::Visa(), XrdCl::FileStateHandler::Write(), XrdCl::FileStateHandler::Write(), XrdCl::LocalFileHandler::Write(), XrdCl::FileStateHandler::WriteV(), and XrdCl::LocalFileHandler::WriteV().

FileSystemMsg

const uint64_t XrdCl::FileSystemMsg = 0x0000000000000100ULL

Definition at line 40 of file XrdClConstants.hh.

Referenced by XrdCl::FileSystemData::AssignLastURL(), XrdCl::FileSystemData::AssignLoadBalancer(), and XrdCl::FileSystemData::Send().

JobMgrMsg

const uint64_t XrdCl::JobMgrMsg = 0x0000000000000400ULL

Definition at line 42 of file XrdClConstants.hh.

Referenced by XrdCl::JobManager::Start(), and XrdCl::JobManager::Stop().

kLogXrdClHttp

const uint64_t XrdCl::kLogXrdClHttp = std::numeric_limits<std::uint64_t>::max()

static

Definition at line 16 of file XrdClHttpPlugInUtil.hh.

Referenced by XrdCl::HttpFilePlugIn::HttpFilePlugIn(), XrdCl::HttpFileSystemPlugIn::HttpFileSystemPlugIn(), XrdCl::HttpFilePlugIn::Close(), XrdCl::HttpFileSystemPlugIn::DirList(), XrdCl::HttpFileSystemPlugIn::MkDir(), XrdCl::HttpFileSystemPlugIn::Mv(), XrdCl::HttpFilePlugIn::Open(), XrdCl::HttpFilePlugIn::Read(), XrdCl::HttpFileSystemPlugIn::Rm(), XrdCl::HttpFileSystemPlugIn::RmDir(), SetUpLogging(), XrdCl::HttpFilePlugIn::Stat(), XrdCl::HttpFileSystemPlugIn::Stat(), XrdCl::HttpFilePlugIn::Sync(), XrdCl::HttpFilePlugIn::VectorRead(), and XrdCl::HttpFilePlugIn::Write().

none

struct XrdCl::None XrdCl::none

static

Referenced by XrdCl::Optional< T >::Optional().

NullRef< Response >::value

template<typename Response>

Response XrdCl::NullRef< Response >::value

Definition at line 128 of file XrdClOperationHandlers.hh.

Referenced by XrdCl::Arg< T >::Arg(), XrdCl::ArgBase< T >::ArgBase(), XrdCl::Fwd< T >::Fwd(), XrdCl::Fwd< T >::Fwd(), XrdCl::FwdStorage< T >::FwdStorage(), XrdCl::FwdStorage< T >::FwdStorage(), XrdCl::ActionMetrics::addDelays(), XrdCl::ActionMetrics::addIos(), XrdCl::MessageUtils::CreateXAttrVec(), DoXAttr(), XrdCl::Env::GetDefaultIntValue(), XrdCl::Env::GetDefaultStringValue(), XrdCl::Env::GetInt(), XrdCl::Utils::GetIntParameter(), XrdCl::File::GetProperty(), XrdCl::FilePlugIn::GetProperty(), XrdCl::FileStateHandler::GetProperty(), XrdCl::FileSystem::GetProperty(), XrdCl::FileSystemPlugIn::GetProperty(), XrdCl::HttpFilePlugIn::GetProperty(), XrdCl::HttpFileSystemPlugIn::GetProperty(), XrdCl::Recorder::GetProperty(), XrdCl::ZipArchive::GetProperty(), xrdcl_proxy::ProxyPrefixFile::GetProperty(), XrdCl::CheckSumHelper::GetRawCheckSum(), XrdCl::Env::GetString(), XrdCl::Utils::GetStringParameter(), XrdCl::LocalFileHandler::GetXAttr(), XrdCl::Env::ImportInt(), XrdCl::Env::ImportString(), XrdCl::ZipArchive::List(), XrdCl::LocalFileHandler::ListXAttr(), XrdCl::Fwd< T >::operator=(), XrdCl::Fwd< T >::operator=(), XrdCl::FwdStorage< T >::operator=(), XrdCl::FwdStorage< T >::operator=(), XrdCl::Utils::ProcessConfig(), XrdCl::Env::PutInt(), XrdCl::Env::PutString(), XrdCl::SetXAttrFsImpl< HasHndl >::RunImpl(), XrdCl::SetXAttrImpl< HasHndl >::RunImpl(), XrdCl::PropertyList::Set(), XrdCl::PropertyList::Set(), XrdCl::File::SetProperty(), XrdCl::FilePlugIn::SetProperty(), XrdCl::FileStateHandler::SetProperty(), XrdCl::FileSystem::SetProperty(), XrdCl::FileSystemPlugIn::SetProperty(), XrdCl::HttpFilePlugIn::SetProperty(), XrdCl::HttpFileSystemPlugIn::SetProperty(), XrdCl::Recorder::SetProperty(), XrdCl::ZipArchive::SetProperty(), xrdcl_proxy::ProxyPrefixFile::SetProperty(), XrdCl::LocalFileHandler::SetXAttr(), SetXAttr(), and SetXAttr().

PlugInMgrMsg

const uint64_t XrdCl::PlugInMgrMsg = 0x0000000000000800ULL

Definition at line 43 of file XrdClConstants.hh.

Referenced by XrdCl::PlugInManager::ProcessEnvironmentSettings(), XrdCl::PlugInManager::RegisterDefaultFactory(), and XrdCl::PlugInManager::RegisterFactory().

PollerMsg

const uint64_t XrdCl::PollerMsg = 0x0000000000000008ULL

Definition at line 35 of file XrdClConstants.hh.

Referenced by XrdCl::PollerBuiltIn::AddSocket(), XrdCl::PollerFactory::CreatePoller(), XrdCl::PollerBuiltIn::EnableReadNotification(), XrdCl::PollerBuiltIn::EnableWriteNotification(), XrdCl::PollerBuiltIn::RemoveSocket(), XrdCl::PollerBuiltIn::Start(), and XrdCl::PollerBuiltIn::Stop().

PostMasterMsg

const uint64_t XrdCl::PostMasterMsg = 0x0000000000000010ULL

Definition at line 36 of file XrdClConstants.hh.

Referenced by XrdCl::Channel::Channel(), XrdCl::Stream::Stream(), XrdCl::Stream::~Stream(), XrdCl::Stream::CanCollapse(), XrdCl::PostMaster::CollapseRedirect(), XrdCl::Socket::Connect(), XrdCl::Stream::DisableIfEmpty(), XrdCl::Stream::EnableLink(), XrdCl::Stream::ForceError(), XrdCl::Stream::OnConnect(), XrdCl::Stream::OnConnectError(), XrdCl::Stream::OnError(), XrdCl::Stream::OnIncoming(), XrdCl::Stream::OnReadTimeout(), XrdCl::Stream::OnReadyToWrite(), and XrdCl::Stream::Send().

root_ctx_

Davix::Context* XrdCl::root_ctx_ = NULL

Definition at line 21 of file XrdClHttpFileSystemPlugIn.cc.

Referenced by XrdCl::HttpFileSystemPlugIn::HttpFileSystemPlugIn(), and XrdCl::HttpFileSystemPlugIn::~HttpFileSystemPlugIn().

root_davix_client_

Davix::DavPosix* XrdCl::root_davix_client_ = NULL

Definition at line 22 of file XrdClHttpFileSystemPlugIn.cc.

Referenced by XrdCl::HttpFileSystemPlugIn::HttpFileSystemPlugIn().

root_davix_client_file_

Davix::DavPosix* XrdCl::root_davix_client_file_ = NULL

Definition at line 46 of file XrdClHttpFilePlugIn.cc.

Referenced by XrdCl::HttpFilePlugIn::HttpFilePlugIn().

root_davix_context_

Davix::Context* XrdCl::root_davix_context_ = NULL

Definition at line 45 of file XrdClHttpFilePlugIn.cc.

Referenced by XrdCl::HttpFilePlugIn::HttpFilePlugIn(), and XrdCl::HttpFilePlugIn::~HttpFilePlugIn().

stError

const uint16_t XrdCl::stError = 0x0001

An error occurred that could potentially be retried.

Definition at line 32 of file XrdClStatus.hh.

Referenced by XrdCl::FutureWrapperBase< Response >::~FutureWrapperBase(), Posix::_PRead(), XrdCl::CopyProcess::AddJob(), XrdCl::SIDManager::AllocateSID(), XrdCl::ZipArchive::AppendFile(), BuildPath(), XrdCl::FileStateHandler::Checkpoint(), XrdCl::Utils::CheckTPC(), XrdCl::Utils::CheckTPCLite(), XrdCl::FileStateHandler::ChkptWrt(), XrdCl::FileStateHandler::ChkptWrtV(), XrdCl::FileSystemPlugIn::ChMod(), XrdCl::Socket::ClassifyErrno(), Posix::Close(), XrdCl::EcHandler::Close(), XrdCl::FilePlugIn::Close(), XrdCl::FileStateHandler::Close(), XrdCl::HttpFilePlugIn::Close(), XrdCl::LocalFileHandler::Close(), XrdCl::ZipArchive::CloseFile(), XrdCl::Socket::Connect(), XrdCl::Socket::ConnectToAddress(), ConvertMode(), XrdCl::MessageUtils::CreateXAttrVec(), XrdCl::MessageUtils::CreateXAttrVec(), XrdCl::FileSystemPlugIn::DeepLocate(), XrdCl::File::DelXAttr(), XrdCl::FileStateHandler::DelXAttr(), XrdCl::FileSystem::DelXAttr(), XrdCl::FileSystemPlugIn::DelXAttr(), XrdCl::LocalFileHandler::DelXAttr(), Posix::DirList(), XrdCl::FileSystem::DirList(), XrdCl::FileSystemPlugIn::DirList(), DoCache(), DoCat(), DoCD(), DoChMod(), DoLocate(), DoLS(), DoMkDir(), DoMv(), DoPrepare(), DoQuery(), DoRm(), DoRmDir(), DoSpaceInfo(), DoStat(), DoStatVFS(), DoTail(), DoTruncate(), DoXAttr(), XrdCl::LocalFileHandler::ExecRequest(), XrdCl::FSExecutor::Execute(), XrdEc::block_t::fail_missing(), XrdCl::FilePlugIn::Fcntl(), XrdCl::FileStateHandler::Fcntl(), XrdCl::LocalFileHandler::Fcntl(), XrdCl::Channel::ForceDisconnect(), XrdCl::PostMaster::ForceDisconnect(), XrdCl::PostMaster::ForceReconnect(), XrdCl::XCpCtx::GetChunk(), XrdCl::ZipArchive::GetCRC32(), XrdCl::Utils::GetDirectoryEntries(), XrdCl::Socket::GetFlags(), XrdCl::XRootDTransport::GetHeader(), XrdCl::Utils::GetHostAddresses(), XrdCl::Utils::GetLocalCheckSum(), XrdCl::XRootDTransport::GetMore(), XrdCl::ZipArchive::GetOffset(), XrdCl::CheckSumHelper::GetRawCheckSum(), XrdCl::Utils::GetRemoteCheckSum(), XrdCl::AsyncDiscardReader::GetResponse(), XrdCl::AsyncRawReader::GetResponse(), XrdCl::XRootDTransport::GetSignature(), XrdCl::Socket::GetSockOpt(), XrdCl::FileSystemUtils::GetSpaceInfo(), XrdCl::File::GetXAttr(), XrdCl::FileStateHandler::GetXAttr(), XrdCl::FileSystem::GetXAttr(), XrdCl::FileSystemPlugIn::GetXAttr(), XrdCl::LocalFileHandler::GetXAttr(), XrdCl::AsyncSocketHandler::HandleHandShake(), XrdCl::ChunkHandler::HandleResponse(), XrdCl::FutureWrapper< Response >::HandleResponse(), XrdCl::MetalinkReadHandler::HandleResponse(), XrdCl::ZipListHandler::HandleResponse(), XrdCl::MetalinkOpenHandler::HandleResponseWithHosts(), XrdCl::CheckSumHelper::Initialize(), XrdCl::Socket::Initialize(), XrdCl::Stream::Initialize(), XrdCl::XCpCtx::Initialize(), XrdCl::Status::IsError(), XrdCl::XRootDTransport::IsStreamBroken(), XrdCl::ZipArchive::List(), XrdCl::File::ListXAttr(), XrdCl::FileStateHandler::ListXAttr(), XrdCl::FileSystem::ListXAttr(), XrdCl::FileSystemPlugIn::ListXAttr(), XrdCl::LocalFileHandler::ListXAttr(), XrdCl::FileSystemPlugIn::Locate(), main(), Posix::MkDir(), XrdCl::FileSystemPlugIn::MkDir(), XrdCl::LocalFileHandler::MkdirPath(), XrdCl::FileSystemPlugIn::Mv(), XrdCl::AsyncSocketHandler::OnConnectionReturn(), XrdCl::AsyncSocketHandler::OnHeaderCorruption(), XrdCl::AsyncSocketHandler::OnRead(), XrdCl::AsyncSocketHandler::OnReadWhileHandshaking(), XrdCl::AsyncSocketHandler::OnTimeoutWhileHandshaking(), XrdCl::AsyncSocketHandler::OnWrite(), Posix::Open(), XrdCl::EcHandler::Open(), XrdCl::FilePlugIn::Open(), XrdCl::FileStateHandler::Open(), XrdCl::HttpFilePlugIn::Open(), xrdcl_proxy::ProxyPrefixFile::Open(), XrdCl::ZipArchive::OpenArchive(), XrdCl::ZipArchive::OpenFile(), XrdCl::FilePlugIn::PgRead(), XrdCl::ZipArchive::PgRead(), XrdCl::FileStateHandler::PgReadImpl(), XrdCl::FileStateHandler::PgReadRetry(), XrdCl::EcHandler::PgWrite(), XrdCl::FilePlugIn::PgWrite(), XrdCl::FileStateHandler::PgWrite(), XrdCl::FileStateHandler::PgWriteImpl(), XrdCl::FileSystemPlugIn::Ping(), XrdCl::Socket::Poll(), Posix::PReadVec(), XrdCl::CopyProcess::Prepare(), XrdCl::FileSystemPlugIn::Prepare(), XrdCl::XRootDMsgHandler::Process(), XrdCl::Utils::ProcessConfig(), ProcessStatQuery(), XrdCl::FileSystemPlugIn::Protocol(), Posix::PWrite(), XrdCl::FileSystemPlugIn::Query(), XrdCl::Stream::Query(), XrdCl::XRootDTransport::Query(), XrdCl::PostMaster::QueryTransport(), XrdCl::AsyncDiscardReader::Read(), XrdCl::AsyncMsgReader::Read(), XrdCl::AsyncRawReader::Read(), XrdCl::AsyncVectorReader::Read(), XrdCl::EcHandler::Read(), XrdCl::FilePlugIn::Read(), XrdCl::FilePlugIn::Read(), XrdCl::FileStateHandler::Read(), XrdCl::HttpFilePlugIn::Read(), XrdCl::LocalFileHandler::Read(), XrdCl::Socket::Read(), XrdCl::ZipArchive::Read(), XrdEc::block_t::read(), XrdCl::ZipArchive::ReadFromImpl, XrdCl::Socket::ReadRaw(), XrdCl::FileStateHandler::ReadV(), XrdCl::LocalFileHandler::ReadV(), XrdCl::Socket::ReadV(), XrdCl::PostMaster::Redirect(), XrdCl::MessageUtils::RedirectMessage(), XrdCl::PostMaster::RegisterEventHandler(), XrdCl::PostMaster::RemoveEventHandler(), Posix::Rename(), XrdCl::InQueue::ReportTimeout(), XrdCl::FileSystemPlugIn::Rm(), Posix::RmDir(), XrdCl::FileSystemPlugIn::RmDir(), XrdCl::ClassicCopyJob::Run(), XrdCl::CopyProcess::Run(), XrdCl::Operation< HasHndl >::Run(), XrdCl::ThirdPartyCopyJob::Run(), XrdCl::PostMaster::Send(), XrdCl::Socket::Send(), XrdCl::Stream::Send(), XrdCl::AsyncSocketHandler::SendHSMsg(), XrdCl::FileSystemPlugIn::SendInfo(), XrdCl::MessageUtils::SendMessage(), XrdCl::Socket::SetFlags(), XrdCl::Socket::SetSockOpt(), XrdCl::File::SetXAttr(), XrdCl::FileStateHandler::SetXAttr(), XrdCl::FileSystem::SetXAttr(), XrdCl::FileSystemPlugIn::SetXAttr(), XrdCl::LocalFileHandler::SetXAttr(), Posix::Stat(), XrdCl::EcHandler::Stat(), XrdCl::FilePlugIn::Stat(), XrdCl::FileStateHandler::Stat(), XrdCl::FileSystemPlugIn::Stat(), XrdCl::HttpFilePlugIn::Stat(), XrdCl::LocalFileHandler::Stat(), XrdCl::ZipArchive::Stat(), XrdCl::ZipArchive::Stat(), XrdCl::FileSystemPlugIn::StatVFS(), XrdCl::FilePlugIn::Sync(), XrdCl::FileStateHandler::Sync(), XrdCl::LocalFileHandler::Sync(), XrdCl::Stream::Tick(), XrdCl::FileStateHandler::TimeOutRequests(), XrdCl::Socket::TlsHandShake(), XrdCl::FilePlugIn::Truncate(), XrdCl::FileStateHandler::Truncate(), XrdCl::FileSystemPlugIn::Truncate(), XrdCl::LocalFileHandler::Truncate(), XrdCl::FileStateHandler::TryOtherServer(), Posix::Unlink(), XrdCl::XRootDTransport::UnMarchalStatusMore(), XrdCl::XRootDTransport::UnMarshallBody(), XrdCl::XRootDTransport::UnMarshalStatusBody(), XrdCl::ZipArchive::UpdateMetadata(), XrdCl::FilePlugIn::VectorRead(), XrdCl::FileStateHandler::VectorRead(), XrdCl::HttpFilePlugIn::VectorRead(), XrdCl::LocalFileHandler::VectorRead(), XrdEc::Reader::VectorRead(), XrdCl::FilePlugIn::VectorWrite(), XrdCl::FileStateHandler::VectorWrite(), XrdCl::LocalFileHandler::VectorWrite(), XrdCl::FilePlugIn::Visa(), XrdCl::FileStateHandler::Visa(), XrdCl::LocalFileHandler::Visa(), XrdCl::MessageUtils::WaitForResponse(), XrdCl::EcHandler::Write(), XrdCl::FilePlugIn::Write(), XrdCl::FilePlugIn::Write(), XrdCl::FilePlugIn::Write(), XrdCl::FileStateHandler::Write(), XrdCl::FileStateHandler::Write(), XrdCl::FileStateHandler::Write(), XrdCl::HttpFilePlugIn::Write(), XrdCl::LocalFileHandler::Write(), XrdCl::ZipArchive::Write(), XrdCl::XRootDMsgHandler::WriteMessageBody(), XrdCl::Socket::WriteRaw(), XrdCl::FilePlugIn::WriteV(), XrdCl::FileStateHandler::WriteV(), and XrdCl::LocalFileHandler::WriteV().

stFatal

const uint16_t XrdCl::stFatal = 0x0003

Fatal error, it's still an error.

Definition at line 33 of file XrdClStatus.hh.

Referenced by XrdCl::Utils::CheckTPC(), XrdCl::Utils::CheckTPCLite(), XrdCl::AsyncSocketHandler::Connect(), XrdCl::Socket::Cork(), XrdCl::AsyncSocketHandler::DisableUplink(), XrdCl::Stream::EnableLink(), XrdCl::AsyncSocketHandler::EnableUplink(), XrdCl::AsyncVectorReader::GetResponse(), XrdCl::XRootDTransport::HandShake(), XrdCl::Status::IsFatal(), XrdCl::AsyncSocketHandler::OnConnectionReturn(), XrdCl::XRootDMsgHandler::Process(), XrdCl::XRootDTransport::Query(), XrdCl::Stream::Send(), XrdCl::Socket::TlsHandShake(), and XrdCl::Socket::Uncork().

stOK

const uint16_t XrdCl::stOK = 0x0000

Everything went OK.

Definition at line 31 of file XrdClStatus.hh.

Referenced by XrdCl::Status::Status(), XrdCl::Utils::CheckTPCLite(), XrdCl::Socket::ClassifyErrno(), XrdCl::FileStateHandler::Close(), XrdCl::FileSystem::DirList(), XrdCl::XRootDTransport::GetBody(), XrdCl::XCpCtx::GetChunk(), XrdCl::XRootDTransport::GetHeader(), XrdCl::XRootDTransport::GetMore(), XrdCl::Status::IsOK(), XrdCl::AsyncSocketHandler::OnWrite(), XrdCl::Socket::Poll(), XrdCl::XRootDMsgHandler::Process(), XrdCl::Tls::Read(), XrdCl::AsyncRawReaderIntfc::ReadBytesAsync(), XrdCl::MsgHandler::ReadMessageBody(), XrdCl::Socket::ReadRaw(), XrdCl::Tls::Send(), XrdCl::LocalFileHandler::Truncate(), XrdCl::XRootDTransport::UnMarshallRequest(), XrdCl::AsyncMsgWriter::Write(), and XrdCl::Socket::WriteRaw().

suAlreadyDone

const uint16_t XrdCl::suAlreadyDone = 4

Definition at line 42 of file XrdClStatus.hh.

Referenced by XrdCl::File::Close(), XrdCl::FileStateHandler::Close(), XrdCl::XRootDTransport::UnMarshallRequest(), and XrdCl::AsyncMsgWriter::Write().

suContinue

const uint16_t XrdCl::suContinue = 1

Definition at line 39 of file XrdClStatus.hh.

Referenced by XrdCl::XCpCtx::GetChunk(), XrdCl::AssignLastURLHandler::HandleResponseWithHosts(), XrdCl::AssignLBHandler::HandleResponseWithHosts(), XrdCl::XRootDMsgHandler::Process(), XrdCl::Status::ToString(), XrdCl::ResponseHandler::Wrap(), and XrdCl::ResponseHandler::Wrap().

suDone

const uint16_t XrdCl::suDone = 0

Definition at line 38 of file XrdClStatus.hh.

Referenced by XrdCl::XRootDTransport::GetBody(), XrdCl::XCpCtx::GetChunk(), XrdCl::XRootDTransport::GetHeader(), XrdCl::XRootDTransport::GetMore(), XrdCl::AsyncSocketHandler::HandleHandShake(), XrdCl::AsyncSocketHandler::OnReadWhileHandshaking(), XrdCl::AsyncRawReaderIntfc::ReadBytesAsync(), XrdCl::MsgHandler::ReadMessageBody(), and XrdCl::ClassicCopyJob::Run().

suNotStarted

const uint16_t XrdCl::suNotStarted = 5

Definition at line 43 of file XrdClStatus.hh.

suPartial

const uint16_t XrdCl::suPartial = 3

Definition at line 41 of file XrdClStatus.hh.

Referenced by XrdCl::Utils::CheckTPCLite(), XrdCl::FileSystem::DirList(), DoLocate(), DoLS(), DoSpaceInfo(), and XrdCl::FileSystemUtils::GetSpaceInfo().

suRetry

const uint16_t XrdCl::suRetry = 2

Definition at line 40 of file XrdClStatus.hh.

Referenced by XrdCl::Socket::ClassifyErrno(), XrdCl::AsyncSocketHandler::DoTlsHandShake(), XrdCl::XRootDTransport::GetBody(), XrdCl::XCpCtx::GetChunk(), XrdCl::XRootDTransport::GetHeader(), XrdCl::XRootDTransport::GetMore(), XrdCl::AsyncSocketHandler::HandleHandShake(), XrdCl::AsyncSocketHandler::OnConnectionReturn(), XrdCl::AsyncSocketHandler::OnRead(), XrdCl::AsyncSocketHandler::OnTLSHandShake(), XrdCl::AsyncSocketHandler::OnWrite(), XrdCl::AsyncSocketHandler::OnWriteWhileHandshaking(), XrdCl::AsyncHSReader::Read(), XrdCl::AsyncMsgReader::Read(), XrdCl::AsyncPageReader::Read(), XrdCl::AsyncRawReader::Read(), XrdCl::AsyncVectorReader::Read(), XrdCl::Tls::Read(), XrdCl::AsyncRawReaderIntfc::ReadBytesAsync(), XrdCl::Tls::ReadV(), XrdCl::Socket::Send(), XrdCl::Tls::Send(), XrdCl::Status::ToString(), XrdCl::AsyncHSWriter::Write(), XrdCl::AsyncMsgWriter::Write(), and XrdCl::XRootDMsgHandler::WriteMessageBody().

TaskMgrMsg

const uint64_t XrdCl::TaskMgrMsg = 0x0000000000000040ULL

Definition at line 38 of file XrdClConstants.hh.

Referenced by XrdCl::TaskManager::RegisterTask(), XrdCl::TaskManager::RunTasks(), XrdCl::TaskManager::Start(), XrdCl::TaskManager::Stop(), and XrdCl::TaskManager::UnregisterTask().

theDefaultInts

std::unordered_map<std::string, int> XrdCl::theDefaultInts

static

Definition at line 122 of file XrdClConstants.hh.

    {
      { to_lower( "SubStreamsPerChannel" ),    DefaultSubStreamsPerChannel },
      { to_lower( "ConnectionWindow" ),        DefaultConnectionWindow },
      { to_lower( "ConnectionRetry" ),         DefaultConnectionRetry },
      { to_lower( "RequestTimeout" ),          DefaultRequestTimeout },
      { to_lower( "StreamTimeout" ),           DefaultStreamTimeout },
      { to_lower( "TimeoutResolution" ),       DefaultTimeoutResolution },
      { to_lower( "StreamErrorWindow" ),       DefaultStreamErrorWindow },
      { to_lower( "RunForkHandler" ),          DefaultRunForkHandler },
      { to_lower( "RedirectLimit" ),           DefaultRedirectLimit },
      { to_lower( "WorkerThreads" ),           DefaultWorkerThreads },
      { to_lower( "CPChunkSize" ),             DefaultCPChunkSize },
      { to_lower( "CPParallelChunks" ),        DefaultCPParallelChunks },
      { to_lower( "DataServerTTL" ),           DefaultDataServerTTL },
      { to_lower( "LoadBalancerTTL" ),         DefaultLoadBalancerTTL },
      { to_lower( "CPInitTimeout" ),           DefaultCPInitTimeout },
      { to_lower( "CPTPCTimeout" ),            DefaultCPTPCTimeout },
      { to_lower( "CPTimeout" ),               DefaultCPTimeout },
      { to_lower( "TCPKeepAlive" ),            DefaultTCPKeepAlive },
      { to_lower( "TCPKeepAliveTime" ),        DefaultTCPKeepAliveTime },
      { to_lower( "TCPKeepAliveInterval" ),    DefaultTCPKeepAliveInterval },
      { to_lower( "TCPKeepAliveProbes" ),      DefaultTCPKeepAliveProbes },
      { to_lower( "MultiProtocol" ),           DefaultMultiProtocol },
      { to_lower( "ParallelEvtLoop" ),         DefaultParallelEvtLoop },
      { to_lower( "MetalinkProcessing" ),      DefaultMetalinkProcessing },
      { to_lower( "LocalMetalinkFile" ),       DefaultLocalMetalinkFile },
      { to_lower( "XRateThreshold" ),          DefaultXRateThreshold },
      { to_lower( "XCpBlockSize" ),            DefaultXCpBlockSize },
      { to_lower( "NoDelay" ),                 DefaultNoDelay },
      { to_lower( "AioSignal" ),               DefaultAioSignal },
      { to_lower( "PreferIPv4" ),              DefaultPreferIPv4 },
      { to_lower( "MaxMetalinkWait" ),         DefaultMaxMetalinkWait },
      { to_lower( "PreserveLocateTried" ),     DefaultPreserveLocateTried },
      { to_lower( "NotAuthorizedRetryLimit" ), DefaultNotAuthorizedRetryLimit },
      { to_lower( "PreserveXAttrs" ),          DefaultPreserveXAttrs },
      { to_lower( "NoTlsOK" ),                 DefaultNoTlsOK },
      { to_lower( "TlsNoData" ),               DefaultTlsNoData },
      { to_lower( "TlsMetalink" ),             DefaultTlsMetalink },
      { to_lower( "ZipMtlnCksum" ),            DefaultZipMtlnCksum },
      { to_lower( "IPNoShuffle" ),             DefaultIPNoShuffle },
      { to_lower( "WantTlsOnNoPgrw" ),         DefaultWantTlsOnNoPgrw },
      { to_lower( "RetryWrtAtLBLimit" ),       DefaultRetryWrtAtLBLimit }
    };

Referenced by XrdCl::Env::GetDefaultIntValue().

theDefaultStrs

std::unordered_map<std::string, std::string> XrdCl::theDefaultStrs

static

Initial value:

{
      { to_lower( "PollerPreference" ),   DefaultPollerPreference },
      { to_lower( "NetworkStack" ),       DefaultNetworkStack },
      { to_lower( "ClientMonitor" ),      DefaultClientMonitor },
      { to_lower( "ClientMonitorParam" ), DefaultClientMonitorParam },
      { to_lower( "PlugInConfDir" ),      DefaultPlugInConfDir },
      { to_lower( "PlugIn" ),             DefaultPlugIn },
      { to_lower( "ReadRecovery" ),       DefaultReadRecovery },
      { to_lower( "WriteRecovery" ),      DefaultWriteRecovery },
      { to_lower( "OpenRecovery" ),       DefaultOpenRecovery },
      { to_lower( "GlfnRedirector" ),     DefaultGlfnRedirector },
      { to_lower( "TlsDbgLvl" ),          DefaultTlsDbgLvl },
      { to_lower( "ClConfDir" ),          DefaultClConfDir },
      { to_lower( "DefaultClConfFile" ),  DefaultClConfFile },
      { to_lower( "CpTarget" ),           DefaultCpTarget },
      { to_lower( "CpRetryPolicy" ),      DefaultCpRetryPolicy }
    }

Definition at line 167 of file XrdClConstants.hh.

    {
      { to_lower( "PollerPreference" ),   DefaultPollerPreference },
      { to_lower( "NetworkStack" ),       DefaultNetworkStack },
      { to_lower( "ClientMonitor" ),      DefaultClientMonitor },
      { to_lower( "ClientMonitorParam" ), DefaultClientMonitorParam },
      { to_lower( "PlugInConfDir" ),      DefaultPlugInConfDir },
      { to_lower( "PlugIn" ),             DefaultPlugIn },
      { to_lower( "ReadRecovery" ),       DefaultReadRecovery },
      { to_lower( "WriteRecovery" ),      DefaultWriteRecovery },
      { to_lower( "OpenRecovery" ),       DefaultOpenRecovery },
      { to_lower( "GlfnRedirector" ),     DefaultGlfnRedirector },
      { to_lower( "TlsDbgLvl" ),          DefaultTlsDbgLvl },
      { to_lower( "ClConfDir" ),          DefaultClConfDir },
      { to_lower( "DefaultClConfFile" ),  DefaultClConfFile },
      { to_lower( "CpTarget" ),           DefaultCpTarget },
      { to_lower( "CpRetryPolicy" ),      DefaultCpRetryPolicy }
    };

Referenced by XrdCl::Env::GetDefaultStringValue().

TlsMsg

const uint64_t XrdCl::TlsMsg = 0x0000000000002000ULL

Definition at line 45 of file XrdClConstants.hh.

Referenced by XrdCl::Tls::Connect(), and InitTLS().

UtilityMsg

const uint64_t XrdCl::UtilityMsg = 0x0000000000000002ULL

Definition at line 33 of file XrdClConstants.hh.

Referenced by XrdCl::ClassicCopyJob::ClassicCopyJob(), XrdCl::ThirdPartyCopyJob::ThirdPartyCopyJob(), XrdCl::TPFallBackCopyJob::TPFallBackCopyJob(), XrdCl::CopyProcess::AddJob(), XrdCl::CheckSumManager::Calculate(), XrdCl::Utils::CheckTPC(), XrdCl::Utils::CheckTPCLite(), XrdCl::ForkHandler::Child(), child(), XrdCl::URL::FromString(), XrdCl::CheckSumManager::GetCalculator(), XrdCl::CheckSumHelper::GetCheckSum(), XrdCl::Utils::GetHostAddresses(), XrdCl::Env::GetInt(), XrdCl::Utils::GetLocalCheckSum(), XrdCl::DefaultEnv::GetMonitor(), XrdCl::Utils::GetRemoteCheckSum(), XrdCl::Env::GetString(), XrdCl::Env::ImportInt(), XrdCl::Env::ImportString(), XrdCl::CheckSumHelper::Initialize(), XrdCl::XCpCtx::Initialize(), XrdCl::ForkHandler::Parent(), parent(), XrdCl::CopyProcess::Prepare(), XrdCl::ForkHandler::Prepare(), prepare(), XrdCl::Utils::ProcessConfigDir(), XrdCl::Env::PutInt(), XrdCl::Env::PutString(), XrdCl::ClassicCopyJob::Run(), XrdCl::ThirdPartyCopyJob::Run(), and XrdCl::TPFallBackCopyJob::Run().

XRootDMsg

const uint64_t XrdCl::XRootDMsg = 0x0000000000000080ULL

Definition at line 39 of file XrdClConstants.hh.

Referenced by XrdCl::XRootDMsgHandler::Examine(), XrdCl::XRootDMsgHandler::InspectStatusRsp(), XrdCl::XRootDTransport::MessageReceived(), XrdCl::XRootDMsgHandler::OnStatusReady(), XrdCl::XRootDMsgHandler::OnStreamEvent(), XrdCl::XRootDMsgHandler::Process(), XrdCl::AsyncDiscardReader::Read(), XrdCl::AsyncRawReader::Read(), XrdCl::AsyncVectorReader::Read(), XrdCl::MessageUtils::RedirectMessage(), XrdCl::MessageUtils::SendMessage(), XrdEc::Reader::VectorRead(), and XrdCl::XRootDMsgHandler::WriteMessageBody().

XRootDTransportMsg

const uint64_t XrdCl::XRootDTransportMsg = 0x0000000000000020ULL

Definition at line 37 of file XrdClConstants.hh.

Referenced by XrdCl::XRootDTransport::Disconnect(), XrdCl::XRootDTransport::GetHeader(), XrdCl::XRootDTransport::GetMore(), XrdCl::XRootDTransport::HandShake(), XrdCl::XRootDTransport::HandShakeDone(), XrdCl::XRootDTransport::IsStreamBroken(), XrdCl::XRootDTransport::IsStreamTTLElapsed(), XrdCl::XRootDTransport::LogErrorResponse(), XrdCl::XRootDTransport::MessageReceived(), XrdCl::XRootDTransport::MultiplexSubStream(), XrdCl::XRootDTransport::NbConnectedStrm(), and XrdCl::XRootDTransport::SubStreamNumber().

ZipMsg

const uint64_t XrdCl::ZipMsg = 0x0000000000004000ULL

Definition at line 46 of file XrdClConstants.hh.

Referenced by XrdCl::ZipArchive::AppendFile(), XrdCl::ZipArchive::CloseArchive(), XrdCl::ZipArchive::OpenArchive(), XrdCl::ZipArchive::OpenFile(), and XrdCl::ZipArchive::ReadFromImpl.