src/OSspecific/POSIX/POSIX.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software: you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by
  13     the Free Software Foundation, either version 3 of the License, or
  14     (at your option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 Description
  25     POSIX versions of the functions declared in OSspecific.H
  26
  27 \*---------------------------------------------------------------------------*/
  28
  29 #ifdef solarisGcc
  30 # define _SYS_VNODE_H
  31 #endif
  32
  33 #include "OSspecific.H"
  34 #include "POSIX.H"
  35 #include "foamVersion.H"
  36 #include "fileName.H"
  37 #include "fileStat.H"
  38 #include "timer.H"
  39 #include "IFstream.H"
  40 #include "DynamicList.H"
  41
  42 #include <fstream>
  43 #include <cstdlib>
  44 #include <cctype>
  45
  46 #include <stdio.h>
  47 #include <unistd.h>
  48 #include <dirent.h>
  49 #include <pwd.h>
  50 #include <errno.h>
  51 #include <sys/types.h>
  52 #include <sys/stat.h>
  53 #include <sys/socket.h>
  54 #include <netdb.h>
  55 #include <dlfcn.h>
  56 #include <link.h>
  57
  58 #include <netinet/in.h>
  59
  60 #ifdef USE_RANDOM
  61 #   include <climits>
  62 #   if INT_MAX    != 2147483647
  63 #       error "INT_MAX    != 2147483647"
  64 #       error "The random number generator may not work!"
  65 #   endif
  66 #endif
  67
  68 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  69
  70 defineTypeNameAndDebug(Foam::POSIX, 0);
  71
  72 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  73
  74 pid_t Foam::pid()
  75 {
  76     return ::getpid();
  77 }
  78
  79
  80 pid_t Foam::ppid()
  81 {
  82     return ::getppid();
  83 }
  84
  85
  86 pid_t Foam::pgid()
  87 {
  88     return ::getpgrp();
  89 }
  90
  91
  92 bool Foam::env(const word& envName)
  93 {
  94     return ::getenv(envName.c_str()) != NULL;
  95 }
  96
  97
  98 Foam::string Foam::getEnv(const word& envName)
  99 {
 100     char* env = ::getenv(envName.c_str());
 101
 102     if (env)
 103     {
 104         return string(env);
 105     }
 106     else
 107     {
 108         // Return null-constructed string rather than string::null
 109         // to avoid cyclic dependencies in the construction of globals
 110         return string();
 111     }
 112 }
 113
 114
 115 bool Foam::setEnv
 116 (
 117     const word& envName,
 118     const std::string& value,
 119     const bool overwrite
 120 )
 121 {
 122     return setenv(envName.c_str(), value.c_str(), overwrite) == 0;
 123 }
 124
 125
 126 Foam::word Foam::hostName(bool full)
 127 {
 128     char buf[128];
 129     ::gethostname(buf, sizeof(buf));
 130
 131     // implementation as per hostname from net-tools
 132     if (full)
 133     {
 134         struct hostent *hp = ::gethostbyname(buf);
 135         if (hp)
 136         {
 137             return hp->h_name;
 138         }
 139     }
 140
 141     return buf;
 142 }
 143
 144
 145 Foam::word Foam::domainName()
 146 {
 147     char buf[128];
 148     ::gethostname(buf, sizeof(buf));
 149
 150     // implementation as per hostname from net-tools
 151     struct hostent *hp = ::gethostbyname(buf);
 152     if (hp)
 153     {
 154         char *p = ::strchr(hp->h_name, '.');
 155         if (p)
 156         {
 157             ++p;
 158             return p;
 159         }
 160     }
 161
 162     return word::null;
 163 }
 164
 165
 166 Foam::word Foam::userName()
 167 {
 168     struct passwd* pw = ::getpwuid(::getuid());
 169
 170     if (pw != NULL)
 171     {
 172         return pw->pw_name;
 173     }
 174     else
 175     {
 176         return word::null;
 177     }
 178 }
 179
 180
 181 bool Foam::isAdministrator()
 182 {
 183     return (::geteuid() == 0);
 184 }
 185
 186
 187 // use $HOME environment variable or passwd info
 188 Foam::fileName Foam::home()
 189 {
 190     char* env = ::getenv("HOME");
 191
 192     if (env != NULL)
 193     {
 194         return fileName(env);
 195     }
 196     else
 197     {
 198         struct passwd* pw = ::getpwuid(getuid());
 199
 200         if (pw != NULL)
 201         {
 202             return pw->pw_dir;
 203         }
 204         else
 205         {
 206             return fileName::null;
 207         }
 208     }
 209 }
 210
 211
 212 Foam::fileName Foam::home(const word& userName)
 213 {
 214     struct passwd* pw;
 215
 216     if (userName.size())
 217     {
 218         pw = ::getpwnam(userName.c_str());
 219     }
 220     else
 221     {
 222         char* env = ::getenv("HOME");
 223
 224         if (env != NULL)
 225         {
 226             return fileName(env);
 227         }
 228
 229         pw = ::getpwuid(::getuid());
 230     }
 231
 232     if (pw != NULL)
 233     {
 234         return pw->pw_dir;
 235     }
 236     else
 237     {
 238         return fileName::null;
 239     }
 240 }
 241
 242
 243 Foam::fileName Foam::cwd()
 244 {
 245     char buf[256];
 246     if (::getcwd(buf, sizeof(buf)))
 247     {
 248         return buf;
 249     }
 250     else
 251     {
 252         FatalErrorIn("Foam::cwd()")
 253             << "Couldn't get the current working directory"
 254             << exit(FatalError);
 255
 256         return fileName::null;
 257     }
 258 }
 259
 260
 261 bool Foam::chDir(const fileName& dir)
 262 {
 263     return ::chdir(dir.c_str()) == 0;
 264 }
 265
 266
 267 Foam::fileNameList Foam::findEtcFiles(const fileName& name, bool mandatory)
 268 {
 269     fileNameList results;
 270
 271     // Search for user files in
 272     // * ~/.OpenFOAM/VERSION
 273     // * ~/.OpenFOAM
 274     //
 275     fileName searchDir = home()/".OpenFOAM";
 276     if (isDir(searchDir))
 277     {
 278         fileName fullName = searchDir/FOAMversion/name;
 279         if (isFile(fullName))
 280         {
 281             results.append(fullName);
 282         }
 283
 284         fullName = searchDir/name;
 285         if (isFile(fullName))
 286         {
 287             results.append(fullName);
 288         }
 289     }
 290
 291     // Search for group (site) files in
 292     // * $WM_PROJECT_SITE/VERSION
 293     // * $WM_PROJECT_SITE
 294     //
 295     searchDir = getEnv("WM_PROJECT_SITE");
 296     if (searchDir.size())
 297     {
 298         if (isDir(searchDir))
 299         {
 300             fileName fullName = searchDir/FOAMversion/name;
 301             if (isFile(fullName))
 302             {
 303                 results.append(fullName);
 304             }
 305
 306             fullName = searchDir/name;
 307             if (isFile(fullName))
 308             {
 309                 results.append(fullName);
 310             }
 311         }
 312     }
 313     else
 314     {
 315         // OR search for group (site) files in
 316         // * $WM_PROJECT_INST_DIR/site/VERSION
 317         // * $WM_PROJECT_INST_DIR/site
 318         //
 319         searchDir = getEnv("WM_PROJECT_INST_DIR");
 320         if (isDir(searchDir))
 321         {
 322             fileName fullName = searchDir/"site"/FOAMversion/name;
 323             if (isFile(fullName))
 324             {
 325                 results.append(fullName);
 326             }
 327
 328             fullName = searchDir/"site"/name;
 329             if (isFile(fullName))
 330             {
 331                 results.append(fullName);
 332             }
 333         }
 334     }
 335
 336     // Search for other (shipped) files in
 337     // * $WM_PROJECT_DIR/etc
 338     //
 339     searchDir = getEnv("WM_PROJECT_DIR");
 340     if (isDir(searchDir))
 341     {
 342         fileName fullName = searchDir/"etc"/name;
 343         if (isFile(fullName))
 344         {
 345             results.append(fullName);
 346         }
 347     }
 348
 349     // Not found
 350     if (results.empty())
 351     {
 352         // Abort if the file is mandatory, otherwise return null
 353         if (mandatory)
 354         {
 355             std::cerr
 356                 << "--> FOAM FATAL ERROR in Foam::findEtcFiles() :"
 357                    " could not find mandatory file\n    '"
 358                 << name.c_str() << "'\n\n" << std::endl;
 359             ::exit(1);
 360         }
 361     }
 362
 363     // Return list of matching paths or empty list if none found
 364     return results;
 365 }
 366
 367
 368 Foam::fileName Foam::findEtcFile(const fileName& name, bool mandatory)
 369 {
 370     fileNameList results(findEtcFiles(name, mandatory));
 371
 372     if (results.size())
 373     {
 374         return results[0];
 375     }
 376     else
 377     {
 378         return fileName();
 379     }
 380 }
 381
 382
 383 bool Foam::mkDir(const fileName& pathName, mode_t mode)
 384 {
 385     // empty names are meaningless
 386     if (pathName.empty())
 387     {
 388         return false;
 389     }
 390
 391     // Construct instance path directory if does not exist
 392     if (::mkdir(pathName.c_str(), mode) == 0)
 393     {
 394         // Directory made OK so return true
 395         return true;
 396     }
 397     else
 398     {
 399         switch (errno)
 400         {
 401             case EPERM:
 402             {
 403                 FatalErrorIn("Foam::mkDir(const fileName&, mode_t)")
 404                     << "The filesystem containing " << pathName
 405                     << " does not support the creation of directories."
 406                     << exit(FatalError);
 407
 408                 return false;
 409             }
 410
 411             case EEXIST:
 412             {
 413                 // Directory already exists so simply return true
 414                 return true;
 415             }
 416
 417             case EFAULT:
 418             {
 419                 FatalErrorIn("Foam::mkDir(const fileName&, mode_t)")
 420                     << "" << pathName
 421                     << " points outside your accessible address space."
 422                     << exit(FatalError);
 423
 424                 return false;
 425             }
 426
 427             case EACCES:
 428             {
 429                 FatalErrorIn("Foam::mkDir(const fileName&, mode_t)")
 430                     << "The parent directory does not allow write "
 431                        "permission to the process,"<< nl
 432                     << "or one of the directories in " << pathName
 433                     << " did not allow search (execute) permission."
 434                     << exit(FatalError);
 435
 436                 return false;
 437             }
 438
 439             case ENAMETOOLONG:
 440             {
 441                 FatalErrorIn("Foam::mkDir(const fileName&, mode_t)")
 442                     << "" << pathName << " is too long."
 443                     << exit(FatalError);
 444
 445                 return false;
 446             }
 447
 448             case ENOENT:
 449             {
 450                 // Part of the path does not exist so try to create it
 451                 if (pathName.path().size() && mkDir(pathName.path(), mode))
 452                 {
 453                     return mkDir(pathName, mode);
 454                 }
 455                 else
 456                 {
 457                     FatalErrorIn("Foam::mkDir(const fileName&, mode_t)")
 458                         << "Couldn't create directory " << pathName
 459                         << exit(FatalError);
 460
 461                     return false;
 462                 }
 463             }
 464
 465             case ENOTDIR:
 466             {
 467                 FatalErrorIn("Foam::mkDir(const fileName&, mode_t)")
 468                     << "A component used as a directory in " << pathName
 469                     << " is not, in fact, a directory."
 470                     << exit(FatalError);
 471
 472                 return false;
 473             }
 474
 475             case ENOMEM:
 476             {
 477                 FatalErrorIn("Foam::mkDir(const fileName&, mode_t)")
 478                     << "Insufficient kernel memory was available to make "
 479                        "directory " << pathName << '.'
 480                     << exit(FatalError);
 481
 482                 return false;
 483             }
 484
 485             case EROFS:
 486             {
 487                 FatalErrorIn("Foam::mkDir(const fileName&, mode_t)")
 488                     << "" << pathName
 489                     << " refers to a file on a read-only filesystem."
 490                     << exit(FatalError);
 491
 492                 return false;
 493             }
 494
 495             case ELOOP:
 496             {
 497                 FatalErrorIn("Foam::mkDir(const fileName&, mode_t)")
 498                     << "Too many symbolic links were encountered in resolving "
 499                     << pathName << '.'
 500                     << exit(FatalError);
 501
 502                 return false;
 503             }
 504
 505             case ENOSPC:
 506             {
 507                 FatalErrorIn("Foam::mkDir(const fileName&, mode_t)")
 508                     << "The device containing " << pathName
 509                     << " has no room for the new directory or "
 510                     << "the user's disk quota is exhausted."
 511                     << exit(FatalError);
 512
 513                 return false;
 514             }
 515
 516             default:
 517             {
 518                 FatalErrorIn("Foam::mkDir(const fileName&, mode_t)")
 519                     << "Couldn't create directory " << pathName
 520                     << exit(FatalError);
 521
 522                 return false;
 523             }
 524         }
 525     }
 526 }
 527
 528
 529 // Set the file mode
 530 bool Foam::chMod(const fileName& name, const mode_t m)
 531 {
 532     return ::chmod(name.c_str(), m) == 0;
 533 }
 534
 535
 536 // Return the file mode
 537 mode_t Foam::mode(const fileName& name)
 538 {
 539     fileStat fileStatus(name);
 540     if (fileStatus.isValid())
 541     {
 542         return fileStatus.status().st_mode;
 543     }
 544     else
 545     {
 546         return 0;
 547     }
 548 }
 549
 550
 551 // Return the file type: FILE or DIRECTORY
 552 Foam::fileName::Type Foam::type(const fileName& name)
 553 {
 554     mode_t m = mode(name);
 555
 556     if (S_ISREG(m))
 557     {
 558         return fileName::FILE;
 559     }
 560     else if (S_ISDIR(m))
 561     {
 562         return fileName::DIRECTORY;
 563     }
 564     else
 565     {
 566         return fileName::UNDEFINED;
 567     }
 568 }
 569
 570
 571 // Does the name exist in the filing system?
 572 bool Foam::exists(const fileName& name, const bool checkGzip)
 573 {
 574     return mode(name) || isFile(name, checkGzip);
 575 }
 576
 577
 578 // Does the directory exist?
 579 bool Foam::isDir(const fileName& name)
 580 {
 581     return S_ISDIR(mode(name));
 582 }
 583
 584
 585 // Does the file exist?
 586 bool Foam::isFile(const fileName& name, const bool checkGzip)
 587 {
 588     return S_ISREG(mode(name)) || (checkGzip && S_ISREG(mode(name + ".gz")));
 589 }
 590
 591
 592 // Return size of file
 593 off_t Foam::fileSize(const fileName& name)
 594 {
 595     fileStat fileStatus(name);
 596     if (fileStatus.isValid())
 597     {
 598         return fileStatus.status().st_size;
 599     }
 600     else
 601     {
 602         return -1;
 603     }
 604 }
 605
 606
 607 // Return time of last file modification
 608 time_t Foam::lastModified(const fileName& name)
 609 {
 610     fileStat fileStatus(name);
 611     if (fileStatus.isValid())
 612     {
 613         return fileStatus.status().st_mtime;
 614     }
 615     else
 616     {
 617         return 0;
 618     }
 619 }
 620
 621
 622 // Read a directory and return the entries as a string list
 623 Foam::fileNameList Foam::readDir
 624 (
 625     const fileName& directory,
 626     const fileName::Type type,
 627     const bool filtergz
 628 )
 629 {
 630     // Initial filename list size
 631     // also used as increment if initial size found to be insufficient
 632     static const int maxNnames = 100;
 633
 634     if (POSIX::debug)
 635     {
 636         Info<< "readDir(const fileName&, const fileType, const bool filtergz)"
 637             << " : reading directory " << directory << endl;
 638     }
 639
 640     // Setup empty string list MAXTVALUES long
 641     fileNameList dirEntries(maxNnames);
 642
 643     // Pointers to the directory entries
 644     DIR *source;
 645     struct dirent *list;
 646
 647     // Temporary variables and counters
 648     label nEntries = 0;
 649
 650     // Attempt to open directory and set the structure pointer
 651     if ((source = ::opendir(directory.c_str())) == NULL)
 652     {
 653         dirEntries.setSize(0);
 654
 655         if (POSIX::debug)
 656         {
 657             Info<< "readDir(const fileName&, const fileType, "
 658                    "const bool filtergz) : cannot open directory "
 659                 << directory << endl;
 660         }
 661     }
 662     else
 663     {
 664         // Read and parse all the entries in the directory
 665         while ((list = ::readdir(source)) != NULL)
 666         {
 667             fileName fName(list->d_name);
 668
 669             // ignore files begining with ., i.e. '.', '..' and '.*'
 670             if (fName.size() && fName[0] != '.')
 671             {
 672                 word fExt = fName.ext();
 673
 674                 if
 675                 (
 676                     (type == fileName::DIRECTORY)
 677                  ||
 678                     (
 679                         type == fileName::FILE
 680                      && fName[fName.size()-1] != '~'
 681                      && fExt != "bak"
 682                      && fExt != "BAK"
 683                      && fExt != "old"
 684                      && fExt != "save"
 685                     )
 686                 )
 687                 {
 688                     if ((directory/fName).type() == type)
 689                     {
 690                         if (nEntries >= dirEntries.size())
 691                         {
 692                             dirEntries.setSize(dirEntries.size() + maxNnames);
 693                         }
 694
 695                         if (filtergz && fExt == "gz")
 696                         {
 697                             dirEntries[nEntries++] = fName.lessExt();
 698                         }
 699                         else
 700                         {
 701                             dirEntries[nEntries++] = fName;
 702                         }
 703                     }
 704                 }
 705             }
 706         }
 707
 708         // Reset the length of the entries list
 709         dirEntries.setSize(nEntries);
 710
 711         ::closedir(source);
 712     }
 713
 714     return dirEntries;
 715 }
 716
 717
 718 // Copy, recursively if necessary, the source to the destination
 719 bool Foam::cp(const fileName& src, const fileName& dest)
 720 {
 721     // Make sure source exists.
 722     if (!exists(src))
 723     {
 724         return false;
 725     }
 726
 727     fileName destFile(dest);
 728
 729     // Check type of source file.
 730     if (src.type() == fileName::FILE)
 731     {
 732         // If dest is a directory, create the destination file name.
 733         if (destFile.type() == fileName::DIRECTORY)
 734         {
 735             destFile = destFile/src.name();
 736         }
 737
 738         // Make sure the destination directory exists.
 739         if (!isDir(destFile.path()) && !mkDir(destFile.path()))
 740         {
 741             return false;
 742         }
 743
 744         // Open and check streams.
 745         std::ifstream srcStream(src.c_str());
 746         if (!srcStream)
 747         {
 748             return false;
 749         }
 750
 751         std::ofstream destStream(destFile.c_str());
 752         if (!destStream)
 753         {
 754             return false;
 755         }
 756
 757         // Copy character data.
 758         char ch;
 759         while (srcStream.get(ch))
 760         {
 761             destStream.put(ch);
 762         }
 763
 764         // Final check.
 765         if (!srcStream.eof() || !destStream)
 766         {
 767             return false;
 768         }
 769     }
 770     else if (src.type() == fileName::DIRECTORY)
 771     {
 772         // If dest is a directory, create the destination file name.
 773         if (destFile.type() == fileName::DIRECTORY)
 774         {
 775             destFile = destFile/src.component(src.components().size() -1);
 776         }
 777
 778         // Make sure the destination directory exists.
 779         if (!isDir(destFile) && !mkDir(destFile))
 780         {
 781             return false;
 782         }
 783
 784         // Copy files
 785         fileNameList contents = readDir(src, fileName::FILE, false);
 786         forAll(contents, i)
 787         {
 788             if (POSIX::debug)
 789             {
 790                 Info<< "Copying : " << src/contents[i]
 791                     << " to " << destFile/contents[i] << endl;
 792             }
 793
 794             // File to file.
 795             cp(src/contents[i], destFile/contents[i]);
 796         }
 797
 798         // Copy sub directories.
 799         fileNameList subdirs = readDir(src, fileName::DIRECTORY);
 800         forAll(subdirs, i)
 801         {
 802             if (POSIX::debug)
 803             {
 804                 Info<< "Copying : " << src/subdirs[i]
 805                     << " to " << destFile << endl;
 806             }
 807
 808             // Dir to Dir.
 809             cp(src/subdirs[i], destFile);
 810         }
 811     }
 812
 813     return true;
 814 }
 815
 816
 817 // Create a softlink. dst should not exist. Returns true if successful.
 818 bool Foam::ln(const fileName& src, const fileName& dst)
 819 {
 820     if (POSIX::debug)
 821     {
 822         Info<< "Create softlink from : " << src << " to " << dst
 823             << endl;
 824     }
 825
 826     if (exists(dst))
 827     {
 828         WarningIn("ln(const fileName&, const fileName&)")
 829             << "destination " << dst << " already exists. Not linking."
 830             << endl;
 831         return false;
 832     }
 833
 834     if (!exists(src))
 835     {
 836         WarningIn("ln(const fileName&, const fileName&)")
 837             << "source " << src << " does not exist." << endl;
 838         return false;
 839     }
 840
 841     if (::symlink(src.c_str(), dst.c_str()) == 0)
 842     {
 843         return true;
 844     }
 845     else
 846     {
 847         WarningIn("ln(const fileName&, const fileName&)")
 848             << "symlink from " << src << " to " << dst << " failed." << endl;
 849         return false;
 850     }
 851 }
 852
 853
 854 // Rename srcFile dstFile
 855 bool Foam::mv(const fileName& src, const fileName& dst)
 856 {
 857     if (POSIX::debug)
 858     {
 859         Info<< "Move : " << src << " to " << dst << endl;
 860     }
 861
 862     if
 863     (
 864         dst.type() == fileName::DIRECTORY
 865      && src.type() != fileName::DIRECTORY
 866     )
 867     {
 868         const fileName dstName(dst/src.name());
 869
 870         return ::rename(src.c_str(), dstName.c_str()) == 0;
 871     }
 872     else
 873     {
 874         return ::rename(src.c_str(), dst.c_str()) == 0;
 875     }
 876 }
 877
 878
 879 //- Rename to a corresponding backup file
 880 //  If the backup file already exists, attempt with "01" .. "99" index
 881 bool Foam::mvBak(const fileName& src, const std::string& ext)
 882 {
 883     if (POSIX::debug)
 884     {
 885         Info<< "mvBak : " << src << " to extension " << ext << endl;
 886     }
 887
 888     if (exists(src, false))
 889     {
 890         const int maxIndex = 99;
 891         char index[3];
 892
 893         for (int n = 0; n <= maxIndex; n++)
 894         {
 895             fileName dstName(src + "." + ext);
 896             if (n)
 897             {
 898                 sprintf(index, "%02d", n);
 899                 dstName += index;
 900             }
 901
 902             // avoid overwriting existing files, except for the last
 903             // possible index where we have no choice
 904             if (!exists(dstName, false) || n == maxIndex)
 905             {
 906                 return ::rename(src.c_str(), dstName.c_str()) == 0;
 907             }
 908
 909         }
 910     }
 911
 912     // fall-through: nothing to do
 913     return false;
 914 }
 915
 916
 917 // Remove a file, returning true if successful otherwise false
 918 bool Foam::rm(const fileName& file)
 919 {
 920     if (POSIX::debug)
 921     {
 922         Info<< "Removing : " << file << endl;
 923     }
 924
 925     // Try returning plain file name; if not there, try with .gz
 926     if (remove(file.c_str()) == 0)
 927     {
 928         return true;
 929     }
 930     else
 931     {
 932         return ::remove(string(file + ".gz").c_str()) == 0;
 933     }
 934 }
 935
 936
 937 // Remove a dirctory and its contents
 938 bool Foam::rmDir(const fileName& directory)
 939 {
 940     if (POSIX::debug)
 941     {
 942         Info<< "rmDir(const fileName&) : "
 943             << "removing directory " << directory << endl;
 944     }
 945
 946     // Pointers to the directory entries
 947     DIR *source;
 948     struct dirent *list;
 949
 950     // Attempt to open directory and set the structure pointer
 951     if ((source = ::opendir(directory.c_str())) == NULL)
 952     {
 953         WarningIn("rmDir(const fileName&)")
 954             << "cannot open directory " << directory << endl;
 955
 956         return false;
 957     }
 958     else
 959     {
 960         // Read and parse all the entries in the directory
 961         while ((list = ::readdir(source)) != NULL)
 962         {
 963             fileName fName(list->d_name);
 964
 965             if (fName != "." && fName != "..")
 966             {
 967                 fileName path = directory/fName;
 968
 969                 if (path.type() == fileName::DIRECTORY)
 970                 {
 971                     if (!rmDir(path))
 972                     {
 973                         WarningIn("rmDir(const fileName&)")
 974                             << "failed to remove directory " << fName
 975                             << " while removing directory " << directory
 976                             << endl;
 977
 978                         ::closedir(source);
 979
 980                         return false;
 981                     }
 982                 }
 983                 else
 984                 {
 985                     if (!rm(path))
 986                     {
 987                         WarningIn("rmDir(const fileName&)")
 988                             << "failed to remove file " << fName
 989                             << " while removing directory " << directory
 990                             << endl;
 991
 992                         ::closedir(source);
 993
 994                         return false;
 995                     }
 996                 }
 997             }
 998
 999         }
1000
1001         if (!rm(directory))
1002         {
1003             WarningIn("rmDir(const fileName&)")
1004                 << "failed to remove directory " << directory << endl;
1005
1006             ::closedir(source);
1007
1008             return false;
1009         }
1010
1011         ::closedir(source);
1012
1013         return true;
1014     }
1015 }
1016
1017
1018 unsigned int Foam::sleep(const unsigned int s)
1019 {
1020     return ::sleep(s);
1021 }
1022
1023
1024 void Foam::fdClose(const int fd)
1025 {
1026     if (close(fd) != 0)
1027     {
1028         FatalErrorIn
1029         (
1030             "fdClose(const int fd)"
1031         )   << "close error on " << fd << endl
1032             << abort(FatalError);
1033     }
1034 }
1035
1036
1037 bool Foam::ping
1038 (
1039     const word& destName,
1040     const label destPort,
1041     const label timeOut
1042 )
1043 {
1044     struct hostent *hostPtr;
1045     volatile int sockfd;
1046     struct sockaddr_in destAddr;      // will hold the destination addr
1047     u_int addr;
1048
1049     if ((hostPtr = ::gethostbyname(destName.c_str())) == NULL)
1050     {
1051         FatalErrorIn
1052         (
1053             "Foam::ping(const word&, ...)"
1054         )   << "gethostbyname error " << h_errno << " for host " << destName
1055             << abort(FatalError);
1056     }
1057
1058     // Get first of the SLL of addresses
1059     addr = (reinterpret_cast<struct in_addr*>(*(hostPtr->h_addr_list)))->s_addr;
1060
1061     // Allocate socket
1062     sockfd = ::socket(AF_INET, SOCK_STREAM, 0);
1063     if (sockfd < 0)
1064     {
1065         FatalErrorIn
1066         (
1067             "Foam::ping(const word&, const label)"
1068         )   << "socket error"
1069             << abort(FatalError);
1070     }
1071
1072     // Fill sockaddr_in structure with dest address and port
1073     memset(reinterpret_cast<char *>(&destAddr), '\0', sizeof(destAddr));
1074     destAddr.sin_family = AF_INET;
1075     destAddr.sin_port = htons(ushort(destPort));
1076     destAddr.sin_addr.s_addr = addr;
1077
1078
1079     timer myTimer(timeOut);
1080
1081     if (timedOut(myTimer))
1082     {
1083         // Setjmp from timer jumps back to here
1084         fdClose(sockfd);
1085         return false;
1086     }
1087
1088     if
1089     (
1090         ::connect
1091         (
1092             sockfd,
1093             reinterpret_cast<struct sockaddr*>(&destAddr),
1094             sizeof(struct sockaddr)
1095         ) != 0
1096     )
1097     {
1098         // Connection refused. Check if network was actually used or not.
1099
1100         int connectErr = errno;
1101
1102         fdClose(sockfd);
1103
1104         if (connectErr == ECONNREFUSED)
1105         {
1106             return true;
1107         }
1108         //perror("connect");
1109
1110         return false;
1111     }
1112
1113     fdClose(sockfd);
1114
1115     return true;
1116 }
1117
1118
1119 bool Foam::ping(const word& hostname, const label timeOut)
1120 {
1121     return ping(hostname, 222, timeOut) || ping(hostname, 22, timeOut);
1122 }
1123
1124
1125 int Foam::system(const std::string& command)
1126 {
1127     return ::system(command.c_str());
1128 }
1129
1130
1131 void* Foam::dlOpen(const fileName& lib)
1132 {
1133     if (POSIX::debug)
1134     {
1135         std::cout<< "dlOpen(const fileName&)"
1136             << " : dlopen of " << lib << std::endl;
1137     }
1138     void* handle = ::dlopen(lib.c_str(), RTLD_LAZY|RTLD_GLOBAL);
1139
1140     if (POSIX::debug)
1141     {
1142         std::cout
1143             << "dlOpen(const fileName&)"
1144             << " : dlopen of " << lib
1145             << " handle " << handle << std::endl;
1146     }
1147
1148     return handle;
1149 }
1150
1151
1152 bool Foam::dlClose(void* handle)
1153 {
1154     if (POSIX::debug)
1155     {
1156         std::cout
1157             << "dlClose(void*)"
1158             << " : dlclose of handle " << handle << std::endl;
1159     }
1160     return ::dlclose(handle) == 0;
1161 }
1162
1163
1164 void* Foam::dlSym(void* handle, const std::string& symbol)
1165 {
1166     if (POSIX::debug)
1167     {
1168         std::cout
1169             << "dlSym(void*, const std::string&)"
1170             << " : dlsym of " << symbol << std::endl;
1171     }
1172     // clear any old errors - see manpage dlopen
1173     (void) ::dlerror();
1174
1175     // get address of symbol
1176     void* fun = ::dlsym(handle, symbol.c_str());
1177
1178     // find error (if any)
1179     char *error = ::dlerror();
1180
1181     if (error)
1182     {
1183         WarningIn("dlSym(void*, const std::string&)")
1184             << "Cannot lookup symbol " << symbol << " : " << error
1185             << endl;
1186     }
1187
1188     return fun;
1189 }
1190
1191
1192 bool Foam::dlSymFound(void* handle, const std::string& symbol)
1193 {
1194     if (handle && !symbol.empty())
1195     {
1196         if (POSIX::debug)
1197         {
1198             std::cout
1199                 << "dlSymFound(void*, const std::string&)"
1200                 << " : dlsym of " << symbol << std::endl;
1201         }
1202
1203         // clear any old errors - see manpage dlopen
1204         (void) ::dlerror();
1205
1206         // get address of symbol
1207         (void) ::dlsym(handle, symbol.c_str());
1208
1209         // symbol can be found if there was no error
1210         return !::dlerror();
1211     }
1212     else
1213     {
1214         return false;
1215     }
1216 }
1217
1218
1219 static int collectLibsCallback
1220 (
1221     struct dl_phdr_info *info,
1222     size_t size,
1223     void *data
1224 )
1225 {
1226     Foam::DynamicList<Foam::fileName>* ptr =
1227         reinterpret_cast<Foam::DynamicList<Foam::fileName>*>(data);
1228     ptr->append(info->dlpi_name);
1229     return 0;
1230 }
1231
1232
1233 Foam::fileNameList Foam::dlLoaded()
1234 {
1235     DynamicList<fileName> libs;
1236     dl_iterate_phdr(collectLibsCallback, &libs);
1237     if (POSIX::debug)
1238     {
1239         std::cout
1240             << "dlLoaded()"
1241             << " : determined loaded libraries :" << libs.size() << std::endl;
1242     }
1243     return libs;
1244 }
1245
1246
1247 void Foam::osRandomSeed(const label seed)
1248 {
1249 #ifdef USE_RANDOM
1250     srandom((unsigned int)seed);
1251 #else
1252     srand48(seed);
1253 #endif
1254 }
1255
1256
1257 Foam::label Foam::osRandomInteger()
1258 {
1259 #ifdef USE_RANDOM
1260     return random();
1261 #else
1262     return lrand48();
1263 #endif
1264 }
1265
1266
1267 Foam::scalar Foam::osRandomDouble()
1268 {
1269 #ifdef USE_RANDOM
1270     return (scalar)random()/INT_MAX;
1271 #else
1272     return drand48();
1273 #endif
1274 }
1275
1276
1277 // ************************************************************************* //