36 #include <sys/param.h>
37 #include <sys/resource.h>
40 #include "XrdVersion.hh"
104 int XrdPosixXrootd::baseFD = 0;
105 int XrdPosixXrootd::initDone = 0;
123 LfnPath(
const char *who,
const char *pURL,
bool ponly=
true)
126 ~LfnPath() {
if (relURL) free(relURL);}
166 if (!cbP)
return fp->
FDNum();
194 if (initDone) {myMutex.
UnLock();
return;}
205 if (*cfn ==
'+') {hush =
false; cfn++;}
206 else hush = (getenv(
"XRDPOSIX_DEBUG") == 0);
209 psxEnv->
Put(
"psx.Client",
"1");
210 XrdOucPsx psxConfig(&XrdVERSIONINFOVAR(XrdPosix), cfn, 0, psxEnv);
213 {std::cerr <<
"Posix: Unable to instantiate specified "
214 "configuration; program exiting!" <<std::endl;
250 if (!admin.
Stat(&stMode))
return -1;
254 if (amode & R_OK && !(stMode & S_IRUSR)) aOK = 0;
255 if (amode & W_OK && !(stMode & S_IWUSR)) aOK = 0;
256 if (amode & X_OK && !(stMode & S_IXUSR)) aOK = 0;
288 {
if ((ret = fP->
Close(Status))) {
delete fP; fP = 0;}
290 {std::string eTxt = Status.
ToString();
343 {fp->
UnLock();
return -ENOTCONN;}
347 std::string dataServer;
351 if (dataServer.size() >= (uint32_t)Blen)
352 {fp->
UnLock();
return -ENAMETOOLONG;}
356 strcpy(Buff, dataServer.c_str());
360 uPort = dataServerUrl.
GetPort();
395 rc = fp->
Fstat(*buf);
397 if (rc < 0) {errno = -rc; rc = -1;}
416 if ((rc = fp->
XCio->
Sync()) < 0)
return Fault(fp, -rc);
451 if ((rc = fp->
XCio->
Trunc(offset)) < 0)
return Fault(fp, -rc);
461 #define ENOATTR ENOTSUP
465 void *value,
unsigned long long size)
469 int vsize =
static_cast<int>(size);
473 if (size == 0)
return 1024;
481 else {errno =
ENOATTR;
return -1;}
482 }
else {errno = EINVAL;
return -1;}
486 if (!admin.
Stat())
return -1;
490 return admin.
Query(reqCode, value, vsize);
500 long long curroffset;
509 if (whence == SEEK_SET) curroffset = fp->
setOffset(offset);
510 else if (whence == SEEK_CUR) curroffset = fp->
addOffset(offset);
511 else if (whence == SEEK_END)
513 if (curroffset < 0)
return Fault(fp,
static_cast<int>(-curroffset));
514 curroffset = fp->
setOffset(curroffset+offset);
516 else return Fault(fp, EINVAL);
540 if (!admin.
isOK())
return -1;
558 return Open(path, oflags, mode, cbP, 0);
570 bool aOK, isRO =
false;
574 if (oflags & (O_WRONLY | O_RDWR))
592 if (oflags & O_CREAT)
608 if (!aOK) {
delete fp;
return -1;}
615 if (infoP && isRO && OpenCache(*fp, *infoP))
621 if (rc > 0)
return OpenDefer(fp, cbP, XOflags, XOmode, oflags&
isStream);
628 if (!cbP) Status = fp->
clFile.
Open((std::string)path, XOflags, XOmode);
629 else Status = fp->
clFile.
Open((std::string)path, XOflags, XOmode,
637 if (
DEBUGON && rc != -ENOENT && rc != -ELOOP)
646 if (!(fp->AssignFD(oflags &
isStream)))
654 if (cbP) {errno = EINPROGRESS;
return -1;}
655 if (fp->Finalize(&Status))
return fp->FDNum();
686 (
int)
sizeof(
Info.cachePath),
690 {
Info.ffReady =
true;
691 DEBUG(
"File in cache url=" <<
Info.cacheURL);
697 Info.ffReady =
false;
728 if ((dirP = dP->
Open()))
return dirP;
745 long long offs, bytes;
755 if (nbyte > (
size_t)0x7fffffff)
756 return Fault(fp, EOVERFLOW,
"read size too large");
757 else iosz =
static_cast<int>(nbyte);
761 offs =
static_cast<long long>(offset);
762 bytes = fp->
XCio->
Read((
char *)buf, offs, (int)iosz);
763 if (bytes < 0)
return Fault(fp,-bytes,
"*");
768 return (ssize_t)bytes;
786 if (nbyte > (
size_t)0x7fffffff)
797 iosz =
static_cast<int>(nbyte);
798 offs =
static_cast<long long>(offset);
802 fp->
XCio->
Read(*cbp, (
char *)buf, offs, (int)iosz);
821 if (nbyte > (
size_t)0x7fffffff)
822 return Fault(fp,EOVERFLOW,
"write size too large");
823 else iosz =
static_cast<int>(nbyte);
827 offs =
static_cast<long long>(offset);
828 bytes = fp->
XCio->
Write((
char *)buf, offs, (int)iosz);
829 if (bytes < 0)
return Fault(fp,-bytes,
"*");
835 return (ssize_t)iosz;
853 if (nbyte > (
size_t)0x7fffffff)
864 iosz =
static_cast<int>(nbyte);
865 offs =
static_cast<long long>(offset);
869 fp->
XCio->
Write(*cbp, (
char *)buf, offs, (int)iosz);
888 if (nbyte > (
size_t)0x7fffffff)
return Fault(fp,EOVERFLOW);
889 else iosz =
static_cast<int>(nbyte);
894 if (bytes < 0)
return Fault(fp,-bytes);
900 return (ssize_t)bytes;
909 ssize_t bytes, totbytes = 0;
914 for (i = 0; i < iovcnt; i++)
915 {bytes =
Read(fildes,(
void *)
iov[i].iov_base,(
size_t)
iov[i].iov_len);
916 if (bytes > 0) totbytes += bytes;
917 else if (bytes < 0)
return -1;
941 if ((bytes = fp->
XCio->
ReadV(readV, n)) < 0)
return Fault(fp,-bytes);
976 dp32 = (
struct dirent *)dp64;
977 if ((
char*)dp32->d_name != (
char*)dp64->d_name)
978 {dp32->d_ino = dp64->d_ino;
979 #if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(__GNU__) && !(defined(__FreeBSD_kernel__) && defined(__GLIBC__))
980 dp32->d_off = dp64->d_off;
983 dp32->d_type = dp64->d_type;
985 dp32->d_reclen = dp64->d_reclen;
986 strcpy(dp32->d_name, dp64->d_name);
1001 return (dirent64*)0;
1021 struct dirent **result)
1023 dirent64 *dp64 = 0, d64ent;
1026 if ((rc =
Readdir64_r(dirp, &d64ent, &dp64)) || !dp64)
1027 {*result = 0;
return rc;}
1029 entry->d_ino = dp64->d_ino;
1030 #if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(__GNU__) && !(defined(__FreeBSD_kernel__) && defined(__GLIBC__))
1031 entry->d_off = dp64->d_off;
1034 entry->d_type = dp64->d_type;
1036 entry->d_reclen = dp64->d_reclen;
1037 strcpy(entry->d_name, dp64->d_name);
1043 struct dirent64 **result)
1054 if (!(*result = dP->
nextEntry(entry))) {rc = dP->
Status(); *result = 0;}
1055 else {rc = 0; *result = entry;}
1080 {LfnPath oldF(
"rename", oldpath);
1081 LfnPath newF(
"rename", newpath);
1082 if (!oldF.path || !newF.path)
return -1;
1089 return EcRename(oldpath, newpath, admin);
1123 if (!admin.
isOK())
return -1;
1128 {LfnPath rmd(
"rmdir", path);
1129 if (!rmd.path)
return -1;
1156 else if (loc < 0) loc = 0;
1172 if (!admin.
isOK())
return -1;
1181 {LfnPath statX(
"stat", path,
false);
1182 if (!statX.path)
return -1;
1185 if (rc < 0) {errno = -rc;
return -1;}
1191 return EcStat(path, buf, admin);
1193 if (!admin.
Stat(*buf))
return -1;
1208 if ((rc =
Statvfs(path, &myVfs)))
return rc;
1212 memset(buf, 0,
sizeof(
struct statfs));
1213 buf->f_bsize = myVfs.f_bsize;
1214 buf->f_blocks = myVfs.f_blocks;
1215 buf->f_bfree = myVfs.f_bfree;
1216 buf->f_files = myVfs.f_files;
1217 buf->f_ffree = myVfs.f_ffree;
1218 #if defined(__APPLE__) || defined(__FreeBSD__) || (defined(__FreeBSD_kernel__) && defined(__GLIBC__))
1219 buf->f_iosize = myVfs.f_frsize;
1221 buf->f_frsize = myVfs.f_frsize;
1223 #if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) || defined(__GNU__) || (defined(__FreeBSD_kernel__) && defined(__GLIBC__))
1224 buf->f_bavail = myVfs.f_bavail;
1226 #if defined(__linux__) || defined(__GNU__)
1227 buf->f_namelen = myVfs.f_namemax;
1228 #elif defined(__FreeBSD__) || (defined(__FreeBSD_kernel__) && defined(__GLIBC__))
1229 buf->f_namemax = myVfs.f_namemax;
1240 static const int szVFS =
sizeof(buf->f_bfree);
1241 static const long long max32 = 0x7fffffffLL;
1246 long long rwFree, ssFree, rwBlks;
1247 int rwNum, ssNum, rwUtil, ssUtil;
1251 if (!admin.
isOK())
return -1;
1261 rwNum =
static_cast<int>(vfsStat->
GetNodesRW());
1262 rwFree = (
long long)vfsStat->
GetFreeRW();
1271 if (rwUtil == 0) rwBlks = rwFree;
1272 else if (rwUtil >= 100) rwBlks = 0;
1273 else rwBlks = rwFree * (100 / (100 - rwUtil));
1274 if (ssUtil == 0) rwBlks += ssFree;
1275 else if (ssUtil < 100) rwBlks += ssFree * (100 / (100 - ssUtil));
1280 {
if (rwBlks > max32) rwBlks = max32;
1281 if (rwFree > max32) rwFree = max32;
1282 if (ssFree > max32) ssFree = max32;
1287 memset(buf, 0,
sizeof(
struct statvfs));
1288 buf->f_bsize = 1024*1024;
1289 buf->f_frsize = 1024*1024;
1290 buf->f_blocks =
static_cast<fsblkcnt_t
>(rwBlks);
1291 buf->f_bfree =
static_cast<fsblkcnt_t
>(rwFree + ssFree);
1292 buf->f_bavail =
static_cast<fsblkcnt_t
>(rwFree);
1293 buf->f_ffree = rwNum + ssNum;
1294 buf->f_favail = rwNum;
1295 buf->f_namemax = 255;
1296 buf->f_flag = (rwNum == 0 ? ST_RDONLY|ST_NOSUID : ST_NOSUID);
1329 uint64_t tSize =
static_cast<uint64_t
>(Size);
1333 if (!admin.
isOK())
return -1;
1338 {LfnPath trunc(
"truncate", path);
1339 if (!trunc.path)
return -1;
1360 if (!admin.
isOK())
return -1;
1365 {LfnPath remf(
"unlink", path);
1366 if (!remf.path)
return -1;
1373 return EcUnlink(path, admin);
1394 if (nbyte > (
size_t)0x7fffffff)
return Fault(fp,EOVERFLOW);
1395 else iosz =
static_cast<int>(nbyte);
1400 if (bytes < 0)
return Fault(fp,-bytes);
1406 return (ssize_t)iosz;
1415 ssize_t totbytes = 0;
1420 for (i = 0; i < iovcnt; i++)
1421 {
if (!
Write(fildes,(
void *)
iov[i].iov_base,(
size_t)
iov[i].iov_len))
1423 totbytes +=
iov[i].iov_len;
1440 if (!dirp)
return false;
1463 char *value,
int vsize)
1469 if (!admin.
Stat(0, &Mtime))
return -1;
1494 return ecmP->
Get(
emsg, reset);
1524 if (!admin.
Stat())
return -1;
1538 int XrdPosixXrootd::Fault(
XrdPosixFile *fp,
int ecode,
const char *msg)
1548 int XrdPosixXrootd::EcRename(
const char *oldpath,
const char *newpath,
1554 std::string file = url.GetPath();
1565 || queryResp->
ToString() ==
"server\n")
1567 if (queryResp)
delete queryResp;
1569 newUrl.GetPathWithParams()),
1573 if (queryResp)
delete queryResp;
1576 std::unique_ptr<XrdCl::LocationInfo> ptr( info );
1585 if ( ! S_ISREG(buf.st_mode))
1592 for(
size_t i = 0; i < info->
GetSize(); ++i )
1594 std::string url_i =
"root://" + info->
At(i).
GetAddress() +
"/" + file;
1597 newUrl.GetPathWithParams()),
1599 if (x != -ENOENT && rc != 0)
1601 if (admin_i)
delete admin_i;
1610 int XrdPosixXrootd::EcStat(
const char *path,
struct stat *buf,
1614 std::string file = url.GetPath();
1618 std::vector<std::string> xattrkeys;
1619 std::vector<XrdCl::XAttr> xattrvals;
1620 xattrkeys.push_back(
"xrdec.strpver");
1621 xattrkeys.push_back(
"xrdec.filesize");
1629 || queryResp->
ToString() ==
"server\n")
1631 if (queryResp)
delete queryResp;
1632 if (!admin.
Stat(*buf))
1636 st = fs.GetXAttr(file, xattrkeys, xattrvals, 0);
1637 if (! xattrvals[0].value.empty())
1639 std::stringstream sstream0(xattrvals[0].value);
1640 sstream0 >> buf->st_mtime;
1641 std::stringstream sstream1(xattrvals[1].value);
1642 sstream1 >> buf->st_size;
1643 buf->st_blocks = (buf->st_size + 512)/512;
1649 if (queryResp)
delete queryResp;
1652 std::unique_ptr<XrdCl::LocationInfo> ptr( info );
1660 uint64_t verNumMax = 0;
1663 for(
size_t i = 0; i < info->
GetSize(); ++i )
1665 std::string url_i =
"root://" + info->
At(i).
GetAddress() +
"/" + file;
1668 if (admin_i->
Stat(buf_i))
1670 if (! S_ISREG(buf_i.st_mode))
1672 memcpy(buf, &buf_i,
sizeof(
struct stat));
1673 if (admin_i)
delete admin_i;
1678 if (verNumMax == 0) memcpy(buf, &buf_i,
sizeof(
struct stat));
1684 st = fs_i->
GetXAttr(file, xattrkeys, xattrvals, 0);
1685 if (! xattrvals[0].value.empty())
1687 std::stringstream sstream(xattrvals[0].value);
1690 if ( verNum > verNumMax )
1693 memcpy(buf, &buf_i,
sizeof(
struct stat));
1694 buf->st_mtime = verNumMax;
1695 std::stringstream sstream(xattrvals[1].value);
1696 sstream >> buf->st_size;
1697 buf->st_blocks = (buf->st_size + 512)/512;
1700 if (fs_i)
delete fs_i;
1702 if (admin_i)
delete admin_i;
1716 int XrdPosixXrootd::EcUnlink(
const char *path,
XrdPosixAdmin &admin)
1719 std::string file = url.GetPath();
1729 || queryResp->
ToString() ==
"server\n")
1731 if (queryResp)
delete queryResp;
1736 if (queryResp)
delete queryResp;
1739 std::unique_ptr<XrdCl::LocationInfo> ptr( info );
1744 for(
size_t i = 0; i < info->
GetSize(); ++i )
1746 std::string url_i =
"root://" + info->
At(i).
GetAddress() +
"/" + file;
1751 if (x != -ENOENT && rc != 0)
1753 if (admin_i)
delete admin_i;
std::string obfuscateAuth(const std::string &input)
int stat(const char *path, struct stat *buf)
int statvfs(const char *path, struct statvfs *buf)
int statfs(const char *path, struct statfs *buf)
XrdVERSIONINFO(XrdPosix, XrdPosix)
int emsg(int rc, char *msg)
Binary blob representation.
void FromString(const std::string str)
Fill the buffer from a string.
std::string ToString() const
Convert the buffer to a string.
Send file/filesystem queries to an XRootD cluster.
XRootDStatus RmDir(const std::string &path, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus Mv(const std::string &source, const std::string &dest, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus Rm(const std::string &path, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus GetXAttr(const std::string &path, const std::vector< std::string > &attrs, ResponseHandler *handler, uint16_t timeout=0)
XRootDStatus Truncate(const std::string &path, uint64_t size, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus MkDir(const std::string &path, MkDirFlags::Flags flags, Access::Mode mode, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus StatVFS(const std::string &path, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
bool IsOpen() const
Check if the file is open.
XRootDStatus Open(const std::string &url, OpenFlags::Flags flags, Access::Mode mode, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
bool GetProperty(const std::string &name, std::string &value) const
const std::string & GetAddress() const
Get address.
uint32_t GetSize() const
Get number of locations.
Location & At(uint32_t index)
Get the location at index.
Handle an async response.
uint64_t GetFreeRW() const
Get size of the largest contiguous area of free r/w space (in MB)
uint64_t GetNodesStaging() const
Get number of nodes that can provide staging space.
uint8_t GetUtilizationStaging() const
Get percentage of the partition utilization represented by FreeStaging.
uint64_t GetFreeStaging() const
Get size of the largest contiguous area of free staging space (in MB)
uint8_t GetUtilizationRW() const
Get percentage of the partition utilization represented by FreeRW.
uint64_t GetNodesRW() const
Get number of nodes that can provide read/write space.
std::string GetPathWithParams() const
Get the path with params.
bool IsValid() const
Is the url valid.
int GetPort() const
Get the target port.
virtual int Read(char *buff, long long offs, int rlen)=0
virtual int Fstat(struct stat &sbuff)
virtual int Write(char *buff, long long offs, int wlen)=0
virtual long long FSize()=0
virtual bool Detach(XrdOucCacheIOCD &iocd)=0
virtual int Trunc(long long offs)=0
virtual int ReadV(const XrdOucIOVec *readV, int rnum)
virtual int Rename(const char *oldp, const char *newp)
virtual int Stat(const char *url, struct stat &sbuff)
virtual int Truncate(const char *path, off_t size)
virtual int Unlink(const char *path)
virtual int LocalFilePath(const char *url, char *buff=0, int blen=0, LFP_Reason why=ForAccess, bool forall=false)
virtual int Prepare(const char *url, int oflags, mode_t mode)
virtual int Rmdir(const char *dirp)
int Get(std::string &ecm, bool rst=true)
int SetErrno(int ecc, int retval=-1, const char *alt=0)
void Put(const char *varname, const char *value)
bool ClientConfig(const char *pfx, bool hush=false)
bool Stat(mode_t *flags=0, time_t *mtime=0)
int Query(XrdCl::QueryCode::Code reqCode, void *buff, int bsz)
virtual void Complete(ssize_t Result)=0
An abstract class to define a callback for Open() call.
virtual void Complete(int Result)=0
static void initStat(struct stat *buf)
static bool SetConfig(XrdOucPsx &parms)
static int dirNo(DIR *dirP)
dirent64 * nextEntry(dirent64 *dp=0)
void setOffset(long offset)
const char * Path() override
void UpdtSize(size_t newsz)
long long addOffset(long long offs, int updtSz=0)
int Fstat(struct stat &buf) override
bool Close(XrdCl::XRootDStatus &Status)
bool Finalize(XrdCl::XRootDStatus *Status)
long long setOffset(long long offs)
static void * DelayedDestroy(void *)
static int Result(const XrdCl::XRootDStatus &Status, XrdOucECMsg &ecMsg, bool retneg1=false)
static XrdCl::Access::Mode Mode2Access(mode_t mode)
bool AssignFD(bool isStream=false)
static XrdPosixDir * Dir(int fildes, bool glk=false)
static XrdPosixDir * ReleaseDir(int fildes)
static int Init(int numfd)
static XrdPosixFile * ReleaseFile(int fildes)
static bool Valid(int fd)
static XrdPosixFile * File(int fildes, bool glk=false)
void Count(long long &Dest)
static const char * P2L(const char *who, const char *inP, char *&relP, bool ponly=false)
static ssize_t Readv(int fildes, const struct iovec *iov, int iovcnt)
Readv() conforms to POSIX.1-2001 readv()
static ssize_t Pread(int fildes, void *buf, size_t nbyte, off_t offset)
Pread() conforms to POSIX.1-2001 pread()
static int Closedir(DIR *dirp)
Closedir() conforms to POSIX.1-2001 closedir()
static void Seekdir(DIR *dirp, long loc)
Seekdir() conforms to POSIX.1-2001 seekdir()
static const int isStream
static int Stat(const char *path, struct stat *buf)
Stat() conforms to POSIX.1-2001 stat()
static int QueryChksum(const char *path, time_t &mtime, char *buff, int blen)
static int Mkdir(const char *path, mode_t mode)
Mkdir() conforms to POSIX.1-2001 mkdir()
static int Unlink(const char *path)
Unlink() conforms to POSIX.1-2001 unlink()
static int Rmdir(const char *path)
Rmdir() conforms to POSIX.1-2001 rmdir()
static void Rewinddir(DIR *dirp)
Rewinddir() conforms to POSIX.1-2001 rewinddir()
static void VRead(int fildes, const XrdOucIOVec *readV, int n, XrdPosixCallBackIO *cbp)
static int Rename(const char *oldpath, const char *newpath)
Rename() conforms to POSIX.1-2001 rename()
static int Close(int fildes)
Close() conforms to POSIX.1-2001 close()
static int Statvfs(const char *path, struct statvfs *buf)
Statvfs() conforms to POSIX.1-2001 statvfs()
static int endPoint(int FD, char *Buff, int Blen)
static ssize_t Write(int fildes, const void *buf, size_t nbyte)
Write() conforms to POSIX.1-2001 write()
static struct dirent * Readdir(DIR *dirp)
static int Readdir_r(DIR *dirp, struct dirent *entry, struct dirent **result)
static ssize_t Writev(int fildes, const struct iovec *iov, int iovcnt)
Writev() conforms to POSIX.1-2001 writev()
static int QueryError(std::string &emsg, int fd=-1, bool reset=true)
static struct dirent64 * Readdir64(DIR *dirp)
XrdPosixXrootd(int maxfd=255, int maxdir=0, int maxthr=0)
static int Ftruncate(int fildes, off_t offset)
Ftruncate() conforms to POSIX.1-2001 ftruncate()
static long Telldir(DIR *dirp)
Telldir() conforms to POSIX.1-2001 telldir()
static bool isXrootdDir(DIR *dirp)
static int Access(const char *path, int amode)
Access() conforms to POSIX.1-2001 access()
static DIR * Opendir(const char *path)
Opendir() conforms to POSIX.1-2001 opendir()
static int Fsync(int fildes)
Fsync() conforms to POSIX.1-2001 fsync()
static long long Getxattr(const char *path, const char *name, void *value, unsigned long long size)
static long long QueryOpaque(const char *path, char *buff, int blen)
static int Statfs(const char *path, struct statfs *buf)
static int Readdir64_r(DIR *dirp, struct dirent64 *entry, struct dirent64 **result)
static ssize_t Read(int fildes, void *buf, size_t nbyte)
Read() conforms to POSIX.1-2001 read()
static int Fstat(int fildes, struct stat *buf)
Fstat() conforms to POSIX.1-2001 fstat()
static off_t Lseek(int fildes, off_t offset, int whence)
Lseek() conforms to POSIX.1-2001 lseek()
static int Open(const char *path, int oflag, mode_t mode=0, XrdPosixCallBack *cbP=0)
static ssize_t Pwrite(int fildes, const void *buf, size_t nbyte, off_t offset)
Pwrite() conforms to POSIX.1-2001 pwrite()
static int Truncate(const char *path, off_t offset)
Telldir() conforms to POSIX.1-2001 telldir()
thread_local XrdOucECMsg ecMsg
XrdCl::DirListFlags::Flags dlFlag
@ MakePath
create the entire directory tree if it doesn't exist
Flags
Open flags, may be or'd when appropriate.
@ Read
Open only for reading.
@ Update
Open for reading and writing.
Code
XRootD query request codes.
@ OpaqueFile
Implementation dependent.
@ XAttr
Query file extended attributes.
@ Config
Query server configuration.
@ Checksum
Query file checksum.
@ Space
Query logical space stats.
bool IsOK() const
We're fine.
std::string ToString() const
Create a string representation.