xref: /illumos-gate/usr/src/cmd/nscd/nscd_switch.c (revision bbf215553c7233fbab8a0afdf1fac74c44781867)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  * Copyright 2012 Milan Jurik. All rights reserved.
26  */
27 
28 #include <stdlib.h>	/* getenv() */
29 #include <assert.h>
30 #include <unistd.h>
31 #include <string.h>
32 #include <pthread.h>
33 #include <dlfcn.h>
34 #include <nss_dbdefs.h>
35 #include <exec_attr.h>
36 #include <gssapi/gssapi.h>
37 #include "nscd_door.h"
38 #include "nscd_switch.h"
39 #include "nscd_log.h"
40 #include "nscd_frontend.h"
41 
42 #pragma weak nss_search = _nss_search
43 #define	nss_search	_nss_search
44 
45 extern rwlock_t nscd_smf_service_state_lock;
46 
47 /* nscd id: main, forker, or child */
48 extern int _whoami;
49 
50 static int
retry_test(nss_status_t res,int n,struct __nsw_lookup_v1 * lkp)51 retry_test(nss_status_t res, int n, struct __nsw_lookup_v1 *lkp)
52 {
53 	if (res != NSS_TRYAGAIN && res !=  NSS_NISSERVDNS_TRYAGAIN) {
54 		if (res == NSS_SUCCESS) {
55 			__NSW_UNPAUSE_ACTION(lkp->actions[__NSW_TRYAGAIN]);
56 			__NSW_UNPAUSE_ACTION(
57 			    lkp->actions[__NSW_NISSERVDNS_TRYAGAIN]);
58 		}
59 		return (0);
60 	}
61 
62 	if ((res == NSS_TRYAGAIN &&
63 	    lkp->actions[__NSW_TRYAGAIN] == __NSW_TRYAGAIN_FOREVER) ||
64 	    (res == NSS_NISSERVDNS_TRYAGAIN &&
65 	    lkp->actions[__NSW_NISSERVDNS_TRYAGAIN] == __NSW_TRYAGAIN_FOREVER))
66 		return (1);
67 
68 	if (res == NSS_TRYAGAIN &&
69 	    lkp->actions[__NSW_TRYAGAIN] == __NSW_TRYAGAIN_NTIMES)
70 		if (n <= lkp->max_retries)
71 			return (1);
72 		else {
73 			lkp->actions[__NSW_TRYAGAIN] = __NSW_TRYAGAIN_PAUSED;
74 			return (0);
75 		}
76 
77 	if (res == NSS_NISSERVDNS_TRYAGAIN &&
78 	    lkp->actions[__NSW_NISSERVDNS_TRYAGAIN] == __NSW_TRYAGAIN_NTIMES)
79 		if (n <= lkp->max_retries)
80 			return (1);
81 		else {
82 			lkp->actions[__NSW_NISSERVDNS_TRYAGAIN] =
83 			    __NSW_TRYAGAIN_PAUSED;
84 			return (0);
85 		}
86 
87 	return (0);
88 }
89 
90 static thread_key_t loopback_key = THR_ONCE_KEY;
91 typedef struct lb_key {
92 	int		srci;
93 	int		dbi;
94 	int		fnum;
95 	int		*lb_flagp;
96 } lb_key_t;
97 
98 static int
set_loopback_key(lb_key_t * key)99 set_loopback_key(lb_key_t *key) {
100 
101 	int		rc;
102 
103 	rc = thr_keycreate_once(&loopback_key, NULL);
104 	/* set key if not already set */
105 	if (rc == 0 && pthread_getspecific(loopback_key) == NULL)
106 		rc = thr_setspecific(loopback_key, key);
107 
108 	return (rc);
109 }
110 
111 static lb_key_t *
get_loopback_key(void)112 get_loopback_key(void) {
113 
114 	char		*me = "get_loopback_key";
115 	lb_key_t	*k = NULL;
116 
117 	k = pthread_getspecific(loopback_key);
118 
119 	_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
120 	(me, "get loopback key, key = %p\n", k);
121 
122 	return (k);
123 }
124 
125 static void
clear_loopback_key(lb_key_t * key)126 clear_loopback_key(lb_key_t *key) {
127 
128 	char		*me = "clear_loopback_key";
129 
130 	if (loopback_key != THR_ONCE_KEY && key != NULL) {
131 		/*
132 		 * key->lb_flagp points to the location of the
133 		 * flag, check_flag, in the stack where it was
134 		 * first set; clearing the flag tells that
135 		 * stack the loopback error has been resolved
136 		 */
137 		*key->lb_flagp = 0;
138 		(void) thr_setspecific(loopback_key, NULL);
139 	}
140 
141 	_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
142 	(me, "key %p cleared\n", key);
143 }
144 
145 static thread_key_t initf_key = THR_ONCE_KEY;
146 
147 static int
set_initf_key(void * pbuf)148 set_initf_key(void *pbuf) {
149 
150 	int		rc;
151 
152 	rc = thr_keycreate_once(&initf_key, NULL);
153 	if (rc == 0)
154 		rc = thr_setspecific(initf_key, pbuf);
155 
156 	return (rc);
157 }
158 
159 static void *
get_initf_key(void)160 get_initf_key(void) {
161 
162 	char		*me = "get_initf_key";
163 	void		*pbuf;
164 
165 	pbuf = pthread_getspecific(initf_key);
166 
167 	_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
168 	(me, "got initf pbuf, key = %p\n", pbuf);
169 
170 	return (pbuf);
171 }
172 
173 static void
clear_initf_key(void)174 clear_initf_key(void) {
175 
176 	char		*me = "clear_initf_key";
177 
178 	(void) thr_setspecific(initf_key, NULL);
179 
180 	_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
181 	(me, "initf pbuf cleared\n");
182 }
183 
184 /*
185  * Call the input initf function to extract the
186  * NSS front end parameters and examine them to
187  * determine if an NSS lookup is to be performed
188  * on a regular or a pseudo (called from compat
189  * backend) database. Then set the necessary
190  * parameters for later data structures creation
191  * and processing.
192  */
193 static nscd_rc_t
getparams(int search_fnum,nss_db_initf_t initf,nscd_nsw_params_t * params)194 getparams(
195 	int			search_fnum,
196 	nss_db_initf_t		initf,
197 	nscd_nsw_params_t	*params)
198 {
199 
200 	nscd_rc_t	rc = NSCD_SUCCESS;
201 	nss_db_params_t	*p;
202 	int		j;
203 	char		*dbn;
204 	const char	*n;
205 	char		*me = "getparams";
206 
207 	p = &params->p;
208 	(void) memset(params, 0, sizeof (nscd_nsw_params_t));
209 	(*initf)(p);
210 	params->dbi = -1;
211 	params->cfgdbi = -1;
212 	params->compati = -1;
213 	params->dnsi = -1;
214 
215 	/* map database name to index */
216 	n = p->name;
217 	for (j = 0; j < NSCD_NUM_DB; j++) {
218 		dbn = NSCD_NSW_DB_NAME(j);
219 		if (*n != *dbn)
220 			continue;
221 		if (strcmp(n, dbn) == 0) {
222 			params->dbi = j;
223 			if (*n != 'h' && *n != 'i' && *n != 's' && *n != 'a')
224 				break;
225 			if (strcmp(n, NSS_DBNAM_HOSTS) == 0 &&
226 			    search_fnum == NSS_DBOP_HOSTS_BYNAME)
227 				params->dnsi = 0;
228 			else if (strcmp(n, NSS_DBNAM_IPNODES) == 0 &&
229 			    search_fnum == NSS_DBOP_IPNODES_BYNAME)
230 				params->dnsi = 1;
231 			else if (strcmp(n, NSS_DBNAM_SHADOW) == 0)
232 				params->privdb = 1;
233 			break;
234 		}
235 	}
236 
237 	/*
238 	 * use the switch policy for passwd_compat or
239 	 * group_compat?
240 	 */
241 	if (p->config_name != NULL) {
242 		n = p->config_name;
243 		for (j = 0; j < NSCD_NUM_DB; j++) {
244 			dbn = NSCD_NSW_DB_NAME(j);
245 			if (*n == *dbn) {
246 				if (strcmp(n, dbn) == 0) {
247 					params->cfgdbi = j;
248 					break;
249 				}
250 			}
251 		}
252 	}
253 
254 	/* map the database name to the pseudo database index */
255 	if (params->cfgdbi != -1) {
256 		if (strstr(p->config_name, "_compat") != NULL) {
257 			n = p->name;
258 			for (j = params->cfgdbi; j < NSCD_NUM_DB; j++) {
259 				dbn = NSCD_NSW_DB_NAME(j);
260 				if (*n == *dbn) {
261 					if (strcmp(n, dbn) == 0) {
262 						params->compati = j;
263 						break;
264 					}
265 				}
266 			}
267 		}
268 	}
269 
270 	/*
271 	 * if unsupported database, let caller determine what to do next
272 	 */
273 	if (params->dbi == -1) {
274 		_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
275 		(me, "unsupported database: %s\n", p->name);
276 		return (NSCD_CFG_UNSUPPORTED_SWITCH_DB);
277 	}
278 
279 	return (rc);
280 }
281 
282 static void
nscd_initf(nss_db_params_t * p)283 nscd_initf(nss_db_params_t	*p)
284 {
285 	nss_pheader_t		*pbuf;
286 	nssuint_t		off;
287 	nss_dbd_t		*pdbd;
288 	char			*me = "nscd_initf";
289 
290 	pbuf = (nss_pheader_t *)get_initf_key();
291 	if (pbuf == NULL) {
292 		_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
293 		(me, "ERROR: initf key not set\n");
294 		return;
295 	}
296 
297 	if (pbuf->dbd_len <= sizeof (nss_dbd_t)) {
298 		_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
299 		(me, "invalid db front params data ? dbd_len = %d\n",
300 		    pbuf->dbd_len);
301 		return;
302 	}
303 
304 	off = pbuf->dbd_off;
305 	pdbd = (nss_dbd_t *)((void *)((char *)pbuf + off));
306 
307 	p->name = (char *)pdbd + pdbd->o_name;
308 	p->config_name = (char *)pdbd + pdbd->o_config_name;
309 	p->default_config = (char *)pdbd + pdbd->o_default_config;
310 	p->flags = (enum nss_dbp_flags)pdbd->flags;
311 	(void) memcpy(&p->private, &pbuf->nscdpriv, sizeof (p->private));
312 
313 	_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
314 	(me, "db frontend params: name =%s, config_name = %s, "
315 	"default_config = %s, flags = %x\n", p->name,
316 	    (p->config_name && *p->config_name != '\0' ?
317 	    p->config_name : "<NOT SPECIFIED>"),
318 	    (p->default_config && *p->default_config != '\0' ?
319 	    p->default_config : "<NOT SPECIFIED>"),
320 	    p->flags);
321 }
322 
323 
324 static void
trace_result(int dbi,int srci,int op,nss_status_t res,nss_XbyY_args_t * arg)325 trace_result(
326 	int		dbi,
327 	int		srci,
328 	int		op,
329 	nss_status_t	res,
330 	nss_XbyY_args_t	*arg)
331 {
332 	char	*res_str;
333 	char	*src = "?";
334 	char	*db = "?";
335 	char	*data_str = "<NOT STRING FORMAT>";
336 	int	data_len = 0;
337 	char	*me = "trace_result";
338 
339 	switch (res) {
340 	case NSS_SUCCESS:
341 		res_str = "NSS_SUCCESS";
342 		break;
343 	case NSS_NOTFOUND:
344 		res_str = "NSS_NOTFOUND";
345 		break;
346 	case NSS_UNAVAIL:
347 		res_str = "NSS_UNAVAIL";
348 		break;
349 	case NSS_TRYAGAIN:
350 		res_str = "NSS_TRYAGAIN";
351 		break;
352 	case NSS_NISSERVDNS_TRYAGAIN:
353 		res_str = "NSS_NISSERVDNS_TRYAGAIN";
354 		break;
355 	default:
356 		res_str = "UNKNOWN STATUS";
357 		break;
358 	}
359 
360 	if (dbi != -1)
361 		db = NSCD_NSW_DB_NAME(dbi);
362 	if (srci != -1)
363 		src = NSCD_NSW_SRC_NAME(srci);
364 
365 	if (arg->buf.result == NULL) {
366 		data_str = arg->buf.buffer;
367 		data_len = arg->returnlen;
368 	}
369 
370 	if (res == NSS_SUCCESS) {
371 		_nscd_logit(me, "%s: database: %s, operation: %d, "
372 		    "source: %s returned >>%s<<, length = %d\n",
373 		    res_str, db, op, src, data_str, data_len);
374 		return;
375 	}
376 
377 	_nscd_logit(me, "%s: database: %s, operation: %d, source: %s, "
378 	    "erange= %d, herrno: %s (%d)\n",
379 	    res_str, db, op, src, arg->erange, hstrerror(arg->h_errno),
380 	    arg->h_errno);
381 }
382 
383 /*
384  * Determine if a request should be done locally in the getXbyY caller's
385  * process. Return none zero if yes, 0 otherwise. This should be called
386  * before the switch engine steps through the backends/sources.
387  * This function returns 1 if:
388  *   -- the database is exec_attr and the search_flag is GET_ALL
389  */
390 static int
try_local(int dbi,void * arg)391 try_local(
392 	int			dbi,
393 	void			*arg)
394 {
395 	struct nss_XbyY_args	*ap = (struct nss_XbyY_args *)arg;
396 	_priv_execattr		*ep;
397 	int			rc = 0;
398 	char			*me = "try_local";
399 
400 	if (strcmp(NSCD_NSW_DB_NAME(dbi), NSS_DBNAM_EXECATTR) == 0) {
401 		if ((ep = ap->key.attrp) != NULL && IS_GET_ALL(ep->search_flag))
402 			rc = 1;
403 	}
404 
405 	if (rc != 0) {
406 
407 		_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
408 		(me, "TRYLOCAL: exec_attr:GET_ALL\n");
409 	}
410 
411 	return (rc);
412 }
413 
414 /*
415  * Determine if a request should be done locally in the getXbyY caller's
416  * process. Return none zero if yes, 0 otherwise. This should be called
417  * before the switch engine invokes any backend.
418  * This function returns 1 if:
419  *   -- the database is shadow and the source is compat
420  */
421 static int
try_local2(int dbi,int srci)422 try_local2(
423 	int	dbi,
424 	int	srci)
425 {
426 	int	rc = 0;
427 	char	*me = "try_local2";
428 
429 	if (*NSCD_NSW_DB_NAME(dbi) == 's' &&
430 	    strcmp(NSCD_NSW_DB_NAME(dbi), NSS_DBNAM_SHADOW) == 0) {
431 		if (strcmp(NSCD_NSW_SRC_NAME(srci), "compat") == 0)
432 			rc = 1;
433 	}
434 
435 	if (rc != 0) {
436 		_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
437 		(me, "TRYLOCAL: database: shadow, source: %s\n",
438 		    NSCD_NSW_SRC_NAME(srci));
439 	}
440 
441 	return (rc);
442 }
443 
444 static nscd_rc_t
get_lib_func(void ** handle,void ** func,mutex_t * lock,char * lib,char * name,void ** func_p)445 get_lib_func(void **handle, void **func, mutex_t *lock,
446 	char *lib, char *name, void **func_p)
447 {
448 	char	*me = "get_lib_func";
449 	void	*sym;
450 
451 	if (func_p != NULL && *handle != NULL && *func != NULL) {
452 		*func_p = *func;
453 		return (NSCD_SUCCESS);
454 	}
455 
456 	(void) mutex_lock(lock);
457 
458 	/* close the handle if requested */
459 	if (func_p == NULL) {
460 		if (*handle != NULL) {
461 			(void) dlclose(*handle);
462 			*handle = NULL;
463 			*func = NULL;
464 		}
465 		(void) mutex_unlock(lock);
466 		return (NSCD_SUCCESS);
467 	}
468 
469 	if (*handle != NULL && *func != NULL) {
470 		*func_p = *func;
471 		(void) mutex_unlock(lock);
472 		return (NSCD_SUCCESS);
473 	}
474 
475 	if (*handle == NULL) {
476 		*handle = dlopen(lib, RTLD_LAZY);
477 		if (*handle == NULL) {
478 			_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_ERROR)
479 			(me, "unable to dlopen %s\n", lib);
480 			(void) mutex_unlock(lock);
481 			return (NSCD_CFG_DLOPEN_ERROR);
482 		}
483 	}
484 
485 	if ((sym = dlsym(*handle, name)) == NULL) {
486 
487 		_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_ERROR)
488 		(me, "unable to find symbol %s:%s\n", lib, name);
489 		(void) mutex_unlock(lock);
490 		return (NSCD_CFG_DLSYM_ERROR);
491 	} else {
492 		*func_p = sym;
493 		*func = sym;
494 	}
495 
496 	(void) mutex_unlock(lock);
497 	return (NSCD_SUCCESS);
498 }
499 
500 static nscd_rc_t
get_libc_nss_search(void ** func_p)501 get_libc_nss_search(void **func_p)
502 {
503 	static void	*handle = NULL;
504 	static void	*func = NULL;
505 	static mutex_t	lock = DEFAULTMUTEX;
506 
507 	return (get_lib_func(&handle, &func, &lock,
508 	    "libc.so", "nss_search", func_p));
509 }
510 
511 static nscd_rc_t
get_gss_func(void ** func_p)512 get_gss_func(void **func_p)
513 {
514 	static void	*handle = NULL;
515 	static void	*func = NULL;
516 	static mutex_t	lock = DEFAULTMUTEX;
517 
518 	return (get_lib_func(&handle, &func, &lock,
519 	    "libgss.so", "gss_inquire_cred", func_p));
520 }
521 
522 static nscd_rc_t
get_sldap_shadow_func(void ** func_p)523 get_sldap_shadow_func(void **func_p)
524 {
525 	static void	*handle = NULL;
526 	static void	*func = NULL;
527 	static mutex_t	lock = DEFAULTMUTEX;
528 
529 	return (get_lib_func(&handle, &func, &lock,
530 	    "libsldap.so", "__ns_ldap_is_shadow_update_enabled",
531 	    func_p));
532 }
533 
534 /*
535  * get_dns_funcs returns pointers to gethostbyname functions in the
536  * dynamically loaded nss_dns & nss_mdns modules that return host
537  * lookup results along with the TTL value in the DNS resource
538  * records. The dnsi parameter indicates whether the lookup database
539  * is hosts(0) or ipnodes(1). The srcname parameter identifies the DNS
540  * module: dns/mdns and the function returns the address of the specific
541  * gethostbyname function in func_p variable.
542  */
543 static nscd_rc_t
get_dns_funcs(int dnsi,nss_status_t (** func_p)(),const char * srcname)544 get_dns_funcs(int dnsi, nss_status_t (**func_p)(), const char *srcname)
545 {
546 	int		si;
547 	void		**funcpp;
548 	static void	*handle[2] = { NULL, NULL };
549 	static mutex_t	func_lock[2] = { DEFAULTMUTEX, DEFAULTMUTEX };
550 	static void 	*func[2][2] = {{NULL, NULL}, {NULL, NULL}};
551 	static const char	*lib[2] = { "nss_dns.so.1", "nss_mdns.so.1" };
552 	static const char 	*func_name[2][2] =
553 		{{ "_nss_get_dns_hosts_name", "_nss_get_dns_ipnodes_name" },
554 		{ "_nss_get_mdns_hosts_name", "_nss_get_mdns_ipnodes_name" }};
555 
556 	/* source index: 0 = dns, 1 = mdns */
557 	if (strcmp(srcname, "dns") == 0)
558 		si = 0;
559 	else
560 		si = 1;
561 
562 	/*
563 	 * function index (func[si][dnsi]):
564 	 * [0,0] = dns/hosts, [0,1] = dns/ipnodes,
565 	 * [1,0] = mdns/hosts, [1,1] = mdns/ipnodes
566 	 */
567 
568 	if (dnsi < 0) { /* close handle */
569 		funcpp = NULL;
570 		(void) mutex_lock(&func_lock[si]);
571 		func[si][0] = NULL;
572 		func[si][1] = NULL;
573 		(void) mutex_unlock(&func_lock[si]);
574 	} else
575 		funcpp = (void **)func_p;
576 
577 	return (get_lib_func(&handle[si], &func[si][dnsi], &func_lock[si],
578 	    (char *)lib[si], (char *)func_name[si][dnsi], funcpp));
579 }
580 
581 static nss_status_t
search_dns_withttl(nscd_sw_return_t * swret,const char * srcname,int dnsi)582 search_dns_withttl(nscd_sw_return_t *swret, const char *srcname, int dnsi)
583 {
584 	nss_status_t	(*func)();
585 	nss_status_t	res = NSS_UNAVAIL;
586 	nscd_rc_t	rc;
587 
588 	swret->noarg = 0;
589 	if (strcmp(srcname, "dns") != 0 && strcmp(srcname, "mdns") != 0)
590 		return (NSS_ERROR);
591 
592 	rc = get_dns_funcs(dnsi, &func, srcname);
593 	if (rc == NSCD_SUCCESS) {
594 		/*
595 		 * data_len in the packed buf header may be changed
596 		 * by the dns or mdns backend, reset it just in
597 		 * case
598 		 */
599 		((nss_pheader_t *)swret->pbuf)->data_len =
600 		    swret->datalen;
601 		res = (func)(NULL, &swret->pbuf, &swret->pbufsiz);
602 	}
603 	return (res);
604 }
605 
606 /*
607  * Returns a flag to indicate if needs to fall back to the
608  * main nscd when a per-user lookup failed with rc NSS_NOTFOUND.
609  */
610 static int
set_fallback_flag(char * srcname,nss_status_t rc)611 set_fallback_flag(char *srcname, nss_status_t rc)
612 {
613 	char	*me = "set_fallback_flag";
614 	if (strcmp(srcname, "ldap") == 0 && rc == NSS_NOTFOUND) {
615 		_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
616 		(me, "NSS_NOTFOUND (ldap): fallback to main nscd "
617 		"may be needed\n");
618 		return (1);
619 	}
620 	return (0);
621 }
622 
623 nss_status_t
nss_search(nss_db_root_t * rootp,nss_db_initf_t initf,int search_fnum,void * search_args)624 nss_search(nss_db_root_t *rootp, nss_db_initf_t initf, int search_fnum,
625 	void *search_args)
626 {
627 	char			*me = "nss_search";
628 	nss_status_t		res = NSS_UNAVAIL;
629 	nscd_nsw_state_t	*s = NULL;
630 	int			n_src;
631 	unsigned int		status_vec = 0;
632 	int			dbi, srci = -1;
633 	int			check_loopback = 0;
634 	int			state_thr = 0;
635 	lb_key_t		key, *k = NULL;
636 	nss_db_root_t		root_db;
637 	nscd_nsw_params_t	params;
638 	nscd_sw_return_t	*swret;
639 
640 	_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
641 	(me, "rootp = %p, initf = %p, search_fnum = %d, "
642 	    "search_args = %p\n", rootp, initf,
643 	    search_fnum, search_args);
644 
645 	NSCD_SW_STATS_G.lookup_request_received_g++;
646 	NSCD_SW_STATS_G.lookup_request_in_progress_g++;
647 	NSCD_SW_STATS_G.lookup_request_queued_g++;
648 
649 	/* determine db index, cfg db index, etc */
650 	if (getparams(search_fnum, initf, &params) ==
651 	    NSCD_CFG_UNSUPPORTED_SWITCH_DB) {
652 		/*
653 		 * if unsupported database and the request is from the
654 		 * the door, tell the door client to try it locally
655 		 */
656 		if (initf == nscd_initf) {
657 			res = NSS_TRYLOCAL;
658 			goto error_exit;
659 		} else { /* otherwise, let libc:nss_search() handle it */
660 			nss_status_t	(*func)();
661 
662 			if (get_libc_nss_search((void **)&func) ==
663 			    NSCD_SUCCESS)
664 				return ((func)(rootp, initf, search_fnum,
665 				    search_args));
666 			else
667 				goto error_exit;
668 		}
669 	}
670 	dbi = params.dbi;
671 
672 	/* get address of the switch engine return data area */
673 	if (initf == nscd_initf) {
674 		swret = (nscd_sw_return_t *)params.p.private;
675 		swret->srci = -1;
676 	} else {
677 		swret = NULL;
678 		params.dnsi = -1;
679 	}
680 
681 	/*
682 	 * for door request that should be processed by the client,
683 	 * send it back with status NSS_TRYLOCAL
684 	 */
685 	if (initf == nscd_initf && try_local(dbi, search_args) == 1) {
686 		res = NSS_TRYLOCAL;
687 		goto error_exit;
688 	}
689 
690 	NSCD_SW_STATS(dbi).lookup_request_received++;
691 	NSCD_SW_STATS(dbi).lookup_request_in_progress++;
692 	NSCD_SW_STATS(dbi).lookup_request_queued++;
693 
694 	/* if lookup not enabled, return NSS_UNAVAIL  */
695 	if (!(NSCD_SW_CFG_G.enable_lookup_g == nscd_true &&
696 	    NSCD_SW_CFG(dbi).enable_lookup == nscd_true)) {
697 
698 		_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
699 		(me, "lookup not enabled for %s\n", NSCD_NSW_DB_NAME(dbi));
700 
701 		goto error_exit;
702 	}
703 
704 	/* determine if loopback checking is configured */
705 	if (NSCD_SW_CFG_G.enable_loopback_checking_g == nscd_true &&
706 	    NSCD_SW_CFG(dbi).enable_loopback_checking == nscd_true) {
707 		check_loopback = 1;
708 
709 		_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
710 		(me, "loopback checking enabled for %s\n",
711 		    NSCD_NSW_DB_NAME(dbi));
712 	}
713 
714 	if (check_loopback) {
715 		k = get_loopback_key();
716 		if (k != NULL) {
717 			if (k->dbi != dbi || k->fnum != search_fnum) {
718 				clear_loopback_key(k);
719 				k = NULL;
720 			}
721 		}
722 	}
723 
724 	if (s == 0) {
725 		nscd_rc_t	rc;
726 
727 		if (check_loopback) {
728 			rc = _nscd_get_nsw_state_thread(&root_db, &params);
729 			state_thr = 1;
730 		} else
731 			rc = _nscd_get_nsw_state(&root_db, &params);
732 
733 		NSCD_SW_STATS_G.lookup_request_queued_g--;
734 		NSCD_SW_STATS(dbi).lookup_request_queued--;
735 
736 		if (rc != NSCD_SUCCESS)
737 				goto error_exit;
738 
739 		s = (nscd_nsw_state_t *)root_db.s;
740 	}
741 
742 	_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
743 	(me, "database = %s, config = >>%s<<\n", NSCD_NSW_DB_NAME(dbi),
744 	    (*s->nsw_cfg_p)->nsw_cfg_str);
745 
746 	for (n_src = 0;  n_src < s->max_src;  n_src++) {
747 		nss_backend_t		*be = NULL;
748 		nss_backend_op_t	funcp = NULL;
749 		struct __nsw_lookup_v1	*lkp;
750 		int			smf_state;
751 		int			n_loop = 0;
752 		int			max_retry = 10;
753 
754 		res = NSS_UNAVAIL;
755 
756 		if (n_src == 0)
757 			lkp = s->config->lookups;
758 		else
759 			lkp = lkp->next;
760 
761 		/* set the number of max. retries */
762 		if (lkp->actions[__NSW_TRYAGAIN] == __NSW_TRYAGAIN_NTIMES)
763 			max_retry = lkp->max_retries;
764 
765 		srci = (*s->nsw_cfg_p)->src_idx[n_src];
766 		if (swret != NULL)
767 			swret->srci = srci;
768 
769 		_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
770 		(me, "nsw source = %s\n", NSCD_NSW_SRC_NAME(srci));
771 
772 		/*
773 		 * If no privilege to look up, skip.
774 		 * 'files' requires PRIV_FILE_DAC_READ to read shadow(5) data,
775 		 * 'ldap' requires all zones privilege.
776 		 */
777 		if (params.privdb == 1 && swret != NULL) {
778 			boolean_t	(*is_shadow_update_enabled)();
779 			boolean_t	check_ldap_priv = B_FALSE;
780 
781 			if (strcmp(NSCD_NSW_SRC_NAME(srci), "ldap") == 0) {
782 				if (get_sldap_shadow_func(
783 				    (void **)&is_shadow_update_enabled) ==
784 				    NSCD_SUCCESS &&
785 				    is_shadow_update_enabled()) {
786 					check_ldap_priv = B_TRUE;
787 
788 					/*
789 					 * A peruser nscd doesn't have
790 					 * the privileges to lookup a
791 					 * private database, such as shadow,
792 					 * returns NSS_ALTRETRY to have the
793 					 * main nscd do the job.
794 					 */
795 					if (_whoami == NSCD_CHILD) {
796 						res = NSS_ALTRETRY;
797 						goto free_nsw_state;
798 					}
799 				}
800 			}
801 
802 			if ((strcmp(NSCD_NSW_SRC_NAME(srci), "files") == 0 &&
803 			    _nscd_check_client_priv(NSCD_READ_PRIV) != 0) ||
804 			    (check_ldap_priv &&
805 			    _nscd_check_client_priv(NSCD_ALL_PRIV) != 0)) {
806 				_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE,
807 				    NSCD_LOG_LEVEL_DEBUG)
808 				(me, "no privilege to look up, skip source\n");
809 
810 				goto next_src;
811 			}
812 		}
813 
814 		/* get state of the (backend) client service */
815 		smf_state = _nscd_get_smf_state(srci, dbi, 0);
816 
817 		/* stop if the source is one that should be TRYLOCAL */
818 		if (initf == nscd_initf &&	/* request is from the door */
819 		    (smf_state == NSCD_SVC_STATE_UNSUPPORTED_SRC ||
820 		    (smf_state == NSCD_SVC_STATE_FOREIGN_SRC &&
821 		    s->be_version_p[n_src] == NULL) ||
822 		    (params.privdb && try_local2(dbi, srci) == 1))) {
823 			_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
824 			(me, "returning TRYLOCAL ... \n");
825 			res = NSS_TRYLOCAL;
826 			goto free_nsw_state;
827 		}
828 
829 		if (check_loopback && k != NULL) {
830 
831 			if (k->srci == srci && k->dbi == dbi)
832 				if (k->fnum == search_fnum) {
833 
834 					_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE,
835 					    NSCD_LOG_LEVEL_DEBUG)
836 					(me, "loopback detected: "
837 					    "source = %s, database = %s "
838 					    "search fnum = %d\n",
839 					    NSCD_NSW_SRC_NAME(srci),
840 					    NSCD_NSW_DB_NAME(dbi), search_fnum);
841 
842 				NSCD_SW_STATS_G.loopback_nsw_db_skipped_g++;
843 				NSCD_SW_STATS(dbi).loopback_nsw_db_skipped++;
844 					continue;
845 				}
846 		}
847 
848 		be = s->be[n_src];
849 		if (be != NULL)
850 			funcp = NSS_LOOKUP_DBOP(be, search_fnum);
851 
852 		/* request could be from within nscd so check states again */
853 		if (be == NULL || (params.dnsi < 0 && (funcp == NULL ||
854 		    (smf_state != NSCD_SVC_STATE_UNINITED &&
855 		    smf_state != NSCD_SVC_STATE_UNSUPPORTED_SRC &&
856 		    smf_state != NSCD_SVC_STATE_FOREIGN_SRC &&
857 		    smf_state < SCF_STATE_ONLINE)))) {
858 
859 			_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE,
860 			    NSCD_LOG_LEVEL_DEBUG)
861 			(me, "unable to look up source %s: be = %p, "
862 			"smf state = %d, funcp = %p\n",
863 			    NSCD_NSW_SRC_NAME(srci), be, smf_state, funcp);
864 
865 			goto next_src;
866 		}
867 
868 		do {
869 			/*
870 			 * we can only retry max_retry times,
871 			 * otherwise threads may get stuck in this
872 			 * do-while loop forever
873 			 */
874 			if (n_loop > max_retry) {
875 				if (swret != NULL)
876 					res = NSS_TRYLOCAL;
877 				goto free_nsw_state;
878 			}
879 
880 			/*
881 			 * set up to prevent loopback
882 			 */
883 			if (check_loopback && k == NULL) {
884 				key.srci = srci;
885 				key.dbi = dbi;
886 				key.fnum = search_fnum;
887 				key.lb_flagp = &check_loopback;
888 				(void) set_loopback_key(&key);
889 				k = &key;
890 			}
891 
892 			_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE,
893 			    NSCD_LOG_LEVEL_DEBUG)
894 			(me, "looking up source = %s, loop# = %d \n",
895 			    NSCD_NSW_SRC_NAME(srci), n_loop);
896 
897 			/*
898 			 * search the backend, if hosts lookups,
899 			 * try to get the hosts data with ttl first
900 			 */
901 			if (params.dnsi >= 0) {
902 				res = search_dns_withttl(swret,
903 				    NSCD_NSW_SRC_NAME(srci), params.dnsi);
904 				/*
905 				 * if not able to get ttl, fall back
906 				 * to the regular backend call
907 				 */
908 				if (res == NSS_ERROR)
909 					res = (*funcp)(be, search_args);
910 				else {
911 					/*
912 					 * status/result are in the
913 					 * packed buffer, not
914 					 * search_args
915 					 */
916 					swret->noarg = 1;
917 				}
918 			} else
919 				res = (*funcp)(be, search_args);
920 			if (swret != NULL)
921 				swret->errnum = errno;
922 
923 			/*
924 			 * backend is not up, check and update the
925 			 * smf state table
926 			 */
927 			if (res == NSS_UNAVAIL)
928 				(void) _nscd_get_smf_state(srci, dbi, 1);
929 
930 			/*
931 			 * may need to fall back to use the main nscd
932 			 * if per-user lookup
933 			 */
934 			if (_whoami == NSCD_CHILD && swret != NULL)
935 				swret->fallback = set_fallback_flag(
936 				    NSCD_NSW_SRC_NAME(srci), res);
937 
938 			_NSCD_LOG_IF(NSCD_LOG_SWITCH_ENGINE,
939 			    NSCD_LOG_LEVEL_DEBUG) {
940 
941 				/*
942 				 * set up to trace the result/status
943 				 * of the dns/ttl lookup
944 				 */
945 				if (swret != NULL && swret->noarg == 1) {
946 					nss_pheader_t *phdr;
947 					struct nss_XbyY_args *arg;
948 					arg = (struct nss_XbyY_args *)
949 					    search_args;
950 					phdr = (nss_pheader_t *)swret->pbuf;
951 					arg->buf.buffer = (char *)phdr +
952 					    phdr->data_off;
953 					arg->returnlen = phdr->data_len;
954 					if (phdr->p_errno == ERANGE)
955 						arg->erange = 1;
956 					arg->h_errno = phdr->p_herrno;
957 				}
958 
959 				trace_result(dbi, srci, search_fnum, res,
960 				    (nss_XbyY_args_t *)search_args);
961 			}
962 
963 			n_loop++;
964 		} while (retry_test(res, n_loop, lkp));
965 
966 		next_src:
967 
968 		status_vec |= (1 << res);
969 
970 		if (__NSW_ACTION_V1(lkp, res) == __NSW_RETURN) {
971 			break;
972 		}
973 	}
974 
975 	free_nsw_state:
976 
977 	if (state_thr == 1)
978 		_nscd_put_nsw_state_thread(s);
979 	else
980 		_nscd_put_nsw_state(s);
981 	if (check_loopback && k != NULL)
982 		clear_loopback_key(k);
983 
984 	if (res != NSS_SUCCESS)
985 		goto error_exit;
986 
987 	NSCD_SW_STATS_G.lookup_request_succeeded_g++;
988 	NSCD_SW_STATS(dbi).lookup_request_succeeded++;
989 	NSCD_SW_STATS_G.lookup_request_in_progress_g--;
990 	NSCD_SW_STATS(dbi).lookup_request_in_progress--;
991 
992 	return (NSS_SUCCESS);
993 
994 	error_exit:
995 
996 	NSCD_SW_STATS_G.lookup_request_failed_g++;
997 	NSCD_SW_STATS_G.lookup_request_in_progress_g--;
998 	NSCD_SW_STATS(dbi).lookup_request_failed++;
999 	NSCD_SW_STATS(dbi).lookup_request_in_progress--;
1000 
1001 	return (res);
1002 }
1003 
1004 
1005 /* ===> get/set/endent */
1006 
1007 static void		nss_setent_u(nss_db_root_t *,
1008 				    nss_db_initf_t,
1009 				    nss_getent_t *);
1010 static nss_status_t	nss_getent_u(nss_db_root_t *,
1011 				    nss_db_initf_t,
1012 				    nss_getent_t *,
1013 				    void *);
1014 static void		nss_endent_u(nss_db_root_t *,
1015 				    nss_db_initf_t,
1016 				    nss_getent_t *);
1017 
1018 void
nss_setent(nss_db_root_t * rootp,nss_db_initf_t initf,nss_getent_t * contextpp)1019 nss_setent(nss_db_root_t *rootp, nss_db_initf_t initf,
1020 	nss_getent_t *contextpp)
1021 {
1022 	if (contextpp == 0)
1023 		return;
1024 	nss_setent_u(rootp, initf, contextpp);
1025 }
1026 
1027 nss_status_t
nss_getent(nss_db_root_t * rootp,nss_db_initf_t initf,nss_getent_t * contextpp,void * args)1028 nss_getent(nss_db_root_t *rootp, nss_db_initf_t initf, nss_getent_t *contextpp,
1029 	void *args)
1030 {
1031 	nss_status_t		status;
1032 
1033 	if (contextpp == 0) {
1034 		return (NSS_UNAVAIL);
1035 	}
1036 	status = nss_getent_u(rootp, initf, contextpp, args);
1037 	return (status);
1038 }
1039 
1040 void
nss_endent(nss_db_root_t * rootp,nss_db_initf_t initf,nss_getent_t * contextpp)1041 nss_endent(nss_db_root_t *rootp, nss_db_initf_t initf,
1042 	nss_getent_t *contextpp)
1043 {
1044 	if (contextpp == 0)
1045 		return;
1046 	nss_endent_u(rootp, initf, contextpp);
1047 }
1048 
1049 /*ARGSUSED*/
1050 static void
end_iter_u(nss_db_root_t * rootp,struct nss_getent_context * contextp)1051 end_iter_u(nss_db_root_t *rootp, struct nss_getent_context *contextp)
1052 {
1053 	nscd_getent_context_t	*ctx;
1054 	nscd_nsw_state_t	*s;
1055 	nss_backend_t		*be;
1056 	int			n_src;
1057 
1058 	ctx = (nscd_getent_context_t *)contextp;
1059 	s = ctx->nsw_state;
1060 	n_src = ctx->n_src;
1061 	be = ctx->be;
1062 
1063 	if (s != 0) {
1064 		if (n_src < s->max_src && be != 0) {
1065 			(void) NSS_INVOKE_DBOP(be, NSS_DBOP_ENDENT, 0);
1066 			ctx->be = 0;  /* Should be unnecessary, but hey */
1067 		}
1068 	}
1069 	ctx->n_src = 0;
1070 }
1071 
1072 static void
nss_setent_u(nss_db_root_t * rootp,nss_db_initf_t initf,nss_getent_t * contextpp)1073 nss_setent_u(nss_db_root_t *rootp, nss_db_initf_t initf,
1074 	nss_getent_t *contextpp)
1075 {
1076 	char			*me = "nss_setent_u";
1077 	nscd_nsw_state_t	*s;
1078 	nscd_getent_context_t	*contextp;
1079 	nscd_nsw_params_t	params;
1080 	nss_db_root_t		root;
1081 	nss_backend_t		*be;
1082 	int			n_src, i;
1083 	nscd_sw_return_t	*swret = NULL;
1084 
1085 	_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
1086 	(me, "rootp = %p, initf = %p, contextpp = %p \n",
1087 	    rootp, initf, contextpp);
1088 
1089 	/*
1090 	 * Get the nsw db index via the initf function. If unsupported
1091 	 * database, no need to continue
1092 	 */
1093 	if (getparams(-1, initf, &params) == NSCD_CFG_UNSUPPORTED_SWITCH_DB)
1094 		return;
1095 
1096 	/* get address of the switch engine return data area */
1097 	if (initf == nscd_initf)
1098 		swret = (nscd_sw_return_t *)params.p.private;
1099 
1100 	/* if no privilege to look up, return */
1101 	if (params.privdb == 1 && swret != NULL &&
1102 	    _nscd_check_client_priv(NSCD_READ_PRIV) != 0) {
1103 
1104 		_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
1105 		(me, "no privilege \n");
1106 		return;
1107 	}
1108 
1109 	if ((contextp = (nscd_getent_context_t *)contextpp->ctx) == 0) {
1110 		if ((_nscd_get_getent_ctx(contextpp, &params)) !=
1111 		    NSCD_SUCCESS) {
1112 			return;
1113 		}
1114 		contextp = (nscd_getent_context_t *)contextpp->ctx;
1115 	}
1116 	s = contextp->nsw_state;
1117 
1118 	if (s == 0) {
1119 		if (_nscd_get_nsw_state(&root, &params) !=
1120 		    NSCD_SUCCESS) {
1121 			return;
1122 		}
1123 		s = (nscd_nsw_state_t *)root.s;
1124 		contextp->nsw_state = s;
1125 
1126 	} else {
1127 		s	= contextp->nsw_state;
1128 		n_src	= contextp->n_src;
1129 		be	= contextp->be;
1130 		if (n_src == 0 && be != 0) {
1131 			/*
1132 			 * Optimization:  don't do endent, don't change
1133 			 *   backends, just do the setent.  Look Ma, no locks
1134 			 *   (nor any context that needs updating).
1135 			 */
1136 			(void) NSS_INVOKE_DBOP(be, NSS_DBOP_SETENT, 0);
1137 			return;
1138 		}
1139 		if (n_src < s->max_src && be != 0) {
1140 			(void) NSS_INVOKE_DBOP(be, NSS_DBOP_ENDENT, 0);
1141 			contextp->be = 0;	/* Play it safe */
1142 		}
1143 	}
1144 	for (n_src = 0, be = 0; n_src < s->max_src &&
1145 	    (be = s->be[n_src]) == 0; n_src++) {
1146 		;
1147 	}
1148 
1149 	contextp->n_src	= n_src;
1150 	contextp->be	= be;
1151 
1152 	if (be == 0) {
1153 		/* Things are broken enough that we can't do setent/getent */
1154 		nss_endent_u(rootp, initf, contextpp);
1155 		return;
1156 	}
1157 
1158 	/*
1159 	 * make sure all the backends are supported
1160 	 */
1161 	for (i = 0; i < s->max_src; i++) {
1162 		int	st, srci;
1163 
1164 		if (s->be[i] == NULL)
1165 			continue;
1166 
1167 		srci = (*s->nsw_cfg_p)->src_idx[i];
1168 		st = _nscd_get_smf_state(srci, params.dbi, 1);
1169 		if (st == NSCD_SVC_STATE_UNSUPPORTED_SRC ||
1170 		    (st == NSCD_SVC_STATE_FOREIGN_SRC &&
1171 		    s->be_version_p[i] == NULL && initf == nscd_initf) ||
1172 		    st == NSCD_SVC_STATE_UNINITED ||
1173 		    (params.privdb &&
1174 		    try_local2(params.dbi, srci) == 1)) {
1175 			nss_endent_u(rootp, initf, contextpp);
1176 
1177 			_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE,
1178 			    NSCD_LOG_LEVEL_DEBUG)
1179 			(me, "backend (%s) not available (state = %d)\n",
1180 			    NSCD_NSW_SRC_NAME(srci), st);
1181 
1182 			return;
1183 		}
1184 	}
1185 
1186 	(void) NSS_INVOKE_DBOP(be, NSS_DBOP_SETENT, 0);
1187 }
1188 
1189 nss_status_t
nss_getent_u(nss_db_root_t * rootp,nss_db_initf_t initf,nss_getent_t * contextpp,void * args)1190 nss_getent_u(nss_db_root_t *rootp, nss_db_initf_t initf,
1191 	nss_getent_t *contextpp, void *args)
1192 {
1193 	char			*me = "nss_getent_u";
1194 	nscd_nsw_state_t	*s;
1195 	nscd_getent_context_t	*contextp;
1196 	int			n_src;
1197 	nss_backend_t		*be;
1198 
1199 	_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
1200 	(me, "rootp = %p, initf = %p, contextpp = %p, args = %p\n",
1201 	    rootp, initf, contextpp, args);
1202 
1203 	if ((contextp = (nscd_getent_context_t *)contextpp->ctx) == 0) {
1204 		nss_setent_u(rootp, initf, contextpp);
1205 		if ((contextp = (nscd_getent_context_t *)contextpp->ctx) == 0) {
1206 			/* Give up */
1207 			_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE,
1208 			    NSCD_LOG_LEVEL_ERROR)
1209 			(me, "not able to obtain getent context ... give up\n");
1210 
1211 			return (NSS_UNAVAIL);
1212 		}
1213 	}
1214 
1215 	s	= contextp->nsw_state;
1216 	n_src	= contextp->n_src;
1217 	be	= contextp->be;
1218 
1219 	if (s == 0) {
1220 		/*
1221 		 * We've done an end_iter() and haven't done nss_setent()
1222 		 * or nss_endent() since;  we should stick in this state
1223 		 * until the caller invokes one of those two routines.
1224 		 */
1225 		return (NSS_SUCCESS);
1226 	}
1227 
1228 	while (n_src < s->max_src) {
1229 		nss_status_t		res;
1230 		struct __nsw_lookup_v1	*lkp = NULL;
1231 		int			n;
1232 
1233 		/* get the nsw config for the current source */
1234 		lkp = s->config->lookups;
1235 		for (n = 0; n < n_src; n++)
1236 			lkp = lkp->next;
1237 
1238 		if (be == 0) {
1239 			/* If it's null it's a bug, but let's play safe */
1240 			res = NSS_UNAVAIL;
1241 		} else {
1242 			_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE,
1243 			    NSCD_LOG_LEVEL_DEBUG)
1244 			(me, "database: %s, backend: %s, nsswitch config: %s\n",
1245 			    NSCD_NSW_DB_NAME(s->dbi),
1246 			    lkp->service_name,
1247 			    (*s->nsw_cfg_p)->nsw_cfg_str);
1248 
1249 			res = NSS_INVOKE_DBOP(be, NSS_DBOP_GETENT, args);
1250 		}
1251 
1252 		if (__NSW_ACTION_V1(lkp, res) == __NSW_RETURN) {
1253 			if (res != __NSW_SUCCESS) {
1254 				end_iter_u(rootp,
1255 				    (struct nss_getent_context *)contextp);
1256 			}
1257 			return (res);
1258 		}
1259 		(void) NSS_INVOKE_DBOP(be, NSS_DBOP_ENDENT, 0);
1260 		do {
1261 			n_src++;
1262 		} while (n_src < s->max_src &&
1263 		    (be = s->be[n_src]) == 0);
1264 		if (be == 0) {
1265 			/*
1266 			 * This is the case where we failed to get the backend
1267 			 * for the last source. We exhausted all sources.
1268 			 */
1269 			nss_endent_u(rootp, initf, contextpp);
1270 			return (NSS_NOTFOUND);
1271 		}
1272 		contextp->n_src	= n_src;
1273 		contextp->be	= be;
1274 		(void) NSS_INVOKE_DBOP(be, NSS_DBOP_SETENT, 0);
1275 	}
1276 	/* Got to the end of the sources without finding another entry */
1277 	end_iter_u(rootp, (struct nss_getent_context *)contextp);
1278 	return (NSS_SUCCESS);
1279 	/* success is either a successful entry or end of the sources */
1280 }
1281 
1282 /*ARGSUSED*/
1283 void
nss_endent_u(nss_db_root_t * rootp,nss_db_initf_t initf,nss_getent_t * contextpp)1284 nss_endent_u(nss_db_root_t *rootp, nss_db_initf_t initf,
1285 	nss_getent_t *contextpp)
1286 {
1287 	char			*me = "nss_endent_u";
1288 	nscd_getent_context_t	*contextp;
1289 
1290 	_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
1291 	(me, "rootp = %p, initf = %p, contextpp = %p \n",
1292 	    rootp, initf, contextpp);
1293 
1294 	if ((contextp = (nscd_getent_context_t *)contextpp->ctx) == 0) {
1295 		/* nss_endent() on an unused context is a no-op */
1296 		return;
1297 	}
1298 
1299 	if (_nscd_is_getent_ctx_in_use(contextp) == 0) {
1300 		end_iter_u(rootp, (struct nss_getent_context *)contextp);
1301 		_nscd_put_getent_ctx(contextp);
1302 		contextpp->ctx = NULL;
1303 	}
1304 }
1305 
1306 /*
1307  * _nss_db_state_destr() and nss_delete() do nothing in nscd
1308  * but is needed to make the caller (below nscd) happy
1309  */
1310 /*ARGSUSED*/
1311 void
_nss_db_state_destr(struct nss_db_state * s)1312 _nss_db_state_destr(struct nss_db_state *s)
1313 {
1314 	/* nsw state in nscd is always reused, so do nothing here */
1315 }
1316 
1317 /*ARGSUSED*/
1318 void
nss_delete(nss_db_root_t * rootp)1319 nss_delete(nss_db_root_t *rootp)
1320 {
1321 	/*
1322 	 * the only resource kept tracked by the nss_db_root_t
1323 	 * is the nsw state which is always reused and no need
1324 	 * to be freed. So just return.
1325 	 */
1326 }
1327 
1328 /*
1329  * Start of nss_psearch/nss_psetent()/nss_pgetent()/nss_pendent()
1330  * buffers switch entry points
1331  */
1332 
1333 /*
1334  * nss_psearch opens a packed structure header, assembles a local
1335  * nss_XbyY_args_t structure and calls the local copy of nss_search.
1336  * The return data is assembled in "files native format" in the
1337  * return buffer location.  Status if packed back up with the buffer
1338  * and the whole wad is returned to the cache or the client.
1339  */
1340 
1341 void
nss_psearch(void * buffer,size_t length)1342 nss_psearch(void *buffer, size_t length)
1343 {
1344 	/* inputs */
1345 	nss_db_initf_t		initf;
1346 	int			dbop;
1347 	int			rc;
1348 	nss_XbyY_args_t		arg;
1349 	nss_status_t		status;
1350 	nscd_sw_return_t	swret = { 0 }, *swrp = &swret;
1351 	nss_pheader_t		*pbuf = (nss_pheader_t *)buffer;
1352 	char			*me = "nss_psearch";
1353 
1354 	if (buffer == NULL || length == 0) {
1355 		NSCD_SET_STATUS(pbuf, NSS_ERROR, EFAULT);
1356 		return;
1357 	}
1358 
1359 	status = nss_packed_arg_init(buffer, length,
1360 	    NULL, &initf, &dbop, &arg);
1361 	if (status != NSS_SUCCESS) {
1362 		NSCD_SET_STATUS(pbuf, status, -1);
1363 		return;
1364 	}
1365 
1366 	/*
1367 	 * pass the address of the return data area
1368 	 * for the switch engine to return its own data
1369 	 */
1370 	(void) memcpy(&pbuf->nscdpriv, &swrp, sizeof (swrp));
1371 	swret.pbuf = buffer;
1372 	swret.pbufsiz = length;
1373 	swret.datalen = pbuf->data_len;
1374 
1375 	/*
1376 	 * use the generic nscd_initf for all database lookups
1377 	 * (the TSD key is the pointer to the packed header)
1378 	 */
1379 	rc = set_initf_key(pbuf);
1380 	if (rc != 0) {
1381 		NSCD_SET_STATUS(pbuf, NSS_UNAVAIL, EINVAL);
1382 		return;
1383 	}
1384 	initf = nscd_initf;
1385 
1386 	/* Perform local search and pack results into return buffer */
1387 	/* nscd's search ignores db_root */
1388 	status = nss_search(NULL, initf, dbop, &arg);
1389 
1390 	/*
1391 	 * If status is NSS_NOTFOUND and ldap also returned
1392 	 * NSS_NOTFOUND, it is possible that the user does
1393 	 * not have a credential, so check and see if
1394 	 * needs to return NSS_ALTRETRY to let the main
1395 	 * nscd get a chance to process the lookup
1396 	 */
1397 	if (swret.fallback == 1 && status == NSS_NOTFOUND) {
1398 		OM_uint32	(*func)();
1399 		OM_uint32	stat;
1400 		nscd_rc_t	rc;
1401 
1402 		rc = get_gss_func((void **)&func);
1403 		if (rc == NSCD_SUCCESS) {
1404 			if (func(&stat, GSS_C_NO_CREDENTIAL,
1405 			    NULL, NULL, NULL, NULL) != GSS_S_COMPLETE) {
1406 
1407 				_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE,
1408 				    NSCD_LOG_LEVEL_DEBUG)
1409 			(me, "NSS_ALTRETRY: fallback to main nscd needed\n");
1410 
1411 				status = NSS_ALTRETRY;
1412 			}
1413 		}
1414 	}
1415 
1416 	NSCD_SET_STATUS(pbuf, status, -1);
1417 	errno = swret.errnum;
1418 
1419 	/*
1420 	 * Move result/status from args to packed buffer only if
1421 	 * arg was being used and rc from the switch engine is not
1422 	 * NSS_TRYLOCAL.
1423 	 */
1424 	if (!swret.noarg && status != NSS_TRYLOCAL)
1425 		nss_packed_set_status(buffer, length, status,  &arg);
1426 
1427 	_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
1428 	(me, "switch engine result: source is %s, status %d, "
1429 	"herrno is %d, errno is %s\n",
1430 	    (swret.srci != -1) ? NSCD_NSW_SRC_NAME(swret.srci) : "<NOTSET>",
1431 	    pbuf->p_status, pbuf->p_herrno, strerror(pbuf->p_errno));
1432 
1433 	/* clear the TSD key used by the generic initf */
1434 	clear_initf_key();
1435 	pbuf->nscdpriv = 0;
1436 }
1437 
1438 static void
nscd_map_contextp(void * buffer,nss_getent_t * contextp,nssuint_t ** cookie_num_p,nssuint_t ** seqnum_p,int setent)1439 nscd_map_contextp(void *buffer, nss_getent_t *contextp,
1440     nssuint_t **cookie_num_p, nssuint_t **seqnum_p, int setent)
1441 {
1442 	nss_pheader_t		*pbuf = (nss_pheader_t *)buffer;
1443 	nssuint_t		off;
1444 	nscd_getent_context_t	*ctx;
1445 	char			*me = "nscd_map_contextp";
1446 	nscd_getent_p1_cookie_t	*cookie;
1447 
1448 	if (buffer == NULL) {
1449 		NSCD_SET_STATUS(pbuf, NSS_ERROR, EFAULT);
1450 		return;
1451 	}
1452 
1453 	off = pbuf->key_off;
1454 	cookie = (nscd_getent_p1_cookie_t *)((void *)((char *)buffer + off));
1455 	if (seqnum_p != NULL)
1456 		*seqnum_p = &cookie->p1_seqnum;
1457 
1458 	/*
1459 	 * if called by nss_psetent, and the passed in cookie number
1460 	 * is NSCD_NEW_COOKIE, then there is no cookie yet, return a
1461 	 * pointer pointing to where the cookie number will be stored.
1462 	 * Also because there is no cookie to validate, just return
1463 	 * success.
1464 	 *
1465 	 * On the other hand, if a cookie number is passed in, we need
1466 	 * to validate the cookie number before returning.
1467 	 */
1468 	if (cookie_num_p != NULL)
1469 		*cookie_num_p = &cookie->p1_cookie_num;
1470 	if (setent == 1 && cookie->p1_cookie_num == NSCD_NEW_COOKIE) {
1471 		NSCD_SET_STATUS_SUCCESS(pbuf);
1472 		return;
1473 	}
1474 
1475 	/*
1476 	 * If the sequence number and start time match nscd's p0 cookie,
1477 	 * then either setent was done twice in a row or this is the
1478 	 * first getent after the setent, return success as well.
1479 	 */
1480 	if (cookie->p1_seqnum == NSCD_P0_COOKIE_SEQNUM) {
1481 		nscd_getent_p0_cookie_t *p0c =
1482 		    (nscd_getent_p0_cookie_t *)cookie;
1483 		if (p0c->p0_time == _nscd_get_start_time()) {
1484 			NSCD_SET_STATUS_SUCCESS(pbuf);
1485 			return;
1486 		}
1487 	}
1488 
1489 	_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
1490 	(me, "cookie # = %lld,  sequence # = %lld\n",
1491 	    cookie->p1_cookie_num, cookie->p1_seqnum);
1492 
1493 	ctx = _nscd_is_getent_ctx(cookie->p1_cookie_num);
1494 
1495 	if (ctx == NULL) {
1496 		_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
1497 		(me, "No matching context found (cookie number: %lld)\n",
1498 		    cookie->p1_cookie_num);
1499 
1500 		NSCD_SET_STATUS(pbuf, NSS_ERROR, EFAULT);
1501 		return;
1502 	}
1503 
1504 	/* if not called by nss_psetent, verify sequence number */
1505 	if (setent != 1 && ctx->seq_num !=
1506 	    (nscd_seq_num_t)cookie->p1_seqnum) {
1507 		_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
1508 		(me, "invalid sequence # (%lld)\n", cookie->p1_seqnum);
1509 
1510 		_nscd_free_ctx_if_aborted(ctx);
1511 		NSCD_SET_STATUS(pbuf, NSS_ERROR, EFAULT);
1512 		return;
1513 	}
1514 
1515 	contextp->ctx = (struct nss_getent_context *)ctx;
1516 
1517 	NSCD_SET_STATUS_SUCCESS(pbuf);
1518 }
1519 
1520 void
nss_psetent(void * buffer,size_t length,pid_t pid)1521 nss_psetent(void *buffer, size_t length, pid_t pid)
1522 {
1523 	nss_getent_t		context = { 0 };
1524 	nss_getent_t		*contextp = &context;
1525 	nssuint_t		*cookie_num_p;
1526 	nssuint_t		*seqnum_p;
1527 	nss_pheader_t		*pbuf = (nss_pheader_t *)buffer;
1528 	nscd_getent_p0_cookie_t *p0c;
1529 	char			*me = "nss_psetent";
1530 
1531 	if (buffer == NULL || length == 0) {
1532 		NSCD_SET_STATUS(pbuf, NSS_ERROR, EFAULT);
1533 		return;
1534 	}
1535 
1536 	/*
1537 	 * If this is a per-user nscd, and the user does not have
1538 	 * the necessary credential, return NSS_TRYLOCAL, so the
1539 	 * setent/getent can be done locally in the process of the
1540 	 * setent call
1541 	 */
1542 	if (_whoami == NSCD_CHILD) {
1543 		OM_uint32	(*func)();
1544 		OM_uint32	stat;
1545 		nscd_rc_t	rc;
1546 
1547 		rc = get_gss_func((void **)&func);
1548 		if (rc == NSCD_SUCCESS) {
1549 			if (func(&stat, GSS_C_NO_CREDENTIAL,
1550 			    NULL, NULL, NULL, NULL) != GSS_S_COMPLETE) {
1551 
1552 				_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE,
1553 				    NSCD_LOG_LEVEL_DEBUG)
1554 			(me, "NSS_TRYLOCAL: fallback to caller process\n");
1555 				NSCD_SET_STATUS(pbuf, NSS_TRYLOCAL, 0);
1556 				return;
1557 			}
1558 		}
1559 	}
1560 
1561 	/* check cookie number */
1562 	nscd_map_contextp(buffer, contextp, &cookie_num_p, &seqnum_p, 1);
1563 	if (NSCD_STATUS_IS_NOT_OK(pbuf))
1564 		return;
1565 
1566 	/* set cookie number and sequence number */
1567 	p0c = (nscd_getent_p0_cookie_t *)cookie_num_p;
1568 	if (contextp->ctx ==  NULL) {
1569 		/*
1570 		 * first setent (no existing getent context),
1571 		 * return a p0 cookie
1572 		 */
1573 		_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
1574 		(me, "first setent, no getent context yet\n");
1575 	} else {
1576 		/*
1577 		 * doing setent on an existing getent context,
1578 		 * release resources allocated and return a
1579 		 * p0 cookie
1580 		 */
1581 		_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
1582 		(me, "setent resetting sequence number = %lld\n",  *seqnum_p);
1583 
1584 		if (_nscd_is_getent_ctx_in_use((nscd_getent_context_t *)
1585 		    contextp->ctx) == 0) {
1586 			/*
1587 			 * context not in use, release the backend and
1588 			 * return the context to the pool
1589 			 */
1590 			end_iter_u(NULL, contextp->ctx);
1591 			_nscd_put_getent_ctx(
1592 			    (nscd_getent_context_t *)contextp->ctx);
1593 			contextp->ctx = NULL;
1594 		}
1595 	}
1596 
1597 	p0c->p0_pid = pid;
1598 	p0c->p0_time = _nscd_get_start_time();
1599 	p0c->p0_seqnum = NSCD_P0_COOKIE_SEQNUM;
1600 	_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
1601 	(me, "returning a p0 cookie: pid = %ld, time = %ld, seq #= %llx\n",
1602 	    p0c->p0_pid, p0c->p0_time, p0c->p0_seqnum);
1603 
1604 	NSCD_SET_STATUS(pbuf, NSS_SUCCESS, 0);
1605 }
1606 
1607 static void
delayed_setent(nss_pheader_t * pbuf,nss_db_initf_t initf,nss_getent_t * contextp,nssuint_t * cookie_num_p,nssuint_t * seqnum_p,pid_t pid)1608 delayed_setent(nss_pheader_t *pbuf, nss_db_initf_t initf,
1609 	nss_getent_t *contextp, nssuint_t *cookie_num_p,
1610 	nssuint_t *seqnum_p, pid_t pid)
1611 {
1612 	nscd_getent_context_t	*ctx;
1613 	nscd_sw_return_t	swret = { 0 }, *swrp = &swret;
1614 	char			*me = "delayed_setent";
1615 
1616 	/*
1617 	 * check credential
1618 	 */
1619 	_nscd_APP_check_cred(pbuf, &pid, "NSCD_DELAYED_SETENT",
1620 	    NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_ERROR);
1621 	if (NSCD_STATUS_IS_NOT_OK(pbuf)) {
1622 		_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
1623 		(me, "invalid credential\n");
1624 		return;
1625 	}
1626 
1627 	/*
1628 	 * pass the packed header buffer pointer to nss_setent
1629 	 */
1630 	(void) memcpy(&pbuf->nscdpriv, &swrp, sizeof (swrp));
1631 	swret.pbuf = pbuf;
1632 
1633 	/* Perform local setent and set context */
1634 	nss_setent(NULL, initf, contextp);
1635 
1636 	/* insert cookie info into packed buffer header */
1637 	ctx = (nscd_getent_context_t *)contextp->ctx;
1638 	if (ctx != NULL) {
1639 		*cookie_num_p = ctx->cookie_num;
1640 		*seqnum_p = ctx->seq_num;
1641 		ctx->pid = pid;
1642 	} else {
1643 		/*
1644 		 * not able to allocate a getent context, the
1645 		 * client should try the enumeration locally
1646 		 */
1647 		*cookie_num_p = NSCD_LOCAL_COOKIE;
1648 		*seqnum_p = 0;
1649 
1650 		_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
1651 		(me, "NSS_TRYLOCAL: cookie # = %lld,  sequence # = %lld\n",
1652 		    *cookie_num_p, *seqnum_p);
1653 		NSCD_SET_STATUS(pbuf, NSS_TRYLOCAL, 0);
1654 		return;
1655 	}
1656 
1657 	_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
1658 	(me, "NSS_SUCCESS: cookie # = %lld,  sequence # = %lld\n",
1659 	    ctx->cookie_num, ctx->seq_num);
1660 
1661 	NSCD_SET_STATUS(pbuf, NSS_SUCCESS, 0);
1662 }
1663 
1664 void
nss_pgetent(void * buffer,size_t length)1665 nss_pgetent(void *buffer, size_t length)
1666 {
1667 	/* inputs */
1668 	nss_db_initf_t		initf;
1669 	nss_getent_t		context = { 0 };
1670 	nss_getent_t		*contextp = &context;
1671 	nss_XbyY_args_t		arg = { 0};
1672 	nss_status_t		status;
1673 	nssuint_t		*cookie_num_p;
1674 	nssuint_t		*seqnum_p;
1675 	nscd_getent_context_t	*ctx;
1676 	int			rc;
1677 	nss_pheader_t		*pbuf = (nss_pheader_t *)buffer;
1678 	char			*me = "nss_pgetent";
1679 
1680 	if (buffer == NULL || length == 0) {
1681 		NSCD_SET_STATUS(pbuf, NSS_ERROR, EFAULT);
1682 		return;
1683 	}
1684 
1685 	/* verify the cookie passed in */
1686 	nscd_map_contextp(buffer, contextp, &cookie_num_p, &seqnum_p, 0);
1687 	if (NSCD_STATUS_IS_NOT_OK(pbuf))
1688 		return;
1689 
1690 	/*
1691 	 * use the generic nscd_initf for all the getent requests
1692 	 * (the TSD key is the pointer to the packed header)
1693 	 */
1694 	rc = set_initf_key(pbuf);
1695 	if (rc != 0) {
1696 		NSCD_SET_STATUS(pbuf, NSS_UNAVAIL, EINVAL);
1697 		return;
1698 	}
1699 	initf = nscd_initf;
1700 
1701 	/* if no context yet, get one */
1702 	if (contextp->ctx ==  NULL) {
1703 		nscd_getent_p0_cookie_t *p0c =
1704 		    (nscd_getent_p0_cookie_t *)cookie_num_p;
1705 
1706 		delayed_setent(pbuf, initf, contextp, cookie_num_p,
1707 		    seqnum_p, p0c->p0_pid);
1708 		if (NSCD_STATUS_IS_NOT_OK(pbuf)) {
1709 			clear_initf_key();
1710 			return;
1711 		}
1712 	}
1713 
1714 	status = nss_packed_context_init(buffer, length,
1715 	    NULL, &initf, &contextp, &arg);
1716 	if (status != NSS_SUCCESS) {
1717 		clear_initf_key();
1718 		_nscd_free_ctx_if_aborted(
1719 		    (nscd_getent_context_t *)contextp->ctx);
1720 		NSCD_SET_STATUS(pbuf, status, -1);
1721 		return;
1722 	}
1723 
1724 	/* Perform local search and pack results into return buffer */
1725 	status = nss_getent(NULL, initf, contextp, &arg);
1726 	NSCD_SET_STATUS(pbuf, status, -1);
1727 	nss_packed_set_status(buffer, length, status,  &arg);
1728 
1729 	/* increment sequence number in the buffer and nscd context */
1730 	if (status == NSS_SUCCESS) {
1731 		ctx = (nscd_getent_context_t *)contextp->ctx;
1732 		ctx->seq_num++;
1733 		*seqnum_p = ctx->seq_num;
1734 		*cookie_num_p = ctx->cookie_num;
1735 
1736 		_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
1737 		(me, "getent OK, new sequence # = %lld, len = %lld,"
1738 		    " data = >>%s<<\n", *seqnum_p,
1739 		    pbuf->data_len, (char *)buffer + pbuf->data_off);
1740 
1741 		_nscd_free_ctx_if_aborted(ctx);
1742 	} else {
1743 		/* release the resources used */
1744 		ctx = (nscd_getent_context_t *)contextp->ctx;
1745 		if (ctx != NULL && _nscd_is_getent_ctx_in_use(ctx) == 0) {
1746 			_nscd_put_getent_ctx(ctx);
1747 			contextp->ctx = NULL;
1748 		}
1749 		_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
1750 		(me, "getent failed, status = %d, sequence # = %lld\n",
1751 		    status, *seqnum_p);
1752 	}
1753 
1754 	/* clear the TSD key used by the generic initf */
1755 	clear_initf_key();
1756 }
1757 
1758 void
nss_pendent(void * buffer,size_t length)1759 nss_pendent(void *buffer, size_t length)
1760 {
1761 	nss_getent_t		context = { 0 };
1762 	nss_getent_t		*contextp = &context;
1763 	nssuint_t		*seqnum_p;
1764 	nssuint_t		*cookie_num_p;
1765 	nss_pheader_t		*pbuf = (nss_pheader_t *)buffer;
1766 	char			*me = "nss_pendent";
1767 
1768 	if (buffer == NULL || length == 0) {
1769 		NSCD_SET_STATUS(pbuf, NSS_ERROR, EFAULT);
1770 		return;
1771 	}
1772 
1773 	/* map the contextp from the cookie information */
1774 	nscd_map_contextp(buffer, contextp, &cookie_num_p, &seqnum_p, 0);
1775 	if (NSCD_STATUS_IS_NOT_OK(pbuf))
1776 		return;
1777 
1778 	if (contextp->ctx == NULL)
1779 		return;
1780 
1781 	_NSCD_LOG(NSCD_LOG_SWITCH_ENGINE, NSCD_LOG_LEVEL_DEBUG)
1782 	(me, "endent, cookie = %lld, sequence # = %lld\n",
1783 	    *cookie_num_p, *seqnum_p);
1784 
1785 	/* Perform local endent and reset context */
1786 	nss_endent(NULL, NULL, contextp);
1787 
1788 	NSCD_SET_STATUS(pbuf, NSS_SUCCESS, 0);
1789 }
1790 
1791 /*ARGSUSED*/
1792 void
nss_pdelete(void * buffer,size_t length)1793 nss_pdelete(void *buffer, size_t length)
1794 {
1795 	nss_pheader_t	*pbuf = (nss_pheader_t *)buffer;
1796 
1797 	/* unnecessary, kept for completeness */
1798 	NSCD_SET_STATUS_SUCCESS(pbuf);
1799 }
1800