public inbox for git-commits@fedoraproject.org
help / color / mirror / Atom feed
* [rpms/xrootd] epel8: Update to version 6.2.0
@ 2026-11-22 9:06 Mattias Ellert
0 siblings, 0 replies; only message in thread
From: Mattias Ellert @ 2026-11-22 9:06 UTC (permalink / raw)
To: git-commits
A new commit has been pushed.
Repo : rpms/xrootd
Branch : epel8
Commit : f65dff7704b2315594b819b96e07d6ba7e9ac55e
Author : Mattias Ellert <mattias.ellert@physics.uu.se>
Date : 2026-10-06T19:53:19+02:00
Stats : +1184/-4 in 6 file(s)
URL : https://src.fedoraproject.org/rpms/xrootd/c/f65dff7704b2315594b819b96e07d6ba7e9ac55e?branch=epel8
Log:
Update to version 6.2.0
---
diff --git a/0001-Python-Fix-parsing-of-enum-arguments-in-python-bindi.patch b/0001-Python-Fix-parsing-of-enum-arguments-in-python-bindi.patch
new file mode 100644
index 0000000..8ce4475
--- /dev/null
+++ b/0001-Python-Fix-parsing-of-enum-arguments-in-python-bindi.patch
@@ -0,0 +1,279 @@
+From 7391572e94de33a8fd337665c5476e353dfb6bd9 Mon Sep 17 00:00:00 2001
+From: Mattias Ellert <mattias.ellert@physics.uu.se>
+Date: Sat, 3 Oct 2026 23:51:59 +0200
+Subject: [PATCH 1/3] [Python] Fix parsing of enum arguments in python bindings
+
+The underlying type of an enum is not mandated by the C++ standard, so
+which format character to use when parsing an enum argument in the
+python bindings is not obvious. The code used 'H' (unsigned short int)
+for most of them. This does not match what is actually used by gcc -
+which is a 32 bit integer. For a little endian architecture it does
+not matter to much as long as the value fits in the 16 bit range since
+ignoring the last bytes in a little endian representation doesn't
+matter if the value is small enough (which is true for most enum
+values). However, for big endian architecture getting the size of the
+underlyimh type wrong results in parsing completely wrong values.
+
+This commit parses all enum arguments as 'I' (unsigned int) using a
+temporary unsigned int variable which is then cast to the enum type.
+
+This fixes python binding test failures on big endian architecture,
+such as s390x.
+---
+ python/src/PyXRootDFile.cc | 38 +++++++++-----
+ python/src/PyXRootDFileSystem.cc | 90 ++++++++++++++++++++++----------
+ 2 files changed, 86 insertions(+), 42 deletions(-)
+
+diff --git a/python/src/PyXRootDFile.cc b/python/src/PyXRootDFile.cc
+index 633b5b169..a2e25b894 100644
+--- a/python/src/PyXRootDFile.cc
++++ b/python/src/PyXRootDFile.cc
+@@ -237,17 +237,24 @@ namespace PyXRootD
+ {
+ static const char *kwlist[] = { "url", "flags", "mode",
+ "timeout", "callback", NULL };
+- const char *url;
+- XrdCl::OpenFlags::Flags flags = XrdCl::OpenFlags::None;
+- XrdCl::Access::Mode mode = XrdCl::Access::None;
++ const char *url;
++ unsigned int flags_val =
++ static_cast<unsigned int>(XrdCl::OpenFlags::None);
++ unsigned int mode_val =
++ static_cast<unsigned int>(XrdCl::Access::None);
+ time_t timeout = 0;
+ PyObject *callback = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s|HHHO:open",
+- (char**) kwlist, &url, &flags, &mode, &timeout, &callback ) )
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s|IIHO:open",
++ (char**) kwlist, &url, &flags_val, &mode_val, &timeout, &callback ) )
+ return NULL;
+
++ XrdCl::OpenFlags::Flags flags =
++ static_cast<XrdCl::OpenFlags::Flags>(flags_val);
++ XrdCl::Access::Mode mode =
++ static_cast<XrdCl::Access::Mode>(mode_val);
++
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::AnyObject>( callback );
+ if ( !handler ) return NULL;
+@@ -1208,21 +1215,26 @@ namespace PyXRootD
+ {
+ static const char *kwlist[] = { "src_file", "url", "flags", "mode",
+ "timeout", "callback", NULL };
+- const char *url;
+- XrdCl::OpenFlags::Flags flags = XrdCl::OpenFlags::None;
+- XrdCl::Access::Mode mode = XrdCl::Access::None;
++ const char *url;
++ unsigned int flags_val =
++ static_cast<unsigned int>(XrdCl::OpenFlags::None);
++ unsigned int mode_val =
++ static_cast<unsigned int>(XrdCl::Access::None);
+ time_t timeout = 0;
+ PyObject *callback = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+ PyObject *tfile = NULL;
+
+- // note flags must be parsed as 32 bit (unsigned int), since the DUP is the
+- // first to use bits beyond the length of short. Open() was not expecting
+- // flags beyond short.
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "O!s|IHHO:open",
+- (char**) kwlist, &FileType, &tfile, &url, &flags, &mode, &timeout, &callback ) )
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "O!s|IIHO:open",
++ (char**) kwlist, &FileType, &tfile, &url, &flags_val, &mode_val,
++ &timeout, &callback ) )
+ return NULL;
+
++ XrdCl::OpenFlags::Flags flags =
++ static_cast<XrdCl::OpenFlags::Flags>(flags_val);
++ XrdCl::Access::Mode mode =
++ static_cast<XrdCl::Access::Mode>(mode_val);
++
+ if ( !tfile || tfile == Py_None ) {
+ PyErr_SetString( PyExc_TypeError, "openusingtemplate() expects an existing file as argument" );
+ return NULL;
+diff --git a/python/src/PyXRootDFileSystem.cc b/python/src/PyXRootDFileSystem.cc
+index d3240c05d..b66f3cb7e 100644
+--- a/python/src/PyXRootDFileSystem.cc
++++ b/python/src/PyXRootDFileSystem.cc
+@@ -82,14 +82,19 @@ namespace PyXRootD
+ {
+ static const char *kwlist[] = { "path", "flags", "timeout", "callback",
+ NULL };
+- const char *path;
+- XrdCl::OpenFlags::Flags flags = XrdCl::OpenFlags::None;
++ const char *path;
++ unsigned int flags_val =
++ static_cast<unsigned int>(XrdCl::OpenFlags::None);
+ time_t timeout = 0;
+ PyObject *callback = NULL, *pyresponse = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "sH|HO:locate",
+- (char**) kwlist, &path, &flags, &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "sI|HO:locate",
++ (char**) kwlist, &path, &flags_val, &timeout, &callback ) )
++ return NULL;
++
++ XrdCl::OpenFlags::Flags flags =
++ static_cast<XrdCl::OpenFlags::Flags>(flags_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::LocationInfo>( callback );
+@@ -120,14 +125,19 @@ namespace PyXRootD
+ {
+ static const char *kwlist[] = { "path", "flags", "timeout", "callback",
+ NULL };
+- const char *path;
+- XrdCl::OpenFlags::Flags flags = XrdCl::OpenFlags::PrefName;
++ const char *path;
++ unsigned int flags_val =
++ static_cast<unsigned int>(XrdCl::OpenFlags::PrefName);
+ time_t timeout = 0;
+ PyObject *callback = NULL, *pyresponse = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "sH|HO:deeplocate",
+- (char**) kwlist, &path, &flags, &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "sI|HO:deeplocate",
++ (char**) kwlist, &path, &flags_val, &timeout, &callback ) )
++ return NULL;
++
++ XrdCl::OpenFlags::Flags flags =
++ static_cast<XrdCl::OpenFlags::Flags>(flags_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::LocationInfo>( callback );
+@@ -192,15 +202,19 @@ namespace PyXRootD
+ {
+ static const char *kwlist[] = { "querycode", "arg", "timeout",
+ "callback", NULL };
+- const char *arg;
++ unsigned int queryCode_val;
++ const char *arg;
+ time_t timeout = 0;
+ PyObject *callback = NULL, *pyresponse = NULL, *pystatus = NULL;
+- XrdCl::QueryCode::Code queryCode;
+ XrdCl::XRootDStatus status;
+ XrdCl::Buffer argbuffer;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "is|HO:query",
+- (char**) kwlist, &queryCode, &arg, &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "Is|HO:query",
++ (char**) kwlist, &queryCode_val, &arg, &timeout, &callback ) )
++ return NULL;
++
++ XrdCl::QueryCode::Code queryCode =
++ static_cast<XrdCl::QueryCode::Code>(queryCode_val);
+
+ argbuffer.FromString(arg);
+
+@@ -298,15 +312,23 @@ namespace PyXRootD
+ {
+ static const char *kwlist[] = { "path", "flags", "mode", "timeout",
+ "callback", NULL };
+- const char *path;
+- XrdCl::MkDirFlags::Flags flags = XrdCl::MkDirFlags::None;
+- XrdCl::Access::Mode mode = XrdCl::Access::None;
++ const char *path;
++ unsigned int flags_val =
++ static_cast<unsigned int>(XrdCl::MkDirFlags::None);
++ unsigned int mode_val =
++ static_cast<unsigned int>(XrdCl::Access::None);
+ time_t timeout = 0;
+ PyObject *callback = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s|HHHO:mkdir", (char**) kwlist,
+- &path, &flags, &mode, &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s|IIHO:mkdir",
++ (char**) kwlist, &path, &flags_val, &mode_val, &timeout, &callback ) )
++ return NULL;
++
++ XrdCl::MkDirFlags::Flags flags =
++ static_cast<XrdCl::MkDirFlags::Flags>(flags_val);
++ XrdCl::Access::Mode mode =
++ static_cast<XrdCl::Access::Mode>(mode_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::AnyObject>( callback );
+@@ -365,13 +387,18 @@ namespace PyXRootD
+ {
+ static const char *kwlist[] = { "path", "mode", "timeout", "callback", NULL };
+ const char *path;
+- XrdCl::Access::Mode mode = XrdCl::Access::None;
++ unsigned int mode_val =
++ static_cast<unsigned int>(XrdCl::Access::None);
+ time_t timeout = 0;
+ PyObject *callback = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "sH|HO:chmod", (char**) kwlist,
+- &path, &mode, &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "sI|HO:chmod",
++ (char**) kwlist, &path, &mode_val, &timeout, &callback ) )
++ return NULL;
++
++ XrdCl::Access::Mode mode =
++ static_cast<XrdCl::Access::Mode>(mode_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::AnyObject>( callback );
+@@ -536,14 +563,19 @@ namespace PyXRootD
+ {
+ static const char *kwlist[] = { "path", "flags", "timeout",
+ "callback", NULL };
+- const char *path;
+- XrdCl::DirListFlags::Flags flags = XrdCl::DirListFlags::None;
++ const char *path;
++ unsigned int flags_val =
++ static_cast<unsigned int>(XrdCl::DirListFlags::None);
+ time_t timeout = 0;
+ PyObject *callback = NULL, *pyresponse = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s|bHO:dirlist",
+- (char**) kwlist, &path, &flags, &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s|IHO:dirlist",
++ (char**) kwlist, &path, &flags_val, &timeout, &callback ) )
++ return NULL;
++
++ XrdCl::DirListFlags::Flags flags =
++ static_cast<XrdCl::DirListFlags::Flags>(flags_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::DirectoryList>( callback );
+@@ -610,15 +642,15 @@ namespace PyXRootD
+ {
+ static const char *kwlist[] = { "files", "flags", "priority",
+ "timeout", "callback", NULL };
+- uint16_t flagval = 0;
++ unsigned int flags_val = 0;
+ uint8_t priority = 0;
+ time_t timeout = 0;
+ PyObject *pyfiles = NULL, *callback = NULL;
+ PyObject *pyresponse = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "OH|bHO:prepare",
+- (char**) kwlist, &pyfiles, &flagval, &priority, &timeout, &callback ) )
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "OI|bHO:prepare",
++ (char**) kwlist, &pyfiles, &flags_val, &priority, &timeout, &callback ) )
+ return NULL;
+
+ if ( !PyList_Check( pyfiles ) ) {
+@@ -639,8 +671,8 @@ namespace PyXRootD
+ files.emplace_back(PyUnicode_AsUTF8(item));
+ }
+
+- XrdCl::PrepareFlags::Flags flags;
+- flags = static_cast<XrdCl::PrepareFlags::Flags>(flagval);
++ XrdCl::PrepareFlags::Flags flags =
++ static_cast<XrdCl::PrepareFlags::Flags>(flags_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::Buffer>( callback );
+--
+2.55.0
+
diff --git a/0001-Tests-Do-not-hardcode-the-name-of-the-build-director.patch b/0001-Tests-Do-not-hardcode-the-name-of-the-build-director.patch
new file mode 100644
index 0000000..14c1011
--- /dev/null
+++ b/0001-Tests-Do-not-hardcode-the-name-of-the-build-director.patch
@@ -0,0 +1,59 @@
+From 74f3a7aca898aef17777a1b428fcc8884918dc9f Mon Sep 17 00:00:00 2001
+From: Mattias Ellert <mattias.ellert@physics.uu.se>
+Date: Wed, 30 Sep 2026 22:22:32 +0200
+Subject: [PATCH] [Tests] Do not hardcode the name of the build directory
+
+---
+ tests/end-to-end/tpc/http/protocol.cfg | 3 ++-
+ tests/end-to-end/tpc/root/root.cfg | 11 ++++++-----
+ 2 files changed, 8 insertions(+), 6 deletions(-)
+
+diff --git a/tests/end-to-end/tpc/http/protocol.cfg b/tests/end-to-end/tpc/http/protocol.cfg
+index b6f69abb7..76ccc4748 100644
+--- a/tests/end-to-end/tpc/http/protocol.cfg
++++ b/tests/end-to-end/tpc/http/protocol.cfg
+@@ -4,6 +4,7 @@ set src = $BATS_TEST_DIRNAME
+ set file = $BATS_FILE_TMPDIR
+ set run = $BATS_TEST_TMPDIR
+ set suite = $BATS_SUITE_TMPDIR
++set build = $BINARY_DIR
+
+ all.export /
+ all.adminpath $run/$name
+@@ -22,7 +23,7 @@ xrd.tlsca certfile $suite/ca.pem
+
+ http.header2cgi Authorization authz strip-on-redirect
+
+-ofs.tpc pgm $src/../../../../build/bin/xrdcp --server
++ofs.tpc pgm $build/bin/xrdcp --server
+
+ all.sitename $name
+
+diff --git a/tests/end-to-end/tpc/root/root.cfg b/tests/end-to-end/tpc/root/root.cfg
+index 904908d01..628b104a2 100644
+--- a/tests/end-to-end/tpc/root/root.cfg
++++ b/tests/end-to-end/tpc/root/root.cfg
+@@ -1,14 +1,15 @@
+-set run = $BATS_TEST_TMPDIR
+-set name = $NAME
+-set port = $PORT
+-set src = $BATS_TEST_DIRNAME
++set run = $BATS_TEST_TMPDIR
++set name = $NAME
++set port = $PORT
++set src = $BATS_TEST_DIRNAME
++set build = $BINARY_DIR
+
+ all.export /
+ all.adminpath $run/$name
+ all.pidpath $run/$name
+ oss.localroot $run/$name
+
+-ofs.tpc pgm $src/../../../../build/bin/xrdcp --server
++ofs.tpc pgm $build/bin/xrdcp --server
+
+ all.sitename $name
+
+--
+2.55.0
+
diff --git a/0002-Python-Fix-parsing-of-timeout-arguments-in-python-bi.patch b/0002-Python-Fix-parsing-of-timeout-arguments-in-python-bi.patch
new file mode 100644
index 0000000..e275cf3
--- /dev/null
+++ b/0002-Python-Fix-parsing-of-timeout-arguments-in-python-bi.patch
@@ -0,0 +1,740 @@
+From f639b79fd3be4ee438bf6d27dad86c7a5e6832d8 Mon Sep 17 00:00:00 2001
+From: Mattias Ellert <mattias.ellert@physics.uu.se>
+Date: Sun, 4 Oct 2026 06:52:38 +0200
+Subject: [PATCH 2/3] [Python] Fix parsing of timeout arguments in python
+ bindings
+
+In XrootD 6 the type for the timeout arguments was changed from
+uint16_t to time_t. In the python bindings the change was not carried
+out completely. The type of the variables were changed, but the format
+character used in the python argunemt parsing was not changed and was
+still 'H' (unsigned short int), resulting in an inconsistency and a
+potential source of errors - especially on big endian architectures.
+
+Since the type corresponding to time_t can vary with architecture and
+by setting preprocessor macros (it can be either int, long int or long
+long int), this commit introduces a temporary long long variable for
+doing the parsing which is cast to a time_t afterwards.
+---
+ python/src/PyXRootDCopyProcess.cc | 16 +--
+ python/src/PyXRootDFile.cc | 102 +++++++++++-------
+ python/src/PyXRootDFileSystem.cc | 167 +++++++++++++++++++-----------
+ 3 files changed, 177 insertions(+), 108 deletions(-)
+
+diff --git a/python/src/PyXRootDCopyProcess.cc b/python/src/PyXRootDCopyProcess.cc
+index 69d0ecd00..3a06718f5 100644
+--- a/python/src/PyXRootDCopyProcess.cc
++++ b/python/src/PyXRootDCopyProcess.cc
+@@ -101,25 +101,29 @@ namespace PyXRootD
+
+ val = XrdCl::DefaultCPInitTimeout;
+ env->GetInt( "CPInitTimeout", val );
+- time_t initTimeout = val;
++ long long initTimeout_val = val;
+
+ val = XrdCl::DefaultCPTPCTimeout;
+ env->GetInt( "CPTPCTimeout", val );
+- time_t tpcTimeout = val;
++ long long tpcTimeout_val = val;
+
+ val = XrdCl::DefaultCPTimeout;
+ env->GetInt( "CPTimeout", val );
+- time_t cpTimeout = val;
++ long long cpTimeout_val = val;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "ss|HbbbbssssbIHHHbHLLLbs:add_job",
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "ss|HbbbbssssbIHLLbLLLLbs:add_job",
+ (char**) kwlist,
+ &source, &target, &sourceLimit, &force, &posc,
+ &coerce, &mkdir, &thirdParty, &checkSumMode, &checkSumType,
+- &checkSumPreset, &dynamicSource, &chunkSize, ¶llelChunks, &initTimeout,
+- &tpcTimeout, &rmBadCksum, &cpTimeout, &xRateThreshold, &xRate,
++ &checkSumPreset, &dynamicSource, &chunkSize, ¶llelChunks, &initTimeout_val,
++ &tpcTimeout_val, &rmBadCksum, &cpTimeout_val, &xRateThreshold, &xRate,
+ &retry, &cont, &rtrplc ) )
+ return NULL;
+
++ time_t initTimeout = static_cast<time_t>(initTimeout_val);
++ time_t tpcTimeout = static_cast<time_t>(tpcTimeout_val);
++ time_t cpTimeout = static_cast<time_t>(cpTimeout_val);
++
+ XrdCl::PropertyList properties;
+ self->results->push_back(XrdCl::PropertyList());
+
+diff --git a/python/src/PyXRootDFile.cc b/python/src/PyXRootDFile.cc
+index a2e25b894..70f2f9121 100644
+--- a/python/src/PyXRootDFile.cc
++++ b/python/src/PyXRootDFile.cc
+@@ -242,18 +242,20 @@ namespace PyXRootD
+ static_cast<unsigned int>(XrdCl::OpenFlags::None);
+ unsigned int mode_val =
+ static_cast<unsigned int>(XrdCl::Access::None);
+- time_t timeout = 0;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s|IIHO:open",
+- (char**) kwlist, &url, &flags_val, &mode_val, &timeout, &callback ) )
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s|IILO:open",
++ (char**) kwlist, &url, &flags_val, &mode_val, &timeout_val,
++ &callback ) )
+ return NULL;
+
+ XrdCl::OpenFlags::Flags flags =
+ static_cast<XrdCl::OpenFlags::Flags>(flags_val);
+ XrdCl::Access::Mode mode =
+ static_cast<XrdCl::Access::Mode>(mode_val);
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::AnyObject>( callback );
+@@ -279,12 +281,14 @@ namespace PyXRootD
+ PyObject* File::Close( File *self, PyObject *args, PyObject *kwds )
+ {
+ static const char *kwlist[] = { "timeout", "callback", NULL };
+- time_t timeout = 0;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "|HO:close", (char**) kwlist,
+- &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "|LO:close",
++ (char**) kwlist, &timeout_val, &callback ) ) return NULL;
++
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::AnyObject>( callback );
+@@ -310,15 +314,17 @@ namespace PyXRootD
+ PyObject* File::Stat( File *self, PyObject *args, PyObject *kwds )
+ {
+ static const char *kwlist[] = { "force", "timeout", "callback", NULL };
+- int force = 0;
+- time_t timeout = 0;
++ int force = 0;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pyresponse = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+ if ( !self->file->IsOpen() ) return FileClosedError();
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "|iHO:stat", (char**) kwlist,
+- &force, &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "|iLO:stat",
++ (char**) kwlist, &force, &timeout_val, &callback ) ) return NULL;
++
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::StatInfo>( callback );
+@@ -686,14 +692,16 @@ namespace PyXRootD
+ PyObject* File::Sync( File *self, PyObject *args, PyObject *kwds )
+ {
+ static const char *kwlist[] = { "timeout", "callback", NULL };
+- time_t timeout = 0;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+ if ( !self->file->IsOpen() ) return FileClosedError();
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "|HO:sync", (char**) kwlist,
+- &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "|LO:sync",
++ (char**) kwlist, &timeout_val, &callback ) ) return NULL;
++
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::AnyObject>( callback );
+@@ -856,18 +864,20 @@ namespace PyXRootD
+ PyObject* File::Fcntl( File *self, PyObject *args, PyObject *kwds )
+ {
+ static const char *kwlist[] = { "arg", "timeout", "callback", NULL };
+- const char *buffer = 0;
++ const char *buffer = 0;
+ Py_ssize_t buffSize = 0;
+- time_t timeout = 0;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pystatus = NULL, *pyresponse = NULL;
+ XrdCl::XRootDStatus status;
+
+ if ( !self->file->IsOpen() ) return FileClosedError();
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s#|HO:fcntl",
+- (char**) kwlist, &buffer, &buffSize, &timeout, &callback ) )
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s#|LO:fcntl",
++ (char**) kwlist, &buffer, &buffSize, &timeout_val, &callback ) )
+ return NULL;
+
++ time_t timeout = static_cast<time_t>(timeout_val);
++
+ XrdCl::Buffer arg; arg.Append( buffer, buffSize );
+
+ if ( callback && callback != Py_None )
+@@ -900,16 +910,18 @@ namespace PyXRootD
+ PyObject* File::Visa( File *self, PyObject *args, PyObject *kwds )
+ {
+ static const char *kwlist[] = { "timeout", "callback", NULL };
+- time_t timeout = 0;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pystatus = NULL, *pyresponse = NULL;
+ XrdCl::XRootDStatus status;
+
+ if ( !self->file->IsOpen() ) return FileClosedError();
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "|HO:visa",
+- (char**) kwlist, &timeout, &callback ) )
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "|LO:visa",
++ (char**) kwlist, &timeout_val, &callback ) )
+ return NULL;
+
++ time_t timeout = static_cast<time_t>(timeout_val);
++
+ if ( callback && callback != Py_None )
+ {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::Buffer>( callback );
+@@ -986,7 +998,7 @@ namespace PyXRootD
+ static const char *kwlist[] = { "attrs", "timeout", "callback", NULL };
+
+ std::vector<XrdCl::xattr_t> attrs;
+- time_t timeout = 0;
++ long long timeout_val = 0;
+
+ PyObject *callback = NULL, *pystatus = NULL;
+ PyObject *pyattrs = NULL, *pyresponse = NULL;
+@@ -994,8 +1006,10 @@ namespace PyXRootD
+
+ if ( !self->file->IsOpen() ) return FileClosedError();
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "O|HO:set_xattr",
+- (char**) kwlist, &pyattrs, &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "O|LO:set_xattr",
++ (char**) kwlist, &pyattrs, &timeout_val, &callback ) ) return NULL;
++
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ // it should be a list
+ if( !PyList_Check( pyattrs ) )
+@@ -1057,7 +1071,7 @@ namespace PyXRootD
+ static const char *kwlist[] = { "attrs", "timeout", "callback", NULL };
+
+ std::vector<std::string> attrs;
+- time_t timeout = 0;
++ long long timeout_val = 0;
+
+ PyObject *callback = NULL, *pystatus = NULL;
+ PyObject *pyattrs = NULL, *pyresponse = NULL;
+@@ -1065,8 +1079,10 @@ namespace PyXRootD
+
+ if ( !self->file->IsOpen() ) return FileClosedError();
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "O|HO:set_xattr",
+- (char**) kwlist, &pyattrs, &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "O|LO:set_xattr",
++ (char**) kwlist, &pyattrs, &timeout_val, &callback ) ) return NULL;
++
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ // it should be a list
+ if( !PyList_Check( pyattrs ) )
+@@ -1116,7 +1132,7 @@ namespace PyXRootD
+ static const char *kwlist[] = { "attrs", "timeout", "callback", NULL };
+
+ std::vector<std::string> attrs;
+- time_t timeout = 0;
++ long long timeout_val = 0;
+
+ PyObject *callback = NULL, *pystatus = NULL;
+ PyObject *pyattrs = NULL, *pyresponse = NULL;
+@@ -1124,8 +1140,10 @@ namespace PyXRootD
+
+ if ( !self->file->IsOpen() ) return FileClosedError();
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "O|HO:set_xattr",
+- (char**) kwlist, &pyattrs, &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "O|LO:set_xattr",
++ (char**) kwlist, &pyattrs, &timeout_val, &callback ) ) return NULL;
++
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ // it should be a list
+ if( !PyList_Check( pyattrs ) )
+@@ -1174,7 +1192,7 @@ namespace PyXRootD
+ {
+ static const char *kwlist[] = { "timeout", "callback", NULL };
+
+- time_t timeout = 0;
++ long long timeout_val = 0;
+
+ PyObject *callback = NULL, *pystatus = NULL;
+ PyObject *pyresponse = NULL;
+@@ -1182,8 +1200,10 @@ namespace PyXRootD
+
+ if ( !self->file->IsOpen() ) return FileClosedError();
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "|HO:set_xattr",
+- (char**) kwlist, &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "|LO:set_xattr",
++ (char**) kwlist, &timeout_val, &callback ) ) return NULL;
++
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<std::vector<XrdCl::XAttr>>( callback );
+@@ -1220,20 +1240,21 @@ namespace PyXRootD
+ static_cast<unsigned int>(XrdCl::OpenFlags::None);
+ unsigned int mode_val =
+ static_cast<unsigned int>(XrdCl::Access::None);
+- time_t timeout = 0;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+ PyObject *tfile = NULL;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "O!s|IIHO:open",
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "O!s|IILO:open",
+ (char**) kwlist, &FileType, &tfile, &url, &flags_val, &mode_val,
+- &timeout, &callback ) )
++ &timeout_val, &callback ) )
+ return NULL;
+
+ XrdCl::OpenFlags::Flags flags =
+ static_cast<XrdCl::OpenFlags::Flags>(flags_val);
+ XrdCl::Access::Mode mode =
+ static_cast<XrdCl::Access::Mode>(mode_val);
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ if ( !tfile || tfile == Py_None ) {
+ PyErr_SetString( PyExc_TypeError, "openusingtemplate() expects an existing file as argument" );
+@@ -1267,14 +1288,17 @@ namespace PyXRootD
+ {
+ static const char *kwlist[] = { "locs", "timeout", "callback", NULL };
+
+- PyObject *locs_list = NULL;
+- time_t timeout = 0;
++ PyObject *locs_list = NULL;
++ long long timeout_val = 0;
+ PyObject *callback = NULL;
+
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "O!|HO:clone",
+- (char**) kwlist, &PyList_Type, &locs_list, &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "O!|LO:clone",
++ (char**) kwlist, &PyList_Type, &locs_list, &timeout_val, &callback ) )
++ return NULL;
++
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ if ( !locs_list || locs_list == Py_None ) {
+ PyErr_SetString( PyExc_TypeError, "clone() expects a list of locations" );
+diff --git a/python/src/PyXRootDFileSystem.cc b/python/src/PyXRootDFileSystem.cc
+index b66f3cb7e..3bd8ea6fa 100644
+--- a/python/src/PyXRootDFileSystem.cc
++++ b/python/src/PyXRootDFileSystem.cc
+@@ -85,16 +85,17 @@ namespace PyXRootD
+ const char *path;
+ unsigned int flags_val =
+ static_cast<unsigned int>(XrdCl::OpenFlags::None);
+- time_t timeout = 0;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pyresponse = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "sI|HO:locate",
+- (char**) kwlist, &path, &flags_val, &timeout, &callback ) )
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "sI|LO:locate",
++ (char**) kwlist, &path, &flags_val, &timeout_val, &callback ) )
+ return NULL;
+
+ XrdCl::OpenFlags::Flags flags =
+ static_cast<XrdCl::OpenFlags::Flags>(flags_val);
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::LocationInfo>( callback );
+@@ -128,16 +129,17 @@ namespace PyXRootD
+ const char *path;
+ unsigned int flags_val =
+ static_cast<unsigned int>(XrdCl::OpenFlags::PrefName);
+- time_t timeout = 0;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pyresponse = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "sI|HO:deeplocate",
+- (char**) kwlist, &path, &flags_val, &timeout, &callback ) )
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "sI|LO:deeplocate",
++ (char**) kwlist, &path, &flags_val, &timeout_val, &callback ) )
+ return NULL;
+
+ XrdCl::OpenFlags::Flags flags =
+ static_cast<XrdCl::OpenFlags::Flags>(flags_val);
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::LocationInfo>( callback );
+@@ -168,14 +170,17 @@ namespace PyXRootD
+ {
+ static const char *kwlist[] = { "source", "dest", "timeout", "callback",
+ NULL };
+- const char *source;
+- const char *dest;
+- time_t timeout = 0;
++ const char *source;
++ const char *dest;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "ss|HO:mv", (char**) kwlist,
+- &source, &dest, &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "ss|LO:mv",
++ (char**) kwlist, &source, &dest, &timeout_val, &callback ) )
++ return NULL;
++
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::AnyObject>( callback );
+@@ -204,17 +209,18 @@ namespace PyXRootD
+ "callback", NULL };
+ unsigned int queryCode_val;
+ const char *arg;
+- time_t timeout = 0;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pyresponse = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+ XrdCl::Buffer argbuffer;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "Is|HO:query",
+- (char**) kwlist, &queryCode_val, &arg, &timeout, &callback ) )
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "Is|LO:query",
++ (char**) kwlist, &queryCode_val, &arg, &timeout_val, &callback ) )
+ return NULL;
+
+ XrdCl::QueryCode::Code queryCode =
+ static_cast<XrdCl::QueryCode::Code>(queryCode_val);
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ argbuffer.FromString(arg);
+
+@@ -247,13 +253,16 @@ namespace PyXRootD
+ {
+ static const char *kwlist[] = { "path", "size", "timeout", "callback", NULL };
+ const char *path;
+- uint64_t size = 0;
+- time_t timeout = 0;
++ uint64_t size = 0;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "sK|HO:truncate",
+- (char**) kwlist, &path, &size, &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "sK|LO:truncate",
++ (char**) kwlist, &path, &size, &timeout_val, &callback ) )
++ return NULL;
++
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::AnyObject>( callback );
+@@ -280,12 +289,14 @@ namespace PyXRootD
+ {
+ static const char *kwlist[] = { "path", "timeout", "callback", NULL };
+ const char *path;
+- time_t timeout = 0;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s|HO:rm", (char**) kwlist,
+- &path, &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s|LO:rm",
++ (char**) kwlist, &path, &timeout_val, &callback ) ) return NULL;
++
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::AnyObject>( callback );
+@@ -317,18 +328,20 @@ namespace PyXRootD
+ static_cast<unsigned int>(XrdCl::MkDirFlags::None);
+ unsigned int mode_val =
+ static_cast<unsigned int>(XrdCl::Access::None);
+- time_t timeout = 0;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s|IIHO:mkdir",
+- (char**) kwlist, &path, &flags_val, &mode_val, &timeout, &callback ) )
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s|IILO:mkdir",
++ (char**) kwlist, &path, &flags_val, &mode_val, &timeout_val,
++ &callback ) )
+ return NULL;
+
+ XrdCl::MkDirFlags::Flags flags =
+ static_cast<XrdCl::MkDirFlags::Flags>(flags_val);
+ XrdCl::Access::Mode mode =
+ static_cast<XrdCl::Access::Mode>(mode_val);
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::AnyObject>( callback );
+@@ -355,12 +368,14 @@ namespace PyXRootD
+ {
+ static const char *kwlist[] = { "path", "timeout", "callback", NULL };
+ const char *path;
+- time_t timeout = 0;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s|HO:rmdir", (char**) kwlist,
+- &path, &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s|LO:rmdir",
++ (char**) kwlist, &path, &timeout_val, &callback ) ) return NULL;
++
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::AnyObject>( callback );
+@@ -389,16 +404,17 @@ namespace PyXRootD
+ const char *path;
+ unsigned int mode_val =
+ static_cast<unsigned int>(XrdCl::Access::None);
+- time_t timeout = 0;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "sI|HO:chmod",
+- (char**) kwlist, &path, &mode_val, &timeout, &callback ) )
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "sI|LO:chmod",
++ (char**) kwlist, &path, &mode_val, &timeout_val, &callback ) )
+ return NULL;
+
+ XrdCl::Access::Mode mode =
+ static_cast<XrdCl::Access::Mode>(mode_val);
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::AnyObject>( callback );
+@@ -424,12 +440,14 @@ namespace PyXRootD
+ PyObject* FileSystem::Ping( FileSystem *self, PyObject *args, PyObject *kwds )
+ {
+ static const char *kwlist[] = { "timeout", "callback", NULL };
+- time_t timeout = 0;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "|HO:ping", (char**) kwlist,
+- &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "|LO:ping",
++ (char**) kwlist, &timeout_val, &callback ) ) return NULL;
++
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::AnyObject>( callback );
+@@ -456,12 +474,14 @@ namespace PyXRootD
+ {
+ static const char *kwlist[] = { "path", "timeout", "callback", NULL };
+ const char *path;
+- time_t timeout = 0;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pyresponse = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s|HO:stat", (char**) kwlist,
+- &path, &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s|LO:stat",
++ (char**) kwlist, &path, &timeout_val, &callback ) ) return NULL;
++
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::StatInfo>( callback );
+@@ -492,12 +512,14 @@ namespace PyXRootD
+ {
+ static const char *kwlist[] = { "path", "timeout", "callback", NULL };
+ const char *path;
+- time_t timeout = 0;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pyresponse = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s|HO:statvfs", (char**) kwlist,
+- &path, &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s|LO:statvfs",
++ (char**) kwlist, &path, &timeout_val, &callback ) ) return NULL;
++
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::StatInfoVFS>( callback );
+@@ -527,12 +549,14 @@ namespace PyXRootD
+ PyObject* FileSystem::Protocol( FileSystem *self, PyObject *args, PyObject *kwds )
+ {
+ static const char *kwlist[] = { "timeout", "callback", NULL };
+- time_t timeout = 0;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pyresponse = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "|HO:protocol", (char**) kwlist,
+- &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "|LO:protocol",
++ (char**) kwlist, &timeout_val, &callback ) ) return NULL;
++
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::ProtocolInfo>( callback );
+@@ -566,16 +590,17 @@ namespace PyXRootD
+ const char *path;
+ unsigned int flags_val =
+ static_cast<unsigned int>(XrdCl::DirListFlags::None);
+- time_t timeout = 0;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pyresponse = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s|IHO:dirlist",
+- (char**) kwlist, &path, &flags_val, &timeout, &callback ) )
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s|ILO:dirlist",
++ (char**) kwlist, &path, &flags_val, &timeout_val, &callback ) )
+ return NULL;
+
+ XrdCl::DirListFlags::Flags flags =
+ static_cast<XrdCl::DirListFlags::Flags>(flags_val);
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::DirectoryList>( callback );
+@@ -606,12 +631,14 @@ namespace PyXRootD
+ {
+ static const char *kwlist[] = { "info", "timeout", "callback", NULL };
+ const char *info;
+- time_t timeout = 0;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pyresponse = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s|HO:sendinfo",
+- (char**) kwlist, &info, &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s|LO:sendinfo",
++ (char**) kwlist, &info, &timeout_val, &callback ) ) return NULL;
++
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<XrdCl::Buffer>( callback );
+@@ -644,15 +671,18 @@ namespace PyXRootD
+ "timeout", "callback", NULL };
+ unsigned int flags_val = 0;
+ uint8_t priority = 0;
+- time_t timeout = 0;
++ long long timeout_val = 0;
+ PyObject *pyfiles = NULL, *callback = NULL;
+ PyObject *pyresponse = NULL, *pystatus = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "OI|bHO:prepare",
+- (char**) kwlist, &pyfiles, &flags_val, &priority, &timeout, &callback ) )
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "OI|bLO:prepare",
++ (char**) kwlist, &pyfiles, &flags_val, &priority, &timeout_val,
++ &callback ) )
+ return NULL;
+
++ time_t timeout = static_cast<time_t>(timeout_val);
++
+ if ( !PyList_Check( pyfiles ) ) {
+ PyErr_SetString( PyExc_TypeError, "files parameter must be a list" );
+ return NULL;
+@@ -777,13 +807,16 @@ namespace PyXRootD
+
+ char *path = 0;
+ std::vector<XrdCl::xattr_t> attrs;
+- time_t timeout = 0;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pystatus = NULL;
+ PyObject *pyattrs = NULL, *pyresponse = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "sO|HO:set_xattr",
+- (char**) kwlist, &path, &pyattrs, &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "sO|LO:set_xattr",
++ (char**) kwlist, &path, &pyattrs, &timeout_val, &callback ) )
++ return NULL;
++
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ // it should be a list
+ if( !PyList_Check( pyattrs ) )
+@@ -846,13 +879,16 @@ namespace PyXRootD
+
+ char *path = 0;
+ std::vector<std::string> attrs;
+- time_t timeout = 0;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pystatus = NULL;
+ PyObject *pyattrs = NULL, *pyresponse = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "sO|HO:set_xattr",
+- (char**) kwlist, &path, &pyattrs, &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "sO|LO:set_xattr",
++ (char**) kwlist, &path, &pyattrs, &timeout_val, &callback ) )
++ return NULL;
++
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ // it should be a list
+ if( !PyList_Check( pyattrs ) )
+@@ -903,13 +939,16 @@ namespace PyXRootD
+
+ char *path = 0;
+ std::vector<std::string> attrs;
+- time_t timeout = 0;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pystatus = NULL;
+ PyObject *pyattrs = NULL, *pyresponse = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "sO|HO:set_xattr",
+- (char**) kwlist, &path, &pyattrs, &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "sO|LO:set_xattr",
++ (char**) kwlist, &path, &pyattrs, &timeout_val, &callback ) )
++ return NULL;
++
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ // it should be a list
+ if( !PyList_Check( pyattrs ) )
+@@ -959,12 +998,14 @@ namespace PyXRootD
+ static const char *kwlist[] = { "path", "timeout", "callback", NULL };
+
+ char *path = 0;
+- time_t timeout = 0;
++ long long timeout_val = 0;
+ PyObject *callback = NULL, *pystatus = NULL, *pyresponse = NULL;
+ XrdCl::XRootDStatus status;
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s|HO:set_xattr",
+- (char**) kwlist, &path, &timeout, &callback ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "s|LO:set_xattr",
++ (char**) kwlist, &path, &timeout_val, &callback ) ) return NULL;
++
++ time_t timeout = static_cast<time_t>(timeout_val);
+
+ if ( callback && callback != Py_None ) {
+ XrdCl::ResponseHandler *handler = GetHandler<std::vector<XrdCl::XAttr>>( callback );
+--
+2.55.0
+
diff --git a/0003-Python-Fix-parsing-of-uint64_t-arguments-in-python-b.patch b/0003-Python-Fix-parsing-of-uint64_t-arguments-in-python-b.patch
new file mode 100644
index 0000000..401df02
--- /dev/null
+++ b/0003-Python-Fix-parsing-of-uint64_t-arguments-in-python-b.patch
@@ -0,0 +1,85 @@
+From 8a261cd0fbd48c9618ec751ed015d203bcb42ed8 Mon Sep 17 00:00:00 2001
+From: Mattias Ellert <mattias.ellert@physics.uu.se>
+Date: Tue, 6 Oct 2026 08:13:49 +0200
+Subject: [PATCH 3/3] [Python] Fix parsing of uint64_t arguments in python
+ bindings
+
+Previously the format "k" (unsigned long) was used for parsing
+uint64_t values. This is not correct on 32 bit architectures where
+unsigned long is 32 bits wide. This commit uses format "K" (unsigned
+long long) which is 64 bits wide on both 32 and 64 bit architectures.
+
+This fixes a test failure on 32 bit architectures such as ix86.
+---
+ python/src/Conversions.hh | 14 +++++++-------
+ python/src/PyXRootDFile.cc | 6 +++---
+ 2 files changed, 10 insertions(+), 10 deletions(-)
+
+diff --git a/python/src/Conversions.hh b/python/src/Conversions.hh
+index a1948c01e..5f5fdec80 100644
+--- a/python/src/Conversions.hh
++++ b/python/src/Conversions.hh
+@@ -127,13 +127,13 @@ namespace PyXRootD
+ {
+ return Py_BuildValue("{sNsNsNsNsNsNsNsNsNsNsNsNsNsNsN}",
+ "id", Py_BuildValue("s", info->GetId().c_str()),
+- "size", Py_BuildValue("k", info->GetSize()),
++ "size", Py_BuildValue("K", info->GetSize()),
+ "flags", Py_BuildValue("I", info->GetFlags()),
+- "mtime", Py_BuildValue("k", info->GetModTime()),
+- "modtime", Py_BuildValue("k", info->GetModTime()),
++ "mtime", Py_BuildValue("K", info->GetModTime()),
++ "modtime", Py_BuildValue("K", info->GetModTime()),
+ "modtimestr", Py_BuildValue("s", info->GetModTimeAsString().c_str()),
+- "ctime", Py_BuildValue("k", info->GetChangeTime()),
+- "atime", Py_BuildValue("k", info->GetAccessTime()),
++ "ctime", Py_BuildValue("K", info->GetChangeTime()),
++ "atime", Py_BuildValue("K", info->GetAccessTime()),
+ "mode", Py_BuildValue("s", info->GetModeAsString().c_str()),
+ "modeoctstr", Py_BuildValue("s", info->GetModeAsOctString().c_str()),
+ "owner", Py_BuildValue("s", info->GetOwner().c_str()),
+@@ -148,7 +148,7 @@ namespace PyXRootD
+ {
+ static PyObject* Convert( XrdCl::StatInfoVFS *info )
+ {
+- return Py_BuildValue( "{sksksksksbsb}",
++ return Py_BuildValue( "{sKsKsKsKsbsb}",
+ "nodes_rw", info->GetNodesRW(),
+ "nodes_staging", info->GetNodesStaging(),
+ "free_rw", info->GetFreeRW(),
+@@ -284,7 +284,7 @@ namespace PyXRootD
+
+ PyList_SET_ITEM( pychunks, i,
+ Py_BuildValue( "{sNsNsO}",
+- "offset", Py_BuildValue( "k", chunk.offset ),
++ "offset", Py_BuildValue( "K", chunk.offset ),
+ "length", Py_BuildValue( "I", chunk.length ),
+ "buffer", buffer ) );
+ Py_DECREF( buffer );
+diff --git a/python/src/PyXRootDFile.cc b/python/src/PyXRootDFile.cc
+index 70f2f9121..6ae8f6989 100644
+--- a/python/src/PyXRootDFile.cc
++++ b/python/src/PyXRootDFile.cc
+@@ -528,8 +528,8 @@ namespace PyXRootD
+
+ if ( !self->file->IsOpen() ) return FileClosedError();
+
+- if ( !PyArg_ParseTupleAndKeywords( args, kwds, "|kII:readlines",
+- (char**) kwlist, &offset, &size, &chunksize ) ) return NULL;
++ if ( !PyArg_ParseTupleAndKeywords( args, kwds, "|OOO:readlines",
++ (char**) kwlist, &py_offset, &py_size, &py_chunksize ) ) return NULL;
+
+ unsigned long long tmp_offset = 0;
+ unsigned int tmp_size = 0, tmp_chunksize = 0;
+@@ -615,7 +615,7 @@ namespace PyXRootD
+
+ if ( PyType_Ready( &ChunkIteratorType ) < 0 ) return NULL;
+
+- args = Py_BuildValue( "ONN", self, Py_BuildValue("k", offset),
++ args = Py_BuildValue( "ONN", self, Py_BuildValue("K", offset),
+ Py_BuildValue("I", chunksize) );
+ iterator = (ChunkIterator*)
+ PyObject_CallObject( (PyObject *) &ChunkIteratorType, args );
+--
+2.55.0
+
diff --git a/sources b/sources
index a960b85..a13d50f 100644
--- a/sources
+++ b/sources
@@ -1 +1 @@
-SHA512 (xrootd-6.1.1.tar.gz) = ac1286cc54c60611bf17b6140b8cd7ef17a8318a4082cae38e5da040199ce4405490e583b376074c3ed29cf2d87c9bbda5da15c6a3091c83c7877abdc3343ebf
+SHA512 (xrootd-6.2.0.tar.gz) = 708300135567fd47a5613898952467efe2214d6706595b9bedad6dc0bf5dbbd4009b6be308d4ee1294b9bbe130b9d0abac9f8e9f6130aa601f9f1c78b0901d81
diff --git a/xrootd.spec b/xrootd.spec
index ce094ee..5f0f4b8 100644
--- a/xrootd.spec
+++ b/xrootd.spec
@@ -10,8 +10,8 @@
Name: xrootd
Epoch: 1
-Version: 6.1.1
-Release: 2%{?dist}
+Version: 6.2.0
+Release: 1%{?dist}
Summary: Extended ROOT file server
License: LGPL-3.0-or-later AND BSD-2-Clause AND BSD-3-Clause AND curl AND MIT AND Zlib AND Apache-2.0 AND MPL-2.0
URL: https://xrootd.web.cern.ch
@@ -24,6 +24,12 @@ Patch0: 0001-Unbundle-tinyxml.patch
Patch1: 0001-Unbundle-gtest.patch
# Make documentation self-contained
Patch2: 0001-Make-documentation-self-contained.patch
+# https://github.com/xrootd/xrootd/pull/2969
+Patch3: 0001-Tests-Do-not-hardcode-the-name-of-the-build-director.patch
+# https://github.com/xrootd/xrootd/pull/2970
+Patch4: 0001-Python-Fix-parsing-of-enum-arguments-in-python-bindi.patch
+Patch5: 0002-Python-Fix-parsing-of-timeout-arguments-in-python-bi.patch
+Patch6: 0003-Python-Fix-parsing-of-uint64_t-arguments-in-python-b.patch
BuildRequires: cmake
BuildRequires: gcc-c++
@@ -79,6 +85,7 @@ BuildRequires: krb5-server
BuildRequires: krb5-workstation
BuildRequires: openssl
BuildRequires: procps
+BuildRequires: python3-pytest
BuildRequires: sqlite
Requires: %{name}-server%{?_isa} = %{epoch}:%{version}-%{release}
@@ -270,10 +277,13 @@ This package contains the API documentation of the xrootd libraries.
%patch -P0 -p1
%patch -P1 -p1
%patch -P2 -p1
+%patch -P3 -p1
+%patch -P4 -p1
+%patch -P5 -p1
+%patch -P6 -p1
# Delete bundled dependencies
rm src/XrdXml/tinyxml/tiny*
-rm -r vendor/bats
rm -r vendor/googletest
%if %{?fedora}%{!?fedora:0}
# picojson not in RHEL/EPEL
@@ -410,6 +420,8 @@ done
# The badredir test fails when there is no network - exclude
# The posix test is broken for 32 bit archs ...
# https://github.com/xrootd/xrootd/issues/2559
+# XrdCl::tpc-http-bigfiles and XrdCl::tpc-http-timeout broken on 32 bit
+# https://github.com/xrootd/xrootd/issues/2972
touch testfile
if ( setfattr -n user.testattr -v testvalue testfile ) ; then
@@ -417,6 +429,8 @@ if ( setfattr -n user.testattr -v testvalue testfile ) ; then
XRootD::badredir\|\
%ifarch %{ix86} %{arm}
XRootD::posix\|\
+XrdCl::tpc-http-bigfiles\|\
+XrdCl::tpc-http-timeout\|\
%endif
XrdCl::FileSystemTest.PlugInTest\|\
XrdCl::FileTest.PlugInTest
@@ -676,6 +690,9 @@ fi
%doc %{_pkgdocdir}
%changelog
+* Tue Oct 06 2026 Mattias Ellert <mattias.ellert@physics.uu.se> - 1:6.2.0-1
+- Update to version 6.2.0
+
* Fri Sep 11 2026 Zbigniew Jędrzejewski-Szmek <zbyszek@in.waw.pl> - 1:6.1.1-2
- Rebuilt for libxml-2.5.4
^ permalink raw reply related [flat|nested] only message in thread
only message in thread, other threads:[~2026-11-22 9:06 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-11-22 9:06 [rpms/xrootd] epel8: Update to version 6.2.0 Mattias Ellert
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox