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, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 2003 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 /* 30 * DESCRIPTION: Contains the map update thread and related code. 31 */ 32 33 #include <unistd.h> 34 #include <syslog.h> 35 #include <ndbm.h> 36 #include <thread.h> 37 #include <unistd.h> 38 #include <strings.h> 39 #include "ypsym.h" 40 #include "ypdefs.h" 41 #include "shim.h" 42 #include "yptol.h" 43 #include "../ldap_util.h" 44 45 /* Enable standard YP code features defined in ypdefs.h */ 46 USE_YP_PREFIX 47 USE_YP_MASTER_NAME 48 USE_YP_LAST_MODIFIED 49 USE_YP_INPUT_FILE 50 USE_YP_OUTPUT_NAME 51 USE_YP_DOMAIN_NAME 52 USE_YP_SECURE 53 USE_YP_INTERDOMAIN 54 55 /* 56 * Decs 57 */ 58 suc_code update_from_dit(map_ctrl *, datum *); 59 void * update_thread(void *); 60 61 /* 62 * Globals 63 */ 64 extern pid_t parent_pid; 65 66 /* 67 * FUNCTION: update_entry_if_required() 68 * 69 * DESCRIPTION: Determines if an entry is to be updated and if it is does the 70 * update. 71 * 72 * GIVEN : Pointer to the open map ctrl 73 * Pointer to the entry key 74 * 75 * RETURNS : SUCCESS = Entry is in a state to be returned to the client 76 * i.e. either got updated, did not need to be updated or we are 77 * in a mode where it is acceptable to return out of date 78 * information. 79 * FAILURE = Entry need an update but it could not be done. 80 */ 81 suc_code 82 update_entry_if_required(map_ctrl *map, datum *key) 83 { 84 85 /* Only update individual entries if entire map is */ 86 /* not being updated */ 87 if (is_map_updating(map)) 88 return (SUCCESS); 89 90 /* 91 * If we are being asked for the order then need to check if 92 * the map is in need of an update. If it is then fake a 93 * recent order. The client will then read the map, using 94 * dbm_firstkey and this will do the update. 95 */ 96 if (0 == strncmp(key->dptr, yp_last_modified, yp_last_modified_sz)) { 97 if (has_map_expired(map)) 98 update_timestamp(map->entries); 99 return (SUCCESS); 100 } 101 102 /* Never update special keys. Have no TTLs */ 103 if (is_special_key(key)) 104 return (SUCCESS); 105 106 if (!has_entry_expired(map, key)) 107 /* Didn't need an update */ 108 return (SUCCESS); 109 110 /* Do the update */ 111 return (update_from_dit(map, key)); 112 } 113 114 /* 115 * FUNCTION: update_from_dit() 116 * 117 * DESCRIPTION: Called to update an entry from the DIT 118 * 119 * INPUTS: Map control structure for an open map 120 * Entry key 121 * 122 * OUTPUTS: SUCCESS = Update complete or we are in a mode where it is 123 * acceptable to return out of date information. 124 * FAILURE = Update failed 125 * 126 */ 127 suc_code 128 update_from_dit(map_ctrl *map, datum *key) 129 { 130 datum dat; 131 int ret; 132 suc_code res; 133 134 /* 135 * Netgroup maps are a special case we cannot update just one entry so 136 * update the entire map instead. 137 */ 138 if ((0 == strcmp(map->map_name, NETGROUP_BYHOST)) || 139 (0 == strcmp(map->map_name, NETGROUP_BYUSER))) { 140 return (update_map_if_required(map, FALSE)); 141 } 142 143 /* Read entry from the DIT */ 144 ret = read_from_dit(map->map_name, map->domain, key, &dat); 145 146 /* Check that we got something */ 147 if (NULL == dat.dptr) { 148 if (0 == ret) { 149 /* 150 * In a mode where it is acceptable to return out of 151 * date information. 152 */ 153 logmsg(MSG_NOTIMECHECK, LOG_INFO, 154 "LDAP inaccessible returning old information"); 155 return (SUCCESS); 156 } else { 157 /* 158 * In a mode where it is not acceptable to return out 159 * of date information. 160 * 161 * If the error positviely indicates that there is no 162 * such entry delete it. For errors where object may 163 * still exist in the DIT leave it. 164 */ 165 if (MAP_NO_MATCHING_KEY == ret) { 166 /* 167 * Don't log errors. If the entry was not 168 * already present then no problem. The user 169 * just asked us for a non existant entry. 170 */ 171 dbm_delete(map->entries, *key); 172 dbm_delete(map->ttl, *key); 173 } 174 return (FAILURE); 175 } 176 } 177 178 /* Write it to DBM */ 179 res = dbm_store(map->entries, *key, dat, DBM_REPLACE); 180 sfree(dat.dptr); 181 182 if (SUCCESS != res) 183 return (FAILURE); 184 185 /* Update TTL */ 186 update_entry_ttl(map, key, TTL_RUNNING); 187 188 return (SUCCESS); 189 } 190 191 /* 192 * FUNCTION: update_map_if_required() 193 * 194 * DESCRIPTION: Called to update an entire map if it is out of date. Map ctrl 195 * must be locked before this is called. This handles checking if 196 * the map is already being updated. It is important that this is 197 * done atomically with obtaining the maps update lock. 198 * 199 * INPUTS: Map control structure for an open map 200 * Flag indication if we should wait for completion 201 * 202 * OUTPUTS: SUCCESS = Map update initiated 203 * FAILURE = Map update not initiated 204 */ 205 suc_code 206 update_map_if_required(map_ctrl *map, bool_t wait) 207 { 208 thread_t tid; 209 map_ctrl *new_map; 210 suc_code res; 211 long flags; 212 213 if (wait) { 214 /* 215 * Actually get the lock 216 * 217 * May block so unlock map_ctrl while it is done 218 */ 219 unlock_map_ctrl(map); 220 res = lock_map_update(map); 221 lock_map_ctrl(map); 222 if (SUCCESS != res) { 223 logmsg(MSG_NOTIMECHECK, LOG_ERR, 224 "Could not lock map %s for update", 225 map->map_name); 226 return (FAILURE); 227 } 228 } else { 229 /* If not waiting try to get the lock */ 230 switch (try_lock_map_update(map)) { 231 case 0: 232 /* 233 * We got the lock. Continue to start an update. 234 */ 235 break; 236 237 case EBUSY: 238 /* 239 * Some one else got the lock. OK they are 240 * doing the update so we can just return. 241 */ 242 return (SUCCESS); 243 244 default: 245 /* 246 * Some serious problem with lock. 247 */ 248 return (FAILURE); 249 } 250 } 251 252 /* 253 * If we get here are holding the update lock. Make a final check that 254 * nobody beat us to the map update while we were getting it. 255 */ 256 if (!has_map_expired(map)) { 257 /* A big waste of time. Somebody else did the update */ 258 unlock_map_update(map); 259 return (SUCCESS); 260 } 261 262 /* 263 * We got the lock and nobody beat us to doing the update. Start our 264 * own update. 265 * 266 * Thread will free the update lock when update is complete. 267 */ 268 269 270 /* 271 * Make a copy of the map_ctrl structure so the update thread has an 272 * independent version to work with. Note: Must not be on stack. 273 * 274 * On exit the update thread must free this. 275 */ 276 new_map = dup_map_ctrl(map); 277 if (NULL == new_map) { 278 unlock_map_update(map); 279 return (FAILURE); 280 } 281 282 /* 283 * While thread is running unlock map so other processes can 284 * execute non update related accesses 285 */ 286 unlock_map_ctrl(map); 287 288 flags = THR_BOUND | THR_NEW_LWP; 289 290 /* 291 * If we are not going to thr_join then need to create detached. 292 * This prevents a zombie being left when nobody joins us. 293 */ 294 if (!wait && (getpid() == parent_pid)) 295 flags |= THR_DETACHED; 296 297 /* Kick off update thread */ 298 if (0 != thr_create(NULL, NULL, update_thread, new_map, 299 flags, &tid)) { 300 logmsg(MSG_NOTIMECHECK, LOG_ERR, 301 "Could not create NIS update thread"); 302 free_map_ctrl(new_map); 303 unlock_map_update(map); 304 if (SUCCESS != lock_map_ctrl(map)) 305 logmsg(MSG_NOTIMECHECK, LOG_ERR, 306 "Could not acquire update lock for %s", map->map_name); 307 return (FAILURE); 308 } 309 310 if (wait) { 311 /* May block but no problem map_ctrl is already unlocked. */ 312 thr_join(tid, NULL, NULL); 313 } 314 315 /* Re acquire lock */ 316 if (1 != lock_map_ctrl(map)) { 317 logmsg(MSG_NOTIMECHECK, LOG_ERR, 318 "Could not re-acquire lock for %s", map->map_name); 319 return (FAILURE); 320 } 321 322 return (SUCCESS); 323 } 324 325 /* 326 * FUNCTION: update_thread() 327 * 328 * DESCRIPTION: The update thread this is called to update an entire NIS map. 329 * if several NIS maps are found to be out of date several 330 * instances of this may be running at the same time. 331 * 332 * Since we are using a duplicate map_ctrl we do not have to lock 333 * it. If we did would end up using the same mutex as the parent 334 * map ctrl an possibly deadlocking. 335 * 336 * INPUTS: Map handle (because we need access to name and lock) 337 * 338 * OUTPUTS: None exits when finished. 339 */ 340 341 void * 342 update_thread(void *arg) 343 { 344 void *ret = (void *)-1; 345 map_ctrl *map; 346 347 /* Cast argument pointer to correct type */ 348 map = (map_ctrl *)arg; 349 350 /* Actually do the work */ 351 if (SUCCESS == update_map_from_dit(map, FALSE)) 352 ret = 0; 353 354 /* Update complete or failed */ 355 unlock_map_update(map); 356 357 /* Free up duplicate copy of the map_ctrl */ 358 free_map_ctrl(map); 359 360 thr_exit(ret); 361 } 362 363 /* 364 * FUNCTION : is_special_key() 365 * 366 * DESCRIPTION: Works out if a given key is one of the special ones. We just 367 * check for the "YP_" prefix. This is not 100% safe but if 368 * valid keys with a "YP_" prefix exist in the DIT then a lot of 369 * other parts of NIS wont work. 370 */ 371 bool_t 372 is_special_key(datum *key) 373 { 374 if (0 == strncmp(key->dptr, yp_prefix, yp_prefix_sz)) 375 return (TRUE); 376 377 return (FALSE); 378 } 379