lustre/tests/stat.c

   1 #include <stdio.h>
   2 #include <sys/stat.h>
   3 #include <sys/sysmacros.h>
   4 #include <pwd.h>
   5 #include <grp.h>
   6 #include <unistd.h>
   7 #include <time.h>
   8 #include <sys/vfs.h>
   9 #include <string.h>
  10 #include <malloc.h>
  11 #include <ctype.h>
  12 #include <stdlib.h>
  13
  14 #ifdef FLASK_LINUX
  15 #include <selinux/fs_secure.h>
  16 #include <linux/flask/security.h>
  17 #include <selinux/flask_util.h>           /* for is_flask_enabled() */
  18 #define SECURITY_ID_T security_id_t
  19 #else
  20 #define SECURITY_ID_T int
  21 #endif
  22
  23 #include "stat_fs.h"
  24
  25 void print_human_type(unsigned short mode)
  26 {
  27   switch (mode & S_IFMT)
  28     {
  29     case S_IFDIR:
  30       printf ("Directory");
  31       break;
  32     case S_IFCHR:
  33       printf ("Character Device");
  34       break;
  35     case S_IFBLK:
  36       printf ("Block Device");
  37       break;
  38     case S_IFREG:
  39       printf ("Regular File");
  40       break;
  41     case S_IFLNK:
  42       printf ("Symbolic Link");
  43       break;
  44     case S_IFSOCK:
  45       printf ("Socket");
  46       break;
  47     case S_IFIFO:
  48       printf ("Fifo File");
  49       break;
  50     default:
  51       printf ("Unknown");
  52     }
  53 }
  54
  55 void print_human_fstype(struct statfs *statfsbuf)
  56 {
  57   char *type;
  58
  59   switch (statfsbuf->f_type)
  60 #if defined (__linux__)
  61   {
  62         case S_MAGIC_AFFS:
  63           type = strdup("affs");
  64           break;
  65         case S_MAGIC_EXT:
  66           type = strdup("ext");
  67           break;
  68         case S_MAGIC_EXT2_OLD:
  69           type = strdup("ext2");
  70           break;
  71         case S_MAGIC_EXT2:
  72           type = strdup("ext2/ext3");
  73           break;
  74         case S_MAGIC_HPFS:
  75           type = strdup("hpfs");
  76           break;
  77         case S_MAGIC_ISOFS:
  78           type = strdup("isofs");
  79           break;
  80         case S_MAGIC_ISOFS_WIN:
  81           type = strdup("isofs");
  82           break;
  83         case S_MAGIC_ISOFS_R_WIN:
  84           type = strdup("isofs");
  85           break;
  86         case S_MAGIC_MINIX:
  87           type = strdup("minix");
  88           break;
  89         case S_MAGIC_MINIX_30:
  90           type = strdup("minix (30 char.)");
  91           break;
  92         case S_MAGIC_MINIX_V2:
  93           type = strdup("minix v2");
  94           break;
  95         case S_MAGIC_MINIX_V2_30:
  96           type = strdup("minix v2 (30 char.)");
  97           break;
  98         case S_MAGIC_MSDOS:
  99           type = strdup("msdos");
 100           break;
 101         case S_MAGIC_FAT:
 102           type = strdup("fat");
 103           break;
 104         case S_MAGIC_NCP:
 105           type = strdup("novell");
 106           break;
 107         case S_MAGIC_NFS:
 108           type = strdup("nfs");
 109           break;
 110         case S_MAGIC_PROC:
 111           type = strdup("proc");
 112           break;
 113         case S_MAGIC_SMB:
 114           type = strdup("smb");
 115           break;
 116         case S_MAGIC_XENIX:
 117           type = strdup("xenix");
 118           break;
 119         case S_MAGIC_SYSV4:
 120           type = strdup("sysv4");
 121           break;
 122         case S_MAGIC_SYSV2:
 123           type = strdup("sysv2");
 124           break;
 125         case S_MAGIC_COH:
 126           type = strdup("coh");
 127           break;
 128         case S_MAGIC_UFS:
 129           type = strdup("ufs");
 130           break;
 131         case S_MAGIC_XIAFS:
 132           type = strdup("xia");
 133           break;
 134         case S_MAGIC_NTFS:
 135           type = strdup("ntfs");
 136           break;
 137         case S_MAGIC_TMPFS:
 138           type = strdup("tmpfs");
 139           break;
 140         case S_MAGIC_REISERFS:
 141           type = strdup("reiserfs");
 142           break;
 143         case S_MAGIC_CRAMFS:
 144           type = strdup("cramfs");
 145           break;
 146         case S_MAGIC_ROMFS:
 147           type = strdup("romfs");
 148           break;
 149         case S_MAGIC_LUSTRE:
 150           type = strdup("lustre");
 151           break;
 152 #elif __GNU__
 153         case FSTYPE_UFS:
 154           type = strdup("ufs");
 155           break;
 156         case FSTYPE_NFS:
 157           type = strdup("nfs");
 158           break;
 159         case FSTYPE_GFS:
 160           type = strdup("gfs");
 161           break;
 162         case FSTYPE_LFS:
 163           type = strdup("lfs");
 164           break;
 165         case FSTYPE_SYSV:
 166           type = strdup("sysv");
 167           break;
 168         case FSTYPE_FTP:
 169           type = strdup("ftp");
 170           break;
 171         case FSTYPE_TAR:
 172           type = strdup("tar");
 173           break;
 174         case FSTYPE_AR:
 175           type = strdup("ar");
 176           break;
 177         case FSTYPE_CPIO:
 178           type = strdup("cpio");
 179           break;
 180         case FSTYPE_MSLOSS:
 181           type = strdup("msloss");
 182           break;
 183         case FSTYPE_CPM:
 184           type = strdup("cpm");
 185           break;
 186         case FSTYPE_HFS:
 187           type = strdup("hfs");
 188           break;
 189         case FSTYPE_DTFS:
 190           type = strdup("dtfs");
 191           break;
 192         case FSTYPE_GRFS:
 193           type = strdup("grfs");
 194           break;
 195         case FSTYPE_TERM:
 196           type = strdup("term");
 197           break;
 198         case FSTYPE_DEV:
 199           type = strdup("dev");
 200           break;
 201         case FSTYPE_PROC:
 202           type = strdup("proc");
 203           break;
 204         case FSTYPE_IFSOCK:
 205           type = strdup("ifsock");
 206           break;
 207         case FSTYPE_AFS:
 208           type = strdup("afs");
 209           break;
 210         case FSTYPE_DFS:
 211           type = strdup("dfs");
 212           break;
 213         case FSTYPE_PROC9:
 214           type = strdup("proc9");
 215           break;
 216         case FSTYPE_SOCKET:
 217           type = strdup("socket");
 218           break;
 219         case FSTYPE_MISC:
 220           type = strdup("misc");
 221           break;
 222         case FSTYPE_EXT2FS:
 223           type = strdup("ext2/ext3");
 224           break;
 225         case FSTYPE_HTTP:
 226           type = strdup("http");
 227           break;
 228         case FSTYPE_MEMFS:
 229           type = strdup("memfs");
 230           break;
 231         case FSTYPE_ISO9660:
 232           type = strdup("iso9660");
 233           break;
 234 #endif
 235         default:
 236           if ((type = (char*)malloc(30 * sizeof(char))) == NULL) {
 237                 perror("malloc error");
 238                 return;
 239           }
 240           sprintf (type, "UNKNOWN (0x%x)\n", (int)statfsbuf->f_type);
 241   }
 242
 243   printf("%s", type);
 244   free(type);
 245 }
 246
 247 void print_human_access(struct stat *statbuf)
 248 {
 249   char access[11];
 250
 251   access[10] = 0;
 252   access[9] = (statbuf->st_mode & S_IXOTH) ?
 253     ((statbuf->st_mode & S_ISVTX) ? 't' : 'x') :
 254     ((statbuf->st_mode & S_ISVTX) ? 'T' : '-');
 255   access[8] = (statbuf->st_mode & S_IWOTH) ? 'w' : '-';
 256   access[7] = (statbuf->st_mode & S_IROTH) ? 'r' : '-';
 257   access[6] = (statbuf->st_mode & S_IXGRP) ?
 258     ((statbuf->st_mode & S_ISGID) ? 's' : 'x') :
 259     ((statbuf->st_mode & S_ISGID) ? 'S' : '-');
 260   access[5] = (statbuf->st_mode & S_IWGRP) ? 'w' : '-';
 261   access[4] = (statbuf->st_mode & S_IRGRP) ? 'r' : '-';
 262   access[3] = (statbuf->st_mode & S_IXUSR) ?
 263     ((statbuf->st_mode & S_ISUID) ? 's' : 'x') :
 264     ((statbuf->st_mode & S_ISUID) ? 'S' : '-');
 265   access[2] = (statbuf->st_mode & S_IWUSR) ? 'w' : '-';
 266   access[1] = (statbuf->st_mode & S_IRUSR) ? 'r' : '-';
 267
 268   switch (statbuf->st_mode & S_IFMT)
 269     {
 270     case S_IFDIR:
 271       access[0] = 'd';
 272       break;
 273     case S_IFCHR:
 274       access[0] = 'c';
 275       break;
 276     case S_IFBLK:
 277       access[0] = 'b';
 278       break;
 279     case S_IFREG:
 280       access[0] = '-';
 281       break;
 282     case S_IFLNK:
 283       access[0] = 'l';
 284       break;
 285     case S_IFSOCK:
 286       access[0] = 's';
 287       break;
 288     case S_IFIFO:
 289       access[0] = 'p';
 290       break;
 291     default:
 292       access[0] = '?';
 293     }
 294     printf (access);
 295 }
 296
 297 /* trick gcc into being unable to recognize the %c format so it doesn't
 298  * issue its inane warning about %c and two-digit year representations. */
 299 static size_t strftime_wrapper(char *s, size_t max, const char *fmt,
 300                                struct tm *tm) {
 301         return strftime(s, max, fmt, tm);
 302 }
 303
 304 void print_human_time(time_t *t)
 305 {
 306   char str[40];
 307
 308   if (strftime_wrapper(str, 40, "%c", localtime(t)) > 0)
 309           printf(str);
 310   else
 311           printf("Cannot calculate human readable time, sorry");
 312 }
 313
 314 /* print statfs info */
 315 void print_statfs(char *pformat, char m, char *filename, void *data, SECURITY_ID_T sid)
 316 {
 317     struct statfs *statfsbuf = (struct statfs*)data;
 318 #ifdef FLASK_LINUX
 319     char sbuf[256];
 320     int rv;
 321     unsigned int sbuflen = sizeof(sbuf);
 322 #endif
 323
 324     switch(m) {
 325         case 'n':
 326             strcat(pformat, "s");
 327             printf(pformat, filename);
 328             break;
 329 #if !defined(__linux__) && defined (__GNU__)
 330         case 'i':
 331             strcat(pformat, "Lx");
 332             printf(pformat, statfsbuf->f_fsid);
 333             break;
 334 #else
 335         case 'i':
 336             strcat(pformat, "x %-8x");
 337             printf(pformat, statfsbuf->f_fsid.__val[0], statfsbuf->f_fsid.__val[1]);
 338             break;
 339 #endif
 340
 341         case 'l':
 342 #ifdef __USE_FILE_OFFSET64
 343             strcat(pformat, "lu");
 344 #else
 345             strcat(pformat, "d");
 346 #endif
 347             printf(pformat, statfsbuf->f_namelen);
 348             break;
 349         case 't':
 350 #ifdef __USE_FILE_OFFSET64
 351             strcat(pformat, "lx");
 352 #else
 353             strcat(pformat, "x");
 354 #endif
 355             printf(pformat, statfsbuf->f_type);
 356             break;
 357         case 'T':
 358 /*          print_human_fstype(statfsbuf, pformat);*/
 359             print_human_fstype(statfsbuf);
 360             break;
 361         case 'b':
 362 #ifdef __USE_FILE_OFFSET64
 363             strcat(pformat, "lld");
 364 #else
 365 #if !defined(__linux__) && defined (__GNU__)
 366             strcat(pformat, "d");
 367 #else
 368             strcat(pformat, "ld");
 369 #endif
 370 #endif
 371             printf(pformat, statfsbuf->f_blocks);
 372             break;
 373         case 'f':
 374 #ifdef __USE_FILE_OFFSET64
 375             strcat(pformat, "lld");
 376 #else
 377 #if !defined(__linux__) && defined (__GNU__)
 378             strcat(pformat, "d");
 379 #else
 380             strcat(pformat, "ld");
 381 #endif
 382 #endif
 383             printf(pformat, statfsbuf->f_bfree);
 384             break;
 385         case 'a':
 386 #ifdef __USE_FILE_OFFSET64
 387             strcat(pformat, "lld");
 388 #else
 389 #if !defined(__linux__) && defined (__GNU__)
 390             strcat(pformat, "d");
 391 #else
 392             strcat(pformat, "ld");
 393 #endif
 394 #endif
 395             printf(pformat, statfsbuf->f_bavail);
 396             break;
 397         case 's':
 398 #ifdef __USE_FILE_OFFSET64
 399             strcat(pformat, "ld");
 400 #else
 401             strcat(pformat, "d");
 402 #endif
 403             printf(pformat, statfsbuf->f_bsize);
 404             break;
 405         case 'c':
 406 #ifdef __USE_FILE_OFFSET64
 407             strcat(pformat, "lld");
 408 #else
 409 #if !defined(__linux__) && defined (__GNU__)
 410             strcat(pformat, "d");
 411 #else
 412             strcat(pformat, "ld");
 413 #endif
 414 #endif
 415             printf(pformat, statfsbuf->f_files);
 416             break;
 417         case 'd':
 418 #ifdef __USE_FILE_OFFSET64
 419             strcat(pformat, "lld");
 420 #else
 421 #if !defined(__linux__) && defined (__GNU__)
 422             strcat(pformat, "d");
 423 #else
 424             strcat(pformat, "ld");
 425 #endif
 426 #endif
 427             printf(pformat, statfsbuf->f_ffree);
 428             break;
 429 #ifdef FLASK_LINUX
 430         case 'S':
 431             strcat(pformat, "d");
 432             printf(pformat, sid);
 433             break;
 434         case 'C':
 435             rv = security_sid_to_context(sid, (security_context_t *) &sbuf, &sbuflen);
 436             if ( rv < 0 )
 437                 sprintf(sbuf, "<error finding security context %d>", sid);
 438             printf(sbuf);
 439             break;
 440 #endif
 441         default:
 442             strcat(pformat, "c");
 443             printf(pformat, m);
 444             break;
 445     }
 446 }
 447
 448 /* print stat info */
 449 void print_stat(char *pformat, char m, char *filename, void *data, SECURITY_ID_T sid)
 450 {
 451     char linkname[256];
 452     int i;
 453     struct stat *statbuf = (struct stat*)data;
 454     struct passwd *pw_ent;
 455     struct group *gw_ent;
 456 #ifdef FLASK_LINUX
 457     char sbuf[256];
 458     int rv;
 459     unsigned int sbuflen = sizeof(sbuf);
 460 #endif
 461
 462     switch(m) {
 463         case 'n':
 464             strcat(pformat, "s");
 465             printf(pformat, filename);
 466             break;
 467         case 'N':
 468             strcat(pformat, "s");
 469             if ((statbuf->st_mode & S_IFMT) == S_IFLNK) {
 470                 if ((i = readlink(filename, linkname, 256)) == -1) {
 471                     perror(filename);
 472                     return;
 473                 }
 474                 linkname[(i >= 256) ? 255 : i] = '\0';
 475                 /*printf("\"%s\" -> \"%s\"", filename, linkname);*/
 476                 printf("\"");
 477                 printf(pformat, filename);
 478                 printf("\" -> \"");
 479                 printf(pformat, linkname);
 480                 printf("\"");
 481             } else {
 482                 printf("\"");
 483                 printf(pformat, filename);
 484                 printf("\"");
 485             }
 486             break;
 487         case 'd':
 488             strcat(pformat, "d");
 489             printf(pformat, (int)statbuf->st_dev);
 490             break;
 491         case 'D':
 492             strcat(pformat, "x");
 493             printf(pformat, (int)statbuf->st_dev);
 494             break;
 495         case 'i':
 496             strcat(pformat, "d");
 497             printf(pformat, (int)statbuf->st_ino);
 498             break;
 499         case 'a':
 500             strcat(pformat, "o");
 501             printf(pformat, statbuf->st_mode & 07777);
 502             break;
 503         case 'A':
 504             print_human_access(statbuf);
 505             break;
 506         case 'f':
 507             strcat(pformat, "x");
 508             printf(pformat, statbuf->st_mode);
 509             break;
 510         case 'F':
 511             print_human_type(statbuf->st_mode);
 512             break;
 513         case 'h':
 514             strcat(pformat, "d");
 515             printf(pformat, (int)statbuf->st_nlink);
 516             break;
 517 #ifdef FLASK_LINUX
 518         case 'S':
 519             strcat(pformat, "d");
 520             printf(pformat, sid);
 521             break;
 522         case 'C':
 523             rv = security_sid_to_context(sid, (security_context_t *) &sbuf, &sbuflen);
 524             if ( rv < 0 )
 525                 sprintf(sbuf, "<error finding security context %d>", sid);
 526             printf(sbuf);
 527             break;
 528 #endif
 529         case 'u':
 530             strcat(pformat, "d");
 531             printf(pformat, statbuf->st_uid);
 532             break;
 533         case 'U':
 534             strcat(pformat, "s");
 535             setpwent();
 536             pw_ent = getpwuid(statbuf->st_uid);
 537             printf(pformat,
 538                 (pw_ent != 0L) ? pw_ent->pw_name : "UNKNOWN");
 539             break;
 540         case 'g':
 541             strcat(pformat, "d");
 542             printf(pformat, statbuf->st_gid);
 543             break;
 544         case 'G':
 545             strcat(pformat, "s");
 546             setgrent();
 547             gw_ent = getgrgid(statbuf->st_gid);
 548             printf(pformat,
 549                 (gw_ent != 0L) ? gw_ent->gr_name : "UNKNOWN");
 550             break;
 551         case 't':
 552             strcat(pformat, "x");
 553             printf(pformat, major(statbuf->st_rdev));
 554             break;
 555         case 'T':
 556             strcat(pformat, "x");
 557             printf(pformat, minor(statbuf->st_rdev));
 558             break;
 559         case 's':
 560 #ifdef __USE_FILE_OFFSET64
 561             strcat(pformat, "llu");
 562             printf(pformat, (unsigned long long)statbuf->st_size);
 563 #else
 564             strcat(pformat, "u");
 565             printf(pformat, (unsigned int)statbuf->st_size);
 566 #endif
 567             break;
 568         case 'b':
 569             strcat(pformat, "u");
 570             printf(pformat, (unsigned int)statbuf->st_blocks);
 571             break;
 572         case 'o':
 573             strcat(pformat, "d");
 574             printf(pformat, (int)statbuf->st_blksize);
 575             break;
 576         case 'x':
 577             print_human_time(&(statbuf->st_atime));
 578             break;
 579         case 'X':
 580             strcat(pformat, "d");
 581             printf(pformat, (int)statbuf->st_atime);
 582             break;
 583         case 'y':
 584             print_human_time(&(statbuf->st_mtime));
 585             break;
 586         case 'Y':
 587             strcat(pformat, "d");
 588             printf(pformat, (int)statbuf->st_mtime);
 589             break;
 590         case 'z':
 591             print_human_time(&(statbuf->st_ctime));
 592             break;
 593         case 'Z':
 594             strcat(pformat, "d");
 595             printf(pformat, (int)statbuf->st_ctime);
 596             break;
 597         default:
 598             strcat(pformat, "c");
 599             printf(pformat, m);
 600             break;
 601     }
 602 }
 603
 604 void print_it(char *masterformat, char *filename,
 605     void (*print_func)(char*, char, char*, void*, SECURITY_ID_T), void *data, SECURITY_ID_T sid)
 606 {
 607     char *m, *b, *format;
 608     char pformat[65];
 609
 610     /* create a working copy of the format string */
 611     format = strdup(masterformat);
 612     if (!format) {
 613         perror(filename);
 614         return;
 615     }
 616
 617     b = format;
 618     while (b)
 619     {
 620         if ((m = strchr(b, (int)'%')) != NULL)
 621         {
 622             strcpy (pformat, "%");
 623             *m++ = '\0';
 624             printf(b);
 625
 626             /* copy all format specifiers to our format string */
 627             while (isdigit(*m) || strchr("#0-+. I", *m))
 628             {
 629                 char copy[2]="a";
 630
 631                 *copy = *m;
 632                 /* make sure the format specifier is not too long */
 633                 if (strlen (pformat) > 63)
 634                         fprintf(stderr, "Warning: Format specifier too long, truncating: %s\n", pformat);
 635                 else
 636                         strcat (pformat, copy);
 637                 m++;
 638             }
 639
 640             switch(*m) {
 641                 case '\0':
 642                 case '%':
 643                     printf("%%");
 644                     break;
 645                 default:
 646                     print_func(pformat, *m, filename, data, sid);
 647                     break;
 648             }
 649             b = m + 1;
 650         }
 651         else
 652         {
 653             printf(b);
 654             b = NULL;
 655         }
 656     }
 657     free(format);
 658     printf("\n");
 659 }
 660
 661 /* stat the filesystem and print what we find */
 662 void
 663 do_statfs (char *filename, int terse, int secure, char *format)
 664 {
 665   struct statfs statfsbuf;
 666   SECURITY_ID_T sid = -1;
 667   int i;
 668
 669 #ifdef FLASK_LINUX
 670   if(!is_flask_enabled())
 671     secure = 0;
 672   if(secure)
 673     i = statfs_secure(filename, &statfsbuf, &sid);
 674   else
 675 #endif
 676     i = statfs(filename, &statfsbuf);
 677   if(i == -1)
 678     {
 679       perror (filename);
 680       return;
 681     }
 682
 683   if (format == NULL)
 684     {
 685         if (terse != 0)
 686           {
 687 #ifdef FLASK_LINUX
 688                 if(secure)
 689                         format = "%n %i %l %t %b %f %a %s %c %d %S %C";
 690                 else
 691 #endif
 692                         format = "%n %i %l %t %b %f %a %s %c %d";
 693           }
 694         else
 695           {
 696 #ifdef FLASK_LINUX
 697                 if(secure)
 698                     format = "  File: \"%n\"\n"
 699                          "    ID: %-8i Namelen: %-7l Type: %T\n"
 700                          "Blocks: Total: %-10b Free: %-10f Available: %-10a Size: %s\n"
 701                          "Inodes: Total: %-10c Free: %-10d\n"
 702                          "   SID: %-14S  S_Context: %C\n";
 703                 else
 704 #endif
 705                     format = "  File: \"%n\"\n"
 706                          "    ID: %-8i Namelen: %-7l Type: %T\n"
 707                          "Blocks: Total: %-10b Free: %-10f Available: %-10a Size: %s\n"
 708                          "Inodes: Total: %-10c Free: %-10d";
 709           }
 710     }
 711
 712     print_it(format, filename, print_statfs, &statfsbuf, sid);
 713 }
 714
 715 /* stat the file and print what we find */
 716 void
 717 do_stat (char *filename, int link, int terse, int secure, char *format)
 718 {
 719   struct stat statbuf;
 720   int i;
 721   SECURITY_ID_T sid = -1;
 722
 723 #ifdef FLASK_LINUX
 724   if(!is_flask_enabled())
 725     secure = 0;
 726   if(secure)
 727     i = (link == 1) ? stat_secure(filename, &statbuf, &sid) : lstat_secure(filename, &statbuf, &sid);
 728   else
 729 #endif
 730   i = (link == 1) ? stat(filename, &statbuf) : lstat(filename, &statbuf);
 731
 732   if (i == -1)
 733     {
 734       perror (filename);
 735       return;
 736     }
 737
 738    if (format == NULL)
 739     {
 740        if (terse != 0)
 741        {
 742 #ifdef FLASK_LINUX
 743            if (secure)
 744                   format = "%n %s %b %f %u %g %D %i %h %t %T %X %Y %Z %o %S %C";
 745            else
 746 #endif
 747                   format = "%n %s %b %f %u %g %D %i %h %t %T %X %Y %Z %o";
 748        }
 749        else
 750        {
 751            /* tmp hack to match orignal output until conditional implemented */
 752           i = statbuf.st_mode & S_IFMT;
 753           if (i == S_IFCHR || i == S_IFBLK) {
 754 #ifdef FLASK_LINUX
 755                 if (secure)
 756                         format =
 757                            "  File: %N\n"
 758                            "  Size: %-10s\tBlocks: %-10b IO Block: %-6o %F\n"
 759                            "Device: %Dh/%dd\tInode: %-10i  Links: %-5h"
 760                            " Device type: %t,%T\n"
 761                            "Access: (%04a/%10.10A)  Uid: (%5u/%8U)   Gid: (%5g/%8G)\n"
 762                            "   SID: %-14S  S_Context: %C\n"
 763                            "Access: %x\n"
 764                            "Modify: %y\n"
 765                            "Change: %z\n";
 766                 else
 767 #endif
 768                         format =
 769                            "  File: %N\n"
 770                            "  Size: %-10s\tBlocks: %-10b IO Block: %-6o %F\n"
 771                            "Device: %Dh/%dd\tInode: %-10i  Links: %-5h"
 772                            " Device type: %t,%T\n"
 773                            "Access: (%04a/%10.10A)  Uid: (%5u/%8U)   Gid: (%5g/%8G)\n"
 774                            "Access: %x\n"
 775                            "Modify: %y\n"
 776                            "Change: %z\n";
 777            }
 778            else
 779            {
 780 #ifdef FLASK_LINUX
 781                 if (secure)
 782                        format =
 783                            "  File: %N\n"
 784                            "  Size: %-10s\tBlocks: %-10b IO Block: %-6o %F\n"
 785                            "Device: %Dh/%dd\tInode: %-10i  Links: %-5h\n"
 786                            "Access: (%04a/%10.10A)  Uid: (%5u/%8U)   Gid: (%5g/%8G)\n"
 787                            "   SID: %-14S  S_Context: %C\n"
 788                            "Access: %x\n"
 789                            "Modify: %y\n"
 790                            "Change: %z\n";
 791                 else
 792 #endif
 793                       format =
 794                            "  File: %N\n"
 795                            "  Size: %-10s\tBlocks: %-10b IO Block: %-6o %F\n"
 796                            "Device: %Dh/%dd\tInode: %-10i  Links: %-5h\n"
 797                            "Access: (%04a/%10.10A)  Uid: (%5u/%8U)   Gid: (%5g/%8G)\n"
 798                            "Access: %x\n"
 799                            "Modify: %y\n"
 800                            "Change: %z\n";
 801           }
 802        }
 803     }
 804     print_it(format, filename, print_stat, &statbuf, sid);
 805 }
 806
 807 void
 808 usage (char *progname)
 809 {
 810   fprintf (stderr, "Usage: %s [-l] [-f] [-s] [-v] [-h] [-t] [-c format] file1 [file2 ...]\n", progname);
 811   exit (1);
 812 }
 813
 814 void verbose_usage(char *progname)
 815 {
 816     fprintf(stderr, "Usage: %s [-l] [-f] [-s] [-v] [-h] [-t] [-c format] file1 [file2 ...]\n", progname);
 817     fprintf(stderr, "\tformat interpreted sequences for file stat are:\n");
 818     fprintf(stderr, "\t\t%%n - File name\n");
 819     fprintf(stderr, "\t\t%%N - Quoted File name with dereference if symbolic link\n");
 820     fprintf(stderr, "\t\t%%d - Device number in decimal\n");
 821     fprintf(stderr, "\t\t%%D - Device number in hex\n");
 822     fprintf(stderr, "\t\t%%i - Inode number\n");
 823     fprintf(stderr, "\t\t%%a - Access rights in octal\n");
 824     fprintf(stderr, "\t\t%%A - Access rights in human readable form\n");
 825     fprintf(stderr, "\t\t%%f - raw mode in hex\n");
 826     fprintf(stderr, "\t\t%%F - File type\n");
 827     fprintf(stderr, "\t\t%%h - Number of hard links\n");
 828     fprintf(stderr, "\t\t%%u - User Id of owner\n");
 829     fprintf(stderr, "\t\t%%U - User name of owner\n");
 830     fprintf(stderr, "\t\t%%g - Group Id of owner\n");
 831     fprintf(stderr, "\t\t%%G - Group name of owner\n");
 832     fprintf(stderr, "\t\t%%t - Major device type in hex\n");
 833     fprintf(stderr, "\t\t%%T - Minor device type in hex\n");
 834     fprintf(stderr, "\t\t%%s - Total size, in bytes\n");
 835     fprintf(stderr, "\t\t%%b - Number of blocks allocated\n");
 836     fprintf(stderr, "\t\t%%o - IO block size\n");
 837     fprintf(stderr, "\t\t%%x - Time of last access\n");
 838     fprintf(stderr, "\t\t%%X - Time of last access as seconds since Epoch\n");
 839     fprintf(stderr, "\t\t%%y - Time of last modification\n");
 840     fprintf(stderr, "\t\t%%Y - Time of last modification as seconds since Epoch\n");
 841     fprintf(stderr, "\t\t%%z - Time of last change\n");
 842     fprintf(stderr, "\t\t%%Z - Time of last change as seconds since Epoch\n");
 843     fprintf(stderr, "\t\t%%S - Security ID in SE-Linux\n");
 844     fprintf(stderr, "\t\t%%C - Security context in SE-Linux\n");
 845     fprintf(stderr, "\tformat interpreted sequences for filesystem stat are:\n");
 846     fprintf(stderr, "\t\t%%n - File name\n");
 847     fprintf(stderr, "\t\t%%i - File System id in hex\n");
 848     fprintf(stderr, "\t\t%%l - Maximum length of filenames\n");
 849     fprintf(stderr, "\t\t%%t - Type in hex\n");
 850     fprintf(stderr, "\t\t%%T - Type in human readable form\n");
 851     fprintf(stderr, "\t\t%%b - Total data blocks in file system\n");
 852     fprintf(stderr, "\t\t%%f - Free blocks in file system\n");
 853     fprintf(stderr, "\t\t%%a - Free blocks available to non-superuser\n");
 854     fprintf(stderr, "\t\t%%s - Optimal transfer block size\n");
 855     fprintf(stderr, "\t\t%%c - Total file nodes in file system\n");
 856     fprintf(stderr, "\t\t%%S - Security ID in SE-Linux\n");
 857     fprintf(stderr, "\t\t%%C - Security context in SE-Linux\n");
 858     fprintf(stderr, "\t\t%%d - Free file nodes in file system\n");
 859     exit(1);
 860 }
 861
 862
 863 int
 864 main (int argc, char *argv[])
 865 {
 866   int c, i, link = 0, fs = 0, terse = 0, secure = 0;
 867   char *format = NULL;
 868
 869   while ((c = getopt (argc, argv, "lsfvthc:")) != EOF)
 870     {
 871       switch (c)
 872         {
 873         case 'l':
 874           link = 1;
 875           break;
 876         case 's':
 877           secure = 1;
 878           break;
 879         case 'f':
 880           fs = 1;
 881           break;
 882         case 't':
 883           terse = 1;
 884           break;
 885         case 'c':
 886           format = optarg;
 887           break;
 888         case 'h':
 889           printf ("stat version: 3.0\n");
 890           verbose_usage(argv[0]);
 891           break;
 892         case 'v':
 893           printf ("stat version: 3.0\n");
 894         default:
 895           usage (argv[0]);
 896         }
 897     }
 898   if (argc == optind)
 899     usage (argv[0]);
 900
 901   for (i = optind; i < argc; i++)
 902     (fs == 0) ? do_stat (argv[i], link, terse, secure, format) :
 903                 do_statfs (argv[i], terse, secure, format);
 904
 905   return (0);
 906 }