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