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 /* 22*767b0abfSmichen * Copyright 2007 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) { 329cb5caa98Sdjl /* No real overrides, return (*args) intact */ 330cb5caa98Sdjl 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) 345cb5caa98Sdjl 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 404e37190e5Smichen be->return_string_data = 0; 405e37190e5Smichen 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 497738d7c77Svk static int 498738d7c77Svk is_nss_lookup_by_name(int attrdb, nss_dbop_t op) 499738d7c77Svk { 5007c478bd9Sstevel@tonic-gate int result = 0; 5017c478bd9Sstevel@tonic-gate 5027c478bd9Sstevel@tonic-gate if ((attrdb != 0) && 503738d7c77Svk ((op == NSS_DBOP_AUDITUSER_BYNAME) || 504738d7c77Svk (op == NSS_DBOP_USERATTR_BYNAME))) { 5057c478bd9Sstevel@tonic-gate result = 1; 5067c478bd9Sstevel@tonic-gate } else if ((attrdb == 0) && 507738d7c77Svk ((op == NSS_DBOP_GROUP_BYNAME) || 508738d7c77Svk (op == NSS_DBOP_PASSWD_BYNAME) || 509738d7c77Svk (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) 540cb5caa98Sdjl 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 547*767b0abfSmichen * file format (if called from _nss_compat_getent(), 548*767b0abfSmichen * be->return_string_data and argp->buf.result 549*767b0abfSmichen * would be set already if argp->buf.result is NULL) 550cb5caa98Sdjl */ 551*767b0abfSmichen if (check != NULL) { 552*767b0abfSmichen if (argp->buf.result == NULL) { 553*767b0abfSmichen be->return_string_data = 1; 554cb5caa98Sdjl 555*767b0abfSmichen /* 556*767b0abfSmichen * the code executed later needs the result struct 557*767b0abfSmichen * as working area 558*767b0abfSmichen */ 559*767b0abfSmichen argp->buf.result = be->workarea; 560*767b0abfSmichen } else 561*767b0abfSmichen be->return_string_data = 0; 562*767b0abfSmichen } 563*767b0abfSmichen 564*767b0abfSmichen /* 565*767b0abfSmichen * use an alternate str2ent function if necessary 566*767b0abfSmichen */ 567*767b0abfSmichen if (be->return_string_data == 1) 568ad0e80f7Smichen func = be->str2ent_alt; 569*767b0abfSmichen else 570ad0e80f7Smichen func = argp->str2ent; 571cb5caa98Sdjl 5727c478bd9Sstevel@tonic-gate /*CONSTCOND*/ 5737c478bd9Sstevel@tonic-gate while (1) { 5747c478bd9Sstevel@tonic-gate int linelen; 5757c478bd9Sstevel@tonic-gate char *instr = be->buf; 5767c478bd9Sstevel@tonic-gate 5777c478bd9Sstevel@tonic-gate if ((linelen = read_line(be->f, instr, be->minbuf)) < 0) { 5787c478bd9Sstevel@tonic-gate /* End of file */ 5797c478bd9Sstevel@tonic-gate argp->returnval = 0; 5807c478bd9Sstevel@tonic-gate argp->erange = 0; 5817c478bd9Sstevel@tonic-gate break; 5827c478bd9Sstevel@tonic-gate } 5837c478bd9Sstevel@tonic-gate if (filter != 0 && strstr(instr, filter) == 0) { 5847c478bd9Sstevel@tonic-gate /* 5857c478bd9Sstevel@tonic-gate * Optimization: if the entry doesn't contain the 5867c478bd9Sstevel@tonic-gate * filter string then it can't be the entry we want, 5877c478bd9Sstevel@tonic-gate * so don't bother looking more closely at it. 5887c478bd9Sstevel@tonic-gate */ 5897c478bd9Sstevel@tonic-gate continue; 5907c478bd9Sstevel@tonic-gate } 5917c478bd9Sstevel@tonic-gate if (netdb) { 5927c478bd9Sstevel@tonic-gate char *first; 5937c478bd9Sstevel@tonic-gate char *last; 5947c478bd9Sstevel@tonic-gate 5957c478bd9Sstevel@tonic-gate if ((last = strchr(instr, '#')) == 0) { 5967c478bd9Sstevel@tonic-gate last = instr + linelen; 5977c478bd9Sstevel@tonic-gate } 5987c478bd9Sstevel@tonic-gate *last-- = '\0'; /* Nuke '\n' or #comment */ 5997c478bd9Sstevel@tonic-gate 6007c478bd9Sstevel@tonic-gate /* 6017c478bd9Sstevel@tonic-gate * Skip leading whitespace. Normally there isn't 6027c478bd9Sstevel@tonic-gate * any, so it's not worth calling strspn(). 6037c478bd9Sstevel@tonic-gate */ 6047c478bd9Sstevel@tonic-gate for (first = instr; isspace(*first); first++) { 6057c478bd9Sstevel@tonic-gate ; 6067c478bd9Sstevel@tonic-gate } 6077c478bd9Sstevel@tonic-gate if (*first == '\0') { 6087c478bd9Sstevel@tonic-gate continue; 6097c478bd9Sstevel@tonic-gate } 6107c478bd9Sstevel@tonic-gate /* 6117c478bd9Sstevel@tonic-gate * Found something non-blank on the line. Skip back 6127c478bd9Sstevel@tonic-gate * over any trailing whitespace; since we know 6137c478bd9Sstevel@tonic-gate * there's non-whitespace earlier in the line, 6147c478bd9Sstevel@tonic-gate * checking for termination is easy. 6157c478bd9Sstevel@tonic-gate */ 6167c478bd9Sstevel@tonic-gate while (isspace(*last)) { 6177c478bd9Sstevel@tonic-gate --last; 6187c478bd9Sstevel@tonic-gate } 6197c478bd9Sstevel@tonic-gate linelen = last - first + 1; 6207c478bd9Sstevel@tonic-gate if (first != instr) { 6217c478bd9Sstevel@tonic-gate instr = first; 6227c478bd9Sstevel@tonic-gate } 6237c478bd9Sstevel@tonic-gate } 6247c478bd9Sstevel@tonic-gate argp->returnval = 0; 6257c478bd9Sstevel@tonic-gate parsestat = (*func)(instr, linelen, argp->buf.result, 6267c478bd9Sstevel@tonic-gate argp->buf.buffer, argp->buf.buflen); 6277c478bd9Sstevel@tonic-gate if (parsestat == NSS_STR_PARSE_SUCCESS) { 628cb5caa98Sdjl argp->returnval = argp->buf.result; 6297c478bd9Sstevel@tonic-gate if (check == 0 || (*check)(argp)) { 630cb5caa98Sdjl int len; 631cb5caa98Sdjl 632cb5caa98Sdjl if (be->return_string_data != 1) { 633cb5caa98Sdjl res = NSS_SUCCESS; 634cb5caa98Sdjl break; 635cb5caa98Sdjl } 636cb5caa98Sdjl 637cb5caa98Sdjl /* copy string data to result buffer */ 638cb5caa98Sdjl argp->buf.result = NULL; 639cb5caa98Sdjl argp->returnval = argp->buf.buffer; 640cb5caa98Sdjl if ((len = strlcpy(argp->buf.buffer, instr, 641cb5caa98Sdjl argp->buf.buflen)) >= 642cb5caa98Sdjl argp->buf.buflen) { 643cb5caa98Sdjl argp->returnval = NULL; 644cb5caa98Sdjl res = NSS_NOTFOUND; 645cb5caa98Sdjl argp->erange = 1; 646cb5caa98Sdjl break; 647cb5caa98Sdjl } 648cb5caa98Sdjl 649cb5caa98Sdjl argp->returnlen = len; 6507c478bd9Sstevel@tonic-gate res = NSS_SUCCESS; 6517c478bd9Sstevel@tonic-gate break; 6527c478bd9Sstevel@tonic-gate } 6537c478bd9Sstevel@tonic-gate } else if (parsestat == NSS_STR_PARSE_ERANGE) { 654cb5caa98Sdjl res = NSS_NOTFOUND; 6557c478bd9Sstevel@tonic-gate argp->erange = 1; 6567c478bd9Sstevel@tonic-gate break; 6577c478bd9Sstevel@tonic-gate } 6587c478bd9Sstevel@tonic-gate } 6597c478bd9Sstevel@tonic-gate /* 6607c478bd9Sstevel@tonic-gate * stayopen is set to 0 by default in order to close the opened 6617c478bd9Sstevel@tonic-gate * file. Some applications may break if it is set to 1. 6627c478bd9Sstevel@tonic-gate */ 6637c478bd9Sstevel@tonic-gate if (check != 0 && !argp->stayopen) { 6647c478bd9Sstevel@tonic-gate (void) _nss_compat_endent(be, 0); 6657c478bd9Sstevel@tonic-gate } 6667c478bd9Sstevel@tonic-gate 6677c478bd9Sstevel@tonic-gate if (res != NSS_SUCCESS) { 668cb5caa98Sdjl /* 669cb5caa98Sdjl * tell the nss_search() and nss_getent() below 670cb5caa98Sdjl * if the result should be returned in the /etc 671cb5caa98Sdjl * file format 672cb5caa98Sdjl */ 673cb5caa98Sdjl if (be->return_string_data == 1) 674cb5caa98Sdjl argp->buf.result = NULL; 675cb5caa98Sdjl 6767c478bd9Sstevel@tonic-gate if ((op_num == NSS_DBOP_USERATTR_BYNAME) || 6777c478bd9Sstevel@tonic-gate (op_num == NSS_DBOP_AUDITUSER_BYNAME)) { 6787c478bd9Sstevel@tonic-gate res = nss_search(be->db_rootp, 6797c478bd9Sstevel@tonic-gate be->db_initf, 6807c478bd9Sstevel@tonic-gate op_num, 6817c478bd9Sstevel@tonic-gate argp); 6827c478bd9Sstevel@tonic-gate } else { 6837c478bd9Sstevel@tonic-gate res = nss_getent(be->db_rootp, 6847c478bd9Sstevel@tonic-gate be->db_initf, &be->db_context, argp); 6857c478bd9Sstevel@tonic-gate } 6867c478bd9Sstevel@tonic-gate if (res != NSS_SUCCESS) { 6877c478bd9Sstevel@tonic-gate argp->returnval = 0; 6887c478bd9Sstevel@tonic-gate argp->erange = 0; 6897c478bd9Sstevel@tonic-gate } 6907c478bd9Sstevel@tonic-gate } 6917c478bd9Sstevel@tonic-gate 6927c478bd9Sstevel@tonic-gate return (res); 6937c478bd9Sstevel@tonic-gate } 6947c478bd9Sstevel@tonic-gate 6957c478bd9Sstevel@tonic-gate nss_status_t 6967c478bd9Sstevel@tonic-gate _nss_compat_XY_all(be, args, check, op_num) 6977c478bd9Sstevel@tonic-gate compat_backend_ptr_t be; 6987c478bd9Sstevel@tonic-gate nss_XbyY_args_t *args; 6997c478bd9Sstevel@tonic-gate compat_XY_check_func check; 7007c478bd9Sstevel@tonic-gate nss_dbop_t op_num; 7017c478bd9Sstevel@tonic-gate { 7027c478bd9Sstevel@tonic-gate nss_status_t res; 7037c478bd9Sstevel@tonic-gate int parsestat; 704cb5caa98Sdjl 7057c478bd9Sstevel@tonic-gate 7067c478bd9Sstevel@tonic-gate if (be->buf == 0 && 7077c478bd9Sstevel@tonic-gate (be->buf = malloc(be->minbuf)) == 0) { 7087c478bd9Sstevel@tonic-gate return (NSS_UNAVAIL); /* really panic, malloc failed */ 7097c478bd9Sstevel@tonic-gate } 7107c478bd9Sstevel@tonic-gate 7117c478bd9Sstevel@tonic-gate if ((res = _nss_compat_setent(be, 0)) != NSS_SUCCESS) { 7127c478bd9Sstevel@tonic-gate return (res); 7137c478bd9Sstevel@tonic-gate } 7147c478bd9Sstevel@tonic-gate 7157c478bd9Sstevel@tonic-gate res = NSS_NOTFOUND; 7167c478bd9Sstevel@tonic-gate 717cb5caa98Sdjl /* 718cb5caa98Sdjl * assume a NULL buf.result pointer is an indication 719cb5caa98Sdjl * that the lookup result should be returned in /etc 720cb5caa98Sdjl * file format 721cb5caa98Sdjl */ 722cb5caa98Sdjl if (args->buf.result == NULL) { 723cb5caa98Sdjl 724cb5caa98Sdjl be->return_string_data = 1; 725cb5caa98Sdjl 726cb5caa98Sdjl /* 727cb5caa98Sdjl * the code executed later needs the result struct 728cb5caa98Sdjl * as working area 729cb5caa98Sdjl */ 730ad0e80f7Smichen args->buf.result = be->workarea; 731ad0e80f7Smichen 732ad0e80f7Smichen be->str2ent_save = args->str2ent; 733ad0e80f7Smichen args->str2ent = be->str2ent_alt; 734e37190e5Smichen } else 735e37190e5Smichen be->return_string_data = 0; 736cb5caa98Sdjl 7377c478bd9Sstevel@tonic-gate /*CONSTCOND*/ 7387c478bd9Sstevel@tonic-gate while (1) { 7397c478bd9Sstevel@tonic-gate int linelen; 7407c478bd9Sstevel@tonic-gate char *instr = be->buf; 7417c478bd9Sstevel@tonic-gate char *colon; 7427c478bd9Sstevel@tonic-gate 7437c478bd9Sstevel@tonic-gate linelen = read_line(be->f, instr, be->minbuf); 7447c478bd9Sstevel@tonic-gate if (linelen < 0) { 7457c478bd9Sstevel@tonic-gate /* End of file */ 7467c478bd9Sstevel@tonic-gate args->returnval = 0; 7477c478bd9Sstevel@tonic-gate args->erange = 0; 7487c478bd9Sstevel@tonic-gate break; 7497c478bd9Sstevel@tonic-gate } 7507c478bd9Sstevel@tonic-gate 7517c478bd9Sstevel@tonic-gate args->returnval = 0; /* reset for both types of entries */ 7527c478bd9Sstevel@tonic-gate 7537c478bd9Sstevel@tonic-gate if (instr[0] != '+' && instr[0] != '-') { 7547c478bd9Sstevel@tonic-gate /* Simple, wholesome, God-fearing entry */ 7557c478bd9Sstevel@tonic-gate parsestat = (*args->str2ent)(instr, linelen, 7567c478bd9Sstevel@tonic-gate args->buf.result, 7577c478bd9Sstevel@tonic-gate args->buf.buffer, 7587c478bd9Sstevel@tonic-gate args->buf.buflen); 7597c478bd9Sstevel@tonic-gate if (parsestat == NSS_STR_PARSE_SUCCESS) { 7607c478bd9Sstevel@tonic-gate args->returnval = args->buf.result; 7617c478bd9Sstevel@tonic-gate if ((*check)(args) != 0) { 762cb5caa98Sdjl int len; 763cb5caa98Sdjl if (be->return_string_data != 1) { 764cb5caa98Sdjl res = NSS_SUCCESS; 765cb5caa98Sdjl break; 766cb5caa98Sdjl } 767cb5caa98Sdjl 768cb5caa98Sdjl /* 769cb5caa98Sdjl * copy string data to 770cb5caa98Sdjl * result buffer 771cb5caa98Sdjl */ 772cb5caa98Sdjl args->buf.result = NULL; 773ad0e80f7Smichen args->str2ent = be->str2ent_save; 774cb5caa98Sdjl if ((len = strlcpy(args->buf.buffer, 775cb5caa98Sdjl instr, args->buf.buflen)) >= 776cb5caa98Sdjl args->buf.buflen) 777cb5caa98Sdjl parsestat = 778cb5caa98Sdjl NSS_STR_PARSE_ERANGE; 779cb5caa98Sdjl else { 780cb5caa98Sdjl args->returnval = 781cb5caa98Sdjl args->buf.buffer; 782cb5caa98Sdjl args->returnlen = len; 783cb5caa98Sdjl res = NSS_SUCCESS; 784cb5caa98Sdjl break; 785cb5caa98Sdjl } 786cb5caa98Sdjl } else 787cb5caa98Sdjl continue; 788cb5caa98Sdjl } 7897c478bd9Sstevel@tonic-gate 7907c478bd9Sstevel@tonic-gate /* ===> Check the Dani logic here... */ 7917c478bd9Sstevel@tonic-gate 792cb5caa98Sdjl if (parsestat == NSS_STR_PARSE_ERANGE) { 7937c478bd9Sstevel@tonic-gate args->erange = 1; 7947c478bd9Sstevel@tonic-gate res = NSS_NOTFOUND; 7957c478bd9Sstevel@tonic-gate break; 7967c478bd9Sstevel@tonic-gate /* should we just skip this one long line ? */ 7977c478bd9Sstevel@tonic-gate } /* else if (parsestat == NSS_STR_PARSE_PARSE) */ 7987c478bd9Sstevel@tonic-gate /* don't care ! */ 7997c478bd9Sstevel@tonic-gate 8007c478bd9Sstevel@tonic-gate /* ==> ?? */ continue; 8017c478bd9Sstevel@tonic-gate } 8027c478bd9Sstevel@tonic-gate 803cb5caa98Sdjl 8047c478bd9Sstevel@tonic-gate /* 8057c478bd9Sstevel@tonic-gate * Process "+", "+name", "+@netgroup", "-name" or "-@netgroup" 8067c478bd9Sstevel@tonic-gate * 8077c478bd9Sstevel@tonic-gate * This code is optimized for lookups by name. 8087c478bd9Sstevel@tonic-gate * 8097c478bd9Sstevel@tonic-gate * For lookups by identifier search key cannot be matched with 8107c478bd9Sstevel@tonic-gate * the name of the "+" or "-" entry. So nss_search() is to be 8117c478bd9Sstevel@tonic-gate * called before extracting the name i.e. via (*be->getnamef)(). 8127c478bd9Sstevel@tonic-gate * 8137c478bd9Sstevel@tonic-gate * But for lookups by name, search key is compared with the name 8147c478bd9Sstevel@tonic-gate * of the "+" or "-" entry to acquire a match and thus 8157c478bd9Sstevel@tonic-gate * unnesessary calls to nss_search() is eliminated. Also for 8167c478bd9Sstevel@tonic-gate * matching "-" entries, calls to nss_search() is eliminated. 8177c478bd9Sstevel@tonic-gate */ 8187c478bd9Sstevel@tonic-gate 8197c478bd9Sstevel@tonic-gate if ((colon = strchr(instr, ':')) != 0) { 8207c478bd9Sstevel@tonic-gate *colon = '\0'; /* terminate field to extract name */ 8217c478bd9Sstevel@tonic-gate } 8227c478bd9Sstevel@tonic-gate 8237c478bd9Sstevel@tonic-gate if (instr[1] == '@') { 8247c478bd9Sstevel@tonic-gate /* 8257c478bd9Sstevel@tonic-gate * Case 1: 8267c478bd9Sstevel@tonic-gate * The entry is of the form "+@netgroup" or 8277c478bd9Sstevel@tonic-gate * "-@netgroup". If we're performing a lookup by name, 8287c478bd9Sstevel@tonic-gate * we can simply extract the name from the search key 8297c478bd9Sstevel@tonic-gate * (i.e. args->key.name). If not, then we must call 8307c478bd9Sstevel@tonic-gate * nss_search() before extracting the name via the 8317c478bd9Sstevel@tonic-gate * get_XXname() function. i.e. (*be->getnamef)(args). 8327c478bd9Sstevel@tonic-gate */ 833738d7c77Svk if (is_nss_lookup_by_name(0, op_num) != 0) { 834738d7c77Svk /* compare then search */ 835738d7c77Svk if (!be->permit_netgroups || 836738d7c77Svk !netgr_in(be, instr + 2, args->key.name)) 837738d7c77Svk continue; 838738d7c77Svk if (instr[0] == '+') { 839738d7c77Svk /* need to search for "+" entry */ 840cb5caa98Sdjl (void) nss_search(be->db_rootp, 841cb5caa98Sdjl be->db_initf, op_num, args); 842738d7c77Svk if (args->returnval == 0) 843738d7c77Svk continue; 844738d7c77Svk } 845738d7c77Svk } else { 846738d7c77Svk /* search then compare */ 847cb5caa98Sdjl (void) nss_search(be->db_rootp, 848cb5caa98Sdjl be->db_initf, op_num, args); 8497c478bd9Sstevel@tonic-gate if (args->returnval == 0) 8507c478bd9Sstevel@tonic-gate continue; 851738d7c77Svk if (!be->permit_netgroups || 852738d7c77Svk !netgr_in(be, instr + 2, 853738d7c77Svk (*be->getnamef)(args))) 854738d7c77Svk continue; 8557c478bd9Sstevel@tonic-gate } 856738d7c77Svk } else if (instr[1] == '\0') { 8577c478bd9Sstevel@tonic-gate /* 8587c478bd9Sstevel@tonic-gate * Case 2: 8597c478bd9Sstevel@tonic-gate * The entry is of the form "+" or "-". The former 8607c478bd9Sstevel@tonic-gate * allows all entries from name services. The latter 8617c478bd9Sstevel@tonic-gate * is illegal and ought to be ignored. 8627c478bd9Sstevel@tonic-gate */ 8637c478bd9Sstevel@tonic-gate if (instr[0] == '-') 8647c478bd9Sstevel@tonic-gate continue; 8657c478bd9Sstevel@tonic-gate /* need to search for "+" entry */ 866cb5caa98Sdjl (void) nss_search(be->db_rootp, be->db_initf, 867cb5caa98Sdjl op_num, args); 8687c478bd9Sstevel@tonic-gate if (args->returnval == 0) 8697c478bd9Sstevel@tonic-gate continue; 870738d7c77Svk } else { 8717c478bd9Sstevel@tonic-gate /* 8727c478bd9Sstevel@tonic-gate * Case 3: 8737c478bd9Sstevel@tonic-gate * The entry is of the form "+name" or "-name". 8747c478bd9Sstevel@tonic-gate * If we're performing a lookup by name, we can simply 8757c478bd9Sstevel@tonic-gate * extract the name from the search key 8767c478bd9Sstevel@tonic-gate * (i.e. args->key.name). If not, then we must call 8777c478bd9Sstevel@tonic-gate * nss_search() before extracting the name via the 8787c478bd9Sstevel@tonic-gate * get_XXname() function. i.e. (*be->getnamef)(args). 8797c478bd9Sstevel@tonic-gate */ 880738d7c77Svk if (is_nss_lookup_by_name(0, op_num) != 0) { 8817c478bd9Sstevel@tonic-gate /* compare then search */ 8827c478bd9Sstevel@tonic-gate if (strcmp(instr + 1, args->key.name) != 0) 8837c478bd9Sstevel@tonic-gate continue; 8847c478bd9Sstevel@tonic-gate if (instr[0] == '+') { 8857c478bd9Sstevel@tonic-gate /* need to search for "+" entry */ 886cb5caa98Sdjl (void) nss_search(be->db_rootp, 887cb5caa98Sdjl be->db_initf, op_num, args); 8887c478bd9Sstevel@tonic-gate if (args->returnval == 0) 8897c478bd9Sstevel@tonic-gate continue; 8907c478bd9Sstevel@tonic-gate } 8917c478bd9Sstevel@tonic-gate } else { 8927c478bd9Sstevel@tonic-gate /* search then compare */ 893cb5caa98Sdjl (void) nss_search(be->db_rootp, 894cb5caa98Sdjl be->db_initf, op_num, args); 8957c478bd9Sstevel@tonic-gate if (args->returnval == 0) 8967c478bd9Sstevel@tonic-gate continue; 8977c478bd9Sstevel@tonic-gate if (strcmp(instr + 1, (*be->getnamef)(args)) 898738d7c77Svk != 0) 8997c478bd9Sstevel@tonic-gate continue; 9007c478bd9Sstevel@tonic-gate } 901738d7c77Svk } 9027c478bd9Sstevel@tonic-gate if (instr[0] == '-') { 9037c478bd9Sstevel@tonic-gate /* no need to search for "-" entry */ 9047c478bd9Sstevel@tonic-gate args->returnval = 0; 9057c478bd9Sstevel@tonic-gate args->erange = 0; 9067c478bd9Sstevel@tonic-gate res = NSS_NOTFOUND; 9077c478bd9Sstevel@tonic-gate } else { 9087c478bd9Sstevel@tonic-gate if (colon != 0) 909738d7c77Svk *colon = ':'; /* restoration */ 9107c478bd9Sstevel@tonic-gate res = do_merge(be, args, instr, linelen); 9117c478bd9Sstevel@tonic-gate } 9127c478bd9Sstevel@tonic-gate break; 9137c478bd9Sstevel@tonic-gate } 9147c478bd9Sstevel@tonic-gate 9157c478bd9Sstevel@tonic-gate /* 9167c478bd9Sstevel@tonic-gate * stayopen is set to 0 by default in order to close the opened 9177c478bd9Sstevel@tonic-gate * file. Some applications may break if it is set to 1. 9187c478bd9Sstevel@tonic-gate */ 9197c478bd9Sstevel@tonic-gate if (!args->stayopen) { 9207c478bd9Sstevel@tonic-gate (void) _nss_compat_endent(be, 0); 9217c478bd9Sstevel@tonic-gate } 9227c478bd9Sstevel@tonic-gate 923cb5caa98Sdjl if (be->return_string_data == 1) { 924ad0e80f7Smichen args->str2ent = be->str2ent_save; 925cb5caa98Sdjl } 926cb5caa98Sdjl 9277c478bd9Sstevel@tonic-gate return (res); 9287c478bd9Sstevel@tonic-gate } 9297c478bd9Sstevel@tonic-gate 9307c478bd9Sstevel@tonic-gate nss_status_t 9317c478bd9Sstevel@tonic-gate _nss_compat_getent(be, a) 9327c478bd9Sstevel@tonic-gate compat_backend_ptr_t be; 9337c478bd9Sstevel@tonic-gate void *a; 9347c478bd9Sstevel@tonic-gate { 9357c478bd9Sstevel@tonic-gate nss_XbyY_args_t *args = (nss_XbyY_args_t *)a; 9367c478bd9Sstevel@tonic-gate nss_status_t res; 9377c478bd9Sstevel@tonic-gate char *colon = 0; /* <=== need comment re lifetime */ 9387c478bd9Sstevel@tonic-gate 9397c478bd9Sstevel@tonic-gate if (be->f == 0) { 9407c478bd9Sstevel@tonic-gate if ((res = _nss_compat_setent(be, 0)) != NSS_SUCCESS) { 9417c478bd9Sstevel@tonic-gate return (res); 9427c478bd9Sstevel@tonic-gate } 9437c478bd9Sstevel@tonic-gate } 9447c478bd9Sstevel@tonic-gate 9457c478bd9Sstevel@tonic-gate if (be->buf == 0 && 9467c478bd9Sstevel@tonic-gate (be->buf = malloc(be->minbuf)) == 0) { 9477c478bd9Sstevel@tonic-gate return (NSS_UNAVAIL); /* really panic, malloc failed */ 9487c478bd9Sstevel@tonic-gate } 9497c478bd9Sstevel@tonic-gate 950cb5caa98Sdjl /* 951cb5caa98Sdjl * assume a NULL buf.result pointer is an indication 952cb5caa98Sdjl * that the lookup result should be returned in /etc 953cb5caa98Sdjl * file format 954cb5caa98Sdjl */ 955cb5caa98Sdjl if (args->buf.result == NULL) { 956cb5caa98Sdjl be->return_string_data = 1; 957cb5caa98Sdjl 958cb5caa98Sdjl /* 959cb5caa98Sdjl * the code executed later needs the result struct 960cb5caa98Sdjl * as working area 961cb5caa98Sdjl */ 962ad0e80f7Smichen args->buf.result = be->workarea; 963e37190e5Smichen } else 964e37190e5Smichen be->return_string_data = 0; 965cb5caa98Sdjl 9667c478bd9Sstevel@tonic-gate /*CONSTCOND*/ 9677c478bd9Sstevel@tonic-gate while (1) { 9687c478bd9Sstevel@tonic-gate char *instr = be->buf; 9697c478bd9Sstevel@tonic-gate int linelen; 9707c478bd9Sstevel@tonic-gate char *name; /* === Need more distinctive label */ 9717c478bd9Sstevel@tonic-gate const char *savename; 9727c478bd9Sstevel@tonic-gate 9737c478bd9Sstevel@tonic-gate /* 9747c478bd9Sstevel@tonic-gate * In the code below... 9757c478bd9Sstevel@tonic-gate * break means "I found one, I think" (i.e. goto the 9767c478bd9Sstevel@tonic-gate * code after the end of the switch statement), 9777c478bd9Sstevel@tonic-gate * continue means "Next candidate" 9787c478bd9Sstevel@tonic-gate * (i.e. loop around to the switch statement), 9797c478bd9Sstevel@tonic-gate * return means "I'm quite sure" (either Yes or No). 9807c478bd9Sstevel@tonic-gate */ 9817c478bd9Sstevel@tonic-gate switch (be->state) { 9827c478bd9Sstevel@tonic-gate 9837c478bd9Sstevel@tonic-gate case GETENT_DONE: 9847c478bd9Sstevel@tonic-gate args->returnval = 0; 9857c478bd9Sstevel@tonic-gate args->erange = 0; 9867c478bd9Sstevel@tonic-gate return (NSS_NOTFOUND); 9877c478bd9Sstevel@tonic-gate 9887c478bd9Sstevel@tonic-gate case GETENT_ATTRDB: 989cb5caa98Sdjl args->key.name = NULL; 9907c478bd9Sstevel@tonic-gate res = _attrdb_compat_XY_all(be, 9917c478bd9Sstevel@tonic-gate args, 1, (compat_XY_check_func)NULL, 0); 9927c478bd9Sstevel@tonic-gate return (res); 9937c478bd9Sstevel@tonic-gate 9947c478bd9Sstevel@tonic-gate case GETENT_FILE: 9957c478bd9Sstevel@tonic-gate linelen = read_line(be->f, instr, be->minbuf); 9967c478bd9Sstevel@tonic-gate if (linelen < 0) { 9977c478bd9Sstevel@tonic-gate /* End of file */ 9987c478bd9Sstevel@tonic-gate be->state = GETENT_DONE; 9997c478bd9Sstevel@tonic-gate continue; 10007c478bd9Sstevel@tonic-gate } 10017c478bd9Sstevel@tonic-gate if ((colon = strchr(instr, ':')) != 0) { 10027c478bd9Sstevel@tonic-gate *colon = '\0'; 10037c478bd9Sstevel@tonic-gate } 10047c478bd9Sstevel@tonic-gate if (instr[0] == '-') { 10057c478bd9Sstevel@tonic-gate if (instr[1] != '@') { 1006cb5caa98Sdjl (void) strset_add(&be->minuses, 1007cb5caa98Sdjl instr + 1); 10087c478bd9Sstevel@tonic-gate } else if (be->permit_netgroups) { 10097c478bd9Sstevel@tonic-gate netgr_set(be, instr + 2); 10107c478bd9Sstevel@tonic-gate while (netgr_next_u(be, &name)) { 1011cb5caa98Sdjl (void) strset_add(&be->minuses, 10127c478bd9Sstevel@tonic-gate name); 10137c478bd9Sstevel@tonic-gate } 10147c478bd9Sstevel@tonic-gate netgr_end(be); 10157c478bd9Sstevel@tonic-gate } /* Else (silently) ignore the entry */ 10167c478bd9Sstevel@tonic-gate continue; 10177c478bd9Sstevel@tonic-gate } else if (instr[0] != '+') { 10187c478bd9Sstevel@tonic-gate int parsestat; 10197c478bd9Sstevel@tonic-gate /* 10207c478bd9Sstevel@tonic-gate * Normal entry, no +/- nonsense 10217c478bd9Sstevel@tonic-gate */ 10227c478bd9Sstevel@tonic-gate if (colon != 0) { 10237c478bd9Sstevel@tonic-gate *colon = ':'; 10247c478bd9Sstevel@tonic-gate } 10257c478bd9Sstevel@tonic-gate args->returnval = 0; 10267c478bd9Sstevel@tonic-gate parsestat = (*args->str2ent)(instr, linelen, 10277c478bd9Sstevel@tonic-gate args->buf.result, 10287c478bd9Sstevel@tonic-gate args->buf.buffer, 10297c478bd9Sstevel@tonic-gate args->buf.buflen); 10307c478bd9Sstevel@tonic-gate if (parsestat == NSS_STR_PARSE_SUCCESS) { 1031cb5caa98Sdjl int len; 1032cb5caa98Sdjl 1033cb5caa98Sdjl if (be->return_string_data != 1) { 1034cb5caa98Sdjl args->returnval = 1035cb5caa98Sdjl args->buf.result; 1036cb5caa98Sdjl return (NSS_SUCCESS); 1037cb5caa98Sdjl } 1038cb5caa98Sdjl 1039cb5caa98Sdjl /* 1040cb5caa98Sdjl * copy string data to 1041cb5caa98Sdjl * result buffer 1042cb5caa98Sdjl */ 1043cb5caa98Sdjl args->buf.result = NULL; 1044cb5caa98Sdjl args->returnval = 1045cb5caa98Sdjl args->buf.buffer; 1046cb5caa98Sdjl if ((len = strlcpy(args->buf.buffer, 1047cb5caa98Sdjl instr, args->buf.buflen)) >= 1048cb5caa98Sdjl args->buf.buflen) 1049cb5caa98Sdjl parsestat = 1050cb5caa98Sdjl NSS_STR_PARSE_ERANGE; 1051cb5caa98Sdjl else { 1052cb5caa98Sdjl args->returnlen = len; 1053cb5caa98Sdjl return (NSS_SUCCESS); 1054cb5caa98Sdjl } 10557c478bd9Sstevel@tonic-gate } 10567c478bd9Sstevel@tonic-gate /* ==> ?? Treat ERANGE differently ?? */ 10577c478bd9Sstevel@tonic-gate if (parsestat == NSS_STR_PARSE_ERANGE) { 10587c478bd9Sstevel@tonic-gate args->returnval = 0; 10597c478bd9Sstevel@tonic-gate args->erange = 1; 10607c478bd9Sstevel@tonic-gate return (NSS_NOTFOUND); 10617c478bd9Sstevel@tonic-gate } 10627c478bd9Sstevel@tonic-gate /* Skip the offending entry, get next */ 10637c478bd9Sstevel@tonic-gate continue; 10647c478bd9Sstevel@tonic-gate } else if (instr[1] == '\0') { 10657c478bd9Sstevel@tonic-gate /* Plain "+" */ 10667c478bd9Sstevel@tonic-gate nss_setent(be->db_rootp, be->db_initf, 10677c478bd9Sstevel@tonic-gate &be->db_context); 10687c478bd9Sstevel@tonic-gate be->state = GETENT_ALL; 10697c478bd9Sstevel@tonic-gate be->linelen = linelen; 1070ad0e80f7Smichen 10717c478bd9Sstevel@tonic-gate continue; 10727c478bd9Sstevel@tonic-gate } else if (instr[1] == '@') { 10737c478bd9Sstevel@tonic-gate /* "+@netgroup" */ 10747c478bd9Sstevel@tonic-gate netgr_set(be, instr + 2); 10757c478bd9Sstevel@tonic-gate be->state = GETENT_NETGROUP; 10767c478bd9Sstevel@tonic-gate be->linelen = linelen; 10777c478bd9Sstevel@tonic-gate continue; 10787c478bd9Sstevel@tonic-gate } else { 10797c478bd9Sstevel@tonic-gate /* "+name" */ 10807c478bd9Sstevel@tonic-gate name = instr + 1; 10817c478bd9Sstevel@tonic-gate break; 10827c478bd9Sstevel@tonic-gate } 10837c478bd9Sstevel@tonic-gate /* NOTREACHED */ 10847c478bd9Sstevel@tonic-gate 10857c478bd9Sstevel@tonic-gate case GETENT_ALL: 10867c478bd9Sstevel@tonic-gate linelen = be->linelen; 10877c478bd9Sstevel@tonic-gate args->returnval = 0; 1088ad0e80f7Smichen if (be->return_string_data == 1) { 1089ad0e80f7Smichen be->str2ent_save = args->str2ent; 1090ad0e80f7Smichen args->str2ent = be->str2ent_alt; 1091ad0e80f7Smichen } 1092ad0e80f7Smichen 1093cb5caa98Sdjl (void) nss_getent(be->db_rootp, be->db_initf, 10947c478bd9Sstevel@tonic-gate &be->db_context, args); 10957c478bd9Sstevel@tonic-gate if (args->returnval == 0) { 10967c478bd9Sstevel@tonic-gate /* ==> ?? Treat ERANGE differently ?? */ 10977c478bd9Sstevel@tonic-gate nss_endent(be->db_rootp, be->db_initf, 10987c478bd9Sstevel@tonic-gate &be->db_context); 10997c478bd9Sstevel@tonic-gate be->state = GETENT_FILE; 1100ad0e80f7Smichen if (be->return_string_data == 1) 1101ad0e80f7Smichen args->str2ent = be->str2ent_save; 11027c478bd9Sstevel@tonic-gate continue; 11037c478bd9Sstevel@tonic-gate } 1104ad0e80f7Smichen if (strset_in(&be->minuses, (*be->getnamef)(args))) 11057c478bd9Sstevel@tonic-gate continue; 11067c478bd9Sstevel@tonic-gate name = 0; /* tell code below we've done the lookup */ 1107ad0e80f7Smichen if (be->return_string_data == 1) 1108ad0e80f7Smichen args->str2ent = be->str2ent_save; 11097c478bd9Sstevel@tonic-gate break; 11107c478bd9Sstevel@tonic-gate 11117c478bd9Sstevel@tonic-gate case GETENT_NETGROUP: 11127c478bd9Sstevel@tonic-gate linelen = be->linelen; 11137c478bd9Sstevel@tonic-gate if (!netgr_next_u(be, &name)) { 11147c478bd9Sstevel@tonic-gate netgr_end(be); 11157c478bd9Sstevel@tonic-gate be->state = GETENT_FILE; 11167c478bd9Sstevel@tonic-gate continue; 11177c478bd9Sstevel@tonic-gate } 11187c478bd9Sstevel@tonic-gate /* pass "name" variable to code below... */ 11197c478bd9Sstevel@tonic-gate break; 11207c478bd9Sstevel@tonic-gate } 11217c478bd9Sstevel@tonic-gate 11227c478bd9Sstevel@tonic-gate if (name != 0) { 11237c478bd9Sstevel@tonic-gate if (strset_in(&be->minuses, name)) { 11247c478bd9Sstevel@tonic-gate continue; 11257c478bd9Sstevel@tonic-gate } 11267c478bd9Sstevel@tonic-gate /* 11277c478bd9Sstevel@tonic-gate * Do a getXXXnam(name). If we were being pure, 11287c478bd9Sstevel@tonic-gate * we'd introduce yet another function-pointer 11297c478bd9Sstevel@tonic-gate * that the database-specific code had to supply 11307c478bd9Sstevel@tonic-gate * to us. Instead we'll be grotty and hard-code 11317c478bd9Sstevel@tonic-gate * the knowledge that 11327c478bd9Sstevel@tonic-gate * (a) The username is always passwd in key.name, 11337c478bd9Sstevel@tonic-gate * (b) NSS_DBOP_PASSWD_BYNAME == 11347c478bd9Sstevel@tonic-gate * NSS_DBOP_SHADOW_BYNAME == 11357c478bd9Sstevel@tonic-gate * NSS_DBOP_next_iter. 11367c478bd9Sstevel@tonic-gate */ 11377c478bd9Sstevel@tonic-gate savename = args->key.name; 11387c478bd9Sstevel@tonic-gate args->key.name = name; 11397c478bd9Sstevel@tonic-gate args->returnval = 0; 1140ad0e80f7Smichen if (be->return_string_data == 1) { 1141ad0e80f7Smichen be->str2ent_save = args->str2ent; 1142ad0e80f7Smichen args->str2ent = be->str2ent_alt; 1143ad0e80f7Smichen } 1144ad0e80f7Smichen 1145cb5caa98Sdjl (void) nss_search(be->db_rootp, be->db_initf, 11467c478bd9Sstevel@tonic-gate NSS_DBOP_next_iter, args); 1147ad0e80f7Smichen 1148ad0e80f7Smichen if (be->return_string_data == 1) 1149ad0e80f7Smichen args->str2ent = be->str2ent_save; 11507c478bd9Sstevel@tonic-gate args->key.name = savename; /* In case anyone cares */ 11517c478bd9Sstevel@tonic-gate } 11527c478bd9Sstevel@tonic-gate /* 11537c478bd9Sstevel@tonic-gate * Found one via "+", "+name" or "@netgroup". 11547c478bd9Sstevel@tonic-gate * Override some fields if the /etc file says to do so. 11557c478bd9Sstevel@tonic-gate */ 11567c478bd9Sstevel@tonic-gate if (args->returnval == 0) { 11577c478bd9Sstevel@tonic-gate /* ==> ?? Should treat erange differently? */ 11587c478bd9Sstevel@tonic-gate continue; 11597c478bd9Sstevel@tonic-gate } 11607c478bd9Sstevel@tonic-gate /* 'colon' was set umpteen iterations ago in GETENT_FILE */ 11617c478bd9Sstevel@tonic-gate if (colon != 0) { 11627c478bd9Sstevel@tonic-gate *colon = ':'; 11637c478bd9Sstevel@tonic-gate colon = 0; 11647c478bd9Sstevel@tonic-gate } 11657c478bd9Sstevel@tonic-gate return (do_merge(be, args, instr, linelen)); 11667c478bd9Sstevel@tonic-gate } 1167cb5caa98Sdjl /*NOTREACHED*/ 11687c478bd9Sstevel@tonic-gate } 11697c478bd9Sstevel@tonic-gate 11707c478bd9Sstevel@tonic-gate /* We don't use this directly; we just copy the bits when we want to */ 11717c478bd9Sstevel@tonic-gate /* initialize the variable (in the compat_backend struct) that we do use */ 11727c478bd9Sstevel@tonic-gate static DEFINE_NSS_GETENT(context_initval); 11737c478bd9Sstevel@tonic-gate 11747c478bd9Sstevel@tonic-gate nss_backend_t * 11757c478bd9Sstevel@tonic-gate _nss_compat_constr(ops, n_ops, filename, min_bufsize, rootp, initf, netgroups, 11767c478bd9Sstevel@tonic-gate getname_func, merge_func) 11777c478bd9Sstevel@tonic-gate compat_backend_op_t ops[]; 11787c478bd9Sstevel@tonic-gate int n_ops; 11797c478bd9Sstevel@tonic-gate const char *filename; 11807c478bd9Sstevel@tonic-gate int min_bufsize; 11817c478bd9Sstevel@tonic-gate nss_db_root_t *rootp; 11827c478bd9Sstevel@tonic-gate nss_db_initf_t initf; 11837c478bd9Sstevel@tonic-gate int netgroups; 11847c478bd9Sstevel@tonic-gate compat_get_name getname_func; 11857c478bd9Sstevel@tonic-gate compat_merge_func merge_func; 11867c478bd9Sstevel@tonic-gate { 11877c478bd9Sstevel@tonic-gate compat_backend_ptr_t be; 11887c478bd9Sstevel@tonic-gate 11897c478bd9Sstevel@tonic-gate if ((be = (compat_backend_ptr_t)malloc(sizeof (*be))) == 0) { 11907c478bd9Sstevel@tonic-gate return (0); 11917c478bd9Sstevel@tonic-gate } 11927c478bd9Sstevel@tonic-gate be->ops = ops; 11937c478bd9Sstevel@tonic-gate be->n_ops = n_ops; 11947c478bd9Sstevel@tonic-gate be->filename = filename; 11957c478bd9Sstevel@tonic-gate be->f = 0; 11967c478bd9Sstevel@tonic-gate be->minbuf = min_bufsize; 11977c478bd9Sstevel@tonic-gate be->buf = 0; 11987c478bd9Sstevel@tonic-gate 11997c478bd9Sstevel@tonic-gate be->db_rootp = rootp; 12007c478bd9Sstevel@tonic-gate be->db_initf = initf; 12017c478bd9Sstevel@tonic-gate be->db_context = context_initval; 12027c478bd9Sstevel@tonic-gate 12037c478bd9Sstevel@tonic-gate be->getnamef = getname_func; 12047c478bd9Sstevel@tonic-gate be->mergef = merge_func; 12057c478bd9Sstevel@tonic-gate 1206ad0e80f7Smichen be->state = GETENT_FILE; /* i.e. do Automatic setent(); */ 1207ad0e80f7Smichen if (strcmp(be->filename, USERATTR_FILENAME) == 0) { 12087c478bd9Sstevel@tonic-gate be->state = GETENT_ATTRDB; 1209ad0e80f7Smichen be->str2ent_alt = str2userattr_s; 1210ad0e80f7Smichen be->workarea = calloc(1, sizeof (userstr_t)); 1211ad0e80f7Smichen } else if (strcmp(be->filename, AUDITUSER_FILENAME) == 0) { 1212ad0e80f7Smichen be->state = GETENT_ATTRDB; 1213ad0e80f7Smichen be->str2ent_alt = str2auuser_s; 1214ad0e80f7Smichen be->workarea = calloc(1, sizeof (au_user_str_t)); 1215ad0e80f7Smichen } else if (strcmp(be->filename, PASSWD) == 0) { 1216ad0e80f7Smichen be->str2ent_alt = str2passwd; 1217ad0e80f7Smichen be->workarea = calloc(1, sizeof (struct passwd)); 1218ad0e80f7Smichen } else if (strcmp(be->filename, SHADOW) == 0) { 1219ad0e80f7Smichen be->str2ent_alt = str2spwd; 1220ad0e80f7Smichen be->workarea = calloc(1, sizeof (struct spwd)); 1221ad0e80f7Smichen } else { /* group */ 1222ad0e80f7Smichen be->str2ent_alt = str2group; 1223ad0e80f7Smichen be->workarea = calloc(1, sizeof (struct group)); 1224ad0e80f7Smichen } 1225ad0e80f7Smichen if (be->workarea == NULL) 1226ad0e80f7Smichen return (NULL); 12277c478bd9Sstevel@tonic-gate 12287c478bd9Sstevel@tonic-gate be->minuses = 0; 12297c478bd9Sstevel@tonic-gate 12307c478bd9Sstevel@tonic-gate be->permit_netgroups = netgroups; 12317c478bd9Sstevel@tonic-gate be->yp_domain = 0; 12327c478bd9Sstevel@tonic-gate be->getnetgrent_backend = 0; 12337c478bd9Sstevel@tonic-gate be->netgr_buffer = 0; 1234cb5caa98Sdjl be->return_string_data = 0; 12357c478bd9Sstevel@tonic-gate 12367c478bd9Sstevel@tonic-gate return ((nss_backend_t *)be); 12377c478bd9Sstevel@tonic-gate } 1238