Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TUnixSystem.cxx
Go to the documentation of this file.
1// @(#)root/unix:$Id: 887c618d89c4ed436e4034fc133f468fecad651b $
2// Author: Fons Rademakers 15/09/95
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12//////////////////////////////////////////////////////////////////////////
13// //
14// TUnixSystem //
15// //
16// Class providing an interface to the UNIX Operating System. //
17// //
18//////////////////////////////////////////////////////////////////////////
19
20#include "RConfigure.h"
21#include <ROOT/RConfig.hxx>
23#include "TUnixSystem.h"
24#include "TROOT.h"
25#include "TError.h"
26#include "TOrdCollection.h"
27#include "TRegexp.h"
28#include "TPRegexp.h"
29#include "TException.h"
30#include "TEnv.h"
31#include "Getline.h"
32#include "TInterpreter.h"
33#include "TApplication.h"
34#include "TObjString.h"
35#include "TVirtualMutex.h"
36#include "ThreadLocalStorage.h"
37#include "TObjArray.h"
38#include "snprintf.h"
39#include "strlcpy.h"
40#include <iostream>
41#include <fstream>
42#include <map>
43#include <algorithm>
44#include <atomic>
45
46//#define G__OLDEXPAND
47
48#include <unistd.h>
49#include <cstdlib>
50#include <sys/types.h>
51#if defined(R__SUN) || defined(R__AIX) || \
52 defined(R__LINUX) || defined(R__SOLARIS) || \
53 defined(R__FBSD) || defined(R__OBSD) || \
54 defined(R__MACOSX) || defined(R__HURD)
55#define HAS_DIRENT
56#endif
57#ifdef HAS_DIRENT
58# include <dirent.h>
59#else
60# include <sys/dir.h>
61#endif
62#if defined(ULTRIX) || defined(R__SUN)
63# include <sgtty.h>
64#endif
65#if defined(R__AIX) || defined(R__LINUX) || \
66 defined(R__FBSD) || defined(R__OBSD) || \
67 defined(R__LYNXOS) || defined(R__MACOSX) || defined(R__HURD)
68# include <sys/ioctl.h>
69#endif
70#if defined(R__AIX) || defined(R__SOLARIS)
71# include <sys/select.h>
72#endif
73#if defined(R__MACOSX)
74# include <mach-o/dyld.h>
75# include <sys/mount.h>
76 extern "C" int statfs(const char *file, struct statfs *buffer);
77#elif defined(R__LINUX) || defined(R__HURD)
78# include <sys/vfs.h>
79#elif defined(R__FBSD) || defined(R__OBSD)
80# include <sys/param.h>
81# include <sys/mount.h>
82# ifdef R__FBSD
83# include <sys/user.h>
84# include <sys/types.h>
85# include <sys/param.h>
86# include <sys/queue.h>
87# include <libprocstat.h>
88# include <libutil.h>
89# endif
90#else
91# include <sys/statfs.h>
92#endif
93
94#include <utime.h>
95#include <syslog.h>
96#include <sys/stat.h>
97#include <csetjmp>
98#include <csignal>
99#include <sys/param.h>
100#include <pwd.h>
101#include <grp.h>
102#include <cerrno>
103#include <sys/resource.h>
104#include <sys/wait.h>
105#include <ctime>
106#include <sys/time.h>
107#include <sys/file.h>
108#include <sys/socket.h>
109#include <netinet/in.h>
110#include <netinet/tcp.h>
111#if defined(R__AIX)
112# define _XOPEN_EXTENDED_SOURCE
113# include <arpa/inet.h>
114# undef _XOPEN_EXTENDED_SOURCE
115# if !defined(_AIX41) && !defined(_AIX43)
116 // AIX 3.2 doesn't have it
117# define HASNOT_INETATON
118# endif
119#else
120# include <arpa/inet.h>
121#endif
122#include <sys/un.h>
123#include <netdb.h>
124#include <fcntl.h>
125#if defined(R__SOLARIS)
126# include <sys/systeminfo.h>
127# include <sys/filio.h>
128# include <sys/sockio.h>
129# define HASNOT_INETATON
130# ifndef INADDR_NONE
131# define INADDR_NONE (UInt_t)-1
132# endif
133#endif
134
135#if defined(R__SOLARIS)
136# define HAVE_UTMPX_H
137# define UTMP_NO_ADDR
138#endif
139
140#if defined(MAC_OS_X_VERSION_10_5)
141# define HAVE_UTMPX_H
142# define UTMP_NO_ADDR
143#endif
144
145#if defined(R__FBSD)
146# include <sys/param.h>
147# if __FreeBSD_version >= 900007
148# define HAVE_UTMPX_H
149# endif
150#endif
151
152#if defined(R__AIX) || defined(R__FBSD) || \
153 defined(R__OBSD) || defined(R__LYNXOS) || \
154 (defined(R__MACOSX) && !defined(MAC_OS_X_VERSION_10_5))
155# define UTMP_NO_ADDR
156#endif
157
158#if defined(R__LYNXOS)
159extern "C" {
160 extern int putenv(const char *);
161 extern int inet_aton(const char *, struct in_addr *);
162};
163#endif
164
165#if defined(R__ARC4_STDLIB)
166// do nothing, stdlib.h already included
167#elif defined(R__ARC4_BSDLIB)
168#include <bsd/stdlib.h>
169#elif defined(R__GETRANDOM_CLIB)
170#include <sys/random.h>
171#endif
172
173#ifdef HAVE_UTMPX_H
174#include <utmpx.h>
175#define STRUCT_UTMP struct utmpx
176#else
177#include <utmp.h>
178#define STRUCT_UTMP struct utmp
179#endif
180#if !defined(UTMP_FILE) && defined(_PATH_UTMP) // 4.4BSD
181#define UTMP_FILE _PATH_UTMP
182#endif
183#if defined(UTMPX_FILE) // Solaris, SysVr4
184#undef UTMP_FILE
185#define UTMP_FILE UTMPX_FILE
186#endif
187#ifndef UTMP_FILE
188#define UTMP_FILE "/etc/utmp"
189#endif
190
191// stack trace code
192#if (defined(R__LINUX) || defined(R__HURD)) && !defined(R__WINGCC)
193# if __GLIBC__ == 2 && __GLIBC_MINOR__ >= 1
194# define HAVE_BACKTRACE_SYMBOLS_FD
195# endif
196# define HAVE_DLADDR
197#endif
198#if defined(R__MACOSX) || defined(R__FBSD)
199# define HAVE_BACKTRACE_SYMBOLS_FD
200# define HAVE_DLADDR
201#endif
202
203#ifdef HAVE_BACKTRACE_SYMBOLS_FD
204# include <execinfo.h>
205#endif
206#ifdef HAVE_DLADDR
207# ifndef __USE_GNU
208# define __USE_GNU
209# endif
210# include <dlfcn.h>
211#endif
212
213#ifdef HAVE_BACKTRACE_SYMBOLS_FD
214 // The maximum stack trace depth for systems where we request the
215 // stack depth separately (currently glibc-based systems).
216 static const int kMAX_BACKTRACE_DEPTH = 128;
217#endif
218
219// FPE handling includes
220#if (defined(R__LINUX) && !defined(R__WINGCC))
221#include <cfenv>
222#include <sys/prctl.h> // for prctl() function used in StackTrace()
223#endif
224
225#if defined(R__MACOSX) && defined(__SSE2__)
226#include <xmmintrin.h>
227#endif
228
229#if defined(R__MACOSX) && !defined(__SSE2__) && !defined(__xlC__) && \
230 !defined(__i386__) && !defined(__x86_64__) && !defined(__arm__) && \
231 !defined(__arm64__)
232#include <cfenv>
233#include <csignal>
234#include <ucontext.h>
235#include <cstdlib>
236#include <cstdio>
237#include <mach/thread_status.h>
238
239#define fegetenvd(x) asm volatile("mffs %0" : "=f" (x));
240#define fesetenvd(x) asm volatile("mtfsf 255,%0" : : "f" (x));
241
242enum {
243 FE_ENABLE_INEXACT = 0x00000008,
244 FE_ENABLE_DIVBYZERO = 0x00000010,
245 FE_ENABLE_UNDERFLOW = 0x00000020,
246 FE_ENABLE_OVERFLOW = 0x00000040,
247 FE_ENABLE_INVALID = 0x00000080,
248 FE_ENABLE_ALL_EXCEPT = 0x000000F8
249};
250#endif
251
252#if defined(R__MACOSX) && !defined(__SSE2__) && \
253 (defined(__i386__) || defined(__x86_64__) || defined(__arm__) || defined(__arm64__))
254#include <cfenv>
255#endif
256// End FPE handling includes
257
258namespace {
259 // Depending on the platform the struct utmp (or utmpx) has either ut_name or ut_user
260 // which are semantically equivalent. Instead of using preprocessor magic,
261 // which is bothersome for cxx modules use SFINAE.
262
263 template<typename T>
264 struct ut_name {
265 template<typename U = T, typename std::enable_if<std::is_member_pointer<decltype(&U::ut_name)>::value, int>::type = 0>
266 static char getValue(U* ue, int) {
267 return ue->ut_name[0];
268 }
269
270 template<typename U = T, typename std::enable_if<std::is_member_pointer<decltype(&U::ut_user)>::value, int>::type = 0>
271 static char getValue(U* ue, long) {
272 return ue->ut_user[0];
273 }
274 };
275
276 static char get_ut_name(STRUCT_UTMP *ue) {
277 // 0 is an integer literal forcing an overload pickup in case both ut_name and ut_user are present.
278 return ut_name<STRUCT_UTMP>::getValue(ue, 0);
279 }
280}
281
284 UInt_t fEntries; // Number of entries in utmp file.
285
288
290 {
291 // Look for utmp entry which is connected to terminal tty.
292
294
295 UInt_t n = fEntries;
296 while (n--) {
297 if (get_ut_name(ue) && !strncmp(tty, ue->ut_line, sizeof(ue->ut_line)))
298 return ue;
299 ue++;
300 }
301 return nullptr;
302 }
303
305 {
306 // Read utmp file. Returns number of entries in utmp file.
307
308 FILE *utmp;
309 struct stat file_stats;
310 size_t n_read, size;
311
312 fEntries = 0;
313
315
316 utmp = fopen(UTMP_FILE, "r");
317 if (!utmp)
318 return 0;
319
320 if (fstat(fileno(utmp), &file_stats) == -1) {
321 fclose(utmp);
322 return 0;
323 }
324 size = file_stats.st_size;
325 if (size <= 0) {
326 fclose(utmp);
327 return 0;
328 }
329
331 if (!fUtmpContents) {
332 fclose(utmp);
333 return 0;
334 }
335
337 if (!ferror(utmp)) {
338 if (fclose(utmp) != EOF && n_read == size) {
339 fEntries = size / sizeof(STRUCT_UTMP);
340 return fEntries;
341 }
342 } else
343 fclose(utmp);
344
346 fUtmpContents = nullptr;
347 return 0;
348 }
349
350};
351
352const char *kServerPath = "/tmp";
353const char *kProtocolName = "tcp";
354
355//------------------- Unix TFdSet ----------------------------------------------
356#ifndef HOWMANY
357# define HOWMANY(x, y) (((x)+((y)-1))/(y))
358#endif
359
360const Int_t kNFDBITS = (sizeof(Long_t) * 8); // 8 bits per byte
361#ifdef FD_SETSIZE
362const Int_t kFDSETSIZE = FD_SETSIZE; // Linux = 1024 file descriptors
363#else
364const Int_t kFDSETSIZE = 256; // upto 256 file descriptors
365#endif
366
367
368class TFdSet {
369private:
371public:
372 TFdSet() { memset(fds_bits, 0, sizeof(fds_bits)); }
373 TFdSet(const TFdSet &org) { memcpy(fds_bits, org.fds_bits, sizeof(org.fds_bits)); }
374 TFdSet &operator=(const TFdSet &rhs) { if (this != &rhs) { memcpy(fds_bits, rhs.fds_bits, sizeof(rhs.fds_bits));} return *this; }
375 void Zero() { memset(fds_bits, 0, sizeof(fds_bits)); }
376 void Set(Int_t n)
377 {
378 if (n >= 0 && n < kFDSETSIZE) {
379 fds_bits[n/kNFDBITS] |= (1UL << (n % kNFDBITS));
380 } else {
381 ::Fatal("TFdSet::Set","fd (%d) out of range [0..%d]", n, kFDSETSIZE-1);
382 }
383 }
384 void Clr(Int_t n)
385 {
386 if (n >= 0 && n < kFDSETSIZE) {
387 fds_bits[n/kNFDBITS] &= ~(1UL << (n % kNFDBITS));
388 } else {
389 ::Fatal("TFdSet::Clr","fd (%d) out of range [0..%d]", n, kFDSETSIZE-1);
390 }
391 }
393 {
394 if (n >= 0 && n < kFDSETSIZE) {
395 return (fds_bits[n/kNFDBITS] & (1UL << (n % kNFDBITS))) != 0;
396 } else {
397 ::Fatal("TFdSet::IsSet","fd (%d) out of range [0..%d]", n, kFDSETSIZE-1);
398 return 0;
399 }
400 }
401 ULong_t *GetBits() { return (ULong_t *)fds_bits; }
402};
403
404////////////////////////////////////////////////////////////////////////////////
405/// Unix signal handler.
406
407static void SigHandler(ESignals sig)
408{
409 if (gSystem)
410 ((TUnixSystem*)gSystem)->DispatchSignals(sig);
411}
412
413////////////////////////////////////////////////////////////////////////////////
414
415static const char *GetExePath()
416{
418 if (exepath == "") {
419#if defined(R__MACOSX)
421#elif defined(R__LINUX) || defined(R__SOLARIS) || defined(R__FBSD)
422 char buf[kMAXPATHLEN]=""; // exe path name
423
424 // get the name from the link in /proc
425#if defined(R__LINUX)
426 int ret = readlink("/proc/self/exe", buf, kMAXPATHLEN);
427#elif defined(R__SOLARIS)
428 int ret = readlink("/proc/self/path/a.out", buf, kMAXPATHLEN);
429#elif defined(R__FBSD)
432
433 int ret{0};
434 if (kp!=NULL) {
435 procstat_getpathname(ps, kp, buf, sizeof(buf));
436 }
437 free(kp);
438 procstat_close(ps);
439 exepath = buf;
440#endif
441 if (ret > 0 && ret < kMAXPATHLEN) {
442 buf[ret] = 0;
443 exepath = buf;
444 }
445#else
446 if (!gApplication)
447 return exepath;
449 if (p.BeginsWith("/"))
450 exepath = p;
451 else if (p.Contains("/")) {
453 exepath += "/";
454 exepath += p;
455 } else {
456 char *exe = gSystem->Which(gSystem->Getenv("PATH"), p, kExecutePermission);
457 if (exe) {
458 exepath = exe;
459 delete [] exe;
460 }
461 }
462#endif
463 }
464 return exepath;
465}
466
467#if defined(HAVE_DLADDR) && !defined(R__MACOSX)
468////////////////////////////////////////////////////////////////////////////////
469
470static void SetRootSys()
471{
472#ifdef ROOTPREFIX
473 if (gSystem->Getenv("ROOTIGNOREPREFIX")) {
474#endif
475 void *addr = (void *)SetRootSys;
477 if (dladdr(addr, &info) && info.dli_fname && info.dli_fname[0]) {
478 char respath[kMAXPATHLEN];
479 if (!realpath(info.dli_fname, respath)) {
480 if (!gSystem->Getenv("ROOTSYS"))
481 ::SysError("TUnixSystem::SetRootSys", "error getting realpath of libCore, please set ROOTSYS in the shell");
482 } else {
484 gSystem->Setenv("ROOTSYS", gSystem->GetDirName(rs.Data()).Data());
485 }
486 }
487#ifdef ROOTPREFIX
488 }
489#endif
490}
491#endif
492
493#if defined(R__MACOSX)
495
496////////////////////////////////////////////////////////////////////////////////
497
498static void DylibAdded(const struct mach_header *mh, intptr_t /* vmaddr_slide */)
499{
500 static int i = 0;
501 static Bool_t gotFirstSo = kFALSE;
502 static TString linkedDylibs;
503
504 // to copy the local linkedDylibs to the global gLinkedDylibs call this
505 // function with mh==0
506 if (!mh) {
508 return;
509 }
510
511 TString lib = _dyld_get_image_name(i++);
512
513 TRegexp sovers = "libCore\\.[0-9]+\\.*[0-9]*\\.*[0-9]*\\.so";
514 TRegexp dyvers = "libCore\\.[0-9]+\\.*[0-9]*\\.*[0-9]*\\.dylib";
515
516#ifdef ROOTPREFIX
517 if (gSystem->Getenv("ROOTIGNOREPREFIX")) {
518#endif
519 if (lib.EndsWith("libCore.dylib") || lib.EndsWith("libCore.so") ||
520 lib.Index(sovers) != kNPOS || lib.Index(dyvers) != kNPOS) {
521 char respath[kMAXPATHLEN];
522 if (!realpath(lib, respath)) {
523 if (!gSystem->Getenv("ROOTSYS"))
524 ::SysError("TUnixSystem::DylibAdded", "error getting realpath of libCore, please set ROOTSYS in the shell");
525 } else {
527 gSystem->Setenv("ROOTSYS", gSystem->GetDirName(rs.Data()).Data());
528 }
529 }
530#ifdef ROOTPREFIX
531 }
532#endif
533
534 // when libSystem.B.dylib is loaded we have finished loading all dylibs
535 // explicitly linked against the executable. Additional dylibs
536 // come when they are explicitly linked against loaded so's, currently
537 // we are not interested in these
538 if (lib.EndsWith("/libSystem.B.dylib")) {
540 if (linkedDylibs.IsNull()) {
541 // TSystem::GetLibraries() assumes that an empty GetLinkedLibraries()
542 // means failure to extract the linked libraries. Signal "we did
543 // manage, but it's empty" by returning a single space.
544 linkedDylibs = ' ';
545 }
546 }
547
548 // add all libs loaded before libSystem.B.dylib
549 if (!gotFirstSo && (lib.EndsWith(".dylib") || lib.EndsWith(".so"))) {
550 sovers = "\\.[0-9]+\\.*[0-9]*\\.so";
551 Ssiz_t idx = lib.Index(sovers);
552 if (idx != kNPOS) {
553 lib.Remove(idx);
554 lib += ".so";
555 }
556 dyvers = "\\.[0-9]+\\.*[0-9]*\\.dylib";
557 idx = lib.Index(dyvers);
558 if (idx != kNPOS) {
559 lib.Remove(idx);
560 lib += ".dylib";
561 }
563 if (linkedDylibs.Length())
564 linkedDylibs += " ";
565 linkedDylibs += lib;
566 }
567 }
568}
569#endif
570
571
572////////////////////////////////////////////////////////////////////////////////
573
574TUnixSystem::TUnixSystem() : TSystem("Unix", "Unix System")
575{ }
576
577////////////////////////////////////////////////////////////////////////////////
578/// Reset to original state.
579
581{
583
584 delete fReadmask;
585 delete fWritemask;
586 delete fReadready;
587 delete fWriteready;
588 delete fSignals;
589}
590
591////////////////////////////////////////////////////////////////////////////////
592/// Initialize Unix system interface.
593
595{
596 if (TSystem::Init())
597 return kTRUE;
598
599 fReadmask = new TFdSet;
600 fWritemask = new TFdSet;
601 fReadready = new TFdSet;
602 fWriteready = new TFdSet;
603 fSignals = new TFdSet;
604
605 //--- install default handlers
617
618#if defined(R__MACOSX)
619 // trap loading of all dylibs to register dylib name,
620 // sets also ROOTSYS if built without ROOTPREFIX
622#elif defined(HAVE_DLADDR)
623 SetRootSys();
624#endif
625
626 // This is a fallback in case TROOT::GetRootSys() can't determine ROOTSYS
628
629 return kFALSE;
630}
631
632//---- Misc --------------------------------------------------------------------
633
634////////////////////////////////////////////////////////////////////////////////
635/// Set the application name (from command line, argv[0]) and copy it in
636/// gProgName. Copy the application pathname in gProgPath.
637/// If name is 0 let the system set the actual executable name and path
638/// (works on MacOS X and Linux).
639
641{
642 if (gProgName)
643 delete [] gProgName;
644 if (gProgPath)
645 delete [] gProgPath;
646
647 if (!name || !*name) {
648 name = GetExePath();
651 } else {
653 char *w = Which(Getenv("PATH"), gProgName);
655 delete [] w;
656 }
657}
658
659////////////////////////////////////////////////////////////////////////////////
660/// Set DISPLAY environment variable based on utmp entry. Only for UNIX.
661
663{
664 if (!Getenv("DISPLAY")) {
665 char *tty = ::ttyname(0); // device user is logged in on
666 if (tty) {
667 tty += 5; // remove "/dev/"
668
670 utmp.ReadUtmpFile();
671
672 STRUCT_UTMP *utmp_entry = utmp.SearchUtmpEntry(tty);
673 if (utmp_entry) {
674 if (utmp_entry->ut_host[0]) {
676 for (unsigned n = 0; (n < sizeof(utmp_entry->ut_host)) && utmp_entry->ut_host[n]; n++)
677 disp.Append(utmp_entry->ut_host[n]);
678 if (disp.First(':') == kNPOS)
679 disp.Append(":0.0");
680 Setenv("DISPLAY", disp.Data());
681 Warning("SetDisplay", "DISPLAY not set, setting it to %s", disp.Data());
682 }
683#ifndef UTMP_NO_ADDR
684 else if (utmp_entry->ut_addr) {
685
686 struct sockaddr_in addr;
687 addr.sin_family = AF_INET;
688 addr.sin_port = 0;
689 memcpy(&addr.sin_addr, &utmp_entry->ut_addr, sizeof(addr.sin_addr));
690 memset(&addr.sin_zero[0], 0, sizeof(addr.sin_zero));
691 struct sockaddr *sa = (struct sockaddr *) &addr; // input
692
693 char hbuf[NI_MAXHOST + 4];
694 if (getnameinfo(sa, sizeof(struct sockaddr), hbuf, sizeof(hbuf), nullptr, 0, NI_NAMEREQD) == 0) {
696 strlcat(hbuf, ":0.0", sizeof(hbuf));
697 Setenv("DISPLAY", hbuf);
698 Warning("SetDisplay", "DISPLAY not set, setting it to %s",
699 hbuf);
700 }
701 }
702#endif
703 }
704 }
705#ifndef R__HAS_COCOA
706 if (!gROOT->IsBatch() && !std::getenv("DISPLAY")) {
707 Error("SetDisplay", "Can't figure out DISPLAY, set it manually\n"
708 "In case you run a remote ssh session, restart your ssh session with:\n"
709 "=========> ssh -Y");
710 }
711#endif
712 }
713}
714
715////////////////////////////////////////////////////////////////////////////////
716/// Return system error string.
717
719{
720 Int_t err = GetErrno();
721 if (err == 0 && GetLastErrorString() != "")
722 return GetLastErrorString();
723
724#if defined(R__SOLARIS) || defined (R__LINUX) || defined(R__AIX) || \
725 defined(R__FBSD) || defined(R__OBSD) || defined(R__HURD)
726 return strerror(err);
727#else
729 return Form("errno out of range %d", err);
730 return sys_errlist[err];
731#endif
732}
733
734////////////////////////////////////////////////////////////////////////////////
735/// Return cryptographic random number
736/// Fill provided buffer with random values
737/// Returns number of bytes written to buffer or -1 in case of error
738
740{
741#if defined(R__ARC4_STDLIB) || defined(R__ARC4_BSDLIB)
742 arc4random_buf(buf, len);
743 return len;
744#elif defined(R__GETRANDOM_CLIB)
745 return getrandom(buf, len, GRND_NONBLOCK);
746#elif defined(R__USE_URANDOM)
747 std::ifstream urandom{"/dev/urandom"};
748 if (!urandom)
749 return -1;
750 urandom.read(reinterpret_cast<char *>(buf), len);
751 return len;
752#else
753#error "Reliable cryptographic random function not defined"
754 return -1;
755#endif
756}
757
758////////////////////////////////////////////////////////////////////////////////
759/// Return the system's host name.
760
762{
763 if (fHostname == "") {
764 char hn[64];
765#if defined(R__SOLARIS)
766 sysinfo(SI_HOSTNAME, hn, sizeof(hn));
767#else
768 gethostname(hn, sizeof(hn));
769#endif
770 fHostname = hn;
771 }
772 return (const char *)fHostname;
773}
774
775//---- EventLoop ---------------------------------------------------------------
776
777////////////////////////////////////////////////////////////////////////////////
778/// Add a file handler to the list of system file handlers. Only adds
779/// the handler if it is not already in the list of file handlers.
780
782{
784
786 if (h) {
787 int fd = h->GetFd();
788 if (h->HasReadInterest()) {
789 fReadmask->Set(fd);
790 fMaxrfd = std::max(fMaxrfd, fd);
791 }
792 if (h->HasWriteInterest()) {
793 fWritemask->Set(fd);
794 fMaxwfd = std::max(fMaxwfd, fd);
795 }
796 }
797}
798
799////////////////////////////////////////////////////////////////////////////////
800/// Remove a file handler from the list of file handlers. Returns
801/// the handler or 0 if the handler was not in the list of file handlers.
802
804{
805 if (!h) return nullptr;
806
808
810 if (oh) { // found
811 TFileHandler *th;
812 TIter next(fFileHandler);
813 fMaxrfd = -1;
814 fMaxwfd = -1;
815 fReadmask->Zero();
816 fWritemask->Zero();
817 while ((th = (TFileHandler *) next())) {
818 int fd = th->GetFd();
819 if (th->HasReadInterest()) {
820 fReadmask->Set(fd);
821 fMaxrfd = std::max(fMaxrfd, fd);
822 }
823 if (th->HasWriteInterest()) {
824 fWritemask->Set(fd);
825 fMaxwfd = std::max(fMaxwfd, fd);
826 }
827 }
828 }
829 return oh;
830}
831
832////////////////////////////////////////////////////////////////////////////////
833/// Add a signal handler to list of system signal handlers. Only adds
834/// the handler if it is not already in the list of signal handlers.
835
843
844////////////////////////////////////////////////////////////////////////////////
845/// Remove a signal handler from list of signal handlers. Returns
846/// the handler or 0 if the handler was not in the list of signal handlers.
847
849{
850 if (!h) return nullptr;
851
853
855
856 Bool_t last = kTRUE;
858 TIter next(fSignalHandler);
859
860 while ((hs = (TSignalHandler*) next())) {
861 if (hs->GetSignal() == h->GetSignal())
862 last = kFALSE;
863 }
864 if (last)
865 ResetSignal(h->GetSignal(), kTRUE);
866
867 return oh;
868}
869
870////////////////////////////////////////////////////////////////////////////////
871/// If reset is true reset the signal handler for the specified signal
872/// to the default handler, else restore previous behaviour.
873
875{
876 if (reset)
877 UnixResetSignal(sig);
878 else
880}
881
882////////////////////////////////////////////////////////////////////////////////
883/// Reset signals handlers to previous behaviour.
884
889
890////////////////////////////////////////////////////////////////////////////////
891/// If ignore is true ignore the specified signal, else restore previous
892/// behaviour.
893
898
899////////////////////////////////////////////////////////////////////////////////
900/// When the argument is true the SIGALRM signal handler is set so that
901/// interrupted syscalls will not be restarted by the kernel. This is
902/// typically used in case one wants to put a timeout on an I/O operation.
903/// By default interrupted syscalls will always be restarted (for all
904/// signals). This can be controlled for each a-synchronous TTimer via
905/// the method TTimer::SetInterruptSyscalls().
906
911
912////////////////////////////////////////////////////////////////////////////////
913/// Return the bitmap of conditions that trigger a floating point exception.
914
916{
917 Int_t mask = 0;
918
919#if defined(R__LINUX) && !defined(__powerpc__)
920#if defined(__GLIBC__) && (__GLIBC__>2 || __GLIBC__==2 && __GLIBC_MINOR__>=1)
921
922#if __GLIBC_MINOR__>=3
923
925
926#else
930#if __ia64__
932#else
933 Int_t oldmask = ~oldenv.__control_word;
934#endif
935#endif
936
937 if (oldmask & FE_INVALID ) mask |= kInvalid;
941# ifdef FE_INEXACT
942 if (oldmask & FE_INEXACT ) mask |= kInexact;
943# endif
944#endif
945#endif
946
947#if defined(R__MACOSX) && defined(__SSE2__)
948 // OS X uses the SSE unit for all FP math by default, not the x87 FP unit
950
956#endif
957
958#if defined(R__MACOSX) && !defined(__SSE2__) && \
959 (defined(__i386__) || defined(__x86_64__) || defined(__arm__) || defined(__arm64__))
963#if defined(__arm__)
964 Int_t oldmask = ~oldenv.__fpscr;
965#elif defined(__arm64__)
966 Int_t oldmask = ~oldenv.__fpcr;
967#else
968 Int_t oldmask = ~oldenv.__control;
969#endif
970
971 if (oldmask & FE_INVALID ) mask |= kInvalid;
975 if (oldmask & FE_INEXACT ) mask |= kInexact;
976#endif
977
978#if defined(R__MACOSX) && !defined(__SSE2__) && !defined(__xlC__) && \
979 !defined(__i386__) && !defined(__x86_64__) && !defined(__arm__) && \
980 !defined(__arm64__)
983
989#endif
990
991 return mask;
992}
993
994////////////////////////////////////////////////////////////////////////////////
995/// Set which conditions trigger a floating point exception.
996/// Return the previous set of conditions.
997
999{
1000 if (mask) { } // use mask to avoid warning
1001
1002 Int_t old = GetFPEMask();
1003
1004#if defined(R__LINUX) && !defined(__powerpc__)
1005#if defined(__GLIBC__) && (__GLIBC__>2 || __GLIBC__==2 && __GLIBC_MINOR__>=1)
1006 Int_t newm = 0;
1007 if (mask & kInvalid ) newm |= FE_INVALID;
1008 if (mask & kDivByZero) newm |= FE_DIVBYZERO;
1009 if (mask & kOverflow ) newm |= FE_OVERFLOW;
1010 if (mask & kUnderflow) newm |= FE_UNDERFLOW;
1011# ifdef FE_INEXACT
1012 if (mask & kInexact ) newm |= FE_INEXACT;
1013# endif
1014
1015#if __GLIBC_MINOR__>=3
1016
1017 // clear pending exceptions so feenableexcept does not trigger them
1021
1022#else
1023
1024 fenv_t cur;
1025 fegetenv(&cur);
1026#if defined __ia64__
1027 cur &= ~newm;
1028#else
1029 cur.__control_word &= ~newm;
1030#endif
1031 fesetenv(&cur);
1032
1033#endif
1034#endif
1035#endif
1036
1037#if defined(R__MACOSX) && defined(__SSE2__)
1038 // OS X uses the SSE unit for all FP math by default, not the x87 FP unit
1039 Int_t newm = 0;
1045
1047#endif
1048
1049#if defined(R__MACOSX) && !defined(__SSE2__) && \
1050 (defined(__i386__) || defined(__x86_64__) || defined(__arm__) || defined(__arm64__))
1051 Int_t newm = 0;
1052 if (mask & kInvalid ) newm |= FE_INVALID;
1053 if (mask & kDivByZero) newm |= FE_DIVBYZERO;
1054 if (mask & kOverflow ) newm |= FE_OVERFLOW;
1055 if (mask & kUnderflow) newm |= FE_UNDERFLOW;
1056 if (mask & kInexact ) newm |= FE_INEXACT;
1057
1058 fenv_t cur;
1059 fegetenv(&cur);
1060#if defined(__arm__)
1061 cur.__fpscr &= ~newm;
1062#elif defined(__arm64__)
1063 cur.__fpcr &= ~newm;
1064#else
1065 cur.__control &= ~newm;
1066#endif
1067 fesetenv(&cur);
1068#endif
1069
1070#if defined(R__MACOSX) && !defined(__SSE2__) && !defined(__xlC__) && \
1071 !defined(__i386__) && !defined(__x86_64__) && !defined(__arm__) && \
1072 !defined(__arm64__)
1073 Int_t newm = 0;
1079
1084#endif
1085
1086 return old;
1087}
1088
1089////////////////////////////////////////////////////////////////////////////////
1090/// Dispatch a single event.
1091
1093{
1095
1096 while (1) {
1097 // first handle any X11 events
1098 if (gXDisplay && gXDisplay->Notify()) {
1099 if (fReadready->IsSet(gXDisplay->GetFd())) {
1101 fNfd--;
1102 }
1103 if (!pendingOnly) return;
1104 }
1105
1106 // check for file descriptors ready for reading/writing
1107 if (fNfd > 0 && fFileHandler && fFileHandler->GetSize() > 0)
1108 if (CheckDescriptors())
1109 if (!pendingOnly) return;
1110 fNfd = 0;
1111 fReadready->Zero();
1112 fWriteready->Zero();
1113
1114 if (pendingOnly && !pollOnce)
1115 return;
1116
1117 // check synchronous signals
1118 if (fSigcnt > 0 && fSignalHandler->GetSize() > 0)
1119 if (CheckSignals(kTRUE))
1120 if (!pendingOnly) return;
1121 fSigcnt = 0;
1122 fSignals->Zero();
1123
1124 // check synchronous timers
1125 Long_t nextto;
1126 if (fTimers && fTimers->GetSize() > 0)
1127 if (DispatchTimers(kTRUE)) {
1128 // prevent timers from blocking file descriptor monitoring
1130 if (nextto > kItimerResolution || nextto == -1)
1131 return;
1132 }
1133
1134 // if in pendingOnly mode poll once file descriptor activity
1136 if (pendingOnly) {
1137 if (fFileHandler && fFileHandler->GetSize() == 0)
1138 return;
1139 nextto = 0;
1140 pollOnce = kFALSE;
1141 }
1142
1143 // nothing ready, so setup select call
1146
1147 int mxfd = std::max(fMaxrfd, fMaxwfd);
1148 mxfd++;
1149
1150 // if nothing to select (socket or timer) return
1151 if (mxfd == 0 && nextto == -1)
1152 return;
1153
1155 if (fNfd < 0 && fNfd != -2) {
1156 int fd, rc;
1157 TFdSet t;
1158 for (fd = 0; fd < mxfd; fd++) {
1159 t.Set(fd);
1160 if (fReadmask->IsSet(fd)) {
1161 rc = UnixSelect(fd+1, &t, nullptr, 0);
1162 if (rc < 0 && rc != -2) {
1163 SysError("DispatchOneEvent", "select: read error on %d", fd);
1164 fReadmask->Clr(fd);
1165 }
1166 }
1167 if (fWritemask->IsSet(fd)) {
1168 rc = UnixSelect(fd+1, nullptr, &t, 0);
1169 if (rc < 0 && rc != -2) {
1170 SysError("DispatchOneEvent", "select: write error on %d", fd);
1171 fWritemask->Clr(fd);
1172 }
1173 }
1174 t.Clr(fd);
1175 }
1176 }
1177 }
1178}
1179
1180////////////////////////////////////////////////////////////////////////////////
1181/// Sleep milliSec milliseconds.
1182
1184{
1185 struct timeval tv;
1186
1187 tv.tv_sec = milliSec / 1000;
1188 tv.tv_usec = (milliSec % 1000) * 1000;
1189
1190 select(0, nullptr, nullptr, nullptr, &tv);
1191}
1192
1193////////////////////////////////////////////////////////////////////////////////
1194/// Select on file descriptors. The timeout to is in millisec. Returns
1195/// the number of ready descriptors, or 0 in case of timeout, or < 0 in
1196/// case of an error, with -2 being EINTR and -3 EBADF. In case of EINTR
1197/// the errno has been reset and the method can be called again. Returns
1198/// -4 in case the list did not contain any file handlers or file handlers
1199/// with file descriptor >= 0.
1200
1202{
1203 Int_t rc = -4;
1204
1205 TFdSet rd, wr;
1206 Int_t mxfd = -1;
1207 TIter next(act);
1208 TFileHandler *h = nullptr;
1209 while ((h = (TFileHandler *) next())) {
1210 Int_t fd = h->GetFd();
1211 if (fd > -1) {
1212 if (h->HasReadInterest()) {
1213 rd.Set(fd);
1214 mxfd = std::max(mxfd, fd);
1215 }
1216 if (h->HasWriteInterest()) {
1217 wr.Set(fd);
1218 mxfd = std::max(mxfd, fd);
1219 }
1220 h->ResetReadyMask();
1221 }
1222 }
1223 if (mxfd > -1)
1224 rc = UnixSelect(mxfd+1, &rd, &wr, to);
1225
1226 // Set readiness bits
1227 if (rc > 0) {
1228 next.Reset();
1229 while ((h = (TFileHandler *) next())) {
1230 Int_t fd = h->GetFd();
1231 if (rd.IsSet(fd))
1232 h->SetReadReady();
1233 if (wr.IsSet(fd))
1234 h->SetWriteReady();
1235 }
1236 }
1237
1238 return rc;
1239}
1240
1241////////////////////////////////////////////////////////////////////////////////
1242/// Select on the file descriptor related to file handler h.
1243/// The timeout to is in millisec. Returns the number of ready descriptors,
1244/// or 0 in case of timeout, or < 0 in case of an error, with -2 being EINTR
1245/// and -3 EBADF. In case of EINTR the errno has been reset and the method
1246/// can be called again. Returns -4 in case the file handler is 0 or does
1247/// not have a file descriptor >= 0.
1248
1250{
1251 Int_t rc = -4;
1252
1253 TFdSet rd, wr;
1254 Int_t mxfd = -1;
1255 Int_t fd = -1;
1256 if (h) {
1257 fd = h->GetFd();
1258 if (fd > -1) {
1259 if (h->HasReadInterest())
1260 rd.Set(fd);
1261 if (h->HasWriteInterest())
1262 wr.Set(fd);
1263 h->ResetReadyMask();
1264 mxfd = fd;
1265 rc = UnixSelect(mxfd+1, &rd, &wr, to);
1266 }
1267 }
1268
1269 // Fill output lists, if required
1270 if (rc > 0) {
1271 if (rd.IsSet(fd))
1272 h->SetReadReady();
1273 if (wr.IsSet(fd))
1274 h->SetWriteReady();
1275 }
1276
1277 return rc;
1278}
1279
1280//---- handling of system events -----------------------------------------------
1281
1282////////////////////////////////////////////////////////////////////////////////
1283/// Check if some signals were raised and call their Notify() member.
1284
1286{
1288 Int_t sigdone = -1;
1289 {
1291
1292 while ((sh = (TSignalHandler*)it.Next())) {
1293 if (sync == sh->IsSync()) {
1294 ESignals sig = sh->GetSignal();
1295 if ((fSignals->IsSet(sig) && sigdone == -1) || sigdone == sig) {
1296 if (sigdone == -1) {
1297 fSignals->Clr(sig);
1298 sigdone = sig;
1299 fSigcnt--;
1300 }
1301 if (sh->IsActive())
1302 sh->Notify();
1303 }
1304 }
1305 }
1306 }
1307 if (sigdone != -1)
1308 return kTRUE;
1309
1310 return kFALSE;
1311}
1312
1313////////////////////////////////////////////////////////////////////////////////
1314/// Check if children have finished.
1315
1317{
1318#if 0 //rdm
1319 int pid;
1320 while ((pid = UnixWaitchild()) > 0) {
1321 TIter next(zombieHandler);
1322 register UnixPtty *pty;
1323 while ((pty = (UnixPtty*) next()))
1324 if (pty->GetPid() == pid) {
1325 zombieHandler->RemovePtr(pty);
1326 pty->DiedNotify();
1327 }
1328 }
1329#endif
1330}
1331
1332////////////////////////////////////////////////////////////////////////////////
1333/// Check if there is activity on some file descriptors and call their
1334/// Notify() member.
1335
1337{
1338 TFileHandler *fh;
1339 Int_t fddone = -1;
1340 Bool_t read = kFALSE;
1342 while ((fh = (TFileHandler*) it.Next())) {
1343 Int_t fd = fh->GetFd();
1344 if ((fd <= fMaxrfd && fReadready->IsSet(fd) && fddone == -1) ||
1345 (fddone == fd && read)) {
1346 if (fddone == -1) {
1347 fReadready->Clr(fd);
1348 fddone = fd;
1349 read = kTRUE;
1350 fNfd--;
1351 }
1352 if (fh->IsActive())
1353 fh->ReadNotify();
1354 }
1355 if ((fd <= fMaxwfd && fWriteready->IsSet(fd) && fddone == -1) ||
1356 (fddone == fd && !read)) {
1357 if (fddone == -1) {
1358 fWriteready->Clr(fd);
1359 fddone = fd;
1360 read = kFALSE;
1361 fNfd--;
1362 }
1363 if (fh->IsActive())
1364 fh->WriteNotify();
1365 }
1366 }
1367 if (fddone != -1)
1368 return kTRUE;
1369
1370 return kFALSE;
1371}
1372
1373//---- Directories -------------------------------------------------------------
1374
1375////////////////////////////////////////////////////////////////////////////////
1376/// Make a Unix file system directory. Returns 0 in case of success and
1377/// -1 if the directory could not be created.
1378
1380{
1382 if (helper)
1383 return helper->MakeDirectory(name);
1384
1385 return UnixMakedir(name);
1386}
1387
1388////////////////////////////////////////////////////////////////////////////////
1389/// Open a Unix file system directory. Returns 0 if directory does not exist.
1390
1392{
1394 if (helper)
1395 return helper->OpenDirectory(name);
1396
1397 return UnixOpendir(name);
1398}
1399
1400////////////////////////////////////////////////////////////////////////////////
1401/// Close a Unix file system directory.
1402
1404{
1405 TSystem *helper = FindHelper(nullptr, dirp);
1406 if (helper) {
1407 helper->FreeDirectory(dirp);
1408 return;
1409 }
1410
1411 if (dirp)
1412 ::closedir((DIR*)dirp);
1413}
1414
1415////////////////////////////////////////////////////////////////////////////////
1416/// Get next Unix file system directory entry. Returns 0 if no more entries.
1417
1419{
1420 TSystem *helper = FindHelper(nullptr, dirp);
1421 if (helper)
1422 return helper->GetDirEntry(dirp);
1423
1424 if (dirp)
1425 return UnixGetdirentry(dirp);
1426
1427 return nullptr;
1428}
1429
1430////////////////////////////////////////////////////////////////////////////////
1431/// Change directory. Returns kTRUE in case of success, kFALSE otherwise.
1432
1434{
1435 Bool_t ret = (Bool_t) (::chdir(path) == 0);
1436 if (fWdpath != "")
1437 fWdpath = ""; // invalidate path cache
1438 return ret;
1439}
1440
1441////////////////////////////////////////////////////////////////////////////////
1442/// Return working directory.
1443
1445{
1446 // don't use cache as user can call chdir() directly somewhere else
1447 //if (fWdpath != "")
1448 // return fWdpath.Data();
1449
1451
1452 static char cwd[kMAXPATHLEN];
1454 fWdpath = cwd;
1455
1456 return fWdpath.Data();
1457}
1458
1459//////////////////////////////////////////////////////////////////////////////
1460/// Return working directory.
1461
1463{
1464 char cwd[kMAXPATHLEN];
1466 return std::string(cwd);
1467}
1468
1469//////////////////////////////////////////////////////////////////////////////
1470/// Fill buffer with current working directory.
1471
1473{
1474 if (::getcwd(cwd, kMAXPATHLEN) == nullptr) {
1475 Error("WorkingDirectory", "getcwd() failed");
1476 }
1477}
1478
1479////////////////////////////////////////////////////////////////////////////////
1480/// Return the user's home directory.
1481
1482const char *TUnixSystem::HomeDirectory(const char *userName)
1483{
1485}
1486
1487//////////////////////////////////////////////////////////////////////////////
1488/// Return the user's home directory.
1489
1490std::string TUnixSystem::GetHomeDirectory(const char *userName) const
1491{
1492 char path[kMAXPATHLEN], mydir[kMAXPATHLEN] = { '\0' };
1493 auto res = UnixHomedirectory(userName, path, mydir);
1494 if (res) return std::string(res);
1495 else return std::string();
1496}
1497
1498////////////////////////////////////////////////////////////////////////////////
1499/// Return a user configured or systemwide directory to create
1500/// temporary files in.
1501
1503{
1504 const char *dir = gSystem->Getenv("TMPDIR");
1505 if (!dir || gSystem->AccessPathName(dir, kWritePermission))
1506 dir = "/tmp";
1507
1508 return dir;
1509}
1510
1511////////////////////////////////////////////////////////////////////////////////
1512/// Create a secure temporary file by appending a unique
1513/// 6 letter string to base. The file will be created in
1514/// a standard (system) directory or in the directory
1515/// provided in dir. Optionally one can provide suffix
1516/// append to the final name - like extension ".txt" or ".html".
1517/// The full filename is returned in base
1518/// and a filepointer is returned for safely writing to the file
1519/// (this avoids certain security problems). Returns 0 in case
1520/// of error.
1521
1522FILE *TUnixSystem::TempFileName(TString &base, const char *dir, const char *suffix)
1523{
1524 char *b = ConcatFileName(dir ? dir : TempDirectory(), base);
1525 base = b;
1526 base += "XXXXXX";
1527 const bool hasSuffix = suffix && *suffix;
1528 if (hasSuffix)
1529 base.Append(suffix);
1530 delete [] b;
1531
1532 char *arg = StrDup(base);
1533 int fd = hasSuffix ? mkstemps(arg, strlen(suffix)) : mkstemp(arg);
1534 base = arg;
1535 delete [] arg;
1536
1537 if (fd == -1) {
1538 SysError("TempFileName", "%s", base.Data());
1539 return nullptr;
1540 } else {
1541 FILE *fp = fdopen(fd, "w+");
1542 if (!fp)
1543 SysError("TempFileName", "converting filedescriptor (%d)", fd);
1544 return fp;
1545 }
1546}
1547
1548////////////////////////////////////////////////////////////////////////////////
1549/// Concatenate a directory and a file name.
1550
1551const char *TUnixSystem::PrependPathName(const char *dir, TString& name)
1552{
1553 if (name.IsNull() || name == ".") {
1554 if (dir) {
1555 name = dir;
1556 if (dir[strlen(dir) - 1] != '/')
1557 name += '/';
1558 } else name = "";
1559 return name.Data();
1560 }
1561
1562 if (!dir || !dir[0])
1563 dir = "/";
1564 else if (dir[strlen(dir) - 1] != '/')
1565 name.Prepend('/');
1566 name.Prepend(dir);
1567
1568 return name.Data();
1569}
1570
1571//---- Paths & Files -----------------------------------------------------------
1572
1573////////////////////////////////////////////////////////////////////////////////
1574/// Returns FALSE if one can access a file using the specified access mode.
1575/// Mode is the same as for the Unix access(2) function.
1576/// Attention, bizarre convention of return value!!
1577
1579{
1580 TSystem *helper = FindHelper(path);
1581 if (helper)
1582 return helper->AccessPathName(path, mode);
1583
1584 if (::access(StripOffProto(path, "file:"), mode) == 0)
1585 return kFALSE;
1587
1588 return kTRUE;
1589}
1590
1591////////////////////////////////////////////////////////////////////////////////
1592/// Copy a file. If overwrite is true and file already exists the
1593/// file will be overwritten. Returns 0 when successful, -1 in case
1594/// of file open failure, -2 in case the file already exists and overwrite
1595/// was false and -3 in case of error during copy.
1596
1597int TUnixSystem::CopyFile(const char *f, const char *t, Bool_t overwrite)
1598{
1599 if (!AccessPathName(t) && !overwrite)
1600 return -2;
1601
1602 FILE *from = fopen(f, "r");
1603 if (!from)
1604 return -1;
1605
1606 FILE *to = fopen(t, "w");
1607 if (!to) {
1608 fclose(from);
1609 return -1;
1610 }
1611
1612 const int bufsize = 1024;
1613 char buf[bufsize];
1614 int ret = 0;
1615 while (!ret && !feof(from)) {
1616 size_t numread = fread (buf, sizeof(char), bufsize, from);
1617 size_t numwritten = fwrite(buf, sizeof(char), numread, to);
1618 if (numread != numwritten)
1619 ret = -3;
1620 }
1621
1622 fclose(from);
1623 fclose(to);
1624
1625 return ret;
1626}
1627
1628////////////////////////////////////////////////////////////////////////////////
1629/// Rename a file. Returns 0 when successful, -1 in case of failure.
1630
1631int TUnixSystem::Rename(const char *f, const char *t)
1632{
1633 int ret = ::rename(f, t);
1635 return ret;
1636}
1637
1638////////////////////////////////////////////////////////////////////////////////
1639/// Returns TRUE if the url in 'path' points to the local file system.
1640/// This is used to avoid going through the NIC card for local operations.
1641
1643{
1644 TSystem *helper = FindHelper(path);
1645 if (helper)
1646 return helper->IsPathLocal(path);
1647
1648 return TSystem::IsPathLocal(path);
1649}
1650
1651////////////////////////////////////////////////////////////////////////////////
1652/// Get info about a file. Info is returned in the form of a FileStat_t
1653/// structure (see TSystem.h).
1654/// The function returns 0 in case of success and 1 if the file could
1655/// not be stat'ed.
1656
1657int TUnixSystem::GetPathInfo(const char *path, FileStat_t &buf)
1658{
1659 TSystem *helper = FindHelper(path);
1660 if (helper)
1661 return helper->GetPathInfo(path, buf);
1662
1663 return UnixFilestat(path, buf);
1664}
1665
1666////////////////////////////////////////////////////////////////////////////////
1667/// Get info about a file system: id, bsize, bfree, blocks.
1668/// Id is file system type (machine dependend, see statfs())
1669/// Bsize is block size of file system
1670/// Blocks is total number of blocks in file system
1671/// Bfree is number of free blocks in file system
1672/// The function returns 0 in case of success and 1 if the file system could
1673/// not be stat'ed.
1674
1675int TUnixSystem::GetFsInfo(const char *path, Long_t *id, Long_t *bsize,
1677{
1678 return UnixFSstat(path, id, bsize, blocks, bfree);
1679}
1680
1681////////////////////////////////////////////////////////////////////////////////
1682/// Create a link from file1 to file2. Returns 0 when successful,
1683/// -1 in case of failure.
1684
1685int TUnixSystem::Link(const char *from, const char *to)
1686{
1687 return ::link(from, to);
1688}
1689
1690////////////////////////////////////////////////////////////////////////////////
1691/// Create a symlink from file1 to file2. Returns 0 when successful,
1692/// -1 in case of failure.
1693
1694int TUnixSystem::Symlink(const char *from, const char *to)
1695{
1696#if defined(R__AIX)
1697 return ::symlink((char*)from, (char*)to);
1698#else
1699 return ::symlink(from, to);
1700#endif
1701}
1702
1703////////////////////////////////////////////////////////////////////////////////
1704/// Unlink, i.e. remove, a file or directory. Returns 0 when successful,
1705/// -1 in case of failure.
1706
1708{
1710 if (helper)
1711 return helper->Unlink(name);
1712
1713#if defined(R__SEEK64)
1714 struct stat64 finfo;
1715 if (lstat64(name, &finfo) < 0)
1716#else
1717 struct stat finfo;
1718 if (lstat(name, &finfo) < 0)
1719#endif
1720 return -1;
1721
1722 if (S_ISDIR(finfo.st_mode))
1723 return ::rmdir(name);
1724 else
1725 return ::unlink(name);
1726}
1727
1728//---- expand the metacharacters as in the shell -------------------------------
1729
1730// expand the metacharacters as in the shell
1731
1732const char
1733#ifdef G__OLDEXPAND
1734 kShellEscape = '\\',
1735 *kShellStuff = "(){}<>\"'",
1736#endif
1737 *kShellMeta = "~*[]{}?$";
1738
1739
1740#ifndef G__OLDEXPAND
1741////////////////////////////////////////////////////////////////////////////////
1742/// Expand a pathname getting rid of special shell characters like ~.$, etc.
1743/// For Unix/Win32 compatibility use $(XXX) instead of $XXX when using
1744/// environment variables in a pathname. If compatibility is not an issue
1745/// you can use on Unix directly $XXX. Returns kFALSE in case of success
1746/// or kTRUE in case of error.
1747
1749{
1750 const char *p, *patbuf = (const char *)path;
1751
1752 // skip leading blanks
1753 while (*patbuf == ' ')
1754 patbuf++;
1755
1756 // any shell meta characters ?
1757 for (p = patbuf; *p; p++)
1758 if (strchr(kShellMeta, *p))
1759 goto expand;
1760
1761 return kFALSE;
1762
1763expand:
1764 // replace $(XXX) by $XXX
1765 path.ReplaceAll("$(","$");
1766 path.ReplaceAll(")","");
1767
1768 return ExpandFileName(path);
1769}
1770#endif
1771
1772#ifdef G__OLDEXPAND
1773////////////////////////////////////////////////////////////////////////////////
1774/// Expand a pathname getting rid of special shell characters like ~.$, etc.
1775/// For Unix/Win32 compatibility use $(XXX) instead of $XXX when using
1776/// environment variables in a pathname. If compatibility is not an issue
1777/// you can use on Unix directly $XXX. Returns kFALSE in case of success
1778/// or kTRUE in case of error.
1779
1781{
1782 const char *patbuf = (const char *)patbuf0;
1783 const char *hd, *p;
1784 // char cmd[kMAXPATHLEN],
1785 char stuffedPat[kMAXPATHLEN], name[70];
1786 char *q;
1787 FILE *pf;
1788 int ch;
1789
1790 // skip leading blanks
1791 while (*patbuf == ' ')
1792 patbuf++;
1793
1794 // any shell meta characters ?
1795 for (p = patbuf; *p; p++)
1796 if (strchr(kShellMeta, *p))
1797 goto needshell;
1798
1799 return kFALSE;
1800
1801needshell:
1802 // replace $(XXX) by $XXX
1803 patbuf0.ReplaceAll("$(","$");
1804 patbuf0.ReplaceAll(")","");
1805
1806 // escape shell quote characters
1808
1809 TString cmd("echo ");
1810
1811 // emulate csh -> popen executes sh
1812 if (stuffedPat[0] == '~') {
1813 if (stuffedPat[1] != '\0' && stuffedPat[1] != '/') {
1814 // extract user name
1815 for (p = &stuffedPat[1], q = name; *p && *p !='/';)
1816 *q++ = *p++;
1817 *q = '\0';
1819 if (!hd)
1820 cmd += stuffedPat;
1821 else {
1822 cmd += hd;
1823 cmd += p;
1824 }
1825 } else {
1826 hd = UnixHomedirectory(nullptr);
1827 if (!hd) {
1829 return kTRUE;
1830 }
1831 cmd += hd;
1832 cmd += &stuffedPat[1];
1833 }
1834 } else
1835 cmd += stuffedPat;
1836
1837 if ((pf = ::popen(cmd.Data(), "r")) == 0) {
1839 return kTRUE;
1840 }
1841
1842 // read first argument
1843 patbuf0 = "";
1844 int cnt = 0;
1845#if defined(R__AIX)
1846again:
1847#endif
1848 for (ch = fgetc(pf); ch != EOF && ch != ' ' && ch != '\n'; ch = fgetc(pf)) {
1849 patbuf0.Append(ch);
1850 cnt++;
1851 }
1852#if defined(R__AIX)
1853 // Work around bug timing problem due to delay in forking a large program
1854 if (cnt == 0 && ch == EOF) goto again;
1855#endif
1856
1857 // skip rest of pipe
1858 while (ch != EOF) {
1859 ch = fgetc(pf);
1860 if (ch == ' ' || ch == '\t') {
1861 GetLastErrorString() = "expression ambigous";
1862 ::pclose(pf);
1863 return kTRUE;
1864 }
1865 }
1866
1867 ::pclose(pf);
1868
1869 return kFALSE;
1870}
1871#endif
1872
1873////////////////////////////////////////////////////////////////////////////////
1874/// Expand a pathname getting rid of special shell characaters like ~.$, etc.
1875/// For Unix/Win32 compatibility use $(XXX) instead of $XXX when using
1876/// environment variables in a pathname. If compatibility is not an issue
1877/// you can use on Unix directly $XXX. The user must delete returned string.
1878/// Returns the expanded pathname or 0 in case of error.
1879/// The user must delete returned string (delete []).
1880
1881char *TUnixSystem::ExpandPathName(const char *path)
1882{
1883 TString patbuf = path;
1885 return nullptr;
1886 return StrDup(patbuf.Data());
1887}
1888
1889////////////////////////////////////////////////////////////////////////////////
1890/// Set the file permission bits. Returns -1 in case or error, 0 otherwise.
1891
1892int TUnixSystem::Chmod(const char *file, UInt_t mode)
1893{
1894 return ::chmod(file, mode);
1895}
1896
1897////////////////////////////////////////////////////////////////////////////////
1898/// Set the process file creation mode mask.
1899
1901{
1902 return ::umask(mask);
1903}
1904
1905////////////////////////////////////////////////////////////////////////////////
1906/// Set a files modification and access times. If actime = 0 it will be
1907/// set to the modtime. Returns 0 on success and -1 in case of error.
1908
1909int TUnixSystem::Utime(const char *file, Long_t modtime, Long_t actime)
1910{
1911 if (!actime)
1912 actime = modtime;
1913
1914 struct utimbuf t;
1915 t.actime = (time_t)actime;
1916 t.modtime = (time_t)modtime;
1917 return ::utime(file, &t);
1918}
1919
1920////////////////////////////////////////////////////////////////////////////////
1921/// Find location of file "wfil" in a search path.
1922/// The search path is specified as a : separated list of directories.
1923/// Return value is pointing to wfile for compatibility with
1924/// Which(const char*,const char*,EAccessMode) version.
1925/// \note This function does not support finding files in directories containing
1926/// colons in their name. For that specific use case and if you know the filename,
1927/// deploy instead TSystem::AccessPathName(dirName+fileName, kReadPermission)
1928
1930{
1931 TString show;
1932 if (gEnv->GetValue("Root.ShowPath", 0))
1933 show.Form("Which: %s =", wfil.Data());
1934
1936
1937 if (wfil[0] == '/') {
1938#if defined(R__SEEK64)
1939 struct stat64 finfo;
1940 if (access(wfil.Data(), mode) == 0 &&
1941 stat64(wfil.Data(), &finfo) == 0 && S_ISREG(finfo.st_mode)) {
1942#else
1943 struct stat finfo;
1944 if (access(wfil.Data(), mode) == 0 &&
1945 stat(wfil.Data(), &finfo) == 0 && S_ISREG(finfo.st_mode)) {
1946#endif
1947 if (show != "")
1948 Printf("%s %s", show.Data(), wfil.Data());
1949 return wfil.Data();
1950 }
1951 if (show != "")
1952 Printf("%s <not found>", show.Data());
1953 wfil = "";
1954 return nullptr;
1955 }
1956
1957 if (!search)
1958 search = ".";
1959
1961 apwd += "/";
1962 for (const char* ptr = search; *ptr;) {
1963 TString name;
1964 if (*ptr != '/' && *ptr !='$' && *ptr != '~')
1965 name = apwd;
1966 const char* posEndOfPart = strchr(ptr, ':');
1967 if (posEndOfPart) {
1968 name.Append(ptr, posEndOfPart - ptr);
1969 ptr = posEndOfPart + 1; // skip ':'
1970 } else {
1971 name.Append(ptr);
1972 ptr += strlen(ptr);
1973 }
1974
1975 if (!name.EndsWith("/"))
1976 name += '/';
1977 name += wfil;
1978
1980#if defined(R__SEEK64)
1981 struct stat64 finfo;
1982 if (access(name.Data(), mode) == 0 &&
1983 stat64(name.Data(), &finfo) == 0 && S_ISREG(finfo.st_mode)) {
1984#else
1985 struct stat finfo;
1986 if (access(name.Data(), mode) == 0 &&
1987 stat(name.Data(), &finfo) == 0 && S_ISREG(finfo.st_mode)) {
1988#endif
1989 if (show != "")
1990 Printf("%s %s", show.Data(), name.Data());
1991 wfil = name;
1992 return wfil.Data();
1993 }
1994 }
1995
1996 if (show != "")
1997 Printf("%s <not found>", show.Data());
1998 wfil = "";
1999 return nullptr;
2000}
2001
2002//---- Users & Groups ----------------------------------------------------------
2003
2004////////////////////////////////////////////////////////////////////////////////
2005/// Returns the user's id. If user = 0, returns current user's id.
2006
2008{
2009 if (!user || !user[0])
2010 return getuid();
2011 else {
2012 struct passwd *apwd = getpwnam(user);
2013 if (apwd)
2014 return apwd->pw_uid;
2015 }
2016 return 0;
2017}
2018
2019////////////////////////////////////////////////////////////////////////////////
2020/// Returns the effective user id. The effective id corresponds to the
2021/// set id bit on the file being executed.
2022
2024{
2025 return geteuid();
2026}
2027
2028////////////////////////////////////////////////////////////////////////////////
2029/// Returns the group's id. If group = 0, returns current user's group.
2030
2032{
2033 if (!group || !group[0])
2034 return getgid();
2035 else {
2036 struct group *grp = getgrnam(group);
2037 if (grp)
2038 return grp->gr_gid;
2039 }
2040 return 0;
2041}
2042
2043////////////////////////////////////////////////////////////////////////////////
2044/// Returns the effective group id. The effective group id corresponds
2045/// to the set id bit on the file being executed.
2046
2048{
2049 return getegid();
2050}
2051
2052////////////////////////////////////////////////////////////////////////////////
2053/// Returns all user info in the UserGroup_t structure. The returned
2054/// structure must be deleted by the user. In case of error 0 is returned.
2055
2057{
2058 typedef std::map<Int_t /*uid*/, UserGroup_t> UserInfoCache_t;
2060
2062 if (iUserInfo != gUserInfo.end())
2063 return new UserGroup_t(iUserInfo->second);
2064
2065 struct passwd *apwd = getpwuid(uid);
2066 if (apwd) {
2067 UserGroup_t *ug = new UserGroup_t;
2068 ug->fUid = apwd->pw_uid;
2069 ug->fGid = apwd->pw_gid;
2070 ug->fUser = apwd->pw_name;
2071 ug->fPasswd = apwd->pw_passwd;
2072 ug->fRealName = apwd->pw_gecos;
2073 ug->fShell = apwd->pw_shell;
2074 UserGroup_t *gr = GetGroupInfo(apwd->pw_gid);
2075 if (gr) ug->fGroup = gr->fGroup;
2076 delete gr;
2077
2078 gUserInfo[uid] = *ug;
2079 return ug;
2080 }
2081 return nullptr;
2082}
2083
2084////////////////////////////////////////////////////////////////////////////////
2085/// Returns all user info in the UserGroup_t structure. If user = 0, returns
2086/// current user's id info. The returned structure must be deleted by the
2087/// user. In case of error 0 is returned.
2088
2090{
2091 return GetUserInfo(GetUid(user));
2092}
2093
2094////////////////////////////////////////////////////////////////////////////////
2095/// Returns all group info in the UserGroup_t structure. The only active
2096/// fields in the UserGroup_t structure for this call are:
2097/// fGid and fGroup
2098/// The returned structure must be deleted by the user. In case of
2099/// error 0 is returned.
2100
2102{
2103 struct group *grp = getgrgid(gid);
2104 if (grp) {
2105 UserGroup_t *gr = new UserGroup_t;
2106 gr->fUid = 0;
2107 gr->fGid = grp->gr_gid;
2108 gr->fGroup = grp->gr_name;
2109 return gr;
2110 }
2111 return nullptr;
2112}
2113
2114////////////////////////////////////////////////////////////////////////////////
2115/// Returns all group info in the UserGroup_t structure. The only active
2116/// fields in the UserGroup_t structure for this call are:
2117/// fGid and fGroup
2118/// If group = 0, returns current user's group. The returned structure
2119/// must be deleted by the user. In case of error 0 is returned.
2120
2122{
2123 return GetGroupInfo(GetGid(group));
2124}
2125
2126//---- environment manipulation ------------------------------------------------
2127
2128////////////////////////////////////////////////////////////////////////////////
2129/// Set environment variable.
2130
2131void TUnixSystem::Setenv(const char *name, const char *value)
2132{
2133 ::setenv(name, value, 1);
2134}
2135
2136////////////////////////////////////////////////////////////////////////////////
2137/// Get environment variable.
2138
2139const char *TUnixSystem::Getenv(const char *name)
2140{
2141 return std::getenv(name);
2142}
2143
2144////////////////////////////////////////////////////////////////////////////////
2145/// Unset environment variable.
2146
2148{
2150}
2151
2152//---- Processes ---------------------------------------------------------------
2153
2154////////////////////////////////////////////////////////////////////////////////
2155/// Execute a command.
2156
2158{
2159 return ::system(shellcmd);
2160}
2161
2162////////////////////////////////////////////////////////////////////////////////
2163/// Open a pipe.
2164
2165FILE *TUnixSystem::OpenPipe(const char *command, const char *mode)
2166{
2167 return ::popen(command, mode);
2168}
2169
2170////////////////////////////////////////////////////////////////////////////////
2171/// Close the pipe.
2172
2174{
2175 return ::pclose(pipe);
2176}
2177
2178////////////////////////////////////////////////////////////////////////////////
2179/// Get process id.
2180
2182{
2183 return ::getpid();
2184}
2185
2186////////////////////////////////////////////////////////////////////////////////
2187/// Exit the application.
2188
2190{
2191 // Insures that the files and sockets are closed before any library is unloaded
2192 // and before emptying CINT.
2194
2195 if (mode)
2196 ::exit(code);
2197 else
2198 ::_exit(code);
2199}
2200
2201////////////////////////////////////////////////////////////////////////////////
2202/// Abort the application.
2203
2205{
2207 ::abort();
2208}
2209
2210
2211#ifdef R__MACOSX
2212/// Use CoreSymbolication to retrieve the stacktrace.
2213#include <mach/mach.h>
2214extern "C" {
2215 // Adapted from https://github.com/mountainstorm/CoreSymbolication
2216 // Under the hood the framework basically just calls through to a set of C++ libraries
2217 typedef struct {
2218 void* csCppData;
2219 void* csCppObj;
2220 } CSTypeRef;
2222 typedef CSTypeRef CSSourceInfoRef;
2224 typedef CSTypeRef CSSymbolRef;
2225
2229 const char* CSSymbolGetName(CSSymbolRef sym);
2234}
2235
2237 return ref.csCppData || ref.csCppObj;
2238}
2239
2240void macosx_backtrace() {
2242 // retrieve current stack addresses
2243 int numstacks = backtrace( addrlist, sizeof( addrlist ) / sizeof( void* ));
2244
2246
2247 // skip TUnixSystem::Backtrace(), macosx_backtrace()
2248 static const int skipFrames = 2;
2249 for (int i = skipFrames; i < numstacks; ++i) {
2250 // No debug info, try to get at least the symbol name.
2253 0x80000000u);
2255
2256 if (const char* libPath = CSSymbolOwnerGetPath(symOwner)) {
2257 printf("[%s]", libPath);
2258 } else {
2259 printf("[<unknown binary>]");
2260 }
2261
2262 if (const char* symname = CSSymbolGetName(sym)) {
2263 printf(" %s", symname);
2264 }
2265
2269 0x80000000u /*"now"*/);
2270 if (const char* sourcePath = CSSourceInfoGetPath(sourceInfo)) {
2272 } else {
2273 printf(" (no debug info)");
2274 }
2275 printf("\n");
2276 }
2277}
2278#endif // R__MACOSX
2279
2280////////////////////////////////////////////////////////////////////////////////
2281/// Print a stack trace.
2282
2284{
2285 if (!gEnv->GetValue("Root.Stacktrace", 1))
2286 return;
2287
2288#ifndef R__MACOSX
2289 TString gdbscript = gEnv->GetValue("Root.StacktraceScript", "");
2290 gdbscript = gdbscript.Strip();
2291 if (gdbscript != "") {
2293 fprintf(stderr, "Root.StacktraceScript %s does not exist\n", gdbscript.Data());
2294 gdbscript = "";
2295 }
2296 }
2297 if (gdbscript == "") {
2298 gdbscript = "gdb-backtrace.sh";
2301 fprintf(stderr, "Error in <TUnixSystem::StackTrace> script %s is missing\n", gdbscript.Data());
2302 return;
2303 }
2304 }
2305 gdbscript += " ";
2306
2307 TString gdbmess = gEnv->GetValue("Root.StacktraceMessage", "");
2308 gdbmess = gdbmess.Strip();
2309
2310 std::cout.flush();
2311 fflush(stdout);
2312
2313 std::cerr.flush();
2314 fflush(stderr);
2315
2316 int fd = STDERR_FILENO;
2317
2318 const char *message = " Generating stack trace...\n";
2319
2320 if (fd && message) { } // remove unused warning (remove later)
2321
2322 if (gApplication && !strcmp(gApplication->GetName(), "TRint"))
2323 Getlinem(kCleanUp, nullptr);
2324
2325#if defined(USE_GDB_STACK_TRACE)
2326 char *gdb = Which(Getenv("PATH"), "gdb", kExecutePermission);
2327 if (!gdb) {
2328 fprintf(stderr, "gdb not found, need it for stack trace\n");
2329 return;
2330 }
2331
2332 // write custom message file
2333 TString gdbmessf = "gdb-message";
2334 if (gdbmess != "") {
2336 fprintf(f, "%s\n", gdbmess.Data());
2337 fclose(f);
2338 }
2339
2340 // use gdb to get stack trace
2341 gdbscript += GetExePath();
2342 gdbscript += " ";
2343 gdbscript += GetPid();
2344 if (gdbmess != "") {
2345 gdbscript += " ";
2347 }
2348 gdbscript += " 1>&2";
2349 Exec(gdbscript);
2350 delete [] gdb;
2351 return;
2352
2353#elif defined(R__AIX)
2354 TString script = "procstack ";
2355 script += GetPid();
2356 Exec(script);
2357 return;
2358#elif defined(R__SOLARIS)
2359 char *cppfilt = Which(Getenv("PATH"), "c++filt", kExecutePermission);
2360 TString script = "pstack ";
2361 script += GetPid();
2362 if (cppfilt) {
2363 script += " | ";
2364 script += cppfilt;
2365 delete [] cppfilt;
2366 }
2367 Exec(script);
2368 return;
2369#elif defined(HAVE_BACKTRACE_SYMBOLS_FD) && defined(HAVE_DLADDR) // linux + MacOS X >= 10.5
2370 // we could have used backtrace_symbols_fd, except its output
2371 // format is pretty bad, so recode that here :-(
2372
2373 // take care of demangling
2375
2376 // check for c++filt
2377 const char *cppfilt = "c++filt";
2378 const char *cppfiltarg = "";
2379#ifdef R__B64
2380 const char *format1 = " 0x%016lx in %.200s %s 0x%lx from %.200s\n";
2381#ifdef R__MACOSX
2382 const char *format2 = " 0x%016lx in %.200s\n";
2383#else
2384 const char *format2 = " 0x%016lx in %.200s at %.200s from %.200s\n";
2385#endif
2386 const char *format3 = " 0x%016lx in %.200s from %.200s\n";
2387 const char *format4 = " 0x%016lx in <unknown function>\n";
2388#else
2389 const char *format1 = " 0x%08lx in %.200s %s 0x%lx from %.200s\n";
2390#ifdef R__MACOSX
2391 const char *format2 = " 0x%08lx in %.200s\n";
2392#else
2393 const char *format2 = " 0x%08lx in %.200s at %.200s from %.200s\n";
2394#endif
2395 const char *format3 = " 0x%08lx in %.200s from %.200s\n";
2396 const char *format4 = " 0x%08lx in <unknown function>\n";
2397#endif
2398
2399 char *filter = Which(Getenv("PATH"), cppfilt, kExecutePermission);
2400 if (!filter)
2401 demangle = kFALSE;
2402
2403#if (__GNUC__ >= 3)
2404 // try finding supported format option for g++ v3
2405 if (filter) {
2406 FILE *p = OpenPipe(TString::Format("%s --help 2>&1", filter), "r");
2407 TString help;
2408 while (help.Gets(p)) {
2409 if (help.Index("gnu-v3") != kNPOS) {
2410 cppfiltarg = "--format=gnu-v3";
2411 break;
2412 } else if (help.Index("gnu-new-abi") != kNPOS) {
2413 cppfiltarg = "--format=gnu-new-abi";
2414 break;
2415 }
2416 }
2417 ClosePipe(p);
2418 }
2419#endif
2420 // gdb-backtrace.sh uses gdb to produce a backtrace. See if it is available.
2421 // If it is, use it. If not proceed as before.
2422#if (defined(R__LINUX) && !defined(R__WINGCC))
2423 // Declare the process that will be generating the stacktrace
2424 // For more see: http://askubuntu.com/questions/41629/after-upgrade-gdb-wont-attach-to-process
2425#ifdef PR_SET_PTRACER
2426 prctl(PR_SET_PTRACER, getpid(), 0, 0, 0);
2427#endif
2428#endif
2429 char *gdb = Which(Getenv("PATH"), "gdb", kExecutePermission);
2430 if (gdb) {
2431 // write custom message file
2432 TString gdbmessf = "gdb-message";
2433 if (gdbmess != "") {
2435 fprintf(f, "%s\n", gdbmess.Data());
2436 fclose(f);
2437 }
2438
2439 // use gdb to get stack trace
2440#ifdef R__MACOSX
2441 gdbscript += GetExePath();
2442 gdbscript += " ";
2443#endif
2444 gdbscript += GetPid();
2445 if (gdbmess != "") {
2446 gdbscript += " ";
2448 }
2449 gdbscript += " 1>&2";
2450 Exec(gdbscript);
2451 delete [] gdb;
2452 } else {
2453 // addr2line uses debug info to convert addresses into file names
2454 // and line numbers
2455#ifdef R__MACOSX
2456 char *addr2line = Which(Getenv("PATH"), "atos", kExecutePermission);
2457#else
2458 char *addr2line = Which(Getenv("PATH"), "addr2line", kExecutePermission);
2459#endif
2460 if (addr2line) {
2461 // might take some time so tell what we are doing...
2462 if (write(fd, message, strlen(message)) < 0)
2463 Warning("StackTrace", "problems writing line numbers (errno: %d)", TSystem::GetErrno());
2464 }
2465
2466 // open tmp file for demangled stack trace
2467 TString tmpf1 = "gdb-backtrace";
2468 std::ofstream file1;
2469 if (demangle) {
2471 if (f) fclose(f);
2472 file1.open(tmpf1);
2473 if (!file1) {
2474 Error("StackTrace", "could not open file %s", tmpf1.Data());
2475 Unlink(tmpf1);
2476 demangle = kFALSE;
2477 }
2478 }
2479
2480#ifdef R__MACOSX
2481 if (addr2line)
2482 demangle = kFALSE; // atos always demangles
2483#endif
2484
2485 char buffer[4096];
2488 for (int n = 5; n < depth; n++) {
2489 ULong_t addr = (ULong_t) trace[n];
2490 Dl_info info;
2491
2492 if (dladdr(trace[n], &info) && info.dli_fname && info.dli_fname[0]) {
2493 const char *libname = info.dli_fname;
2494 const char *symname = (info.dli_sname && info.dli_sname[0]) ?
2495 info.dli_sname : "<unknown>";
2496 ULong_t libaddr = (ULong_t) info.dli_fbase;
2497 ULong_t symaddr = (ULong_t) info.dli_saddr;
2498 Bool_t gte = (addr >= symaddr);
2499 ULong_t diff = (gte) ? addr - symaddr : symaddr - addr;
2500 if (addr2line && symaddr) {
2502#ifdef R__MACOSX
2503 if (libaddr) { } // use libaddr
2504#if defined(MAC_OS_X_VERSION_10_10)
2505 snprintf(buffer, sizeof(buffer), "%s -p %d 0x%016lx", addr2line, GetPid(), addr);
2506#elif defined(MAC_OS_X_VERSION_10_9)
2507 // suppress deprecation warning with opti
2508 snprintf(buffer, sizeof(buffer), "%s -d -p %d 0x%016lx", addr2line, GetPid(), addr);
2509#else
2510 snprintf(buffer, sizeof(buffer), "%s -p %d 0x%016lx", addr2line, GetPid(), addr);
2511#endif
2512#else
2513 ULong_t offset = (addr >= libaddr) ? addr - libaddr :
2514 libaddr - addr;
2518 if (name[0] != '/') noPath = kTRUE;
2519 if (name.Contains(".so") || name.Contains(".sl")) noShare = kFALSE;
2520 if (noShare) offset = addr;
2521 if (noPath) name = "`which " + name + "`";
2522 snprintf(buffer, sizeof(buffer), "%s -e %s 0x%016lx", addr2line, name.Data(), offset);
2523#endif
2524 if (FILE *pf = ::popen(buffer, "r")) {
2525 char buf[2048];
2526 if (fgets(buf, 2048, pf)) {
2527 buf[strlen(buf)-1] = 0; // remove trailing \n
2528 if (strncmp(buf, "??", 2)) {
2529#ifdef R__MACOSX
2530 snprintf(buffer, sizeof(buffer), format2, addr, buf);
2531#else
2532 snprintf(buffer, sizeof(buffer), format2, addr, symname, buf, libname);
2533#endif
2534 nodebug = kFALSE;
2535 }
2536 }
2537 ::pclose(pf);
2538 }
2539 if (nodebug)
2540 snprintf(buffer, sizeof(buffer), format1, addr, symname,
2541 gte ? "+" : "-", diff, libname);
2542 } else {
2543 if (symaddr)
2544 snprintf(buffer, sizeof(buffer), format1, addr, symname,
2545 gte ? "+" : "-", diff, libname);
2546 else
2547 snprintf(buffer, sizeof(buffer), format3, addr, symname, libname);
2548 }
2549 } else {
2550 snprintf(buffer, sizeof(buffer), format4, addr);
2551 }
2552
2553 if (demangle)
2554 file1 << buffer;
2555 else
2556 if (write(fd, buffer, ::strlen(buffer)) < 0)
2557 Warning("StackTrace", "problems writing buffer (errno: %d)", TSystem::GetErrno());
2558 }
2559
2560 if (demangle) {
2561 TString tmpf2 = "gdb-backtrace";
2563 if (f) fclose(f);
2564 file1.close();
2565 snprintf(buffer, sizeof(buffer), "%s %s < %s > %s", filter, cppfiltarg, tmpf1.Data(), tmpf2.Data());
2566 Exec(buffer);
2567 std::ifstream file2(tmpf2);
2568 TString line;
2569 while (file2) {
2570 line = "";
2571 line.ReadString(file2);
2572 if (write(fd, line.Data(), line.Length()) < 0)
2573 Warning("StackTrace", "problems writing line (errno: %d)", TSystem::GetErrno());
2574 }
2575 file2.close();
2576 Unlink(tmpf1);
2577 Unlink(tmpf2);
2578 }
2579
2580 delete [] addr2line;
2581 }
2582 delete [] filter;
2583#elif defined(HAVE_EXCPT_H) && defined(HAVE_PDSC_H) && \
2584 defined(HAVE_RLD_INTERFACE_H) // tru64
2585 // Tru64 stack walk. Uses the exception handling library and the
2586 // run-time linker's core functions (loader(5)). FIXME: Tru64
2587 // should have _RLD_DLADDR like IRIX below. Verify and update.
2588
2589 char buffer [128];
2590 sigcontext context;
2591 int rc = 0;
2592
2593 exc_capture_context (&context);
2594 while (!rc && context.sc_pc) {
2595 // FIXME: Elf32?
2596 pdsc_crd *func, *base, *crd
2597 = exc_remote_lookup_function_entry(0, 0, context.sc_pc, 0, &func, &base);
2599 // const char *name = _rld_address_to_name(addr);
2600 const char *name = "<unknown function>";
2601 sprintf(buffer, " 0x%012lx %.200s + 0x%lx\n",
2602 context.sc_pc, name, context.sc_pc - addr);
2603 write(fd, buffer, ::strlen(buffer));
2604 rc = exc_virtual_unwind(0, &context);
2605 }
2606#endif
2607#else //R__MACOSX
2609#endif //R__MACOSX
2610}
2611
2612//---- System Logging ----------------------------------------------------------
2613
2614////////////////////////////////////////////////////////////////////////////////
2615/// Open connection to system log daemon. For the use of the options and
2616/// facility see the Unix openlog man page.
2617
2619{
2620 int fac = 0;
2621
2622 switch (facility) {
2623 case kLogLocal0:
2624 fac = LOG_LOCAL0;
2625 break;
2626 case kLogLocal1:
2627 fac = LOG_LOCAL1;
2628 break;
2629 case kLogLocal2:
2630 fac = LOG_LOCAL2;
2631 break;
2632 case kLogLocal3:
2633 fac = LOG_LOCAL3;
2634 break;
2635 case kLogLocal4:
2636 fac = LOG_LOCAL4;
2637 break;
2638 case kLogLocal5:
2639 fac = LOG_LOCAL5;
2640 break;
2641 case kLogLocal6:
2642 fac = LOG_LOCAL6;
2643 break;
2644 case kLogLocal7:
2645 fac = LOG_LOCAL7;
2646 break;
2647 }
2648
2649 ::openlog(name, options, fac);
2650}
2651
2652////////////////////////////////////////////////////////////////////////////////
2653/// Send mess to syslog daemon. Level is the logging level and mess the
2654/// message that will be written on the log.
2655
2656void TUnixSystem::Syslog(ELogLevel level, const char *mess)
2657{
2658 // ELogLevel matches exactly the Unix values.
2659 ::syslog(level, "%s", mess);
2660}
2661
2662////////////////////////////////////////////////////////////////////////////////
2663/// Close connection to system log daemon.
2664
2666{
2667 ::closelog();
2668}
2669
2670//---- Standard output redirection ---------------------------------------------
2671
2672////////////////////////////////////////////////////////////////////////////////
2673/// Redirect standard output (stdout, stderr) to the specified file.
2674/// If the file argument is 0 the output is set again to stderr, stdout.
2675/// The second argument specifies whether the output should be added to the
2676/// file ("a", default) or the file be truncated before ("w").
2677/// This function saves internally the current state into a static structure.
2678/// The call can be made reentrant by specifying the opaque structure pointed
2679/// by 'h', which is filled with the relevant information. The handle 'h'
2680/// obtained on the first call must then be used in any subsequent call,
2681/// included ShowOutput, to display the redirected output.
2682/// Returns 0 on success, -1 in case of error.
2683
2684Int_t TUnixSystem::RedirectOutput(const char *file, const char *mode,
2686{
2687 // Instance to be used if the caller does not passes 'h'
2688 static RedirectHandle_t loch;
2689
2690 Int_t rc = 0;
2691
2692 // Which handle to use ?
2693 RedirectHandle_t *xh = (h) ? h : &loch;
2694
2695 if (file) {
2696 // Save the paths
2698 if (xh->fStdOutTty.IsNull()) {
2699 const char *tty = ttyname(STDOUT_FILENO);
2700 if (tty) {
2701 xh->fStdOutTty = tty;
2702 } else {
2703 if ((xh->fStdOutDup = dup(STDOUT_FILENO)) < 0) {
2704 SysError("RedirectOutput", "could not 'dup' stdout (errno: %d)", TSystem::GetErrno());
2705 return -1;
2706 }
2707 outdone = kTRUE;
2708 }
2709 }
2710 if (xh->fStdErrTty.IsNull()) {
2711 const char *tty = ttyname(STDERR_FILENO);
2712 if (tty) {
2713 xh->fStdErrTty = tty;
2714 } else {
2715 if ((xh->fStdErrDup = dup(STDERR_FILENO)) < 0) {
2716 SysError("RedirectOutput", "could not 'dup' stderr (errno: %d)", TSystem::GetErrno());
2717 if (outdone && dup2(xh->fStdOutDup, STDOUT_FILENO) < 0) {
2718 Warning("RedirectOutput", "could not restore stdout (back to original redirected"
2719 " file) (errno: %d)", TSystem::GetErrno());
2720 }
2721 return -1;
2722 }
2723 }
2724 }
2725
2726 // Make sure mode makes sense; default "a"
2727 const char *m = (mode[0] == 'a' || mode[0] == 'w') ? mode : "a";
2728
2729 // Current file size
2730 xh->fReadOffSet = 0;
2731 if (m[0] == 'a') {
2732 // If the file exists, save the current size
2733 FileStat_t st;
2734 if (!gSystem->GetPathInfo(file, st))
2735 xh->fReadOffSet = (st.fSize > 0) ? st.fSize : xh->fReadOffSet;
2736 }
2737 xh->fFile = file;
2738
2739 // Redirect stdout & stderr
2740 if (freopen(file, m, stdout) == nullptr) {
2741 SysError("RedirectOutput", "could not freopen stdout (errno: %d)", TSystem::GetErrno());
2742 return -1;
2743 }
2744 if (freopen(file, m, stderr) == nullptr) {
2745 SysError("RedirectOutput", "could not freopen stderr (errno: %d)", TSystem::GetErrno());
2746 if (freopen(xh->fStdOutTty.Data(), "a", stdout) == nullptr)
2747 SysError("RedirectOutput", "could not restore stdout (errno: %d)", TSystem::GetErrno());
2748 return -1;
2749 }
2750 } else {
2751 // Restore stdout & stderr
2752 fflush(stdout);
2753 if (!(xh->fStdOutTty.IsNull())) {
2754 if (freopen(xh->fStdOutTty.Data(), "a", stdout) == nullptr) {
2755 SysError("RedirectOutput", "could not restore stdout (errno: %d)", TSystem::GetErrno());
2756 rc = -1;
2757 }
2758 xh->fStdOutTty = "";
2759 } else {
2760 if (close(STDOUT_FILENO) != 0) {
2761 SysError("RedirectOutput",
2762 "problems closing STDOUT_FILENO (%d) before 'dup2' (errno: %d)",
2764 rc = -1;
2765 }
2766 if (dup2(xh->fStdOutDup, STDOUT_FILENO) < 0) {
2767 SysError("RedirectOutput", "could not restore stdout (back to original redirected"
2768 " file) (errno: %d)", TSystem::GetErrno());
2769 rc = -1;
2770 }
2771 if (close(xh->fStdOutDup) != 0) {
2772 SysError("RedirectOutput",
2773 "problems closing temporary 'out' descriptor %d (errno: %d)",
2774 TSystem::GetErrno(), xh->fStdOutDup);
2775 rc = -1;
2776 }
2777 }
2778 fflush(stderr);
2779 if (!(xh->fStdErrTty.IsNull())) {
2780 if (freopen(xh->fStdErrTty.Data(), "a", stderr) == nullptr) {
2781 SysError("RedirectOutput", "could not restore stderr (errno: %d)", TSystem::GetErrno());
2782 rc = -1;
2783 }
2784 xh->fStdErrTty = "";
2785 } else {
2786 if (close(STDERR_FILENO) != 0) {
2787 SysError("RedirectOutput",
2788 "problems closing STDERR_FILENO (%d) before 'dup2' (errno: %d)",
2790 rc = -1;
2791 }
2792 if (dup2(xh->fStdErrDup, STDERR_FILENO) < 0) {
2793 SysError("RedirectOutput", "could not restore stderr (back to original redirected"
2794 " file) (errno: %d)", TSystem::GetErrno());
2795 rc = -1;
2796 }
2797 if (close(xh->fStdErrDup) != 0) {
2798 SysError("RedirectOutput",
2799 "problems closing temporary 'err' descriptor %d (errno: %d)",
2800 TSystem::GetErrno(), xh->fStdErrDup);
2801 rc = -1;
2802 }
2803 }
2804 // Reset the static instance, if using that
2805 if (xh == &loch)
2806 xh->Reset();
2807 }
2808 return rc;
2809}
2810
2811//---- dynamic loading and linking ---------------------------------------------
2812
2813////////////////////////////////////////////////////////////////////////////////
2814///dynamic linking of module
2815
2816Func_t TUnixSystem::DynFindSymbol(const char * /*module*/, const char *entry)
2817{
2818 return TSystem::DynFindSymbol("*", entry);
2819}
2820
2821////////////////////////////////////////////////////////////////////////////////
2822/// Load a shared library. Returns 0 on successful loading, 1 in
2823/// case lib was already loaded and -1 in case lib does not exist
2824/// or in case of error.
2825
2826int TUnixSystem::Load(const char *module, const char *entry, Bool_t system)
2827{
2828 return TSystem::Load(module, entry, system);
2829}
2830
2831////////////////////////////////////////////////////////////////////////////////
2832/// Unload a shared library.
2833
2835{
2836 if (module) { TSystem::Unload(module); }
2837}
2838
2839////////////////////////////////////////////////////////////////////////////////
2840/// List symbols in a shared library.
2841
2842void TUnixSystem::ListSymbols(const char * /*module*/, const char * /*regexp*/)
2843{
2844 Error("ListSymbols", "not yet implemented");
2845}
2846
2847////////////////////////////////////////////////////////////////////////////////
2848/// List all loaded shared libraries.
2849
2850void TUnixSystem::ListLibraries(const char *regexp)
2851{
2852 TSystem::ListLibraries(regexp);
2853}
2854
2855////////////////////////////////////////////////////////////////////////////////
2856/// Get list of shared libraries loaded at the start of the executable.
2857/// Returns 0 in case list cannot be obtained or in case of error.
2858
2860{
2861 static TString linkedLibs;
2862 static Bool_t once = kFALSE;
2863
2865
2866 if (!linkedLibs.IsNull())
2867 return linkedLibs;
2868
2869 if (once)
2870 return nullptr;
2871
2872#if !defined(R__MACOSX)
2873 const char *exe = GetExePath();
2874 if (!exe || !*exe)
2875 return nullptr;
2876#endif
2877
2878#if defined(R__MACOSX)
2879 DylibAdded(0, 0);
2881#if 0
2882 FILE *p = OpenPipe(TString::Format("otool -L %s", exe), "r");
2883 TString otool;
2884 while (otool.Gets(p)) {
2885 TString delim(" \t");
2886 TObjArray *tok = otool.Tokenize(delim);
2887 TString dylib = ((TObjString*)tok->At(0))->String();
2888 if (dylib.EndsWith(".dylib") && !dylib.Contains("/libSystem.B.dylib")) {
2889 if (!linkedLibs.IsNull())
2890 linkedLibs += " ";
2891 linkedLibs += dylib;
2892 }
2893 delete tok;
2894 }
2895 if (p) {
2896 ClosePipe(p);
2897 }
2898#endif
2899#elif defined(R__LINUX) || defined(R__SOLARIS) || defined(R__AIX)
2900#if defined(R__WINGCC )
2901 const char *cLDD="cygcheck";
2902 const char *cSOEXT=".dll";
2903 size_t lenexe = strlen(exe);
2904 if (strcmp(exe + lenexe - 4, ".exe")
2905 && strcmp(exe + lenexe - 4, ".dll")) {
2906 // it's not a dll and exe doesn't end on ".exe";
2907 // need to add it for cygcheck to find it:
2908 char* longerexe = new char[lenexe + 5];
2910 strlcat(longerexe, ".exe",lenexe+5);
2911 exe = longerexe; // memory leak
2912 #error "unsupported platform, fix memory leak to use it"
2913 }
2914 TRegexp sovers = "\\.so\\.[0-9]+";
2915#else
2916 const char *cLDD="ldd";
2917#if defined(R__AIX)
2918 const char *cSOEXT=".a";
2919 TRegexp sovers = "\\.a\\.[0-9]+";
2920#else
2921 const char *cSOEXT=".so";
2922 TRegexp sovers = "\\.so\\.[0-9]+";
2923#endif
2924#endif
2925 FILE *p = OpenPipe(TString::Format("%s '%s'", cLDD, exe), "r");
2926 if (p) {
2927 TString ldd;
2928 while (ldd.Gets(p)) {
2929 TString delim(" \t");
2930 TObjArray *tok = ldd.Tokenize(delim);
2931
2932 // expected format:
2933 // libCore.so => /home/rdm/root/lib/libCore.so (0x40017000)
2934 TObjString *solibName = (TObjString*)tok->At(2);
2935 if (!solibName) {
2936 // case where there is only one name of the list:
2937 // /usr/platform/SUNW,UltraAX-i2/lib/libc_psr.so.1
2938 solibName = (TObjString*)tok->At(0);
2939 }
2940 if (solibName) {
2941 TString solib = solibName->String();
2942 Ssiz_t idx = solib.Index(sovers);
2943 if (solib.EndsWith(cSOEXT) || idx != kNPOS) {
2944 if (idx != kNPOS)
2945 solib.Remove(idx+3);
2947 if (!linkedLibs.IsNull())
2948 linkedLibs += " ";
2949 linkedLibs += solib;
2950 }
2951 }
2952 }
2953 delete tok;
2954 }
2955 ClosePipe(p);
2956 }
2957#endif
2958
2959 once = kTRUE;
2960
2961 if (linkedLibs.IsNull())
2962 return nullptr;
2963
2964 return linkedLibs;
2965}
2966
2967//---- Time & Date -------------------------------------------------------------
2968
2969////////////////////////////////////////////////////////////////////////////////
2970/// Get current time in milliseconds since 0:00 Jan 1 1995.
2971
2973{
2974 return UnixNow();
2975}
2976
2977////////////////////////////////////////////////////////////////////////////////
2978/// Handle and dispatch timers. If mode = kTRUE dispatch synchronous
2979/// timers else a-synchronous timers.
2980
2982{
2983 if (!fTimers) return kFALSE;
2984
2986
2987 TListIter it(fTimers);
2988 TTimer *t;
2990
2991 while ((t = (TTimer *) it.Next())) {
2992 // NB: the timer resolution is added in TTimer::CheckTimer()
2993 Long64_t now = UnixNow();
2994 if (mode && t->IsSync()) {
2995 if (t->CheckTimer(now))
2996 timedout = kTRUE;
2997 } else if (!mode && t->IsAsync()) {
2998 if (t->CheckTimer(now)) {
3000 timedout = kTRUE;
3001 }
3002 }
3003 }
3005 return timedout;
3006}
3007
3008////////////////////////////////////////////////////////////////////////////////
3009/// Add timer to list of system timers.
3010
3016
3017////////////////////////////////////////////////////////////////////////////////
3018/// Remove timer from list of system timers.
3019
3021{
3022 if (!ti) return nullptr;
3023
3025
3027 if (ti->IsAsync())
3029 return t;
3030}
3031
3032////////////////////////////////////////////////////////////////////////////////
3033/// Reset a-sync timer.
3034
3036{
3037 if (!fInsideNotify && ti && ti->IsAsync())
3039}
3040
3041//---- RPC ---------------------------------------------------------------------
3042
3043////////////////////////////////////////////////////////////////////////////////
3044/// Get Internet Protocol (IP) address of host. Returns an TInetAddress
3045/// object. To see if the hostname lookup was successfull call
3046/// TInetAddress::IsValid().
3047
3049{
3051 struct addrinfo hints;
3052 struct addrinfo *result, *rp;
3053 memset(&hints, 0, sizeof(struct addrinfo));
3054 hints.ai_family = AF_INET; // only IPv4
3055 hints.ai_socktype = 0; // any socket type
3056 hints.ai_protocol = 0; // any protocol
3057 hints.ai_flags = AI_CANONNAME; // get canonical name
3058#ifdef R__MACOSX
3059 // Anything ending on ".local" causes a 5 second delay in getaddrinfo().
3060 // See e.g. https://apple.stackexchange.com/questions/175320/why-is-my-hostname-resolution-taking-so-long
3061 // Only reasonable solution: remove the "domain" part if it's ".local".
3062 size_t lenHostname = strlen(hostname);
3063 std::string hostnameWithoutLocal{hostname};
3064 if (lenHostname > 6 && !strcmp(hostname + lenHostname - 6, ".local")) {
3067 }
3068#endif
3069
3070 // obsolete gethostbyname() replaced by getaddrinfo()
3071 int rc = getaddrinfo(hostname, nullptr, &hints, &result);
3072 if (rc != 0) {
3073 if (rc == EAI_NONAME) {
3074 if (gDebug > 0) Error("GetHostByName", "unknown host '%s'", hostname);
3075 ia.fHostname = "UnNamedHost";
3076 } else {
3077 Error("GetHostByName", "getaddrinfo failed for '%s': %s", hostname, gai_strerror(rc));
3078 ia.fHostname = "UnknownHost";
3079 }
3080 return ia;
3081 }
3082
3083 std::string hostcanon(result->ai_canonname ? result->ai_canonname : hostname);
3084 ia.fHostname = hostcanon.data();
3085 ia.fFamily = result->ai_family;
3086 ia.fAddresses[0] = ntohl(((struct sockaddr_in *)(result->ai_addr))->sin_addr.s_addr);
3087 // with getaddrinfo() no way to get list of aliases for a hostname
3088 if (hostcanon.compare(hostname) != 0) ia.AddAlias(hostname);
3089
3090 // check on numeric hostname
3091 char tmp[sizeof(struct in_addr)];
3092 if (inet_pton(AF_INET, hostcanon.data(), tmp) == 1) {
3093 char hbuf[NI_MAXHOST];
3094 if (getnameinfo(result->ai_addr, result->ai_addrlen, hbuf, sizeof(hbuf), nullptr, 0, 0) == 0)
3095 ia.fHostname = hbuf;
3096 }
3097
3098 // check other addresses (if exist)
3099 rp = result->ai_next;
3100 for (; rp != nullptr; rp = rp->ai_next) {
3101 UInt_t arp = ntohl(((struct sockaddr_in *)(rp->ai_addr))->sin_addr.s_addr);
3102 if ( !(std::find(ia.fAddresses.begin(), ia.fAddresses.end(), arp) != ia.fAddresses.end()) )
3103 ia.AddAddress(arp);
3104 }
3105
3107 return ia;
3108}
3109
3110////////////////////////////////////////////////////////////////////////////////
3111/// Get Internet Protocol (IP) address of host and port #.
3112
3114{
3115 struct sockaddr addr;
3116 socklen_t len = sizeof(addr);
3117
3119 if (getsockname(sock, &addr, &len) == -1) {
3120 SysError("GetSockName", "getsockname failed");
3121 return ia;
3122 }
3123
3124 if (addr.sa_family != AF_INET) return ia; // only IPv4
3125 ia.fFamily = addr.sa_family;
3126 struct sockaddr_in *addrin = (struct sockaddr_in *)&addr;
3127 ia.fPort = ntohs(addrin->sin_port);
3128 ia.fAddresses[0] = ntohl(addrin->sin_addr.s_addr);
3129
3130 char hbuf[NI_MAXHOST];
3131 if (getnameinfo(&addr, sizeof(struct sockaddr), hbuf, sizeof(hbuf), nullptr, 0, 0) != 0) {
3132 Error("GetSockName", "getnameinfo failed");
3133 ia.fHostname = "????";
3134 } else
3135 ia.fHostname = hbuf;
3136
3137 return ia;
3138}
3139
3140////////////////////////////////////////////////////////////////////////////////
3141/// Get Internet Protocol (IP) address of remote host and port #.
3142
3144{
3145 struct sockaddr addr;
3146 socklen_t len = sizeof(addr);
3147
3149 if (getpeername(sock, &addr, &len) == -1) {
3150 SysError("GetPeerName", "getpeername failed");
3151 return ia;
3152 }
3153
3154 if (addr.sa_family != AF_INET) return ia; // only IPv4
3155 ia.fFamily = addr.sa_family;
3156 struct sockaddr_in *addrin = (struct sockaddr_in *)&addr;
3157 ia.fPort = ntohs(addrin->sin_port);
3158 ia.fAddresses[0] = ntohl(addrin->sin_addr.s_addr);
3159
3160 char hbuf[NI_MAXHOST];
3161 if (getnameinfo(&addr, sizeof(struct sockaddr), hbuf, sizeof(hbuf), nullptr, 0, 0) != 0) {
3162 Error("GetPeerName", "getnameinfo failed");
3163 ia.fHostname = "????";
3164 } else
3165 ia.fHostname = hbuf;
3166
3167 return ia;
3168}
3169
3170////////////////////////////////////////////////////////////////////////////////
3171/// Get port # of internet service.
3172
3174{
3175 struct servent *sp;
3176
3177 if ((sp = getservbyname(servicename, kProtocolName)) == nullptr) {
3178 Error("GetServiceByName", "no service \"%s\" with protocol \"%s\"\n",
3180 return -1;
3181 }
3182 return ntohs(sp->s_port);
3183}
3184
3185////////////////////////////////////////////////////////////////////////////////
3186/// Get name of internet service.
3187
3189{
3190 struct servent *sp;
3191
3192 if ((sp = getservbyport(htons(port), kProtocolName)) == nullptr) {
3193 //::Error("GetServiceByPort", "no service \"%d\" with protocol \"%s\"",
3194 // port, kProtocolName);
3195 return Form("%d", port);
3196 }
3197 return sp->s_name;
3198}
3199
3200////////////////////////////////////////////////////////////////////////////////
3201/// Connect to service servicename on server servername.
3202
3203int TUnixSystem::ConnectService(const char *servername, int port,
3204 int tcpwindowsize, const char *protocol)
3205{
3206 if (!strcmp(servername, "unix")) {
3207 return UnixUnixConnect(port);
3208 } else if (!gSystem->AccessPathName(servername) || servername[0] == '/') {
3210 }
3211
3212 if (!strcmp(protocol, "udp")){
3213 return UnixUdpConnect(servername, port);
3214 }
3215
3217}
3218
3219////////////////////////////////////////////////////////////////////////////////
3220/// Open a connection to a service on a server. Returns -1 in case
3221/// connection cannot be opened.
3222/// Use tcpwindowsize to specify the size of the receive buffer, it has
3223/// to be specified here to make sure the window scale option is set (for
3224/// tcpwindowsize > 65KB and for platforms supporting window scaling).
3225/// Is called via the TSocket constructor.
3226
3227int TUnixSystem::OpenConnection(const char *server, int port, int tcpwindowsize, const char *protocol)
3228{
3229 return ConnectService(server, port, tcpwindowsize, protocol);
3230}
3231
3232////////////////////////////////////////////////////////////////////////////////
3233/// Announce TCP/IP service.
3234/// Open a socket, bind to it and start listening for TCP/IP connections
3235/// on the port. If reuse is true reuse the address, backlog specifies
3236/// how many sockets can be waiting to be accepted.
3237/// Use tcpwindowsize to specify the size of the receive buffer, it has
3238/// to be specified here to make sure the window scale option is set (for
3239/// tcpwindowsize > 65KB and for platforms supporting window scaling).
3240/// Returns socket fd or -1 if socket() failed, -2 if bind() failed
3241/// or -3 if listen() failed.
3242
3248
3249////////////////////////////////////////////////////////////////////////////////
3250/// Announce UDP service.
3251
3256
3257////////////////////////////////////////////////////////////////////////////////
3258/// Announce unix domain service on path "kServerPath/<port>"
3259
3261{
3262 return UnixUnixService(port, backlog);
3263}
3264
3265////////////////////////////////////////////////////////////////////////////////
3266/// Announce unix domain service on path 'sockpath'
3267
3269{
3271}
3272
3273////////////////////////////////////////////////////////////////////////////////
3274/// Accept a connection. In case of an error return -1. In case
3275/// non-blocking I/O is enabled and no connections are available
3276/// return -2.
3277
3279{
3280 int soc = -1;
3281
3282 while ((soc = ::accept(sock, nullptr, nullptr)) == -1 && GetErrno() == EINTR)
3283 ResetErrno();
3284
3285 if (soc == -1) {
3286 if (GetErrno() == EWOULDBLOCK)
3287 return -2;
3288 else {
3289 SysError("AcceptConnection", "accept");
3290 return -1;
3291 }
3292 }
3293
3294 return soc;
3295}
3296
3297////////////////////////////////////////////////////////////////////////////////
3298/// Close socket.
3299
3301{
3302 if (sock < 0) return;
3303
3304#if !defined(R__AIX) || defined(_AIX41) || defined(_AIX43)
3305 if (force)
3306 ::shutdown(sock, 2); // will also close connection of parent
3307#endif
3308
3309 while (::close(sock) == -1 && GetErrno() == EINTR)
3310 ResetErrno();
3311}
3312
3313////////////////////////////////////////////////////////////////////////////////
3314/// Receive a buffer headed by a length indicator. Length is the size of
3315/// the buffer. Returns the number of bytes received in buf or -1 in
3316/// case of error.
3317
3318int TUnixSystem::RecvBuf(int sock, void *buf, int length)
3319{
3320 Int_t header;
3321
3322 if (UnixRecv(sock, &header, sizeof(header), 0) > 0) {
3323 int count = ntohl(header);
3324
3325 if (count > length) {
3326 Error("RecvBuf", "record header exceeds buffer size");
3327 return -1;
3328 } else if (count > 0) {
3329 if (UnixRecv(sock, buf, count, 0) < 0) {
3330 Error("RecvBuf", "cannot receive buffer");
3331 return -1;
3332 }
3333 }
3334 return count;
3335 }
3336 return -1;
3337}
3338
3339////////////////////////////////////////////////////////////////////////////////
3340/// Send a buffer headed by a length indicator. Returns length of sent buffer
3341/// or -1 in case of error.
3342
3343int TUnixSystem::SendBuf(int sock, const void *buf, int length)
3344{
3345 Int_t header = htonl(length);
3346
3347 if (UnixSend(sock, &header, sizeof(header), 0) < 0) {
3348 Error("SendBuf", "cannot send header");
3349 return -1;
3350 }
3351 if (length > 0) {
3352 if (UnixSend(sock, buf, length, 0) < 0) {
3353 Error("SendBuf", "cannot send buffer");
3354 return -1;
3355 }
3356 }
3357 return length;
3358}
3359
3360////////////////////////////////////////////////////////////////////////////////
3361/// Receive exactly length bytes into buffer. Use opt to receive out-of-band
3362/// data or to have a peek at what is in the buffer (see TSocket). Buffer
3363/// must be able to store at least length bytes. Returns the number of
3364/// bytes received (can be 0 if other side of connection was closed) or -1
3365/// in case of error, -2 in case of MSG_OOB and errno == EWOULDBLOCK, -3
3366/// in case of MSG_OOB and errno == EINVAL and -4 in case of kNoBlock and
3367/// errno == EWOULDBLOCK. Returns -5 if pipe broken or reset by peer
3368/// (EPIPE || ECONNRESET).
3369
3370int TUnixSystem::RecvRaw(int sock, void *buf, int length, int opt)
3371{
3372 int flag;
3373
3374 switch (opt) {
3375 case kDefault:
3376 flag = 0;
3377 break;
3378 case kOob:
3379 flag = MSG_OOB;
3380 break;
3381 case kPeek:
3382 flag = MSG_PEEK;
3383 break;
3384 case kDontBlock:
3385 flag = -1;
3386 break;
3387 default:
3388 flag = 0;
3389 break;
3390 }
3391
3392 int n;
3393 if ((n = UnixRecv(sock, buf, length, flag)) <= 0) {
3394 if (n == -1 && GetErrno() != EINTR)
3395 Error("RecvRaw", "cannot receive buffer");
3396 return n;
3397 }
3398 return n;
3399}
3400
3401////////////////////////////////////////////////////////////////////////////////
3402/// Send exactly length bytes from buffer. Use opt to send out-of-band
3403/// data (see TSocket). Returns the number of bytes sent or -1 in case of
3404/// error. Returns -4 in case of kNoBlock and errno == EWOULDBLOCK.
3405/// Returns -5 if pipe broken or reset by peer (EPIPE || ECONNRESET).
3406
3407int TUnixSystem::SendRaw(int sock, const void *buf, int length, int opt)
3408{
3409 int flag;
3410
3411 switch (opt) {
3412 case kDefault:
3413 flag = 0;
3414 break;
3415 case kOob:
3416 flag = MSG_OOB;
3417 break;
3418 case kDontBlock:
3419 flag = -1;
3420 break;
3421 case kPeek: // receive only option (see RecvRaw)
3422 default:
3423 flag = 0;
3424 break;
3425 }
3426
3427 int n;
3428 if ((n = UnixSend(sock, buf, length, flag)) <= 0) {
3429 if (n == -1 && GetErrno() != EINTR)
3430 Error("SendRaw", "cannot send buffer");
3431 return n;
3432 }
3433 return n;
3434}
3435
3436////////////////////////////////////////////////////////////////////////////////
3437/// Set socket option.
3438
3439int TUnixSystem::SetSockOpt(int sock, int opt, int val)
3440{
3441 if (sock < 0) return -1;
3442
3443 switch (opt) {
3444 case kSendBuffer:
3445 if (setsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char*)&val, sizeof(val)) == -1) {
3446 SysError("SetSockOpt", "setsockopt(SO_SNDBUF)");
3447 return -1;
3448 }
3449 break;
3450 case kRecvBuffer:
3451 if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char*)&val, sizeof(val)) == -1) {
3452 SysError("SetSockOpt", "setsockopt(SO_RCVBUF)");
3453 return -1;
3454 }
3455 break;
3456 case kOobInline:
3457 if (setsockopt(sock, SOL_SOCKET, SO_OOBINLINE, (char*)&val, sizeof(val)) == -1) {
3458 SysError("SetSockOpt", "setsockopt(SO_OOBINLINE)");
3459 return -1;
3460 }
3461 break;
3462 case kKeepAlive:
3463 if (setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (char*)&val, sizeof(val)) == -1) {
3464 SysError("SetSockOpt", "setsockopt(SO_KEEPALIVE)");
3465 return -1;
3466 }
3467 break;
3468 case kReuseAddr:
3469 if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char*)&val, sizeof(val)) == -1) {
3470 SysError("SetSockOpt", "setsockopt(SO_REUSEADDR)");
3471 return -1;
3472 }
3473 break;
3474 case kNoDelay:
3475 if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (char*)&val, sizeof(val)) == -1) {
3476 SysError("SetSockOpt", "setsockopt(TCP_NODELAY)");
3477 return -1;
3478 }
3479 break;
3480 case kNoBlock:
3481 if (ioctl(sock, FIONBIO, (char*)&val) == -1) {
3482 SysError("SetSockOpt", "ioctl(FIONBIO)");
3483 return -1;
3484 }
3485 break;
3486 case kProcessGroup:
3487#ifndef R__WINGCC
3488 if (ioctl(sock, SIOCSPGRP, (char*)&val) == -1) {
3489 SysError("SetSockOpt", "ioctl(SIOCSPGRP)");
3490 return -1;
3491 }
3492#else
3493 Error("SetSockOpt", "ioctl(SIOCGPGRP) not supported on cygwin/gcc");
3494 return -1;
3495#endif
3496 break;
3497 case kAtMark: // read-only option (see GetSockOpt)
3498 case kBytesToRead: // read-only option
3499 default:
3500 Error("SetSockOpt", "illegal option (%d)", opt);
3501 return -1;
3502 }
3503 return 0;
3504}
3505
3506////////////////////////////////////////////////////////////////////////////////
3507/// Get socket option.
3508
3509int TUnixSystem::GetSockOpt(int sock, int opt, int *val)
3510{
3511 if (sock < 0) return -1;
3512
3513 socklen_t optlen = sizeof(*val);
3514
3515 switch (opt) {
3516 case kSendBuffer:
3517 if (getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char*)val, &optlen) == -1) {
3518 SysError("GetSockOpt", "getsockopt(SO_SNDBUF)");
3519 return -1;
3520 }
3521 break;
3522 case kRecvBuffer:
3523 if (getsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char*)val, &optlen) == -1) {
3524 SysError("GetSockOpt", "getsockopt(SO_RCVBUF)");
3525 return -1;
3526 }
3527 break;
3528 case kOobInline:
3529 if (getsockopt(sock, SOL_SOCKET, SO_OOBINLINE, (char*)val, &optlen) == -1) {
3530 SysError("GetSockOpt", "getsockopt(SO_OOBINLINE)");
3531 return -1;
3532 }
3533 break;
3534 case kKeepAlive:
3535 if (getsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (char*)val, &optlen) == -1) {
3536 SysError("GetSockOpt", "getsockopt(SO_KEEPALIVE)");
3537 return -1;
3538 }
3539 break;
3540 case kReuseAddr:
3541 if (getsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char*)val, &optlen) == -1) {
3542 SysError("GetSockOpt", "getsockopt(SO_REUSEADDR)");
3543 return -1;
3544 }
3545 break;
3546 case kNoDelay:
3547 if (getsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (char*)val, &optlen) == -1) {
3548 SysError("GetSockOpt", "getsockopt(TCP_NODELAY)");
3549 return -1;
3550 }
3551 break;
3552 case kNoBlock:
3553 int flg;
3554 if ((flg = fcntl(sock, F_GETFL, 0)) == -1) {
3555 SysError("GetSockOpt", "fcntl(F_GETFL)");
3556 return -1;
3557 }
3558 *val = flg & O_NDELAY;
3559 break;
3560 case kProcessGroup:
3561#if !defined(R__LYNXOS) && !defined(R__WINGCC)
3562 if (ioctl(sock, SIOCGPGRP, (char*)val) == -1) {
3563 SysError("GetSockOpt", "ioctl(SIOCGPGRP)");
3564 return -1;
3565 }
3566#else
3567 Error("GetSockOpt", "ioctl(SIOCGPGRP) not supported on LynxOS and cygwin/gcc");
3568 return -1;
3569#endif
3570 break;
3571 case kAtMark:
3572#if !defined(R__LYNXOS)
3573 if (ioctl(sock, SIOCATMARK, (char*)val) == -1) {
3574 SysError("GetSockOpt", "ioctl(SIOCATMARK)");
3575 return -1;
3576 }
3577#else
3578 Error("GetSockOpt", "ioctl(SIOCATMARK) not supported on LynxOS");
3579 return -1;
3580#endif
3581 break;
3582 case kBytesToRead:
3583#if !defined(R__LYNXOS)
3584 if (ioctl(sock, FIONREAD, (char*)val) == -1) {
3585 SysError("GetSockOpt", "ioctl(FIONREAD)");
3586 return -1;
3587 }
3588#else
3589 Error("GetSockOpt", "ioctl(FIONREAD) not supported on LynxOS");
3590 return -1;
3591#endif
3592 break;
3593 default:
3594 Error("GetSockOpt", "illegal option (%d)", opt);
3595 *val = 0;
3596 return -1;
3597 }
3598 return 0;
3599}
3600
3601//////////////////////////////////////////////////////////////////////////
3602// //
3603// Static Protected Unix Interface functions. //
3604// //
3605//////////////////////////////////////////////////////////////////////////
3606
3607//---- signals -----------------------------------------------------------------
3608
3609static struct Signalmap_t {
3613 const char *fSigName;
3614} gSignalMap[kMAXSIGNALS] = { // the order of the signals should be identical
3615 { SIGBUS, nullptr, nullptr, "bus error" }, // to the one in TSysEvtHandler.h
3616 { SIGSEGV, nullptr, nullptr, "segmentation violation" },
3617 { SIGSYS, nullptr, nullptr, "bad argument to system call" },
3618 { SIGPIPE, nullptr, nullptr, "write on a pipe with no one to read it" },
3619 { SIGILL, nullptr, nullptr, "illegal instruction" },
3620 { SIGABRT, nullptr, nullptr, "abort" },
3621 { SIGQUIT, nullptr, nullptr, "quit" },
3622 { SIGINT, nullptr, nullptr, "interrupt" },
3623 { SIGWINCH, nullptr, nullptr, "window size change" },
3624 { SIGALRM, nullptr, nullptr, "alarm clock" },
3625 { SIGCHLD, nullptr, nullptr, "death of a child" },
3626 { SIGURG, nullptr, nullptr, "urgent data arrived on an I/O channel" },
3627 { SIGFPE, nullptr, nullptr, "floating point exception" },
3628 { SIGTERM, nullptr, nullptr, "termination signal" },
3629 { SIGUSR1, nullptr, nullptr, "user-defined signal 1" },
3630 { SIGUSR2, nullptr, nullptr, "user-defined signal 2" }
3632
3633
3634////////////////////////////////////////////////////////////////////////////////
3635/// Call the signal handler associated with the signal.
3636
3637static void sighandler(int sig)
3638{
3639 for (int i= 0; i < kMAXSIGNALS; i++) {
3640 if (gSignalMap[i].fCode == sig) {
3641 (*gSignalMap[i].fHandler)((ESignals)i);
3642 return;
3643 }
3644 }
3645}
3646
3647////////////////////////////////////////////////////////////////////////////////
3648/// Handle and dispatch signals.
3649
3651{
3652 switch (sig) {
3653 case kSigAlarm:
3655 break;
3656 case kSigChild:
3657 CheckChilds();
3658 break;
3659 case kSigBus:
3662 case kSigAbort:
3666 else {
3667 if (sig == kSigAbort)
3668 return;
3669 Break("TUnixSystem::DispatchSignals", "%s", UnixSigname(sig));
3670 StackTrace();
3671 if (gApplication)
3672 //sig is ESignal, should it be mapped to the correct signal number?
3674 else
3675 //map to the real signal code + set the
3676 //high order bit to indicate a signal (?)
3677 Exit(gSignalMap[sig].fCode + 0x80);
3678 }
3679 break;
3680 case kSigSystem:
3681 case kSigPipe:
3682 Break("TUnixSystem::DispatchSignals", "%s", UnixSigname(sig));
3683 break;
3684 case kSigWindowChanged:
3686 break;
3687 case kSigUser2:
3688 Break("TUnixSystem::DispatchSignals", "%s: printing stacktrace", UnixSigname(sig));
3689 StackTrace();
3690 // Intentional fall-through; pass the signal to handlers (or terminate):
3691 default:
3692 fSignals->Set(sig);
3693 fSigcnt++;
3694 break;
3695 }
3696
3697 // check a-synchronous signals
3698 if (fSigcnt > 0 && fSignalHandler->GetSize() > 0)
3700}
3701
3702////////////////////////////////////////////////////////////////////////////////
3703/// Set a signal handler for a signal.
3704
3706{
3707 if (gEnv && !gEnv->GetValue("Root.ErrorHandlers", 1))
3708 return;
3709
3710 if (gSignalMap[sig].fHandler != handler) {
3711 struct sigaction sigact;
3712
3713 gSignalMap[sig].fHandler = handler;
3714 gSignalMap[sig].fOldHandler = new struct sigaction();
3715
3716#if defined(R__SUN)
3717 sigact.sa_handler = (void (*)())sighandler;
3718#elif defined(R__SOLARIS)
3719 sigact.sa_handler = sighandler;
3720#elif defined(R__LYNXOS)
3721# if (__GNUG__>=3)
3722 sigact.sa_handler = sighandler;
3723# else
3724 sigact.sa_handler = (void (*)(...))sighandler;
3725# endif
3726#else
3727 sigact.sa_handler = sighandler;
3728#endif
3729 sigemptyset(&sigact.sa_mask);
3730 sigact.sa_flags = 0;
3731#if defined(SA_RESTART)
3732 sigact.sa_flags |= SA_RESTART;
3733#endif
3734 if (sigaction(gSignalMap[sig].fCode, &sigact,
3735 gSignalMap[sig].fOldHandler) < 0)
3736 ::SysError("TUnixSystem::UnixSignal", "sigaction");
3737 }
3738}
3739
3740////////////////////////////////////////////////////////////////////////////////
3741/// If ignore is true ignore the specified signal, else restore previous
3742/// behaviour.
3743
3745{
3748
3749 if (ignore != ignoreSig[sig]) {
3750 ignoreSig[sig] = ignore;
3751 if (ignore) {
3752 struct sigaction sigact;
3753#if defined(R__SUN)
3754 sigact.sa_handler = (void (*)())SIG_IGN;
3755#elif defined(R__SOLARIS)
3756 sigact.sa_handler = (void (*)(int))SIG_IGN;
3757#else
3758 sigact.sa_handler = SIG_IGN;
3759#endif
3760 sigemptyset(&sigact.sa_mask);
3761 sigact.sa_flags = 0;
3762 if (sigaction(gSignalMap[sig].fCode, &sigact, &oldsigact[sig]) < 0)
3763 ::SysError("TUnixSystem::UnixIgnoreSignal", "sigaction");
3764 } else {
3765 if (sigaction(gSignalMap[sig].fCode, &oldsigact[sig], nullptr) < 0)
3766 ::SysError("TUnixSystem::UnixIgnoreSignal", "sigaction");
3767 }
3768 }
3769}
3770
3771////////////////////////////////////////////////////////////////////////////////
3772/// When the argument is true the SIGALRM signal handler is set so that
3773/// interrupted syscalls will not be restarted by the kernel. This is
3774/// typically used in case one wants to put a timeout on an I/O operation.
3775/// By default interrupted syscalls will always be restarted (for all
3776/// signals). This can be controlled for each a-synchronous TTimer via
3777/// the method TTimer::SetInterruptSyscalls().
3778
3780{
3781 if (gSignalMap[kSigAlarm].fHandler) {
3782 struct sigaction sigact;
3783#if defined(R__SUN)
3784 sigact.sa_handler = (void (*)())sighandler;
3785#elif defined(R__SOLARIS)
3786 sigact.sa_handler = sighandler;
3787#elif defined(R__LYNXOS)
3788# if (__GNUG__>=3)
3789 sigact.sa_handler = sighandler;
3790# else
3791 sigact.sa_handler = (void (*)(...))sighandler;
3792# endif
3793#else
3794 sigact.sa_handler = sighandler;
3795#endif
3796 sigemptyset(&sigact.sa_mask);
3797 sigact.sa_flags = 0;
3798 if (set) {
3799#if defined(SA_INTERRUPT) // SunOS
3800 sigact.sa_flags |= SA_INTERRUPT;
3801#endif
3802 } else {
3803#if defined(SA_RESTART)
3804 sigact.sa_flags |= SA_RESTART;
3805#endif
3806 }
3807 if (sigaction(gSignalMap[kSigAlarm].fCode, &sigact, nullptr) < 0)
3808 ::SysError("TUnixSystem::UnixSigAlarmInterruptsSyscalls", "sigaction");
3809 }
3810}
3811
3812////////////////////////////////////////////////////////////////////////////////
3813/// Return the signal name associated with a signal.
3814
3816{
3817 return gSignalMap[sig].fSigName;
3818}
3819
3820////////////////////////////////////////////////////////////////////////////////
3821/// Restore old signal handler for specified signal.
3822
3824{
3825 if (gSignalMap[sig].fOldHandler) {
3826 // restore old signal handler
3827 if (sigaction(gSignalMap[sig].fCode, gSignalMap[sig].fOldHandler, nullptr) < 0)
3828 ::SysError("TUnixSystem::UnixSignal", "sigaction");
3829 delete gSignalMap[sig].fOldHandler;
3830 gSignalMap[sig].fOldHandler = nullptr;
3831 gSignalMap[sig].fHandler = nullptr;
3832 }
3833}
3834
3835////////////////////////////////////////////////////////////////////////////////
3836/// Restore old signal handlers.
3837
3839{
3840 for (int sig = 0; sig < kMAXSIGNALS; sig++)
3842}
3843
3844//---- time --------------------------------------------------------------------
3845
3846////////////////////////////////////////////////////////////////////////////////
3847/// Get current time in milliseconds since 0:00 Jan 1 1995.
3848
3850{
3851 static std::atomic<time_t> jan95{0};
3852 if (!jan95) {
3853 struct tm tp;
3854 tp.tm_year = 95;
3855 tp.tm_mon = 0;
3856 tp.tm_mday = 1;
3857 tp.tm_hour = 0;
3858 tp.tm_min = 0;
3859 tp.tm_sec = 0;
3860 tp.tm_isdst = -1;
3861
3862 jan95 = mktime(&tp);
3863 if ((int)jan95 == -1) {
3864 ::SysError("TUnixSystem::UnixNow", "error converting 950001 0:00 to time_t");
3865 return 0;
3866 }
3867 }
3868
3869 struct timeval t;
3870 gettimeofday(&t, nullptr);
3871 return Long64_t(t.tv_sec-(Long_t)jan95)*1000 + t.tv_usec/1000;
3872}
3873
3874////////////////////////////////////////////////////////////////////////////////
3875/// Set interval timer to time-out in ms milliseconds.
3876
3878{
3879 struct itimerval itv;
3880 itv.it_value.tv_sec = 0;
3881 itv.it_value.tv_usec = 0;
3882 itv.it_interval.tv_sec = 0;
3883 itv.it_interval.tv_usec = 0;
3884 if (ms > 0) {
3885 itv.it_value.tv_sec = time_t(ms / 1000);
3886 itv.it_value.tv_usec = time_t((ms % 1000) * 1000);
3887 }
3888 int st = setitimer(ITIMER_REAL, &itv, nullptr);
3889 if (st == -1)
3890 ::SysError("TUnixSystem::UnixSetitimer", "setitimer");
3891 return st;
3892}
3893
3894//---- file descriptors --------------------------------------------------------
3895
3896////////////////////////////////////////////////////////////////////////////////
3897/// Wait for events on the file descriptors specified in the readready and
3898/// writeready masks or for timeout (in milliseconds) to occur. Returns
3899/// the number of ready descriptors, or 0 in case of timeout, or < 0 in
3900/// case of an error, with -2 being EINTR and -3 EBADF. In case of EINTR
3901/// the errno has been reset and the method can be called again.
3902
3905{
3906 int retcode;
3907
3908 fd_set *rd = (readready) ? (fd_set*)readready->GetBits() : nullptr;
3909 fd_set *wr = (writeready) ? (fd_set*)writeready->GetBits() : nullptr;
3910
3911 if (timeout >= 0) {
3912 struct timeval tv;
3913 tv.tv_sec = Int_t(timeout / 1000);
3914 tv.tv_usec = (timeout % 1000) * 1000;
3915 retcode = select(nfds, rd, wr, nullptr, &tv);
3916 } else {
3917 retcode = select(nfds, rd, wr, nullptr, nullptr);
3918 }
3919 if (retcode == -1) {
3920 if (GetErrno() == EINTR) {
3921 ResetErrno(); // errno is not self reseting
3922 return -2;
3923 }
3924 if (GetErrno() == EBADF)
3925 return -3;
3926 return -1;
3927 }
3928
3929 return retcode;
3930}
3931
3932//---- directories -------------------------------------------------------------
3933
3934////////////////////////////////////////////////////////////////////////////////
3935/// Returns the user's home directory.
3936
3937const char *TUnixSystem::UnixHomedirectory(const char *name)
3938{
3939 static char path[kMAXPATHLEN], mydir[kMAXPATHLEN] = { '\0' };
3940 return UnixHomedirectory(name, path, mydir);
3941}
3942
3943////////////////////////////////////////////////////////////////////////////
3944/// Returns the user's home directory.
3945
3946const char *TUnixSystem::UnixHomedirectory(const char *name, char *path, char *mydir)
3947{
3948 struct passwd *pw;
3949 if (name) {
3950 pw = getpwnam(name);
3951 if (pw) {
3952 strncpy(path, pw->pw_dir, kMAXPATHLEN-1);
3953 path[kMAXPATHLEN-1] = '\0';
3954 return path;
3955 }
3956 } else {
3957 if (mydir[0])
3958 return mydir;
3959 pw = getpwuid(getuid());
3960 if (gSystem->Getenv("HOME")) {
3961 strncpy(mydir, gSystem->Getenv("HOME"), kMAXPATHLEN-1);
3962 mydir[kMAXPATHLEN-1] = '\0';
3963 return mydir;
3964 } else if (pw && pw->pw_dir) {
3965 strncpy(mydir, pw->pw_dir, kMAXPATHLEN-1);
3966 mydir[kMAXPATHLEN-1] = '\0';
3967 return mydir;
3968 }
3969 }
3970 return nullptr;
3971}
3972
3973////////////////////////////////////////////////////////////////////////////////
3974/// Make a Unix file system directory. Returns 0 in case of success and
3975/// -1 if the directory could not be created (either already exists or
3976/// illegal path name).
3977
3978int TUnixSystem::UnixMakedir(const char *dir)
3979{
3980 return ::mkdir(StripOffProto(dir, "file:"), 0755);
3981}
3982
3983////////////////////////////////////////////////////////////////////////////////
3984/// Open a directory.
3985
3986void *TUnixSystem::UnixOpendir(const char *dir)
3987{
3988 struct stat finfo;
3989
3990 const char *edir = StripOffProto(dir, "file:");
3991
3992 if (stat(edir, &finfo) < 0)
3993 return nullptr;
3994
3995 if (!S_ISDIR(finfo.st_mode))
3996 return nullptr;
3997
3998 return (void*) opendir(edir);
3999}
4000
4001#if defined(_POSIX_SOURCE)
4002// Posix does not require that the d_ino field be present, and some
4003// systems do not provide it.
4004# define REAL_DIR_ENTRY(dp) 1
4005#else
4006# define REAL_DIR_ENTRY(dp) (dp->d_ino != 0)
4007#endif
4008
4009////////////////////////////////////////////////////////////////////////////////
4010/// Returns the next directory entry.
4011
4013{
4014 DIR *dirp = (DIR*)dirp1;
4015#ifdef HAS_DIRENT
4016 struct dirent *dp;
4017#else
4018 struct direct *dp;
4019#endif
4020
4021 if (dirp) {
4022 for (;;) {
4023 dp = readdir(dirp);
4024 if (!dp)
4025 return nullptr;
4026 if (REAL_DIR_ENTRY(dp))
4027 return dp->d_name;
4028 }
4029 }
4030 return nullptr;
4031}
4032
4033//---- files -------------------------------------------------------------------
4034
4035////////////////////////////////////////////////////////////////////////////////
4036/// Get info about a file. Info is returned in the form of a FileStat_t
4037/// structure (see TSystem.h).
4038/// The function returns 0 in case of success and 1 if the file could
4039/// not be stat'ed.
4040
4042{
4043 const char *path = StripOffProto(fpath, "file:");
4044 buf.fIsLink = kFALSE;
4045
4046#if defined(R__SEEK64)
4047 struct stat64 sbuf;
4048 if (path && lstat64(path, &sbuf) == 0) {
4049#else
4050 struct stat sbuf;
4051 if (path && lstat(path, &sbuf) == 0) {
4052#endif
4053 buf.fIsLink = S_ISLNK(sbuf.st_mode);
4054 if (buf.fIsLink) {
4055#if defined(R__SEEK64)
4056 if (stat64(path, &sbuf) == -1) {
4057#else
4058 if (stat(path, &sbuf) == -1) {
4059#endif
4060 return 1;
4061 }
4062 }
4063 buf.fDev = sbuf.st_dev;
4064 buf.fIno = sbuf.st_ino;
4065 buf.fMode = sbuf.st_mode;
4066 buf.fUid = sbuf.st_uid;
4067 buf.fGid = sbuf.st_gid;
4068 buf.fSize = sbuf.st_size;
4069 buf.fMtime = sbuf.st_mtime;
4070
4071 return 0;
4072 }
4073 return 1;
4074}
4075
4076////////////////////////////////////////////////////////////////////////////////
4077/// Get info about a file system: id, bsize, bfree, blocks.
4078/// Id is file system type (machine dependend, see statfs())
4079/// Bsize is block size of file system
4080/// Blocks is total number of blocks in file system
4081/// Bfree is number of free blocks in file system
4082/// The function returns 0 in case of success and 1 if the file system could
4083/// not be stat'ed.
4084
4085int TUnixSystem::UnixFSstat(const char *path, Long_t *id, Long_t *bsize,
4087{
4088 struct statfs statfsbuf;
4089#if (defined(R__SOLARIS) && !defined(R__LINUX))
4090 if (statfs(path, &statfsbuf, sizeof(struct statfs), 0) == 0) {
4091 *id = statfsbuf.f_fstyp;
4092 *bsize = statfsbuf.f_bsize;
4093 *blocks = statfsbuf.f_blocks;
4094 *bfree = statfsbuf.f_bfree;
4095#else
4096 if (statfs((char*)path, &statfsbuf) == 0) {
4097#ifdef R__OBSD
4098 // Convert BSD filesystem names to Linux filesystem type numbers
4099 // where possible. Linux statfs uses a value of -1 to indicate
4100 // an unsupported field.
4101
4102 if (!strcmp(statfsbuf.f_fstypename, MOUNT_FFS) ||
4103 !strcmp(statfsbuf.f_fstypename, MOUNT_MFS))
4104 *id = 0x11954;
4105 else if (!strcmp(statfsbuf.f_fstypename, MOUNT_NFS))
4106 *id = 0x6969;
4107 else if (!strcmp(statfsbuf.f_fstypename, MOUNT_MSDOS))
4108 *id = 0x4d44;
4109 else if (!strcmp(statfsbuf.f_fstypename, MOUNT_EXT2FS))
4110 *id = 0xef53;
4111 else if (!strcmp(statfsbuf.f_fstypename, MOUNT_CD9660))
4112 *id = 0x9660;
4113 else if (!strcmp(statfsbuf.f_fstypename, MOUNT_NCPFS))
4114 *id = 0x6969;
4115 else
4116 *id = -1;
4117#else
4118 *id = statfsbuf.f_type;
4119#endif
4120 *bsize = statfsbuf.f_bsize;
4121 *blocks = statfsbuf.f_blocks;
4122 *bfree = statfsbuf.f_bavail;
4123#endif
4124 return 0;
4125 }
4126 return 1;
4127}
4128
4129////////////////////////////////////////////////////////////////////////////////
4130/// Wait till child is finished.
4131
4133{
4134 int status;
4135 return (int) waitpid(0, &status, WNOHANG);
4136}
4137
4138//---- RPC -------------------------------------------------------------------
4139
4140////////////////////////////////////////////////////////////////////////////////
4141/// Open a TCP/IP connection to server and connect to a service (i.e. port).
4142/// Use tcpwindowsize to specify the size of the receive buffer, it has
4143/// to be specified here to make sure the window scale option is set (for
4144/// tcpwindowsize > 65KB and for platforms supporting window scaling).
4145/// Is called via the TSocket constructor. Returns -1 in case of error.
4146
4147int TUnixSystem::UnixTcpConnect(const char *hostname, int port,
4148 int tcpwindowsize)
4149{
4150 short sport;
4151 struct servent *sp;
4152
4153 if ((sp = getservbyport(htons(port), kProtocolName)))
4154 sport = sp->s_port;
4155 else
4156 sport = htons(port);
4157
4159 if (!addr.IsValid()) return -1;
4160 UInt_t adr = htonl(addr.GetAddress());
4161
4162 struct sockaddr_in server;
4163 memset(&server, 0, sizeof(server));
4164 memcpy(&server.sin_addr, &adr, sizeof(adr));
4165 server.sin_family = addr.GetFamily();
4166 server.sin_port = sport;
4167
4168 // Create socket
4169 int sock;
4170 if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
4171 ::SysError("TUnixSystem::UnixTcpConnect", "socket (%s:%d)",
4172 hostname, port);
4173 return -1;
4174 }
4175
4176 if (tcpwindowsize > 0) {
4179 }
4180
4181 while (connect(sock, (struct sockaddr*) &server, sizeof(server)) == -1) {
4182 if (GetErrno() == EINTR)
4183 ResetErrno();
4184 else {
4185 ::SysError("TUnixSystem::UnixTcpConnect", "connect (%s:%d)",
4186 hostname, port);
4187 close(sock);
4188 return -1;
4189 }
4190 }
4191 return sock;
4192}
4193
4194
4195////////////////////////////////////////////////////////////////////////////////
4196/// Creates a UDP socket connection
4197/// Is called via the TSocket constructor. Returns -1 in case of error.
4198
4199int TUnixSystem::UnixUdpConnect(const char *hostname, int port)
4200{
4201 short sport;
4202 struct servent *sp;
4203
4204 if ((sp = getservbyport(htons(port), kProtocolName)))
4205 sport = sp->s_port;
4206 else
4207 sport = htons(port);
4208
4210 if (!addr.IsValid()) return -1;
4211 UInt_t adr = htonl(addr.GetAddress());
4212
4213 struct sockaddr_in server;
4214 memset(&server, 0, sizeof(server));
4215 memcpy(&server.sin_addr, &adr, sizeof(adr));
4216 server.sin_family = addr.GetFamily();
4217 server.sin_port = sport;
4218
4219 // Create socket
4220 int sock;
4221 if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
4222 ::SysError("TUnixSystem::UnixUdpConnect", "socket (%s:%d)",
4223 hostname, port);
4224 return -1;
4225 }
4226
4227 while (connect(sock, (struct sockaddr*) &server, sizeof(server)) == -1) {
4228 if (GetErrno() == EINTR)
4229 ResetErrno();
4230 else {
4231 ::SysError("TUnixSystem::UnixUdpConnect", "connect (%s:%d)",
4232 hostname, port);
4233 close(sock);
4234 return -1;
4235 }
4236 }
4237 return sock;
4238}
4239
4240////////////////////////////////////////////////////////////////////////////////
4241/// Connect to a Unix domain socket.
4242
4244{
4245 return UnixUnixConnect(TString::Format("%s/%d", kServerPath, port));
4246}
4247
4248////////////////////////////////////////////////////////////////////////////////
4249/// Connect to a Unix domain socket. Returns -1 in case of error.
4250
4252{
4253 if (!sockpath || strlen(sockpath) <= 0) {
4254 ::SysError("TUnixSystem::UnixUnixConnect", "socket path undefined");
4255 return -1;
4256 }
4257
4258 int sock;
4259 struct sockaddr_un unserver;
4260 unserver.sun_family = AF_UNIX;
4261
4262 if (strlen(sockpath) > sizeof(unserver.sun_path)-1) {
4263 ::Error("TUnixSystem::UnixUnixConnect", "socket path %s, longer than max allowed length (%u)",
4264 sockpath, (UInt_t)sizeof(unserver.sun_path)-1);
4265 return -1;
4266 }
4267 strlcpy(unserver.sun_path, sockpath, sizeof(unserver.sun_path));
4268
4269 // Open socket
4270 if ((sock = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
4271 ::SysError("TUnixSystem::UnixUnixConnect", "socket");
4272 return -1;
4273 }
4274
4275 while (connect(sock, (struct sockaddr*) &unserver, strlen(unserver.sun_path)+2) == -1) {
4276 if (GetErrno() == EINTR)
4277 ResetErrno();
4278 else {
4279 ::SysError("TUnixSystem::UnixUnixConnect", "connect");
4280 close(sock);
4281 return -1;
4282 }
4283 }
4284 return sock;
4285}
4286
4287////////////////////////////////////////////////////////////////////////////////
4288/// Open a socket, bind to it and start listening for TCP/IP connections
4289/// on the port. If reuse is true reuse the address, backlog specifies
4290/// how many sockets can be waiting to be accepted. If port is 0 a port
4291/// scan will be done to find a free port. This option is mutual exlusive
4292/// with the reuse option.
4293/// Use tcpwindowsize to specify the size of the receive buffer, it has
4294/// to be specified here to make sure the window scale option is set (for
4295/// tcpwindowsize > 65KB and for platforms supporting window scaling).
4296/// The socketBindOption parameter allows to specify how the socket will be
4297/// bound. See the documentation of ESocketBindOption for the details.
4298/// Returns socket fd or -1 if socket() failed, -2 if bind() failed
4299/// or -3 if listen() failed.
4300
4303{
4304 const short kSOCKET_MINPORT = 5000, kSOCKET_MAXPORT = 15000;
4305 short sport, tryport = kSOCKET_MINPORT;
4306 struct servent *sp;
4307
4308 if (port == 0 && reuse) {
4309 ::Error("TUnixSystem::UnixTcpService", "cannot do a port scan while reuse is true");
4310 return -1;
4311 }
4312
4313 if ((sp = getservbyport(htons(port), kProtocolName)))
4314 sport = sp->s_port;
4315 else
4316 sport = htons(port);
4317
4318 // Create tcp socket
4319 int sock;
4320 if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
4321 ::SysError("TUnixSystem::UnixTcpService", "socket");
4322 return -1;
4323 }
4324
4325 if (reuse)
4326 gSystem->SetSockOpt(sock, kReuseAddr, 1);
4327
4328 if (tcpwindowsize > 0) {
4331 }
4332
4333 struct sockaddr_in inserver;
4334 memset(&inserver, 0, sizeof(inserver));
4335 inserver.sin_family = AF_INET;
4337 inserver.sin_port = sport;
4338
4339 // Bind socket
4340 if (port > 0) {
4341 if (::bind(sock, (struct sockaddr*) &inserver, sizeof(inserver))) {
4342 ::SysError("TUnixSystem::UnixTcpService", "bind");
4343 close(sock);
4344 return -2;
4345 }
4346 } else {
4347 int bret;
4348 do {
4349 inserver.sin_port = htons(tryport);
4350 bret = ::bind(sock, (struct sockaddr*) &inserver, sizeof(inserver));
4351 tryport++;
4352 } while (bret < 0 && GetErrno() == EADDRINUSE && tryport < kSOCKET_MAXPORT);
4353 if (bret < 0) {
4354 ::SysError("TUnixSystem::UnixTcpService", "bind (port scan)");
4355 close(sock);
4356 return -2;
4357 }
4358 }
4359
4360 // Start accepting connections
4361 if (::listen(sock, backlog)) {
4362 ::SysError("TUnixSystem::UnixTcpService", "listen");
4363 close(sock);
4364 return -3;
4365 }
4366
4367 return sock;
4368}
4369
4370////////////////////////////////////////////////////////////////////////////////
4371/// Open a socket, bind to it and start listening for UDP connections
4372/// on the port. If reuse is true reuse the address, backlog specifies
4373/// how many sockets can be waiting to be accepted. If port is 0 a port
4374/// scan will be done to find a free port. This option is mutual exlusive
4375/// with the reuse option.
4376/// The socketBindOption parameter allows to specify how the socket will be
4377/// bound. See the documentation of ESocketBindOption for the details.
4378
4380{
4381 const short kSOCKET_MINPORT = 5000, kSOCKET_MAXPORT = 15000;
4382 short sport, tryport = kSOCKET_MINPORT;
4383 struct servent *sp;
4384
4385 if ((sp = getservbyport(htons(port), kProtocolName)))
4386 sport = sp->s_port;
4387 else
4388 sport = htons(port);
4389
4390 // Create udp socket
4391 int sock;
4392 if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
4393 ::SysError("TUnixSystem::UnixUdpService", "socket");
4394 return -1;
4395 }
4396
4397 struct sockaddr_in inserver;
4398 memset(&inserver, 0, sizeof(inserver));
4399 inserver.sin_family = AF_INET;
4401 inserver.sin_port = sport;
4402
4403 // Bind socket
4404 if (port > 0) {
4405 if (::bind(sock, (struct sockaddr*) &inserver, sizeof(inserver))) {
4406 ::SysError("TUnixSystem::UnixUdpService", "bind");
4407 close(sock);
4408 return -2;
4409 }
4410 } else {
4411 int bret;
4412 do {
4413 inserver.sin_port = htons(tryport);
4414 bret = ::bind(sock, (struct sockaddr*) &inserver, sizeof(inserver));
4415 tryport++;
4416 } while (bret < 0 && GetErrno() == EADDRINUSE && tryport < kSOCKET_MAXPORT);
4417 if (bret < 0) {
4418 ::SysError("TUnixSystem::UnixUdpService", "bind (port scan)");
4419 close(sock);
4420 return -2;
4421 }
4422 }
4423
4424 // Start accepting connections
4425 if (::listen(sock, backlog)) {
4426 ::SysError("TUnixSystem::UnixUdpService", "listen");
4427 close(sock);
4428 return -3;
4429 }
4430
4431 return sock;
4432}
4433
4434////////////////////////////////////////////////////////////////////////////////
4435/// Open a socket, bind to it and start listening for Unix domain connections
4436/// to it. Returns socket fd or -1.
4437
4439{
4440 int oldumask;
4441
4442 // Assure that socket directory exists
4443 oldumask = umask(0);
4444 int res = ::mkdir(kServerPath, 0777);
4445 umask(oldumask);
4446
4447 if (res == -1)
4448 return -1;
4449
4450 // Socket path
4452 sockpath.Form("%s/%d", kServerPath, port);
4453
4454 // Remove old socket
4455 unlink(sockpath.Data());
4456
4458}
4459
4460////////////////////////////////////////////////////////////////////////////////
4461/// Open a socket on path 'sockpath', bind to it and start listening for Unix
4462/// domain connections to it. Returns socket fd or -1.
4463
4465{
4466 if (!sockpath || strlen(sockpath) <= 0) {
4467 ::SysError("TUnixSystem::UnixUnixService", "socket path undefined");
4468 return -1;
4469 }
4470
4471 struct sockaddr_un unserver;
4472 int sock;
4473
4474 // Prepare structure
4475 memset(&unserver, 0, sizeof(unserver));
4476 unserver.sun_family = AF_UNIX;
4477
4478 if (strlen(sockpath) > sizeof(unserver.sun_path)-1) {
4479 ::Error("TUnixSystem::UnixUnixService", "socket path %s, longer than max allowed length (%u)",
4480 sockpath, (UInt_t)sizeof(unserver.sun_path)-1);
4481 return -1;
4482 }
4483 strlcpy(unserver.sun_path, sockpath, sizeof(unserver.sun_path));
4484
4485 // Create socket
4486 if ((sock = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
4487 ::SysError("TUnixSystem::UnixUnixService", "socket");
4488 return -1;
4489 }
4490
4491 if (::bind(sock, (struct sockaddr*) &unserver, strlen(unserver.sun_path)+2)) {
4492 ::SysError("TUnixSystem::UnixUnixService", "bind");
4493 close(sock);
4494 return -1;
4495 }
4496
4497 // Start accepting connections
4498 if (::listen(sock, backlog)) {
4499 ::SysError("TUnixSystem::UnixUnixService", "listen");
4500 close(sock);
4501 return -1;
4502 }
4503
4504 return sock;
4505}
4506
4507////////////////////////////////////////////////////////////////////////////////
4508/// Receive exactly length bytes into buffer. Returns number of bytes
4509/// received. Returns -1 in case of error, -2 in case of MSG_OOB
4510/// and errno == EWOULDBLOCK, -3 in case of MSG_OOB and errno == EINVAL
4511/// and -4 in case of kNoBlock and errno == EWOULDBLOCK.
4512/// Returns -5 if pipe broken or reset by peer (EPIPE || ECONNRESET).
4513
4514int TUnixSystem::UnixRecv(int sock, void *buffer, int length, int flag)
4515{
4516 ResetErrno();
4517
4518 if (sock < 0) return -1;
4519
4520 int once = 0;
4521 if (flag == -1) {
4522 flag = 0;
4523 once = 1;
4524 }
4525 if (flag == MSG_PEEK)
4526 once = 1;
4527
4528 int n, nrecv = 0;
4529 char *buf = (char *)buffer;
4530
4531 for (n = 0; n < length; n += nrecv) {
4532 if ((nrecv = recv(sock, buf+n, length-n, flag)) <= 0) {
4533 if (nrecv == 0)
4534 break; // EOF
4535 if (flag == MSG_OOB) {
4536 if (GetErrno() == EWOULDBLOCK)
4537 return -2;
4538 else if (GetErrno() == EINVAL)
4539 return -3;
4540 }
4541 if (GetErrno() == EWOULDBLOCK)
4542 return -4;
4543 else {
4544 if (GetErrno() != EINTR)
4545 ::SysError("TUnixSystem::UnixRecv", "recv");
4546 if (GetErrno() == EPIPE || GetErrno() == ECONNRESET)
4547 return -5;
4548 else
4549 return -1;
4550 }
4551 }
4552 if (once)
4553 return nrecv;
4554 }
4555 return n;
4556}
4557
4558////////////////////////////////////////////////////////////////////////////////
4559/// Send exactly length bytes from buffer. Returns -1 in case of error,
4560/// otherwise number of sent bytes. Returns -4 in case of kNoBlock and
4561/// errno == EWOULDBLOCK. Returns -5 if pipe broken or reset by peer
4562/// (EPIPE || ECONNRESET).
4563
4564int TUnixSystem::UnixSend(int sock, const void *buffer, int length, int flag)
4565{
4566 if (sock < 0) return -1;
4567
4568 int once = 0;
4569 if (flag == -1) {
4570 flag = 0;
4571 once = 1;
4572 }
4573
4574 int n, nsent = 0;
4575 const char *buf = (const char *)buffer;
4576
4577 for (n = 0; n < length; n += nsent) {
4578 if ((nsent = send(sock, buf+n, length-n, flag)) <= 0) {
4579 if (nsent == 0)
4580 break;
4581 if (GetErrno() == EWOULDBLOCK)
4582 return -4;
4583 else {
4584 if (GetErrno() != EINTR)
4585 ::SysError("TUnixSystem::UnixSend", "send");
4586 if (GetErrno() == EPIPE || GetErrno() == ECONNRESET)
4587 return -5;
4588 else
4589 return -1;
4590 }
4591 }
4592 if (once)
4593 return nsent;
4594 }
4595 return n;
4596}
4597
4598//---- Dynamic Loading ---------------------------------------------------------
4599
4600////////////////////////////////////////////////////////////////////////////////
4601/// Get shared library search path. Static utility function.
4602
4603static const char *DynamicPath(const char *newpath = nullptr, Bool_t reset = kFALSE)
4604{
4605 static TString dynpath_full;
4606 static std::atomic<bool> initialized(kFALSE);
4607 static std::atomic<bool> seenCling(kFALSE);
4608
4609 // If we have not seen Cling but the result has been initialized and gCling
4610 // is still nullptr, the result won't change.
4611 if (newpath == nullptr && !reset && (seenCling || (initialized && gCling == nullptr)))
4612 return dynpath_full;
4613
4615
4616 if (newpath) {
4618 // Don't erase the user given path at the next call.
4619 initialized = kTRUE;
4620 // We do not (otherwise) record whether the path was set automatically or
4621 // whether it was set explicitly by the user. If the user set the path
4622 // explicitly, we should never automatically over-ride the value; if
4623 // seenCling stayed false, it would tell this routine that at the next
4624 // call it should update the value (to insert the Cling provided parts)
4625 // back to the default.
4626 seenCling = kTRUE;
4627 return dynpath_full;
4628 }
4629
4630 // Another thread might have updated this. Even-though this is executed at the
4631 // start of the process, we might get there if the user is explicitly
4632 // 'resetting' the value.
4633 if (!reset && (seenCling || (initialized && gCling == nullptr)))
4634 return dynpath_full;
4635
4636 if (!initialized) {
4637 // force one time initialization of gROOT before we start
4638 // (otherwise it might be done as a side effect of gEnv->GetValue and
4639 // TROOT's initialization will call this routine).
4640 gROOT;
4641 }
4642
4643 static TString dynpath_envpart;
4644 static TString dynpath_syspart;
4645
4646 if (reset || !initialized) {
4647
4648 dynpath_envpart = gSystem->Getenv("ROOT_LIBRARY_PATH");
4649 TString rdynpath = gEnv->GetValue("Root.DynamicPath", nullptr);
4650 rdynpath.ReplaceAll(": ", ":"); // in case DynamicPath was extended
4651 if (rdynpath.IsNull()) {
4652 rdynpath = ".:"; rdynpath += TROOT::GetLibDir();
4653 }
4655 #if defined (R__AIX)
4656 ldpath = gSystem->Getenv("LIBPATH");
4657 #elif defined(R__MACOSX)
4658 ldpath = gSystem->Getenv("DYLD_LIBRARY_PATH");
4659 if (!ldpath.IsNull())
4660 ldpath += ":";
4661 ldpath += gSystem->Getenv("LD_LIBRARY_PATH");
4662 if (!ldpath.IsNull())
4663 ldpath += ":";
4664 ldpath += gSystem->Getenv("DYLD_FALLBACK_LIBRARY_PATH");
4665 #else
4666 ldpath = gSystem->Getenv("LD_LIBRARY_PATH");
4667 #endif
4668 if (!ldpath.IsNull()) {
4669 if (!dynpath_envpart.IsNull())
4670 dynpath_envpart += ":";
4672 }
4673 if (!rdynpath.IsNull()) {
4674 if (!dynpath_envpart.IsNull())
4675 dynpath_envpart += ":";
4677 }
4678 if (!dynpath_envpart.Contains(TROOT::GetLibDir())) {
4680 }
4681
4682 #if defined(R__WINGCC) || defined(R__MACOSX)
4683 // if (!dynpath.EndsWith(":")) dynpath += ":";
4684 dynpath_syspart = "/usr/local/lib:/usr/X11R6/lib:/usr/lib:/lib:";
4685 dynpath_syspart += "/lib/x86_64-linux-gnu:/usr/local/lib64:/usr/lib64:/lib64:";
4686 #else
4687 // trick to get the system search path
4688 std::string cmd("LD_DEBUG=libs LD_PRELOAD=DOESNOTEXIST ls 2>&1");
4689 FILE *pf = popen(cmd.c_str (), "r");
4690 std::string result = "";
4691 char buffer[128];
4692 while (!feof(pf)) {
4693 if (fgets(buffer, 128, pf) != nullptr)
4694 result += buffer;
4695 }
4696 pclose(pf);
4697 std::size_t from = result.find("search path=", result.find("(LD_LIBRARY_PATH)"));
4698 std::size_t to = result.find("(system search path)");
4699 if (from != std::string::npos && to != std::string::npos) {
4700 from += 12;
4701 std::string sys_path = result.substr(from, to-from);
4702 sys_path.erase(std::remove_if(sys_path.begin(), sys_path.end(), isspace), sys_path.end());
4703 dynpath_syspart = sys_path.c_str();
4704 }
4705 dynpath_envpart.ReplaceAll("::", ":");
4706 dynpath_syspart.ReplaceAll("::", ":");
4707 #endif
4708 }
4709
4710 if (!initialized || (!seenCling && gCling)) {
4712 if (!dynpath_full.EndsWith(":")) dynpath_full += ":";
4713 if (gCling) {
4715 if (!dynpath_full.EndsWith(":")) dynpath_full += ":";
4716
4717 seenCling = kTRUE;
4718 }
4720 initialized = kTRUE;
4721
4722 if (gDebug > 0) std::cout << "dynpath = " << dynpath_full.Data() << std::endl;
4723 }
4724
4725 return dynpath_full;
4726}
4727
4728////////////////////////////////////////////////////////////////////////////////
4729/// Add a new directory to the dynamic path.
4730
4731void TUnixSystem::AddDynamicPath(const char *path)
4732{
4733 if (path) {
4734 TString oldpath = DynamicPath(nullptr, kFALSE);
4735 oldpath.Append(":");
4736 oldpath.Append(path);
4738 }
4739}
4740
4741////////////////////////////////////////////////////////////////////////////////
4742/// Return the dynamic path (used to find shared libraries).
4743
4745{
4746 return DynamicPath(nullptr, kFALSE);
4747}
4748
4749////////////////////////////////////////////////////////////////////////////////
4750/// Set the dynamic path to a new value.
4751/// If the value of 'path' is zero, the dynamic path is reset to its
4752/// default value.
4753
4754void TUnixSystem::SetDynamicPath(const char *path)
4755{
4756 if (!path)
4757 DynamicPath(nullptr, kTRUE);
4758 else
4759 DynamicPath(path);
4760}
4761
4762////////////////////////////////////////////////////////////////////////////////
4763/// Returns the path of a shared library (searches for library in the
4764/// shared library search path). If no file name extension is provided
4765/// it first tries .so, .sl, .dl and then .a (for AIX).
4766
4768{
4769 char buf[PATH_MAX + 1];
4770 char *res = realpath(sLib.Data(), buf);
4771 if (res) sLib = buf;
4774 return sLib;
4775 }
4776 sLib = searchFor;
4777 const char* lib = sLib.Data();
4778 int len = sLib.Length();
4779 if (len > 3 && (!strcmp(lib+len-3, ".so") ||
4780 !strcmp(lib+len-3, ".dl") ||
4781 !strcmp(lib+len-4, ".dll") ||
4782 !strcmp(lib+len-4, ".DLL") ||
4783 !strcmp(lib+len-6, ".dylib") ||
4784 !strcmp(lib+len-3, ".sl") ||
4785 !strcmp(lib+len-2, ".a"))) {
4787 return sLib;
4788 }
4789 if (!quiet)
4790 Error("FindDynamicLibrary",
4791 "%s does not exist in %s", searchFor.Data(), GetDynamicPath());
4792 return nullptr;
4793 }
4794 static const char* exts[] = {
4795 ".so", ".dll", ".dylib", ".sl", ".dl", ".a", nullptr };
4796 const char** ext = exts;
4797 while (*ext) {
4799 fname += *ext;
4800 ++ext;
4802 sLib.Swap(fname);
4803 return sLib;
4804 }
4805 }
4806
4807 if (!quiet)
4808 Error("FindDynamicLibrary",
4809 "%s[.so | .dll | .dylib | .sl | .dl | .a] does not exist in %s",
4810 searchFor.Data(), GetDynamicPath());
4811
4812 return nullptr;
4813}
4814
4815//---- System, CPU and Memory info ---------------------------------------------
4816
4817#if defined(R__FBSD)
4818///////////////////////////////////////////////////////////////////////////////
4819//// Get system info for FreeBSD
4820
4822{
4823 // it probably would be better to get this information from syscalls
4824 // this is possibly less error prone
4825 FILE *p = gSystem->OpenPipe("sysctl -n kern.ostype hw.model hw.ncpu "
4826 "hw.realmem dev.cpu.0.freq", "r");
4827 TString s;
4828 s.Gets(p);
4829 sysinfo->fOS = s;
4830 s.Gets(p);
4831 sysinfo->fCpuType = s;
4832 s.Gets(p);
4833 sysinfo->fCpus = s.Atoi();
4834 s.Gets(p);
4835 Long64_t t = s.Atoll();
4836 sysinfo->fPhysRam = Int_t(t / 1024 / 1024);
4837 s.Gets(p);
4838 t = s.Atoll();
4839 sysinfo->fCpuSpeed = Int_t(t);
4841}
4842
4843static void GetFreeBSDCpuInfo(CpuInfo_t*, Int_t)
4844{
4845 Error("ListSymbols", "not yet implemented");
4846}
4847#endif
4848
4849#if defined(R__MACOSX)
4850#include <sys/resource.h>
4851#include <mach/mach.h>
4852#include <mach/mach_error.h>
4853
4854////////////////////////////////////////////////////////////////////////////////
4855/// Get system info for Mac OS X.
4856
4858{
4859 FILE *p = gSystem->OpenPipe("sysctl -n kern.ostype hw.model hw.ncpu hw.cpufrequency "
4860 "hw.busfrequency hw.l2cachesize hw.memsize", "r");
4861 TString s;
4862 s.Gets(p);
4863 sysinfo->fOS = s;
4864 s.Gets(p);
4865 sysinfo->fModel = s;
4866 s.Gets(p);
4867 sysinfo->fCpus = s.Atoi();
4868 s.Gets(p);
4869 Long64_t t = s.Atoll();
4870 sysinfo->fCpuSpeed = Int_t(t / 1000000);
4871 s.Gets(p);
4872 t = s.Atoll();
4873 sysinfo->fBusSpeed = Int_t(t / 1000000);
4874 s.Gets(p);
4875 sysinfo->fL2Cache = s.Atoi() / 1024;
4876 s.Gets(p);
4877 t = s.Atoll();
4878 sysinfo->fPhysRam = Int_t(t / 1024 / 1024);
4880 p = gSystem->OpenPipe("hostinfo", "r");
4881 while (s.Gets(p)) {
4882 if (s.BeginsWith("Processor type: ")) {
4883 TPRegexp("Processor type: ([^ ]+).*").Substitute(s, "$1");
4884 sysinfo->fCpuType = s;
4885 }
4886 }
4888}
4889
4890////////////////////////////////////////////////////////////////////////////////
4891/// Get CPU load on Mac OS X.
4892
4893static void ReadDarwinCpu(long *ticks)
4894{
4898
4899 ticks[0] = ticks[1] = ticks[2] = ticks[3] = 0;
4900
4903 if (kr != KERN_SUCCESS) {
4904 ::Error("TUnixSystem::ReadDarwinCpu", "host_statistics: %s", mach_error_string(kr));
4905 } else {
4906 ticks[0] = cpu.cpu_ticks[CPU_STATE_USER];
4907 ticks[1] = cpu.cpu_ticks[CPU_STATE_SYSTEM];
4908 ticks[2] = cpu.cpu_ticks[CPU_STATE_IDLE];
4909 ticks[3] = cpu.cpu_ticks[CPU_STATE_NICE];
4910 }
4911}
4912
4913////////////////////////////////////////////////////////////////////////////////
4914/// Get CPU stat for Mac OS X. Use sampleTime to set the interval over which
4915/// the CPU load will be measured, in ms (default 1000).
4916
4918{
4919 Double_t avg[3];
4920 if (getloadavg(avg, sizeof(avg)) < 0) {
4921 ::Error("TUnixSystem::GetDarwinCpuInfo", "getloadavg failed");
4922 } else {
4923 cpuinfo->fLoad1m = (Float_t)avg[0];
4924 cpuinfo->fLoad5m = (Float_t)avg[1];
4925 cpuinfo->fLoad15m = (Float_t)avg[2];
4926 }
4927
4932
4934 (cpu_ticks1[0] + cpu_ticks1[3]);
4937 if (userticks < 0) userticks = 0;
4938 if (systicks < 0) systicks = 0;
4939 if (idleticks < 0) idleticks = 0;
4941 if (totalticks) {
4942 cpuinfo->fUser = ((Float_t)(100 * userticks)) / ((Float_t)totalticks);
4943 cpuinfo->fSys = ((Float_t)(100 * systicks)) / ((Float_t)totalticks);
4944 cpuinfo->fTotal = cpuinfo->fUser + cpuinfo->fSys;
4945 cpuinfo->fIdle = ((Float_t)(100 * idleticks)) / ((Float_t)totalticks);
4946 }
4947}
4948
4949////////////////////////////////////////////////////////////////////////////////
4950/// Get VM stat for Mac OS X.
4951
4953{
4954 static Int_t pshift = 0;
4955
4959 if (kr != KERN_SUCCESS) {
4960 ::Error("TUnixSystem::GetDarwinMemInfo", "host_statistics: %s", mach_error_string(kr));
4961 return;
4962 }
4963 if (pshift == 0) {
4964 for (int psize = getpagesize(); psize > 1; psize >>= 1)
4965 pshift++;
4966 }
4967
4968 // Figure out total swap. This adds up the size of the swapfiles */
4969 DIR *dirp = opendir("/private/var/vm");
4970 if (!dirp)
4971 return;
4972
4973 Long64_t swap_total = 0;
4974 struct dirent *dp;
4975 while ((dp = readdir(dirp)) != 0) {
4976 struct stat sb;
4977 char fname [MAXNAMLEN];
4978 if (strncmp(dp->d_name, "swapfile", 8))
4979 continue;
4980 strlcpy(fname, "/private/var/vm/",MAXNAMLEN);
4981 strlcat (fname, dp->d_name,MAXNAMLEN);
4982 if (stat(fname, &sb) < 0)
4983 continue;
4984 swap_total += sb.st_size;
4985 }
4986 closedir(dirp);
4987
4988 Long64_t used = (Long64_t)(vm_info.active_count + vm_info.inactive_count + vm_info.wire_count) << pshift;
4989 Long64_t free = (Long64_t)(vm_info.free_count) << pshift;
4990 Long64_t total = (Long64_t)(vm_info.active_count + vm_info.inactive_count + vm_info.free_count + vm_info.wire_count) << pshift;
4991 Long64_t avail = (Long64_t)(vm_info.inactive_count + vm_info.free_count) << pshift;
4992
4993 // Swap is available at same time as mem, so grab values here.
4994 Long64_t swap_used = vm_info.pageouts << pshift;
4995
4996 meminfo->fMemTotal = (Int_t) (total >> 20); // divide by 1024 * 1024
4997 meminfo->fMemUsed = (Int_t) (used >> 20);
4998 meminfo->fMemFree = (Int_t) (free >> 20);
4999 meminfo->fSwapTotal = (Int_t) (swap_total >> 20);
5000 meminfo->fSwapUsed = (Int_t) (swap_used >> 20);
5001 meminfo->fSwapFree = meminfo->fSwapTotal - meminfo->fSwapUsed;
5002 meminfo->fMemAvailable = (Int_t)(avail >> 20);
5003}
5004
5005////////////////////////////////////////////////////////////////////////////////
5006/// Get process info for this process on Mac OS X.
5007/// Code largely taken from:
5008/// http://www.opensource.apple.com/source/top/top-15/libtop.c
5009/// The virtual memory usage is slightly over estimated as we don't
5010/// subtract shared regions, but the value makes more sense
5011/// than using `virtual_size`, which is useless on 64-bit machines.
5012
5014{
5015#ifdef _LP64
5016#define vm_region vm_region_64
5017#endif
5018
5019// taken from <mach/shared_memory_server.h> which is obsoleted in 10.5
5020#define GLOBAL_SHARED_TEXT_SEGMENT 0x90000000U
5021#define GLOBAL_SHARED_DATA_SEGMENT 0xA0000000U
5022#define SHARED_TEXT_REGION_SIZE 0x10000000
5023#define SHARED_DATA_REGION_SIZE 0x10000000
5024
5025 struct rusage ru;
5026 if (getrusage(RUSAGE_SELF, &ru) < 0) {
5027 ::SysError("TUnixSystem::GetDarwinProcInfo", "getrusage failed");
5028 } else {
5029 procinfo->fCpuUser = (Float_t)(ru.ru_utime.tv_sec) +
5030 ((Float_t)(ru.ru_utime.tv_usec) / 1000000.);
5031 procinfo->fCpuSys = (Float_t)(ru.ru_stime.tv_sec) +
5032 ((Float_t)(ru.ru_stime.tv_usec) / 1000000.);
5033 }
5034
5038
5039 task_t a_task = mach_task_self();
5040
5041 count = TASK_BASIC_INFO_COUNT;
5043 if (kr != KERN_SUCCESS) {
5044 ::Error("TUnixSystem::GetDarwinProcInfo", "task_info: %s", mach_error_string(kr));
5045 } else {
5046 // resident size does not require any calculation. Virtual size
5047 // needs to be adjusted if traversing memory objects do not include the
5048 // globally shared text and data regions
5050 vm_address_t address;
5053 rsize = ti.resident_size;
5054 vprvt = 0;
5055 for (address = 0; ; address += size) {
5056 // get memory region
5058 if (vm_region(a_task, &address, &size,
5061 // no more memory regions.
5062 break;
5063 }
5064
5065 if (address >= GLOBAL_SHARED_TEXT_SEGMENT &&
5067 // This region is private shared.
5068 // Check if this process has the globally shared
5069 // text and data regions mapped in. If so, adjust
5070 // virtual memory size and exit loop.
5071 if (info.share_mode == SM_EMPTY) {
5074 if (vm_region_64(a_task, &address,
5076 (vm_region_info_t)&b_info, &count,
5078 break;
5079 }
5080 }
5081 // Short circuit the loop if this isn't a shared
5082 // private region, since that's the only region
5083 // type we care about within the current address range.
5084 if (info.share_mode != SM_PRIVATE) {
5085 continue;
5086 }
5087 }
5088 switch (info.share_mode) {
5089 case SM_COW: {
5090 if (info.ref_count == 1) {
5091 vprvt += size;
5092 } else {
5093 vprvt += info.private_pages_resident * getpagesize();
5094 }
5095 break;
5096 }
5097 case SM_PRIVATE: {
5098 vprvt += size;
5099 break;
5100 }
5101 default:
5102 break;
5103 }
5104 }
5105
5106 procinfo->fMemResident = (Long_t)(rsize / 1024);
5107 procinfo->fMemVirtual = (Long_t)(vprvt / 1024);
5108 }
5109}
5110#endif
5111
5112#if defined(R__LINUX)
5113
5114namespace {
5115bool parseLine(TString &s, const char *prefix, Int_t &field)
5116{
5117 if (s.BeginsWith(prefix)) {
5118 TPRegexp{"^.+: *([^ ]+).*"}.Substitute(s, "$1");
5119 field = (s.Atoi() / 1024);
5120 return true;
5121 }
5122 return false;
5123};
5124} // namespace
5125
5126////////////////////////////////////////////////////////////////////////////////
5127/// Get system info for Linux. Only fBusSpeed is not set.
5128
5129static void GetLinuxSysInfo(SysInfo_t *sysinfo)
5130{
5131 TString s;
5132 FILE *f = fopen("/proc/cpuinfo", "r");
5133 if (f) {
5134 while (s.Gets(f)) {
5135 if (s.BeginsWith("model name")) {
5136 TPRegexp("^.+: *(.*$)").Substitute(s, "$1");
5137 sysinfo->fModel = s;
5138 }
5139 parseLine(s, "cpu MHz", sysinfo->fCpuSpeed);
5140 parseLine(s, "cache size", sysinfo->fL2Cache);
5141 if (parseLine(s, "processor", sysinfo->fCpus)) {
5142 sysinfo->fCpus++;
5143 }
5144 }
5145 fclose(f);
5146 }
5147
5148 f = fopen("/proc/meminfo", "r");
5149 if (f) {
5150 while (s.Gets(f)) {
5151 if (parseLine(s, "MemTotal", sysinfo->fPhysRam)) {
5152 break;
5153 }
5154 }
5155 fclose(f);
5156 }
5157
5158 f = gSystem->OpenPipe("uname -s -p", "r");
5159 if (f) {
5160 s.Gets(f);
5161 Ssiz_t from = 0;
5162 s.Tokenize(sysinfo->fOS, from);
5163 s.Tokenize(sysinfo->fCpuType, from);
5165 }
5166}
5167
5168////////////////////////////////////////////////////////////////////////////////
5169/// Get CPU load on Linux.
5170
5171static void ReadLinuxCpu(long *ticks)
5172{
5173 ticks[0] = ticks[1] = ticks[2] = ticks[3] = 0;
5174
5175 TString s;
5176 FILE *f = fopen("/proc/stat", "r");
5177 if (!f) return;
5178 s.Gets(f);
5179 // user, user nice, sys, idle
5180 sscanf(s.Data(), "%*s %ld %ld %ld %ld", &ticks[0], &ticks[3], &ticks[1], &ticks[2]);
5181 fclose(f);
5182}
5183
5184////////////////////////////////////////////////////////////////////////////////
5185/// Get CPU stat for Linux. Use sampleTime to set the interval over which
5186/// the CPU load will be measured, in ms (default 1000).
5187
5189{
5190 Double_t avg[3] = { -1., -1., -1. };
5191#ifndef R__WINGCC
5192 if (getloadavg(avg, sizeof(avg)) < 0) {
5193 ::Error("TUnixSystem::GetLinuxCpuInfo", "getloadavg failed");
5194 } else
5195#endif
5196 {
5197 cpuinfo->fLoad1m = (Float_t)avg[0];
5198 cpuinfo->fLoad5m = (Float_t)avg[1];
5199 cpuinfo->fLoad15m = (Float_t)avg[2];
5200 }
5201
5206
5208 (cpu_ticks1[0] + cpu_ticks1[3]);
5211 if (userticks < 0) userticks = 0;
5212 if (systicks < 0) systicks = 0;
5213 if (idleticks < 0) idleticks = 0;
5215 if (totalticks) {
5216 cpuinfo->fUser = ((Float_t)(100 * userticks)) / ((Float_t)totalticks);
5217 cpuinfo->fSys = ((Float_t)(100 * systicks)) / ((Float_t)totalticks);
5218 cpuinfo->fTotal = cpuinfo->fUser + cpuinfo->fSys;
5219 cpuinfo->fIdle = ((Float_t)(100 * idleticks)) / ((Float_t)totalticks);
5220 }
5221}
5222
5223////////////////////////////////////////////////////////////////////////////////
5224/// Get VM stat for Linux.
5225
5226static void GetLinuxMemInfo(MemInfo_t *meminfo)
5227{
5228 TString s;
5229 FILE *f = fopen("/proc/meminfo", "r");
5230 if (!f)
5231 return;
5232
5233 while (s.Gets(f)) {
5234 parseLine(s, "MemTotal", meminfo->fMemTotal);
5235 parseLine(s, "MemFree", meminfo->fMemFree);
5236 parseLine(s, "MemAvailable", meminfo->fMemAvailable);
5237 parseLine(s, "Cached", meminfo->fMemCached);
5238 parseLine(s, "Buffers", meminfo->fMemBuffer);
5239 parseLine(s, "Shmem", meminfo->fMemShared);
5240 parseLine(s, "SwapTotal", meminfo->fSwapTotal);
5241 parseLine(s, "SwapFree", meminfo->fSwapFree);
5242 parseLine(s, "SwapCached", meminfo->fSwapCached);
5243 parseLine(s, "SReclaimable", meminfo->fSReclaimable);
5244 }
5245 fclose(f);
5246
5247 /*
5248 * Compute memory partition like procps(free), see https://gitlab.com/procps-ng/procps/-/blob/master/proc/sysinfo.c
5249 *
5250 * fMemShared is a part of Cached (see https://lore.kernel.org/patchwork/patch/648763/), does not subtract twice from used
5251 */
5252
5253 meminfo->fMemCached = meminfo->fMemCached + meminfo->fSReclaimable - meminfo->fMemShared;
5254 const Int_t usedDiff = meminfo->fMemFree + meminfo->fMemCached + meminfo->fSReclaimable + meminfo->fMemBuffer;
5255
5256 meminfo->fMemUsed = (meminfo->fMemTotal >= usedDiff) ? meminfo->fMemTotal - usedDiff : meminfo->fMemTotal - meminfo->fMemFree;
5257 meminfo->fMemAvailable = meminfo->fMemAvailable != 0 ? std::min(meminfo->fMemAvailable, meminfo->fMemTotal) : meminfo->fMemFree;
5258
5259 meminfo->fSwapUsed = meminfo->fSwapTotal - meminfo->fSwapFree - meminfo->fSwapCached;
5260
5261}
5262
5263////////////////////////////////////////////////////////////////////////////////
5264/// Get process info for this process on Linux.
5265
5267{
5268 struct rusage ru;
5269 if (getrusage(RUSAGE_SELF, &ru) < 0) {
5270 ::SysError("TUnixSystem::GetLinuxProcInfo", "getrusage failed");
5271 } else {
5272 procinfo->fCpuUser = (Float_t)(ru.ru_utime.tv_sec) +
5273 ((Float_t)(ru.ru_utime.tv_usec) / 1000000.);
5274 procinfo->fCpuSys = (Float_t)(ru.ru_stime.tv_sec) +
5275 ((Float_t)(ru.ru_stime.tv_usec) / 1000000.);
5276 }
5277
5278 procinfo->fMemVirtual = -1;
5279 procinfo->fMemResident = -1;
5280 TString s;
5281 FILE *f = fopen(TString::Format("/proc/%d/statm", gSystem->GetPid()), "r");
5282 if (f) {
5283 s.Gets(f);
5284 fclose(f);
5285 Long_t total, rss;
5286 sscanf(s.Data(), "%ld %ld", &total, &rss);
5287 procinfo->fMemVirtual = total * (getpagesize() / 1024);
5288 procinfo->fMemResident = rss * (getpagesize() / 1024);
5289 }
5290}
5291#endif
5292
5293////////////////////////////////////////////////////////////////////////////////
5294/// Returns static system info, like OS type, CPU type, number of CPUs
5295/// RAM size, etc into the SysInfo_t structure. Returns -1 in case of error,
5296/// 0 otherwise.
5297
5299{
5300 if (!info) return -1;
5301
5302 static SysInfo_t sysinfo;
5303
5304 if (!sysinfo.fCpus) {
5305#if defined(R__MACOSX)
5307#elif defined(R__LINUX)
5309#elif defined(R__FBSD)
5311#endif
5312 }
5313
5314 *info = sysinfo;
5315
5316 return 0;
5317}
5318
5319////////////////////////////////////////////////////////////////////////////////
5320/// Returns cpu load average and load info into the CpuInfo_t structure.
5321/// Returns -1 in case of error, 0 otherwise. Use sampleTime to set the
5322/// interval over which the CPU load will be measured, in ms (default 1000).
5323
5325{
5326 if (!info) return -1;
5327
5328#if defined(R__MACOSX)
5330#elif defined(R__LINUX)
5332#elif defined(R__FBSD)
5334#endif
5335
5336 return 0;
5337}
5338
5339////////////////////////////////////////////////////////////////////////////////
5340/// Returns ram and swap memory usage info into the MemInfo_t structure.
5341/// Returns -1 in case of error, 0 otherwise.
5342
5344{
5345 if (!info) return -1;
5346
5347#if defined(R__MACOSX)
5349#elif defined(R__LINUX)
5351#endif
5352
5353 return 0;
5354}
5355
5356////////////////////////////////////////////////////////////////////////////////
5357/// Returns cpu and memory used by this process into the ProcInfo_t structure.
5358/// Returns -1 in case of error, 0 otherwise.
5359
5361{
5362 if (!info) return -1;
5363
5364#if defined(R__MACOSX)
5366#elif defined(R__LINUX)
5368#endif
5369
5370 return 0;
5371}
The file contains utilities which are foundational and could be used across the core component of ROO...
#define b(i)
Definition RSha256.hxx:100
#define f(i)
Definition RSha256.hxx:104
#define h(i)
Definition RSha256.hxx:106
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
bool Bool_t
Boolean (0=false, 1=true) (bool)
Definition RtypesCore.h:77
int Int_t
Signed integer 4 bytes (int)
Definition RtypesCore.h:59
int Ssiz_t
String size (currently int)
Definition RtypesCore.h:81
unsigned long ULong_t
Unsigned long integer 4 bytes (unsigned long). Size depends on architecture.
Definition RtypesCore.h:69
long Long_t
Signed long integer 4 bytes (long). Size depends on architecture.
Definition RtypesCore.h:68
float Float_t
Float 4 bytes (float)
Definition RtypesCore.h:71
constexpr Bool_t kFALSE
Definition RtypesCore.h:108
double Double_t
Double 8 bytes.
Definition RtypesCore.h:73
constexpr Ssiz_t kNPOS
The equivalent of std::string::npos for the ROOT class TString.
Definition RtypesCore.h:131
long long Long64_t
Portable signed long integer 8 bytes.
Definition RtypesCore.h:83
constexpr Bool_t kTRUE
Definition RtypesCore.h:107
@ kItimerResolution
Definition Rtypes.h:63
@ kMAXSIGNALS
Definition Rtypes.h:60
@ kMAXPATHLEN
Definition Rtypes.h:61
R__EXTERN TApplication * gApplication
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
R__EXTERN TEnv * gEnv
Definition TEnv.h:170
void SysError(const char *location, const char *msgfmt,...)
Use this function in case a system (OS or GUI) related error occurred.
Definition TError.cxx:219
void Break(const char *location, const char *msgfmt,...)
Use this function in case an error occurred.
Definition TError.cxx:230
void Fatal(const char *location, const char *msgfmt,...)
Use this function in case of a fatal error. It will abort the program.
Definition TError.cxx:267
R__EXTERN TExceptionHandler * gExceptionHandler
Definition TException.h:79
static unsigned int total
winID h TVirtualViewer3D TVirtualGLPainter p
winID h direct
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t mask
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h offset
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t result
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h length
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t UChar_t len
Option_t Option_t TPoint TPoint const char mode
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t org
char name[80]
Definition TGX11.cxx:110
float * q
R__EXTERN TInterpreter * gCling
#define HOWMANY(x, y)
const Int_t kFDSETSIZE
const Int_t kNFDBITS
Int_t gDebug
Global variable setting the debug level. Set to 0 to disable, increase it in steps of 1 to increase t...
Definition TROOT.cxx:627
#define gROOT
Definition TROOT.h:411
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
Definition TString.cxx:2495
void Printf(const char *fmt,...)
Formats a string in a circular formatting buffer and prints the string.
Definition TString.cxx:2509
char * StrDup(const char *str)
Duplicate the string str.
Definition TString.cxx:2563
int EscChar(const char *src, char *dst, int dstlen, char *specchars, char escchar)
Escape specchars in src with escchar and copy to dst.
Definition TString.cxx:2599
ESignals
@ kSigIllegalInstruction
@ kSigPipe
@ kSigBus
@ kSigAbort
@ kSigWindowChanged
@ kSigUrgent
@ kSigUser2
@ kSigFloatingException
@ kSigChild
@ kSigAlarm
@ kSigSegmentationViolation
@ kSigSystem
R__EXTERN const char * gProgName
Definition TSystem.h:252
R__EXTERN TVirtualMutex * gSystemMutex
Definition TSystem.h:254
@ kKeepAlive
Definition TSystem.h:233
@ kBytesToRead
Definition TSystem.h:239
@ kReuseAddr
Definition TSystem.h:234
@ kNoBlock
Definition TSystem.h:236
@ kSendBuffer
Definition TSystem.h:230
@ kNoDelay
Definition TSystem.h:235
@ kOobInline
Definition TSystem.h:232
@ kRecvBuffer
Definition TSystem.h:231
@ kProcessGroup
Definition TSystem.h:237
@ kAtMark
Definition TSystem.h:238
@ kDontBlock
Definition TSystem.h:246
@ kPeek
Definition TSystem.h:245
@ kOob
Definition TSystem.h:244
void(* Func_t)()
Definition TSystem.h:249
R__EXTERN const char * gRootDir
Definition TSystem.h:251
EAccessMode
Definition TSystem.h:51
@ kExecutePermission
Definition TSystem.h:53
@ kReadPermission
Definition TSystem.h:55
@ kWritePermission
Definition TSystem.h:54
ELogFacility
Definition TSystem.h:74
@ kLogLocal2
Definition TSystem.h:77
@ kLogLocal6
Definition TSystem.h:81
@ kLogLocal4
Definition TSystem.h:79
@ kLogLocal5
Definition TSystem.h:80
@ kLogLocal0
Definition TSystem.h:75
@ kLogLocal3
Definition TSystem.h:78
@ kLogLocal1
Definition TSystem.h:76
@ kLogLocal7
Definition TSystem.h:82
ESocketBindOption
Options for binging the sockets created.
Definition TSystem.h:46
@ kInaddrAny
Any address for socket binding.
Definition TSystem.h:47
ELogLevel
Definition TSystem.h:63
R__EXTERN TSystem * gSystem
Definition TSystem.h:572
@ kDivByZero
Definition TSystem.h:88
@ kInexact
Definition TSystem.h:91
@ kInvalid
Definition TSystem.h:87
@ kUnderflow
Definition TSystem.h:90
@ kOverflow
Definition TSystem.h:89
R__EXTERN TFileHandler * gXDisplay
Definition TSystem.h:573
R__EXTERN const char * gProgPath
Definition TSystem.h:253
const char * kServerPath
static void sighandler(int sig)
Call the signal handler associated with the signal.
const char * kShellMeta
const Int_t kFDSETSIZE
#define STRUCT_UTMP
static const char * DynamicPath(const char *newpath=nullptr, Bool_t reset=kFALSE)
Get shared library search path. Static utility function.
#define UTMP_FILE
static void SigHandler(ESignals sig)
Unix signal handler.
#define REAL_DIR_ENTRY(dp)
const char * kProtocolName
static struct Signalmap_t gSignalMap[kMAXSIGNALS]
static const char * GetExePath()
const Int_t kNFDBITS
void(* SigHandler_t)(ESignals)
Definition TUnixSystem.h:29
#define R__LOCKGUARD2(mutex)
#define free
Definition civetweb.c:1578
#define snprintf
Definition civetweb.c:1579
#define malloc
Definition civetweb.c:1575
const_iterator begin() const
const_iterator end() const
virtual void HandleException(Int_t sig)
Handle exceptions (kSigBus, kSigSegmentationViolation, kSigIllegalInstruction and kSigFloatingExcepti...
char ** Argv() const
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
virtual Int_t GetValue(const char *name, Int_t dflt) const
Returns the integer value for a resource.
Definition TEnv.cxx:490
virtual void HandleException(int sig)=0
void Zero()
void Set(Int_t n)
TFdSet & operator=(const TFdSet &rhs)
void Clr(Int_t n)
Int_t IsSet(Int_t n)
ULong_t * GetBits()
ULong_t fds_bits[(((kFDSETSIZE)+((kNFDBITS) -1))/(kNFDBITS))]
TFdSet(const TFdSet &org)
virtual Bool_t HasReadInterest()
True if handler is interested in read events.
virtual Bool_t WriteNotify()
Notify when something can be written to the descriptor associated with this handler.
virtual Bool_t HasWriteInterest()
True if handler is interested in write events.
int GetFd() const
virtual Bool_t ReadNotify()
Notify when something can be read from the descriptor associated with this handler.
Bool_t Notify() override
Notify when event occurred on descriptor associated with this handler.
This class represents an Internet Protocol (IP) address.
virtual const char * GetSTLIncludePath() const
void Reset()
Iterator of linked list.
Definition TList.h:191
TObject * Next() override
Return next object in the list. Returns 0 when no more objects in list.
Definition TList.cxx:1110
A doubly linked list.
Definition TList.h:38
An array of TObjects.
Definition TObjArray.h:31
Collectable string class.
Definition TObjString.h:28
virtual const char * GetName() const
Returns name of object.
Definition TObject.cxx:457
virtual void SysError(const char *method, const char *msgfmt,...) const
Issue system error message.
Definition TObject.cxx:1085
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition TObject.cxx:1057
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition TObject.cxx:1071
Iterator of ordered collection.
TObject * Next() override
Return next object in collection.
Ordered collection.
Int_t Substitute(TString &s, const TString &replace, const TString &mods="", Int_t start=0, Int_t nMatchMax=10)
Substitute replaces the string s by a new string in which matching patterns are replaced by the repla...
Definition TPRegexp.cxx:560
static void ShutDown()
Shut down ROOT.
Definition TROOT.cxx:3191
static const TString & GetEtcDir()
Get the sysconfig directory in the installation. Static utility function.
Definition TROOT.cxx:3107
static const TString & GetLibDir()
Get the library directory in the installation.
Definition TROOT.cxx:3027
Regular expression class.
Definition TRegexp.h:31
Basic string class.
Definition TString.h:138
Int_t Atoi() const
Return integer value of string.
Definition TString.cxx:1994
Bool_t Gets(FILE *fp, Bool_t chop=kTRUE)
Read one line from the stream, including the \n, or until EOF.
Definition Stringio.cxx:204
Bool_t EndsWith(const char *pat, ECaseCompare cmp=kExact) const
Return true if string ends with the specified string.
Definition TString.cxx:2250
const char * Data() const
Definition TString.h:384
TString & ReplaceAll(const TString &s1, const TString &s2)
Definition TString.h:712
TObjArray * Tokenize(const TString &delim) const
This function is used to isolate sequential tokens in a TString.
Definition TString.cxx:2270
Bool_t BeginsWith(const char *s, ECaseCompare cmp=kExact) const
Definition TString.h:631
TString & Remove(Ssiz_t pos)
Definition TString.h:693
TString & Append(const char *cs)
Definition TString.h:580
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString.
Definition TString.cxx:2384
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Definition TString.h:659
Long64_t Atoll() const
Return long long value of string.
Definition TString.cxx:2020
Bool_t IsActive() const
Abstract base class defining a generic interface to the underlying Operating System.
Definition TSystem.h:276
virtual void Unload(const char *module)
Unload a shared library.
Definition TSystem.cxx:2063
TSeqCollection * fFileHandler
Definition TSystem.h:306
Int_t fMaxrfd
Definition TSystem.h:291
virtual void AddFileHandler(TFileHandler *fh)
Add a file handler to the list of system file handlers.
Definition TSystem.cxx:552
TString & GetLastErrorString()
Return the thread local storage for the custom last error message.
Definition TSystem.cxx:2113
virtual Func_t DynFindSymbol(const char *module, const char *entry)
Find specific entry point in specified library.
Definition TSystem.cxx:2055
static void ResetErrno()
Static function resetting system error number.
Definition TSystem.cxx:282
virtual Bool_t ExpandPathName(TString &path)
Expand a pathname getting rid of special shell characters like ~.
Definition TSystem.cxx:1285
static Int_t GetErrno()
Static function returning system error number.
Definition TSystem.cxx:274
@ kDefault
Definition TSystem.h:279
TFdSet * fReadmask
Definition TSystem.h:285
TString fWdpath
Definition TSystem.h:294
virtual const char * DirName(const char *pathname)
Return the directory name in pathname.
Definition TSystem.cxx:1016
virtual int GetPid()
Get process id.
Definition TSystem.cxx:716
TString fHostname
Definition TSystem.h:295
virtual Long_t NextTimeOut(Bool_t mode)
Time when next timer of mode (synchronous=kTRUE or asynchronous=kFALSE) will time-out (in ms).
Definition TSystem.cxx:492
virtual int SetSockOpt(int sock, int kind, int val)
Set socket option.
Definition TSystem.cxx:2447
virtual const char * Getenv(const char *env)
Get environment variable.
Definition TSystem.cxx:1676
TFdSet * fWritemask
Files that should be checked for read events.
Definition TSystem.h:286
TFdSet * fSignals
Files with writes waiting.
Definition TSystem.h:289
virtual char * ConcatFileName(const char *dir, const char *name)
Concatenate a directory and a file name.
Definition TSystem.cxx:1082
virtual Bool_t IsPathLocal(const char *path)
Returns TRUE if the url in 'path' points to the local file system.
Definition TSystem.cxx:1316
virtual const char * FindFile(const char *search, TString &file, EAccessMode mode=kFileExists)
Find location of file in a search path.
Definition TSystem.cxx:1549
virtual int mkdir(const char *name, Bool_t recursive=kFALSE)
Make a file system directory.
Definition TSystem.cxx:916
virtual const char * ExpandFileName(const char *fname)
Expand a pathname getting rid of special shell characters like ~.
Definition TSystem.cxx:1109
virtual TFileHandler * RemoveFileHandler(TFileHandler *fh)
Remove a file handler from the list of file handlers.
Definition TSystem.cxx:562
Int_t fSigcnt
Definition TSystem.h:293
virtual int Load(const char *module, const char *entry="", Bool_t system=kFALSE)
Load a shared library.
Definition TSystem.cxx:1868
virtual void ListLibraries(const char *regexp="")
List the loaded shared libraries.
Definition TSystem.cxx:2096
virtual FILE * OpenPipe(const char *command, const char *mode)
Open a pipe.
Definition TSystem.cxx:660
int GetPathInfo(const char *path, Long_t *id, Long_t *size, Long_t *flags, Long_t *modtime)
Get info about a file: id, size, flags, modification time.
Definition TSystem.cxx:1409
virtual const char * PrependPathName(const char *dir, TString &name)
Concatenate a directory and a file name.
Definition TSystem.cxx:1092
virtual Bool_t AccessPathName(const char *path, EAccessMode mode=kFileExists)
Returns FALSE if one can access a file using the specified access mode.
Definition TSystem.cxx:1307
virtual Bool_t Init()
Initialize the OS interface.
Definition TSystem.cxx:181
virtual void AddTimer(TTimer *t)
Add timer to list of system timers.
Definition TSystem.cxx:469
TFdSet * fWriteready
Files with reads waiting.
Definition TSystem.h:288
virtual int ClosePipe(FILE *pipe)
Close the pipe.
Definition TSystem.cxx:669
virtual const char * BaseName(const char *pathname)
Base name of a file name. Base name of /user/root is root.
Definition TSystem.cxx:944
virtual void AddSignalHandler(TSignalHandler *sh)
Add a signal handler to list of system signal handlers.
Definition TSystem.cxx:530
TSeqCollection * fSignalHandler
Definition TSystem.h:305
TFdSet * fReadready
Files that should be checked for write events.
Definition TSystem.h:287
TSystem * FindHelper(const char *path, void *dirptr=nullptr)
Create helper TSystem to handle file and directory operations that might be special for remote file a...
Definition TSystem.cxx:755
TList * fTimers
Definition TSystem.h:304
Int_t fNfd
Signals that were trapped.
Definition TSystem.h:290
std::atomic< Bool_t > fInsideNotify
Definition TSystem.h:296
virtual void Sleep(UInt_t milliSec)
Sleep milliSec milli seconds.
Definition TSystem.cxx:435
Int_t fMaxwfd
Definition TSystem.h:292
virtual const char * WorkingDirectory()
Return working directory.
Definition TSystem.cxx:881
virtual char * Which(const char *search, const char *file, EAccessMode mode=kFileExists)
Find location of file in a search path.
Definition TSystem.cxx:1559
virtual TInetAddress GetHostByName(const char *server)
Get Internet Protocol (IP) address of host.
Definition TSystem.cxx:2302
virtual TSignalHandler * RemoveSignalHandler(TSignalHandler *sh)
Remove a signal handler from list of signal handlers.
Definition TSystem.cxx:540
virtual void Setenv(const char *name, const char *value)
Set environment variable.
Definition TSystem.cxx:1660
static const char * StripOffProto(const char *path, const char *proto)
Strip off protocol string from specified path.
Definition TSystem.cxx:115
virtual TTimer * RemoveTimer(TTimer *t)
Remove timer from list of system timers.
Definition TSystem.cxx:479
virtual TString GetDirName(const char *pathname)
Return the directory name in pathname.
Definition TSystem.cxx:1042
Basic time type with millisecond precision.
Definition TTime.h:27
Handles synchronous and a-synchronous timer events.
Definition TTimer.h:51
Bool_t IsAsync() const
Definition TTimer.h:81
Bool_t CheckTimer(const TTime &now)
Check if timer timed out.
Definition TTimer.cxx:133
Bool_t IsSync() const
Definition TTimer.h:80
void AddTimer(TTimer *ti) override
Add timer to list of system timers.
int RecvRaw(int sock, void *buffer, int length, int flag) override
Receive exactly length bytes into buffer.
int OpenConnection(const char *server, int port, int tcpwindowsize=-1, const char *protocol="tcp") override
Open a connection to a service on a server.
int GetMemInfo(MemInfo_t *info) const override
Returns ram and swap memory usage info into the MemInfo_t structure.
Bool_t IsPathLocal(const char *path) override
Returns TRUE if the url in 'path' points to the local file system.
int Symlink(const char *from, const char *to) override
Create a symlink from file1 to file2.
const char * HomeDirectory(const char *userName=nullptr) override
Return the user's home directory.
Int_t GetGid(const char *group=nullptr) override
Returns the group's id. If group = 0, returns current user's group.
static int UnixUdpConnect(const char *hostname, int port)
Creates a UDP socket connection Is called via the TSocket constructor.
int CopyFile(const char *from, const char *to, Bool_t overwrite=kFALSE) override
Copy a file.
TTimer * RemoveTimer(TTimer *ti) override
Remove timer from list of system timers.
int AnnounceUnixService(int port, int backlog) override
Announce unix domain service on path "kServerPath/<port>".
static int UnixTcpConnect(const char *hostname, int port, int tcpwindowsize)
Open a TCP/IP connection to server and connect to a service (i.e.
Int_t SetFPEMask(Int_t mask=kDefaultMask) override
Set which conditions trigger a floating point exception.
static const char * UnixGetdirentry(void *dir)
Returns the next directory entry.
void Setenv(const char *name, const char *value) override
Set environment variable.
int ConnectService(const char *server, int port, int tcpwindowsize, const char *protocol="tcp")
Connect to service servicename on server servername.
Bool_t ChangeDirectory(const char *path) override
Change directory. Returns kTRUE in case of success, kFALSE otherwise.
static int UnixTcpService(int port, Bool_t reuse, int backlog, int tcpwindowsize, ESocketBindOption socketBindOption)
Open a socket, bind to it and start listening for TCP/IP connections on the port.
static const char * UnixHomedirectory(const char *user=nullptr)
Returns the user's home directory.
char * GetServiceByPort(int port) override
Get name of internet service.
Bool_t CheckSignals(Bool_t sync)
Check if some signals were raised and call their Notify() member.
static int UnixMakedir(const char *name)
Make a Unix file system directory.
static void UnixSigAlarmInterruptsSyscalls(Bool_t set)
When the argument is true the SIGALRM signal handler is set so that interrupted syscalls will not be ...
Int_t GetFPEMask() override
Return the bitmap of conditions that trigger a floating point exception.
static int UnixUnixConnect(int port)
Connect to a Unix domain socket.
int GetSysInfo(SysInfo_t *info) const override
Returns static system info, like OS type, CPU type, number of CPUs RAM size, etc into the SysInfo_t s...
void Exit(int code, Bool_t mode=kTRUE) override
Exit the application.
void AddDynamicPath(const char *lib) override
Add a new directory to the dynamic path.
void SetDynamicPath(const char *lib) override
Set the dynamic path to a new value.
int ClosePipe(FILE *pipe) override
Close the pipe.
std::string GetHomeDirectory(const char *userName=nullptr) const override
Return the user's home directory.
Int_t Select(TList *active, Long_t timeout) override
Select on file descriptors.
void Unsetenv(const char *name) override
Unset environment variable.
virtual ~TUnixSystem()
Reset to original state.
void Abort(int code=0) override
Abort the application.
void Syslog(ELogLevel level, const char *mess) override
Send mess to syslog daemon.
int AnnounceTcpService(int port, Bool_t reuse, int backlog, int tcpwindowsize=-1, ESocketBindOption socketBindOption=ESocketBindOption::kInaddrAny) override
Announce TCP/IP service.
UserGroup_t * GetGroupInfo(Int_t gid) override
Returns all group info in the UserGroup_t structure.
Int_t GetUid(const char *user=nullptr) override
Returns the user's id. If user = 0, returns current user's id.
Bool_t ExpandPathName(TString &patbuf) override
Expand a pathname getting rid of special shell characters like ~.
void Openlog(const char *name, Int_t options, ELogFacility facility) override
Open connection to system log daemon.
int AcceptConnection(int sock) override
Accept a connection.
TTime Now() override
Get current time in milliseconds since 0:00 Jan 1 1995.
static void UnixResetSignal(ESignals sig)
Restore old signal handler for specified signal.
int GetServiceByName(const char *service) override
Get port # of internet service.
const char * FindFile(const char *search, TString &file, EAccessMode mode=kFileExists) override
Find location of file "wfil" in a search path.
void SigAlarmInterruptsSyscalls(Bool_t set) override
When the argument is true the SIGALRM signal handler is set so that interrupted syscalls will not be ...
int Utime(const char *file, Long_t modtime, Long_t actime) override
Set a files modification and access times.
const char * GetLinkedLibraries() override
Get list of shared libraries loaded at the start of the executable.
const char * GetError() override
Return system error string.
std::string GetWorkingDirectory() const override
Return working directory.
Bool_t AccessPathName(const char *path, EAccessMode mode=kFileExists) override
Returns FALSE if one can access a file using the specified access mode.
FILE * TempFileName(TString &base, const char *dir=nullptr, const char *suffix=nullptr) override
Create a secure temporary file by appending a unique 6 letter string to base.
void DispatchOneEvent(Bool_t pendingOnly=kFALSE) override
Dispatch a single event.
int Chmod(const char *file, UInt_t mode) override
Set the file permission bits. Returns -1 in case or error, 0 otherwise.
const char * PrependPathName(const char *dir, TString &name) override
Concatenate a directory and a file name.
Bool_t DispatchTimers(Bool_t mode)
Handle and dispatch timers.
void IgnoreSignal(ESignals sig, Bool_t ignore=kTRUE) override
If ignore is true ignore the specified signal, else restore previous behaviour.
void ListSymbols(const char *module, const char *re="") override
List symbols in a shared library.
int Load(const char *module, const char *entry="", Bool_t system=kFALSE) override
Load a shared library.
void StackTrace() override
Print a stack trace.
TInetAddress GetHostByName(const char *server) override
Get Internet Protocol (IP) address of host.
int SendBuf(int sock, const void *buffer, int length) override
Send a buffer headed by a length indicator.
const char * HostName() override
Return the system's host name.
void CheckChilds()
Check if children have finished.
int RecvBuf(int sock, void *buffer, int length) override
Receive a buffer headed by a length indicator.
static int UnixUnixService(int port, int backlog)
Open a socket, bind to it and start listening for Unix domain connections to it.
UserGroup_t * GetUserInfo(Int_t uid) override
Returns all user info in the UserGroup_t structure.
void SetDisplay() override
Set DISPLAY environment variable based on utmp entry. Only for UNIX.
TFileHandler * RemoveFileHandler(TFileHandler *fh) override
Remove a file handler from the list of file handlers.
static const char * UnixSigname(ESignals sig)
Return the signal name associated with a signal.
static Long64_t UnixNow()
Get current time in milliseconds since 0:00 Jan 1 1995.
static int UnixFSstat(const char *path, Long_t *id, Long_t *bsize, Long_t *blocks, Long_t *bfree)
Get info about a file system: id, bsize, bfree, blocks.
void ResetSignals() override
Reset signals handlers to previous behaviour.
TInetAddress GetSockName(int sock) override
Get Internet Protocol (IP) address of host and port #.
int Link(const char *from, const char *to) override
Create a link from file1 to file2.
int GetProcInfo(ProcInfo_t *info) const override
Returns cpu and memory used by this process into the ProcInfo_t structure.
int SetSockOpt(int sock, int option, int val) override
Set socket option.
static int UnixSetitimer(Long_t ms)
Set interval timer to time-out in ms milliseconds.
static int UnixSend(int sock, const void *buf, int len, int flag)
Send exactly length bytes from buffer.
TInetAddress GetPeerName(int sock) override
Get Internet Protocol (IP) address of remote host and port #.
static void UnixIgnoreSignal(ESignals sig, Bool_t ignore)
If ignore is true ignore the specified signal, else restore previous behaviour.
void DispatchSignals(ESignals sig)
Handle and dispatch signals.
void AddFileHandler(TFileHandler *fh) override
Add a file handler to the list of system file handlers.
int AnnounceUdpService(int port, int backlog, ESocketBindOption socketBindOption=ESocketBindOption::kInaddrAny) override
Announce UDP service.
Int_t GetCryptoRandom(void *buf, Int_t len) override
Return cryptographic random number Fill provided buffer with random values Returns number of bytes wr...
void * OpenDirectory(const char *name) override
Open a Unix file system directory. Returns 0 if directory does not exist.
int Rename(const char *from, const char *to) override
Rename a file. Returns 0 when successful, -1 in case of failure.
const char * Getenv(const char *name) override
Get environment variable.
int GetPathInfo(const char *path, FileStat_t &buf) override
Get info about a file.
Int_t GetEffectiveGid() override
Returns the effective group id.
static int UnixSelect(Int_t nfds, TFdSet *readready, TFdSet *writeready, Long_t timeout)
Wait for events on the file descriptors specified in the readready and writeready masks or for timeou...
int GetPid() override
Get process id.
Int_t Exec(const char *shellcmd) override
Execute a command.
void ResetTimer(TTimer *ti) override
Reset a-sync timer.
TSignalHandler * RemoveSignalHandler(TSignalHandler *sh) override
Remove a signal handler from list of signal handlers.
static void UnixSignal(ESignals sig, SigHandler_t h)
Set a signal handler for a signal.
void CloseConnection(int sock, Bool_t force=kFALSE) override
Close socket.
Bool_t CheckDescriptors()
Check if there is activity on some file descriptors and call their Notify() member.
Bool_t Init() override
Initialize Unix system interface.
void Unload(const char *module) override
Unload a shared library.
int Umask(Int_t mask) override
Set the process file creation mode mask.
static int UnixFilestat(const char *path, FileStat_t &buf)
Get info about a file.
static int UnixRecv(int sock, void *buf, int len, int flag)
Receive exactly length bytes into buffer.
Int_t GetEffectiveUid() override
Returns the effective user id.
void FillWithCwd(char *cwd) const
Fill buffer with current working directory.
static int UnixWaitchild()
Wait till child is finished.
int Unlink(const char *name) override
Unlink, i.e.
void ListLibraries(const char *regexp="") override
List all loaded shared libraries.
void Closelog() override
Close connection to system log daemon.
Int_t RedirectOutput(const char *name, const char *mode="a", RedirectHandle_t *h=nullptr) override
Redirect standard output (stdout, stderr) to the specified file.
void Sleep(UInt_t milliSec) override
Sleep milliSec milliseconds.
void ResetSignal(ESignals sig, Bool_t reset=kTRUE) override
If reset is true reset the signal handler for the specified signal to the default handler,...
const char * TempDirectory() const override
Return a user configured or systemwide directory to create temporary files in.
Func_t DynFindSymbol(const char *module, const char *entry) override
dynamic linking of module
const char * GetDynamicPath() override
Return the dynamic path (used to find shared libraries).
FILE * OpenPipe(const char *shellcmd, const char *mode) override
Open a pipe.
void FreeDirectory(void *dirp) override
Close a Unix file system directory.
static void UnixResetSignals()
Restore old signal handlers.
int GetCpuInfo(CpuInfo_t *info, Int_t sampleTime=1000) const override
Returns cpu load average and load info into the CpuInfo_t structure.
void AddSignalHandler(TSignalHandler *sh) override
Add a signal handler to list of system signal handlers.
static void * UnixOpendir(const char *name)
Open a directory.
int SendRaw(int sock, const void *buffer, int length, int flag) override
Send exactly length bytes from buffer.
const char * WorkingDirectory() override
Return working directory.
int GetSockOpt(int sock, int option, int *val) override
Get socket option.
const char * FindDynamicLibrary(TString &lib, Bool_t quiet=kFALSE) override
Returns the path of a shared library (searches for library in the shared library search path).
void SetProgname(const char *name) override
Set the application name (from command line, argv[0]) and copy it in gProgName.
const char * GetDirEntry(void *dirp) override
Get next Unix file system directory entry. Returns 0 if no more entries.
int MakeDirectory(const char *name) override
Make a Unix file system directory.
static int UnixUdpService(int port, int backlog, ESocketBindOption socketBindOption)
Open a socket, bind to it and start listening for UDP connections on the port.
int GetFsInfo(const char *path, Long_t *id, Long_t *bsize, Long_t *blocks, Long_t *bfree) override
Get info about a file system: id, bsize, bfree, blocks.
TLine * line
const Int_t n
Definition legend1.C:16
TGraphErrors * gr
Definition legend1.C:25
const std::string & GetFallbackRootSys()
const char * cnt
Definition TXMLSetup.cxx:74
const char * GetExePath()
Returns the executable path name, used e.g. by SetRootSys().
void SetRootSys()
Set the ROOTSYS env var based on the executable location.
Int_t fMode
Definition TSystem.h:135
Long64_t fSize
Definition TSystem.h:138
Long_t fDev
Definition TSystem.h:133
Int_t fGid
Definition TSystem.h:137
Long_t fMtime
Definition TSystem.h:139
Long_t fIno
Definition TSystem.h:134
Bool_t fIsLink
Definition TSystem.h:140
Int_t fUid
Definition TSystem.h:136
struct sigaction * fOldHandler
const char * fSigName
SigHandler_t fHandler
struct utmp * fUtmpContents
struct utmp * SearchUtmpEntry(const char *tty)
TMarker m
Definition textangle.C:8