17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 5004388ebScasper * Common Development and Distribution License (the "License"). 6004388ebScasper * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 217c478bd9Sstevel@tonic-gate /* 22004388ebScasper * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 237c478bd9Sstevel@tonic-gate * Use is subject to license terms. 247c478bd9Sstevel@tonic-gate * 257c478bd9Sstevel@tonic-gate * Common code and structures used by name-service-switch "compat" backends. 267c478bd9Sstevel@tonic-gate * 277c478bd9Sstevel@tonic-gate * Most of the code in the "compat" backend is a perverted form of code from 287c478bd9Sstevel@tonic-gate * the "files" backend; this file is no exception. 297c478bd9Sstevel@tonic-gate */ 307c478bd9Sstevel@tonic-gate 317c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 327c478bd9Sstevel@tonic-gate 337c478bd9Sstevel@tonic-gate #include <stdio.h> 347c478bd9Sstevel@tonic-gate #include <stdlib.h> 357c478bd9Sstevel@tonic-gate #include <string.h> 367c478bd9Sstevel@tonic-gate #include <ctype.h> 377c478bd9Sstevel@tonic-gate #include <bsm/libbsm.h> 387c478bd9Sstevel@tonic-gate #include <user_attr.h> 39cb5caa98Sdjl #include <pwd.h> 40cb5caa98Sdjl #include <shadow.h> 41cb5caa98Sdjl #include <grp.h> 42cb5caa98Sdjl #include <unistd.h> /* for GF_PATH */ 43cb5caa98Sdjl #include <dlfcn.h> 447c478bd9Sstevel@tonic-gate #include "compat_common.h" 457c478bd9Sstevel@tonic-gate 467c478bd9Sstevel@tonic-gate /* 477c478bd9Sstevel@tonic-gate * This should be in a header. 487c478bd9Sstevel@tonic-gate */ 497c478bd9Sstevel@tonic-gate 507c478bd9Sstevel@tonic-gate extern int yp_get_default_domain(char **domain); 517c478bd9Sstevel@tonic-gate 52cb5caa98Sdjl /* from libc */ 53cb5caa98Sdjl extern int str2passwd(const char *instr, int lenstr, void *ent, 54cb5caa98Sdjl char *buffer, int buflen); 55cb5caa98Sdjl extern int str2spwd(const char *instr, int lenstr, void *ent, 56cb5caa98Sdjl char *buffer, int buflen); 57cb5caa98Sdjl extern int str2group(const char *instr, int lenstr, void *ent, 58cb5caa98Sdjl char *buffer, int buflen); 59cb5caa98Sdjl 60cb5caa98Sdjl /* from libnsl */ 61cb5caa98Sdjl extern char *_strtok_escape(char *, char *, char **); 62cb5caa98Sdjl 63cb5caa98Sdjl /* 64cb5caa98Sdjl * str2auuser_s and str2userattr_s are very simple version 65cb5caa98Sdjl * of the str2auuser() and str2userattr() that can be found in 66cb5caa98Sdjl * libnsl. They only copy the user name into the userstr_t 67cb5caa98Sdjl * or au_user_str_t structure (so check on user name can be 68cb5caa98Sdjl * performed). 69cb5caa98Sdjl */ 70cb5caa98Sdjl static int 71cb5caa98Sdjl str2auuser_s( 72cb5caa98Sdjl const char *instr, 73cb5caa98Sdjl int lenstr, 74cb5caa98Sdjl void *ent, 75cb5caa98Sdjl char *buffer, 76cb5caa98Sdjl int buflen) 77cb5caa98Sdjl { 78cb5caa98Sdjl char *last = NULL; 79cb5caa98Sdjl char *sep = KV_TOKEN_DELIMIT; 80cb5caa98Sdjl au_user_str_t *au_user = (au_user_str_t *)ent; 81cb5caa98Sdjl 82cb5caa98Sdjl if (lenstr >= buflen) 83cb5caa98Sdjl return (NSS_STR_PARSE_ERANGE); 84cb5caa98Sdjl (void) strncpy(buffer, instr, buflen); 85cb5caa98Sdjl au_user->au_name = _strtok_escape(buffer, sep, &last); 86cb5caa98Sdjl return (0); 87cb5caa98Sdjl } 88cb5caa98Sdjl 89cb5caa98Sdjl static int 90cb5caa98Sdjl str2userattr_s( 91cb5caa98Sdjl const char *instr, 92cb5caa98Sdjl int lenstr, 93cb5caa98Sdjl void *ent, 94cb5caa98Sdjl char *buffer, 95cb5caa98Sdjl int buflen) 96cb5caa98Sdjl { 97cb5caa98Sdjl char *last = NULL; 98cb5caa98Sdjl char *sep = KV_TOKEN_DELIMIT; 99cb5caa98Sdjl userstr_t *user = (userstr_t *)ent; 100cb5caa98Sdjl 101cb5caa98Sdjl if (lenstr >= buflen) 102cb5caa98Sdjl return (NSS_STR_PARSE_ERANGE); 103cb5caa98Sdjl (void) strncpy(buffer, instr, buflen); 104cb5caa98Sdjl user->name = _strtok_escape(buffer, sep, &last); 105cb5caa98Sdjl return (0); 106cb5caa98Sdjl } 107cb5caa98Sdjl 1087c478bd9Sstevel@tonic-gate /* 1097c478bd9Sstevel@tonic-gate * Routines to manage list of "-" users for get{pw, sp, gr}ent(). Current 1107c478bd9Sstevel@tonic-gate * implementation is completely moronic; we use a linked list. But then 1117c478bd9Sstevel@tonic-gate * that's what it's always done in 4.x... 1127c478bd9Sstevel@tonic-gate */ 1137c478bd9Sstevel@tonic-gate 1147c478bd9Sstevel@tonic-gate struct setofstrings { 1157c478bd9Sstevel@tonic-gate char *name; 1167c478bd9Sstevel@tonic-gate struct setofstrings *next; 1177c478bd9Sstevel@tonic-gate /* 1187c478bd9Sstevel@tonic-gate * === Should get smart and malloc the string and pointer as one 1197c478bd9Sstevel@tonic-gate * object rather than two. 1207c478bd9Sstevel@tonic-gate */ 1217c478bd9Sstevel@tonic-gate }; 1227c478bd9Sstevel@tonic-gate 1237c478bd9Sstevel@tonic-gate static void 1247c478bd9Sstevel@tonic-gate strset_free(ssp) 1257c478bd9Sstevel@tonic-gate strset_t *ssp; 1267c478bd9Sstevel@tonic-gate { 1277c478bd9Sstevel@tonic-gate strset_t cur, nxt; 1287c478bd9Sstevel@tonic-gate 1297c478bd9Sstevel@tonic-gate for (cur = *ssp; cur != 0; cur = nxt) { 1307c478bd9Sstevel@tonic-gate nxt = cur->next; 1317c478bd9Sstevel@tonic-gate free(cur->name); 1327c478bd9Sstevel@tonic-gate free(cur); 1337c478bd9Sstevel@tonic-gate } 1347c478bd9Sstevel@tonic-gate *ssp = 0; 1357c478bd9Sstevel@tonic-gate } 1367c478bd9Sstevel@tonic-gate 1377c478bd9Sstevel@tonic-gate static boolean_t 1387c478bd9Sstevel@tonic-gate strset_add(ssp, nam) 1397c478bd9Sstevel@tonic-gate strset_t *ssp; 1407c478bd9Sstevel@tonic-gate const char *nam; 1417c478bd9Sstevel@tonic-gate { 1427c478bd9Sstevel@tonic-gate strset_t new; 1437c478bd9Sstevel@tonic-gate 1447c478bd9Sstevel@tonic-gate if (0 == (new = (strset_t)malloc(sizeof (*new)))) { 1457c478bd9Sstevel@tonic-gate return (B_FALSE); 1467c478bd9Sstevel@tonic-gate } 1477c478bd9Sstevel@tonic-gate if (0 == (new->name = malloc(strlen(nam) + 1))) { 1487c478bd9Sstevel@tonic-gate free(new); 1497c478bd9Sstevel@tonic-gate return (B_FALSE); 1507c478bd9Sstevel@tonic-gate } 151cb5caa98Sdjl (void) strcpy(new->name, nam); 1527c478bd9Sstevel@tonic-gate new->next = *ssp; 1537c478bd9Sstevel@tonic-gate *ssp = new; 1547c478bd9Sstevel@tonic-gate return (B_TRUE); 1557c478bd9Sstevel@tonic-gate } 1567c478bd9Sstevel@tonic-gate 1577c478bd9Sstevel@tonic-gate static boolean_t 1587c478bd9Sstevel@tonic-gate strset_in(ssp, nam) 1597c478bd9Sstevel@tonic-gate const strset_t *ssp; 1607c478bd9Sstevel@tonic-gate const char *nam; 1617c478bd9Sstevel@tonic-gate { 1627c478bd9Sstevel@tonic-gate strset_t cur; 1637c478bd9Sstevel@tonic-gate 1647c478bd9Sstevel@tonic-gate for (cur = *ssp; cur != 0; cur = cur->next) { 1657c478bd9Sstevel@tonic-gate if (strcmp(cur->name, nam) == 0) { 1667c478bd9Sstevel@tonic-gate return (B_TRUE); 1677c478bd9Sstevel@tonic-gate } 1687c478bd9Sstevel@tonic-gate } 1697c478bd9Sstevel@tonic-gate return (B_FALSE); 1707c478bd9Sstevel@tonic-gate } 1717c478bd9Sstevel@tonic-gate 1727c478bd9Sstevel@tonic-gate /* 1737c478bd9Sstevel@tonic-gate * Lookup and enumeration routines for +@group and -@group. 1747c478bd9Sstevel@tonic-gate * 1757c478bd9Sstevel@tonic-gate * This code knows a lot more about lib/libc/port/gen/getnetgrent.c than 1767c478bd9Sstevel@tonic-gate * is really healthy. The set/get/end routines below duplicate code 1777c478bd9Sstevel@tonic-gate * from that file, but keep the state information per-backend-instance 1787c478bd9Sstevel@tonic-gate * instead of just per-process. 1797c478bd9Sstevel@tonic-gate */ 1807c478bd9Sstevel@tonic-gate 1817c478bd9Sstevel@tonic-gate extern void _nss_initf_netgroup(nss_db_params_t *); 1827c478bd9Sstevel@tonic-gate /* 1837c478bd9Sstevel@tonic-gate * Should really share the db_root in getnetgrent.c in order to get the 1847c478bd9Sstevel@tonic-gate * resource-management quotas right, but this will have to do. 1857c478bd9Sstevel@tonic-gate */ 1867c478bd9Sstevel@tonic-gate static DEFINE_NSS_DB_ROOT(netgr_db_root); 1877c478bd9Sstevel@tonic-gate 1887c478bd9Sstevel@tonic-gate static boolean_t 1897c478bd9Sstevel@tonic-gate netgr_in(compat_backend_ptr_t be, const char *group, const char *user) 1907c478bd9Sstevel@tonic-gate { 1917c478bd9Sstevel@tonic-gate if (be->yp_domain == 0) { 1927c478bd9Sstevel@tonic-gate if (yp_get_default_domain((char **)&be->yp_domain) != 0) { 1937c478bd9Sstevel@tonic-gate return (B_FALSE); 1947c478bd9Sstevel@tonic-gate } 1957c478bd9Sstevel@tonic-gate } 1967c478bd9Sstevel@tonic-gate return (innetgr(group, 0, user, be->yp_domain)); 1977c478bd9Sstevel@tonic-gate } 1987c478bd9Sstevel@tonic-gate 1997c478bd9Sstevel@tonic-gate static void 2007c478bd9Sstevel@tonic-gate netgr_set(be, netgroup) 2017c478bd9Sstevel@tonic-gate compat_backend_ptr_t be; 2027c478bd9Sstevel@tonic-gate const char *netgroup; 2037c478bd9Sstevel@tonic-gate { 2047c478bd9Sstevel@tonic-gate /* 2057c478bd9Sstevel@tonic-gate * ===> Need comment to explain that this first "if" is optimizing 2067c478bd9Sstevel@tonic-gate * for the same-netgroup-as-last-time case 2077c478bd9Sstevel@tonic-gate */ 2087c478bd9Sstevel@tonic-gate if (be->getnetgrent_backend != 0 && 2097c478bd9Sstevel@tonic-gate NSS_INVOKE_DBOP(be->getnetgrent_backend, 2107c478bd9Sstevel@tonic-gate NSS_DBOP_SETENT, 2117c478bd9Sstevel@tonic-gate (void *) netgroup) != NSS_SUCCESS) { 2127c478bd9Sstevel@tonic-gate NSS_INVOKE_DBOP(be->getnetgrent_backend, NSS_DBOP_DESTRUCTOR, 2137c478bd9Sstevel@tonic-gate 0); 2147c478bd9Sstevel@tonic-gate be->getnetgrent_backend = 0; 2157c478bd9Sstevel@tonic-gate } 2167c478bd9Sstevel@tonic-gate if (be->getnetgrent_backend == 0) { 2177c478bd9Sstevel@tonic-gate struct nss_setnetgrent_args args; 2187c478bd9Sstevel@tonic-gate 2197c478bd9Sstevel@tonic-gate args.netgroup = netgroup; 2207c478bd9Sstevel@tonic-gate args.iterator = 0; 221cb5caa98Sdjl (void) nss_search(&netgr_db_root, _nss_initf_netgroup, 2227c478bd9Sstevel@tonic-gate NSS_DBOP_NETGROUP_SET, &args); 2237c478bd9Sstevel@tonic-gate be->getnetgrent_backend = args.iterator; 2247c478bd9Sstevel@tonic-gate } 2257c478bd9Sstevel@tonic-gate } 2267c478bd9Sstevel@tonic-gate 2277c478bd9Sstevel@tonic-gate static boolean_t 2287c478bd9Sstevel@tonic-gate netgr_next_u(be, up) 2297c478bd9Sstevel@tonic-gate compat_backend_ptr_t be; 2307c478bd9Sstevel@tonic-gate char **up; 2317c478bd9Sstevel@tonic-gate { 2327c478bd9Sstevel@tonic-gate if (be->netgr_buffer == 0 && 2337c478bd9Sstevel@tonic-gate (be->netgr_buffer = malloc(NSS_BUFLEN_NETGROUP)) == 0) { 2347c478bd9Sstevel@tonic-gate /* Out of memory */ 2357c478bd9Sstevel@tonic-gate return (B_FALSE); 2367c478bd9Sstevel@tonic-gate } 2377c478bd9Sstevel@tonic-gate 2387c478bd9Sstevel@tonic-gate do { 2397c478bd9Sstevel@tonic-gate struct nss_getnetgrent_args args; 2407c478bd9Sstevel@tonic-gate 2417c478bd9Sstevel@tonic-gate args.buffer = be->netgr_buffer; 2427c478bd9Sstevel@tonic-gate args.buflen = NSS_BUFLEN_NETGROUP; 2437c478bd9Sstevel@tonic-gate args.status = NSS_NETGR_NO; 2447c478bd9Sstevel@tonic-gate 2457c478bd9Sstevel@tonic-gate if (be->getnetgrent_backend != 0) { 2467c478bd9Sstevel@tonic-gate NSS_INVOKE_DBOP(be->getnetgrent_backend, 2477c478bd9Sstevel@tonic-gate NSS_DBOP_GETENT, &args); 2487c478bd9Sstevel@tonic-gate } 2497c478bd9Sstevel@tonic-gate 2507c478bd9Sstevel@tonic-gate if (args.status == NSS_NETGR_FOUND) { 2517c478bd9Sstevel@tonic-gate *up = args.retp[NSS_NETGR_USER]; 2527c478bd9Sstevel@tonic-gate } else { 2537c478bd9Sstevel@tonic-gate return (B_FALSE); 2547c478bd9Sstevel@tonic-gate } 2557c478bd9Sstevel@tonic-gate } while (*up == 0); 2567c478bd9Sstevel@tonic-gate return (B_TRUE); 2577c478bd9Sstevel@tonic-gate } 2587c478bd9Sstevel@tonic-gate 2597c478bd9Sstevel@tonic-gate static void 2607c478bd9Sstevel@tonic-gate netgr_end(be) 2617c478bd9Sstevel@tonic-gate compat_backend_ptr_t be; 2627c478bd9Sstevel@tonic-gate { 2637c478bd9Sstevel@tonic-gate if (be->getnetgrent_backend != 0) { 2647c478bd9Sstevel@tonic-gate NSS_INVOKE_DBOP(be->getnetgrent_backend, 2657c478bd9Sstevel@tonic-gate NSS_DBOP_DESTRUCTOR, 0); 2667c478bd9Sstevel@tonic-gate be->getnetgrent_backend = 0; 2677c478bd9Sstevel@tonic-gate } 2687c478bd9Sstevel@tonic-gate if (be->netgr_buffer != 0) { 2697c478bd9Sstevel@tonic-gate free(be->netgr_buffer); 2707c478bd9Sstevel@tonic-gate be->netgr_buffer = 0; 2717c478bd9Sstevel@tonic-gate } 2727c478bd9Sstevel@tonic-gate } 2737c478bd9Sstevel@tonic-gate 2747c478bd9Sstevel@tonic-gate 2757c478bd9Sstevel@tonic-gate #define MAXFIELDS 9 /* Sufficient for passwd (7), shadow (9), group (4) */ 2767c478bd9Sstevel@tonic-gate 2777c478bd9Sstevel@tonic-gate static nss_status_t 2787c478bd9Sstevel@tonic-gate do_merge(be, args, instr, linelen) 2797c478bd9Sstevel@tonic-gate compat_backend_ptr_t be; 2807c478bd9Sstevel@tonic-gate nss_XbyY_args_t *args; 2817c478bd9Sstevel@tonic-gate const char *instr; 2827c478bd9Sstevel@tonic-gate int linelen; 2837c478bd9Sstevel@tonic-gate { 2847c478bd9Sstevel@tonic-gate char *fields[MAXFIELDS]; 2857c478bd9Sstevel@tonic-gate int i; 2867c478bd9Sstevel@tonic-gate int overrides; 2877c478bd9Sstevel@tonic-gate const char *p; 2887c478bd9Sstevel@tonic-gate const char *end = instr + linelen; 289cb5caa98Sdjl nss_status_t res = NSS_NOTFOUND; 2907c478bd9Sstevel@tonic-gate 2917c478bd9Sstevel@tonic-gate /* 2927c478bd9Sstevel@tonic-gate * Potential optimization: only perform the field-splitting nonsense 2937c478bd9Sstevel@tonic-gate * once per input line (at present, "+" and "+@netgroup" entries 2947c478bd9Sstevel@tonic-gate * will cause us to do this multiple times in getent() requests). 2957c478bd9Sstevel@tonic-gate */ 2967c478bd9Sstevel@tonic-gate 2977c478bd9Sstevel@tonic-gate for (i = 0; i < MAXFIELDS; i++) { 2987c478bd9Sstevel@tonic-gate fields[i] = 0; 2997c478bd9Sstevel@tonic-gate } 3007c478bd9Sstevel@tonic-gate for (p = instr, overrides = 0, i = 0; /* no test */; i++) { 3017c478bd9Sstevel@tonic-gate const char *q = memchr(p, ':', end - p); 3027c478bd9Sstevel@tonic-gate const char *r = (q == 0) ? end : q; 3037c478bd9Sstevel@tonic-gate ssize_t len = r - p; 3047c478bd9Sstevel@tonic-gate 3057c478bd9Sstevel@tonic-gate if (len > 0) { 3067c478bd9Sstevel@tonic-gate char *s = malloc(len + 1); 3077c478bd9Sstevel@tonic-gate if (s == 0) { 3087c478bd9Sstevel@tonic-gate overrides = -1; /* Indicates "you lose" */ 3097c478bd9Sstevel@tonic-gate break; 3107c478bd9Sstevel@tonic-gate } 311cb5caa98Sdjl (void) memcpy(s, p, len); 3127c478bd9Sstevel@tonic-gate s[len] = '\0'; 3137c478bd9Sstevel@tonic-gate fields[i] = s; 3147c478bd9Sstevel@tonic-gate overrides++; 3157c478bd9Sstevel@tonic-gate } 3167c478bd9Sstevel@tonic-gate if (q == 0) { 3177c478bd9Sstevel@tonic-gate /* End of line */ 3187c478bd9Sstevel@tonic-gate break; 3197c478bd9Sstevel@tonic-gate } else { 3207c478bd9Sstevel@tonic-gate /* Skip the colon at (*q) */ 3217c478bd9Sstevel@tonic-gate p = q + 1; 3227c478bd9Sstevel@tonic-gate } 3237c478bd9Sstevel@tonic-gate } 3247c478bd9Sstevel@tonic-gate if (overrides == 1) { 325cb5caa98Sdjl /* 326cb5caa98Sdjl * return result here if /etc file format is requested 327cb5caa98Sdjl */ 328cb5caa98Sdjl if (be->return_string_data != 1) { 3297c478bd9Sstevel@tonic-gate /* No real overrides, return (*args) intact */ 3307c478bd9Sstevel@tonic-gate res = NSS_SUCCESS; 331cb5caa98Sdjl } else { 332cb5caa98Sdjl free(fields[0]); 333cb5caa98Sdjl fields[0] = NULL; 334cb5caa98Sdjl } 335cb5caa98Sdjl } 336cb5caa98Sdjl 337cb5caa98Sdjl if (overrides > 1 || be->return_string_data == 1) { 3387c478bd9Sstevel@tonic-gate /* 3397c478bd9Sstevel@tonic-gate * The zero'th field is always nonempty (+/-...), but at least 3407c478bd9Sstevel@tonic-gate * one other field was also nonempty, i.e. wants to override 3417c478bd9Sstevel@tonic-gate */ 3427c478bd9Sstevel@tonic-gate switch ((*be->mergef)(be, args, (const char **)fields)) { 3437c478bd9Sstevel@tonic-gate case NSS_STR_PARSE_SUCCESS: 344cb5caa98Sdjl if (be->return_string_data != 1) 3457c478bd9Sstevel@tonic-gate args->returnval = args->buf.result; 346cb5caa98Sdjl else 347cb5caa98Sdjl args->returnval = args->buf.buffer; 3487c478bd9Sstevel@tonic-gate args->erange = 0; 3497c478bd9Sstevel@tonic-gate res = NSS_SUCCESS; 3507c478bd9Sstevel@tonic-gate break; 3517c478bd9Sstevel@tonic-gate case NSS_STR_PARSE_ERANGE: 3527c478bd9Sstevel@tonic-gate args->returnval = 0; 3537c478bd9Sstevel@tonic-gate args->erange = 1; 3547c478bd9Sstevel@tonic-gate res = NSS_NOTFOUND; 3557c478bd9Sstevel@tonic-gate break; 3567c478bd9Sstevel@tonic-gate case NSS_STR_PARSE_PARSE: 3577c478bd9Sstevel@tonic-gate args->returnval = 0; 3587c478bd9Sstevel@tonic-gate args->erange = 0; 3597c478bd9Sstevel@tonic-gate /* ===> Very likely the wrong thing to do... */ 3607c478bd9Sstevel@tonic-gate res = NSS_NOTFOUND; 3617c478bd9Sstevel@tonic-gate break; 3627c478bd9Sstevel@tonic-gate } 363cb5caa98Sdjl } else if (res != NSS_SUCCESS) { 3647c478bd9Sstevel@tonic-gate args->returnval = 0; 3657c478bd9Sstevel@tonic-gate args->erange = 0; 3667c478bd9Sstevel@tonic-gate res = NSS_UNAVAIL; /* ==> Right? */ 3677c478bd9Sstevel@tonic-gate } 3687c478bd9Sstevel@tonic-gate 3697c478bd9Sstevel@tonic-gate for (i = 0; i < MAXFIELDS; i++) { 3707c478bd9Sstevel@tonic-gate if (fields[i] != 0) { 3717c478bd9Sstevel@tonic-gate free(fields[i]); 3727c478bd9Sstevel@tonic-gate } 3737c478bd9Sstevel@tonic-gate } 3747c478bd9Sstevel@tonic-gate 3757c478bd9Sstevel@tonic-gate return (res); 3767c478bd9Sstevel@tonic-gate } 3777c478bd9Sstevel@tonic-gate 3787c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 3797c478bd9Sstevel@tonic-gate nss_status_t 3807c478bd9Sstevel@tonic-gate _nss_compat_setent(be, dummy) 3817c478bd9Sstevel@tonic-gate compat_backend_ptr_t be; 3827c478bd9Sstevel@tonic-gate void *dummy; 3837c478bd9Sstevel@tonic-gate { 3847c478bd9Sstevel@tonic-gate if (be->f == 0) { 3857c478bd9Sstevel@tonic-gate if (be->filename == 0) { 3867c478bd9Sstevel@tonic-gate /* Backend isn't initialized properly? */ 3877c478bd9Sstevel@tonic-gate return (NSS_UNAVAIL); 3887c478bd9Sstevel@tonic-gate } 389004388ebScasper if ((be->f = fopen(be->filename, "rF")) == 0) { 3907c478bd9Sstevel@tonic-gate return (NSS_UNAVAIL); 3917c478bd9Sstevel@tonic-gate } 3927c478bd9Sstevel@tonic-gate } else { 393004388ebScasper rewind(be->f); 3947c478bd9Sstevel@tonic-gate } 3957c478bd9Sstevel@tonic-gate strset_free(&be->minuses); 3967c478bd9Sstevel@tonic-gate /* ===> ??? nss_endent(be->db_rootp, be->db_initf, &be->db_context); */ 3977c478bd9Sstevel@tonic-gate 3987c478bd9Sstevel@tonic-gate if ((strcmp(be->filename, USERATTR_FILENAME) == 0) || 3997c478bd9Sstevel@tonic-gate (strcmp(be->filename, AUDITUSER_FILENAME) == 0)) 4007c478bd9Sstevel@tonic-gate be->state = GETENT_ATTRDB; 4017c478bd9Sstevel@tonic-gate else 4027c478bd9Sstevel@tonic-gate be->state = GETENT_FILE; 4037c478bd9Sstevel@tonic-gate 404*e37190e5Smichen be->return_string_data = 0; 405*e37190e5Smichen 4067c478bd9Sstevel@tonic-gate /* ===> ?? netgroup stuff? */ 4077c478bd9Sstevel@tonic-gate return (NSS_SUCCESS); 4087c478bd9Sstevel@tonic-gate } 4097c478bd9Sstevel@tonic-gate 4107c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 4117c478bd9Sstevel@tonic-gate nss_status_t 4127c478bd9Sstevel@tonic-gate _nss_compat_endent(be, dummy) 4137c478bd9Sstevel@tonic-gate compat_backend_ptr_t be; 4147c478bd9Sstevel@tonic-gate void *dummy; 4157c478bd9Sstevel@tonic-gate { 4167c478bd9Sstevel@tonic-gate if (be->f != 0) { 417cb5caa98Sdjl (void) fclose(be->f); 4187c478bd9Sstevel@tonic-gate be->f = 0; 4197c478bd9Sstevel@tonic-gate } 4207c478bd9Sstevel@tonic-gate if (be->buf != 0) { 4217c478bd9Sstevel@tonic-gate free(be->buf); 4227c478bd9Sstevel@tonic-gate be->buf = 0; 4237c478bd9Sstevel@tonic-gate } 4247c478bd9Sstevel@tonic-gate nss_endent(be->db_rootp, be->db_initf, &be->db_context); 4257c478bd9Sstevel@tonic-gate 4267c478bd9Sstevel@tonic-gate be->state = GETENT_FILE; /* Probably superfluous but comforting */ 4277c478bd9Sstevel@tonic-gate strset_free(&be->minuses); 4287c478bd9Sstevel@tonic-gate netgr_end(be); 4297c478bd9Sstevel@tonic-gate 4307c478bd9Sstevel@tonic-gate /* 4317c478bd9Sstevel@tonic-gate * Question: from the point of view of resource-freeing vs. time to 4327c478bd9Sstevel@tonic-gate * start up again, how much should we do in endent() and how much 4337c478bd9Sstevel@tonic-gate * in the destructor? 4347c478bd9Sstevel@tonic-gate */ 4357c478bd9Sstevel@tonic-gate return (NSS_SUCCESS); 4367c478bd9Sstevel@tonic-gate } 4377c478bd9Sstevel@tonic-gate 4387c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 4397c478bd9Sstevel@tonic-gate nss_status_t 4407c478bd9Sstevel@tonic-gate _nss_compat_destr(be, dummy) 4417c478bd9Sstevel@tonic-gate compat_backend_ptr_t be; 4427c478bd9Sstevel@tonic-gate void *dummy; 4437c478bd9Sstevel@tonic-gate { 4447c478bd9Sstevel@tonic-gate if (be != 0) { 4457c478bd9Sstevel@tonic-gate if (be->f != 0) { 446cb5caa98Sdjl (void) _nss_compat_endent(be, 0); 4477c478bd9Sstevel@tonic-gate } 4487c478bd9Sstevel@tonic-gate nss_delete(be->db_rootp); 4497c478bd9Sstevel@tonic-gate nss_delete(&netgr_db_root); 450ad0e80f7Smichen free(be->workarea); 4517c478bd9Sstevel@tonic-gate free(be); 4527c478bd9Sstevel@tonic-gate } 4537c478bd9Sstevel@tonic-gate return (NSS_SUCCESS); /* In case anyone is dumb enough to check */ 4547c478bd9Sstevel@tonic-gate } 4557c478bd9Sstevel@tonic-gate 4567c478bd9Sstevel@tonic-gate static int 4577c478bd9Sstevel@tonic-gate read_line(f, buffer, buflen) 458004388ebScasper FILE *f; 4597c478bd9Sstevel@tonic-gate char *buffer; 4607c478bd9Sstevel@tonic-gate int buflen; 4617c478bd9Sstevel@tonic-gate { 4627c478bd9Sstevel@tonic-gate /*CONSTCOND*/ 4637c478bd9Sstevel@tonic-gate while (1) { 4647c478bd9Sstevel@tonic-gate int linelen; 4657c478bd9Sstevel@tonic-gate 466004388ebScasper if (fgets(buffer, buflen, f) == 0) { 4677c478bd9Sstevel@tonic-gate /* End of file */ 4687c478bd9Sstevel@tonic-gate return (-1); 4697c478bd9Sstevel@tonic-gate } 4707c478bd9Sstevel@tonic-gate linelen = strlen(buffer); 4717c478bd9Sstevel@tonic-gate /* linelen >= 1 (since fgets didn't return 0) */ 4727c478bd9Sstevel@tonic-gate 4737c478bd9Sstevel@tonic-gate if (buffer[linelen - 1] == '\n') { 4747c478bd9Sstevel@tonic-gate /* 4757c478bd9Sstevel@tonic-gate * ===> The code below that calls read_line() doesn't 4767c478bd9Sstevel@tonic-gate * play by the rules; it assumes in places that 4777c478bd9Sstevel@tonic-gate * the line is null-terminated. For now we'll 4787c478bd9Sstevel@tonic-gate * humour it. 4797c478bd9Sstevel@tonic-gate */ 4807c478bd9Sstevel@tonic-gate buffer[--linelen] = '\0'; 4817c478bd9Sstevel@tonic-gate return (linelen); 4827c478bd9Sstevel@tonic-gate } 483004388ebScasper if (feof(f)) { 4847c478bd9Sstevel@tonic-gate /* Line is last line in file, and has no newline */ 4857c478bd9Sstevel@tonic-gate return (linelen); 4867c478bd9Sstevel@tonic-gate } 4877c478bd9Sstevel@tonic-gate /* Line too long for buffer; toss it and loop for next line */ 4887c478bd9Sstevel@tonic-gate /* ===== should syslog() in cases where previous code did */ 489004388ebScasper while (fgets(buffer, buflen, f) != 0 && 4907c478bd9Sstevel@tonic-gate buffer[strlen(buffer) - 1] != '\n') { 4917c478bd9Sstevel@tonic-gate ; 4927c478bd9Sstevel@tonic-gate } 4937c478bd9Sstevel@tonic-gate } 494cb5caa98Sdjl /*NOTREACHED*/ 4957c478bd9Sstevel@tonic-gate } 4967c478bd9Sstevel@tonic-gate 497738d7c77Svk154806 static int 498738d7c77Svk154806 is_nss_lookup_by_name(int attrdb, nss_dbop_t op) 499738d7c77Svk154806 { 5007c478bd9Sstevel@tonic-gate int result = 0; 5017c478bd9Sstevel@tonic-gate 5027c478bd9Sstevel@tonic-gate if ((attrdb != 0) && 5037c478bd9Sstevel@tonic-gate ((op == NSS_DBOP_AUDITUSER_BYNAME) || 5047c478bd9Sstevel@tonic-gate (op == NSS_DBOP_USERATTR_BYNAME))) { 5057c478bd9Sstevel@tonic-gate result = 1; 5067c478bd9Sstevel@tonic-gate } else if ((attrdb == 0) && 5077c478bd9Sstevel@tonic-gate ((op == NSS_DBOP_GROUP_BYNAME) || 5087c478bd9Sstevel@tonic-gate (op == NSS_DBOP_PASSWD_BYNAME) || 5097c478bd9Sstevel@tonic-gate (op == NSS_DBOP_SHADOW_BYNAME))) { 5107c478bd9Sstevel@tonic-gate result = 1; 5117c478bd9Sstevel@tonic-gate } 5127c478bd9Sstevel@tonic-gate 5137c478bd9Sstevel@tonic-gate return (result); 5147c478bd9Sstevel@tonic-gate } 5157c478bd9Sstevel@tonic-gate 5167c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 5177c478bd9Sstevel@tonic-gate nss_status_t 5187c478bd9Sstevel@tonic-gate _attrdb_compat_XY_all(be, argp, netdb, check, op_num) 5197c478bd9Sstevel@tonic-gate compat_backend_ptr_t be; 5207c478bd9Sstevel@tonic-gate nss_XbyY_args_t *argp; 5217c478bd9Sstevel@tonic-gate int netdb; 5227c478bd9Sstevel@tonic-gate compat_XY_check_func check; 5237c478bd9Sstevel@tonic-gate nss_dbop_t op_num; 5247c478bd9Sstevel@tonic-gate { 5257c478bd9Sstevel@tonic-gate int parsestat; 5267c478bd9Sstevel@tonic-gate int (*func)(); 5277c478bd9Sstevel@tonic-gate const char *filter = argp->key.name; 5287c478bd9Sstevel@tonic-gate nss_status_t res; 5297c478bd9Sstevel@tonic-gate 5307c478bd9Sstevel@tonic-gate #ifdef DEBUG 5317c478bd9Sstevel@tonic-gate (void) fprintf(stdout, "\n[compat_common.c: _attrdb_compat_XY_all]\n"); 5327c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 5337c478bd9Sstevel@tonic-gate 5347c478bd9Sstevel@tonic-gate if (be->buf == 0 && 5357c478bd9Sstevel@tonic-gate (be->buf = malloc(be->minbuf)) == 0) { 5367c478bd9Sstevel@tonic-gate return (NSS_UNAVAIL); 5377c478bd9Sstevel@tonic-gate } 538cb5caa98Sdjl if (check != NULL) 539cb5caa98Sdjl if ((res = _nss_compat_setent(be, 0)) != NSS_SUCCESS) 5407c478bd9Sstevel@tonic-gate return (res); 541cb5caa98Sdjl 5427c478bd9Sstevel@tonic-gate res = NSS_NOTFOUND; 5437c478bd9Sstevel@tonic-gate 544cb5caa98Sdjl /* 545cb5caa98Sdjl * assume a NULL buf.result pointer is an indication 546cb5caa98Sdjl * that the lookup result should be returned in /etc 547cb5caa98Sdjl * file format 548cb5caa98Sdjl */ 549cb5caa98Sdjl if (argp->buf.result == NULL) { 550cb5caa98Sdjl be->return_string_data = 1; 551cb5caa98Sdjl 552cb5caa98Sdjl /* 553cb5caa98Sdjl * the code executed later needs the result struct 554cb5caa98Sdjl * as working area 555cb5caa98Sdjl */ 556ad0e80f7Smichen argp->buf.result = be->workarea; 557ad0e80f7Smichen func = be->str2ent_alt; 558*e37190e5Smichen } else { 559*e37190e5Smichen be->return_string_data = 0; 560cb5caa98Sdjl func = argp->str2ent; 561*e37190e5Smichen } 562cb5caa98Sdjl 5637c478bd9Sstevel@tonic-gate /*CONSTCOND*/ 5647c478bd9Sstevel@tonic-gate while (1) { 5657c478bd9Sstevel@tonic-gate int linelen; 5667c478bd9Sstevel@tonic-gate char *instr = be->buf; 5677c478bd9Sstevel@tonic-gate 5687c478bd9Sstevel@tonic-gate if ((linelen = read_line(be->f, instr, be->minbuf)) < 0) { 5697c478bd9Sstevel@tonic-gate /* End of file */ 5707c478bd9Sstevel@tonic-gate argp->returnval = 0; 5717c478bd9Sstevel@tonic-gate argp->erange = 0; 5727c478bd9Sstevel@tonic-gate break; 5737c478bd9Sstevel@tonic-gate } 5747c478bd9Sstevel@tonic-gate if (filter != 0 && strstr(instr, filter) == 0) { 5757c478bd9Sstevel@tonic-gate /* 5767c478bd9Sstevel@tonic-gate * Optimization: if the entry doesn't contain the 5777c478bd9Sstevel@tonic-gate * filter string then it can't be the entry we want, 5787c478bd9Sstevel@tonic-gate * so don't bother looking more closely at it. 5797c478bd9Sstevel@tonic-gate */ 5807c478bd9Sstevel@tonic-gate continue; 5817c478bd9Sstevel@tonic-gate } 5827c478bd9Sstevel@tonic-gate if (netdb) { 5837c478bd9Sstevel@tonic-gate char *first; 5847c478bd9Sstevel@tonic-gate char *last; 5857c478bd9Sstevel@tonic-gate 5867c478bd9Sstevel@tonic-gate if ((last = strchr(instr, '#')) == 0) { 5877c478bd9Sstevel@tonic-gate last = instr + linelen; 5887c478bd9Sstevel@tonic-gate } 5897c478bd9Sstevel@tonic-gate *last-- = '\0'; /* Nuke '\n' or #comment */ 5907c478bd9Sstevel@tonic-gate 5917c478bd9Sstevel@tonic-gate /* 5927c478bd9Sstevel@tonic-gate * Skip leading whitespace. Normally there isn't 5937c478bd9Sstevel@tonic-gate * any, so it's not worth calling strspn(). 5947c478bd9Sstevel@tonic-gate */ 5957c478bd9Sstevel@tonic-gate for (first = instr; isspace(*first); first++) { 5967c478bd9Sstevel@tonic-gate ; 5977c478bd9Sstevel@tonic-gate } 5987c478bd9Sstevel@tonic-gate if (*first == '\0') { 5997c478bd9Sstevel@tonic-gate continue; 6007c478bd9Sstevel@tonic-gate } 6017c478bd9Sstevel@tonic-gate /* 6027c478bd9Sstevel@tonic-gate * Found something non-blank on the line. Skip back 6037c478bd9Sstevel@tonic-gate * over any trailing whitespace; since we know 6047c478bd9Sstevel@tonic-gate * there's non-whitespace earlier in the line, 6057c478bd9Sstevel@tonic-gate * checking for termination is easy. 6067c478bd9Sstevel@tonic-gate */ 6077c478bd9Sstevel@tonic-gate while (isspace(*last)) { 6087c478bd9Sstevel@tonic-gate --last; 6097c478bd9Sstevel@tonic-gate } 6107c478bd9Sstevel@tonic-gate linelen = last - first + 1; 6117c478bd9Sstevel@tonic-gate if (first != instr) { 6127c478bd9Sstevel@tonic-gate instr = first; 6137c478bd9Sstevel@tonic-gate } 6147c478bd9Sstevel@tonic-gate } 6157c478bd9Sstevel@tonic-gate argp->returnval = 0; 6167c478bd9Sstevel@tonic-gate parsestat = (*func)(instr, linelen, argp->buf.result, 6177c478bd9Sstevel@tonic-gate argp->buf.buffer, argp->buf.buflen); 6187c478bd9Sstevel@tonic-gate if (parsestat == NSS_STR_PARSE_SUCCESS) { 6197c478bd9Sstevel@tonic-gate argp->returnval = argp->buf.result; 6207c478bd9Sstevel@tonic-gate if (check == 0 || (*check)(argp)) { 621cb5caa98Sdjl int len; 622cb5caa98Sdjl 623cb5caa98Sdjl if (be->return_string_data != 1) { 624cb5caa98Sdjl res = NSS_SUCCESS; 625cb5caa98Sdjl break; 626cb5caa98Sdjl } 627cb5caa98Sdjl 628cb5caa98Sdjl /* copy string data to result buffer */ 629cb5caa98Sdjl argp->buf.result = NULL; 630cb5caa98Sdjl argp->returnval = argp->buf.buffer; 631cb5caa98Sdjl if ((len = strlcpy(argp->buf.buffer, instr, 632cb5caa98Sdjl argp->buf.buflen)) >= 633cb5caa98Sdjl argp->buf.buflen) { 634cb5caa98Sdjl argp->returnval = NULL; 635cb5caa98Sdjl res = NSS_NOTFOUND; 636cb5caa98Sdjl argp->erange = 1; 637cb5caa98Sdjl break; 638cb5caa98Sdjl } 639cb5caa98Sdjl 640cb5caa98Sdjl argp->returnlen = len; 6417c478bd9Sstevel@tonic-gate res = NSS_SUCCESS; 6427c478bd9Sstevel@tonic-gate break; 6437c478bd9Sstevel@tonic-gate } 6447c478bd9Sstevel@tonic-gate } else if (parsestat == NSS_STR_PARSE_ERANGE) { 645cb5caa98Sdjl res = NSS_NOTFOUND; 6467c478bd9Sstevel@tonic-gate argp->erange = 1; 6477c478bd9Sstevel@tonic-gate break; 6487c478bd9Sstevel@tonic-gate } 6497c478bd9Sstevel@tonic-gate } 6507c478bd9Sstevel@tonic-gate /* 6517c478bd9Sstevel@tonic-gate * stayopen is set to 0 by default in order to close the opened 6527c478bd9Sstevel@tonic-gate * file. Some applications may break if it is set to 1. 6537c478bd9Sstevel@tonic-gate */ 6547c478bd9Sstevel@tonic-gate if (check != 0 && !argp->stayopen) { 6557c478bd9Sstevel@tonic-gate (void) _nss_compat_endent(be, 0); 6567c478bd9Sstevel@tonic-gate } 6577c478bd9Sstevel@tonic-gate 6587c478bd9Sstevel@tonic-gate if (res != NSS_SUCCESS) { 659cb5caa98Sdjl /* 660cb5caa98Sdjl * tell the nss_search() and nss_getent() below 661cb5caa98Sdjl * if the result should be returned in the /etc 662cb5caa98Sdjl * file format 663cb5caa98Sdjl */ 664cb5caa98Sdjl if (be->return_string_data == 1) 665cb5caa98Sdjl argp->buf.result = NULL; 666cb5caa98Sdjl 6677c478bd9Sstevel@tonic-gate if ((op_num == NSS_DBOP_USERATTR_BYNAME) || 6687c478bd9Sstevel@tonic-gate (op_num == NSS_DBOP_AUDITUSER_BYNAME)) { 6697c478bd9Sstevel@tonic-gate res = nss_search(be->db_rootp, 6707c478bd9Sstevel@tonic-gate be->db_initf, 6717c478bd9Sstevel@tonic-gate op_num, 6727c478bd9Sstevel@tonic-gate argp); 6737c478bd9Sstevel@tonic-gate } else { 6747c478bd9Sstevel@tonic-gate res = nss_getent(be->db_rootp, 6757c478bd9Sstevel@tonic-gate be->db_initf, &be->db_context, argp); 6767c478bd9Sstevel@tonic-gate } 6777c478bd9Sstevel@tonic-gate if (res != NSS_SUCCESS) { 6787c478bd9Sstevel@tonic-gate argp->returnval = 0; 6797c478bd9Sstevel@tonic-gate argp->erange = 0; 6807c478bd9Sstevel@tonic-gate } 6817c478bd9Sstevel@tonic-gate } 6827c478bd9Sstevel@tonic-gate 6837c478bd9Sstevel@tonic-gate return (res); 6847c478bd9Sstevel@tonic-gate } 6857c478bd9Sstevel@tonic-gate 6867c478bd9Sstevel@tonic-gate nss_status_t 6877c478bd9Sstevel@tonic-gate _nss_compat_XY_all(be, args, check, op_num) 6887c478bd9Sstevel@tonic-gate compat_backend_ptr_t be; 6897c478bd9Sstevel@tonic-gate nss_XbyY_args_t *args; 6907c478bd9Sstevel@tonic-gate compat_XY_check_func check; 6917c478bd9Sstevel@tonic-gate nss_dbop_t op_num; 6927c478bd9Sstevel@tonic-gate { 6937c478bd9Sstevel@tonic-gate nss_status_t res; 6947c478bd9Sstevel@tonic-gate int parsestat; 695cb5caa98Sdjl 6967c478bd9Sstevel@tonic-gate 6977c478bd9Sstevel@tonic-gate if (be->buf == 0 && 6987c478bd9Sstevel@tonic-gate (be->buf = malloc(be->minbuf)) == 0) { 6997c478bd9Sstevel@tonic-gate return (NSS_UNAVAIL); /* really panic, malloc failed */ 7007c478bd9Sstevel@tonic-gate } 7017c478bd9Sstevel@tonic-gate 7027c478bd9Sstevel@tonic-gate if ((res = _nss_compat_setent(be, 0)) != NSS_SUCCESS) { 7037c478bd9Sstevel@tonic-gate return (res); 7047c478bd9Sstevel@tonic-gate } 7057c478bd9Sstevel@tonic-gate 7067c478bd9Sstevel@tonic-gate res = NSS_NOTFOUND; 7077c478bd9Sstevel@tonic-gate 708cb5caa98Sdjl /* 709cb5caa98Sdjl * assume a NULL buf.result pointer is an indication 710cb5caa98Sdjl * that the lookup result should be returned in /etc 711cb5caa98Sdjl * file format 712cb5caa98Sdjl */ 713cb5caa98Sdjl if (args->buf.result == NULL) { 714cb5caa98Sdjl 715cb5caa98Sdjl be->return_string_data = 1; 716cb5caa98Sdjl 717cb5caa98Sdjl /* 718cb5caa98Sdjl * the code executed later needs the result struct 719cb5caa98Sdjl * as working area 720cb5caa98Sdjl */ 721ad0e80f7Smichen args->buf.result = be->workarea; 722cb5caa98Sdjl 723ad0e80f7Smichen be->str2ent_save = args->str2ent; 724ad0e80f7Smichen args->str2ent = be->str2ent_alt; 725*e37190e5Smichen } else 726*e37190e5Smichen be->return_string_data = 0; 727cb5caa98Sdjl 7287c478bd9Sstevel@tonic-gate /*CONSTCOND*/ 7297c478bd9Sstevel@tonic-gate while (1) { 7307c478bd9Sstevel@tonic-gate int linelen; 7317c478bd9Sstevel@tonic-gate char *instr = be->buf; 7327c478bd9Sstevel@tonic-gate char *colon; 7337c478bd9Sstevel@tonic-gate 7347c478bd9Sstevel@tonic-gate linelen = read_line(be->f, instr, be->minbuf); 7357c478bd9Sstevel@tonic-gate if (linelen < 0) { 7367c478bd9Sstevel@tonic-gate /* End of file */ 7377c478bd9Sstevel@tonic-gate args->returnval = 0; 7387c478bd9Sstevel@tonic-gate args->erange = 0; 7397c478bd9Sstevel@tonic-gate break; 7407c478bd9Sstevel@tonic-gate } 7417c478bd9Sstevel@tonic-gate 7427c478bd9Sstevel@tonic-gate args->returnval = 0; /* reset for both types of entries */ 7437c478bd9Sstevel@tonic-gate 7447c478bd9Sstevel@tonic-gate if (instr[0] != '+' && instr[0] != '-') { 7457c478bd9Sstevel@tonic-gate /* Simple, wholesome, God-fearing entry */ 7467c478bd9Sstevel@tonic-gate parsestat = (*args->str2ent)(instr, linelen, 7477c478bd9Sstevel@tonic-gate args->buf.result, 7487c478bd9Sstevel@tonic-gate args->buf.buffer, 7497c478bd9Sstevel@tonic-gate args->buf.buflen); 7507c478bd9Sstevel@tonic-gate if (parsestat == NSS_STR_PARSE_SUCCESS) { 7517c478bd9Sstevel@tonic-gate args->returnval = args->buf.result; 7527c478bd9Sstevel@tonic-gate if ((*check)(args) != 0) { 753cb5caa98Sdjl int len; 754cb5caa98Sdjl if (be->return_string_data != 1) { 7557c478bd9Sstevel@tonic-gate res = NSS_SUCCESS; 7567c478bd9Sstevel@tonic-gate break; 7577c478bd9Sstevel@tonic-gate } 7587c478bd9Sstevel@tonic-gate 759cb5caa98Sdjl /* 760cb5caa98Sdjl * copy string data to 761cb5caa98Sdjl * result buffer 762cb5caa98Sdjl */ 763cb5caa98Sdjl args->buf.result = NULL; 764ad0e80f7Smichen args->str2ent = be->str2ent_save; 765cb5caa98Sdjl if ((len = strlcpy(args->buf.buffer, 766cb5caa98Sdjl instr, args->buf.buflen)) >= 767cb5caa98Sdjl args->buf.buflen) 768cb5caa98Sdjl parsestat = 769cb5caa98Sdjl NSS_STR_PARSE_ERANGE; 770cb5caa98Sdjl else { 771cb5caa98Sdjl args->returnval = 772cb5caa98Sdjl args->buf.buffer; 773cb5caa98Sdjl args->returnlen = len; 774cb5caa98Sdjl res = NSS_SUCCESS; 775cb5caa98Sdjl break; 776cb5caa98Sdjl } 777cb5caa98Sdjl } else 778cb5caa98Sdjl continue; 779cb5caa98Sdjl } 780cb5caa98Sdjl 7817c478bd9Sstevel@tonic-gate /* ===> Check the Dani logic here... */ 7827c478bd9Sstevel@tonic-gate 783cb5caa98Sdjl if (parsestat == NSS_STR_PARSE_ERANGE) { 7847c478bd9Sstevel@tonic-gate args->erange = 1; 7857c478bd9Sstevel@tonic-gate res = NSS_NOTFOUND; 7867c478bd9Sstevel@tonic-gate break; 7877c478bd9Sstevel@tonic-gate /* should we just skip this one long line ? */ 7887c478bd9Sstevel@tonic-gate } /* else if (parsestat == NSS_STR_PARSE_PARSE) */ 7897c478bd9Sstevel@tonic-gate /* don't care ! */ 7907c478bd9Sstevel@tonic-gate 7917c478bd9Sstevel@tonic-gate /* ==> ?? */ continue; 7927c478bd9Sstevel@tonic-gate } 7937c478bd9Sstevel@tonic-gate 794cb5caa98Sdjl 7957c478bd9Sstevel@tonic-gate /* 7967c478bd9Sstevel@tonic-gate * Process "+", "+name", "+@netgroup", "-name" or "-@netgroup" 7977c478bd9Sstevel@tonic-gate * 7987c478bd9Sstevel@tonic-gate * This code is optimized for lookups by name. 7997c478bd9Sstevel@tonic-gate * 8007c478bd9Sstevel@tonic-gate * For lookups by identifier search key cannot be matched with 8017c478bd9Sstevel@tonic-gate * the name of the "+" or "-" entry. So nss_search() is to be 8027c478bd9Sstevel@tonic-gate * called before extracting the name i.e. via (*be->getnamef)(). 8037c478bd9Sstevel@tonic-gate * 8047c478bd9Sstevel@tonic-gate * But for lookups by name, search key is compared with the name 8057c478bd9Sstevel@tonic-gate * of the "+" or "-" entry to acquire a match and thus 8067c478bd9Sstevel@tonic-gate * unnesessary calls to nss_search() is eliminated. Also for 8077c478bd9Sstevel@tonic-gate * matching "-" entries, calls to nss_search() is eliminated. 8087c478bd9Sstevel@tonic-gate */ 8097c478bd9Sstevel@tonic-gate 8107c478bd9Sstevel@tonic-gate if ((colon = strchr(instr, ':')) != 0) { 8117c478bd9Sstevel@tonic-gate *colon = '\0'; /* terminate field to extract name */ 8127c478bd9Sstevel@tonic-gate } 8137c478bd9Sstevel@tonic-gate 8147c478bd9Sstevel@tonic-gate if (instr[1] == '@') { 8157c478bd9Sstevel@tonic-gate /* 8167c478bd9Sstevel@tonic-gate * Case 1: 8177c478bd9Sstevel@tonic-gate * The entry is of the form "+@netgroup" or 8187c478bd9Sstevel@tonic-gate * "-@netgroup". If we're performing a lookup by name, 8197c478bd9Sstevel@tonic-gate * we can simply extract the name from the search key 8207c478bd9Sstevel@tonic-gate * (i.e. args->key.name). If not, then we must call 8217c478bd9Sstevel@tonic-gate * nss_search() before extracting the name via the 8227c478bd9Sstevel@tonic-gate * get_XXname() function. i.e. (*be->getnamef)(args). 8237c478bd9Sstevel@tonic-gate */ 824738d7c77Svk154806 if (is_nss_lookup_by_name(0, op_num) != 0) { 8257c478bd9Sstevel@tonic-gate /* compare then search */ 8267c478bd9Sstevel@tonic-gate if (!be->permit_netgroups || 8277c478bd9Sstevel@tonic-gate !netgr_in(be, instr + 2, args->key.name)) 8287c478bd9Sstevel@tonic-gate continue; 8297c478bd9Sstevel@tonic-gate if (instr[0] == '+') { 8307c478bd9Sstevel@tonic-gate /* need to search for "+" entry */ 831cb5caa98Sdjl (void) nss_search(be->db_rootp, 832cb5caa98Sdjl be->db_initf, op_num, args); 8337c478bd9Sstevel@tonic-gate if (args->returnval == 0) 8347c478bd9Sstevel@tonic-gate continue; 8357c478bd9Sstevel@tonic-gate } 8367c478bd9Sstevel@tonic-gate } else { 8377c478bd9Sstevel@tonic-gate /* search then compare */ 838cb5caa98Sdjl (void) nss_search(be->db_rootp, 839cb5caa98Sdjl be->db_initf, op_num, args); 8407c478bd9Sstevel@tonic-gate if (args->returnval == 0) 8417c478bd9Sstevel@tonic-gate continue; 8427c478bd9Sstevel@tonic-gate if (!be->permit_netgroups || 843738d7c77Svk154806 !netgr_in(be, instr + 2, 844738d7c77Svk154806 (*be->getnamef)(args))) 8457c478bd9Sstevel@tonic-gate continue; 8467c478bd9Sstevel@tonic-gate } 847738d7c77Svk154806 } else if (instr[1] == '\0') { 8487c478bd9Sstevel@tonic-gate /* 8497c478bd9Sstevel@tonic-gate * Case 2: 8507c478bd9Sstevel@tonic-gate * The entry is of the form "+" or "-". The former 8517c478bd9Sstevel@tonic-gate * allows all entries from name services. The latter 8527c478bd9Sstevel@tonic-gate * is illegal and ought to be ignored. 8537c478bd9Sstevel@tonic-gate */ 8547c478bd9Sstevel@tonic-gate if (instr[0] == '-') 8557c478bd9Sstevel@tonic-gate continue; 8567c478bd9Sstevel@tonic-gate /* need to search for "+" entry */ 857cb5caa98Sdjl (void) nss_search(be->db_rootp, be->db_initf, 858cb5caa98Sdjl op_num, args); 8597c478bd9Sstevel@tonic-gate if (args->returnval == 0) 8607c478bd9Sstevel@tonic-gate continue; 861738d7c77Svk154806 } else { 8627c478bd9Sstevel@tonic-gate /* 8637c478bd9Sstevel@tonic-gate * Case 3: 8647c478bd9Sstevel@tonic-gate * The entry is of the form "+name" or "-name". 8657c478bd9Sstevel@tonic-gate * If we're performing a lookup by name, we can simply 8667c478bd9Sstevel@tonic-gate * extract the name from the search key 8677c478bd9Sstevel@tonic-gate * (i.e. args->key.name). If not, then we must call 8687c478bd9Sstevel@tonic-gate * nss_search() before extracting the name via the 8697c478bd9Sstevel@tonic-gate * get_XXname() function. i.e. (*be->getnamef)(args). 8707c478bd9Sstevel@tonic-gate */ 871738d7c77Svk154806 if (is_nss_lookup_by_name(0, op_num) != 0) { 8727c478bd9Sstevel@tonic-gate /* compare then search */ 8737c478bd9Sstevel@tonic-gate if (strcmp(instr + 1, args->key.name) != 0) 8747c478bd9Sstevel@tonic-gate continue; 8757c478bd9Sstevel@tonic-gate if (instr[0] == '+') { 8767c478bd9Sstevel@tonic-gate /* need to search for "+" entry */ 877cb5caa98Sdjl (void) nss_search(be->db_rootp, 878cb5caa98Sdjl be->db_initf, op_num, args); 8797c478bd9Sstevel@tonic-gate if (args->returnval == 0) 8807c478bd9Sstevel@tonic-gate continue; 8817c478bd9Sstevel@tonic-gate } 8827c478bd9Sstevel@tonic-gate } else { 8837c478bd9Sstevel@tonic-gate /* search then compare */ 884cb5caa98Sdjl (void) nss_search(be->db_rootp, 885cb5caa98Sdjl be->db_initf, op_num, args); 8867c478bd9Sstevel@tonic-gate if (args->returnval == 0) 8877c478bd9Sstevel@tonic-gate continue; 8887c478bd9Sstevel@tonic-gate if (strcmp(instr + 1, (*be->getnamef)(args)) 8897c478bd9Sstevel@tonic-gate != 0) 8907c478bd9Sstevel@tonic-gate continue; 8917c478bd9Sstevel@tonic-gate } 892738d7c77Svk154806 } 8937c478bd9Sstevel@tonic-gate if (instr[0] == '-') { 8947c478bd9Sstevel@tonic-gate /* no need to search for "-" entry */ 8957c478bd9Sstevel@tonic-gate args->returnval = 0; 8967c478bd9Sstevel@tonic-gate args->erange = 0; 8977c478bd9Sstevel@tonic-gate res = NSS_NOTFOUND; 8987c478bd9Sstevel@tonic-gate } else { 8997c478bd9Sstevel@tonic-gate if (colon != 0) 9007c478bd9Sstevel@tonic-gate *colon = ':'; /* restoration */ 9017c478bd9Sstevel@tonic-gate res = do_merge(be, args, instr, linelen); 9027c478bd9Sstevel@tonic-gate } 9037c478bd9Sstevel@tonic-gate break; 9047c478bd9Sstevel@tonic-gate } 9057c478bd9Sstevel@tonic-gate 9067c478bd9Sstevel@tonic-gate /* 9077c478bd9Sstevel@tonic-gate * stayopen is set to 0 by default in order to close the opened 9087c478bd9Sstevel@tonic-gate * file. Some applications may break if it is set to 1. 9097c478bd9Sstevel@tonic-gate */ 9107c478bd9Sstevel@tonic-gate if (!args->stayopen) { 9117c478bd9Sstevel@tonic-gate (void) _nss_compat_endent(be, 0); 9127c478bd9Sstevel@tonic-gate } 9137c478bd9Sstevel@tonic-gate 914cb5caa98Sdjl if (be->return_string_data == 1) { 915ad0e80f7Smichen args->str2ent = be->str2ent_save; 916cb5caa98Sdjl } 917cb5caa98Sdjl 9187c478bd9Sstevel@tonic-gate return (res); 9197c478bd9Sstevel@tonic-gate } 9207c478bd9Sstevel@tonic-gate 9217c478bd9Sstevel@tonic-gate nss_status_t 9227c478bd9Sstevel@tonic-gate _nss_compat_getent(be, a) 9237c478bd9Sstevel@tonic-gate compat_backend_ptr_t be; 9247c478bd9Sstevel@tonic-gate void *a; 9257c478bd9Sstevel@tonic-gate { 9267c478bd9Sstevel@tonic-gate nss_XbyY_args_t *args = (nss_XbyY_args_t *)a; 9277c478bd9Sstevel@tonic-gate nss_status_t res; 9287c478bd9Sstevel@tonic-gate char *colon = 0; /* <=== need comment re lifetime */ 9297c478bd9Sstevel@tonic-gate 9307c478bd9Sstevel@tonic-gate if (be->f == 0) { 9317c478bd9Sstevel@tonic-gate if ((res = _nss_compat_setent(be, 0)) != NSS_SUCCESS) { 9327c478bd9Sstevel@tonic-gate return (res); 9337c478bd9Sstevel@tonic-gate } 9347c478bd9Sstevel@tonic-gate } 9357c478bd9Sstevel@tonic-gate 9367c478bd9Sstevel@tonic-gate if (be->buf == 0 && 9377c478bd9Sstevel@tonic-gate (be->buf = malloc(be->minbuf)) == 0) { 9387c478bd9Sstevel@tonic-gate return (NSS_UNAVAIL); /* really panic, malloc failed */ 9397c478bd9Sstevel@tonic-gate } 9407c478bd9Sstevel@tonic-gate 941cb5caa98Sdjl /* 942cb5caa98Sdjl * assume a NULL buf.result pointer is an indication 943cb5caa98Sdjl * that the lookup result should be returned in /etc 944cb5caa98Sdjl * file format 945cb5caa98Sdjl */ 946cb5caa98Sdjl if (args->buf.result == NULL) { 947cb5caa98Sdjl be->return_string_data = 1; 948cb5caa98Sdjl 949cb5caa98Sdjl /* 950cb5caa98Sdjl * the code executed later needs the result struct 951cb5caa98Sdjl * as working area 952cb5caa98Sdjl */ 953ad0e80f7Smichen args->buf.result = be->workarea; 954*e37190e5Smichen } else 955*e37190e5Smichen be->return_string_data = 0; 956cb5caa98Sdjl 9577c478bd9Sstevel@tonic-gate /*CONSTCOND*/ 9587c478bd9Sstevel@tonic-gate while (1) { 9597c478bd9Sstevel@tonic-gate char *instr = be->buf; 9607c478bd9Sstevel@tonic-gate int linelen; 9617c478bd9Sstevel@tonic-gate char *name; /* === Need more distinctive label */ 9627c478bd9Sstevel@tonic-gate const char *savename; 9637c478bd9Sstevel@tonic-gate 9647c478bd9Sstevel@tonic-gate /* 9657c478bd9Sstevel@tonic-gate * In the code below... 9667c478bd9Sstevel@tonic-gate * break means "I found one, I think" (i.e. goto the 9677c478bd9Sstevel@tonic-gate * code after the end of the switch statement), 9687c478bd9Sstevel@tonic-gate * continue means "Next candidate" 9697c478bd9Sstevel@tonic-gate * (i.e. loop around to the switch statement), 9707c478bd9Sstevel@tonic-gate * return means "I'm quite sure" (either Yes or No). 9717c478bd9Sstevel@tonic-gate */ 9727c478bd9Sstevel@tonic-gate switch (be->state) { 9737c478bd9Sstevel@tonic-gate 9747c478bd9Sstevel@tonic-gate case GETENT_DONE: 9757c478bd9Sstevel@tonic-gate args->returnval = 0; 9767c478bd9Sstevel@tonic-gate args->erange = 0; 9777c478bd9Sstevel@tonic-gate return (NSS_NOTFOUND); 9787c478bd9Sstevel@tonic-gate 9797c478bd9Sstevel@tonic-gate case GETENT_ATTRDB: 980cb5caa98Sdjl args->key.name = NULL; 9817c478bd9Sstevel@tonic-gate res = _attrdb_compat_XY_all(be, 9827c478bd9Sstevel@tonic-gate args, 1, (compat_XY_check_func)NULL, 0); 9837c478bd9Sstevel@tonic-gate return (res); 9847c478bd9Sstevel@tonic-gate 9857c478bd9Sstevel@tonic-gate case GETENT_FILE: 9867c478bd9Sstevel@tonic-gate linelen = read_line(be->f, instr, be->minbuf); 9877c478bd9Sstevel@tonic-gate if (linelen < 0) { 9887c478bd9Sstevel@tonic-gate /* End of file */ 9897c478bd9Sstevel@tonic-gate be->state = GETENT_DONE; 9907c478bd9Sstevel@tonic-gate continue; 9917c478bd9Sstevel@tonic-gate } 9927c478bd9Sstevel@tonic-gate if ((colon = strchr(instr, ':')) != 0) { 9937c478bd9Sstevel@tonic-gate *colon = '\0'; 9947c478bd9Sstevel@tonic-gate } 9957c478bd9Sstevel@tonic-gate if (instr[0] == '-') { 9967c478bd9Sstevel@tonic-gate if (instr[1] != '@') { 997cb5caa98Sdjl (void) strset_add(&be->minuses, 998cb5caa98Sdjl instr + 1); 9997c478bd9Sstevel@tonic-gate } else if (be->permit_netgroups) { 10007c478bd9Sstevel@tonic-gate netgr_set(be, instr + 2); 10017c478bd9Sstevel@tonic-gate while (netgr_next_u(be, &name)) { 1002cb5caa98Sdjl (void) strset_add(&be->minuses, 10037c478bd9Sstevel@tonic-gate name); 10047c478bd9Sstevel@tonic-gate } 10057c478bd9Sstevel@tonic-gate netgr_end(be); 10067c478bd9Sstevel@tonic-gate } /* Else (silently) ignore the entry */ 10077c478bd9Sstevel@tonic-gate continue; 10087c478bd9Sstevel@tonic-gate } else if (instr[0] != '+') { 10097c478bd9Sstevel@tonic-gate int parsestat; 10107c478bd9Sstevel@tonic-gate /* 10117c478bd9Sstevel@tonic-gate * Normal entry, no +/- nonsense 10127c478bd9Sstevel@tonic-gate */ 10137c478bd9Sstevel@tonic-gate if (colon != 0) { 10147c478bd9Sstevel@tonic-gate *colon = ':'; 10157c478bd9Sstevel@tonic-gate } 10167c478bd9Sstevel@tonic-gate args->returnval = 0; 10177c478bd9Sstevel@tonic-gate parsestat = (*args->str2ent)(instr, linelen, 10187c478bd9Sstevel@tonic-gate args->buf.result, 10197c478bd9Sstevel@tonic-gate args->buf.buffer, 10207c478bd9Sstevel@tonic-gate args->buf.buflen); 10217c478bd9Sstevel@tonic-gate if (parsestat == NSS_STR_PARSE_SUCCESS) { 1022cb5caa98Sdjl int len; 1023cb5caa98Sdjl 1024cb5caa98Sdjl if (be->return_string_data != 1) { 1025cb5caa98Sdjl args->returnval = 1026cb5caa98Sdjl args->buf.result; 10277c478bd9Sstevel@tonic-gate return (NSS_SUCCESS); 10287c478bd9Sstevel@tonic-gate } 1029cb5caa98Sdjl 1030cb5caa98Sdjl /* 1031cb5caa98Sdjl * copy string data to 1032cb5caa98Sdjl * result buffer 1033cb5caa98Sdjl */ 1034cb5caa98Sdjl args->buf.result = NULL; 1035cb5caa98Sdjl args->returnval = 1036cb5caa98Sdjl args->buf.buffer; 1037cb5caa98Sdjl if ((len = strlcpy(args->buf.buffer, 1038cb5caa98Sdjl instr, args->buf.buflen)) >= 1039cb5caa98Sdjl args->buf.buflen) 1040cb5caa98Sdjl parsestat = 1041cb5caa98Sdjl NSS_STR_PARSE_ERANGE; 1042cb5caa98Sdjl else { 1043cb5caa98Sdjl args->returnlen = len; 1044cb5caa98Sdjl return (NSS_SUCCESS); 1045cb5caa98Sdjl } 1046cb5caa98Sdjl } 10477c478bd9Sstevel@tonic-gate /* ==> ?? Treat ERANGE differently ?? */ 10487c478bd9Sstevel@tonic-gate if (parsestat == NSS_STR_PARSE_ERANGE) { 10497c478bd9Sstevel@tonic-gate args->returnval = 0; 10507c478bd9Sstevel@tonic-gate args->erange = 1; 10517c478bd9Sstevel@tonic-gate return (NSS_NOTFOUND); 10527c478bd9Sstevel@tonic-gate } 10537c478bd9Sstevel@tonic-gate /* Skip the offending entry, get next */ 10547c478bd9Sstevel@tonic-gate continue; 10557c478bd9Sstevel@tonic-gate } else if (instr[1] == '\0') { 10567c478bd9Sstevel@tonic-gate /* Plain "+" */ 10577c478bd9Sstevel@tonic-gate nss_setent(be->db_rootp, be->db_initf, 10587c478bd9Sstevel@tonic-gate &be->db_context); 10597c478bd9Sstevel@tonic-gate be->state = GETENT_ALL; 10607c478bd9Sstevel@tonic-gate be->linelen = linelen; 1061ad0e80f7Smichen 10627c478bd9Sstevel@tonic-gate continue; 10637c478bd9Sstevel@tonic-gate } else if (instr[1] == '@') { 10647c478bd9Sstevel@tonic-gate /* "+@netgroup" */ 10657c478bd9Sstevel@tonic-gate netgr_set(be, instr + 2); 10667c478bd9Sstevel@tonic-gate be->state = GETENT_NETGROUP; 10677c478bd9Sstevel@tonic-gate be->linelen = linelen; 10687c478bd9Sstevel@tonic-gate continue; 10697c478bd9Sstevel@tonic-gate } else { 10707c478bd9Sstevel@tonic-gate /* "+name" */ 10717c478bd9Sstevel@tonic-gate name = instr + 1; 10727c478bd9Sstevel@tonic-gate break; 10737c478bd9Sstevel@tonic-gate } 10747c478bd9Sstevel@tonic-gate /* NOTREACHED */ 10757c478bd9Sstevel@tonic-gate 10767c478bd9Sstevel@tonic-gate case GETENT_ALL: 10777c478bd9Sstevel@tonic-gate linelen = be->linelen; 10787c478bd9Sstevel@tonic-gate args->returnval = 0; 1079ad0e80f7Smichen if (be->return_string_data == 1) { 1080ad0e80f7Smichen be->str2ent_save = args->str2ent; 1081ad0e80f7Smichen args->str2ent = be->str2ent_alt; 1082ad0e80f7Smichen } 1083ad0e80f7Smichen 1084cb5caa98Sdjl (void) nss_getent(be->db_rootp, be->db_initf, 10857c478bd9Sstevel@tonic-gate &be->db_context, args); 10867c478bd9Sstevel@tonic-gate if (args->returnval == 0) { 10877c478bd9Sstevel@tonic-gate /* ==> ?? Treat ERANGE differently ?? */ 10887c478bd9Sstevel@tonic-gate nss_endent(be->db_rootp, be->db_initf, 10897c478bd9Sstevel@tonic-gate &be->db_context); 10907c478bd9Sstevel@tonic-gate be->state = GETENT_FILE; 1091ad0e80f7Smichen if (be->return_string_data == 1) 1092ad0e80f7Smichen args->str2ent = be->str2ent_save; 10937c478bd9Sstevel@tonic-gate continue; 10947c478bd9Sstevel@tonic-gate } 1095ad0e80f7Smichen if (strset_in(&be->minuses, (*be->getnamef)(args))) 10967c478bd9Sstevel@tonic-gate continue; 10977c478bd9Sstevel@tonic-gate name = 0; /* tell code below we've done the lookup */ 1098ad0e80f7Smichen if (be->return_string_data == 1) 1099ad0e80f7Smichen args->str2ent = be->str2ent_save; 11007c478bd9Sstevel@tonic-gate break; 11017c478bd9Sstevel@tonic-gate 11027c478bd9Sstevel@tonic-gate case GETENT_NETGROUP: 11037c478bd9Sstevel@tonic-gate linelen = be->linelen; 11047c478bd9Sstevel@tonic-gate if (!netgr_next_u(be, &name)) { 11057c478bd9Sstevel@tonic-gate netgr_end(be); 11067c478bd9Sstevel@tonic-gate be->state = GETENT_FILE; 11077c478bd9Sstevel@tonic-gate continue; 11087c478bd9Sstevel@tonic-gate } 11097c478bd9Sstevel@tonic-gate /* pass "name" variable to code below... */ 11107c478bd9Sstevel@tonic-gate break; 11117c478bd9Sstevel@tonic-gate } 11127c478bd9Sstevel@tonic-gate 11137c478bd9Sstevel@tonic-gate if (name != 0) { 11147c478bd9Sstevel@tonic-gate if (strset_in(&be->minuses, name)) { 11157c478bd9Sstevel@tonic-gate continue; 11167c478bd9Sstevel@tonic-gate } 11177c478bd9Sstevel@tonic-gate /* 11187c478bd9Sstevel@tonic-gate * Do a getXXXnam(name). If we were being pure, 11197c478bd9Sstevel@tonic-gate * we'd introduce yet another function-pointer 11207c478bd9Sstevel@tonic-gate * that the database-specific code had to supply 11217c478bd9Sstevel@tonic-gate * to us. Instead we'll be grotty and hard-code 11227c478bd9Sstevel@tonic-gate * the knowledge that 11237c478bd9Sstevel@tonic-gate * (a) The username is always passwd in key.name, 11247c478bd9Sstevel@tonic-gate * (b) NSS_DBOP_PASSWD_BYNAME == 11257c478bd9Sstevel@tonic-gate * NSS_DBOP_SHADOW_BYNAME == 11267c478bd9Sstevel@tonic-gate * NSS_DBOP_next_iter. 11277c478bd9Sstevel@tonic-gate */ 11287c478bd9Sstevel@tonic-gate savename = args->key.name; 11297c478bd9Sstevel@tonic-gate args->key.name = name; 11307c478bd9Sstevel@tonic-gate args->returnval = 0; 1131ad0e80f7Smichen if (be->return_string_data == 1) { 1132ad0e80f7Smichen be->str2ent_save = args->str2ent; 1133ad0e80f7Smichen args->str2ent = be->str2ent_alt; 1134ad0e80f7Smichen } 1135ad0e80f7Smichen 1136cb5caa98Sdjl (void) nss_search(be->db_rootp, be->db_initf, 11377c478bd9Sstevel@tonic-gate NSS_DBOP_next_iter, args); 1138ad0e80f7Smichen 1139ad0e80f7Smichen if (be->return_string_data == 1) 1140ad0e80f7Smichen args->str2ent = be->str2ent_save; 11417c478bd9Sstevel@tonic-gate args->key.name = savename; /* In case anyone cares */ 11427c478bd9Sstevel@tonic-gate } 11437c478bd9Sstevel@tonic-gate /* 11447c478bd9Sstevel@tonic-gate * Found one via "+", "+name" or "@netgroup". 11457c478bd9Sstevel@tonic-gate * Override some fields if the /etc file says to do so. 11467c478bd9Sstevel@tonic-gate */ 11477c478bd9Sstevel@tonic-gate if (args->returnval == 0) { 11487c478bd9Sstevel@tonic-gate /* ==> ?? Should treat erange differently? */ 11497c478bd9Sstevel@tonic-gate continue; 11507c478bd9Sstevel@tonic-gate } 11517c478bd9Sstevel@tonic-gate /* 'colon' was set umpteen iterations ago in GETENT_FILE */ 11527c478bd9Sstevel@tonic-gate if (colon != 0) { 11537c478bd9Sstevel@tonic-gate *colon = ':'; 11547c478bd9Sstevel@tonic-gate colon = 0; 11557c478bd9Sstevel@tonic-gate } 11567c478bd9Sstevel@tonic-gate return (do_merge(be, args, instr, linelen)); 11577c478bd9Sstevel@tonic-gate } 1158cb5caa98Sdjl /*NOTREACHED*/ 11597c478bd9Sstevel@tonic-gate } 11607c478bd9Sstevel@tonic-gate 11617c478bd9Sstevel@tonic-gate /* We don't use this directly; we just copy the bits when we want to */ 11627c478bd9Sstevel@tonic-gate /* initialize the variable (in the compat_backend struct) that we do use */ 11637c478bd9Sstevel@tonic-gate static DEFINE_NSS_GETENT(context_initval); 11647c478bd9Sstevel@tonic-gate 11657c478bd9Sstevel@tonic-gate nss_backend_t * 11667c478bd9Sstevel@tonic-gate _nss_compat_constr(ops, n_ops, filename, min_bufsize, rootp, initf, netgroups, 11677c478bd9Sstevel@tonic-gate getname_func, merge_func) 11687c478bd9Sstevel@tonic-gate compat_backend_op_t ops[]; 11697c478bd9Sstevel@tonic-gate int n_ops; 11707c478bd9Sstevel@tonic-gate const char *filename; 11717c478bd9Sstevel@tonic-gate int min_bufsize; 11727c478bd9Sstevel@tonic-gate nss_db_root_t *rootp; 11737c478bd9Sstevel@tonic-gate nss_db_initf_t initf; 11747c478bd9Sstevel@tonic-gate int netgroups; 11757c478bd9Sstevel@tonic-gate compat_get_name getname_func; 11767c478bd9Sstevel@tonic-gate compat_merge_func merge_func; 11777c478bd9Sstevel@tonic-gate { 11787c478bd9Sstevel@tonic-gate compat_backend_ptr_t be; 11797c478bd9Sstevel@tonic-gate 11807c478bd9Sstevel@tonic-gate if ((be = (compat_backend_ptr_t)malloc(sizeof (*be))) == 0) { 11817c478bd9Sstevel@tonic-gate return (0); 11827c478bd9Sstevel@tonic-gate } 11837c478bd9Sstevel@tonic-gate be->ops = ops; 11847c478bd9Sstevel@tonic-gate be->n_ops = n_ops; 11857c478bd9Sstevel@tonic-gate be->filename = filename; 11867c478bd9Sstevel@tonic-gate be->f = 0; 11877c478bd9Sstevel@tonic-gate be->minbuf = min_bufsize; 11887c478bd9Sstevel@tonic-gate be->buf = 0; 11897c478bd9Sstevel@tonic-gate 11907c478bd9Sstevel@tonic-gate be->db_rootp = rootp; 11917c478bd9Sstevel@tonic-gate be->db_initf = initf; 11927c478bd9Sstevel@tonic-gate be->db_context = context_initval; 11937c478bd9Sstevel@tonic-gate 11947c478bd9Sstevel@tonic-gate be->getnamef = getname_func; 11957c478bd9Sstevel@tonic-gate be->mergef = merge_func; 11967c478bd9Sstevel@tonic-gate 11977c478bd9Sstevel@tonic-gate be->state = GETENT_FILE; /* i.e. do Automatic setent(); */ 1198ad0e80f7Smichen if (strcmp(be->filename, USERATTR_FILENAME) == 0) { 1199ad0e80f7Smichen be->state = GETENT_ATTRDB; 1200ad0e80f7Smichen be->str2ent_alt = str2userattr_s; 1201ad0e80f7Smichen be->workarea = calloc(1, sizeof (userstr_t)); 1202ad0e80f7Smichen } else if (strcmp(be->filename, AUDITUSER_FILENAME) == 0) { 1203ad0e80f7Smichen be->state = GETENT_ATTRDB; 1204ad0e80f7Smichen be->str2ent_alt = str2auuser_s; 1205ad0e80f7Smichen be->workarea = calloc(1, sizeof (au_user_str_t)); 1206ad0e80f7Smichen } else if (strcmp(be->filename, PASSWD) == 0) { 1207ad0e80f7Smichen be->str2ent_alt = str2passwd; 1208ad0e80f7Smichen be->workarea = calloc(1, sizeof (struct passwd)); 1209ad0e80f7Smichen } else if (strcmp(be->filename, SHADOW) == 0) { 1210ad0e80f7Smichen be->str2ent_alt = str2spwd; 1211ad0e80f7Smichen be->workarea = calloc(1, sizeof (struct spwd)); 1212ad0e80f7Smichen } else { /* group */ 1213ad0e80f7Smichen be->str2ent_alt = str2group; 1214ad0e80f7Smichen be->workarea = calloc(1, sizeof (struct group)); 1215ad0e80f7Smichen } 1216ad0e80f7Smichen if (be->workarea == NULL) 1217ad0e80f7Smichen return (NULL); 12187c478bd9Sstevel@tonic-gate 12197c478bd9Sstevel@tonic-gate be->minuses = 0; 12207c478bd9Sstevel@tonic-gate 12217c478bd9Sstevel@tonic-gate be->permit_netgroups = netgroups; 12227c478bd9Sstevel@tonic-gate be->yp_domain = 0; 12237c478bd9Sstevel@tonic-gate be->getnetgrent_backend = 0; 12247c478bd9Sstevel@tonic-gate be->netgr_buffer = 0; 1225cb5caa98Sdjl be->return_string_data = 0; 12267c478bd9Sstevel@tonic-gate 12277c478bd9Sstevel@tonic-gate return ((nss_backend_t *)be); 12287c478bd9Sstevel@tonic-gate } 1229