XRootD
XrdPosix.cc
Go to the documentation of this file.
1 /******************************************************************************/
2 /* */
3 /* X r d P o s i x . c c */
4 /* */
5 /* (c) 2005 by the Board of Trustees of the Leland Stanford, Jr., University */
6 /* All Rights Reserved */
7 /* Produced by Andrew Hanushevsky for Stanford University under contract */
8 /* DE-AC02-76-SFO0515 with the Department of Energy */
9 /* */
10 /* This file is part of the XRootD software suite. */
11 /* */
12 /* XRootD is free software: you can redistribute it and/or modify it under */
13 /* the terms of the GNU Lesser General Public License as published by the */
14 /* Free Software Foundation, either version 3 of the License, or (at your */
15 /* option) any later version. */
16 /* */
17 /* XRootD is distributed in the hope that it will be useful, but WITHOUT */
18 /* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or */
19 /* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public */
20 /* License for more details. */
21 /* */
22 /* You should have received a copy of the GNU Lesser General Public License */
23 /* along with XRootD in a file called COPYING.LESSER (LGPL license) and file */
24 /* COPYING (GPL license). If not, see <http://www.gnu.org/licenses/>. */
25 /* */
26 /* The copyright holder's institutional names and contributor's names may not */
27 /* be used to endorse or promote products derived from this software without */
28 /* specific prior written permission of the institution or contributor. */
29 /******************************************************************************/
30 
31 #include <cstdarg>
32 #include <cstdio>
33 #include <cstdlib>
34 #include <sys/param.h>
35 #include <sys/types.h>
36 #include <sys/stat.h>
37 #include <fcntl.h>
38 #include <unistd.h>
39 #include <sys/uio.h>
40 
41 #include "XrdSys/XrdSysHeaders.hh"
45 
46 /******************************************************************************/
47 /* G l o b a l O b j e c t s */
48 /******************************************************************************/
49 
51 
53 
54 extern XrdPosixLinkage Xunix;
55 
56 /******************************************************************************/
57 /* U t i l i t y F u n c t i o n s */
58 /******************************************************************************/
59 
60 #ifdef MUSL
61 #include <stdio_ext.h>
62 #endif
63 
64 static inline void fseterr(FILE *fp)
65 {
66  /* Most systems provide FILE as a struct and the necessary bitmask in
67  <stdio.h>, because they need it for implementing getc() and putc() as
68  fast macros. This function is based on gnulib's fseterr.c */
69 #if defined _IO_ERR_SEEN || defined _IO_ftrylockfile || __GNU_LIBRARY__ == 1
70  /* GNU libc, BeOS, Haiku, Linux libc5 */
71  fp->_flags |= _IO_ERR_SEEN;
72 #elif defined __sferror || defined __APPLE__ || defined __DragonFly__ || defined __FreeBSD__ || defined __ANDROID__
73  /* FreeBSD, NetBSD, OpenBSD, DragonFly, Mac OS X, Cygwin, Minix 3, Android */
74  fp->_flags |= __SERR;
75 #elif defined _IOERR
76  /* AIX, HP-UX, IRIX, OSF/1, Solaris, OpenServer, UnixWare, mingw, MSVC, NonStop Kernel, OpenVMS */
77  fp->_flag |= _IOERR;
78 #elif defined __UCLIBC__ /* uClibc */
79  fp->__modeflags |= __FLAG_ERROR;
80 #elif defined MUSL /* musl libc */
81  __fseterr(fp);
82 #else
83  #error "Unsupported platform! Please report it as a bug."
84 #endif
85 }
86 
87 static inline void fseteof(FILE *fp)
88 {
89  /* Most systems provide FILE as a struct and the necessary bitmask in
90  <stdio.h>, because they need it for implementing getc() and putc() as
91  fast macros. */
92 #if defined _IO_EOF_SEEN || defined _IO_ftrylockfile || __GNU_LIBRARY__ == 1
93  /* GNU libc, BeOS, Haiku, Linux libc5 */
94  fp->_flags |= _IO_EOF_SEEN;
95 #elif defined __sferror || defined __APPLE__ || defined __DragonFly__ || defined __ANDROID__
96  /* FreeBSD, NetBSD, OpenBSD, DragonFly, Mac OS X, Cygwin, Minix 3, Android */
97  fp->_flags |= __SEOF;
98 #elif defined _IOEOF
99  /* AIX, HP-UX, IRIX, OSF/1, Solaris, OpenServer, UnixWare, mingw, MSVC, NonStop Kernel, OpenVMS */
100  fp->_flag |= _IOEOF;
101 #elif defined __UCLIBC__ /* uClibc */
102  fp->__modeflags |= __FLAG_EOF;
103 #else
104  (void) fseek(fp, 0L, SEEK_END);
105 #endif
106 }
107 
108 /******************************************************************************/
109 /* X r d P o s i x _ A c c e s s */
110 /******************************************************************************/
111 
112 extern "C"
113 {
114 int XrdPosix_Access(const char *path, int amode)
115 {
116  char *myPath, buff[2048];
117 
118 // Make sure a path was passed
119 //
120  if (!path) {errno = EFAULT; return -1;}
121 
122 // Return the results of a mkdir of a Unix file system
123 //
124  if (!(myPath = XrootPath.URL(path, buff, sizeof(buff))))
125  return Xunix.Access( path, amode);
126 
127 // Return the results of our version of access()
128 //
129  return Xroot.Access(myPath, amode);
130 }
131 }
132 
133 /******************************************************************************/
134 /* X r d P o s i x _ A c l */
135 /******************************************************************************/
136 
137 // This is a required addition for Solaris 10+ systems
138 
139 extern "C"
140 {
141 int XrdPosix_Acl(const char *path, int cmd, int nentries, void *aclbufp)
142 {
143  return (XrootPath.URL(path, 0, 0)
144  ? Xunix.Acl("/tmp", cmd,nentries,aclbufp)
145  : Xunix.Acl(path, cmd,nentries,aclbufp));
146 }
147 }
148 
149 /******************************************************************************/
150 /* X r d P o s i x _ C h d i r */
151 /******************************************************************************/
152 
153 extern "C"
154 {
155 int XrdPosix_Chdir(const char *path)
156 {
157  int rc;
158 
159 // Set the working directory if the actual chdir succeeded
160 //
161  if (!(rc = Xunix.Chdir(path))) XrootPath.CWD(path);
162  return rc;
163 }
164 }
165 
166 /******************************************************************************/
167 /* X r d P o s i x _ C l o s e */
168 /******************************************************************************/
169 
170 extern "C"
171 {
172 int XrdPosix_Close(int fildes)
173 {
174 
175 // Return result of the close
176 //
177  return (Xroot.myFD(fildes) ? Xroot.Close(fildes) : Xunix.Close(fildes));
178 }
179 }
180 
181 /******************************************************************************/
182 /* X r d P o s i x _ C l o s e d i r */
183 /******************************************************************************/
184 
185 extern "C"
186 {
187 int XrdPosix_Closedir(DIR *dirp)
188 {
189 
190  return (Xroot.isXrootdDir(dirp) ? Xroot.Closedir(dirp)
191  : Xunix.Closedir(dirp));
192 }
193 }
194 
195 /******************************************************************************/
196 /* X r d P o s i x _ C r e a t */
197 /******************************************************************************/
198 
199 extern "C"
200 {
201 int XrdPosix_Creat(const char *path, mode_t mode)
202 {
203  extern int XrdPosix_Open(const char *path, int oflag, ...);
204 
205  return XrdPosix_Open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);
206 }
207 }
208 
209 /******************************************************************************/
210 /* X r d P o s i x _ F c l o s e */
211 /******************************************************************************/
212 
213 extern "C"
214 {
215 int XrdPosix_Fclose(FILE *stream)
216 {
217  int nullfd = fileno(stream);
218 
219 // Close the associated file
220 //
221  if (Xroot.myFD(nullfd)) Xroot.Close(nullfd);
222 
223 // Now close the stream
224 //
225  return Xunix.Fclose(stream);
226 }
227 }
228 
229 /******************************************************************************/
230 /* X r d P o s i x _ F c n t l */
231 /******************************************************************************/
232 
233 extern "C"
234 {
235 int XrdPosix_Fcntl(int fd, int cmd, ...)
236 {
237  va_list ap;
238  void *theArg;
239 
240  if (Xroot.myFD(fd)) return 0;
241  va_start(ap, cmd);
242  theArg = va_arg(ap, void *);
243  va_end(ap);
244  return Xunix.Fcntl64(fd, cmd, theArg);
245 }
246 }
247 
248 /******************************************************************************/
249 /* X r d P o s i x _ F d a t a s y n c */
250 /******************************************************************************/
251 
252 extern "C"
253 {
254 int XrdPosix_Fdatasync(int fildes)
255 {
256 
257 // Return the result of the sync
258 //
259  return (Xroot.myFD(fildes) ? Xroot.Fsync(fildes)
260  : Xunix.Fsync(fildes));
261 }
262 }
263 
264 /******************************************************************************/
265 /* X r d P o s i x _ F g e t x a t t r */
266 /******************************************************************************/
267 
268 #if defined(__linux__) || defined(__GNU__) || (defined(__FreeBSD_kernel__) && defined(__GLIBC__))
269 extern "C"
270 {
271 long long XrdPosix_Fgetxattr (int fd, const char *name, void *value,
272  unsigned long long size)
273 {
274  if (Xroot.myFD(fd)) {errno = ENOTSUP; return -1;}
275  return Xunix.Fgetxattr(fd, name, value, size);
276 }
277 }
278 #endif
279 
280 /******************************************************************************/
281 /* X r d P o s i x _ F f l u s h */
282 /******************************************************************************/
283 
284 extern "C"
285 {
286 int XrdPosix_Fflush(FILE *stream)
287 {
288 
289 // Return the result of the fseek
290 //
291  if (!stream || !Xroot.myFD(fileno(stream)))
292  return Xunix.Fflush(stream);
293 
294  return Xroot.Fsync(fileno(stream));
295 }
296 }
297 
298 /******************************************************************************/
299 /* X r d P o s i x _ F o p e n */
300 /******************************************************************************/
301 
302 #define ISMODE(x) !strcmp(mode, x)
303 
304 extern "C"
305 {
306 FILE *XrdPosix_Fopen(const char *path, const char *mode)
307 {
308  char *myPath, buff[2048];
309  int erc, fd, omode;
310  FILE *stream;
311 
312 // Transfer to unix if this is not our path
313 //
314  if (!(myPath = XrootPath.URL(path, buff, sizeof(buff))))
315  return Xunix.Fopen64(path, mode);
316 
317 // Translate the mode flags
318 //
319  if (ISMODE("r") || ISMODE("rb")) omode = O_RDONLY;
320  else if (ISMODE("w") || ISMODE("wb")) omode = O_WRONLY
321  | O_CREAT | O_TRUNC;
322  else if (ISMODE("a") || ISMODE("ab")) omode = O_WRONLY
323  | O_CREAT | O_APPEND;
324  else if (ISMODE("r+") || ISMODE("rb+") || ISMODE("r+b")) omode = O_RDWR;
325  else if (ISMODE("w+") || ISMODE("wb+") || ISMODE("w+b")) omode = O_RDWR
326  | O_CREAT | O_TRUNC;
327  else if (ISMODE("a+") || ISMODE("ab+") || ISMODE("a+b")) omode = O_RDWR
328  | O_CREAT | O_APPEND;
329  else {errno = EINVAL; return 0;}
330 
331 // Now open the file
332 //
333  if ((fd = Xroot.Open(myPath, omode | XrdPosixXrootd::isStream , 0)) < 0)
334  return 0;
335 
336 // First obtain a free stream
337 //
338  if (!(stream = fdopen(fd, mode)))
339  {erc = errno; Xroot.Close(fd); errno = erc;}
340 
341 // All done
342 //
343  return stream;
344 }
345 }
346 
347 /******************************************************************************/
348 /* X r d P o s i x _ F r e a d */
349 /******************************************************************************/
350 
351 extern "C"
352 {
353 size_t XrdPosix_Fread(void *ptr, size_t size, size_t nitems, FILE *stream)
354 {
355  ssize_t bytes;
356  size_t rc = 0;
357  int fd = fileno(stream);
358 
359  if (!Xroot.myFD(fd)) return Xunix.Fread(ptr, size, nitems, stream);
360 
361  bytes = Xroot.Read(fd, ptr, size*nitems);
362 
363 // Get the right return code. Note that we cannot emulate the flags in sunx86
364 //
365  if (bytes > 0 && size) rc = bytes/size;
366  else if (bytes < 0) fseterr(stream);
367  else fseteof(stream);
368 
369  return rc;
370 }
371 }
372 
373 /******************************************************************************/
374 /* X r d P o s i x _ F s e e k */
375 /******************************************************************************/
376 
377 extern "C"
378 {
379 int XrdPosix_Fseek(FILE *stream, long offset, int whence)
380 {
381 
382 // Return the result of the fseek
383 //
384  if (!Xroot.myFD(fileno(stream)))
385  return Xunix.Fseek( stream, offset, whence);
386 
387  return (Xroot.Lseek(fileno(stream), offset, whence) < 0 ? -1 : 0);
388 }
389 }
390 
391 /******************************************************************************/
392 /* X r d P o s i x _ F s e e k o */
393 /******************************************************************************/
394 
395 extern "C"
396 {
397 int XrdPosix_Fseeko(FILE *stream, long long offset, int whence)
398 {
399 
400 // Return the result of the fseek
401 //
402  if (!Xroot.myFD(fileno(stream)))
403  return Xunix.Fseeko64(stream, offset, whence);
404 
405  return (Xroot.Lseek(fileno(stream), offset, whence) < 0 ? -1 : 0);
406 }
407 }
408 
409 /******************************************************************************/
410 /* X r d P o s i x _ F s t a t */
411 /******************************************************************************/
412 
413 extern "C"
414 {
415 int XrdPosix_Fstat(int fildes, struct stat *buf)
416 {
417 
418 // Return result of the close
419 //
420  return (Xroot.myFD(fildes)
421  ? Xroot.Fstat(fildes, buf)
422 #if defined(__linux__) and defined(_STAT_VER)
423  : Xunix.Fstat64(_STAT_VER, fildes, (struct stat64 *)buf));
424 #else
425  : Xunix.Fstat64( fildes, (struct stat64 *)buf));
426 #endif
427 }
428 
429 #ifdef __linux__
430 int XrdPosix_FstatV(int ver, int fildes, struct stat *buf)
431 {
432  return (Xroot.myFD(fildes)
433  ? Xroot.Fstat(fildes, buf)
434 #ifdef _STAT_VER
435  : Xunix.Fstat64(ver, fildes, (struct stat64 *)buf));
436 #else
437  : Xunix.Fstat64( fildes, (struct stat64 *)buf));
438 #endif
439 }
440 #endif
441 }
442 
443 /******************************************************************************/
444 /* X r d P o s i x _ F s y n c */
445 /******************************************************************************/
446 
447 extern "C"
448 {
449 int XrdPosix_Fsync(int fildes)
450 {
451 
452 // Return the result of the sync
453 //
454  return (Xroot.myFD(fildes) ? Xroot.Fsync(fildes)
455  : Xunix.Fsync(fildes));
456 }
457 }
458 
459 /******************************************************************************/
460 /* X r d P o s i x _ F t e l l */
461 /******************************************************************************/
462 
463 extern "C"
464 {
465 long XrdPosix_Ftell(FILE *stream)
466 {
467 
468 // Return the result of the tell
469 //
470  if (!Xroot.myFD(fileno(stream))) return Xunix.Ftell(stream);
471 
472  return static_cast<long>(Xroot.Lseek(fileno(stream), 0, SEEK_CUR));
473 }
474 }
475 
476 /******************************************************************************/
477 /* X r d P o s i x _ F t e l l o */
478 /******************************************************************************/
479 
480 extern "C"
481 {
482 long long XrdPosix_Ftello(FILE *stream)
483 {
484 
485 // Return the result of the tell
486 //
487  if (!Xroot.myFD(fileno(stream))) return Xunix.Ftello64(stream);
488 
489  return Xroot.Lseek(fileno(stream), 0, SEEK_CUR);
490 }
491 }
492 
493 /******************************************************************************/
494 /* X r d P o s i x _ F t r u n c a t e */
495 /******************************************************************************/
496 
497 extern "C"
498 {
499 int XrdPosix_Ftruncate(int fildes, long long offset)
500 {
501 
502 // Return the result of the ftruncate
503 //
504  return (Xroot.myFD(fildes) ? Xroot.Ftruncate (fildes, offset)
505  : Xunix.Ftruncate64(fildes, offset));
506 }
507 }
508 
509 /******************************************************************************/
510 /* X r d P o s i x _ F w r i t e */
511 /******************************************************************************/
512 
513 extern "C"
514 {
515 size_t XrdPosix_Fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream)
516 {
517  size_t bytes, rc = 0;
518  int fd = fileno(stream);
519 
520  if (!Xroot.myFD(fd)) return Xunix.Fwrite(ptr, size, nitems, stream);
521 
522  bytes = Xroot.Write(fd, ptr, size*nitems);
523 
524 // Get the right return code.
525 //
526  if (bytes > 0 && size) rc = bytes/size;
527  else fseterr(stream);
528 
529  return rc;
530 }
531 }
532 
533 /******************************************************************************/
534 /* X r d P o s i x _ G e t x a t t r */
535 /******************************************************************************/
536 
537 #if defined(__linux__) || defined(__GNU__) || (defined(__FreeBSD_kernel__) && defined(__GLIBC__))
538 extern "C"
539 {
540 long long XrdPosix_Getxattr (const char *path, const char *name, void *value,
541  unsigned long long size)
542 {
543  char *myPath, buff[2048];
544 
545  if (!(myPath = XrootPath.URL(path, buff, sizeof(buff))))
546  return Xunix.Getxattr(path, name, value, size);
547 
548  return Xroot.Getxattr(myPath, name, value, size);
549 }
550 }
551 #endif
552 
553 /******************************************************************************/
554 /* X r d P o s i x _ L g e t x a t t r */
555 /******************************************************************************/
556 
557 #if defined(__linux__) || defined(__GNU__) || (defined(__FreeBSD_kernel__) && defined(__GLIBC__))
558 extern "C"
559 {
560 long long XrdPosix_Lgetxattr (const char *path, const char *name, void *value,
561  unsigned long long size)
562 {
563  if (XrootPath.URL(path, 0, 0)) {errno = ENOTSUP; return -1;}
564  return Xunix.Lgetxattr(path, name, value, size);
565 }
566 }
567 #endif
568 
569 /******************************************************************************/
570 /* X r d P o s i x _ L s e e k */
571 /******************************************************************************/
572 
573 extern "C"
574 {
575 long long XrdPosix_Lseek(int fildes, long long offset, int whence)
576 {
577 
578 // Return the operation of the seek
579 //
580  return (Xroot.myFD(fildes) ? Xroot.Lseek (fildes, offset, whence)
581  : Xunix.Lseek64(fildes, offset, whence));
582 }
583 }
584 
585 /******************************************************************************/
586 /* X r d P o s i x _ L s t a t */
587 /******************************************************************************/
588 
589 extern "C"
590 {
591 int XrdPosix_Lstat(const char *path, struct stat *buf)
592 {
593  char *myPath, buff[2048];
594 
595 // Make sure a path was passed
596 //
597  if (!path) {errno = EFAULT; return -1;}
598 
599 // Return the results of an open of a Unix file
600 //
601  return (!(myPath = XrootPath.URL(path, buff, sizeof(buff)))
602 #if defined(__linux__) and defined(_STAT_VER)
603  ? Xunix.Lstat64(_STAT_VER, path, (struct stat64 *)buf)
604 #else
605  ? Xunix.Lstat64( path, (struct stat64 *)buf)
606 #endif
607  : Xroot.Stat(myPath, buf));
608 }
609 }
610 
611 /******************************************************************************/
612 /* X r d P o s i x _ M k d i r */
613 /******************************************************************************/
614 
615 extern "C"
616 {
617 int XrdPosix_Mkdir(const char *path, mode_t mode)
618 {
619  char *myPath, buff[2048];
620 
621 // Make sure a path was passed
622 //
623  if (!path) {errno = EFAULT; return -1;}
624 
625 // Return the results of a mkdir of a Unix file system
626 //
627  if (!(myPath = XrootPath.URL(path, buff, sizeof(buff))))
628  return Xunix.Mkdir(path, mode);
629 
630 // Return the results of an mkdir of an xrootd file system
631 //
632  return Xroot.Mkdir(myPath, mode);
633 }
634 }
635 
636 /******************************************************************************/
637 /* X r d P o s i x _ O p e n */
638 /******************************************************************************/
639 
640 extern "C"
641 {
642 int XrdPosix_Open(const char *path, int oflag, ...)
643 {
644  char *myPath, buff[2048];
645  va_list ap;
646  int mode;
647 
648 // Make sure a path was passed
649 //
650  if (!path) {errno = EFAULT; return -1;}
651 
652 // Return the results of an open of a Unix file
653 //
654  if (!(myPath = XrootPath.URL(path, buff, sizeof(buff))))
655  {if (!(oflag & O_CREAT)) return Xunix.Open64(path, oflag);
656  va_start(ap, oflag);
657  mode = va_arg(ap, int);
658  va_end(ap);
659  return Xunix.Open64(path, oflag, (mode_t)mode);
660  }
661 
662 // Return the results of an open of an xrootd file
663 //
664  if (!(oflag & O_CREAT)) return Xroot.Open(myPath, oflag);
665  va_start(ap, oflag);
666  mode = va_arg(ap, int);
667  va_end(ap);
668  return Xroot.Open(myPath, oflag, (mode_t)mode);
669 }
670 }
671 
672 /******************************************************************************/
673 /* X r d P o s i x _ O p e n d i r */
674 /******************************************************************************/
675 
676 extern "C"
677 {
678 DIR* XrdPosix_Opendir(const char *path)
679 {
680  char *myPath, buff[2048];
681 
682 // Make sure a path was passed
683 //
684  if (!path) {errno = EFAULT; return 0;}
685 
686 // Unix opendir
687 //
688  if (!(myPath = XrootPath.URL(path, buff, sizeof(buff))))
689  return Xunix.Opendir(path);
690 
691 // Xrootd opendir
692 //
693  return Xroot.Opendir(myPath);
694 }
695 }
696 
697 /******************************************************************************/
698 /* X r d P o s i x _ P a t h c o n f */
699 /******************************************************************************/
700 
701 // This is a required addition for Solaris 10+ systems
702 
703 extern "C"
704 {
705 long XrdPosix_Pathconf(const char *path, int name)
706 {
707  return (XrootPath.URL(path, 0, 0) ? Xunix.Pathconf("/tmp", name)
708  : Xunix.Pathconf(path, name));
709 }
710 }
711 
712 /******************************************************************************/
713 /* X r d P o s i x _ P r e a d */
714 /******************************************************************************/
715 
716 extern "C"
717 {
718 long long XrdPosix_Pread(int fildes, void *buf, unsigned long long nbyte,
719  long long offset)
720 {
721 
722 // Return the results of the read
723 //
724  return (Xroot.myFD(fildes) ? Xroot.Pread (fildes, buf, nbyte, offset)
725  : Xunix.Pread64(fildes, buf, nbyte, offset));
726 }
727 }
728 
729 /******************************************************************************/
730 /* X r d P o s i x _ P w r i t e */
731 /******************************************************************************/
732 
733 extern "C"
734 {
735 long long XrdPosix_Pwrite(int fildes, const void *buf, unsigned long long nbyte,
736  long long offset)
737 {
738 
739 // Return the results of the write
740 //
741  return (Xroot.myFD(fildes) ? Xroot.Pwrite (fildes, buf, nbyte, offset)
742  : Xunix.Pwrite64(fildes, buf, nbyte, offset));
743 }
744 }
745 
746 /******************************************************************************/
747 /* X r d P o s i x _ R e a d */
748 /******************************************************************************/
749 
750 extern "C"
751 {
752 long long XrdPosix_Read(int fildes, void *buf, unsigned long long nbyte)
753 {
754 
755 // Return the results of the read
756 //
757  return (Xroot.myFD(fildes) ? Xroot.Read(fildes, buf, nbyte)
758  : Xunix.Read(fildes, buf, nbyte));
759 }
760 }
761 
762 /******************************************************************************/
763 /* X r d P o s i x _ R e a d v */
764 /******************************************************************************/
765 
766 extern "C"
767 {
768 long long XrdPosix_Readv(int fildes, const struct iovec *iov, int iovcnt)
769 {
770 
771 // Return results of the readv
772 //
773  return (Xroot.myFD(fildes) ? Xroot.Readv(fildes, iov, iovcnt)
774  : Xunix.Readv(fildes, iov, iovcnt));
775 }
776 }
777 
778 /******************************************************************************/
779 /* X r d P o s i x _ R e a d d i r */
780 /******************************************************************************/
781 
782 extern "C"
783 {
784 // On some platforms both 32- and 64-bit versions are callable. so do the same
785 //
786 struct dirent * XrdPosix_Readdir (DIR *dirp)
787 {
788 
789 // Return result of readdir
790 //
791  return (Xroot.isXrootdDir(dirp) ? Xroot.Readdir(dirp)
792  : Xunix.Readdir(dirp));
793 }
794 
795 struct dirent64 * XrdPosix_Readdir64(DIR *dirp)
796 {
797 
798 // Return result of readdir
799 //
800  return (Xroot.isXrootdDir(dirp) ? Xroot.Readdir64(dirp)
801  : Xunix.Readdir64(dirp));
802 }
803 }
804 
805 /******************************************************************************/
806 /* X r d P o s i x _ R e a d d i r _ r */
807 /******************************************************************************/
808 
809 extern "C"
810 {
811 int XrdPosix_Readdir_r(DIR *dirp, struct dirent *entry, struct dirent **result)
812 {
813 
814 // Return result of readdir
815 //
816  return (Xroot.isXrootdDir(dirp) ? Xroot.Readdir_r(dirp,entry,result)
817  : Xunix.Readdir_r(dirp,entry,result));
818 }
819 
820 int XrdPosix_Readdir64_r(DIR *dirp, struct dirent64 *entry, struct dirent64 **result)
821 {
822 
823 // Return result of readdir
824 //
825  return (Xroot.isXrootdDir(dirp) ? Xroot.Readdir64_r(dirp,entry,result)
826  : Xunix.Readdir64_r(dirp,entry,result));
827 }
828 }
829 
830 /******************************************************************************/
831 /* X r d P o s i x _ R e n a m e */
832 /******************************************************************************/
833 
834 extern "C"
835 {
836 int XrdPosix_Rename(const char *oldpath, const char *newpath)
837 {
838  char *oldPath, buffold[2048], *newPath, buffnew[2048];
839 
840 // Make sure a path was passed
841 //
842  if (!oldpath || !newpath) {errno = EFAULT; return -1;}
843 
844 // Return the results of a mkdir of a Unix file system
845 //
846  if (!(oldPath = XrootPath.URL(oldpath, buffold, sizeof(buffold)))
847  || !(newPath = XrootPath.URL(newpath, buffnew, sizeof(buffnew))))
848  return Xunix.Rename(oldpath, newpath);
849 
850 // Return the results of an mkdir of an xrootd file system
851 //
852  return Xroot.Rename(oldPath, newPath);
853 }
854 }
855 
856 /******************************************************************************/
857 /* X r d P o s i x _ R e w i n d d i r */
858 /******************************************************************************/
859 
860 extern "C"
861 {
862 void XrdPosix_Rewinddir(DIR *dirp)
863 {
864 
865 // Return result of rewind
866 //
867  return (Xroot.isXrootdDir(dirp) ? Xroot.Rewinddir(dirp)
868  : Xunix.Rewinddir(dirp));
869 }
870 }
871 
872 /******************************************************************************/
873 /* X r d P o s i x _ R m d i r */
874 /******************************************************************************/
875 
876 extern "C"
877 {
878 int XrdPosix_Rmdir(const char *path)
879 {
880  char *myPath, buff[2048];
881 
882 // Make sure a path was passed
883 //
884  if (!path) {errno = EFAULT; return -1;}
885 
886 // Return the results of a mkdir of a Unix file system
887 //
888  if (!(myPath = XrootPath.URL(path, buff, sizeof(buff))))
889  return Xunix.Rmdir(path);
890 
891 // Return the results of an mkdir of an xrootd file system
892 //
893  return Xroot.Rmdir(myPath);
894 }
895 }
896 
897 /******************************************************************************/
898 /* X r d P o s i x _ S e e k d i r */
899 /******************************************************************************/
900 
901 extern "C"
902 {
903 void XrdPosix_Seekdir(DIR *dirp, long loc)
904 {
905 
906 // Call seekdir
907 //
908  (Xroot.isXrootdDir(dirp) ? Xroot.Seekdir(dirp, loc)
909  : Xunix.Seekdir(dirp, loc));
910 }
911 }
912 
913 /******************************************************************************/
914 /* X r d P o s i x _ S t a t */
915 /******************************************************************************/
916 
917 extern "C"
918 {
919 int XrdPosix_Stat(const char *path, struct stat *buf)
920 {
921  char *myPath, buff[2048];
922 
923 // Make sure a path was passed
924 //
925  if (!path) {errno = EFAULT; return -1;}
926 
927 // Return the results of an open of a Unix file
928 //
929  return (!(myPath = XrootPath.URL(path, buff, sizeof(buff)))
930 #if defined(__linux__) and defined(_STAT_VER)
931  ? Xunix.Stat64(_STAT_VER, path, (struct stat64 *)buf)
932 #else
933  ? Xunix.Stat64( path, (struct stat64 *)buf)
934 #endif
935  : Xroot.Stat(myPath, buf));
936 }
937 }
938 
939 /******************************************************************************/
940 /* X r d P o s i x _ S t a t f s */
941 /******************************************************************************/
942 
943 extern "C"
944 {
945 int XrdPosix_Statfs(const char *path, struct statfs *buf)
946 {
947  char *myPath, buff[2048];
948 
949 // Make sure a path was passed
950 //
951  if (!path) {errno = EFAULT; return -1;}
952 
953 // Return the results of an open of a Unix file
954 //
955  return ((myPath = XrootPath.URL(path, buff, sizeof(buff)))
956  ? Xroot.Statfs(myPath, buf)
957  : Xunix.Statfs64(path, (struct statfs64 *)buf));
958 }
959 }
960 
961 /******************************************************************************/
962 /* X r d P o s i x _ S t a t v f s */
963 /******************************************************************************/
964 
965 extern "C"
966 {
967 int XrdPosix_Statvfs(const char *path, struct statvfs *buf)
968 {
969  char *myPath, buff[2048];
970 
971 // Make sure a path was passed
972 //
973  if (!path) {errno = EFAULT; return -1;}
974 
975 // Return the results of an open of a Unix file
976 //
977  return ((myPath = XrootPath.URL(path, buff, sizeof(buff)))
978  ? Xroot.Statvfs(myPath, buf)
979  : Xunix.Statvfs64(path, (struct statvfs64 *)buf));
980 }
981 }
982 
983 /******************************************************************************/
984 /* X r d P o s i x _ T e l l d i r */
985 /******************************************************************************/
986 
987 extern "C"
988 {
989 long XrdPosix_Telldir(DIR *dirp)
990 {
991 
992 // Return result of telldir
993 //
994  return (Xroot.isXrootdDir(dirp) ? Xroot.Telldir(dirp)
995  : Xunix.Telldir(dirp));
996 }
997 }
998 
999 /******************************************************************************/
1000 /* X r d P o s i x _ T r u n c a t e */
1001 /******************************************************************************/
1002 
1003 extern "C"
1004 {
1005 int XrdPosix_Truncate(const char *path, long long offset)
1006 {
1007  char *myPath, buff[2048];
1008 
1009 // Make sure a path was passed
1010 //
1011  if (!path) {errno = EFAULT; return -1;}
1012 
1013 // Return the results of a truncate of a Unix file system
1014 //
1015  if (!(myPath = XrootPath.URL(path, buff, sizeof(buff))))
1016  return Xunix.Truncate64(path, offset);
1017 
1018 // Return the results of an truncate of an xrootd file system
1019 //
1020  return Xroot.Truncate(myPath, offset);
1021 }
1022 }
1023 
1024 /******************************************************************************/
1025 /* X r d P o s i x _ U n l i n k */
1026 /******************************************************************************/
1027 
1028 extern "C"
1029 {
1030 int XrdPosix_Unlink(const char *path)
1031 {
1032  char *myPath, buff[2048];
1033 
1034 // Make sure a path was passed
1035 //
1036  if (!path) {errno = EFAULT; return -1;}
1037 
1038 // Return the result of a unlink of a Unix file
1039 //
1040  if (!(myPath = XrootPath.URL(path, buff, sizeof(buff))))
1041  return Xunix.Unlink(path);
1042 
1043 // Return the results of an unlink of an xrootd file
1044 //
1045  return Xroot.Unlink(myPath);
1046 }
1047 }
1048 
1049 /******************************************************************************/
1050 /* X r d P o s i x _ W r i t e */
1051 /******************************************************************************/
1052 
1053 extern "C"
1054 {
1055 long long XrdPosix_Write(int fildes, const void *buf, unsigned long long nbyte)
1056 {
1057 
1058 // Return the results of the write
1059 //
1060  return (Xroot.myFD(fildes) ? Xroot.Write(fildes, buf, nbyte)
1061  : Xunix.Write(fildes, buf, nbyte));
1062 }
1063 }
1064 
1065 /******************************************************************************/
1066 /* X r d P o s i x _ W r i t e v */
1067 /******************************************************************************/
1068 
1069 extern "C"
1070 {
1071 long long XrdPosix_Writev(int fildes, const struct iovec *iov, int iovcnt)
1072 {
1073 
1074 // Return results of the writev
1075 //
1076  return (Xroot.myFD(fildes) ? Xroot.Writev(fildes, iov, iovcnt)
1077  : Xunix.Writev(fildes, iov, iovcnt));
1078 }
1079 }
1080 
1081 /******************************************************************************/
1082 /* X r d P o s i x _ i s M y P a t h */
1083 /******************************************************************************/
1084 
1085 int XrdPosix_isMyPath(const char *path)
1086 {
1087  return (0 != XrootPath.URL(path, 0, 0));
1088 }
1089 
1090 /******************************************************************************/
1091 /* X r d P o s i x _ U R L */
1092 /******************************************************************************/
1093 
1094 char *XrdPosix_URL(const char *path, char *buff, int blen)
1095 {
1096  return XrootPath.URL(path, buff, blen);
1097 }
int stat(const char *path, struct stat *buf)
int statvfs(const char *path, struct statvfs *buf)
int statfs(const char *path, struct statfs *buf)
int statvfs64(const char *path, struct statvfs64 *buf)
int fseek(FILE *stream, long offset, int whence)
int statfs64(const char *path, struct statfs64 *buf)
int stat64(const char *path, struct stat64 *buf)
int XrdPosix_Statfs(const char *path, struct statfs *buf)
Definition: XrdPosix.cc:945
long long XrdPosix_Pread(int fildes, void *buf, unsigned long long nbyte, long long offset)
Definition: XrdPosix.cc:718
long long XrdPosix_Write(int fildes, const void *buf, unsigned long long nbyte)
Definition: XrdPosix.cc:1055
#define ISMODE(x)
Definition: XrdPosix.cc:302
long long XrdPosix_Lseek(int fildes, long long offset, int whence)
Definition: XrdPosix.cc:575
long long XrdPosix_Writev(int fildes, const struct iovec *iov, int iovcnt)
Definition: XrdPosix.cc:1071
int XrdPosix_Closedir(DIR *dirp)
Definition: XrdPosix.cc:187
int XrdPosix_Fsync(int fildes)
Definition: XrdPosix.cc:449
static void fseterr(FILE *fp)
Definition: XrdPosix.cc:64
int XrdPosix_isMyPath(const char *path)
Definition: XrdPosix.cc:1085
long long XrdPosix_Ftello(FILE *stream)
Definition: XrdPosix.cc:482
int XrdPosix_Open(const char *path, int oflag,...)
Definition: XrdPosix.cc:642
void XrdPosix_Rewinddir(DIR *dirp)
Definition: XrdPosix.cc:862
long long XrdPosix_Readv(int fildes, const struct iovec *iov, int iovcnt)
Definition: XrdPosix.cc:768
int XrdPosix_Readdir64_r(DIR *dirp, struct dirent64 *entry, struct dirent64 **result)
Definition: XrdPosix.cc:820
int XrdPosix_Close(int fildes)
Definition: XrdPosix.cc:172
void XrdPosix_Seekdir(DIR *dirp, long loc)
Definition: XrdPosix.cc:903
int XrdPosix_Rmdir(const char *path)
Definition: XrdPosix.cc:878
int XrdPosix_Chdir(const char *path)
Definition: XrdPosix.cc:155
FILE * XrdPosix_Fopen(const char *path, const char *mode)
Definition: XrdPosix.cc:306
int XrdPosix_Stat(const char *path, struct stat *buf)
Definition: XrdPosix.cc:919
int XrdPosix_Rename(const char *oldpath, const char *newpath)
Definition: XrdPosix.cc:836
int XrdPosix_Fcntl(int fd, int cmd,...)
Definition: XrdPosix.cc:235
int XrdPosix_Fseek(FILE *stream, long offset, int whence)
Definition: XrdPosix.cc:379
long XrdPosix_Ftell(FILE *stream)
Definition: XrdPosix.cc:465
static void fseteof(FILE *fp)
Definition: XrdPosix.cc:87
int XrdPosix_Readdir_r(DIR *dirp, struct dirent *entry, struct dirent **result)
Definition: XrdPosix.cc:811
long long XrdPosix_Pwrite(int fildes, const void *buf, unsigned long long nbyte, long long offset)
Definition: XrdPosix.cc:735
XrdPosixXrootd Xroot
Definition: XrdPosix.cc:50
int XrdPosix_Mkdir(const char *path, mode_t mode)
Definition: XrdPosix.cc:617
long long XrdPosix_Read(int fildes, void *buf, unsigned long long nbyte)
Definition: XrdPosix.cc:752
int XrdPosix_Fflush(FILE *stream)
Definition: XrdPosix.cc:286
char * XrdPosix_URL(const char *path, char *buff, int blen)
Definition: XrdPosix.cc:1094
XrdPosixXrootPath XrootPath
Definition: XrdPosix.cc:52
DIR * XrdPosix_Opendir(const char *path)
Definition: XrdPosix.cc:678
long XrdPosix_Telldir(DIR *dirp)
Definition: XrdPosix.cc:989
int XrdPosix_Lstat(const char *path, struct stat *buf)
Definition: XrdPosix.cc:591
int XrdPosix_Creat(const char *path, mode_t mode)
Definition: XrdPosix.cc:201
int XrdPosix_Statvfs(const char *path, struct statvfs *buf)
Definition: XrdPosix.cc:967
int XrdPosix_Acl(const char *path, int cmd, int nentries, void *aclbufp)
Definition: XrdPosix.cc:141
int XrdPosix_Fstat(int fildes, struct stat *buf)
Definition: XrdPosix.cc:415
XrdPosixLinkage Xunix
size_t XrdPosix_Fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream)
Definition: XrdPosix.cc:515
int XrdPosix_Fclose(FILE *stream)
Definition: XrdPosix.cc:215
int XrdPosix_Fdatasync(int fildes)
Definition: XrdPosix.cc:254
int XrdPosix_Ftruncate(int fildes, long long offset)
Definition: XrdPosix.cc:499
struct dirent64 * XrdPosix_Readdir64(DIR *dirp)
Definition: XrdPosix.cc:795
long XrdPosix_Pathconf(const char *path, int name)
Definition: XrdPosix.cc:705
int XrdPosix_Truncate(const char *path, long long offset)
Definition: XrdPosix.cc:1005
struct dirent * XrdPosix_Readdir(DIR *dirp)
Definition: XrdPosix.cc:786
int XrdPosix_Unlink(const char *path)
Definition: XrdPosix.cc:1030
size_t XrdPosix_Fread(void *ptr, size_t size, size_t nitems, FILE *stream)
Definition: XrdPosix.cc:353
int XrdPosix_Fseeko(FILE *stream, long long offset, int whence)
Definition: XrdPosix.cc:397
int XrdPosix_Access(const char *path, int amode)
Definition: XrdPosix.cc:114
Retv_Opendir(* Opendir)(Args_Opendir)
Retv_Mkdir(* Mkdir)(Args_Mkdir)
Retv_Readdir64(* Readdir64)(Args_Readdir64)
Retv_Fflush(* Fflush)(Args_Fflush)
Retv_Fstat64(* Fstat64)(Args_Fstat64)
Retv_Fclose(* Fclose)(Args_Fclose)
Retv_Fseek(* Fseek)(Args_Fseek)
Retv_Fwrite(* Fwrite)(Args_Fwrite)
Retv_Acl(* Acl)(Args_Acl)
Retv_Writev(* Writev)(Args_Writev)
Retv_Read(* Read)(Args_Read)
Retv_Fsync(* Fsync)(Args_Fsync)
Retv_Rename(* Rename)(Args_Rename)
Retv_Close(* Close)(Args_Close)
Retv_Statfs64(* Statfs64)(Args_Statfs64)
Retv_Lgetxattr(* Lgetxattr)(Args_Lgetxattr)
Retv_Ftruncate64(* Ftruncate64)(Args_Ftruncate64)
Retv_Rewinddir(* Rewinddir)(Args_Rewinddir)
Retv_Readdir(* Readdir)(Args_Readdir)
Retv_Lseek64(* Lseek64)(Args_Lseek64)
Retv_Statvfs64(* Statvfs64)(Args_Statvfs64)
Retv_Truncate64(* Truncate64)(Args_Truncate64)
Retv_Ftell(* Ftell)(Args_Ftell)
Retv_Fread(* Fread)(Args_Fread)
Retv_Open64(* Open64)(Args_Open64)
Retv_Fopen64(* Fopen64)(Args_Fopen64)
Retv_Telldir(* Telldir)(Args_Telldir)
Retv_Fseeko64(* Fseeko64)(Args_Fseeko64)
Retv_Readv(* Readv)(Args_Readv)
Retv_Stat64(* Stat64)(Args_Stat64)
Retv_Pread64(* Pread64)(Args_Pread64)
Retv_Readdir64_r(* Readdir64_r)(Args_Readdir64_r)
Retv_Fcntl64(* Fcntl64)(Args_Fcntl64)
Retv_Seekdir(* Seekdir)(Args_Seekdir)
Retv_Lstat64(* Lstat64)(Args_Lstat64)
Retv_Chdir(* Chdir)(Args_Chdir)
Retv_Getxattr(* Getxattr)(Args_Getxattr)
Retv_Access(* Access)(Args_Access)
Retv_Closedir(* Closedir)(Args_Closedir)
Retv_Pathconf(* Pathconf)(Args_Pathconf)
Retv_Write(* Write)(Args_Write)
Retv_Readdir_r(* Readdir_r)(Args_Readdir_r)
Retv_Rmdir(* Rmdir)(Args_Rmdir)
Retv_Fgetxattr(* Fgetxattr)(Args_Fgetxattr)
Retv_Unlink(* Unlink)(Args_Unlink)
Retv_Pwrite64(* Pwrite64)(Args_Pwrite64)
Retv_Ftello64(* Ftello64)(Args_Ftello64)
char * URL(const char *path, char *buff, int blen)
void CWD(const char *path)
POSIX interface to XRootD with some extensions, as noted.
static ssize_t Readv(int fildes, const struct iovec *iov, int iovcnt)
Readv() conforms to POSIX.1-2001 readv()
static ssize_t Pread(int fildes, void *buf, size_t nbyte, off_t offset)
Pread() conforms to POSIX.1-2001 pread()
static int Closedir(DIR *dirp)
Closedir() conforms to POSIX.1-2001 closedir()
static void Seekdir(DIR *dirp, long loc)
Seekdir() conforms to POSIX.1-2001 seekdir()
static const int isStream
static int Stat(const char *path, struct stat *buf)
Stat() conforms to POSIX.1-2001 stat()
static int Mkdir(const char *path, mode_t mode)
Mkdir() conforms to POSIX.1-2001 mkdir()
static int Unlink(const char *path)
Unlink() conforms to POSIX.1-2001 unlink()
static int Rmdir(const char *path)
Rmdir() conforms to POSIX.1-2001 rmdir()
static void Rewinddir(DIR *dirp)
Rewinddir() conforms to POSIX.1-2001 rewinddir()
static int Rename(const char *oldpath, const char *newpath)
Rename() conforms to POSIX.1-2001 rename()
static int Close(int fildes)
Close() conforms to POSIX.1-2001 close()
static int Statvfs(const char *path, struct statvfs *buf)
Statvfs() conforms to POSIX.1-2001 statvfs()
static ssize_t Write(int fildes, const void *buf, size_t nbyte)
Write() conforms to POSIX.1-2001 write()
static struct dirent * Readdir(DIR *dirp)
static int Readdir_r(DIR *dirp, struct dirent *entry, struct dirent **result)
static ssize_t Writev(int fildes, const struct iovec *iov, int iovcnt)
Writev() conforms to POSIX.1-2001 writev()
static struct dirent64 * Readdir64(DIR *dirp)
static bool myFD(int fd)
static int Ftruncate(int fildes, off_t offset)
Ftruncate() conforms to POSIX.1-2001 ftruncate()
static long Telldir(DIR *dirp)
Telldir() conforms to POSIX.1-2001 telldir()
static bool isXrootdDir(DIR *dirp)
static int Access(const char *path, int amode)
Access() conforms to POSIX.1-2001 access()
static DIR * Opendir(const char *path)
Opendir() conforms to POSIX.1-2001 opendir()
static int Fsync(int fildes)
Fsync() conforms to POSIX.1-2001 fsync()
static long long Getxattr(const char *path, const char *name, void *value, unsigned long long size)
static int Statfs(const char *path, struct statfs *buf)
static int Readdir64_r(DIR *dirp, struct dirent64 *entry, struct dirent64 **result)
static ssize_t Read(int fildes, void *buf, size_t nbyte)
Read() conforms to POSIX.1-2001 read()
static int Fstat(int fildes, struct stat *buf)
Fstat() conforms to POSIX.1-2001 fstat()
static off_t Lseek(int fildes, off_t offset, int whence)
Lseek() conforms to POSIX.1-2001 lseek()
static int Open(const char *path, int oflag, mode_t mode=0, XrdPosixCallBack *cbP=0)
static ssize_t Pwrite(int fildes, const void *buf, size_t nbyte, off_t offset)
Pwrite() conforms to POSIX.1-2001 pwrite()
static int Truncate(const char *path, off_t offset)
Telldir() conforms to POSIX.1-2001 telldir()