tools/regression/fstest/fstest.c

   1 /*-
   2  * Copyright (c) 2006-2007 Pawel Jakub Dawidek <pjd@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD$
  27  */
  28
  29 #include <sys/param.h>
  30 #include <sys/stat.h>
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <unistd.h>
  34 #include <fcntl.h>
  35 #include <grp.h>
  36 #include <string.h>
  37 #include <ctype.h>
  38 #include <errno.h>
  39 #include <assert.h>
  40
  41 #ifndef HAS_TRUNCATE64
  42 #define truncate64      truncate
  43 #endif
  44 #ifndef HAS_STAT64
  45 #define stat64  stat
  46 #define lstat64 lstat
  47 #endif
  48
  49 #ifndef ALLPERMS
  50 #define ALLPERMS        (S_ISUID|S_ISGID|S_ISVTX|S_IRWXU|S_IRWXG|S_IRWXO)
  51 #endif
  52
  53 enum action {
  54         ACTION_OPEN,
  55         ACTION_CREATE,
  56         ACTION_UNLINK,
  57         ACTION_MKDIR,
  58         ACTION_RMDIR,
  59         ACTION_LINK,
  60         ACTION_SYMLINK,
  61         ACTION_RENAME,
  62         ACTION_MKFIFO,
  63         ACTION_CHMOD,
  64 #ifdef HAS_LCHMOD
  65         ACTION_LCHMOD,
  66 #endif
  67         ACTION_CHOWN,
  68         ACTION_LCHOWN,
  69 #ifdef HAS_CHFLAGS
  70         ACTION_CHFLAGS,
  71 #endif
  72 #ifdef HAS_LCHFLAGS
  73         ACTION_LCHFLAGS,
  74 #endif
  75         ACTION_TRUNCATE,
  76         ACTION_STAT,
  77         ACTION_LSTAT,
  78 };
  79
  80 #define TYPE_NONE       0x0000
  81 #define TYPE_STRING     0x0001
  82 #define TYPE_NUMBER     0x0002
  83
  84 #define TYPE_OPTIONAL   0x0100
  85
  86 #define MAX_ARGS        8
  87
  88 struct syscall_desc {
  89         char            *sd_name;
  90         enum action      sd_action;
  91         int              sd_args[MAX_ARGS];
  92 };
  93
  94 static struct syscall_desc syscalls[] = {
  95         { "open", ACTION_OPEN, { TYPE_STRING, TYPE_STRING, TYPE_NUMBER | TYPE_OPTIONAL, TYPE_NONE } },
  96         { "create", ACTION_CREATE, { TYPE_STRING, TYPE_NUMBER, TYPE_NONE } },
  97         { "unlink", ACTION_UNLINK, { TYPE_STRING, TYPE_NONE } },
  98         { "mkdir", ACTION_MKDIR, { TYPE_STRING, TYPE_NUMBER, TYPE_NONE } },
  99         { "rmdir", ACTION_RMDIR, { TYPE_STRING, TYPE_NONE } },
 100         { "link", ACTION_LINK, { TYPE_STRING, TYPE_STRING, TYPE_NONE } },
 101         { "symlink", ACTION_SYMLINK, { TYPE_STRING, TYPE_STRING, TYPE_NONE } },
 102         { "rename", ACTION_RENAME, { TYPE_STRING, TYPE_STRING, TYPE_NONE } },
 103         { "mkfifo", ACTION_MKFIFO, { TYPE_STRING, TYPE_NUMBER, TYPE_NONE } },
 104         { "chmod", ACTION_CHMOD, { TYPE_STRING, TYPE_NUMBER, TYPE_NONE } },
 105 #ifdef HAS_LCHMOD
 106         { "lchmod", ACTION_LCHMOD, { TYPE_STRING, TYPE_NUMBER, TYPE_NONE } },
 107 #endif
 108         { "chown", ACTION_CHOWN, { TYPE_STRING, TYPE_NUMBER, TYPE_NUMBER, TYPE_NONE } },
 109         { "lchown", ACTION_LCHOWN, { TYPE_STRING, TYPE_NUMBER, TYPE_NUMBER, TYPE_NONE } },
 110 #ifdef HAS_CHFLAGS
 111         { "chflags", ACTION_CHFLAGS, { TYPE_STRING, TYPE_STRING, TYPE_NONE } },
 112 #endif
 113 #ifdef HAS_LCHFLAGS
 114         { "lchflags", ACTION_LCHFLAGS, { TYPE_STRING, TYPE_STRING, TYPE_NONE } },
 115 #endif
 116         { "truncate", ACTION_TRUNCATE, { TYPE_STRING, TYPE_NUMBER, TYPE_NONE } },
 117         { "stat", ACTION_STAT, { TYPE_STRING, TYPE_STRING, TYPE_NONE } },
 118         { "lstat", ACTION_LSTAT, { TYPE_STRING, TYPE_STRING, TYPE_NONE } },
 119         { NULL, -1, { TYPE_NONE } }
 120 };
 121
 122 struct flag {
 123         long long        f_flag;
 124         char            *f_str;
 125 };
 126
 127 static struct flag open_flags[] = {
 128 #ifdef O_RDONLY
 129         { O_RDONLY, "O_RDONLY" },
 130 #endif
 131 #ifdef O_WRONLY
 132         { O_WRONLY, "O_WRONLY" },
 133 #endif
 134 #ifdef O_RDWR
 135         { O_RDWR, "O_RDWR" },
 136 #endif
 137 #ifdef O_NONBLOCK
 138         { O_NONBLOCK, "O_NONBLOCK" },
 139 #endif
 140 #ifdef O_APPEND
 141         { O_APPEND, "O_APPEND" },
 142 #endif
 143 #ifdef O_CREAT
 144         { O_CREAT, "O_CREAT" },
 145 #endif
 146 #ifdef O_TRUNC
 147         { O_TRUNC, "O_TRUNC" },
 148 #endif
 149 #ifdef O_EXCL
 150         { O_EXCL, "O_EXCL" },
 151 #endif
 152 #ifdef O_SHLOCK
 153         { O_SHLOCK, "O_SHLOCK" },
 154 #endif
 155 #ifdef O_EXLOCK
 156         { O_EXLOCK, "O_EXLOCK" },
 157 #endif
 158 #ifdef O_DIRECT
 159         { O_DIRECT, "O_DIRECT" },
 160 #endif
 161 #ifdef O_FSYNC
 162         { O_FSYNC, "O_FSYNC" },
 163 #endif
 164 #ifdef O_SYNC
 165         { O_SYNC, "O_SYNC" },
 166 #endif
 167 #ifdef O_NOFOLLOW
 168         { O_NOFOLLOW, "O_NOFOLLOW" },
 169 #endif
 170 #ifdef O_NOCTTY
 171         { O_NOCTTY, "O_NOCTTY" },
 172 #endif
 173         { 0, NULL }
 174 };
 175
 176 #ifdef HAS_CHFLAGS
 177 static struct flag chflags_flags[] = {
 178 #ifdef UF_NODUMP
 179         { UF_NODUMP, "UF_NODUMP" },
 180 #endif
 181 #ifdef UF_IMMUTABLE
 182         { UF_IMMUTABLE, "UF_IMMUTABLE" },
 183 #endif
 184 #ifdef UF_APPEND
 185         { UF_APPEND, "UF_APPEND" },
 186 #endif
 187 #ifdef UF_NOUNLINK
 188         { UF_NOUNLINK, "UF_NOUNLINK" },
 189 #endif
 190 #ifdef UF_OPAQUE
 191         { UF_OPAQUE, "UF_OPAQUE" },
 192 #endif
 193 #ifdef SF_ARCHIVED
 194         { SF_ARCHIVED, "SF_ARCHIVED" },
 195 #endif
 196 #ifdef SF_IMMUTABLE
 197         { SF_IMMUTABLE, "SF_IMMUTABLE" },
 198 #endif
 199 #ifdef SF_APPEND
 200         { SF_APPEND, "SF_APPEND" },
 201 #endif
 202 #ifdef SF_NOUNLINK
 203         { SF_NOUNLINK, "SF_NOUNLINK" },
 204 #endif
 205 #ifdef SF_SNAPSHOT
 206         { SF_SNAPSHOT, "SF_SNAPSHOT" },
 207 #endif
 208         { 0, NULL }
 209 };
 210 #endif
 211
 212 static const char *err2str(int error);
 213
 214 static void
 215 usage(void)
 216 {
 217
 218         fprintf(stderr, "usage: fstest [-u uid] [-g gid1[,gid2[...]]] syscall args ...\n");
 219         exit(1);
 220 }
 221
 222 static long long
 223 str2flags(struct flag *tflags, char *sflags)
 224 {
 225         long long flags = 0;
 226         unsigned int i;
 227         char *f;
 228
 229         for (f = strtok(sflags, ","); f != NULL; f = strtok(NULL, ",")) {
 230                 /* Support magic 'none' flag which just reset all flags. */
 231                 if (strcmp(f, "none") == 0)
 232                         return (0);
 233                 for (i = 0; tflags[i].f_str != NULL; i++) {
 234                         if (strcmp(tflags[i].f_str, f) == 0)
 235                                 break;
 236                 }
 237                 if (tflags[i].f_str == NULL) {
 238                         fprintf(stderr, "unknown flag '%s'\n", f);
 239                         exit(1);
 240                 }
 241                 flags |= tflags[i].f_flag;
 242         }
 243         return (flags);
 244 }
 245
 246 #ifdef HAS_CHFLAGS
 247 static char *
 248 flags2str(struct flag *tflags, long long flags)
 249 {
 250         static char sflags[1024];
 251         unsigned int i;
 252
 253         sflags[0] = '\0';
 254         for (i = 0; tflags[i].f_str != NULL; i++) {
 255                 if (flags & tflags[i].f_flag) {
 256                         if (sflags[0] != '\0')
 257                                 strlcat(sflags, ",", sizeof(sflags));
 258                         strlcat(sflags, tflags[i].f_str, sizeof(sflags));
 259                 }
 260         }
 261         if (sflags[0] == '\0')
 262                 strlcpy(sflags, "none", sizeof(sflags));
 263         return (sflags);
 264 }
 265 #endif
 266
 267 static struct syscall_desc *
 268 find_syscall(const char *name)
 269 {
 270         int i;
 271
 272         for (i = 0; syscalls[i].sd_name != NULL; i++) {
 273                 if (strcmp(syscalls[i].sd_name, name) == 0)
 274                         return (&syscalls[i]);
 275         }
 276         return (NULL);
 277 }
 278
 279 static void
 280 show_stat(struct stat64 *sp, const char *what)
 281 {
 282
 283         if (strcmp(what, "mode") == 0)
 284                 printf("0%o", (unsigned int)(sp->st_mode & ALLPERMS));
 285         else if (strcmp(what, "inode") == 0)
 286                 printf("%lld", (long long)sp->st_ino);
 287         else if (strcmp(what, "nlink") == 0)
 288                 printf("%lld", (long long)sp->st_nlink);
 289         else if (strcmp(what, "uid") == 0)
 290                 printf("%d", (int)sp->st_uid);
 291         else if (strcmp(what, "gid") == 0)
 292                 printf("%d", (int)sp->st_gid);
 293         else if (strcmp(what, "size") == 0)
 294                 printf("%lld", (long long)sp->st_size);
 295         else if (strcmp(what, "blocks") == 0)
 296                 printf("%lld", (long long)sp->st_blocks);
 297         else if (strcmp(what, "atime") == 0)
 298                 printf("%lld", (long long)sp->st_atime);
 299         else if (strcmp(what, "mtime") == 0)
 300                 printf("%lld", (long long)sp->st_mtime);
 301         else if (strcmp(what, "ctime") == 0)
 302                 printf("%lld", (long long)sp->st_ctime);
 303 #ifdef HAS_CHFLAGS
 304         else if (strcmp(what, "flags") == 0)
 305                 printf("%s", flags2str(chflags_flags, sp->st_flags));
 306 #endif
 307         else if (strcmp(what, "type") == 0) {
 308                 switch (sp->st_mode & S_IFMT) {
 309                 case S_IFIFO:
 310                         printf("fifo");
 311                         break;
 312                 case S_IFCHR:
 313                         printf("char");
 314                         break;
 315                 case S_IFDIR:
 316                         printf("dir");
 317                         break;
 318                 case S_IFBLK:
 319                         printf("block");
 320                         break;
 321                 case S_IFREG:
 322                         printf("regular");
 323                         break;
 324                 case S_IFLNK:
 325                         printf("symlink");
 326                         break;
 327                 case S_IFSOCK:
 328                         printf("socket");
 329                         break;
 330                 default:
 331                         printf("unknown");
 332                         break;
 333                 }
 334         } else {
 335                 printf("unknown");
 336         }
 337 }
 338
 339 static void
 340 show_stats(struct stat64 *sp, char *what)
 341 {
 342         const char *s = "";
 343         char *w;
 344
 345         for (w = strtok(what, ","); w != NULL; w = strtok(NULL, ",")) {
 346                 printf("%s", s);
 347                 show_stat(sp, w);
 348                 s = ",";
 349         }
 350         printf("\n");
 351 }
 352
 353 static unsigned int
 354 call_syscall(struct syscall_desc *scall, char *argv[])
 355 {
 356         struct stat64 sb;
 357         long long flags;
 358         unsigned int i;
 359         char *endp;
 360         int rval;
 361         union {
 362                 char *str;
 363                 long long num;
 364         } args[MAX_ARGS];
 365
 366         /*
 367          * Verify correctness of the arguments.
 368          */
 369         for (i = 0; i < sizeof(args)/sizeof(args[0]); i++) {
 370                 if (scall->sd_args[i] == TYPE_NONE) {
 371                         if (argv[i] == NULL || strcmp(argv[i], ":") == 0)
 372                                 break;
 373                         fprintf(stderr, "too many arguments [%s]\n", argv[i]);
 374                         exit(1);
 375                 } else {
 376                         if (argv[i] == NULL || strcmp(argv[i], ":") == 0) {
 377                                 if (scall->sd_args[i] & TYPE_OPTIONAL)
 378                                         break;
 379                                 fprintf(stderr, "too few arguments\n");
 380                                 exit(1);
 381                         }
 382                         if (scall->sd_args[i] & TYPE_STRING) {
 383                                 if (strcmp(argv[i], "NULL") == 0)
 384                                         args[i].str = NULL;
 385                                 else if (strcmp(argv[i], "DEADCODE") == 0)
 386                                         args[i].str = (void *)0xdeadc0de;
 387                                 else
 388                                         args[i].str = argv[i];
 389                         } else if (scall->sd_args[i] & TYPE_NUMBER) {
 390                                 args[i].num = strtoll(argv[i], &endp, 0);
 391                                 if (*endp != '\0' && !isspace((unsigned char)*endp)) {
 392                                         fprintf(stderr, "invalid argument %u, number expected [%s]\n", i, endp);
 393                                         exit(1);
 394                                 }
 395                         }
 396                 }
 397         }
 398         /*
 399          * Call the given syscall.
 400          */
 401 #define NUM(n)  (args[(n)].num)
 402 #define STR(n)  (args[(n)].str)
 403         switch (scall->sd_action) {
 404         case ACTION_OPEN:
 405                 flags = str2flags(open_flags, STR(1));
 406                 if (flags & O_CREAT) {
 407                         if (i == 2) {
 408                                 fprintf(stderr, "too few arguments\n");
 409                                 exit(1);
 410                         }
 411                         rval = open(STR(0), flags, (mode_t)NUM(2));
 412                 } else {
 413                         if (i == 3) {
 414                                 fprintf(stderr, "too many arguments\n");
 415                                 exit(1);
 416                         }
 417                         rval = open(STR(0), flags);
 418                 }
 419                 break;
 420         case ACTION_CREATE:
 421                 rval = open(STR(0), O_CREAT | O_EXCL, NUM(1));
 422                 if (rval >= 0)
 423                         close(rval);
 424                 break;
 425         case ACTION_UNLINK:
 426                 rval = unlink(STR(0));
 427                 break;
 428         case ACTION_MKDIR:
 429                 rval = mkdir(STR(0), NUM(1));
 430                 break;
 431         case ACTION_RMDIR:
 432                 rval = rmdir(STR(0));
 433                 break;
 434         case ACTION_LINK:
 435                 rval = link(STR(0), STR(1));
 436                 break;
 437         case ACTION_SYMLINK:
 438                 rval = symlink(STR(0), STR(1));
 439                 break;
 440         case ACTION_RENAME:
 441                 rval = rename(STR(0), STR(1));
 442                 break;
 443         case ACTION_MKFIFO:
 444                 rval = mkfifo(STR(0), NUM(1));
 445                 break;
 446         case ACTION_CHMOD:
 447                 rval = chmod(STR(0), NUM(1));
 448                 break;
 449 #ifdef HAS_LCHMOD
 450         case ACTION_LCHMOD:
 451                 rval = lchmod(STR(0), NUM(1));
 452                 break;
 453 #endif
 454         case ACTION_CHOWN:
 455                 rval = chown(STR(0), NUM(1), NUM(2));
 456                 break;
 457         case ACTION_LCHOWN:
 458                 rval = lchown(STR(0), NUM(1), NUM(2));
 459                 break;
 460 #ifdef HAS_CHFLAGS
 461         case ACTION_CHFLAGS:
 462                 rval = chflags(STR(0), str2flags(chflags_flags, STR(1)));
 463                 break;
 464 #endif
 465 #ifdef HAS_LCHFLAGS
 466         case ACTION_LCHFLAGS:
 467                 rval = lchflags(STR(0), str2flags(chflags_flags, STR(1)));
 468                 break;
 469 #endif
 470         case ACTION_TRUNCATE:
 471                 rval = truncate64(STR(0), NUM(1));
 472                 break;
 473         case ACTION_STAT:
 474                 rval = stat64(STR(0), &sb);
 475                 if (rval == 0) {
 476                         show_stats(&sb, STR(1));
 477                         return (i);
 478                 }
 479                 break;
 480         case ACTION_LSTAT:
 481                 rval = lstat64(STR(0), &sb);
 482                 if (rval == 0) {
 483                         show_stats(&sb, STR(1));
 484                         return (i);
 485                 }
 486                 break;
 487         default:
 488                 fprintf(stderr, "unsupported syscall\n");
 489                 exit(1);
 490         }
 491 #undef STR
 492 #undef NUM
 493         if (rval < 0) {
 494                 const char *serrno;
 495
 496                 serrno = err2str(errno);
 497                 fprintf(stderr, "%s returned %d\n", scall->sd_name, rval);
 498                 printf("%s\n", serrno);
 499                 exit(1);
 500         }
 501         printf("0\n");
 502         return (i);
 503 }
 504
 505 static void
 506 set_gids(char *gids)
 507 {
 508         gid_t *gidset;
 509         long ngroups;
 510         char *g, *endp;
 511         unsigned i;
 512
 513         ngroups = sysconf(_SC_NGROUPS_MAX);
 514         assert(ngroups > 0);
 515         gidset = malloc(sizeof(*gidset) * ngroups);
 516         assert(gidset != NULL);
 517         for (i = 0, g = strtok(gids, ","); g != NULL; g = strtok(NULL, ","), i++) {
 518                 if (i >= ngroups) {
 519                         fprintf(stderr, "too many gids\n");
 520                         exit(1);
 521                 }
 522                 gidset[i] = strtol(g, &endp, 0);
 523                 if (*endp != '\0' && !isspace((unsigned char)*endp)) {
 524                         fprintf(stderr, "invalid gid '%s' - number expected\n",
 525                             g);
 526                         exit(1);
 527                 }
 528         }
 529         if (setgroups(i, gidset) < 0) {
 530                 fprintf(stderr, "cannot change groups: %s\n", strerror(errno));
 531                 exit(1);
 532         }
 533         if (setegid(gidset[0]) < 0) {
 534                 fprintf(stderr, "cannot change effective gid: %s\n", strerror(errno));
 535                 exit(1);
 536         }
 537         free(gidset);
 538 }
 539
 540 int
 541 main(int argc, char *argv[])
 542 {
 543         struct syscall_desc *scall;
 544         unsigned int n;
 545         char *gids, *endp;
 546         int uid, umsk, ch;
 547
 548         uid = -1;
 549         gids = NULL;
 550         umsk = 0;
 551
 552         while ((ch = getopt(argc, argv, "g:u:U:")) != -1) {
 553                 switch(ch) {
 554                 case 'g':
 555                         gids = optarg;
 556                         break;
 557                 case 'u':
 558                         uid = (int)strtol(optarg, &endp, 0);
 559                         if (*endp != '\0' && !isspace((unsigned char)*endp)) {
 560                                 fprintf(stderr, "invalid uid '%s' - number "
 561                                     "expected\n", optarg);
 562                                 exit(1);
 563                         }
 564                         break;
 565                 case 'U':
 566                         umsk = (int)strtol(optarg, &endp, 0);
 567                         if (*endp != '\0' && !isspace((unsigned char)*endp)) {
 568                                 fprintf(stderr, "invalid umask '%s' - number "
 569                                     "expected\n", optarg);
 570                                 exit(1);
 571                         }
 572                         break;
 573                 default:
 574                         usage();
 575                 }
 576         }
 577         argc -= optind;
 578         argv += optind;
 579
 580         if (argc < 1) {
 581                 fprintf(stderr, "too few arguments\n");
 582                 usage();
 583         }
 584
 585         if (gids != NULL) {
 586                 fprintf(stderr, "changing groups to %s\n", gids);
 587                 set_gids(gids);
 588         }
 589         if (uid != -1) {
 590                 fprintf(stderr, "changing uid to %d\n", uid);
 591                 if (setuid(uid) < 0) {
 592                         fprintf(stderr, "cannot change uid: %s\n",
 593                             strerror(errno));
 594                         exit(1);
 595                 }
 596         }
 597
 598         /* Change umask to requested value or to 0, if not requested. */
 599         umask(umsk);
 600
 601         for (;;) {
 602                 scall = find_syscall(argv[0]);
 603                 if (scall == NULL) {
 604                         fprintf(stderr, "syscall '%s' not supported\n", argv[0]);
 605                         exit(1);
 606                 }
 607                 argc++;
 608                 argv++;
 609                 n = call_syscall(scall, argv);
 610                 argc += n;
 611                 argv += n;
 612                 if (argv[0] == NULL)
 613                         break;
 614                 argc++;
 615                 argv++;
 616         }
 617
 618         exit(0);
 619 }
 620
 621 static const char *
 622 err2str(int error)
 623 {
 624         static char errnum[8];
 625
 626         switch (error) {
 627 #ifdef EPERM
 628         case EPERM:
 629                 return ("EPERM");
 630 #endif
 631 #ifdef ENOENT
 632         case ENOENT:
 633                 return ("ENOENT");
 634 #endif
 635 #ifdef ESRCH
 636         case ESRCH:
 637                 return ("ESRCH");
 638 #endif
 639 #ifdef EINTR
 640         case EINTR:
 641                 return ("EINTR");
 642 #endif
 643 #ifdef EIO
 644         case EIO:
 645                 return ("EIO");
 646 #endif
 647 #ifdef ENXIO
 648         case ENXIO:
 649                 return ("ENXIO");
 650 #endif
 651 #ifdef E2BIG
 652         case E2BIG:
 653                 return ("E2BIG");
 654 #endif
 655 #ifdef ENOEXEC
 656         case ENOEXEC:
 657                 return ("ENOEXEC");
 658 #endif
 659 #ifdef EBADF
 660         case EBADF:
 661                 return ("EBADF");
 662 #endif
 663 #ifdef ECHILD
 664         case ECHILD:
 665                 return ("ECHILD");
 666 #endif
 667 #ifdef EDEADLK
 668         case EDEADLK:
 669                 return ("EDEADLK");
 670 #endif
 671 #ifdef ENOMEM
 672         case ENOMEM:
 673                 return ("ENOMEM");
 674 #endif
 675 #ifdef EACCES
 676         case EACCES:
 677                 return ("EACCES");
 678 #endif
 679 #ifdef EFAULT
 680         case EFAULT:
 681                 return ("EFAULT");
 682 #endif
 683 #ifdef ENOTBLK
 684         case ENOTBLK:
 685                 return ("ENOTBLK");
 686 #endif
 687 #ifdef EBUSY
 688         case EBUSY:
 689                 return ("EBUSY");
 690 #endif
 691 #ifdef EEXIST
 692         case EEXIST:
 693                 return ("EEXIST");
 694 #endif
 695 #ifdef EXDEV
 696         case EXDEV:
 697                 return ("EXDEV");
 698 #endif
 699 #ifdef ENODEV
 700         case ENODEV:
 701                 return ("ENODEV");
 702 #endif
 703 #ifdef ENOTDIR
 704         case ENOTDIR:
 705                 return ("ENOTDIR");
 706 #endif
 707 #ifdef EISDIR
 708         case EISDIR:
 709                 return ("EISDIR");
 710 #endif
 711 #ifdef EINVAL
 712         case EINVAL:
 713                 return ("EINVAL");
 714 #endif
 715 #ifdef ENFILE
 716         case ENFILE:
 717                 return ("ENFILE");
 718 #endif
 719 #ifdef EMFILE
 720         case EMFILE:
 721                 return ("EMFILE");
 722 #endif
 723 #ifdef ENOTTY
 724         case ENOTTY:
 725                 return ("ENOTTY");
 726 #endif
 727 #ifdef ETXTBSY
 728         case ETXTBSY:
 729                 return ("ETXTBSY");
 730 #endif
 731 #ifdef EFBIG
 732         case EFBIG:
 733                 return ("EFBIG");
 734 #endif
 735 #ifdef ENOSPC
 736         case ENOSPC:
 737                 return ("ENOSPC");
 738 #endif
 739 #ifdef ESPIPE
 740         case ESPIPE:
 741                 return ("ESPIPE");
 742 #endif
 743 #ifdef EROFS
 744         case EROFS:
 745                 return ("EROFS");
 746 #endif
 747 #ifdef EMLINK
 748         case EMLINK:
 749                 return ("EMLINK");
 750 #endif
 751 #ifdef EPIPE
 752         case EPIPE:
 753                 return ("EPIPE");
 754 #endif
 755 #ifdef EDOM
 756         case EDOM:
 757                 return ("EDOM");
 758 #endif
 759 #ifdef ERANGE
 760         case ERANGE:
 761                 return ("ERANGE");
 762 #endif
 763 #ifdef EAGAIN
 764         case EAGAIN:
 765                 return ("EAGAIN");
 766 #endif
 767 #ifdef EINPROGRESS
 768         case EINPROGRESS:
 769                 return ("EINPROGRESS");
 770 #endif
 771 #ifdef EALREADY
 772         case EALREADY:
 773                 return ("EALREADY");
 774 #endif
 775 #ifdef ENOTSOCK
 776         case ENOTSOCK:
 777                 return ("ENOTSOCK");
 778 #endif
 779 #ifdef EDESTADDRREQ
 780         case EDESTADDRREQ:
 781                 return ("EDESTADDRREQ");
 782 #endif
 783 #ifdef EMSGSIZE
 784         case EMSGSIZE:
 785                 return ("EMSGSIZE");
 786 #endif
 787 #ifdef EPROTOTYPE
 788         case EPROTOTYPE:
 789                 return ("EPROTOTYPE");
 790 #endif
 791 #ifdef ENOPROTOOPT
 792         case ENOPROTOOPT:
 793                 return ("ENOPROTOOPT");
 794 #endif
 795 #ifdef EPROTONOSUPPORT
 796         case EPROTONOSUPPORT:
 797                 return ("EPROTONOSUPPORT");
 798 #endif
 799 #ifdef ESOCKTNOSUPPORT
 800         case ESOCKTNOSUPPORT:
 801                 return ("ESOCKTNOSUPPORT");
 802 #endif
 803 #ifdef EOPNOTSUPP
 804         case EOPNOTSUPP:
 805                 return ("EOPNOTSUPP");
 806 #endif
 807 #ifdef EPFNOSUPPORT
 808         case EPFNOSUPPORT:
 809                 return ("EPFNOSUPPORT");
 810 #endif
 811 #ifdef EAFNOSUPPORT
 812         case EAFNOSUPPORT:
 813                 return ("EAFNOSUPPORT");
 814 #endif
 815 #ifdef EADDRINUSE
 816         case EADDRINUSE:
 817                 return ("EADDRINUSE");
 818 #endif
 819 #ifdef EADDRNOTAVAIL
 820         case EADDRNOTAVAIL:
 821                 return ("EADDRNOTAVAIL");
 822 #endif
 823 #ifdef ENETDOWN
 824         case ENETDOWN:
 825                 return ("ENETDOWN");
 826 #endif
 827 #ifdef ENETUNREACH
 828         case ENETUNREACH:
 829                 return ("ENETUNREACH");
 830 #endif
 831 #ifdef ENETRESET
 832         case ENETRESET:
 833                 return ("ENETRESET");
 834 #endif
 835 #ifdef ECONNABORTED
 836         case ECONNABORTED:
 837                 return ("ECONNABORTED");
 838 #endif
 839 #ifdef ECONNRESET
 840         case ECONNRESET:
 841                 return ("ECONNRESET");
 842 #endif
 843 #ifdef ENOBUFS
 844         case ENOBUFS:
 845                 return ("ENOBUFS");
 846 #endif
 847 #ifdef EISCONN
 848         case EISCONN:
 849                 return ("EISCONN");
 850 #endif
 851 #ifdef ENOTCONN
 852         case ENOTCONN:
 853                 return ("ENOTCONN");
 854 #endif
 855 #ifdef ESHUTDOWN
 856         case ESHUTDOWN:
 857                 return ("ESHUTDOWN");
 858 #endif
 859 #ifdef ETOOMANYREFS
 860         case ETOOMANYREFS:
 861                 return ("ETOOMANYREFS");
 862 #endif
 863 #ifdef ETIMEDOUT
 864         case ETIMEDOUT:
 865                 return ("ETIMEDOUT");
 866 #endif
 867 #ifdef ECONNREFUSED
 868         case ECONNREFUSED:
 869                 return ("ECONNREFUSED");
 870 #endif
 871 #ifdef ELOOP
 872         case ELOOP:
 873                 return ("ELOOP");
 874 #endif
 875 #ifdef ENAMETOOLONG
 876         case ENAMETOOLONG:
 877                 return ("ENAMETOOLONG");
 878 #endif
 879 #ifdef EHOSTDOWN
 880         case EHOSTDOWN:
 881                 return ("EHOSTDOWN");
 882 #endif
 883 #ifdef EHOSTUNREACH
 884         case EHOSTUNREACH:
 885                 return ("EHOSTUNREACH");
 886 #endif
 887 #ifdef ENOTEMPTY
 888         case ENOTEMPTY:
 889                 return ("ENOTEMPTY");
 890 #endif
 891 #ifdef EPROCLIM
 892         case EPROCLIM:
 893                 return ("EPROCLIM");
 894 #endif
 895 #ifdef EUSERS
 896         case EUSERS:
 897                 return ("EUSERS");
 898 #endif
 899 #ifdef EDQUOT
 900         case EDQUOT:
 901                 return ("EDQUOT");
 902 #endif
 903 #ifdef ESTALE
 904         case ESTALE:
 905                 return ("ESTALE");
 906 #endif
 907 #ifdef EREMOTE
 908         case EREMOTE:
 909                 return ("EREMOTE");
 910 #endif
 911 #ifdef EBADRPC
 912         case EBADRPC:
 913                 return ("EBADRPC");
 914 #endif
 915 #ifdef ERPCMISMATCH
 916         case ERPCMISMATCH:
 917                 return ("ERPCMISMATCH");
 918 #endif
 919 #ifdef EPROGUNAVAIL
 920         case EPROGUNAVAIL:
 921                 return ("EPROGUNAVAIL");
 922 #endif
 923 #ifdef EPROGMISMATCH
 924         case EPROGMISMATCH:
 925                 return ("EPROGMISMATCH");
 926 #endif
 927 #ifdef EPROCUNAVAIL
 928         case EPROCUNAVAIL:
 929                 return ("EPROCUNAVAIL");
 930 #endif
 931 #ifdef ENOLCK
 932         case ENOLCK:
 933                 return ("ENOLCK");
 934 #endif
 935 #ifdef ENOSYS
 936         case ENOSYS:
 937                 return ("ENOSYS");
 938 #endif
 939 #ifdef EFTYPE
 940         case EFTYPE:
 941                 return ("EFTYPE");
 942 #endif
 943 #ifdef EAUTH
 944         case EAUTH:
 945                 return ("EAUTH");
 946 #endif
 947 #ifdef ENEEDAUTH
 948         case ENEEDAUTH:
 949                 return ("ENEEDAUTH");
 950 #endif
 951 #ifdef EIDRM
 952         case EIDRM:
 953                 return ("EIDRM");
 954 #endif
 955 #ifdef ENOMSG
 956         case ENOMSG:
 957                 return ("ENOMSG");
 958 #endif
 959 #ifdef EOVERFLOW
 960         case EOVERFLOW:
 961                 return ("EOVERFLOW");
 962 #endif
 963 #ifdef ECANCELED
 964         case ECANCELED:
 965                 return ("ECANCELED");
 966 #endif
 967 #ifdef EILSEQ
 968         case EILSEQ:
 969                 return ("EILSEQ");
 970 #endif
 971 #ifdef ENOATTR
 972         case ENOATTR:
 973                 return ("ENOATTR");
 974 #endif
 975 #ifdef EDOOFUS
 976         case EDOOFUS:
 977                 return ("EDOOFUS");
 978 #endif
 979 #ifdef EBADMSG
 980         case EBADMSG:
 981                 return ("EBADMSG");
 982 #endif
 983 #ifdef EMULTIHOP
 984         case EMULTIHOP:
 985                 return ("EMULTIHOP");
 986 #endif
 987 #ifdef ENOLINK
 988         case ENOLINK:
 989                 return ("ENOLINK");
 990 #endif
 991 #ifdef EPROTO
 992         case EPROTO:
 993                 return ("EPROTO");
 994 #endif
 995         default:
 996                 snprintf(errnum, sizeof(errnum), "%d", error);
 997                 return (errnum);
 998         }
 999 }