xref: /titanic_50/usr/src/lib/libnisdb/yptol/shim.c (revision f841f6ad96ea6675d6c6b35c749eaac601799fdf)
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  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #pragma ident	"%Z%%M%	%I%	%E% SMI"
27 
28 /*
29  * DESCRIPTION: Contains the top level shim hook functions. These must have
30  *		identical interfaces to the equivalent standard dbm calls.
31  *
32  *		Unfortunately many of these will do a copy of a datum structure
33  *		on return. This is a side effect of the original DBM function
34  *		being written to pass structures rather than pointers.
35  *
36  * NOTE :	There is a major bug/feature in dbm. A key obtained by
37  *		dbm_nextkey() of dbm_firstkey() cannot be passed to dbm_store().
38  *		When the store occurs dbm's internal memory get's reorganized
39  *		and the static strings pointed to by the key are destroyed. The
40  *		data is then stored in the wrong place. We attempt to get round
41  *		this by dbm_firstkey() and dbm_nextkey() making a copy of the
42  *		key data in malloced memory. This is freed when map_ctrl is
43  *		freed.
44  */
45 
46 #include <unistd.h>
47 #include <syslog.h>
48 #include <ndbm.h>
49 #include <strings.h>
50 #include "ypsym.h"
51 #include "ypdefs.h"
52 #include "shim.h"
53 #include "yptol.h"
54 #include "../ldap_parse.h"
55 #include "../ldap_util.h"
56 
57 /*
58  * Globals
59  */
60 bool_t yptol_mode = FALSE;	/* Set if in N2L mode */
61 bool_t yptol_newlock = FALSE;
62 				/*
63 				 * Set if in N2L mode and we want to use the new
64 				 * lock mapping mechanism
65 				 */
66 bool_t ypxfrd_flag = FALSE;	/* Set if called from ypxfrd */
67 pid_t parent_pid;			/* ID of calling parent process */
68 
69 
70 /*
71  * Decs
72  */
73 void check_old_map_date(map_ctrl *);
74 
75 /*
76  * Constants
77  */
78 /* Number of times to try to update a map before giving up */
79 /* #define MAX_UPDATE_ATTEMPTS 3 */
80 #define	MAX_UPDATE_ATTEMPTS 1
81 
82 /*
83  * FUNCTION:    shim_dbm_close();
84  *
85  * INPUTS:      Identical to equivalent dbm call.
86  *
87  * OUTPUTS:     Identical to equivalent dbm call.
88  *
89  */
90 void
91 shim_dbm_close(DBM *db)
92 {
93 	map_ctrl *map;
94 
95 	/* Lock the map */
96 	map = get_map_ctrl(db);
97 	if (map == NULL)
98 		return;
99 
100 	free_map_ctrl(map);
101 }
102 
103 /*
104  * FUNCTION:    shim_dbm_delete();
105  *
106  * DESCRIPTION:	This function is currently unused but is present so that the
107  *		set of shim_dbm_xxx() interfaces is complete if required in
108  *		future.
109  *
110  * INPUTS:      Identical to equivalent dbm call.
111  *
112  * OUTPUTS:     Identical to equivalent dbm call.
113  *
114  */
115 int
116 shim_dbm_delete(DBM *db, datum key)
117 {
118 	int ret;
119 	map_ctrl *map;
120 
121 	/* Lock the map */
122 	map = get_map_ctrl(db);
123 	if (map == NULL)
124 		return (FAILURE);
125 	if (1 != lock_map_ctrl(map))
126 		return (FAILURE);
127 
128 	if (yptol_mode) {
129 		/* Delete from and ttl map. Not a huge disaster if it fails. */
130 		dbm_delete(map->ttl, key);
131 	}
132 
133 	ret = dbm_delete(map->entries, key);
134 
135 	unlock_map_ctrl(map);
136 
137 	return (ret);
138 }
139 
140 
141 /*
142  * FUNCTION:    shim_dbm_fetch()
143  *
144  * DESCRIPTION:	N2L function used to handle 'normal' dbm_fetch() operations.
145  *
146  * INPUTS:      First two identical to equivalent dbm call.
147  *
148  * OUTPUTS:     Identical to equivalent dbm call.
149  *
150  */
151 datum
152 shim_dbm_fetch(DBM *db, datum key)
153 {
154 	datum ret = {0, NULL};
155 	map_ctrl *map;
156 
157 	/* Lock the map */
158 	map = get_map_ctrl(db);
159 	if (map == NULL)
160 		return (ret);
161 	if (1 != lock_map_ctrl(map))
162 		return (ret);
163 
164 	if (yptol_mode) {
165 		if (SUCCESS == update_entry_if_required(map, &key)) {
166 			/* Update thinks we should return something */
167 			ret = dbm_fetch(map->entries, key);
168 		}
169 	} else {
170 		/* Non yptol mode do a normal fetch */
171 		ret = dbm_fetch(map->entries, key);
172 	}
173 
174 	unlock_map_ctrl(map);
175 
176 	return (ret);
177 }
178 
179 /*
180  * FUNCTION:    shim_dbm_fetch_noupdate()
181  *
182  * DESCRIPTION:	A special version of shim_dbm_fetch() that never checks TTLs
183  *		or updates entries.
184  *
185  * INPUTS:      Identical to equivalent dbm call.
186  *
187  * OUTPUTS:     Identical to equivalent dbm call.
188  *
189  */
190 datum
191 shim_dbm_fetch_noupdate(DBM *db, datum key)
192 {
193 	datum ret = {0, NULL};
194 	map_ctrl *map;
195 
196 	/* Get the map control block */
197 	map = get_map_ctrl(db);
198 	if (map == NULL)
199 		return (ret);
200 
201 	/* Not updating so no need to lock */
202 	ret = dbm_fetch(map->entries, key);
203 
204 	return (ret);
205 }
206 
207 /*
208  * FUNCTION:    shim_dbm_firstkey()
209  *
210  * DESCRIPTION: Get firstkey in an enumeration. If the map is out of date then
211  *	      this is the time to scan it and see if any new entries have been
212  *	      created.
213  *
214  * INPUTS:      Identical to equivalent dbm call.
215  *
216  * OUTPUTS:     Identical to equivalent dbm call.
217  *
218  */
219 datum
220 shim_dbm_firstkey(DBM *db)
221 {
222 	int count;
223 	bool_t wait_flag;
224 
225 	datum ret = {0, NULL};
226 	map_ctrl *map;
227 
228 	/* Lock the map */
229 	map = get_map_ctrl(db);
230 	if (map == NULL)
231 		return (ret);
232 	if (1 != lock_map_ctrl(map))
233 		return (ret);
234 
235 	if (yptol_mode) {
236 		/*
237 		 * Due to the limitations in the hashing algorithm ypxfrd
238 		 * may end up waiting on the wrong update. It must thus loop
239 		 * until the right map has been updated.
240 		 */
241 		for (count = 0; has_map_expired(map) &&
242 				(MAX_UPDATE_ATTEMPTS > count); count++) {
243 			/*
244 			 * Ideally ypxfr should wait for the map update
245 			 * to complete i.e. pass ypxfrd_flag into
246 			 * update_map_if_required(). This cannot be done
247 			 * because if there is a large map update the client
248 			 * side, ypxfr, can time out while waiting.
249 			 */
250 			wait_flag = FALSE;
251 			update_map_if_required(map, wait_flag);
252 
253 			if (wait_flag) {
254 				/*
255 				 * Because ypxfrd does weird things with DBMs
256 				 * internal structures it's a good idea to
257 				 * reopen here. (Code that uses the real DBM
258 				 * API appears not to need this.)
259 				 *
260 				 * This should not be necessary all we have
261 				 * done is 'mv' the new file over the old one.
262 				 * Open handles should get the old data but if
263 				 * these lines are removed the first ypxfrd
264 				 * read access fail with bad file handle.
265 				 *
266 				 * NOTE : If we don't wait, because of the
267 				 * ypxfr timeout problem, there is no point
268 				 * doing this.
269 				 */
270 				dbm_close(map->entries);
271 				dbm_close(map->ttl);
272 				if (FAILURE == open_yptol_files(map)) {
273 					logmsg(MSG_NOTIMECHECK, LOG_ERR,
274 						"Could not reopen DBM files");
275 				}
276 			} else {
277 				/* For daemons that don't wait just try once */
278 				break;
279 			}
280 		}
281 
282 		if (MAX_UPDATE_ATTEMPTS < count)
283 			logmsg(MSG_NOTIMECHECK, LOG_ERR,
284 					"Cannot update map %s", map->map_name);
285 	}
286 
287 	ret = dbm_firstkey(map->entries);
288 
289 	/* Move key data out of static memory. See NOTE in file header above */
290 	if (yptol_mode) {
291 		set_key_data(map, &ret);
292 	}
293 	unlock_map_ctrl(map);
294 
295 	return (ret);
296 }
297 
298 /*
299  * FUNCTION:    shim_dbm_nextkey()
300  *
301  * DESCRIPTION: Get next key in an enumeration. Since updating an entry would
302  *	      invalidate the enumeration we never do it.
303  *
304  * INPUTS:      Identical to equivalent dbm call.
305  *
306  * OUTPUTS:     Identical to equivalent dbm call.
307  *
308  */
309 datum
310 shim_dbm_nextkey(DBM *db)
311 {
312 	datum ret;
313 	map_ctrl *map;
314 
315 	/* Lock the map */
316 	map = get_map_ctrl(db);
317 	if (map == NULL)
318 		return (ret);
319 	if (1 != lock_map_ctrl(map))
320 		return (ret);
321 
322 	ret = dbm_nextkey(map->entries);
323 
324 	/* Move key data out of static memory. See NOTE in file header above */
325 	if (yptol_mode) {
326 		set_key_data(map, &ret);
327 	}
328 
329 	unlock_map_ctrl(map);
330 
331 	return (ret);
332 }
333 
334 /*
335  * FUNCTION:    shim_dbm_do_nextkey()
336  *
337  * DESCRIPTION: Get next key in an enumeration. Since updating an entry would
338  *	      invalidate the enumeration we never do it.
339  *
340  * NOTE :	dbm_do_nextkey is not a documented or legal DBM API.
341  *		Despite this the existing NIS code calls it. One gross hack
342  *		deserves another so we have this extra shim function to handle
343  *		the illegal call.
344  *
345  * INPUTS:      Identical to equivalent dbm call.
346  *
347  * OUTPUTS:     Identical to equivalent dbm call.
348  *
349  */
350 datum
351 shim_dbm_do_nextkey(DBM *db, datum inkey)
352 {
353 	datum ret;
354 	map_ctrl *map;
355 
356 	/* Lock the map */
357 	map = get_map_ctrl(db);
358 	if (map == NULL)
359 		return (ret);
360 	if (1 != lock_map_ctrl(map))
361 		return (ret);
362 
363 	ret = dbm_do_nextkey(map->entries, inkey);
364 
365 	/* Move key data out of static memory. See NOTE in file header above */
366 	if (yptol_mode) {
367 		set_key_data(map, &ret);
368 	}
369 
370 	unlock_map_ctrl(map);
371 
372 	return (ret);
373 }
374 /*
375  * FUNCTION:    shim_dbm_open()
376  *
377  * INPUTS:      Identical to equivalent dbm call.
378  *
379  * OUTPUTS:     Identical to equivalent dbm call.
380  *
381  */
382 DBM *
383 shim_dbm_open(const char *file, int open_flags, mode_t file_mode)
384 {
385 	map_ctrl *map;
386 	suc_code ret = FAILURE;
387 
388 	/* Find or create map_ctrl for this map */
389 	map = create_map_ctrl((char *)file);
390 
391 	if (map == NULL)
392 		return (NULL);
393 
394 	/* Lock map */
395 	if (1 != lock_map_ctrl(map))
396 		return (NULL);
397 
398 	/* Remember flags and mode in case we have to reopen */
399 	map->open_flags = open_flags;
400 	map->open_mode = file_mode;
401 
402 	if (yptol_mode) {
403 		ret = open_yptol_files(map);
404 
405 		/*
406 		 * This is a good place to check that the
407 		 * equivalent old style map file has not been
408 		 * updated.
409 		 */
410 		if (SUCCESS == ret)
411 			check_old_map_date(map);
412 
413 	} else {
414 		/* Open entries map */
415 		map->entries = dbm_open(map->map_path, map->open_flags,
416 								map->open_mode);
417 
418 		if (NULL != map->entries)
419 			ret = SUCCESS;
420 	}
421 
422 	/* If we were not successful unravel what we have done so far */
423 	if (ret != SUCCESS) {
424 		unlock_map_ctrl(map);
425 		free_map_ctrl(map);
426 		return (NULL);
427 	}
428 
429 	unlock_map_ctrl(map);
430 
431 	/* Return map_ctrl pointer as a DBM *. To the outside world it is */
432 	/* opaque. */
433 	return ((DBM *)map);
434 }
435 
436 /*
437  * FUNCTION: 	shim_dbm_store()
438  *
439  * DESCRIPTION:	Shim for dbm_store.
440  *
441  *		In N2L mode if we are asked to store in DBM_INSERT mode
442  *		then first an attempt is made to write to the DIT (in the same
443  *		mode). If this is successful then the value is forced into DBM
444  *		using DBM_REPLACE. This is because the DIT is authoritative.
445  *		The success of failure of an 'insert' is determined by the
446  *		presence or otherwise of an entry in the DIT not DBM.
447  *
448  * INPUTS:	Identical to equivalent dbm call.
449  *
450  * OUTPUTS:	Identical to equivalent dbm call.
451  *
452  */
453 int
454 shim_dbm_store(DBM  *db,  datum  key,  datum  content, int store_mode)
455 {
456 	int ret;
457 	map_ctrl *map;
458 
459 	/* Get map name */
460 	map = get_map_ctrl(db);
461 	if (map == NULL)
462 		return (FAILURE);
463 
464 	if (yptol_mode) {
465 		/* Write to the DIT before doing anything else */
466 		if (!write_to_dit(map->map_name, map->domain, key, content,
467 					DBM_REPLACE == store_mode, FALSE))
468 			return (FAILURE);
469 	}
470 
471 	/* Lock the map */
472 	if (1 != lock_map_ctrl(map))
473 		return (FAILURE);
474 
475 	if (yptol_mode) {
476 		if (!is_map_updating(map)) {
477 			ret = dbm_store(map->entries, key, content,
478 								DBM_REPLACE);
479 
480 			if (SUCCESS == ret)
481 				/* Update TTL */
482 				update_entry_ttl(map, &key, TTL_RAND);
483 		}
484 	} else {
485 		ret = dbm_store(map->entries, key, content, store_mode);
486 	}
487 
488 	unlock_map_ctrl(map);
489 
490 	return (ret);
491 }
492 
493 /*
494  * FUNCTION :	shim_exit()
495  *
496  * DESCRIPTION:	Intercepts exit() calls made by N2L compatible NIS components.
497  *		This is required because any call to the shim_dbm... series
498  *		of functions may have started an update thread. If the process
499  *		exits normally then this thread may be killed before it can
500  *		complete its work. We thus wait here for the thread to complete.
501  *
502  * GIVEN :	Same arg as exit()
503  *
504  * RETURNS :	Never
505  */
506 void
507 shim_exit(int code)
508 {
509 	thr_join(NULL, NULL, NULL);
510 	exit(code);
511 }
512 
513 /*
514  * FUNCTION :	init_yptol_flag()
515  *
516  * DESCRIPTION: Initializes two flags these are similar but their function is
517  *		subtly different.
518  *
519  *		yp2ldap tells the mapping system if it is to work in NIS or
520  *		NIS+ mode. For N2L this is always set to NIS mode.
521  *
522  *		yptol tells the shim if it is to work in N2L or traditional
523  *		NIS mode. For N2L this is turned on if the N2L mapping file
524  *		is found to be present. In NIS+ mode it is meaningless.
525  */
526 void
527 init_yptol_flag()
528 {
529 	/*
530 	 * yp2ldap is used to switch appropriate code in the
531 	 * common libnisdb library used by rpc.nisd and ypserv.
532 	 */
533 	yp2ldap = 1;
534 	yptol_mode = is_yptol_mode();
535 	/*
536 	 * Use the new lock mapping mechanism
537 	 * if in N2L mode.
538 	 */
539 	yptol_newlock = yptol_mode;
540 }
541 
542 /*
543  * FUNCTION :	set_yxfrd_flag()
544  */
545 void
546 set_ypxfrd_flag()
547 {
548 	ypxfrd_flag = TRUE;
549 }
550 
551 /*
552  * FUNCTION :	check_old_map_date()
553  *
554  * DESCRIPTION:	Checks that an old style map has not been updated. If it has
555  *		then ypmake has probably erroneously been run and an error is
556  *		logged.
557  *
558  * GIVEN :	A map_ctrl containing details of the NEW STYLE map.
559  *
560  * RETURNS :	Nothing
561  */
562 void
563 check_old_map_date(map_ctrl *map)
564 {
565 	datum key;
566 	datum value;
567 	struct stat stats;
568 	time_t old_time;
569 
570 	/* Get date of last update */
571 	if (0 != stat(map->trad_map_path, &stats)) {
572 		/*
573 		 * No problem. We have a new style map but no old style map
574 		 * this will occur if the original data came from native LDAP
575 		 * instead of NIS.
576 		 */
577 		return;
578 	}
579 
580 	/* Set up datum with key for recorded old map update time */
581 	key.dsize = strlen(MAP_OLD_MAP_DATE_KEY);
582 	key.dptr = MAP_OLD_MAP_DATE_KEY;
583 	value = dbm_fetch(map->ttl, key);
584 
585 	if (NULL != value.dptr) {
586 		/*
587 		 * Because dptr may not be int aligned need to build an int
588 		 * out of what it points to or will get a bus error.
589 		 */
590 		bcopy(value.dptr, &old_time, sizeof (time_t));
591 
592 
593 		/* Do the comparison */
594 		if (stats.st_mtime <= old_time) {
595 			/* All is well, has not been updated */
596 			return;
597 		}
598 
599 		/* If we get here the file has been updated */
600 		logmsg(MSG_NOTIMECHECK, LOG_ERR,
601 			"Caution. ypmake may have been run in N2L "
602 			"mode. This will NOT initiate a NIS map push. In "
603 			"this mode pushes should be initiated with yppush");
604 	}
605 
606 	/*
607 	 * If we get here then either the file was updated or there was not
608 	 * a valid old map date (no problem, maybe this is the first time we
609 	 * checked). In either case the old map date entry must be update.
610 	 */
611 	value.dptr = (char *)&(stats.st_mtime);
612 	value.dsize = sizeof (time_t);
613 	dbm_store(map->ttl, key, value, DBM_REPLACE);
614 }
615 
616 /*
617  * FUNCTION :	init_lock_system()
618  *
619  * DESCRIPTION:	Initializes all the systems related to map locking. This must
620  *		be called before any access to the shim functions.
621  *
622  * GIVEN :	A flag indicating if we are being called from ypserv, which does
623  *		not wait for map updates to complete, or other NIS components
624  *		which do.
625  *
626  * RETURNS :	TRUE = Everything worked
627  *		FALSE = There were problems
628  */
629 bool_t
630 init_lock_system(bool_t ypxfrd)
631 {
632 	/* Remember what called us */
633 	if (ypxfrd)
634 		set_ypxfrd_flag();
635 
636 	/*
637 	 * Remember PID of process which called us. This enables update threads
638 	 * created by YP children to be handled differently to those created
639 	 * by YP parents.
640 	 */
641 	parent_pid = getpid();
642 
643 	/* Init map locks */
644 	if (!init_lock_map()) {
645 		logmsg(MSG_NOTIMECHECK, LOG_ERR,
646 				"Failed to init process synchronization");
647 		return (FALSE);
648 	}
649 
650 	/* If we are in yptol mode set flag indicating the fact */
651 	init_yptol_flag();
652 
653 	/*
654 	 * If boot random number system. For now go for reproducible
655 	 * random numbers.
656 	 */
657 	srand48(0x12345678);
658 
659 	/*
660 	 * If not N2L mode then no error but do not bother initializing update
661 	 * flags.
662 	 */
663 	if (yptol_mode) {
664 		if (!init_update_lock_map()) {
665 			logmsg(MSG_NOTIMECHECK, LOG_ERR,
666 				"Failed to init update synchronization");
667 			return (FALSE);
668 		}
669 	}
670 
671 	return (TRUE);
672 }
673