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, &parallelChunks, &initTimeout,
+-         &tpcTimeout, &rmBadCksum, &cpTimeout, &xRateThreshold, &xRate,
++         &checkSumPreset, &dynamicSource, &chunkSize, &parallelChunks, &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