/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2015 Gary Mills * Copyright 2003 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* * DESCRIPTION: Contains the map update thread and related code. */ #include <unistd.h> #include <syslog.h> #include <ndbm.h> #include <thread.h> #include <unistd.h> #include <strings.h> #include "ypsym.h" #include "ypdefs.h" #include "shim.h" #include "yptol.h" #include "../ldap_util.h" /* Enable standard YP code features defined in ypdefs.h */ USE_YP_PREFIX USE_YP_MASTER_NAME USE_YP_LAST_MODIFIED USE_YP_INPUT_FILE USE_YP_OUTPUT_NAME USE_YP_DOMAIN_NAME USE_YP_SECURE USE_YP_INTERDOMAIN /* * Decs */ suc_code update_from_dit(map_ctrl *, datum *); void * update_thread(void *); /* * Globals */ extern pid_t parent_pid; /* * FUNCTION: update_entry_if_required() * * DESCRIPTION: Determines if an entry is to be updated and if it is does the * update. * * GIVEN : Pointer to the open map ctrl * Pointer to the entry key * * RETURNS : SUCCESS = Entry is in a state to be returned to the client * i.e. either got updated, did not need to be updated or we are * in a mode where it is acceptable to return out of date * information. * FAILURE = Entry need an update but it could not be done. */ suc_code update_entry_if_required(map_ctrl *map, datum *key) { /* Only update individual entries if entire map is */ /* not being updated */ if (is_map_updating(map)) return (SUCCESS); /* * If we are being asked for the order then need to check if * the map is in need of an update. If it is then fake a * recent order. The client will then read the map, using * dbm_firstkey and this will do the update. */ if (0 == strncmp(key->dptr, yp_last_modified, yp_last_modified_sz)) { if (has_map_expired(map)) update_timestamp(map->entries); return (SUCCESS); } /* Never update special keys. Have no TTLs */ if (is_special_key(key)) return (SUCCESS); if (!has_entry_expired(map, key)) /* Didn't need an update */ return (SUCCESS); /* Do the update */ return (update_from_dit(map, key)); } /* * FUNCTION: update_from_dit() * * DESCRIPTION: Called to update an entry from the DIT * * INPUTS: Map control structure for an open map * Entry key * * OUTPUTS: SUCCESS = Update complete or we are in a mode where it is * acceptable to return out of date information. * FAILURE = Update failed * */ suc_code update_from_dit(map_ctrl *map, datum *key) { datum dat; int ret; suc_code res; /* * Netgroup maps are a special case we cannot update just one entry so * update the entire map instead. */ if ((0 == strcmp(map->map_name, NETGROUP_BYHOST)) || (0 == strcmp(map->map_name, NETGROUP_BYUSER))) { return (update_map_if_required(map, FALSE)); } /* Read entry from the DIT */ ret = read_from_dit(map->map_name, map->domain, key, &dat); /* Check that we got something */ if (NULL == dat.dptr) { if (0 == ret) { /* * In a mode where it is acceptable to return out of * date information. */ logmsg(MSG_NOTIMECHECK, LOG_INFO, "LDAP inaccessible returning old information"); return (SUCCESS); } else { /* * In a mode where it is not acceptable to return out * of date information. * * If the error positviely indicates that there is no * such entry delete it. For errors where object may * still exist in the DIT leave it. */ if (MAP_NO_MATCHING_KEY == ret) { /* * Don't log errors. If the entry was not * already present then no problem. The user * just asked us for a non existant entry. */ dbm_delete(map->entries, *key); dbm_delete(map->ttl, *key); } return (FAILURE); } } /* Write it to DBM */ res = dbm_store(map->entries, *key, dat, DBM_REPLACE); sfree(dat.dptr); if (SUCCESS != res) return (FAILURE); /* Update TTL */ update_entry_ttl(map, key, TTL_RUNNING); return (SUCCESS); } /* * FUNCTION: update_map_if_required() * * DESCRIPTION: Called to update an entire map if it is out of date. Map ctrl * must be locked before this is called. This handles checking if * the map is already being updated. It is important that this is * done atomically with obtaining the maps update lock. * * INPUTS: Map control structure for an open map * Flag indication if we should wait for completion * * OUTPUTS: SUCCESS = Map update initiated * FAILURE = Map update not initiated */ suc_code update_map_if_required(map_ctrl *map, bool_t wait) { thread_t tid; map_ctrl *new_map; suc_code res; long flags; if (wait) { /* * Actually get the lock * * May block so unlock map_ctrl while it is done */ unlock_map_ctrl(map); res = lock_map_update(map); lock_map_ctrl(map); if (SUCCESS != res) { logmsg(MSG_NOTIMECHECK, LOG_ERR, "Could not lock map %s for update", map->map_name); return (FAILURE); } } else { /* If not waiting try to get the lock */ switch (try_lock_map_update(map)) { case 0: /* * We got the lock. Continue to start an update. */ break; case EBUSY: /* * Some one else got the lock. OK they are * doing the update so we can just return. */ return (SUCCESS); default: /* * Some serious problem with lock. */ return (FAILURE); } } /* * If we get here are holding the update lock. Make a final check that * nobody beat us to the map update while we were getting it. */ if (!has_map_expired(map)) { /* A big waste of time. Somebody else did the update */ unlock_map_update(map); return (SUCCESS); } /* * We got the lock and nobody beat us to doing the update. Start our * own update. * * Thread will free the update lock when update is complete. */ /* * Make a copy of the map_ctrl structure so the update thread has an * independent version to work with. Note: Must not be on stack. * * On exit the update thread must free this. */ new_map = dup_map_ctrl(map); if (NULL == new_map) { unlock_map_update(map); return (FAILURE); } /* * While thread is running unlock map so other processes can * execute non update related accesses */ unlock_map_ctrl(map); flags = THR_BOUND | THR_NEW_LWP; /* * If we are not going to thr_join then need to create detached. * This prevents a zombie being left when nobody joins us. */ if (!wait && (getpid() == parent_pid)) flags |= THR_DETACHED; /* Kick off update thread */ if (0 != thr_create(NULL, NULL, update_thread, new_map, flags, &tid)) { logmsg(MSG_NOTIMECHECK, LOG_ERR, "Could not create NIS update thread"); free_map_ctrl(new_map); unlock_map_update(map); if (SUCCESS != lock_map_ctrl(map)) logmsg(MSG_NOTIMECHECK, LOG_ERR, "Could not acquire update lock for %s", map->map_name); return (FAILURE); } if (wait) { /* May block but no problem map_ctrl is already unlocked. */ thr_join(tid, NULL, NULL); } /* Re acquire lock */ if (1 != lock_map_ctrl(map)) { logmsg(MSG_NOTIMECHECK, LOG_ERR, "Could not re-acquire lock for %s", map->map_name); return (FAILURE); } return (SUCCESS); } /* * FUNCTION: update_thread() * * DESCRIPTION: The update thread this is called to update an entire NIS map. * if several NIS maps are found to be out of date several * instances of this may be running at the same time. * * Since we are using a duplicate map_ctrl we do not have to lock * it. If we did would end up using the same mutex as the parent * map ctrl an possibly deadlocking. * * INPUTS: Map handle (because we need access to name and lock) * * OUTPUTS: None exits when finished. */ void * update_thread(void *arg) { void *ret = (void *)-1; map_ctrl *map; /* Cast argument pointer to correct type */ map = (map_ctrl *)arg; /* Actually do the work */ if (SUCCESS == update_map_from_dit(map, FALSE)) ret = 0; /* Update complete or failed */ unlock_map_update(map); /* Free up duplicate copy of the map_ctrl */ free_map_ctrl(map); thr_exit(ret); return (NULL); } /* * FUNCTION : is_special_key() * * DESCRIPTION: Works out if a given key is one of the special ones. We just * check for the "YP_" prefix. This is not 100% safe but if * valid keys with a "YP_" prefix exist in the DIT then a lot of * other parts of NIS wont work. */ bool_t is_special_key(datum *key) { if (0 == strncmp(key->dptr, yp_prefix, yp_prefix_sz)) return (TRUE); return (FALSE); }
