]> git.saurik.com Git - apple/libinfo.git/blob - lookup.subproj/ds_module.c
projects / apple / libinfo.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Libinfo-324.1.tar.gz
[apple/libinfo.git] / lookup.subproj / ds_module.c
1 /*
2 * Copyright (c) 2008-2009 Apple Inc. All rights reserved.
3 *
4 * @APPLE_LICENSE_HEADER_START@
5 *
6 * This ds 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 ds 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 * ds.
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 <stdio.h>
25 #include <unistd.h>
26 #include <string.h>
27 #include <time.h>
28 #include <errno.h>
29 #include <arpa/inet.h>
30 #include <sys/stat.h>
31 #include <mach/mach.h>
32 #include <ils.h>
33 #include <kvbuf.h>
34 #include <pwd.h>
35 #include <grp.h>
36 #include <fstab.h>
37 #include <netdb.h>
38 #include <notify.h>
39 #include <si_data.h>
40 #include <si_module.h>
41 #include <netdb_async.h>
42 #include <net/if.h>
43 #include <servers/bootstrap.h>
44 #include <DSlibinfoMIG.h>
45 #include <DSmemberdMIG.h>
46 #ifdef DEBUG
47 #include <asl.h>
48 #endif
49
50 #define SOCK_UNSPEC 0
51 #define IPPROTO_UNSPEC 0
52
53 #define IPV6_ADDR_LEN 16
54 #define IPV4_ADDR_LEN 4
55
56 #define WANT_NOTHING 0
57 #define WANT_A4_ONLY 1
58 #define WANT_A6_ONLY 2
59 #define WANT_A6_PLUS_MAPPED_A4 3
60 #define WANT_MAPPED_A4_ONLY 4
61
62 /* ONLY TO BE USED BY getipv6nodebyaddr */
63 #define WANT_A6_OR_MAPPED_A4_IF_NO_A6 5
64
65 #define DS_NOTIFICATION_KEY_GLOBAL "com.apple.system.DirectoryService.InvalidateCache"
66 #define DS_NOTIFICATION_KEY_USER "com.apple.system.DirectoryService.InvalidateCache.user"
67 #define DS_NOTIFICATION_KEY_GROUP "com.apple.system.DirectoryService.InvalidateCache.group"
68 #define DS_NOTIFICATION_KEY_HOST "com.apple.system.DirectoryService.InvalidateCache.host"
69 #define DS_NOTIFICATION_KEY_SERVICE "com.apple.system.DirectoryService.InvalidateCache.service"
70
71 #define MAX_LOOKUP_ATTEMPTS 10
72
73 #define INET_NTOP_AF_INET_OFFSET 4
74 #define INET_NTOP_AF_INET6_OFFSET 8
75
76 extern mach_port_t _ds_port;
77 extern int _ds_running();
78 extern uint32_t gL1CacheEnabled;
79
80 static pthread_key_t _ds_serv_cache_key = 0;
81
82 static void
83 _ds_serv_cache_free(void *x)
84 {
85 if (x != NULL) si_item_release(x);
86 }
87
88 __private_extern__ kern_return_t
89 libinfoDSmig_do_Response_async(mach_port_t server, char *reply, mach_msg_type_number_t replyCnt, vm_offset_t ooreply, mach_msg_type_number_t ooreplyCnt, mach_vm_address_t callbackAddr, security_token_t servertoken)
90 {
91 return KERN_SUCCESS;
92 }
93
94 __private_extern__ kern_return_t
95 LI_DSLookupGetProcedureNumber(const char *name, int32_t *procno)
96 {
97 kern_return_t status;
98 security_token_t token;
99 uint32_t n, len;
100
101 if (name == NULL) return KERN_FAILURE;
102
103 len = strlen(name) + 1;
104 if (len == 1) return KERN_FAILURE;
105
106 token.val[0] = -1;
107 token.val[1] = -1;
108
109 if (_ds_running() == 0) return KERN_FAILURE;
110 if (_ds_port == MACH_PORT_NULL) return KERN_FAILURE;
111
112 status = MIG_SERVER_DIED;
113 for (n = 0; (_ds_port != MACH_PORT_NULL) && (status == MIG_SERVER_DIED) && (n < MAX_LOOKUP_ATTEMPTS); n++)
114 {
115 status = libinfoDSmig_GetProcedureNumber(_ds_port, (char *)name, procno, &token);
116
117 if (status == MACH_SEND_INVALID_DEST)
118 {
119 mach_port_mod_refs(mach_task_self(), _ds_port, MACH_PORT_RIGHT_SEND, -1);
120 status = bootstrap_look_up(bootstrap_port, kDSStdMachDSLookupPortName, &_ds_port);
121 if ((status != BOOTSTRAP_SUCCESS) && (status != BOOTSTRAP_UNKNOWN_SERVICE)) _ds_port = MACH_PORT_NULL;
122 status = MIG_SERVER_DIED;
123 }
124 }
125
126 if (status != KERN_SUCCESS)
127 {
128 #ifdef DEBUG
129 asl_log(NULL, NULL, ASL_LEVEL_DEBUG, "_DSLookupGetProcedureNumber %s status %u", name, status);
130 #endif
131 return status;
132 }
133
134 if (token.val[0] != 0)
135 {
136 #ifdef DEBUG
137 asl_log(NULL, NULL, ASL_LEVEL_DEBUG, "_DSLookupGetProcedureNumber %s auth failure uid=%d", name, token.val[0]);
138 #endif
139 return KERN_FAILURE;
140 }
141
142 #ifdef DEBUG
143 asl_log(NULL, NULL, ASL_LEVEL_DEBUG, "_DSLookupGetProcedureNumber %s = %d", name, *procno);
144 #endif
145 return status;
146 }
147
148 __private_extern__ kern_return_t
149 LI_DSLookupQuery(int32_t procno, kvbuf_t *request, kvarray_t **reply)
150 {
151 kern_return_t status;
152 security_token_t token;
153 uint32_t n;
154 mach_msg_type_number_t illen, oolen;
155 char ilbuf[MAX_MIG_INLINE_DATA];
156 vm_offset_t oobuf;
157 kvbuf_t *out;
158
159 if (reply == NULL) return KERN_FAILURE;
160 if ((request != NULL) && ((request->databuf == NULL) || (request->datalen == 0))) return KERN_FAILURE;
161
162 token.val[0] = -1;
163 token.val[1] = -1;
164 *reply = NULL;
165
166 if (_ds_running() == 0) return KERN_FAILURE;
167 if (_ds_port == MACH_PORT_NULL) return KERN_FAILURE;
168
169 status = MIG_SERVER_DIED;
170 for (n = 0; (_ds_port != MACH_PORT_NULL) && (status == MIG_SERVER_DIED) && (n < MAX_LOOKUP_ATTEMPTS); n++)
171 {
172 illen = 0;
173 oolen = 0;
174 oobuf = 0;
175
176 if (request != NULL)
177 {
178 status = libinfoDSmig_Query(_ds_port, procno, request->databuf, request->datalen, ilbuf, &illen, &oobuf, &oolen, &token);
179 }
180 else
181 {
182 status = libinfoDSmig_Query(_ds_port, procno, "", 0, ilbuf, &illen, &oobuf, &oolen, &token);
183 }
184
185 if (status == MACH_SEND_INVALID_DEST)
186 {
187 mach_port_mod_refs(mach_task_self(), _ds_port, MACH_PORT_RIGHT_SEND, -1);
188 status = bootstrap_look_up(bootstrap_port, kDSStdMachDSLookupPortName, &_ds_port);
189 if ((status != BOOTSTRAP_SUCCESS) && (status != BOOTSTRAP_UNKNOWN_SERVICE)) _ds_port = MACH_PORT_NULL;
190 status = MIG_SERVER_DIED;
191 }
192 }
193
194 if (status != KERN_SUCCESS)
195 {
196 #ifdef DEBUG
197 asl_log(NULL, NULL, ASL_LEVEL_DEBUG, "_DSLookupQuery %d status %u", procno, status);
198 #endif
199 return status;
200 }
201
202 if (token.val[0] != 0)
203 {
204 #ifdef DEBUG
205 asl_log(NULL, NULL, ASL_LEVEL_DEBUG, "_DSLookupQuery %d auth failure uid=%d", procno, token.val[0]);
206 #endif
207 if (oolen > 0) vm_deallocate(mach_task_self(), (vm_address_t)oobuf, oolen);
208 return KERN_FAILURE;
209 }
210
211 out = (kvbuf_t *)calloc(1, sizeof(kvbuf_t));
212 if (out == NULL)
213 {
214 if (oolen > 0) vm_deallocate(mach_task_self(), (vm_address_t)oobuf, oolen);
215 return KERN_FAILURE;
216 }
217
218 if (oolen > 0)
219 {
220 out->datalen = oolen;
221 out->databuf = malloc(oolen);
222 if (out->databuf == NULL)
223 {
224 free(out);
225 *reply = NULL;
226 vm_deallocate(mach_task_self(), (vm_address_t)oobuf, oolen);
227 return KERN_FAILURE;
228 }
229
230 memcpy(out->databuf, (char *)oobuf, oolen);
231 vm_deallocate(mach_task_self(), (vm_address_t)oobuf, oolen);
232 }
233 else if (illen > 0)
234 {
235 out->datalen = illen;
236 out->databuf = malloc(illen);
237 if (out->databuf == NULL)
238 {
239 free(out);
240 *reply = NULL;
241 return KERN_FAILURE;
242 }
243
244 memcpy(out->databuf, ilbuf, illen);
245 }
246
247 *reply = kvbuf_decode(out);
248 if (*reply == NULL)
249 {
250 /* DS returned no data */
251 free(out->databuf);
252 free(out);
253 }
254
255 #ifdef DEBUG
256 asl_log(NULL, NULL, ASL_LEVEL_DEBUG, "_DSLookupQuery %d status OK", procno);
257 #endif
258 return status;
259 }
260
261 /* notify SPI */
262 uint32_t notify_peek(int token, uint32_t *val);
263
264 typedef struct
265 {
266 int notify_token_global;
267 int notify_token_user;
268 int notify_token_group;
269 int notify_token_host;
270 int notify_token_service;
271 } ds_si_private_t;
272
273 static uid_t
274 audit_token_uid(audit_token_t a)
275 {
276 /*
277 * This should really call audit_token_to_au32,
278 * but that's in libbsm, not in a Libsystem library.
279 */
280 return (uid_t)a.val[1];
281 }
282
283 static void
284 ds_get_validation(si_mod_t *si, uint64_t *a, uint64_t *b, int cat)
285 {
286 ds_si_private_t *pp;
287 uint32_t peek;
288 int status;
289
290 if (si == NULL) return;
291
292 pp = (ds_si_private_t *)si->private;
293 if (pp == NULL) return;
294
295 if (a != NULL)
296 {
297 *a = 0;
298 status = notify_peek(pp->notify_token_global, &peek);
299 if (status == NOTIFY_STATUS_OK) *a = ntohl(peek);
300 }
301
302 if (b != NULL)
303 {
304 *b = 0;
305 peek = 0;
306 status = NOTIFY_STATUS_FAILED;
307
308 if (cat == CATEGORY_USER) status = notify_peek(pp->notify_token_user, &peek);
309 else if (cat == CATEGORY_GROUP) status = notify_peek(pp->notify_token_group, &peek);
310 else if (cat == CATEGORY_GROUPLIST) status = notify_peek(pp->notify_token_group, &peek);
311 else if (cat == CATEGORY_HOST_IPV4) status = notify_peek(pp->notify_token_host, &peek);
312 else if (cat == CATEGORY_HOST_IPV6) status = notify_peek(pp->notify_token_host, &peek);
313 else if (cat == CATEGORY_SERVICE) status = notify_peek(pp->notify_token_service, &peek);
314
315 if (status == NOTIFY_STATUS_OK) *b = ntohl(peek);
316 }
317 }
318
319 static si_list_t *
320 ds_list(si_mod_t *si, int cat, const char *procname, int *procnum, void *extra, si_item_t *(*extract)(si_mod_t *, kvarray_t *, void *, uint64_t, uint64_t), kvbuf_t *request)
321 {
322 si_item_t *item;
323 si_list_t *list;
324 kvarray_t *reply;
325 kern_return_t status;
326 uint64_t va, vb;
327
328 if (*procnum < 0)
329 {
330 status = LI_DSLookupGetProcedureNumber(procname, procnum);
331 if (status != KERN_SUCCESS) return NULL;
332 }
333
334 reply = NULL;
335 ds_get_validation(si, &va, &vb, cat);
336 status = LI_DSLookupQuery(*procnum, request, &reply);
337
338 if ((status != KERN_SUCCESS) || (reply == NULL)) return NULL;
339
340 list = NULL;
341 while (reply->curr < reply->count)
342 {
343 item = extract(si, reply, extra, va, vb);
344 list = si_list_add(list, item);
345 si_item_release(item);
346 }
347
348 kvarray_free(reply);
349
350 return list;
351 }
352
353 static si_item_t *
354 ds_item(si_mod_t *si, int cat, const char *procname, int *procnum, void *extra, si_item_t *(*extract)(si_mod_t *, kvarray_t *, void *, uint64_t, uint64_t), kvbuf_t *request)
355 {
356 si_item_t *item;
357 kvarray_t *reply;
358 kern_return_t status;
359 uint64_t va, vb;
360
361 if (*procnum < 0)
362 {
363 status = LI_DSLookupGetProcedureNumber(procname, procnum);
364 if (status != KERN_SUCCESS) return NULL;
365 }
366
367 reply = NULL;
368 ds_get_validation(si, &va, &vb, cat);
369 status = LI_DSLookupQuery(*procnum, request, &reply);
370
371 if ((status != KERN_SUCCESS) || (reply == NULL)) return NULL;
372
373 item = extract(si, reply, extra, va, vb);
374 kvarray_free(reply);
375
376 return item;
377 }
378
379 /*
380 * Extract the next user entry from a kvarray.
381 */
382 static si_item_t *
383 extract_user(si_mod_t *si, kvarray_t *in, void *ignored, uint64_t valid_global, uint64_t valid_cat)
384 {
385 struct passwd tmp;
386 uint32_t d, k, kcount;
387
388 if (si == NULL) return NULL;
389 if (in == NULL) return NULL;
390
391 d = in->curr;
392 in->curr++;
393
394 if (d >= in->count) return NULL;
395
396 memset(&tmp, 0, sizeof(struct passwd));
397
398 tmp.pw_uid = -2;
399 tmp.pw_gid = -2;
400
401 kcount = in->dict[d].kcount;
402
403 for (k = 0; k < kcount; k++)
404 {
405 if (string_equal(in->dict[d].key[k], "pw_name"))
406 {
407 if (tmp.pw_name != NULL) continue;
408 if (in->dict[d].vcount[k] == 0) continue;
409
410 tmp.pw_name = (char *)in->dict[d].val[k][0];
411 }
412 else if (string_equal(in->dict[d].key[k], "pw_passwd"))
413 {
414 if (tmp.pw_passwd != NULL) continue;
415 if (in->dict[d].vcount[k] == 0) continue;
416
417 tmp.pw_passwd = (char *)in->dict[d].val[k][0];
418 }
419 else if (string_equal(in->dict[d].key[k], "pw_uid"))
420 {
421 if (in->dict[d].vcount[k] == 0) continue;
422 tmp.pw_uid = atoi(in->dict[d].val[k][0]);
423 }
424 else if (string_equal(in->dict[d].key[k], "pw_gid"))
425 {
426 if (in->dict[d].vcount[k] == 0) continue;
427 tmp.pw_gid = atoi(in->dict[d].val[k][0]);
428 }
429 else if (string_equal(in->dict[d].key[k], "pw_change"))
430 {
431 if (in->dict[d].vcount[k] == 0) continue;
432 tmp.pw_change = atol(in->dict[d].val[k][0]);
433 }
434 else if (string_equal(in->dict[d].key[k], "pw_expire"))
435 {
436 if (in->dict[d].vcount[k] == 0) continue;
437 tmp.pw_expire = atol(in->dict[d].val[k][0]);
438 }
439 else if (string_equal(in->dict[d].key[k], "pw_class"))
440 {
441 if (tmp.pw_class != NULL) continue;
442 if (in->dict[d].vcount[k] == 0) continue;
443
444 tmp.pw_class = (char *)in->dict[d].val[k][0];
445 }
446 else if (string_equal(in->dict[d].key[k], "pw_gecos"))
447 {
448 if (tmp.pw_gecos != NULL) continue;
449 if (in->dict[d].vcount[k] == 0) continue;
450
451 tmp.pw_gecos = (char *)in->dict[d].val[k][0];
452 }
453 else if (string_equal(in->dict[d].key[k], "pw_dir"))
454 {
455 if (tmp.pw_dir != NULL) continue;
456 if (in->dict[d].vcount[k] == 0) continue;
457
458 tmp.pw_dir = (char *)in->dict[d].val[k][0];
459 }
460 else if (string_equal(in->dict[d].key[k], "pw_shell"))
461 {
462 if (tmp.pw_shell != NULL) continue;
463 if (in->dict[d].vcount[k] == 0) continue;
464
465 tmp.pw_shell = (char *)in->dict[d].val[k][0];
466 }
467 }
468
469 if (tmp.pw_name == NULL) tmp.pw_name = "";
470 if (tmp.pw_passwd == NULL) tmp.pw_passwd = "";
471 if (tmp.pw_class == NULL) tmp.pw_class = "";
472 if (tmp.pw_gecos == NULL) tmp.pw_gecos = "";
473 if (tmp.pw_dir == NULL) tmp.pw_dir = "";
474 if (tmp.pw_shell == NULL) tmp.pw_shell = "";
475
476 return (si_item_t *)LI_ils_create("L4488ss44LssssL", (unsigned long)si, CATEGORY_USER, 1, valid_global, valid_cat, tmp.pw_name, tmp.pw_passwd, tmp.pw_uid, tmp.pw_gid, tmp.pw_change, tmp.pw_class, tmp.pw_gecos, tmp.pw_dir, tmp.pw_shell, tmp.pw_expire);
477 }
478
479 static si_item_t *
480 extract_group(si_mod_t *si, kvarray_t *in, void *ignored, uint64_t valid_global, uint64_t valid_cat)
481 {
482 struct group tmp;
483 char *empty[1];
484 uint32_t d, k, kcount;
485
486 if (si == NULL) return NULL;
487 if (in == NULL) return NULL;
488
489 d = in->curr;
490 in->curr++;
491
492 if (d >= in->count) return NULL;
493
494 empty[0] = NULL;
495 memset(&tmp, 0, sizeof(struct group));
496
497 tmp.gr_gid = -2;
498
499 kcount = in->dict[d].kcount;
500
501 for (k = 0; k < kcount; k++)
502 {
503 if (string_equal(in->dict[d].key[k], "gr_name"))
504 {
505 if (tmp.gr_name != NULL) continue;
506 if (in->dict[d].vcount[k] == 0) continue;
507
508 tmp.gr_name = (char *)in->dict[d].val[k][0];
509 }
510 else if (string_equal(in->dict[d].key[k], "gr_passwd"))
511 {
512 if (tmp.gr_passwd != NULL) continue;
513 if (in->dict[d].vcount[k] == 0) continue;
514
515 tmp.gr_passwd = (char *)in->dict[d].val[k][0];
516 }
517 else if (string_equal(in->dict[d].key[k], "gr_gid"))
518 {
519 if (in->dict[d].vcount[k] == 0) continue;
520 tmp.gr_gid = atoi(in->dict[d].val[k][0]);
521 }
522 else if (string_equal(in->dict[d].key[k], "gr_mem"))
523 {
524 if (tmp.gr_mem != NULL) continue;
525 if (in->dict[d].vcount[k] == 0) continue;
526
527 tmp.gr_mem = (char **)in->dict[d].val[k];
528 }
529 }
530
531 if (tmp.gr_name == NULL) tmp.gr_name = "";
532 if (tmp.gr_passwd == NULL) tmp.gr_passwd = "";
533 if (tmp.gr_mem == NULL) tmp.gr_mem = empty;
534
535 return (si_item_t *)LI_ils_create("L4488ss4*", (unsigned long)si, CATEGORY_GROUP, 1, valid_global, valid_cat, tmp.gr_name, tmp.gr_passwd, tmp.gr_gid, tmp.gr_mem);
536 }
537
538 static void
539 _free_addr_list(char **l)
540 {
541 int i;
542
543 if (l == NULL) return;
544 for (i = 0; l[i] != NULL; i++) free(l[i]);
545 free(l);
546 }
547
548 /* map ipv4 addresses and append to v6 list */
549 static int
550 _map_v4(char ***v6, uint32_t n6, char **v4, uint32_t n4)
551 {
552 struct in6_addr a6;
553 uint32_t i;
554
555 a6.__u6_addr.__u6_addr32[0] = 0x00000000;
556 a6.__u6_addr.__u6_addr32[1] = 0x00000000;
557 a6.__u6_addr.__u6_addr32[2] = htonl(0x0000ffff);
558
559 if (*v6 == NULL)
560 {
561 *v6 = (char **)calloc(n4 + 1, sizeof(char *));
562 }
563 else
564 {
565 *v6 = (char **)reallocf(*v6, (n6 + n4 + 1) * sizeof(char *));
566 }
567
568 if (*v6 == NULL) return -1;
569
570 for (i = 0; i < n4; i++)
571 {
572 (*v6)[n6] = (char *)calloc(1, IPV6_ADDR_LEN);
573 if ((*v6)[n6] == NULL) return -1;
574
575 memcpy(&(a6.__u6_addr.__u6_addr32[3]), v4[i], IPV4_ADDR_LEN);
576 memcpy((*v6)[n6], &(a6.__u6_addr.__u6_addr32[0]), IPV6_ADDR_LEN);
577
578 n6++;
579 }
580
581 return 0;
582 }
583
584 static si_item_t *
585 extract_netgroup(si_mod_t *si, kvarray_t *in, void *ignored, uint64_t valid_global, uint64_t valid_cat)
586 {
587 const char *host, *user, *domain;
588 uint32_t d, k, kcount;
589
590 if (si == NULL) return NULL;
591 if (in == NULL) return NULL;
592
593 d = in->curr;
594 in->curr++;
595
596 if (d >= in->count) return NULL;
597
598 kcount = in->dict[d].kcount;
599
600 host = NULL;
601 user = NULL;
602 domain = NULL;
603
604 for (k = 0; k < kcount; k++)
605 {
606 if (string_equal(in->dict[d].key[k], "host"))
607 {
608 if (host != NULL) continue;
609 if (in->dict[d].vcount[k] == 0) continue;
610
611 host = (char *)in->dict[d].val[k][0];
612 }
613 else if (string_equal(in->dict[d].key[k], "user"))
614 {
615 if (user != NULL) continue;
616 if (in->dict[d].vcount[k] == 0) continue;
617
618 user = (char *)in->dict[d].val[k][0];
619 }
620 else if (string_equal(in->dict[d].key[k], "domain"))
621 {
622 if (domain != NULL) continue;
623 if (in->dict[d].vcount[k] == 0) continue;
624
625 domain = (char *)in->dict[d].val[k][0];
626 }
627 }
628
629 if (host == NULL) host = "";
630 if (user == NULL) user = "";
631 if (domain == NULL) domain = "";
632
633 return (si_item_t *)LI_ils_create("L4488sss", (unsigned long)si, CATEGORY_ALIAS, 1, valid_global, valid_cat, host, user, domain);
634 }
635
636 static si_item_t *
637 extract_alias(si_mod_t *si, kvarray_t *in, void *ignored, uint64_t valid_global, uint64_t valid_cat)
638 {
639 struct aliasent tmp;
640 char *empty[1];
641 uint32_t d, k, kcount;
642
643 if (si == NULL) return NULL;
644 if (in == NULL) return NULL;
645
646 d = in->curr;
647 in->curr++;
648
649 if (d >= in->count) return NULL;
650
651 empty[0] = NULL;
652 memset(&tmp, 0, sizeof(struct group));
653
654 kcount = in->dict[d].kcount;
655
656 for (k = 0; k < kcount; k++)
657 {
658 if (string_equal(in->dict[d].key[k], "alias_name"))
659 {
660 if (tmp.alias_name != NULL) continue;
661 if (in->dict[d].vcount[k] == 0) continue;
662
663 tmp.alias_name = (char *)in->dict[d].val[k][0];
664 }
665 else if (string_equal(in->dict[d].key[k], "alias_members"))
666 {
667 if (tmp.alias_members != NULL) continue;
668 if (in->dict[d].vcount[k] == 0) continue;
669
670 tmp.alias_members_len = in->dict[d].vcount[k];
671 tmp.alias_members = (char **)in->dict[d].val[k];
672 }
673 else if (string_equal(in->dict[d].key[k], "alias_local"))
674 {
675 if (in->dict[d].vcount[k] == 0) continue;
676 tmp.alias_local = atoi(in->dict[d].val[k][0]);
677 }
678 }
679
680 return (si_item_t *)LI_ils_create("L4488s4*4", (unsigned long)si, CATEGORY_ALIAS, 1, valid_global, valid_cat, tmp.alias_name, tmp.alias_members_len, tmp.alias_members, tmp.alias_local);
681 }
682
683 static si_item_t *
684 extract_host(si_mod_t *si, kvarray_t *in, void *extra, uint64_t valid_global, uint64_t valid_cat)
685 {
686 struct hostent tmp;
687 si_item_t *out;
688 uint32_t i, d, k, kcount, vcount, v4count, v6count, want;
689 int status, addr_len;
690 int family, addr_count;
691 struct in_addr a4;
692 struct in6_addr a6;
693 char **v4addrs, **v6addrs;
694 char *empty[1];
695
696 v4addrs = NULL;
697 v6addrs = NULL;
698 v4count = 0;
699 v6count = 0;
700 addr_count = 0;
701 addr_len = sizeof(void *);
702
703 if (si == NULL) return NULL;
704 if (in == NULL) return NULL;
705
706 d = in->curr;
707 in->curr++;
708
709 if (d >= in->count) return NULL;
710
711 empty[0] = NULL;
712 memset(&tmp, 0, sizeof(struct hostent));
713
714 family = AF_INET;
715 tmp.h_length = IPV4_ADDR_LEN;
716
717 want = WANT_A4_ONLY;
718 if (extra != NULL) want = *(uint32_t *)extra;
719
720 if (want != WANT_A4_ONLY)
721 {
722 family = AF_INET6;
723 tmp.h_length = IPV6_ADDR_LEN;
724 }
725
726 tmp.h_addrtype = family;
727
728 kcount = in->dict[d].kcount;
729
730 for (k = 0; k < kcount; k++)
731 {
732 if (string_equal(in->dict[d].key[k], "h_name"))
733 {
734 if (tmp.h_name != NULL) continue;
735
736 vcount = in->dict[d].vcount[k];
737 if (vcount == 0) continue;
738
739 tmp.h_name = (char *)in->dict[d].val[k][0];
740 }
741 else if (string_equal(in->dict[d].key[k], "h_aliases"))
742 {
743 if (tmp.h_aliases != NULL) continue;
744
745 vcount = in->dict[d].vcount[k];
746 if (vcount == 0) continue;
747
748 tmp.h_aliases = (char **)in->dict[d].val[k];
749 }
750 else if (string_equal(in->dict[d].key[k], "h_ipv4_addr_list"))
751 {
752 if (v4addrs != NULL) continue;
753
754 v4count = in->dict[d].vcount[k];
755 if (v4count == 0) continue;
756
757 v4addrs = (char **)calloc(v4count + 1, sizeof(char *));
758 if (v4addrs == NULL)
759 {
760 _free_addr_list(v6addrs);
761 return NULL;
762 }
763
764 for (i = 0; i < v4count; i++)
765 {
766 v4addrs[i] = calloc(1, IPV4_ADDR_LEN);
767 if (v4addrs[i] == NULL)
768 {
769 _free_addr_list(v4addrs);
770 _free_addr_list(v6addrs);
771 return NULL;
772 }
773
774 memset(&a4, 0, sizeof(struct in_addr));
775 status = inet_pton(AF_INET, in->dict[d].val[k][i], &a4);
776 if (status != 1)
777 {
778 _free_addr_list(v4addrs);
779 _free_addr_list(v6addrs);
780 return NULL;
781 }
782
783 memcpy(v4addrs[i], &a4, IPV4_ADDR_LEN);
784 }
785 }
786 else if (string_equal(in->dict[d].key[k], "h_ipv6_addr_list"))
787 {
788 if (v6addrs != NULL) continue;
789
790 v6count = in->dict[d].vcount[k];
791 if (v6count == 0) continue;
792
793 v6addrs = (char **)calloc(v6count + 1, sizeof(char *));
794 if (v6addrs == NULL)
795 {
796 _free_addr_list(v4addrs);
797 return NULL;
798 }
799
800 for (i = 0; i < v6count; i++)
801 {
802 v6addrs[i] = calloc(1, IPV6_ADDR_LEN);
803 if (v6addrs[i] == NULL)
804 {
805 _free_addr_list(v4addrs);
806 _free_addr_list(v6addrs);
807 return NULL;
808 }
809
810 memset(&a6, 0, sizeof(struct in6_addr));
811 status = inet_pton(AF_INET6, in->dict[d].val[k][i], &a6);
812 if (status != 1)
813 {
814 _free_addr_list(v4addrs);
815 _free_addr_list(v6addrs);
816 return NULL;
817 }
818
819 memcpy(v6addrs[i], &(a6.__u6_addr.__u6_addr32[0]), IPV6_ADDR_LEN);
820 }
821 }
822 }
823
824 if (tmp.h_name == NULL) tmp.h_name = "";
825 if (tmp.h_aliases == NULL) tmp.h_aliases = empty;
826
827 if (want == WANT_A4_ONLY)
828 {
829 _free_addr_list(v6addrs);
830 if (v4addrs == NULL) return NULL;
831
832 tmp.h_addr_list = v4addrs;
833 out = (si_item_t *)LI_ils_create("L4488s*44a", (unsigned long)si, CATEGORY_HOST_IPV4, 1, valid_global, valid_cat, tmp.h_name, tmp.h_aliases, tmp.h_addrtype, tmp.h_length, tmp.h_addr_list);
834 _free_addr_list(v4addrs);
835 return out;
836 }
837 else if ((want == WANT_A6_ONLY) || ((want == WANT_A6_OR_MAPPED_A4_IF_NO_A6) && (v6count > 0)))
838 {
839 _free_addr_list(v4addrs);
840 if (v6addrs == NULL) return NULL;
841
842 tmp.h_addr_list = v6addrs;
843 out = (si_item_t *)LI_ils_create("L4488s*44c", (unsigned long)si, CATEGORY_HOST_IPV6, 1, valid_global, valid_cat, tmp.h_name, tmp.h_aliases, tmp.h_addrtype, tmp.h_length, tmp.h_addr_list);
844 _free_addr_list(v6addrs);
845 return out;
846 }
847
848 /*
849 * At this point, want is WANT_A6_PLUS_MAPPED_A4, WANT_MAPPED_A4_ONLY,
850 * or WANT_A6_OR_MAPPED_A4_IF_NO_A6. In the last case, there are no ipv6
851 * addresses, so that case degenerates into WANT_MAPPED_A4_ONLY.
852 */
853 if (want == WANT_A6_OR_MAPPED_A4_IF_NO_A6) want = WANT_MAPPED_A4_ONLY;
854
855 if (want == WANT_MAPPED_A4_ONLY)
856 {
857 _free_addr_list(v6addrs);
858 v6addrs = NULL;
859 v6count = 0;
860 }
861
862 status = _map_v4(&v6addrs, v6count, v4addrs, v4count);
863 _free_addr_list(v4addrs);
864 if (status != 0)
865 {
866 _free_addr_list(v6addrs);
867 return NULL;
868 }
869
870 if (v6addrs == NULL) return NULL;
871
872 tmp.h_addr_list = v6addrs;
873 out = (si_item_t *)LI_ils_create("L4488s*44c", (unsigned long)si, CATEGORY_HOST_IPV6, 1, valid_global, valid_cat, tmp.h_name, tmp.h_aliases, tmp.h_addrtype, tmp.h_length, tmp.h_addr_list);
874 _free_addr_list(v6addrs);
875 return out;
876 }
877
878 static si_item_t *
879 extract_network(si_mod_t *si, kvarray_t *in, void *ignored, uint64_t valid_global, uint64_t valid_cat)
880 {
881 struct netent tmp;
882 uint32_t d, k, kcount;
883 char *empty[1];
884
885 if (si == NULL) return NULL;
886 if (in == NULL) return NULL;
887
888 d = in->curr;
889 in->curr++;
890
891 if (d >= in->count) return NULL;
892
893 empty[0] = NULL;
894 memset(&tmp, 0, sizeof(struct netent));
895
896 tmp.n_addrtype = AF_INET;
897
898 kcount = in->dict[d].kcount;
899
900 for (k = 0; k < kcount; k++)
901 {
902 if (string_equal(in->dict[d].key[k], "n_name"))
903 {
904 if (tmp.n_name != NULL) continue;
905 if (in->dict[d].vcount[k] == 0) continue;
906
907 tmp.n_name = (char *)in->dict[d].val[k][0];
908 }
909 else if (string_equal(in->dict[d].key[k], "n_net"))
910 {
911 if (in->dict[d].vcount[k] == 0) continue;
912 tmp.n_net = inet_network(in->dict[d].val[k][0]);
913 }
914 else if (string_equal(in->dict[d].key[k], "n_addrtype"))
915 {
916 if (in->dict[d].vcount[k] == 0) continue;
917 tmp.n_addrtype = atoi(in->dict[d].val[k][0]);
918 }
919 else if (string_equal(in->dict[d].key[k], "n_aliases"))
920 {
921 if (tmp.n_aliases != NULL) continue;
922 if (in->dict[d].vcount[k] == 0) continue;
923
924 tmp.n_aliases = (char **)in->dict[d].val[k];
925 }
926 }
927
928 if (tmp.n_name == NULL) tmp.n_name = "";
929 if (tmp.n_aliases == NULL) tmp.n_aliases = empty;
930
931 return (si_item_t *)LI_ils_create("L4488s*44", (unsigned long)si, CATEGORY_NETWORK, 1, valid_global, valid_cat, tmp.n_name, tmp.n_aliases, tmp.n_addrtype, tmp.n_net);
932 }
933
934 static si_item_t *
935 extract_service(si_mod_t *si, kvarray_t *in, void *ignored, uint64_t valid_global, uint64_t valid_cat)
936 {
937 struct servent tmp;
938 char *empty[1];
939 uint32_t d, k, kcount;
940
941 if (si == NULL) return NULL;
942 if (in == NULL) return NULL;
943
944 d = in->curr;
945 in->curr++;
946
947 if (d >= in->count) return NULL;
948
949 empty[0] = NULL;
950 memset(&tmp, 0, sizeof(struct servent));
951
952 kcount = in->dict[d].kcount;
953
954 for (k = 0; k < kcount; k++)
955 {
956 if (string_equal(in->dict[d].key[k], "s_name"))
957 {
958 if (tmp.s_name != NULL) continue;
959 if (in->dict[d].vcount[k] == 0) continue;
960
961 tmp.s_name = (char *)in->dict[d].val[k][0];
962 }
963 else if (string_equal(in->dict[d].key[k], "s_aliases"))
964 {
965 if (tmp.s_aliases != NULL) continue;
966 if (in->dict[d].vcount[k] == 0) continue;
967
968 tmp.s_aliases = (char **)in->dict[d].val[k];
969 }
970 else if (string_equal(in->dict[d].key[k], "s_port"))
971 {
972 if (in->dict[d].vcount[k] == 0) continue;
973 tmp.s_port = atoi(in->dict[d].val[k][0]);
974 }
975 else if (string_equal(in->dict[d].key[k], "s_proto"))
976 {
977 if (tmp.s_proto != NULL) continue;
978 if (in->dict[d].vcount[k] == 0) continue;
979
980 tmp.s_proto = (char *)in->dict[d].val[k][0];
981 }
982 }
983
984 if (tmp.s_name == NULL) tmp.s_name = "";
985 if (tmp.s_proto == NULL) tmp.s_proto = "";
986 if (tmp.s_aliases == NULL) tmp.s_aliases = empty;
987
988 /* strange but correct */
989 tmp.s_port = htons(tmp.s_port);
990
991 return (si_item_t *)LI_ils_create("L4488s*4s", (unsigned long)si, CATEGORY_SERVICE, 1, valid_global, valid_cat, tmp.s_name, tmp.s_aliases, tmp.s_port, tmp.s_proto);
992 }
993
994 static si_item_t *
995 extract_protocol(si_mod_t *si, kvarray_t *in, void *ignored, uint64_t valid_global, uint64_t valid_cat)
996 {
997 struct protoent tmp;
998 uint32_t d, k, kcount;
999 char *empty[1];
1000
1001 if (si == NULL) return NULL;
1002 if (in == NULL) return NULL;
1003
1004 d = in->curr;
1005 in->curr++;
1006
1007 if (d >= in->count) return NULL;
1008
1009 empty[0] = NULL;
1010 memset(&tmp, 0, sizeof(struct protoent));
1011
1012 kcount = in->dict[d].kcount;
1013
1014 for (k = 0; k < kcount; k++)
1015 {
1016 if (string_equal(in->dict[d].key[k], "p_name"))
1017 {
1018 if (tmp.p_name != NULL) continue;
1019 if (in->dict[d].vcount[k] == 0) continue;
1020
1021 tmp.p_name = (char *)in->dict[d].val[k][0];
1022 }
1023 else if (string_equal(in->dict[d].key[k], "p_proto"))
1024 {
1025 if (in->dict[d].vcount[k] == 0) continue;
1026 tmp.p_proto = atoi(in->dict[d].val[k][0]);
1027 }
1028 else if (string_equal(in->dict[d].key[k], "p_aliases"))
1029 {
1030 if (tmp.p_aliases != NULL) continue;
1031 if (in->dict[d].vcount[k] == 0) continue;
1032
1033 tmp.p_aliases = (char **)in->dict[d].val[k];
1034 }
1035 }
1036
1037 if (tmp.p_name == NULL) tmp.p_name = "";
1038 if (tmp.p_aliases == NULL) tmp.p_aliases = empty;
1039
1040 return (si_item_t *)LI_ils_create("L4488s*4", (unsigned long)si, CATEGORY_PROTOCOL, 1, valid_global, valid_cat, tmp.p_name, tmp.p_aliases, tmp.p_proto);
1041 }
1042
1043 static si_item_t *
1044 extract_rpc(si_mod_t *si, kvarray_t *in, void *ignored, uint64_t valid_global, uint64_t valid_cat)
1045 {
1046 struct rpcent tmp;
1047 uint32_t d, k, kcount;
1048 char *empty[1];
1049
1050 if (si == NULL) return NULL;
1051 if (in == NULL) return NULL;
1052
1053 d = in->curr;
1054 in->curr++;
1055
1056 if (d >= in->count) return NULL;
1057
1058 empty[0] = NULL;
1059 memset(&tmp, 0, sizeof(struct rpcent));
1060
1061 kcount = in->dict[d].kcount;
1062
1063 for (k = 0; k < kcount; k++)
1064 {
1065 if (string_equal(in->dict[d].key[k], "r_name"))
1066 {
1067 if (tmp.r_name != NULL) continue;
1068 if (in->dict[d].vcount[k] == 0) continue;
1069
1070 tmp.r_name = (char *)in->dict[d].val[k][0];
1071 }
1072 else if (string_equal(in->dict[d].key[k], "r_number"))
1073 {
1074 if (in->dict[d].vcount[k] == 0) continue;
1075 tmp.r_number = atoi(in->dict[d].val[k][0]);
1076 }
1077 else if (string_equal(in->dict[d].key[k], "r_aliases"))
1078 {
1079 if (tmp.r_aliases != NULL) continue;
1080 if (in->dict[d].vcount[k] == 0) continue;
1081
1082 tmp.r_aliases = (char **)in->dict[d].val[k];
1083 }
1084 }
1085
1086 if (tmp.r_name == NULL) tmp.r_name = "";
1087 if (tmp.r_aliases == NULL) tmp.r_aliases = empty;
1088
1089 return (si_item_t *)LI_ils_create("L4488s*4", (unsigned long)si, CATEGORY_RPC, 1, valid_global, valid_cat, tmp.r_name, tmp.r_aliases, tmp.r_number);
1090 }
1091
1092 static si_item_t *
1093 extract_fstab(si_mod_t *si, kvarray_t *in, void *extra, uint64_t valid_global, uint64_t valid_cat)
1094 {
1095 struct fstab tmp;
1096 uint32_t d, k, kcount;
1097 char *file;
1098
1099 if (si == NULL) return NULL;
1100 if (in == NULL) return NULL;
1101
1102 file = NULL;
1103 if (extra != NULL) file = (char *)extra;
1104
1105 d = in->curr;
1106 in->curr++;
1107
1108 if (d >= in->count) return NULL;
1109
1110 memset(&tmp, 0, sizeof(struct fstab));
1111
1112 kcount = in->dict[d].kcount;
1113
1114 for (k = 0; k < kcount; k++)
1115 {
1116 if (string_equal(in->dict[d].key[k], "fs_spec"))
1117 {
1118 if (tmp.fs_spec != NULL) continue;
1119 if (in->dict[d].vcount[k] == 0) continue;
1120
1121 tmp.fs_spec = (char *)in->dict[d].val[k][0];
1122 }
1123 else if (string_equal(in->dict[d].key[k], "fs_file"))
1124 {
1125 if (tmp.fs_file != NULL) continue;
1126 if (in->dict[d].vcount[k] == 0) continue;
1127
1128 tmp.fs_file = (char *)in->dict[d].val[k][0];
1129 }
1130 else if (string_equal(in->dict[d].key[k], "fs_vfstype"))
1131 {
1132 if (tmp.fs_vfstype != NULL) continue;
1133 if (in->dict[d].vcount[k] == 0) continue;
1134
1135 tmp.fs_vfstype = (char *)in->dict[d].val[k][0];
1136 }
1137 else if (string_equal(in->dict[d].key[k], "fs_mntops"))
1138 {
1139 if (tmp.fs_mntops != NULL) continue;
1140 if (in->dict[d].vcount[k] == 0) continue;
1141
1142 tmp.fs_mntops = (char *)in->dict[d].val[k][0];
1143 }
1144 else if (string_equal(in->dict[d].key[k], "fs_type"))
1145 {
1146 if (tmp.fs_type != NULL) continue;
1147 if (in->dict[d].vcount[k] == 0) continue;
1148
1149 tmp.fs_type = (char *)in->dict[d].val[k][0];
1150 }
1151 else if (string_equal(in->dict[d].key[k], "fs_freq"))
1152 {
1153 if (in->dict[d].vcount[k] == 0) continue;
1154 tmp.fs_freq = atoi(in->dict[d].val[k][0]);
1155 }
1156 else if (string_equal(in->dict[d].key[k], "fs_passno"))
1157 {
1158 if (in->dict[d].vcount[k] == 0) continue;
1159 tmp.fs_passno = atoi(in->dict[d].val[k][0]);
1160 }
1161 }
1162
1163 if (tmp.fs_spec == NULL) tmp.fs_spec = "";
1164 if (tmp.fs_file == NULL) tmp.fs_file = "";
1165 if (tmp.fs_vfstype == NULL) tmp.fs_vfstype = "";
1166 if (tmp.fs_mntops == NULL) tmp.fs_mntops = "";
1167 if (tmp.fs_type == NULL) tmp.fs_type = "";
1168
1169 if ((file != NULL) && string_not_equal(file, tmp.fs_file)) return NULL;
1170
1171 return (si_item_t *)LI_ils_create("L4488sssss44", (unsigned long)si, CATEGORY_FS, 1, valid_global, valid_cat, tmp.fs_spec, tmp.fs_file, tmp.fs_vfstype, tmp.fs_mntops, tmp.fs_type, tmp.fs_freq, tmp.fs_passno);
1172 }
1173
1174 static si_item_t *
1175 extract_mac_mac(si_mod_t *si, kvarray_t *in, void *extra, uint64_t valid_global, uint64_t valid_cat)
1176 {
1177 uint32_t d, k, kcount;
1178 char *cmac;
1179 si_item_t *out;
1180
1181 if (si == NULL) return NULL;
1182 if (in == NULL) return NULL;
1183 if (extra == NULL) return NULL;
1184
1185 d = in->curr;
1186 in->curr++;
1187
1188 if (d >= in->count) return NULL;
1189
1190 kcount = in->dict[d].kcount;
1191
1192 cmac = NULL;
1193 for (k = 0; k < kcount; k++)
1194 {
1195 if ((cmac == NULL) && (string_equal(in->dict[d].key[k], "mac")))
1196 {
1197 if (in->dict[d].vcount[k] == 0) continue;
1198 cmac = si_canonical_mac_address(in->dict[d].val[k][0]);
1199 if (cmac == NULL) return NULL;
1200 }
1201 }
1202
1203 if (cmac == NULL) return NULL;
1204
1205 out = (si_item_t *)LI_ils_create("L4488ss", (unsigned long)si, CATEGORY_MAC, 1, valid_global, valid_cat, extra, cmac);
1206 free(cmac);
1207 return out;
1208 }
1209
1210 static si_item_t *
1211 extract_mac_name(si_mod_t *si, kvarray_t *in, void *extra, uint64_t valid_global, uint64_t valid_cat)
1212 {
1213 uint32_t d, k, kcount;
1214 const char *name;
1215 si_item_t *out;
1216
1217 if (si == NULL) return NULL;
1218 if (in == NULL) return NULL;
1219 if (extra == NULL) return NULL;
1220
1221 d = in->curr;
1222 in->curr++;
1223
1224 if (d >= in->count) return NULL;
1225
1226 kcount = in->dict[d].kcount;
1227
1228 name = NULL;
1229 for (k = 0; k < kcount; k++)
1230 {
1231 if ((name == NULL) && (string_equal(in->dict[d].key[k], "name")))
1232 {
1233 if (in->dict[d].vcount[k] == 0) continue;
1234 name = in->dict[d].val[k][0];
1235 }
1236 }
1237
1238 if (name == NULL) return NULL;
1239
1240 out = (si_item_t *)LI_ils_create("L4488ss", (unsigned long)si, CATEGORY_MAC, 1, valid_global, valid_cat, name, extra);
1241 return out;
1242 }
1243
1244 __private_extern__ si_item_t *
1245 ds_user_byname(si_mod_t *si, const char *name)
1246 {
1247 static int proc = -1;
1248 kvbuf_t *request;
1249 si_item_t *item;
1250
1251 request = kvbuf_query_key_val("login", name);
1252 if (request == NULL) return NULL;
1253
1254 item = ds_item(si, CATEGORY_USER, "getpwnam", &proc, NULL, extract_user, request);
1255
1256 kvbuf_free(request);
1257 return item;
1258 }
1259
1260 __private_extern__ si_item_t *
1261 ds_user_byuid(si_mod_t *si, uid_t uid)
1262 {
1263 static int proc = -1;
1264 char val[16];
1265 kvbuf_t *request;
1266 si_item_t *item;
1267
1268 snprintf(val, sizeof(val), "%d", (int)uid);
1269 request = kvbuf_query_key_val("uid", val);
1270 if (request == NULL) return NULL;
1271
1272 item = ds_item(si, CATEGORY_USER, "getpwuid", &proc, NULL, extract_user, request);
1273
1274 kvbuf_free(request);
1275 return item;
1276 }
1277
1278 __private_extern__ si_list_t *
1279 ds_user_all(si_mod_t *si)
1280 {
1281 static int proc = -1;
1282
1283 return ds_list(si, CATEGORY_USER, "getpwent", &proc, NULL, extract_user, NULL);
1284 }
1285
1286 __private_extern__ si_item_t *
1287 ds_group_byname(si_mod_t *si, const char *name)
1288 {
1289 static int proc = -1;
1290 kvbuf_t *request;
1291 si_item_t *item;
1292
1293 request = kvbuf_query_key_val("name", name);
1294 if (request == NULL) return NULL;
1295
1296 item = ds_item(si, CATEGORY_GROUP, "getgrnam", &proc, NULL, extract_group, request);
1297
1298 kvbuf_free(request);
1299 return item;
1300 }
1301
1302 __private_extern__ si_item_t *
1303 ds_group_bygid(si_mod_t *si, gid_t gid)
1304 {
1305 static int proc = -1;
1306 char val[16];
1307 kvbuf_t *request;
1308 si_item_t *item;
1309
1310 snprintf(val, sizeof(val), "%d", (int)gid);
1311 request = kvbuf_query_key_val("gid", val);
1312 if (request == NULL) return NULL;
1313
1314 item = ds_item(si, CATEGORY_GROUP, "getgrgid", &proc, NULL, extract_group, request);
1315
1316 kvbuf_free(request);
1317 return item;
1318 }
1319
1320 __private_extern__ si_list_t *
1321 ds_group_all(si_mod_t *si)
1322 {
1323 static int proc = -1;
1324
1325 return ds_list(si, CATEGORY_GROUP, "getgrent", &proc, NULL, extract_group, NULL);
1326 }
1327
1328 __private_extern__ si_item_t *
1329 ds_grouplist(si_mod_t *si, const char *name)
1330 {
1331 struct passwd *pw;
1332 kern_return_t kstatus;
1333 uint32_t i, j, count, uid, basegid, gidptrCnt;
1334 int32_t *gidp;
1335 gid_t *gidptr;
1336 audit_token_t token;
1337 si_item_t *user, *item;
1338 char **gidlist;
1339 uint64_t va, vb;
1340 size_t gidptrsz;
1341
1342 if (name == NULL) return NULL;
1343
1344 user = ds_user_byname(si, name);
1345 if (user == NULL) return NULL;
1346
1347 pw = (struct passwd *)((uintptr_t)user + sizeof(si_item_t));
1348 uid = pw->pw_uid;
1349 basegid = pw->pw_gid;
1350
1351 free(user);
1352
1353 count = 0;
1354 gidptr = NULL;
1355 gidptrCnt = 0;
1356 gidptrsz = 0;
1357 memset(&token, 0, sizeof(audit_token_t));
1358
1359 kstatus = memberdDSmig_GetAllGroups(_ds_port, uid, &count, &gidptr, &gidptrCnt, &token);
1360 if (kstatus != KERN_SUCCESS) return NULL;
1361
1362 gidptrsz = gidptrCnt * sizeof(gid_t);
1363
1364 if ((audit_token_uid(token) != 0) || (count == 0))
1365 {
1366 if (gidptr != NULL) vm_deallocate(mach_task_self(), (vm_address_t)gidptr, gidptrsz);
1367 return NULL;
1368 }
1369
1370 gidlist = (char **)calloc(count + 1, sizeof(char *));
1371 if (gidlist == NULL)
1372 {
1373 if (gidptr != NULL) vm_deallocate(mach_task_self(), (vm_address_t)gidptr, gidptrsz);
1374 return NULL;
1375 }
1376
1377 for (i = 0; i < count; i++)
1378 {
1379 gidp = (int32_t *)calloc(1, sizeof(int32_t));
1380 if (gidp == NULL)
1381 {
1382 for (j = 0; j < i; j++) free(gidlist[j]);
1383 free(gidlist);
1384 count = 0;
1385 break;
1386 }
1387
1388 *gidp = gidptr[i];
1389 gidlist[i] = (char *)gidp;
1390 }
1391
1392 if (count == 0)
1393 {
1394 if (gidptr != NULL) vm_deallocate(mach_task_self(), (vm_address_t)gidptr, gidptrsz);
1395 return NULL;
1396 }
1397
1398 va = 0;
1399 vb = 0;
1400 ds_get_validation(si, &va, &vb, CATEGORY_GROUPLIST);
1401
1402 item = (si_item_t *)LI_ils_create("L4488s44a", (unsigned long)si, CATEGORY_GROUPLIST, 1, va, vb, name, basegid, count, gidlist);
1403
1404 if (gidptr != NULL) vm_deallocate(mach_task_self(), (vm_address_t)gidptr, gidptrsz);
1405
1406 for (i = 0; i <= count; i++) free(gidlist[i]);
1407 free(gidlist);
1408
1409 return item;
1410 }
1411
1412 __private_extern__ si_list_t *
1413 ds_netgroup_byname(si_mod_t *si, const char *name)
1414 {
1415 static int proc = -1;
1416 kvbuf_t *request;
1417 si_list_t *list;
1418
1419 request = kvbuf_query_key_val("netgroup", name);
1420 if (request == NULL) return NULL;
1421
1422 list = ds_list(si, CATEGORY_NETGROUP, "getnetgrent", &proc, NULL, extract_netgroup, request);
1423
1424 kvbuf_free(request);
1425
1426 return list;
1427 }
1428
1429 static int
1430 check_innetgr(kvarray_t *in)
1431 {
1432 uint32_t d, k, kcount;
1433
1434 if (in == NULL) return 0;
1435
1436 d = in->curr;
1437 if (d >= in->count) return 0;
1438
1439 kcount = in->dict[d].kcount;
1440
1441 for (k = 0; k < kcount; k++)
1442 {
1443 if (string_equal(in->dict[d].key[k], "result"))
1444 {
1445 if (in->dict[d].vcount[k] == 0) continue;
1446 return atoi(in->dict[d].val[k][0]);
1447 }
1448 }
1449
1450 return 0;
1451 }
1452
1453 __private_extern__ int
1454 ds_in_netgroup(si_mod_t *si, const char *group, const char *host, const char *user, const char *domain)
1455 {
1456 int is_innetgr;
1457 kvbuf_t *request;
1458 kvarray_t *reply;
1459 kern_return_t status;
1460 static int proc = -1;
1461
1462 if (proc < 0)
1463 {
1464 status = LI_DSLookupGetProcedureNumber("innetgr", &proc);
1465 if (status != KERN_SUCCESS) return 0;
1466 }
1467
1468 /* Encode NULL */
1469 if (group == NULL) group = "";
1470 if (host == NULL) host = "";
1471 if (user == NULL) user = "";
1472 if (domain == NULL) domain = "";
1473
1474 request = kvbuf_query("ksksksks", "netgroup", group, "host", host, "user", user, "domain", domain);
1475 if (request == NULL) return 0;
1476
1477 reply = NULL;
1478 status = LI_DSLookupQuery(proc, request, &reply);
1479 kvbuf_free(request);
1480
1481 if ((status != KERN_SUCCESS) || (reply == NULL)) return 0;
1482
1483 is_innetgr = check_innetgr(reply);
1484
1485 kvarray_free(reply);
1486
1487 return is_innetgr;
1488 }
1489
1490 __private_extern__ si_item_t *
1491 ds_alias_byname(si_mod_t *si, const char *name)
1492 {
1493 static int proc = -1;
1494 kvbuf_t *request;
1495 si_item_t *item;
1496
1497 request = kvbuf_query_key_val("name", name);
1498 if (request == NULL) return NULL;
1499
1500 item = ds_item(si, CATEGORY_ALIAS, "alias_getbyname", &proc, NULL, extract_alias, request);
1501
1502 kvbuf_free(request);
1503 return item;
1504 }
1505
1506 __private_extern__ si_list_t *
1507 ds_alias_all(si_mod_t *si)
1508 {
1509 static int proc = -1;
1510
1511 return ds_list(si, CATEGORY_ALIAS, "alias_getent", &proc, NULL, extract_alias, NULL);
1512 }
1513
1514 __private_extern__ si_item_t *
1515 ds_host_byname(si_mod_t *si, const char *name, int af, uint32_t *err)
1516 {
1517 static int proc = -1;
1518 kvbuf_t *request;
1519 si_item_t *item;
1520 uint32_t want4, want6;
1521 int cat;
1522
1523 if (err != NULL) *err = SI_STATUS_NO_ERROR;
1524
1525 if (name == NULL)
1526 {
1527 *err = SI_STATUS_H_ERRNO_NO_RECOVERY;
1528 return NULL;
1529 }
1530
1531 want4 = 0;
1532 want6 = 0;
1533
1534 cat = CATEGORY_HOST_IPV4;
1535
1536 if (af == AF_INET)
1537 {
1538 want4 = 1;
1539 }
1540 else if (af == AF_INET6)
1541 {
1542 want6 = 1;
1543 cat = CATEGORY_HOST_IPV6;
1544 }
1545 else
1546 {
1547 *err = SI_STATUS_H_ERRNO_NO_RECOVERY;
1548 return NULL;
1549 }
1550
1551 request = kvbuf_query("kskuku", "name", name, "ipv4", want4, "ipv6", want6);
1552 if (request == NULL)
1553 {
1554 *err = SI_STATUS_H_ERRNO_NO_RECOVERY;
1555 return NULL;
1556 }
1557
1558 item = ds_item(si, cat, "gethostbyname", &proc, NULL, extract_host, request);
1559
1560 if ((item == NULL) && (err != NULL)) *err = SI_STATUS_H_ERRNO_HOST_NOT_FOUND;
1561
1562 kvbuf_free(request);
1563 return item;
1564 }
1565
1566 __private_extern__ si_item_t *
1567 ds_host_byaddr(si_mod_t *si, const void *addr, int af, uint32_t *err)
1568 {
1569 static int proc = -1;
1570 kvbuf_t *request;
1571 si_item_t *item;
1572 struct in_addr addr4;
1573 struct in6_addr addr6;
1574 char val[64 + 1 + IF_NAMESIZE];
1575 int cat;
1576 uint32_t want;
1577
1578 if (err != NULL) *err = SI_STATUS_NO_ERROR;
1579
1580 cat = CATEGORY_HOST_IPV4;
1581
1582 memset(&addr4, 0, sizeof(struct in_addr));
1583 memset(&addr6, 0, sizeof(struct in6_addr));
1584 memset(val, 0, sizeof(val));
1585
1586 want = WANT_A4_ONLY;
1587
1588 if (af == AF_INET)
1589 {
1590 memcpy(&addr4.s_addr, addr, IPV4_ADDR_LEN);
1591 if (inet_ntop(af, &addr4, val, sizeof(val)) == NULL)
1592 {
1593 *err = SI_STATUS_H_ERRNO_NO_RECOVERY;
1594 return NULL;
1595 }
1596 }
1597 else if (af == AF_INET6)
1598 {
1599 want = WANT_A6_ONLY;
1600 cat = CATEGORY_HOST_IPV6;
1601 memcpy(&addr6, addr, IPV6_ADDR_LEN);
1602 if (inet_ntop(af, &addr6, val, sizeof(val)) == NULL)
1603 {
1604 *err = SI_STATUS_H_ERRNO_NO_RECOVERY;
1605 return NULL;
1606 }
1607 }
1608 else
1609 {
1610 *err = SI_STATUS_H_ERRNO_NO_RECOVERY;
1611 return NULL;
1612 }
1613
1614 request = kvbuf_query("ksku", "address", val, "family", af);
1615 if (request == NULL)
1616 {
1617 *err = SI_STATUS_H_ERRNO_NO_RECOVERY;
1618 return NULL;
1619 }
1620
1621 item = ds_item(si, cat, "gethostbyaddr", &proc, &want, extract_host, request);
1622
1623 if ((item == NULL) && (err != NULL)) *err = SI_STATUS_H_ERRNO_HOST_NOT_FOUND;
1624
1625 kvbuf_free(request);
1626 return item;
1627 }
1628
1629 __private_extern__ si_list_t *
1630 ds_host_all(si_mod_t *si)
1631 {
1632 static int proc = -1;
1633
1634 return ds_list(si, CATEGORY_HOST_IPV4, "gethostent", &proc, NULL, extract_host, NULL);
1635 }
1636
1637 __private_extern__ si_item_t *
1638 ds_network_byname(si_mod_t *si, const char *name)
1639 {
1640 static int proc = -1;
1641 kvbuf_t *request;
1642 si_item_t *item;
1643
1644 request = kvbuf_query_key_val("name", name);
1645 if (request == NULL) return NULL;
1646
1647 item = ds_item(si, CATEGORY_NETWORK, "getnetbyname", &proc, NULL, extract_network, request);
1648
1649 kvbuf_free(request);
1650 return item;
1651 }
1652
1653 __private_extern__ si_item_t *
1654 ds_network_byaddr(si_mod_t *si, uint32_t addr)
1655 {
1656 static int proc = -1;
1657 unsigned char f1, f2, f3;
1658 char val[64];
1659 kvbuf_t *request;
1660 si_item_t *item;
1661
1662 f1 = addr & 0xff;
1663 addr >>= 8;
1664 f2 = addr & 0xff;
1665 addr >>= 8;
1666 f3 = addr & 0xff;
1667
1668 if (f3 != 0) snprintf(val, sizeof(val), "%u.%u.%u", f3, f2, f1);
1669 else if (f2 != 0) snprintf(val, sizeof(val), "%u.%u", f2, f1);
1670 else snprintf(val, sizeof(val), "%u", f1);
1671
1672 request = kvbuf_query_key_val("net", val);
1673 if (request == NULL) return NULL;
1674
1675 item = ds_item(si, CATEGORY_NETWORK, "getnetbyaddr", &proc, NULL, extract_network, request);
1676
1677 kvbuf_free(request);
1678 return item;
1679 }
1680
1681 __private_extern__ si_list_t *
1682 ds_network_all(si_mod_t *si)
1683 {
1684 static int proc = -1;
1685
1686 return ds_list(si, CATEGORY_NETWORK, "getnetent", &proc, NULL, extract_network, NULL);
1687 }
1688
1689 __private_extern__ si_item_t *
1690 ds_service_byname(si_mod_t *si, const char *name, const char *proto)
1691 {
1692 static int proc = -1;
1693 kvbuf_t *request;
1694 si_item_t *item;
1695 struct servent *s;
1696
1697 if (name == NULL) name = "";
1698 if (proto == NULL) proto = "";
1699
1700 /* Check our local service cache (see ds_addrinfo). */
1701 item = pthread_getspecific(_ds_serv_cache_key);
1702 if (item != NULL)
1703 {
1704 s = (struct servent *)((uintptr_t)item + sizeof(si_item_t));
1705 if (string_equal(name, s->s_name)) return si_item_retain(item);
1706 }
1707
1708 request = kvbuf_query("ksks", "name", name, "proto", proto);
1709 if (request == NULL) return NULL;
1710
1711 item = ds_item(si, CATEGORY_SERVICE, "getservbyname", &proc, NULL, extract_service, request);
1712
1713 kvbuf_free(request);
1714 return item;
1715 }
1716
1717 __private_extern__ si_item_t *
1718 ds_service_byport(si_mod_t *si, int port, const char *proto)
1719 {
1720 static int proc = -1;
1721 uint16_t sport;
1722 char val[16];
1723 kvbuf_t *request;
1724 si_item_t *item;
1725
1726 if (proto == NULL) proto = "";
1727
1728 sport = port;
1729 snprintf(val, sizeof(val), "%d", ntohs(sport));
1730
1731 request = kvbuf_query("ksks", "port", val, "proto", proto);
1732 if (request == NULL) return NULL;
1733
1734 item = ds_item(si, CATEGORY_SERVICE, "getservbyport", &proc, NULL, extract_service, request);
1735
1736 kvbuf_free(request);
1737 return item;
1738 }
1739
1740 __private_extern__ si_list_t *
1741 ds_service_all(si_mod_t *si)
1742 {
1743 static int proc = -1;
1744
1745 return ds_list(si, CATEGORY_SERVICE, "getservent", &proc, NULL, extract_service, NULL);
1746 }
1747
1748 __private_extern__ si_item_t *
1749 ds_protocol_byname(si_mod_t *si, const char *name)
1750 {
1751 static int proc = -1;
1752 kvbuf_t *request;
1753 si_item_t *item;
1754
1755 request = kvbuf_query_key_val("name", name);
1756 if (request == NULL) return NULL;
1757
1758 item = ds_item(si, CATEGORY_PROTOCOL, "getprotobyname", &proc, NULL, extract_protocol, request);
1759
1760 kvbuf_free(request);
1761 return item;
1762 }
1763
1764 __private_extern__ si_item_t *
1765 ds_protocol_bynumber(si_mod_t *si, int number)
1766 {
1767 static int proc = -1;
1768 char val[16];
1769 kvbuf_t *request;
1770 si_item_t *item;
1771
1772 snprintf(val, sizeof(val), "%d", number);
1773 request = kvbuf_query_key_val("number", val);
1774 if (request == NULL) return NULL;
1775
1776 item = ds_item(si, CATEGORY_PROTOCOL, "getprotobynumber", &proc, NULL, extract_protocol, request);
1777
1778 kvbuf_free(request);
1779 return item;
1780 }
1781
1782 __private_extern__ si_list_t *
1783 ds_protocol_all(si_mod_t *si)
1784 {
1785 static int proc = -1;
1786
1787 return ds_list(si, CATEGORY_PROTOCOL, "getprotoent", &proc, NULL, extract_protocol, NULL);
1788 }
1789
1790 __private_extern__ si_item_t *
1791 ds_rpc_byname(si_mod_t *si, const char *name)
1792 {
1793 static int proc = -1;
1794 kvbuf_t *request;
1795 si_item_t *item;
1796
1797 request = kvbuf_query_key_val("name", name);
1798 if (request == NULL) return NULL;
1799
1800 item = ds_item(si, CATEGORY_RPC, "getrpcbyname", &proc, NULL, extract_rpc, request);
1801
1802 kvbuf_free(request);
1803 return item;
1804 }
1805
1806 __private_extern__ si_item_t *
1807 ds_rpc_bynumber(si_mod_t *si, int number)
1808 {
1809 static int proc = -1;
1810 char val[16];
1811 kvbuf_t *request;
1812 si_item_t *item;
1813
1814 snprintf(val, sizeof(val), "%u", (uint32_t)number);
1815 request = kvbuf_query_key_val("number", val);
1816 if (request == NULL) return NULL;
1817
1818 item = ds_item(si, CATEGORY_RPC, "getrpcbynumber", &proc, NULL, extract_rpc, request);
1819
1820 kvbuf_free(request);
1821 return item;
1822 }
1823
1824 __private_extern__ si_list_t *
1825 ds_rpc_all(si_mod_t *si)
1826 {
1827 static int proc = -1;
1828
1829 return ds_list(si, CATEGORY_RPC, "getrpcent", &proc, NULL, extract_rpc, NULL);
1830 }
1831
1832 __private_extern__ si_item_t *
1833 ds_fs_byspec(si_mod_t *si, const char *name)
1834 {
1835 static int proc = -1;
1836 kvbuf_t *request;
1837 si_item_t *item;
1838
1839 request = kvbuf_query_key_val("name", name);
1840 if (request == NULL) return NULL;
1841
1842 item = ds_item(si, CATEGORY_FS, "getfsbyname", &proc, NULL, extract_fstab, request);
1843
1844 kvbuf_free(request);
1845 return item;
1846 }
1847
1848 __private_extern__ si_list_t *
1849 ds_fs_all(si_mod_t *si)
1850 {
1851 static int proc = -1;
1852
1853 return ds_list(si, CATEGORY_FS, "getfsent", &proc, NULL, extract_fstab, NULL);
1854 }
1855
1856 __private_extern__ si_item_t *
1857 ds_fs_byfile(si_mod_t *si, const char *name)
1858 {
1859 si_item_t *item;
1860 si_list_t *list;
1861 uint32_t i;
1862 struct fstab *f;
1863
1864 if (name == NULL) return NULL;
1865
1866 list = ds_fs_all(si);
1867 if (list == NULL) return NULL;
1868
1869 item = NULL;
1870 for (i = 0; (i < list->count) && (item == NULL); i++)
1871 {
1872 f = (struct fstab *)((uintptr_t)(list->entry[i]) + sizeof(si_item_t));
1873 if (string_equal(name, f->fs_file)) item = si_item_retain(list->entry[i]);
1874 }
1875
1876 si_list_release(list);
1877 return item;
1878 }
1879
1880 __private_extern__ si_item_t *
1881 ds_mac_byname(si_mod_t *si, const char *name)
1882 {
1883 static int proc = -1;
1884 kvbuf_t *request;
1885 si_item_t *item;
1886
1887 request = kvbuf_query_key_val("name", name);
1888 if (request == NULL) return NULL;
1889
1890 item = ds_item(si, CATEGORY_MAC, "getmacbyname", &proc, (void *)name, extract_mac_mac, request);
1891
1892 kvbuf_free(request);
1893 return item;
1894 }
1895
1896 __private_extern__ si_item_t *
1897 ds_mac_bymac(si_mod_t *si, const char *mac)
1898 {
1899 static int proc = -1;
1900 kvbuf_t *request;
1901 si_item_t *item;
1902 char *cmac;
1903
1904 cmac = si_canonical_mac_address(mac);
1905 if (cmac == NULL) return NULL;
1906
1907 request = kvbuf_query_key_val("mac", cmac);
1908 if (request == NULL) return NULL;
1909
1910 item = ds_item(si, CATEGORY_MAC, "gethostbymac", &proc, cmac, extract_mac_name, request);
1911
1912 free(cmac);
1913 kvbuf_free(request);
1914 return item;
1915 }
1916
1917 static si_list_t *
1918 ds_addrinfo(si_mod_t *si, const void *node, const void *serv, uint32_t family, uint32_t socktype, uint32_t proto, uint32_t flags, uint32_t *err)
1919 {
1920 static int proc = -1;
1921 si_list_t *list, *out;
1922 si_item_t *item;
1923 kvbuf_t *request = NULL;
1924 kvdict_t *dict;
1925 kvarray_t *reply = NULL;
1926 kern_return_t status = 0;
1927 uint16_t scope = 0;
1928 int i, k, kcount, d;
1929 uint32_t port;
1930
1931 struct hostent *h;
1932 char *h_name = NULL;
1933 int h_aliases_cnt = 0;
1934 const char **h_aliases = NULL;
1935 struct in_addr *a4 = NULL;
1936 struct in6_addr *a6 = NULL;
1937 int a4_cnt = 0;
1938 int a6_cnt = 0;
1939 struct servent *s;
1940 const char *s_name = NULL;
1941 int s_aliases_cnt = 0;
1942 const char **s_aliases = NULL;
1943 uint16_t s_port = 0;
1944 const char *s_proto = NULL;
1945 const char *protoname;
1946 int wantv4, wantv6;
1947
1948 int numericserv = ((flags & AI_NUMERICSERV) != 0);
1949 int numerichost = ((flags & AI_NUMERICHOST) != 0);
1950
1951 wantv4 = 0;
1952 wantv6 = 0;
1953
1954 if (node != NULL)
1955 {
1956 wantv4 = (family != AF_INET6);
1957 wantv6 = (family != AF_INET);
1958 }
1959
1960 if (err != NULL) *err = SI_STATUS_NO_ERROR;
1961
1962 if (proc < 0)
1963 {
1964 status = LI_DSLookupGetProcedureNumber("gethostbyname_service", &proc);
1965 if (status != KERN_SUCCESS)
1966 {
1967 if (err != NULL) *err = SI_STATUS_EAI_SYSTEM;
1968 return NULL;
1969 }
1970 }
1971
1972 /* look up canonical name of numeric host */
1973 if ((numerichost == 1) && (flags & AI_CANONNAME) && (node != NULL))
1974 {
1975 item = si_host_byaddr(si, node, family, NULL);
1976 if (item != NULL)
1977 {
1978 h = (struct hostent *)((uintptr_t)item + sizeof(si_item_t));
1979 h_name = strdup(h->h_name);
1980 si_item_release(item);
1981 }
1982 }
1983
1984 if (numericserv == 1)
1985 {
1986 s_port = *(int16_t *)serv;
1987 }
1988
1989 if ((numericserv == 0) || (numerichost == 0))
1990 {
1991 request = kvbuf_new();
1992 if (request != NULL)
1993 {
1994 kvbuf_add_dict(request);
1995
1996 if (numerichost == 0)
1997 {
1998 kvbuf_add_key(request, "name");
1999 kvbuf_add_val(request, node);
2000 kvbuf_add_key(request, "ipv4");
2001 kvbuf_add_val(request, wantv4 ? "1" : "0");
2002 kvbuf_add_key(request, "ipv6");
2003 kvbuf_add_val(request, wantv6 ? "1" : "0");
2004 }
2005
2006 if (numericserv == 0)
2007 {
2008 protoname = NULL;
2009 if (proto == IPPROTO_UDP) protoname = "udp";
2010 if (proto == IPPROTO_TCP) protoname = "tcp";
2011
2012 kvbuf_add_key(request, "s_name");
2013 kvbuf_add_val(request, serv);
2014 if (protoname != NULL)
2015 {
2016 kvbuf_add_key(request, "s_proto");
2017 kvbuf_add_val(request, protoname);
2018 }
2019 }
2020
2021 status = LI_DSLookupQuery(proc, request, &reply);
2022 kvbuf_free(request);
2023 }
2024 else
2025 {
2026 if (err != NULL) *err = SI_STATUS_EAI_SYSTEM;
2027 }
2028 }
2029
2030 if ((status != KERN_SUCCESS) || (reply == NULL))
2031 {
2032 free(h_name);
2033 return NULL;
2034 }
2035
2036 for (d = 0; d < reply->count; d++)
2037 {
2038 dict = reply->dict + d;
2039 kcount = dict->kcount;
2040
2041 for (k = 0; k < kcount; k++)
2042 {
2043 if (string_equal(dict->key[k], "h_name"))
2044 {
2045 if (dict->vcount[k] == 0) continue;
2046 h_name = strdup(dict->val[k][0]);
2047 }
2048 else if (string_equal(dict->key[k], "h_aliases"))
2049 {
2050 h_aliases_cnt = dict->vcount[k];
2051 h_aliases = (const char **)calloc(h_aliases_cnt, sizeof(char *));
2052 if (h_aliases == NULL) h_aliases_cnt = 0;
2053
2054 for (i = 0; i < h_aliases_cnt; ++i)
2055 {
2056 h_aliases[i] = dict->val[k][i];
2057 }
2058 }
2059 else if (wantv4 && (string_equal(dict->key[k], "h_ipv4_addr_list")))
2060 {
2061 a4_cnt = dict->vcount[k];
2062 a4 = calloc(a4_cnt, sizeof(struct in_addr));
2063 if (a4 == NULL) a4_cnt = 0;
2064
2065 for (i = 0; i < a4_cnt; ++i)
2066 {
2067 memset(&a4[i], 0, sizeof(struct in_addr));
2068 inet_pton(AF_INET, dict->val[k][i], &a4[i]);
2069 }
2070 }
2071 else if (wantv6 && (string_equal(dict->key[k], "h_ipv6_addr_list")))
2072 {
2073 a6_cnt = dict->vcount[k];
2074 a6 = calloc(a6_cnt, sizeof(struct in6_addr));
2075 if (a6 == NULL) a6_cnt = 0;
2076
2077 for (i = 0; i < a6_cnt; ++i)
2078 {
2079 memset(&a6[i], 0, sizeof(struct in6_addr));
2080 inet_pton(AF_INET6, dict->val[k][i], &a6[i]);
2081 }
2082 }
2083 else if (string_equal(dict->key[k], "s_name"))
2084 {
2085 if (dict->vcount[k] == 0) continue;
2086 s_name = dict->val[k][0];
2087 }
2088 else if (string_equal(dict->key[k], "s_port"))
2089 {
2090 if (dict->vcount[k] == 0) continue;
2091 s_port = atoi(dict->val[k][0]);
2092 }
2093 else if (string_equal(dict->key[k], "s_aliases"))
2094 {
2095 s_aliases_cnt = dict->vcount[k];
2096 s_aliases = (const char **)calloc(s_aliases_cnt+1, sizeof(char *));
2097 if (s_aliases == NULL) s_aliases_cnt = 0;
2098
2099 for (i = 0; i < s_aliases_cnt; ++i)
2100 {
2101 s_aliases[i] = dict->val[k][i];
2102 }
2103 }
2104 else if (string_equal(dict->key[k], "s_proto"))
2105 {
2106 if (dict->vcount[k] == 0) continue;
2107 s_proto = dict->val[k][0];
2108 }
2109 }
2110 }
2111
2112 kvarray_free(reply);
2113
2114 /* check if we actually got back what we wanted */
2115 if (((wantv4 || wantv6) && (a4_cnt == 0) && (a6_cnt == 0)) || ((serv != NULL) && (s_port == 0)))
2116 {
2117 if (err != NULL) *err = SI_STATUS_EAI_NONAME;
2118
2119 free(h_name);
2120 free(h_aliases);
2121 free(s_aliases);
2122 free(a4);
2123 free(a6);
2124
2125 return NULL;
2126 }
2127
2128 /*
2129 * Cache the service entry regardless of whether there is a host match.
2130 * This allows later modules to get the service entry quickly.
2131 * This should really be part of the general cache mechanism, but that's
2132 * not currently visible outside of the search module.
2133 */
2134 if ((s_name != NULL) && (s_port != 0))
2135 {
2136 port = htons(s_port);
2137
2138 item = pthread_getspecific(_ds_serv_cache_key);
2139 if (item != NULL)
2140 {
2141 s = (struct servent *)((uintptr_t)item + sizeof(si_item_t));
2142 if ((port != s->s_port) || string_not_equal(s_name, s->s_name))
2143 {
2144 si_item_release(item);
2145 item = NULL;
2146 }
2147 }
2148
2149 if (item == NULL)
2150 {
2151 item = LI_ils_create("L4488s*4s", (unsigned long)si, CATEGORY_SERVICE, 1, (uint64_t)1, (uint64_t)1, s_name, s_aliases, port, s_proto);
2152 pthread_setspecific(_ds_serv_cache_key, item);
2153 }
2154 }
2155
2156 /* Construct the addrinfo list from the returned addresses (if found). */
2157 out = NULL;
2158 for (i = 0; i < a6_cnt; i++)
2159 {
2160 list = si_addrinfo_list(si, socktype, proto, NULL, &a6[i], s_port, scope, NULL, h_name);
2161 out = si_list_concat(out, list);
2162 si_list_release(list);
2163 }
2164
2165 for (i = 0; i < a4_cnt; i++)
2166 {
2167 list = si_addrinfo_list(si, socktype, proto, &a4[i], NULL, s_port, 0, h_name, NULL);
2168 out = si_list_concat(out, list);
2169 si_list_release(list);
2170 }
2171
2172 free(h_name);
2173 free(h_aliases);
2174 free(s_aliases);
2175 free(a4);
2176 free(a6);
2177
2178 return out;
2179 }
2180
2181 __private_extern__ int
2182 ds_is_valid(si_mod_t *si, si_item_t *item)
2183 {
2184 si_mod_t *src;
2185 ds_si_private_t *pp;
2186 int status;
2187 uint32_t oldval, newval;
2188
2189 if (si == NULL) return 0;
2190 if (item == NULL) return 0;
2191 if (si->name == NULL) return 0;
2192 if (item->src == NULL) return 0;
2193
2194 pp = (ds_si_private_t *)si->private;
2195 if (pp == NULL) return 0;
2196
2197 src = (si_mod_t *)item->src;
2198
2199 if (src->name == NULL) return 0;
2200 if (string_not_equal(si->name, src->name)) return 0;
2201
2202 /* check global invalidation */
2203 oldval = item->validation_a;
2204 newval = -1;
2205 status = notify_peek(pp->notify_token_global, &newval);
2206 if (status != NOTIFY_STATUS_OK) return 0;
2207
2208 newval = ntohl(newval);
2209 if (oldval != newval) return 0;
2210
2211 oldval = item->validation_b;
2212 newval = -1;
2213 if (item->type == CATEGORY_USER) status = notify_peek(pp->notify_token_user, &newval);
2214 else if (item->type == CATEGORY_GROUP) status = notify_peek(pp->notify_token_group, &newval);
2215 else if (item->type == CATEGORY_HOST_IPV4) status = notify_peek(pp->notify_token_host, &newval);
2216 else if (item->type == CATEGORY_HOST_IPV6) status = notify_peek(pp->notify_token_host, &newval);
2217 else if (item->type == CATEGORY_SERVICE) status = notify_peek(pp->notify_token_service, &newval);
2218 else return 0;
2219
2220 if (status != NOTIFY_STATUS_OK) return 0;
2221
2222 newval = ntohl(newval);
2223 if (oldval != newval) return 0;
2224
2225 return 1;
2226 }
2227
2228 __private_extern__ si_mod_t *
2229 si_module_static_ds()
2230 {
2231 si_mod_t *out;
2232 char *outname;
2233 ds_si_private_t *pp;
2234 int status;
2235
2236 out = (si_mod_t *)calloc(1, sizeof(si_mod_t));
2237 outname = strdup("ds");
2238 pp = (ds_si_private_t *)calloc(1, sizeof(ds_si_private_t));
2239
2240 if ((out == NULL) || (outname == NULL) || (pp == NULL))
2241 {
2242 if (out != NULL) free(out);
2243 if (outname != NULL) free(outname);
2244 if (pp != NULL) free(pp);
2245
2246 errno = ENOMEM;
2247 return NULL;
2248 }
2249
2250 pthread_key_create(&_ds_serv_cache_key, _ds_serv_cache_free);
2251
2252 pp->notify_token_global = -1;
2253 pp->notify_token_user = -1;
2254 pp->notify_token_group = -1;
2255 pp->notify_token_host = -1;
2256 pp->notify_token_service = -1;
2257
2258 /*
2259 * Don't register for notifications if the cache is disabled.
2260 * notifyd (notably) disables the cache to prevent deadlocks.
2261 */
2262 if (gL1CacheEnabled != 0)
2263 {
2264 /*
2265 * Errors in registering for cache invalidation notifications are ignored.
2266 * If there are failures, the tokens remain set to -1 which just causes
2267 * cached items to be invalidated.
2268 */
2269 status = notify_register_check(DS_NOTIFICATION_KEY_GLOBAL, &(pp->notify_token_global));
2270 status = notify_register_check(DS_NOTIFICATION_KEY_GLOBAL, &(pp->notify_token_user));
2271 status = notify_register_check(DS_NOTIFICATION_KEY_GLOBAL, &(pp->notify_token_group));
2272 status = notify_register_check(DS_NOTIFICATION_KEY_GLOBAL, &(pp->notify_token_host));
2273 status = notify_register_check(DS_NOTIFICATION_KEY_GLOBAL, &(pp->notify_token_service));
2274 }
2275
2276 out->name = outname;
2277 out->vers = 1;
2278 out->refcount = 1;
2279 out->private = pp;
2280
2281 out->sim_is_valid = ds_is_valid;
2282
2283 out->sim_user_byname = ds_user_byname;
2284 out->sim_user_byuid = ds_user_byuid;
2285 out->sim_user_all = ds_user_all;
2286
2287 out->sim_group_byname = ds_group_byname;
2288 out->sim_group_bygid = ds_group_bygid;
2289 out->sim_group_all = ds_group_all;
2290
2291 out->sim_grouplist = ds_grouplist;
2292
2293 out->sim_netgroup_byname = ds_netgroup_byname;
2294 out->sim_in_netgroup = ds_in_netgroup;
2295
2296 out->sim_alias_byname = ds_alias_byname;
2297 out->sim_alias_all = ds_alias_all;
2298
2299 out->sim_host_byname = ds_host_byname;
2300 out->sim_host_byaddr = ds_host_byaddr;
2301 out->sim_host_all = ds_host_all;
2302
2303 out->sim_network_byname = ds_network_byname;
2304 out->sim_network_byaddr = ds_network_byaddr;
2305 out->sim_network_all = ds_network_all;
2306
2307 out->sim_service_byname = ds_service_byname;
2308 out->sim_service_byport = ds_service_byport;
2309 out->sim_service_all = ds_service_all;
2310
2311 out->sim_protocol_byname = ds_protocol_byname;
2312 out->sim_protocol_bynumber = ds_protocol_bynumber;
2313 out->sim_protocol_all = ds_protocol_all;
2314
2315 out->sim_rpc_byname = ds_rpc_byname;
2316 out->sim_rpc_bynumber = ds_rpc_bynumber;
2317 out->sim_rpc_all = ds_rpc_all;
2318
2319 out->sim_fs_byspec = ds_fs_byspec;
2320 out->sim_fs_byfile = ds_fs_byfile;
2321 out->sim_fs_all = ds_fs_all;
2322
2323 out->sim_mac_byname = ds_mac_byname;
2324 out->sim_mac_bymac = ds_mac_bymac;
2325
2326 /* si_mac_all not supported */
2327 out->sim_mac_all = NULL;
2328
2329 out->sim_addrinfo = ds_addrinfo;
2330
2331 return out;
2332 }
mirror of libinfo