lookup.subproj/file_module.c

   1 /*
   2  * Copyright (c) 2008-2015 Apple Inc.  All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23
  24 #include <si_module.h>
  25 #include <paths.h>
  26 #include <stdio.h>
  27 #include <unistd.h>
  28 #include <string.h>
  29 #include <time.h>
  30 #include <dirent.h>
  31 #include <errno.h>
  32 #include <notify.h>
  33 #include <pthread.h>
  34 #include <arpa/inet.h>
  35 #include <sys/param.h>
  36 #include <sys/mount.h>
  37 #include <sys/stat.h>
  38 #include <ils.h>
  39 #include <dispatch/dispatch.h>
  40 #include <TargetConditionals.h>
  41 #if (TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR)
  42 #include <sys/sysctl.h>
  43 #include <apfs/apfs_sysctl.h>
  44 #endif
  45
  46 /* notify SPI */
  47 uint32_t notify_peek(int token, uint32_t *val);
  48
  49 extern uint32_t gL1CacheEnabled;
  50
  51 /* These really should be in netdb.h & etc. */
  52 #define _PATH_RPCS "/etc/rpc"
  53 #define _PATH_ALIASES "/etc/aliases"
  54 #define _PATH_ETHERS "/etc/ethers"
  55 #define _PATH_NETGROUP "/etc/netgroup"
  56
  57 static dispatch_once_t rootfs_once;
  58 static si_item_t *rootfs = NULL;
  59
  60 #define CHUNK 256
  61 #define FNG_MEM 0x00000010
  62 #define FNG_GRP 0x00000020
  63
  64 #define forever for(;;)
  65
  66 #define VALIDATION_PASSWD 0
  67 #define VALIDATION_MASTER_PASSWD 1
  68 #define VALIDATION_GROUP 2
  69 #define VALIDATION_NETGROUP 3
  70 #define VALIDATION_ALIASES 4
  71 #define VALIDATION_HOSTS 5
  72 #define VALIDATION_NETWORKS 6
  73 #define VALIDATION_SERVICES 7
  74 #define VALIDATION_PROTOCOLS 8
  75 #define VALIDATION_RPC 9
  76 #define VALIDATION_FSTAB 10
  77 #define VALIDATION_ETHERS 11
  78 #define VALIDATION_COUNT 12
  79
  80 #define VALIDATION_MASK_PASSWD                  0x00000001
  81 #define VALIDATION_MASK_MASTER_PASSWD   0x00000002
  82 #define VALIDATION_MASK_MASK_GROUP              0x00000004
  83 #define VALIDATION_MASK_NETGROUP                                0x00000008
  84 #define VALIDATION_MASK_ALIASES                 0x00000010
  85 #define VALIDATION_MASK_HOSTS                   0x00000020
  86 #define VALIDATION_MASK_NETWORKS                0x00000040
  87 #define VALIDATION_MASK_SERVICES                0x00000080
  88 #define VALIDATION_MASK_PROTOCOLS               0x00000100
  89 #define VALIDATION_MASK_RPC                             0x00000200
  90 #define VALIDATION_MASK_FSTAB                   0x00000400
  91 #define VALIDATION_MASK_ETHERS                  0x00000800
  92
  93 typedef struct file_netgroup_member_s
  94 {
  95         uint32_t flags;
  96         char *host;
  97         char *user;
  98         char *domain;
  99         struct file_netgroup_member_s *next;
 100 } file_netgroup_member_t;
 101
 102 typedef struct file_netgroup_s
 103 {
 104         char *name;
 105         uint32_t flags;
 106         file_netgroup_member_t *members;
 107         struct file_netgroup_s *next;
 108 } file_netgroup_t;
 109
 110 typedef struct
 111 {
 112         uint32_t validation_notify_mask;
 113         int notify_token[VALIDATION_COUNT];
 114         file_netgroup_t *file_netgroup_cache;
 115         uint64_t netgroup_validation_a;
 116         uint64_t netgroup_validation_b;
 117 } file_si_private_t;
 118
 119 static pthread_mutex_t file_mutex = PTHREAD_MUTEX_INITIALIZER;
 120
 121 static char *
 122 _fsi_copy_string(char *s)
 123 {
 124         int len;
 125         char *t;
 126
 127         if (s == NULL) return NULL;
 128
 129         len = strlen(s) + 1;
 130         t = malloc(len);
 131         if (t == NULL) return NULL;
 132
 133         bcopy(s, t, len);
 134         return t;
 135 }
 136
 137 static char **
 138 _fsi_append_string(char *s, char **l)
 139 {
 140         int i, len;
 141
 142         if (s == NULL) return l;
 143         if (l != NULL) {
 144                 for (i = 0; l[i] != NULL; i++);
 145                 len = i;
 146         } else {
 147                 len = 0;
 148         }
 149
 150         l = (char **) reallocf(l, (len + 2) * sizeof(char *));
 151         if (l == NULL) return NULL;
 152
 153         l[len] = s;
 154         l[len + 1] = NULL;
 155         return l;
 156 }
 157
 158 char **
 159 _fsi_tokenize(char *data, const char *sep, int trailing_empty, int *ntokens)
 160 {
 161         char **tokens;
 162         int p, i, start, end, more, len, end_on_sep;
 163         int scanning;
 164
 165         tokens = NULL;
 166         end_on_sep = 0;
 167
 168         if (data == NULL) return NULL;
 169
 170         if (ntokens != NULL) *ntokens = 0;
 171         if (sep == NULL)
 172         {
 173                 tokens = _fsi_append_string(data, tokens);
 174                 if (ntokens != NULL) *ntokens = *ntokens + 1;
 175                 return tokens;
 176         }
 177
 178         len = strlen(sep);
 179         p = 0;
 180
 181         while (data[p] != '\0')
 182         {
 183                 end_on_sep = 1;
 184                 /* skip leading white space */
 185                 while ((data[p] == ' ') || (data[p] == '\t') || (data[p] == '\n')) p++;
 186
 187                 /* check for end of line */
 188                 if (data[p] == '\0') break;
 189
 190                 /* scan for separator */
 191                 start = p;
 192                 end = p;
 193                 scanning = 1;
 194                 end_on_sep = 0;
 195
 196                 while (scanning == 1)
 197                 {
 198                         if (data[p] == '\0') break;
 199
 200                         for (i = 0; i < len; i++)
 201                         {
 202                                 if (data[p] == sep[i])
 203                                 {
 204                                         scanning = 0;
 205                                         end_on_sep = 1;
 206                                         break;
 207                                 }
 208                         }
 209
 210                         /* end is last non-whitespace character */
 211                         if ((scanning == 1) && (data[p] != ' ') && (data[p] != '\t') && (data[p] != '\n')) end = p;
 212
 213                         p += scanning;
 214                 }
 215
 216                 /* see if there's data left after p */
 217                 more = 0;
 218                 if (data[p] != '\0') more = 1;
 219
 220                 /* set the character following the token to nul */
 221                 if (start == p) data[p] = '\0';
 222                 else data[end + 1] = '\0';
 223
 224                 tokens = _fsi_append_string(data + start, tokens);
 225                 if (ntokens != NULL) *ntokens = *ntokens + 1;
 226                 p += more;
 227         }
 228
 229         if ((end_on_sep == 1) && (trailing_empty != 0))
 230         {
 231                 /* if the scan ended on an empty token, add a null string */
 232                 tokens = _fsi_append_string(data + p, tokens);
 233                 if (ntokens != NULL) *ntokens = *ntokens + 1;
 234         }
 235
 236         return tokens;
 237 }
 238
 239 char *
 240 _fsi_get_line(FILE *fp)
 241 {
 242         char s[4096];
 243         char *x, *out;
 244
 245         s[0] = '\0';
 246
 247         x = fgets(s, sizeof(s), fp);
 248         if ((x == NULL) || (s[0] == '\0')) return NULL;
 249
 250         if (s[0] != '#') s[strlen(s) - 1] = '\0';
 251
 252         out = _fsi_copy_string(s);
 253         return out;
 254 }
 255
 256 static const char *
 257 _fsi_validation_path(int vtype)
 258 {
 259         if (vtype == VALIDATION_PASSWD) return _PATH_PASSWD;
 260         else if (vtype == VALIDATION_MASTER_PASSWD) return _PATH_MASTERPASSWD;
 261         else if (vtype == VALIDATION_GROUP) return _PATH_GROUP;
 262         else if (vtype == VALIDATION_NETGROUP) return _PATH_NETGROUP;
 263         else if (vtype == VALIDATION_ALIASES) return _PATH_ALIASES;
 264         else if (vtype == VALIDATION_HOSTS) return _PATH_HOSTS;
 265         else if (vtype == VALIDATION_NETWORKS) return _PATH_NETWORKS;
 266         else if (vtype == VALIDATION_SERVICES) return _PATH_SERVICES;
 267         else if (vtype == VALIDATION_PROTOCOLS) return _PATH_PROTOCOLS;
 268         else if (vtype == VALIDATION_RPC) return _PATH_RPCS;
 269         else if (vtype == VALIDATION_FSTAB) return _PATH_FSTAB;
 270         else if (vtype == VALIDATION_ETHERS) return _PATH_ETHERS;
 271
 272         return NULL;
 273 }
 274
 275 static void
 276 _fsi_get_validation(si_mod_t *si, int vtype, const char *path, FILE *f, uint64_t *a, uint64_t *b)
 277 {
 278         struct stat sb;
 279         file_si_private_t *pp;
 280         uint32_t peek, bit;
 281         int status;
 282
 283         if (a != NULL) *a = 0;
 284         if (b != NULL) *b = 0;
 285
 286         if (si == NULL) return;
 287         if (path == NULL) return;
 288         if (gL1CacheEnabled == 0) return;
 289
 290         pp = (file_si_private_t *)si->private;
 291         if (pp == NULL) return;
 292
 293         if (vtype >= VALIDATION_COUNT) return;
 294
 295         bit = 1 << vtype;
 296         if (bit & pp->validation_notify_mask)
 297         {
 298                 /* use notify validation for this type */
 299                 if (pp->notify_token[vtype] < 0)
 300                 {
 301                         char *str = NULL;
 302                         asprintf(&str, "com.apple.system.info:%s", path);
 303                         if (str == NULL) return;
 304
 305                         status = notify_register_check(str, &(pp->notify_token[vtype]));
 306                         free(str);
 307                 }
 308
 309                 if (a != NULL)
 310                 {
 311                         status = notify_peek(pp->notify_token[vtype], &peek);
 312                         if (status == NOTIFY_STATUS_OK) *a = ntohl(peek);
 313                 }
 314
 315                 if (b != NULL) *b = vtype;
 316         }
 317         else
 318         {
 319                 /* use stat() and last mod time for this type */
 320                 memset(&sb, 0, sizeof(struct stat));
 321                 if (f != NULL)
 322                 {
 323                         if (fstat(fileno(f), &sb) == 0)
 324                         {
 325                                 if (a != NULL) *a = sb.st_mtimespec.tv_sec;
 326                                 if (b != NULL) *b = sb.st_mtimespec.tv_nsec;
 327                         }
 328                 }
 329                 else
 330                 {
 331                         path = _fsi_validation_path(vtype);
 332                         if (path != NULL)
 333                         {
 334                                 memset(&sb, 0, sizeof(struct stat));
 335                                 if (stat(path, &sb) == 0)
 336                                 {
 337                                         if (a != NULL) *a = sb.st_mtimespec.tv_sec;
 338                                         if (b != NULL) *b = sb.st_mtimespec.tv_nsec;
 339                                 }
 340                         }
 341                 }
 342         }
 343 }
 344
 345 static int
 346 _fsi_validate(si_mod_t *si, int cat, uint64_t va, uint64_t vb)
 347 {
 348 #if !(TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR)
 349         struct stat sb;
 350         const char *path;
 351         uint32_t item_val, curr_val, vtype;
 352         file_si_private_t *pp;
 353         int status;
 354 #endif
 355
 356         if (si == NULL) return 0;
 357
 358 #if !(TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR)
 359         /* /etc is on a read-only filesystem, so no validation is required */
 360
 361         pp = (file_si_private_t *)si->private;
 362         if (pp == NULL) return 0;
 363
 364         vtype = UINT32_MAX;
 365         switch (cat)
 366         {
 367                 case CATEGORY_USER:
 368                 {
 369                         if (geteuid() == 0) vtype = VALIDATION_MASTER_PASSWD;
 370                         else vtype = VALIDATION_PASSWD;
 371                         break;
 372                 }
 373                 case CATEGORY_GROUP:
 374                 {
 375                         vtype = VALIDATION_GROUP;
 376                         break;
 377                 }
 378                 case CATEGORY_GROUPLIST:
 379                 {
 380                         vtype = VALIDATION_GROUP;
 381                         break;
 382                 }
 383                 case CATEGORY_NETGROUP:
 384                 {
 385                         vtype = VALIDATION_NETGROUP;
 386                         break;
 387                 }
 388                 case CATEGORY_ALIAS:
 389                 {
 390                         vtype = VALIDATION_ALIASES;
 391                         break;
 392                 }
 393                 case CATEGORY_HOST_IPV4:
 394                 {
 395                         vtype = VALIDATION_HOSTS;
 396                         break;
 397                 }
 398                 case CATEGORY_HOST_IPV6:
 399                 {
 400                         vtype = VALIDATION_HOSTS;
 401                         break;
 402                 }
 403                 case CATEGORY_NETWORK:
 404                 {
 405                         vtype = VALIDATION_NETWORKS;
 406                         break;
 407                 }
 408                 case CATEGORY_SERVICE:
 409                 {
 410                         vtype = VALIDATION_SERVICES;
 411                         break;
 412                 }
 413                 case CATEGORY_PROTOCOL:
 414                 {
 415                         vtype = VALIDATION_PROTOCOLS;
 416                         break;
 417                 }
 418                 case CATEGORY_RPC:
 419                 {
 420                         vtype = VALIDATION_RPC;
 421                         break;
 422                 }
 423                 case CATEGORY_FS:
 424                 {
 425                         vtype = VALIDATION_FSTAB;
 426                         break;
 427                 }
 428                 case CATEGORY_MAC:
 429                 {
 430                         vtype = VALIDATION_ETHERS;
 431                         break;
 432                 }
 433                 default: return 0;
 434         }
 435
 436         if (pp->notify_token[vtype] < 0)
 437         {
 438                 path = _fsi_validation_path(vtype);
 439                 if (path == NULL) return 0;
 440
 441                 memset(&sb, 0, sizeof(struct stat));
 442                 if (stat(path, &sb) != 0) return 0;
 443                 if (va != sb.st_mtimespec.tv_sec) return 0;
 444                 if (vb != sb.st_mtimespec.tv_nsec) return 0;
 445         }
 446         else
 447         {
 448                 item_val = va;
 449                 curr_val = -1;
 450                 status = notify_peek(pp->notify_token[vtype], &curr_val);
 451                 if (status != NOTIFY_STATUS_OK) return 0;
 452
 453                 curr_val = ntohl(curr_val);
 454                 if (item_val != curr_val) return 0;
 455         }
 456 #endif
 457
 458         return 1;
 459 }
 460
 461 /* netgroup support */
 462 static char *
 463 _fsi_append_char_to_line(char c, char *buf, size_t *x)
 464 {
 465         if (x == NULL) return NULL;
 466
 467         if (buf == NULL) *x = 0;
 468
 469         if ((*x % CHUNK) == 0)
 470         {
 471                 buf = reallocf(buf, *x + CHUNK);
 472                 if (buf == NULL) return NULL;
 473
 474                 memset(buf + *x, 0, CHUNK);
 475         }
 476
 477         buf[*x] = c;
 478         *x = *x + 1;
 479
 480         return buf;
 481 }
 482
 483 static char *
 484 _fsi_read_netgroup_line(FILE *f)
 485 {
 486         char *out = NULL;
 487         size_t x = 0;
 488         int white = 0;
 489         int paren = 0;
 490
 491         if (f == NULL) return NULL;
 492         forever
 493         {
 494                 int c = getc(f);
 495
 496                 if (c == EOF)
 497                 {
 498                         if (out == NULL) return NULL;
 499                         return _fsi_append_char_to_line('\0', out, &x);
 500                 }
 501
 502                 if (c == '\n') return _fsi_append_char_to_line('\0', out, &x);
 503                 if (c == '(') paren = 1;
 504                 else if (c == ')') paren = 0;
 505
 506                 if ((c == ' ') || (c == '\t'))
 507                 {
 508                         if ((white == 0) && (paren == 0)) out = _fsi_append_char_to_line(' ', out, &x);
 509                         white = 1;
 510                 }
 511                 else if (c == '\\')
 512                 {
 513                         forever
 514                         {
 515                                 c = getc(f);
 516                                 if (c == EOF) return _fsi_append_char_to_line('\0', out, &x);
 517                                 if (c == '\n') break;
 518                         }
 519                 }
 520                 else
 521                 {
 522                         out = _fsi_append_char_to_line(c, out, &x);
 523                         white = 0;
 524                 }
 525         }
 526 }
 527
 528 static file_netgroup_t *
 529 _fsi_find_netgroup(file_netgroup_t **list, const char *name, int create)
 530 {
 531         file_netgroup_t *n;
 532
 533         if (list == NULL) return NULL;
 534
 535         for (n = *list; n != NULL; n = n->next)
 536         {
 537                 if (!strcmp(name, n->name)) return n;
 538         }
 539
 540         if (create == 0) return NULL;
 541
 542         n = (file_netgroup_t *)calloc(1, sizeof(file_netgroup_t));
 543         if (n == NULL) return NULL;
 544
 545         n->name = strdup(name);
 546
 547         n->next = *list;
 548         *list = n;
 549         return n;
 550 }
 551
 552 void
 553 _fsi_free_file_netgroup(file_netgroup_t *n)
 554 {
 555         file_netgroup_member_t *m;
 556
 557         if (n == NULL) return;
 558         free(n->name);
 559
 560         m = n->members;
 561         while (m != NULL)
 562         {
 563                 file_netgroup_member_t *x = m;
 564                 m = m->next;
 565                 free(x->host);
 566                 free(x->user);
 567                 free(x->domain);
 568                 free(x);
 569         }
 570
 571         free(n);
 572 }
 573
 574 static void
 575 _fsi_add_netgroup_group(file_netgroup_t *n, char *grp)
 576 {
 577         file_netgroup_member_t *g;
 578
 579         if (n == NULL) return;
 580
 581         g = (file_netgroup_member_t *)calloc(1, sizeof(file_netgroup_member_t));
 582         if (g == NULL) return;
 583
 584         g->flags = FNG_GRP;
 585         g->host = strdup(grp);
 586
 587         g->next = n->members;
 588         n->members = g;
 589
 590         return;
 591 }
 592
 593 static void
 594 _fsi_add_netgroup_member(file_netgroup_t *n, char *mem)
 595 {
 596         char **tokens;
 597         file_netgroup_member_t *m;
 598         int ntokens;
 599
 600         if (n == NULL) return;
 601
 602         m = (file_netgroup_member_t *)calloc(1, sizeof(file_netgroup_member_t));
 603         if (m == NULL) return;
 604
 605         tokens = _fsi_tokenize(mem + 1, ",)", 0, &ntokens);
 606
 607         if (tokens == NULL)
 608         {
 609                 free(m);
 610                 return;
 611         }
 612
 613         if ((ntokens > 0) && (tokens[0][0] != '\0')) m->host = strdup(tokens[0]);
 614         if ((ntokens > 1) && (tokens[1][0] != '\0')) m->user = strdup(tokens[1]);
 615         if ((ntokens > 2) && (tokens[2][0] != '\0')) m->domain = strdup(tokens[2]);
 616
 617         free(tokens);
 618
 619         m->flags = FNG_MEM;
 620         m->next = n->members;
 621         n->members = m;
 622 }
 623
 624 static file_netgroup_t *
 625 _fsi_process_netgroup_line(file_netgroup_t **pass1, char *line)
 626 {
 627         file_netgroup_t *n;
 628         char **tokens;
 629         int i, ntokens = 0;
 630
 631         tokens = _fsi_tokenize(line, " ", 0, &ntokens);
 632         if (tokens == NULL) return NULL;
 633         if (tokens[0] == NULL)
 634         {
 635                 free(tokens);
 636                 return NULL;
 637         }
 638
 639         n = _fsi_find_netgroup(pass1, tokens[0], 1);
 640
 641         for (i = 1; tokens[i] != NULL; i++)
 642         {
 643                 if (tokens[i][0] == '(') _fsi_add_netgroup_member(n, tokens[i]);
 644                 else if (tokens[i][0] != '\0') _fsi_add_netgroup_group(n, tokens[i]);
 645         }
 646
 647         free(tokens);
 648         return n;
 649 }
 650
 651 static void
 652 _fsi_flatten_netgroup(file_netgroup_t *pass1, file_netgroup_t **top, file_netgroup_t *n, file_netgroup_member_t *m)
 653 {
 654         if (n == NULL) return;
 655
 656         if (n->flags == 1) return;
 657         n->flags = 1;
 658
 659         if (*top == NULL)
 660         {
 661                 *top = (file_netgroup_t *)calloc(1, sizeof(file_netgroup_t));
 662                 if (*top == NULL) return;
 663                 (*top)->name = strdup(n->name);
 664                 if ((*top)->name == NULL)
 665                 {
 666                         free(*top);
 667                         *top = NULL;
 668                         return;
 669                 }
 670         }
 671
 672         while (m!= NULL)
 673         {
 674                 if (m->flags & FNG_MEM)
 675                 {
 676                         file_netgroup_member_t *x = (file_netgroup_member_t *)calloc(1, sizeof(file_netgroup_member_t));
 677                         if (x == NULL) return;
 678
 679                         x->flags = FNG_MEM;
 680                         if (m->host != NULL) x->host = strdup(m->host);
 681                         if (m->user != NULL) x->user = strdup(m->user);
 682                         if (m->domain != NULL) x->domain = strdup(m->domain);
 683
 684                         x->next = (*top)->members;
 685                         (*top)->members = x;
 686                 }
 687                 else
 688                 {
 689                         file_netgroup_t *g = _fsi_find_netgroup(&pass1, m->host, 0);
 690                         if (g == NULL) continue;
 691
 692                         _fsi_flatten_netgroup(pass1, top, g, g->members);
 693                 }
 694
 695                 m = m->next;
 696         }
 697 }
 698
 699 static void
 700 _fsi_check_netgroup_cache(si_mod_t *si)
 701 {
 702         file_netgroup_t *p1, *n, *x, *a;
 703         char *line;
 704         FILE *f;
 705         file_si_private_t *pp;
 706
 707         if (si == NULL) return;
 708
 709         pp = (file_si_private_t *)si->private;
 710         if (pp == NULL) return;
 711
 712         pthread_mutex_lock(&file_mutex);
 713
 714         if (_fsi_validate(si, CATEGORY_NETGROUP, pp->netgroup_validation_a, pp->netgroup_validation_b))
 715         {
 716                 pthread_mutex_unlock(&file_mutex);
 717                 return;
 718         }
 719
 720         n = pp->file_netgroup_cache;
 721         while (n != NULL)
 722         {
 723                 x = n;
 724                 n = n->next;
 725                 _fsi_free_file_netgroup(x);
 726         }
 727
 728         pp->file_netgroup_cache = NULL;
 729
 730         f = fopen(_PATH_NETGROUP, "r");
 731         if (f == NULL)
 732         {
 733                 pthread_mutex_unlock(&file_mutex);
 734                 return;
 735         }
 736
 737         _fsi_get_validation(si, VALIDATION_NETGROUP, _PATH_NETGROUP, f, &(pp->netgroup_validation_a), &(pp->netgroup_validation_b));
 738
 739         p1 = NULL;
 740
 741         line = _fsi_read_netgroup_line(f);
 742         while (line != NULL)
 743         {
 744                 n = _fsi_process_netgroup_line(&p1, line);
 745
 746                 free(line);
 747                 line = _fsi_read_netgroup_line(f);
 748         }
 749
 750         fclose(f);
 751
 752         for (n = p1; n != NULL; n = n->next)
 753         {
 754                 a = NULL;
 755                 _fsi_flatten_netgroup(p1, &a, n, n->members);
 756                 for (x = p1; x != NULL; x = x->next) x->flags = 0;
 757
 758                 if (a != NULL)
 759                 {
 760                         a->next = pp->file_netgroup_cache;
 761                         pp->file_netgroup_cache = a;
 762                 }
 763         }
 764
 765         n = p1;
 766         while (n != NULL)
 767         {
 768                 x = n;
 769                 n = n->next;
 770                 _fsi_free_file_netgroup(x);
 771         }
 772
 773         pthread_mutex_unlock(&file_mutex);
 774 }
 775
 776 /* USERS */
 777
 778 static si_item_t *
 779 _fsi_parse_user(si_mod_t *si, const char *name, uid_t uid, int which, char *data, int format, uint64_t va, uint64_t vb)
 780 {
 781         char **tokens;
 782         int ntokens, match;
 783         time_t change, expire;
 784         si_item_t *item;
 785         uid_t xuid;
 786
 787         if (data == NULL) return NULL;
 788
 789         ntokens = 0;
 790         tokens = _fsi_tokenize(data, ":", 1, &ntokens);
 791         if (((format == 0) && (ntokens != 10)) || ((format == 1) && (ntokens !=  7)))
 792         {
 793                 free(tokens);
 794                 return NULL;
 795         }
 796
 797         xuid = atoi(tokens[2]);
 798         match = 0;
 799
 800         /* XXX MATCH GECOS? XXX*/
 801         if (which == SEL_ALL) match = 1;
 802         else if ((which == SEL_NAME) && (string_equal(name, tokens[0]))) match = 1;
 803         else if ((which == SEL_NUMBER) && (uid == xuid)) match = 1;
 804
 805         if (match == 0)
 806         {
 807                 free(tokens);
 808                 return NULL;
 809         }
 810
 811         if (format == 0)
 812         {
 813                 /* master.passwd: name[0] passwd[1] uid[2] gid[3] class[4] change[5] expire[6] gecos[7] dir[8] shell[9] */
 814                 /* struct pwd: name[0] passwd[1] uid[2] gid[3] change[5] class[4] gecos[7] dir[8] shell[9] expire[6] */
 815                 change = atoi(tokens[5]);
 816                 expire = atoi(tokens[6]);
 817                 item = (si_item_t *)LI_ils_create("L4488ss44LssssL", (unsigned long)si, CATEGORY_USER, 1, va, vb, tokens[0], tokens[1], xuid, atoi(tokens[3]), change, tokens[4], tokens[7], tokens[8], tokens[9], expire);
 818         }
 819         else
 820         {
 821                 /* passwd: name[0] passwd[1] uid[2] gid[3] gecos[4] dir[5] shell[6] */
 822                 /* struct pwd: name[0] passwd[1] uid[2] gid[3] change[-] class[-] gecos[4] dir[5] shell[6] expire[-] */
 823                 item = (si_item_t *)LI_ils_create("L4488ss44LssssL", (unsigned long)si, CATEGORY_USER, 1, va, vb, tokens[0], tokens[1], xuid, atoi(tokens[3]), 0, "", tokens[4], tokens[5], tokens[6], 0);
 824         }
 825
 826         free(tokens);
 827         return item;
 828 }
 829
 830 static void *
 831 _fsi_get_user(si_mod_t *si, const char *name, uid_t uid, int which)
 832 {
 833         char *line;
 834         si_item_t *item;
 835         int fmt;
 836         FILE *f;
 837         si_list_t *all;
 838         uint64_t va, vb;
 839
 840         if ((which == SEL_NAME) && (name == NULL)) return NULL;
 841
 842         all = NULL;
 843         f = NULL;
 844         fmt = 0;
 845         va = 0;
 846         vb = 0;
 847
 848         if (geteuid() == 0)
 849         {
 850                 f = fopen(_PATH_MASTERPASSWD, "r");
 851                 _fsi_get_validation(si, VALIDATION_MASTER_PASSWD, _PATH_MASTERPASSWD, f, &va, &vb);
 852         }
 853         else
 854         {
 855                 f = fopen(_PATH_PASSWD, "r");
 856                 _fsi_get_validation(si, VALIDATION_PASSWD, _PATH_PASSWD, f, &va, &vb);
 857                 fmt = 1;
 858         }
 859
 860         if (f == NULL) return NULL;
 861
 862
 863         forever
 864         {
 865                 line = _fsi_get_line(f);
 866                 if (line == NULL) break;
 867
 868                 if (line[0] == '#')
 869                 {
 870                         free(line);
 871                         line = NULL;
 872                         continue;
 873                 }
 874
 875                 item = _fsi_parse_user(si, name, uid, which, line, fmt, va, vb);
 876                 free(line);
 877                 line = NULL;
 878
 879                 if (item == NULL) continue;
 880
 881                 if (which == SEL_ALL)
 882                 {
 883                         all = si_list_add(all, item);
 884                         si_item_release(item);
 885                         continue;
 886                 }
 887
 888                 fclose(f);
 889                 return item;
 890         }
 891         fclose(f);
 892         return all;
 893 }
 894
 895 /* GROUPS */
 896
 897 static si_item_t *
 898 _fsi_parse_group(si_mod_t *si, const char *name, gid_t gid, int which, char *data, uint64_t va, uint64_t vb)
 899 {
 900         char **tokens, **members;
 901         int ntokens, match;
 902         si_item_t *item;
 903         gid_t xgid;
 904
 905         if (data == NULL) return NULL;
 906
 907         ntokens = 0;
 908         tokens = _fsi_tokenize(data, ":", 1, &ntokens);
 909         if (ntokens != 4)
 910         {
 911                 free(tokens);
 912                 return NULL;
 913         }
 914
 915         xgid = atoi(tokens[2]);
 916         match = 0;
 917
 918         if (which == SEL_ALL) match = 1;
 919         else if ((which == SEL_NAME) && (string_equal(name, tokens[0]))) match = 1;
 920         else if ((which == SEL_NUMBER) && (gid == xgid)) match = 1;
 921
 922         if (match == 0)
 923         {
 924                 free(tokens);
 925                 return NULL;
 926         }
 927
 928         ntokens = 0;
 929         members = _fsi_tokenize(tokens[3], ",", 1, &ntokens);
 930
 931         item = (si_item_t *)LI_ils_create("L4488ss4*", (unsigned long)si, CATEGORY_GROUP, 1, va, vb, tokens[0], tokens[1], xgid, members);
 932
 933         free(tokens);
 934         free(members);
 935
 936         return item;
 937 }
 938
 939 static void *
 940 _fsi_get_group(si_mod_t *si, const char *name, gid_t gid, int which)
 941 {
 942         char *line;
 943         si_item_t *item;
 944         FILE *f;
 945         si_list_t *all;
 946         uint64_t va, vb;
 947
 948         if ((which == SEL_NAME) && (name == NULL)) return NULL;
 949
 950         all = NULL;
 951         f = NULL;
 952
 953         f = fopen(_PATH_GROUP, "r");
 954         if (f == NULL) return NULL;
 955
 956         _fsi_get_validation(si, VALIDATION_GROUP, _PATH_GROUP, f, &va, &vb);
 957
 958         forever
 959         {
 960                 line = _fsi_get_line(f);
 961                 if (line == NULL) break;
 962
 963                 if (line[0] == '#')
 964                 {
 965                         free(line);
 966                         line = NULL;
 967                         continue;
 968                 }
 969
 970                 item = _fsi_parse_group(si, name, gid, which, line, va, vb);
 971                 free(line);
 972                 line = NULL;
 973
 974                 if (item == NULL) continue;
 975
 976                 if (which == SEL_ALL)
 977                 {
 978                         all = si_list_add(all, item);
 979                         si_item_release(item);
 980                         continue;
 981                 }
 982
 983                 fclose(f);
 984                 return item;
 985         }
 986
 987         fclose(f);
 988         return all;
 989 }
 990
 991 static void *
 992 _fsi_get_grouplist(si_mod_t *si, const char *user)
 993 {
 994         char **tokens, **members;
 995         int ntokens, i, match, gidcount;
 996         char *line;
 997         si_item_t *item;
 998         FILE *f;
 999         uint64_t va, vb;
1000         gid_t gid, basegid;
1001         gid_t *gidlist;
1002         struct passwd *pw;
1003
1004         if (user == NULL) return NULL;
1005
1006         gidlist = NULL;
1007         gidcount = 0;
1008         f = NULL;
1009         basegid = -1;
1010
1011         item = si->vtable->sim_user_byname(si, user);
1012         if (item != NULL)
1013         {
1014                 pw = (struct passwd *)((uintptr_t)item + sizeof(si_item_t));
1015                 basegid = pw->pw_gid;
1016                 si_item_release(item);
1017                 item = NULL;
1018         }
1019
1020         f = fopen(_PATH_GROUP, "r");
1021         if (f == NULL) return NULL;
1022
1023         _fsi_get_validation(si, VALIDATION_GROUP, _PATH_GROUP, f, &va, &vb);
1024
1025         forever
1026         {
1027                 line = _fsi_get_line(f);
1028                 if (line == NULL) break;
1029
1030                 if (line[0] == '#')
1031                 {
1032                         free(line);
1033                         line = NULL;
1034                         continue;
1035                 }
1036
1037                 ntokens = 0;
1038                 tokens = _fsi_tokenize(line, ":", 1, &ntokens);
1039                 if (ntokens != 4)
1040                 {
1041                         free(tokens);
1042                         continue;
1043                 }
1044
1045                 ntokens = 0;
1046                 members = _fsi_tokenize(tokens[3], ",", 1, &ntokens);
1047
1048                 match = 0;
1049                 gid = -2;
1050
1051                 for (i = 0; i < ntokens; i++)
1052                 {
1053                         if (string_equal(user, members[i]))
1054                         {
1055                                 gid = atoi(tokens[2]);
1056                                 match = 1;
1057                                 break;
1058                         }
1059                 }
1060
1061                 free(tokens);
1062                 free(members);
1063                 free(line);
1064                 line = NULL;
1065
1066                 if (match == 1)
1067                 {
1068                         gidlist = (gid_t *) reallocf(gidlist, (gidcount + 1) * sizeof(gid_t));
1069                         if (gidlist == NULL)
1070                         {
1071                                 gidcount = 0;
1072                                 break;
1073                         }
1074
1075                         gidlist[gidcount++] = gid;
1076                 }
1077         }
1078
1079         fclose(f);
1080
1081         if (gidcount != 0) {
1082                 item = (si_item_t *)LI_ils_create("L4488s4@", (unsigned long)si, CATEGORY_GROUPLIST, 1, va, vb, user, gidcount,
1083                                                                                   gidcount * sizeof(gid_t), gidlist);
1084         }
1085
1086         free(gidlist);
1087
1088         return item;
1089 }
1090
1091 /* ALIASES */
1092
1093 static si_item_t *
1094 _fsi_parse_alias(si_mod_t *si, const char *name, int which, char *data, uint64_t va, uint64_t vb)
1095 {
1096         char **tokens, **members;
1097         int ntokens, match;
1098         si_item_t *item;
1099
1100         if (data == NULL) return NULL;
1101
1102         ntokens = 0;
1103         tokens = _fsi_tokenize(data, ":", 1, &ntokens);
1104         if (ntokens < 2)
1105         {
1106                 free(tokens);
1107                 return NULL;
1108         }
1109
1110         match = 0;
1111
1112         if (which == SEL_ALL) match = 1;
1113         else if (string_equal(name, tokens[0])) match = 1;
1114
1115         if (match == 0)
1116         {
1117                 free(tokens);
1118                 return NULL;
1119         }
1120
1121         ntokens = 0;
1122         members = _fsi_tokenize(tokens[1], ",", 1, &ntokens);
1123
1124         item = (si_item_t *)LI_ils_create("L4488s4*4", (unsigned long)si, CATEGORY_ALIAS, 1, va, vb, tokens[0], ntokens, members, 1);
1125
1126         free(tokens);
1127         free(members);
1128
1129         return item;
1130 }
1131
1132 static void *
1133 _fsi_get_alias(si_mod_t *si, const char *name, int which)
1134 {
1135         char *line;
1136         si_item_t *item;
1137         FILE *f;
1138         si_list_t *all;
1139         uint64_t va, vb;
1140
1141         if ((which == SEL_NAME) && (name == NULL)) return NULL;
1142
1143         all = NULL;
1144         f = NULL;
1145
1146         f = fopen(_PATH_ALIASES, "r");
1147         if (f == NULL) return NULL;
1148
1149         _fsi_get_validation(si, VALIDATION_ALIASES, _PATH_ALIASES, f, &va, &vb);
1150
1151         forever
1152         {
1153                 line = _fsi_get_line(f);
1154                 if (line == NULL) break;
1155
1156                 if (line[0] == '#')
1157                 {
1158                         free(line);
1159                         line = NULL;
1160                         continue;
1161                 }
1162
1163                 item = _fsi_parse_alias(si, name, which, line, va, vb);
1164                 free(line);
1165                 line = NULL;
1166
1167                 if (item == NULL) continue;
1168
1169                 if (which == SEL_ALL)
1170                 {
1171                         all = si_list_add(all, item);
1172                         si_item_release(item);
1173                         continue;
1174                 }
1175
1176                 fclose(f);
1177                 return item;
1178         }
1179
1180         fclose(f);
1181         return all;
1182 }
1183
1184 /* ETHERS */
1185
1186 static si_item_t *
1187 _fsi_parse_ether(si_mod_t *si, const char *name, int which, char *data, uint64_t va, uint64_t vb)
1188 {
1189         char **tokens;
1190         char *cmac;
1191         int ntokens, match;
1192         si_item_t *item;
1193
1194         if (data == NULL) return NULL;
1195
1196         ntokens = 0;
1197         tokens = _fsi_tokenize(data, " \t", 1, &ntokens);
1198         if (ntokens != 2)
1199         {
1200                 free(tokens);
1201                 return NULL;
1202         }
1203
1204         cmac = si_standardize_mac_address(tokens[0]);
1205         if (cmac == NULL)
1206         {
1207                 free(tokens);
1208                 return NULL;
1209         }
1210
1211         match = 0;
1212         if (which == SEL_ALL) match = 1;
1213         else if ((which == SEL_NAME) && (string_equal(name, tokens[1]))) match = 1;
1214         else if ((which == SEL_NUMBER) && (string_equal(name, cmac))) match = 1;
1215
1216         if (match == 0)
1217         {
1218                 free(tokens);
1219                 free(cmac);
1220                 return NULL;
1221         }
1222
1223         item = (si_item_t *)LI_ils_create("L4488ss", (unsigned long)si, CATEGORY_MAC, 1, va, vb, tokens[1], cmac);
1224
1225         free(tokens);
1226         free(cmac);
1227
1228         return item;
1229 }
1230
1231 static void *
1232 _fsi_get_ether(si_mod_t *si, const char *name, int which)
1233 {
1234         char *line, *cmac;
1235         si_item_t *item;
1236         FILE *f;
1237         si_list_t *all;
1238         uint64_t va, vb;
1239
1240         if ((which != SEL_ALL) && (name == NULL)) return NULL;
1241
1242         cmac = NULL;
1243         if (which == SEL_NUMBER)
1244         {
1245                 cmac = si_standardize_mac_address(name);
1246                 if (cmac == NULL) return NULL;
1247         }
1248
1249         all = NULL;
1250         f = NULL;
1251
1252         f = fopen(_PATH_ETHERS, "r");
1253         if (f == NULL) return NULL;
1254
1255         _fsi_get_validation(si, VALIDATION_ETHERS, _PATH_ETHERS, f, &va, &vb);
1256
1257         forever
1258         {
1259                 line = _fsi_get_line(f);
1260                 if (line == NULL) break;
1261
1262                 if (line[0] == '#')
1263                 {
1264                         free(line);
1265                         line = NULL;
1266                         continue;
1267                 }
1268
1269                 item = NULL;
1270                 if (which == SEL_NUMBER) item = _fsi_parse_ether(si, cmac, which, line, va, vb);
1271                 else item = _fsi_parse_ether(si, name, which, line, va, vb);
1272
1273                 free(line);
1274                 line = NULL;
1275
1276                 if (item == NULL) continue;
1277
1278                 if (which == SEL_ALL)
1279                 {
1280                         all = si_list_add(all, item);
1281                         si_item_release(item);
1282                         continue;
1283                 }
1284
1285                 fclose(f);
1286                 return item;
1287         }
1288
1289         fclose(f);
1290         return all;
1291 }
1292
1293 /* HOSTS */
1294
1295 static si_item_t *
1296 _fsi_parse_host(si_mod_t *si, const char *name, const void *addr, int af, int which, char *data, uint64_t va, uint64_t vb)
1297 {
1298         char **tokens, **h_aliases, *null_alias;
1299         int i, ntokens, match, h_addrtype, h_length;
1300         struct in_addr a4;
1301         struct in6_addr a6;
1302         si_item_t *item;
1303         char *h_addr_list[2];
1304         char h_addr_4[4], h_addr_6[16];
1305
1306         if (data == NULL) return NULL;
1307
1308         null_alias = NULL;
1309
1310         ntokens = 0;
1311         tokens = _fsi_tokenize(data, "  ", 0, &ntokens);
1312         if (ntokens < 2)
1313         {
1314                 free(tokens);
1315                 return NULL;
1316         }
1317
1318         h_addr_list[1] = NULL;
1319
1320         h_addrtype = AF_UNSPEC;
1321         if (inet_pton(AF_INET, tokens[0], &a4) == 1)
1322         {
1323                 h_addrtype = AF_INET;
1324                 h_length = sizeof(struct in_addr);
1325                 memcpy(h_addr_4, &a4, 4);
1326                 h_addr_list[0] = h_addr_4;
1327         }
1328         else if (inet_pton(AF_INET6, tokens[0], &a6) == 1)
1329         {
1330                 h_addrtype = AF_INET6;
1331                 h_length = sizeof(struct in6_addr);
1332                 memcpy(h_addr_6, &a6, 16);
1333                 h_addr_list[0] = h_addr_6;
1334         }
1335
1336         if (h_addrtype == AF_UNSPEC)
1337         {
1338                 free(tokens);
1339                 return NULL;
1340         }
1341
1342         h_aliases = NULL;
1343         if (ntokens > 2) h_aliases = &(tokens[2]);
1344
1345         match = 0;
1346
1347         if (which == SEL_ALL) match = 1;
1348         else
1349         {
1350                 if (h_addrtype == af)
1351                 {
1352                         if (which == SEL_NAME)
1353                         {
1354                                 if (string_equal(name, tokens[1])) match = 1;
1355                                 else if (h_aliases != NULL)
1356                                 {
1357                                         for (i = 0; (h_aliases[i] != NULL) && (match == 0); i++)
1358                                                 if (string_equal(name, h_aliases[i])) match = 1;
1359                                 }
1360                         }
1361                         else if (which == SEL_NUMBER)
1362                         {
1363                                 if (memcmp(addr, h_addr_list[0], h_length) == 0) match = 1;
1364                         }
1365                 }
1366         }
1367
1368         if (match == 0)
1369         {
1370                 free(tokens);
1371                 return NULL;
1372         }
1373
1374         item = NULL;
1375
1376         if (h_aliases == NULL) h_aliases = &null_alias;
1377
1378         if (h_addrtype == AF_INET)
1379         {
1380                 item = (si_item_t *)LI_ils_create("L4488s*44a", (unsigned long)si, CATEGORY_HOST_IPV4, 1, va, vb, tokens[1], h_aliases, h_addrtype, h_length, h_addr_list);
1381         }
1382         else
1383         {
1384                 item = (si_item_t *)LI_ils_create("L4488s*44c", (unsigned long)si, CATEGORY_HOST_IPV6, 1, va, vb, tokens[1], h_aliases, h_addrtype, h_length, h_addr_list);
1385         }
1386
1387         free(tokens);
1388
1389         return item;
1390 }
1391
1392 static void *
1393 _fsi_get_host(si_mod_t *si, const char *name, const void *addr, int af, int which, uint32_t *err)
1394 {
1395         char *line;
1396         si_item_t *item;
1397         FILE *f;
1398         si_list_t *all;
1399         uint64_t va, vb;
1400
1401         if ((which == SEL_NAME) && (name == NULL))
1402         {
1403                 if (err != NULL) *err = NO_RECOVERY;
1404                 return NULL;
1405         }
1406
1407         if ((which == SEL_NUMBER) && (addr == NULL))
1408         {
1409                 if (err != NULL) *err = NO_RECOVERY;
1410                 return NULL;
1411         }
1412
1413         f = fopen(_PATH_HOSTS, "r");
1414         if (f == NULL)
1415         {
1416                 if (err != NULL) *err = NO_RECOVERY;
1417                 return NULL;
1418         }
1419
1420         _fsi_get_validation(si, VALIDATION_HOSTS, _PATH_HOSTS, f, &va, &vb);
1421
1422         all = NULL;
1423
1424         forever
1425         {
1426                 line = _fsi_get_line(f);
1427                 if (line == NULL) break;
1428
1429                 if (line[0] == '#')
1430                 {
1431                         free(line);
1432                         line = NULL;
1433                         continue;
1434                 }
1435
1436                 item = _fsi_parse_host(si, name, addr, af, which, line, va, vb);
1437                 free(line);
1438                 line = NULL;
1439
1440                 if (item == NULL) continue;
1441
1442                 if (which == SEL_ALL)
1443                 {
1444                         all = si_list_add(all, item);
1445                         si_item_release(item);
1446                         continue;
1447                 }
1448
1449                 fclose(f);
1450                 return item;
1451         }
1452
1453         fclose(f);
1454         return all;
1455 }
1456
1457 /* SERVICE */
1458
1459 static si_item_t *
1460 _fsi_parse_service(si_mod_t *si, const char *name, const char *proto, int port, int which, char *data, uint64_t va, uint64_t vb)
1461 {
1462         char **tokens, **s_aliases, *xproto;
1463         int i, ntokens, match;
1464         si_item_t *item;
1465         int xport;
1466
1467         if (data == NULL) return NULL;
1468
1469         port = ntohs(port);
1470
1471         ntokens = 0;
1472         tokens = _fsi_tokenize(data, "  ", 0, &ntokens);
1473         if (ntokens < 2)
1474         {
1475                 free(tokens);
1476                 return NULL;
1477         }
1478
1479         s_aliases = NULL;
1480         if (ntokens > 2) s_aliases = &(tokens[2]);
1481
1482         xport = atoi(tokens[1]);
1483
1484         xproto = strchr(tokens[1], '/');
1485
1486         if (xproto == NULL)
1487         {
1488                 free(tokens);
1489                 return NULL;
1490         }
1491
1492         *xproto++ = '\0';
1493         if ((proto != NULL) && (string_not_equal(proto, xproto)))
1494         {
1495                 free(tokens);
1496                 return NULL;
1497         }
1498
1499         match = 0;
1500         if (which == SEL_ALL) match = 1;
1501         else if (which == SEL_NAME)
1502         {
1503                 if (string_equal(name, tokens[0])) match = 1;
1504                 else if (s_aliases != NULL)
1505                 {
1506                         for (i = 0; (s_aliases[i] != NULL) && (match == 0); i++)
1507                                 if (string_equal(name, s_aliases[i])) match = 1;
1508                 }
1509         }
1510         else if ((which == SEL_NUMBER) && (port == xport)) match = 1;
1511
1512         if (match == 0)
1513         {
1514                 free(tokens);
1515                 return NULL;
1516         }
1517
1518         /* strange but correct */
1519         xport = htons(xport);
1520
1521         item = (si_item_t *)LI_ils_create("L4488s*4s", (unsigned long)si, CATEGORY_SERVICE, 1, va, vb, tokens[0], s_aliases, xport, xproto);
1522
1523         free(tokens);
1524
1525         return item;
1526 }
1527
1528 static void *
1529 _fsi_get_service(si_mod_t *si, const char *name, const char *proto, int port, int which)
1530 {
1531         char *p, *line;
1532         si_item_t *item;
1533         FILE *f;
1534         si_list_t *all;
1535         uint64_t va, vb;
1536
1537         if ((which == SEL_NAME) && (name == NULL)) return NULL;
1538         if ((which == SEL_NUMBER) && (port == 0)) return NULL;
1539
1540         f = fopen(_PATH_SERVICES, "r");
1541         if (f == NULL) return NULL;
1542
1543         _fsi_get_validation(si, VALIDATION_SERVICES, _PATH_SERVICES, f, &va, &vb);
1544
1545         all = NULL;
1546
1547         forever
1548         {
1549                 line = _fsi_get_line(f);
1550                 if (line == NULL) break;
1551
1552                 if (line[0] == '#')
1553                 {
1554                         free(line);
1555                         line = NULL;
1556                         continue;
1557                 }
1558
1559                 p = strchr(line, '#');
1560                 if (p != NULL) *p = '\0';
1561
1562                 item = _fsi_parse_service(si, name, proto, port, which, line, va, vb);
1563                 free(line);
1564                 line = NULL;
1565
1566                 if (item == NULL) continue;
1567
1568                 if (which == SEL_ALL)
1569                 {
1570                         all = si_list_add(all, item);
1571                         si_item_release(item);
1572                         continue;
1573                 }
1574
1575                 fclose(f);
1576                 return item;
1577         }
1578
1579         fclose(f);
1580         return all;
1581 }
1582
1583 /*
1584  * Generic name/number/aliases lookup
1585  * Works for protocols, networks, and rpcs
1586  */
1587
1588 static si_item_t *
1589 _fsi_parse_name_num_aliases(si_mod_t *si, const char *name, int num, int which, char *data, uint64_t va, uint64_t vb, int cat)
1590 {
1591         char **tokens, **aliases;
1592         int i, ntokens, match, xnum;
1593         si_item_t *item;
1594
1595         if (data == NULL) return NULL;
1596
1597         ntokens = 0;
1598         tokens = _fsi_tokenize(data, "  ", 0, &ntokens);
1599         if (ntokens < 2)
1600         {
1601                 free(tokens);
1602                 return NULL;
1603         }
1604
1605         xnum = atoi(tokens[1]);
1606
1607         aliases = NULL;
1608         if (ntokens > 2) aliases = &(tokens[2]);
1609
1610         match = 0;
1611
1612         if (which == SEL_ALL) match = 1;
1613         else if (which == SEL_NAME)
1614         {
1615                 if (string_equal(name, tokens[0])) match = 1;
1616                 else if (aliases != NULL)
1617                 {
1618                         for (i = 0; (aliases[i] != NULL) && (match == 0); i++)
1619                                 if (string_equal(name, aliases[i])) match = 1;
1620                 }
1621         }
1622         else if ((which == SEL_NUMBER) && (num == xnum)) match = 1;
1623
1624         if (match == 0)
1625         {
1626                 free(tokens);
1627                 return NULL;
1628         }
1629
1630         switch (cat) {
1631                 case CATEGORY_NETWORK:
1632                         // struct netent
1633                         item = (si_item_t *)LI_ils_create("L4488s*44", (unsigned long)si, cat, 1, va, vb, tokens[0], aliases, AF_INET, xnum);
1634                         break;
1635                 case CATEGORY_PROTOCOL:
1636                 case CATEGORY_RPC:
1637                         // struct protoent
1638                         // struct rpcent
1639                         item = (si_item_t *)LI_ils_create("L4488s*4", (unsigned long)si, cat, 1, va, vb, tokens[0], aliases, xnum);
1640                         break;
1641                 default:
1642                         abort();
1643         }
1644
1645         free(tokens);
1646
1647         return item;
1648 }
1649
1650 static void *
1651 _fsi_get_name_number_aliases(si_mod_t *si, const char *name, int num, int which, int cat)
1652 {
1653         char *p, *line;
1654         si_item_t *item;
1655         FILE *f;
1656         si_list_t *all;
1657         uint64_t va, vb;
1658         const char *path;
1659         int vtype;
1660
1661         switch (cat) {
1662                 case CATEGORY_NETWORK:
1663                         vtype = VALIDATION_NETWORKS;
1664                         path = _PATH_NETWORKS;
1665                         break;
1666                 case CATEGORY_PROTOCOL:
1667                         vtype = VALIDATION_PROTOCOLS;
1668                         path = _PATH_PROTOCOLS;
1669                         break;
1670                 case CATEGORY_RPC:
1671                         vtype = VALIDATION_RPC;
1672                         path = _PATH_RPCS;
1673                         break;
1674                 default:
1675                         abort();
1676         }
1677
1678         f = fopen(path, "r");
1679         if (f == NULL) return NULL;
1680
1681         _fsi_get_validation(si, vtype, path, f, &va, &vb);
1682
1683         all = NULL;
1684
1685         forever
1686         {
1687                 line = _fsi_get_line(f);
1688                 if (line == NULL) break;
1689
1690                 if (line[0] == '#')
1691                 {
1692                         free(line);
1693                         line = NULL;
1694                         continue;
1695                 }
1696
1697                 p = strchr(line, '#');
1698                 if (p != NULL) *p = '\0';
1699
1700                 item = _fsi_parse_name_num_aliases(si, name, num, which, line, va, vb, cat);
1701                 free(line);
1702                 line = NULL;
1703
1704                 if (item == NULL) continue;
1705
1706                 if (which == SEL_ALL)
1707                 {
1708                         all = si_list_add(all, item);
1709                         si_item_release(item);
1710                         continue;
1711                 }
1712
1713                 fclose(f);
1714                 return item;
1715         }
1716
1717         fclose(f);
1718         return all;
1719 }
1720
1721 /* MOUNT */
1722
1723 #if (TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR)
1724 static si_item_t *
1725 _fsi_parse_edt_fs(si_mod_t *si, const char *name, int which, struct edt_fstab *fs, uint64_t va, uint64_t vb)
1726 {
1727         int match;
1728         si_item_t *item;
1729
1730         if (fs == NULL) return NULL;
1731
1732         match = 0;
1733
1734         if (which == SEL_ALL) match = 1;
1735         else if ((which == SEL_NAME) && (string_equal(name, fs->fs_spec))) match = 1;
1736         else if ((which == SEL_NUMBER) && (string_equal(name, fs->fs_file))) match = 1;
1737
1738         if (match == 0)
1739         {
1740                 return NULL;
1741         }
1742
1743         item = (si_item_t *)LI_ils_create("L4488sssss44", (unsigned long)si, CATEGORY_FS, 1, va, vb, fs->fs_spec, fs->fs_file, fs->fs_vfstype, fs->fs_mntops, fs->fs_type, fs->fs_freq, fs->fs_passno);
1744
1745         return item;
1746 }
1747 #endif
1748
1749 static si_item_t *
1750 _fsi_parse_fs(si_mod_t *si, const char *name, int which, char *data, uint64_t va, uint64_t vb)
1751 {
1752         char **tokens, *tmp, **opts, *fstype;
1753         int ntokens, match, i, freq, passno;
1754         si_item_t *item;
1755
1756         if (data == NULL) return NULL;
1757
1758         freq = 0;
1759         passno = 0;
1760         fstype = NULL;
1761
1762         ntokens = 0;
1763         tokens = _fsi_tokenize(data, "  ", 0, &ntokens);
1764         if ((ntokens < 4) || (ntokens > 6))
1765         {
1766                 free(tokens);
1767                 return NULL;
1768         }
1769
1770         if (ntokens >= 5) freq = atoi(tokens[4]);
1771         if (ntokens == 6) passno = atoi(tokens[5]);
1772
1773         tmp = strdup(tokens[3]);
1774         if (tmp == NULL)
1775         {
1776                 free(tokens);
1777                 return NULL;
1778         }
1779
1780         ntokens = 0;
1781         opts = _fsi_tokenize(tmp, ",", 0, &ntokens);
1782
1783         if (opts == NULL)
1784         {
1785                 free(tokens);
1786                 free(tmp);
1787                 return NULL;
1788         }
1789
1790         for (i = 0; i < ntokens; i++)
1791         {
1792                 if ((string_equal(opts[i], "rw")) || (string_equal(opts[i], "ro")) || (string_equal(opts[i], "sw")) || (string_equal(opts[i], "xx")))
1793                 {
1794                         fstype = opts[i];
1795                         break;
1796                 }
1797         }
1798
1799         match = 0;
1800
1801         if (which == SEL_ALL) match = 1;
1802         else if ((which == SEL_NAME) && (string_equal(name, tokens[0]))) match = 1;
1803         else if ((which == SEL_NUMBER) && (string_equal(name, tokens[1]))) match = 1;
1804
1805         if (match == 0)
1806         {
1807                 free(tokens);
1808                 return NULL;
1809         }
1810
1811         item = (si_item_t *)LI_ils_create("L4488sssss44", (unsigned long)si, CATEGORY_FS, 1, va, vb, tokens[0], tokens[1], tokens[2], tokens[3], (fstype == NULL) ? "rw" : fstype, freq, passno);
1812
1813         free(tokens);
1814         free(opts);
1815         free(tmp);
1816
1817         return item;
1818 }
1819
1820 static char *
1821 _fsi_get_device_path(dev_t target_dev)
1822 {
1823         char *result;
1824     char dev[PATH_MAX];
1825     char *name;
1826         char namebuf[PATH_MAX];
1827
1828         result = NULL;
1829
1830     strlcpy(dev, _PATH_DEV, sizeof(dev));
1831
1832     /* The root device in fstab should always be a block special device */
1833     name = devname_r(target_dev, S_IFBLK, namebuf, sizeof(namebuf));
1834     if (name == NULL)
1835         {
1836                 DIR *dirp;
1837                 struct stat devst;
1838                 struct dirent *ent, entbuf;
1839
1840        /* No _PATH_DEVDB. We have to search for it the slow way */
1841         dirp = opendir(_PATH_DEV);
1842         if (dirp == NULL) return NULL;
1843
1844         while (readdir_r(dirp, &entbuf, &ent) == 0 && ent != NULL)
1845                 {
1846             /* Look for a block special device */
1847             if (ent->d_type == DT_BLK)
1848                         {
1849                 strlcat(dev, ent->d_name, sizeof(dev));
1850                 if (stat(dev, &devst) == 0)
1851                                 {
1852                     if (devst.st_rdev == target_dev) {
1853                                                 result = strdup(dev);
1854                                                 break;
1855                                         }
1856                 }
1857             }
1858
1859             /* reset dev to _PATH_DEV and try again */
1860             dev[sizeof(_PATH_DEV) - 1] = '\0';
1861         }
1862
1863                 if (dirp) closedir(dirp);
1864     }
1865         else
1866         {
1867         /* We found the _PATH_DEVDB entry */
1868                 strlcat(dev, name, sizeof(dev));
1869                 result = strdup(dev);
1870         }
1871
1872     return result;
1873 }
1874
1875 static si_item_t *
1876 _fsi_fs_root(si_mod_t *si)
1877 {
1878         dispatch_once(&rootfs_once, ^{
1879                 struct stat rootstat;
1880                 struct statfs rootfsinfo;
1881                 char *root_spec;
1882                 const char *root_path = "/";
1883
1884                 if (stat(root_path, &rootstat) < 0) return;
1885                 if (statfs(root_path, &rootfsinfo) < 0) return;
1886
1887                 // Check to make sure we're not looking at a synthetic root:
1888                 if (string_equal(rootfsinfo.f_fstypename, "synthfs")) {
1889                         root_path = "/root";
1890                         if (stat(root_path, &rootstat) < 0) return;
1891                         if (statfs(root_path, &rootfsinfo) < 0) return;
1892                 }
1893
1894                 root_spec = _fsi_get_device_path(rootstat.st_dev);
1895
1896                 // In case root is mounted from snapshot, _fsi_get_device_path will return NULL as the device name does not comply to
1897                 // /dev/diskAAsBB, but in the format of snap@/dev/diskAAsBB, in that case f_mntfromname has the correct device name, so return it
1898                 if (root_spec == NULL) {
1899                         const char *mntfromname = rootfsinfo.f_mntfromname;
1900                         size_t len = sizeof(rootfsinfo.f_mntfromname);
1901                         const char *p;
1902                         while ((p = strnstr(mntfromname, "@", len))) {
1903                                 len -= p + 1 - mntfromname;
1904                                 mntfromname = p + 1;
1905                         }
1906                         root_spec = strndup(mntfromname, len);
1907                 }
1908
1909                 rootfs = (si_item_t *)LI_ils_create("L4488sssss44", (unsigned long)si, CATEGORY_FS, 1, 0LL, 0LL, root_spec, root_path, rootfsinfo.f_fstypename, FSTAB_RW, FSTAB_RW, 0, 1);
1910                 free(root_spec);
1911         });
1912
1913         return si_item_retain(rootfs);
1914 }
1915
1916 #if (TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR)
1917 static void *
1918 _fsi_get_edt_fs(si_mod_t *si, const char *name, int which)
1919 {
1920         void *data;
1921         struct edt_fstab *fstab;
1922         size_t i, size;
1923         si_item_t *item;
1924         si_list_t *all;
1925         uint64_t va, vb;
1926
1927         if ((which != SEL_ALL) && (name == NULL)) return NULL;
1928
1929         all = NULL;
1930         item = NULL;
1931         fstab = NULL;
1932         i = 0;
1933         size = 0;
1934
1935         // obtain fstab information from the EDT provided through this sysctl
1936         if (sysctlbyname(APFS_FSTAB_SYSCTL, NULL, &size, NULL, 0) || !size)
1937         {
1938                 return all;
1939         }
1940
1941         fstab = malloc(size);
1942         if (!fstab)
1943         {
1944                 return all;
1945         }
1946
1947         if (sysctlbyname(APFS_FSTAB_SYSCTL, fstab, &size, NULL, 0))
1948         {
1949                 free(fstab);
1950                 return all;
1951         }
1952         size = size / sizeof(struct edt_fstab);
1953
1954         _fsi_get_validation(si, VALIDATION_FSTAB, _PATH_FSTAB, NULL, &va, &vb);
1955
1956         forever
1957         {
1958                 if (i >= size)
1959                 {
1960                         free(fstab);
1961                         break;
1962                 }
1963
1964                 data = fstab + i;
1965                 i++;
1966
1967                 item = _fsi_parse_edt_fs(si, name, which, data, va, vb);
1968
1969                 if (item == NULL) continue;
1970
1971                 if (which == SEL_ALL)
1972                 {
1973                         all = si_list_add(all, item);
1974                         si_item_release(item);
1975                         continue;
1976                 }
1977
1978                 return item;
1979         }
1980
1981         return all;
1982 }
1983 #endif
1984
1985 static void *
1986 _fsi_get_fs(si_mod_t *si, const char *name, int which)
1987 {
1988         char *line;
1989         si_item_t *item;
1990         FILE *f;
1991         si_list_t *all;
1992         uint64_t va, vb;
1993         int synthesize_root;
1994         struct fstab *rfs;
1995
1996         if ((which != SEL_ALL) && (name == NULL)) return NULL;
1997
1998         all = NULL;
1999         f = NULL;
2000 #ifdef SYNTH_ROOTFS
2001         synthesize_root = 1;
2002 #else
2003         synthesize_root = 0;
2004 #endif
2005
2006 #if (TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR)
2007         // We still boot using HFS sometimes (e.g. ramdisks) and therefore
2008         // need to conditionalize using the EDT over the fstab file.
2009         // Certain HFS ramdisks rely on the EDT entries. Prefer the EDT
2010         // over the fstab file, but fall back to use the file upon failure
2011         // to obtain the EDT entries.
2012         struct statfs rootfs;
2013         const char *root_path = "/";
2014
2015         if (statfs(root_path, &rootfs)) return NULL;
2016
2017         all = _fsi_get_edt_fs(si, name, which);
2018         if (all || string_equal(rootfs.f_fstypename, "apfs"))
2019         {
2020                 return all;
2021         }
2022 #endif
2023
2024         f = fopen(_PATH_FSTAB, "r");
2025         if ((f == NULL) || (synthesize_root == 1))
2026         {
2027                 item = _fsi_fs_root(si);
2028
2029                 rfs = NULL;
2030                 if (item != NULL) rfs = (struct fstab *)((uintptr_t)item + sizeof(si_item_t));
2031
2032                 switch (which)
2033                 {
2034                         case SEL_NAME:
2035                         {
2036                                 if ((rfs != NULL) && (string_equal(name, rfs->fs_spec)))
2037                                 {
2038                                         if (f != NULL) fclose(f);
2039                                         return item;
2040                                 }
2041
2042                                 break;
2043                         }
2044
2045                         case SEL_NUMBER:
2046                         {
2047                                 if ((rfs != NULL) && (string_equal(name, rfs->fs_file)))
2048                                 {
2049                                         if (f != NULL) fclose(f);
2050                                         return item;
2051                                 }
2052
2053                                 break;
2054                         }
2055
2056                         case SEL_ALL:
2057                         {
2058                                 all = si_list_add(all, item);
2059                                 si_item_release(item);
2060                                 break;
2061                         }
2062                 }
2063         }
2064
2065         if (f == NULL) return all;
2066
2067         _fsi_get_validation(si, VALIDATION_FSTAB, _PATH_FSTAB, f, &va, &vb);
2068
2069         forever
2070         {
2071                 line = _fsi_get_line(f);
2072                 if (line == NULL) break;
2073
2074                 if (line[0] == '#')
2075                 {
2076                         free(line);
2077                         line = NULL;
2078                         continue;
2079                 }
2080
2081                 item = _fsi_parse_fs(si, name, which, line, va, vb);
2082                 free(line);
2083                 line = NULL;
2084
2085                 if (item == NULL) continue;
2086
2087                 if (which == SEL_ALL)
2088                 {
2089                         all = si_list_add(all, item);
2090                         si_item_release(item);
2091                         continue;
2092                 }
2093
2094                 fclose(f);
2095                 return item;
2096         }
2097
2098         fclose(f);
2099         return all;
2100 }
2101
2102 static int
2103 file_is_valid(si_mod_t *si, si_item_t *item)
2104 {
2105         si_mod_t *src;
2106
2107         if (si == NULL) return 0;
2108         if (item == NULL) return 0;
2109         if (si->name == NULL) return 0;
2110         if (item->src == NULL) return 0;
2111
2112         src = (si_mod_t *)item->src;
2113
2114         if (src->name == NULL) return 0;
2115         if (string_not_equal(si->name, src->name)) return 0;
2116
2117         if (item == rootfs) return 1;
2118
2119         return _fsi_validate(si, item->type, item->validation_a, item->validation_b);
2120 }
2121
2122 static si_item_t *
2123 file_user_byname(si_mod_t *si, const char *name)
2124 {
2125         return _fsi_get_user(si, name, 0, SEL_NAME);
2126 }
2127
2128 static si_item_t *
2129 file_user_byuid(si_mod_t *si, uid_t uid)
2130 {
2131         return _fsi_get_user(si, NULL, uid, SEL_NUMBER);
2132 }
2133
2134 static si_list_t *
2135 file_user_all(si_mod_t *si)
2136 {
2137         return _fsi_get_user(si, NULL, 0, SEL_ALL);
2138 }
2139
2140 static si_item_t *
2141 file_group_byname(si_mod_t *si, const char *name)
2142 {
2143         return _fsi_get_group(si, name, 0, SEL_NAME);
2144 }
2145
2146 static si_item_t *
2147 file_group_bygid(si_mod_t *si, gid_t gid)
2148 {
2149         return _fsi_get_group(si, NULL, gid, SEL_NUMBER);
2150 }
2151
2152 static si_list_t *
2153 file_group_all(si_mod_t *si)
2154 {
2155         return _fsi_get_group(si, NULL, 0, SEL_ALL);
2156 }
2157
2158 static si_item_t *
2159 file_grouplist(si_mod_t *si, const char *name, __unused uint32_t ignored)
2160 {
2161         return _fsi_get_grouplist(si, name);
2162 }
2163
2164 static si_list_t *
2165 file_netgroup_byname(si_mod_t *si, const char *name)
2166 {
2167         si_list_t *list = NULL;
2168         si_item_t *item;
2169         uint64_t va=0, vb=0;
2170         file_netgroup_t *n;
2171         file_si_private_t *pp;
2172
2173         if (name == NULL) return NULL;
2174
2175         pp = (file_si_private_t *)si->private;
2176         if (pp == NULL) return NULL;
2177
2178         _fsi_check_netgroup_cache(si);
2179
2180         pthread_mutex_lock(&file_mutex);
2181
2182         n = _fsi_find_netgroup(&(pp->file_netgroup_cache), name, 0);
2183         if (n != NULL)
2184         {
2185                 file_netgroup_member_t *m = n->members;
2186                 while (m != NULL)
2187                 {
2188                         item = (si_item_t *)LI_ils_create("L4488sss", (unsigned long)si, CATEGORY_NETGROUP, 1, va, vb, m->host, m->user, m->domain);
2189                         list = si_list_add(list, item);
2190                         m = m->next;
2191                 }
2192         }
2193
2194         pthread_mutex_unlock(&file_mutex);
2195
2196         return list;
2197 }
2198
2199 static int
2200 file_in_netgroup(si_mod_t *si, const char *group, const char *host, const char *user, const char *domain)
2201 {
2202         file_netgroup_t *n;
2203         file_netgroup_member_t *m;
2204         file_si_private_t *pp;
2205
2206         if (group == NULL) return 0;
2207
2208         pp = (file_si_private_t *)si->private;
2209         if (pp == NULL) return 0;
2210
2211         _fsi_check_netgroup_cache(si);
2212
2213         pthread_mutex_lock(&file_mutex);
2214
2215         n = _fsi_find_netgroup(&(pp->file_netgroup_cache), group, 0);
2216         if (n == NULL)
2217         {
2218                 pthread_mutex_unlock(&file_mutex);
2219                 return 0;
2220         }
2221
2222         m = n->members;
2223         while (m != NULL)
2224         {
2225                 file_netgroup_member_t *x = m;
2226                 m = m->next;
2227
2228                 if (host != NULL)
2229                 {
2230                         if (x->host == NULL) continue;
2231                         if (strcmp(host, x->host)) continue;
2232                 }
2233
2234                 if (user != NULL)
2235                 {
2236                         if (x->user == NULL) continue;
2237                         if (strcmp(user, x->user)) continue;
2238                 }
2239
2240                 if (domain != NULL)
2241                 {
2242                         if (x->domain == NULL) continue;
2243                         if (strcmp(domain, x->domain)) continue;
2244                 }
2245
2246                 pthread_mutex_unlock(&file_mutex);
2247                 return 1;
2248         }
2249
2250         pthread_mutex_unlock(&file_mutex);
2251         return 0;
2252 }
2253
2254 static si_item_t *
2255 file_host_byname(si_mod_t *si, const char *name, int af, const char *ignored, uint32_t *err)
2256 {
2257         si_item_t *item;
2258
2259         if (err != NULL) *err = SI_STATUS_NO_ERROR;
2260
2261         item = _fsi_get_host(si, name, NULL, af, SEL_NAME, err);
2262         if ((item == NULL) && (err != NULL) && (*err == 0)) *err = SI_STATUS_H_ERRNO_HOST_NOT_FOUND;
2263
2264         return item;
2265 }
2266
2267 static si_item_t *
2268 file_host_byaddr(si_mod_t *si, const void *addr, int af, const char *ignored, uint32_t *err)
2269 {
2270         si_item_t *item;
2271
2272         if (err != NULL) *err = SI_STATUS_NO_ERROR;
2273
2274         item = _fsi_get_host(si, NULL, addr, af, SEL_NUMBER, err);
2275         if ((item == NULL) && (err != NULL) && (*err == 0)) *err = SI_STATUS_H_ERRNO_HOST_NOT_FOUND;
2276
2277         return item;
2278 }
2279
2280 static si_list_t *
2281 file_host_all(si_mod_t *si)
2282 {
2283         return _fsi_get_host(si, NULL, NULL, 0, SEL_ALL, NULL);
2284 }
2285
2286 static si_item_t *
2287 file_network_byname(si_mod_t *si, const char *name)
2288 {
2289         if (name == NULL) return NULL;
2290         return _fsi_get_name_number_aliases(si, name, 0, SEL_NAME, CATEGORY_NETWORK);
2291 }
2292
2293 static si_item_t *
2294 file_network_byaddr(si_mod_t *si, uint32_t addr)
2295 {
2296         return _fsi_get_name_number_aliases(si, NULL, (int)addr, SEL_NUMBER, CATEGORY_NETWORK);
2297 }
2298
2299 static si_list_t *
2300 file_network_all(si_mod_t *si)
2301 {
2302         return _fsi_get_name_number_aliases(si, NULL, 0, SEL_ALL, CATEGORY_NETWORK);
2303 }
2304
2305 static si_item_t *
2306 file_service_byname(si_mod_t *si, const char *name, const char *proto)
2307 {
2308         return _fsi_get_service(si, name, proto, 0, SEL_NAME);
2309 }
2310
2311 static si_item_t *
2312 file_service_byport(si_mod_t *si, int port, const char *proto)
2313 {
2314         return _fsi_get_service(si, NULL, proto, port, SEL_NUMBER);
2315 }
2316
2317 static si_list_t *
2318 file_service_all(si_mod_t *si)
2319 {
2320         return _fsi_get_service(si, NULL, NULL, 0, SEL_ALL);
2321 }
2322
2323 static si_item_t *
2324 file_protocol_byname(si_mod_t *si, const char *name)
2325 {
2326         if (name == NULL) return NULL;
2327         return _fsi_get_name_number_aliases(si, name, 0, SEL_NAME, CATEGORY_PROTOCOL);
2328 }
2329
2330 static si_item_t *
2331 file_protocol_bynumber(si_mod_t *si, int number)
2332 {
2333         return _fsi_get_name_number_aliases(si, NULL, number, SEL_NUMBER, CATEGORY_PROTOCOL);
2334 }
2335
2336 static si_list_t *
2337 file_protocol_all(si_mod_t *si)
2338 {
2339         return _fsi_get_name_number_aliases(si, NULL, 0, SEL_ALL, CATEGORY_PROTOCOL);
2340 }
2341
2342 static si_item_t *
2343 file_rpc_byname(si_mod_t *si, const char *name)
2344 {
2345         if (name == NULL) return NULL;
2346         return _fsi_get_name_number_aliases(si, name, 0, SEL_NAME, CATEGORY_RPC);
2347 }
2348
2349 static si_item_t *
2350 file_rpc_bynumber(si_mod_t *si, int number)
2351 {
2352         return _fsi_get_name_number_aliases(si, NULL, number, SEL_NUMBER, CATEGORY_RPC);
2353 }
2354
2355 static si_list_t *
2356 file_rpc_all(si_mod_t *si)
2357 {
2358         return _fsi_get_name_number_aliases(si, NULL, 0, SEL_ALL, CATEGORY_RPC);
2359 }
2360
2361 static si_item_t *
2362 file_fs_byspec(si_mod_t *si, const char *spec)
2363 {
2364         return _fsi_get_fs(si, spec, SEL_NAME);
2365 }
2366
2367 static si_item_t *
2368 file_fs_byfile(si_mod_t *si, const char *file)
2369 {
2370         return _fsi_get_fs(si, file, SEL_NUMBER);
2371 }
2372
2373 static si_list_t *
2374 file_fs_all(si_mod_t *si)
2375 {
2376         return _fsi_get_fs(si, NULL, SEL_ALL);
2377 }
2378
2379 static si_item_t *
2380 file_alias_byname(si_mod_t *si, const char *name)
2381 {
2382         return _fsi_get_alias(si, name, SEL_NAME);
2383 }
2384
2385 static si_list_t *
2386 file_alias_all(si_mod_t *si)
2387 {
2388         return _fsi_get_alias(si, NULL, SEL_ALL);
2389 }
2390
2391 static si_item_t *
2392 file_mac_byname(si_mod_t *si, const char *name)
2393 {
2394         return _fsi_get_ether(si, name, SEL_NAME);
2395 }
2396
2397 static si_item_t *
2398 file_mac_bymac(si_mod_t *si, const char *mac)
2399 {
2400         return _fsi_get_ether(si, mac, SEL_NUMBER);
2401 }
2402
2403 static si_list_t *
2404 file_mac_all(si_mod_t *si)
2405 {
2406         return _fsi_get_ether(si, NULL, SEL_ALL);
2407 }
2408
2409 static si_list_t *
2410 file_addrinfo(si_mod_t *si, const void *node, const void *serv, uint32_t family, uint32_t socktype, uint32_t proto, uint32_t flags, const char *interface, uint32_t *err)
2411 {
2412         if (err != NULL) *err = SI_STATUS_NO_ERROR;
2413         return _gai_simple(si, node, serv, family, socktype, proto, flags, interface, err);
2414 }
2415
2416 si_mod_t *
2417 si_module_static_file(void)
2418 {
2419         static const struct si_mod_vtable_s file_vtable =
2420         {
2421                 .sim_is_valid = &file_is_valid,
2422
2423                 .sim_user_byname = &file_user_byname,
2424                 .sim_user_byuid = &file_user_byuid,
2425                 .sim_user_byuuid = NULL,
2426                 .sim_user_all = &file_user_all,
2427
2428                 .sim_group_byname = &file_group_byname,
2429                 .sim_group_bygid = &file_group_bygid,
2430                 .sim_group_byuuid = NULL,
2431                 .sim_group_all = &file_group_all,
2432
2433                 .sim_grouplist = &file_grouplist,
2434
2435                 .sim_netgroup_byname = &file_netgroup_byname,
2436                 .sim_in_netgroup = &file_in_netgroup,
2437
2438                 .sim_alias_byname = &file_alias_byname,
2439                 .sim_alias_all = &file_alias_all,
2440
2441                 .sim_host_byname = &file_host_byname,
2442                 .sim_host_byaddr = &file_host_byaddr,
2443                 .sim_host_all = &file_host_all,
2444
2445                 .sim_network_byname = &file_network_byname,
2446                 .sim_network_byaddr = &file_network_byaddr,
2447                 .sim_network_all = &file_network_all,
2448
2449                 .sim_service_byname = &file_service_byname,
2450                 .sim_service_byport = &file_service_byport,
2451                 .sim_service_all = &file_service_all,
2452
2453                 .sim_protocol_byname = &file_protocol_byname,
2454                 .sim_protocol_bynumber = &file_protocol_bynumber,
2455                 .sim_protocol_all = &file_protocol_all,
2456
2457                 .sim_rpc_byname = &file_rpc_byname,
2458                 .sim_rpc_bynumber = &file_rpc_bynumber,
2459                 .sim_rpc_all = &file_rpc_all,
2460
2461                 .sim_fs_byspec = &file_fs_byspec,
2462                 .sim_fs_byfile = &file_fs_byfile,
2463                 .sim_fs_all = &file_fs_all,
2464
2465                 .sim_mac_byname = &file_mac_byname,
2466                 .sim_mac_bymac = &file_mac_bymac,
2467                 .sim_mac_all = &file_mac_all,
2468
2469                 .sim_wants_addrinfo = NULL,
2470                 .sim_addrinfo = &file_addrinfo,
2471
2472                 /* no nameinfo support */
2473                 .sim_nameinfo = NULL,
2474         };
2475
2476         static si_mod_t si =
2477         {
2478                 .vers = 1,
2479                 .refcount = 1,
2480                 .flags = SI_MOD_FLAG_STATIC,
2481
2482                 .private = NULL,
2483                 .vtable = &file_vtable,
2484         };
2485
2486         static dispatch_once_t once;
2487
2488         dispatch_once(&once, ^{
2489                 si.name = strdup("file");
2490                 file_si_private_t *pp = calloc(1, sizeof(file_si_private_t));
2491                 if (pp != NULL)
2492                 {
2493                         int i;
2494                         for (i = 0; i < VALIDATION_COUNT; i++) pp->notify_token[i] = -1;
2495
2496                         /* hardwired for now, but we may want to make this configurable someday */
2497                         pp->validation_notify_mask = VALIDATION_MASK_HOSTS | VALIDATION_MASK_SERVICES | VALIDATION_MASK_PROTOCOLS;
2498                 }
2499
2500                 si.private = pp;
2501         });
2502
2503         return (si_mod_t *)&si;
2504 }