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 2004 Sun Microsystems, Inc. All rights reserved.
25 * Use is subject to license terms.
26 */
27
28 /*
29 * DESCRIPTION: Contains utilities relating to TTL calculation.
30 */
31 #include <unistd.h>
32 #include <syslog.h>
33 #include <errno.h>
34 #include <strings.h>
35 #include <ndbm.h>
36 #include "ypsym.h"
37 #include "ypdefs.h"
38 #include "shim.h"
39 #include "yptol.h"
40 #include "../ldap_util.h"
41
42 /*
43 * Constants used in time calculations
44 */
45 #define MILLION 1000000
46
47 /*
48 * Decs
49 */
50 suc_code is_greater_timeval(struct timeval *, struct timeval *);
51 suc_code add_to_timeval(struct timeval *, int);
52
53 /*
54 * FUNCTION: has_entry_expired()
55 *
56 * DESCRIPTION: Determines if an individual entry has expired.
57 *
58 * INPUTS: Map control structure for an open map
59 * Entry key
60 *
61 * OUTPUTS: TRUE = Entry has expired or cannot be found this will cause
62 * missing entries to be pulled out of the DIT.
63 * FALSE = Entry has not expired
64 *
65 */
66 bool_t
67 has_entry_expired(map_ctrl *map, datum *key)
68 {
69 datum ttl;
70 struct timeval now;
71 struct timeval old_time;
72 char *key_name;
73 char *myself = "has_entry_expired";
74
75 if ((map == NULL) || (map->ttl == NULL))
76 return (FALSE);
77
78 /* Get expiry time entry for key */
79 ttl = dbm_fetch(map->ttl, *key);
80
81 if (NULL == ttl.dptr) {
82 /*
83 * If we failed to get a map expiry key, which must always be
84 * present, then something is seriously wrong. Try to recreate
85 * the map.
86 */
87 if ((key->dsize == strlen(MAP_EXPIRY_KEY)) &&
88 (0 == strncmp(key->dptr, MAP_EXPIRY_KEY, key->dsize))) {
89 logmsg(MSG_NOTIMECHECK, LOG_ERR, "Cannot find %s TTL "
90 "for map %s. Will attempt to recreate map",
91 MAP_EXPIRY_KEY, map->map_name);
92 return (TRUE);
93 }
94
95 /*
96 * Not a problem just no TTL entry for this entry. Maybe it has
97 * not yet been downloaded. Maybe it will be handled by a
98 * service other than NIS. Check if the entire map has expired.
99 * This prevents repeated LDAP reads when requests are made for
100 * nonexistant entries.
101 */
102 if (has_map_expired(map)) {
103 /* Kick of a map update */
104 update_map_if_required(map, FALSE);
105 }
106
107 /* Don't update the entry */
108 return (FALSE);
109 }
110
111 if (ttl.dsize != sizeof (struct timeval)) {
112 /*
113 * Need to malloc some memory before can syslog the key name
114 * but this may fail. Solution log a simple message first THEn
115 * a more detailed one if it works.
116 */
117 logmsg(MSG_NOTIMECHECK, LOG_ERR,
118 "Invalid TTL key in map %s. error %d",
119 map->map_name, dbm_error(map->ttl));
120
121 /* Log the key name */
122 key_name = (char *)am(myself, key->dsize + 1);
123 if (NULL == key_name) {
124 logmsg(MSG_NOMEM, LOG_ERR,
125 "Could not alloc memory for keyname");
126 } else {
127 strncpy(key_name, key->dptr, key->dsize);
128 key_name[key->dsize] = '\0';
129 logmsg(MSG_NOTIMECHECK, LOG_ERR,
130 "Key name was %s", key_name);
131 sfree(key_name);
132 }
133 /* Update it Anyway */
134 return (TRUE);
135 }
136
137 /* Get current time */
138 gettimeofday(&now, NULL);
139
140 /*
141 * Because dptr may not be int aligned need to build an int
142 * out of what it points to or will get a bus error
143 */
144 bcopy(ttl.dptr, &old_time, sizeof (struct timeval));
145
146 return (is_greater_timeval(&now, &old_time));
147 }
148
149 /*
150 * FUNCTION: has_map_expired()
151 *
152 * DESCRIPTION: Determines if an entire map has expire
153 *
154 * INPUTS: Map control structure for an open map
155 *
156 * OUTPUTS: TRUE = Map has expired
157 * FALSE Map has not expired
158 *
159 */
160 bool_t
161 has_map_expired(map_ctrl *map)
162 {
163 datum key;
164
165 /* Set up datum with magic expiry key */
166 key.dsize = strlen(MAP_EXPIRY_KEY);
167 key.dptr = MAP_EXPIRY_KEY;
168
169 /* Call has_entry_expired() with magic map expiry key */
170 return (has_entry_expired(map, &key));
171 }
172
173 /*
174 * FUNCTION: update_entry_ttl()
175 *
176 * DESCRIPTION: Updates the TTL for one map entry
177 *
178 * INPUTS: Map control structure for an open map
179 * Entry key
180 * Flag indication if TTL should be max, min or random
181 *
182 * OUTPUTS: SUCCESS = TTL updated
183 * FAILURE = TTL not updated
184 *
185 */
186
187 suc_code
188 update_entry_ttl(map_ctrl *map, datum *key, TTL_TYPE type)
189 {
190 datum expire;
191 struct timeval now;
192 int ttl;
193
194 /* Get current time */
195 gettimeofday(&now, NULL);
196
197 /* Get TTL from mapping file */
198 ttl = get_ttl_value(map, type);
199
200 if (FAILURE == add_to_timeval(&now, ttl))
201 return (FAILURE);
202
203 /* Convert time into a datum */
204 expire.dsize = sizeof (struct timeval);
205 expire.dptr = (char *)&now;
206
207 /* Set expiry time entry for key */
208 errno = 0;
209 if (0 > dbm_store(map->ttl, *key, expire, DBM_REPLACE)) {
210 logmsg(MSG_NOTIMECHECK, LOG_ERR, "Could not write TTL entry "
211 "(errno=%d)", errno);
212 return (FAILURE);
213 }
214
215 return (SUCCESS);
216 }
217
218 /*
219 * FUNCTION: update_map_ttl()
220 *
221 * DESCRIPTION: Updates the TTL for entire map. This can be called either with
222 * the map open (map_ctrl DBM pointer set up) or the map closed
223 * (map_ctrl DBM pointers not set). The latter case will occur
224 * when we have just created a new map.
225 *
226 * This function must open the TTL map but, in either case, must
227 * return with the map_ctrl in it's original state.
228 *
229 * INPUTS: Map control structure for an open map
230 *
231 * OUTPUTS: SUCCESS = TTL updated
232 * FAILURE = TTL not updated
233 *
234 */
235 suc_code
236 update_map_ttl(map_ctrl *map)
237 {
238 datum key;
239 bool_t map_was_open = TRUE;
240 suc_code ret;
241
242 /* Set up datum with magic expiry key */
243 key.dsize = strlen(MAP_EXPIRY_KEY);
244 key.dptr = MAP_EXPIRY_KEY;
245
246 /* If TTL not open open it */
247 if (NULL == map->ttl) {
248 map->ttl = dbm_open(map->ttl_path, O_RDWR, 0644);
249 if (NULL == map->ttl)
250 return (FAILURE);
251 map_was_open = FALSE;
252 }
253
254 /* Call update_entry_ttl() with magic map expiry key */
255 ret = update_entry_ttl(map, &key, TTL_MIN);
256
257 /* If we had to open TTL file close it */
258 if (!map_was_open) {
259 dbm_close(map->ttl);
260 map->ttl_path = NULL;
261 }
262
263 return (ret);
264 }
265
266 /*
267 * FUNCTION: add_to_timeval()
268 *
269 * DESCRIPTION: Adds an int to a timeval
270 *
271 * NOTE : Seems strange that there is not a library function to do this
272 * if one exists then this function can be removed.
273 *
274 * NOTE : Does not handle UNIX clock wrap round but this is a much bigger
275 * problem.
276 *
277 * INPUTS: Time value to add to
278 * Time value to add in seconds
279 *
280 * OUTPUTS: SUCCESS = Addition successful
281 * FAILURE = Addition failed (probably wrapped)
282 *
283 */
284 suc_code
285 add_to_timeval(struct timeval *t1, int t2)
286 {
287 struct timeval oldval;
288
289 oldval.tv_sec = t1->tv_sec;
290
291 /* Add seconds part */
292 t1->tv_sec += t2;
293
294 /* Check for clock wrap */
295 if (!(t1->tv_sec >= oldval.tv_sec)) {
296 logmsg(MSG_NOTIMECHECK, LOG_ERR,
297 "Wrap when adding %d to %d", t2, oldval.tv_sec);
298 return (FAILURE);
299 }
300
301 return (SUCCESS);
302 }
303
304 /*
305 * FUNCTION: is_greater_timeval()
306 *
307 * DESCRIPTION: Compares two timevals
308 *
309 * NOTE : Seems strange that there is not a library function to do this
310 * if one exists then this function can be removed.
311 *
312 * INPUTS: First time value
313 * Time value to compare it with
314 *
315 * OUTPUTS: TRUE t1 > t2
316 * FALSE t1 <= t2
317 *
318 */
319 suc_code
320 is_greater_timeval(struct timeval *t1, struct timeval *t2)
321 {
322 if (t1->tv_sec > t2->tv_sec)
323 return (TRUE);
324
325 if (t1->tv_sec == t2->tv_sec) {
326 if (t1->tv_usec > t2->tv_usec)
327 return (TRUE);
328 else
329 return (FALSE);
330 }
331
332 return (FALSE);
333 }