Actual source code: ftest.c
petsc-3.10.5 2019-03-28
Report Typos and Errors

      2:  #include <petscsys.h>
      3: #include <errno.h>
      4: #if defined(PETSC_HAVE_PWD_H)
      5: #include <pwd.h>
      6: #endif
      7: #include <ctype.h>
      8: #include <sys/stat.h>
      9: #if defined(PETSC_HAVE_UNISTD_H)
     10: #include <unistd.h>
     11: #endif
     12: #if defined(PETSC_HAVE_SYS_UTSNAME_H)
     13: #include <sys/utsname.h>
     14: #endif
     15: #if defined(PETSC_HAVE_IO_H)
     16: #include <io.h>
     17: #endif
     18: #if defined(PETSC_HAVE_SYS_SYSTEMINFO_H)
     19: #include <sys/systeminfo.h>
     20: #endif

     22: #if defined(PETSC_HAVE__ACCESS) || defined(PETSC_HAVE_ACCESS)

     24: static PetscErrorCode PetscTestOwnership(const char fname[], char mode, uid_t fuid, gid_t fgid, int fmode, PetscBool  *flg)
     25: {
     26:   int            m = R_OK;

     30:   if (mode == 'r') m = R_OK;
     31:   else if (mode == 'w') m = W_OK;
     32:   else if (mode == 'x') m = X_OK;
     33:   else SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG, "Mode must be one of r, w, or x");
     34: #if defined(PETSC_HAVE_ACCESS)
     35:   if (!access(fname, m)) {
     36:     PetscInfo1(NULL,"System call access() succeeded on file %s\n",fname);
     37:     *flg = PETSC_TRUE;
     38:   } else {
     39:     PetscInfo1(NULL,"System call access() failed on file %s\n",fname);
     40:     *flg = PETSC_FALSE;
     41:   }
     42: #else
     43:   if (m == X_OK) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP, "Unable to check execute permission for file %s", fname);
     44:   if (!_access(fname, m)) *flg = PETSC_TRUE;
     45: #endif
     46:   return(0);
     47: }

     49: #else  /* PETSC_HAVE_ACCESS or PETSC_HAVE__ACCESS */

     51: static PetscErrorCode PetscTestOwnership(const char fname[], char mode, uid_t fuid, gid_t fgid, int fmode, PetscBool  *flg)
     52: {
     53:   uid_t          uid;
     54:   gid_t          *gid = NULL;
     55:   int            numGroups;
     56:   int            rbit = S_IROTH;
     57:   int            wbit = S_IWOTH;
     58:   int            ebit = S_IXOTH;

     62:   /* Get the number of supplementary group IDs */
     63: #if !defined(PETSC_MISSING_GETGROUPS)
     64:   numGroups = getgroups(0, gid); if (numGroups < 0) SETERRQ(PETSC_COMM_SELF,numGroups, "Unable to count supplementary group IDs");
     65:   PetscMalloc1(numGroups+1, &gid);
     66: #else
     67:   numGroups = 0;
     68: #endif

     70:   /* Get the (effective) user and group of the caller */
     71:   uid    = geteuid();
     72:   gid[0] = getegid();

     74:   /* Get supplementary group IDs */
     75: #if !defined(PETSC_MISSING_GETGROUPS)
     76:   getgroups(numGroups, gid+1); if (ierr < 0) SETERRQ(PETSC_COMM_SELF,ierr, "Unable to obtain supplementary group IDs");
     77: #endif

     79:   /* Test for accessibility */
     80:   if (fuid == uid) {
     81:     rbit = S_IRUSR;
     82:     wbit = S_IWUSR;
     83:     ebit = S_IXUSR;
     84:   } else {
     85:     int g;

     87:     for (g = 0; g <= numGroups; g++) {
     88:       if (fgid == gid[g]) {
     89:         rbit = S_IRGRP;
     90:         wbit = S_IWGRP;
     91:         ebit = S_IXGRP;
     92:         break;
     93:       }
     94:     }
     95:   }
     96:   PetscFree(gid);

     98:   if (mode == 'r') {
     99:     if (fmode & rbit) *flg = PETSC_TRUE;
    100:   } else if (mode == 'w') {
    101:     if (fmode & wbit) *flg = PETSC_TRUE;
    102:   } else if (mode == 'x') {
    103:     if (fmode & ebit) *flg = PETSC_TRUE;
    104:   }
    105:   return(0);
    106: }

    108: #endif /* PETSC_HAVE_ACCESS */

    110: static PetscErrorCode PetscGetFileStat(const char fname[], uid_t *fileUid, gid_t *fileGid, int *fileMode,PetscBool  *exists)
    111: {
    112:   struct stat    statbuf;

    116:   *fileMode = 0;
    117:   *exists = PETSC_FALSE;
    118: #if defined(PETSC_HAVE_STAT_NO_CONST)
    119:   stat((char*) fname, &statbuf);
    120: #else
    121:   stat(fname, &statbuf);
    122: #endif
    123:   if (ierr) {
    124: #if defined(EOVERFLOW)
    125:     if (errno == EOVERFLOW) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SYS,"EOVERFLOW in stat(), configure PETSc --with-large-file-io=1 to support files larger than 2GiB");
    126: #endif
    127:     PetscInfo1(NULL,"System call stat() failed on file %s\n",fname);
    128:     *exists = PETSC_FALSE;
    129:   } else {
    130:     PetscInfo1(NULL,"System call stat() succeeded on file %s\n",fname);
    131:     *exists   = PETSC_TRUE;
    132:     *fileUid  = statbuf.st_uid;
    133:     *fileGid  = statbuf.st_gid;
    134:     *fileMode = statbuf.st_mode;
    135:   }
    136:   return(0);
    137: }

    139: /*@C
    140:    PetscTestFile - checks for the existence of a file

    142:    Not Collective

    144:    Input Parameter:
    145: +  fname - the filename
    146: -  mode - either 'r', 'w', or 'x'

    148:    Output Parameter:
    149: .  flg - the file exists and satisfies the mode

    151:    Level: intermediate

    153: .seealso: PetscTestDirectory(), PetscLs()
    154: @*/
    155: PetscErrorCode  PetscTestFile(const char fname[], char mode, PetscBool  *flg)
    156: {
    157:   uid_t          fuid;
    158:   gid_t          fgid;
    159:   int            fmode;
    161:   PetscBool      exists;

    164:   *flg = PETSC_FALSE;
    165:   if (!fname) return(0);

    167:   PetscGetFileStat(fname, &fuid, &fgid, &fmode,&exists);
    168:   if (!exists) return(0);
    169:   /* Except for systems that have this broken stat macros (rare), this is the correct way to check for a regular file */
    170:   if (!S_ISREG(fmode)) return(0);

    172:   PetscTestOwnership(fname, mode, fuid, fgid, fmode, flg);
    173:   return(0);
    174: }

    176: /*@C
    177:    PetscTestDirectory - checks for the existence of a directory

    179:    Not Collective

    181:    Input Parameter:
    182: +  dirname - the directory name
    183: -  mode - either 'r', 'w', or 'x'

    185:    Output Parameter:
    186: .  flg - the directory exists and satisfies the mode

    188:    Level: intermediate

    190: .seealso: PetscTestFile(), PetscLs()
    191: @*/
    192: PetscErrorCode  PetscTestDirectory(const char dirname[],char mode,PetscBool  *flg)
    193: {
    194:   uid_t          fuid;
    195:   gid_t          fgid;
    196:   int            fmode;
    198:   PetscBool      exists;

    201:   *flg = PETSC_FALSE;
    202:   if (!dirname) return(0);

    204:   PetscGetFileStat(dirname, &fuid, &fgid, &fmode,&exists);
    205:   if (!exists) return(0);
    206:   /* Except for systems that have this broken stat macros (rare), this
    207:      is the correct way to check for a directory */
    208:   if (!S_ISDIR(fmode)) return(0);

    210:   PetscTestOwnership(dirname, mode, fuid, fgid, fmode, flg);
    211:   return(0);
    212: }

    214: /*@C
    215:    PetscLs - produce a listing of the files in a directory

    217:    Collective on MPI_Comm

    219:    Input Parameter:
    220: +  comm - the MPI communicator
    221: .  dirname - the directory name
    222: -  tlen - the length of the buffer found[]

    224:    Output Parameter:
    225: +  found - listing of files
    226: -  flg - the directory exists

    228:    Level: intermediate

    230: .seealso: PetscTestFile(), PetscLs()
    231: @*/
    232: PetscErrorCode  PetscLs(MPI_Comm comm,const char dirname[],char found[],size_t tlen,PetscBool  *flg)
    233: {
    235:   size_t         len;
    236:   char           *f,program[PETSC_MAX_PATH_LEN];
    237:   FILE           *fp;

    240:   PetscStrcpy(program,"ls ");
    241:   PetscStrcat(program,dirname);
    242: #if defined(PETSC_HAVE_POPEN)
    243:   PetscPOpen(comm,NULL,program,"r",&fp);
    244: #else
    245:   SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP_SYS,"Cannot run external programs on this machine");
    246: #endif
    247:   f = fgets(found,tlen,fp);
    248:   if (f) *flg = PETSC_TRUE;
    249:   else *flg = PETSC_FALSE;
    250:   while (f) {
    251:     PetscStrlen(found,&len);
    252:     f    = fgets(found+len,tlen-len,fp);
    253:   }
    254:   if (*flg) {PetscInfo2(0,"ls on %s gives \n%s\n",dirname,found);}
    255: #if defined(PETSC_HAVE_POPEN)
    256:   PetscPClose(comm,fp);
    257: #else
    258:   SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP_SYS,"Cannot run external programs on this machine");
    259: #endif
    260:   return(0);
    261: }