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 functions relating to movement of entire maps.
31 */
32
33 #include <unistd.h>
34 #include <syslog.h>
35 #include <ndbm.h>
36 #include <string.h>
37 #include "ypsym.h"
38 #include "ypdefs.h"
39 #include "shim.h"
40 #include "yptol.h"
41 #include "../ldap_util.h"
42
43 /*
44 * Switch on parts of ypdefs.h
45 */
46 USE_YPDBPATH
47 USE_DBM
48
49 /*
50 * Decs
51 */
52 void add_separator(char *);
53 suc_code dump_domain_to_dit(char *, bool_t);
54 suc_code dump_map_to_dit(char *, char *, bool_t);
55 suc_code dump_maps_to_dit(bool_t);
56 suc_code dump_dit_to_map();
57 suc_code dump_dit_to_maps();
58
59 /*
60 * FUNCTION : dump_maps_to_dit()
61 *
62 * DESCRIPTION: Dump all the OLD STYLE NIS maps into the DIT.
63 *
64 * Since the DIT is not yet set up details about which maps and
65 * domains exist are gathered from the N2L config file and the
66 * existing map files.
67 *
68 * GIVEN : Flag indicating if containers and domains should be set up.
69 *
70 * RETURNS : Success code
71 */
72 suc_code
73 dump_maps_to_dit(bool_t init_containers)
74 {
75 char **dom_list;
76 int num_doms, i;
77
78 num_doms = get_mapping_domain_list(&dom_list);
79
80 /* Dump all domains in list */
81 for (i = 0; i < num_doms; i++) {
82 if (FAILURE == dump_domain_to_dit(dom_list[i], init_containers))
83 return (FAILURE);
84 }
85
86 return (SUCCESS);
87 }
88
89 /*
90 * FUNCTION : dump_domain_to_dit()
91 *
92 * DESCRIPTION: Dumps all maps in one domain into the DIT
93 *
94 * GIVEN : Name of the domain
95 * Flag indicating if containers and domains should be set up.
96 *
97 * RETURNS : SUCCESS = domain completely dumped
98 * FAILURE = domain not completely dumped
99 *
100 */
101 suc_code
102 dump_domain_to_dit(char *dom_name, bool_t init_containers)
103 {
104 char **map_list;
105 int i;
106
107 /* Set up nis domain object */
108 if (SUCCESS != make_nis_domain(dom_name, init_containers)) {
109 if (init_containers)
110 logmsg(MSG_NOTIMECHECK, LOG_ERR,
111 "Could not make nisDomain object for %s", dom_name);
112 else
113 logmsg(MSG_NOTIMECHECK, LOG_ERR,
114 "Problem detected with nisDomain object for %s",
115 dom_name);
116 return (FAILURE);
117 }
118
119 /* Get list of maps from mapping file */
120 map_list = get_mapping_map_list(dom_name);
121 if (NULL == map_list) {
122 logmsg(MSG_NOTIMECHECK, LOG_ERR,
123 "Could not get map list for %s", dom_name);
124 return (FAILURE);
125 }
126
127 for (i = 0; NULL != map_list[i]; i++) {
128 dump_map_to_dit(map_list[i], dom_name, init_containers);
129 }
130
131 free_map_list(map_list);
132
133 return (SUCCESS);
134 }
135
136 /*
137 * FUNCTION : dump_map_to_dit()
138 *
139 * DESCRIPTION: Dump a OLD STYLE NIS map into the DIT.
140 *
141 * GIVEN : Name of map (not fully qualified)
142 * Name of domain
143 * Flag indicating if containers should be set up.
144 *
145 * RETURNS : SUCCESS = Map copy completed
146 * FAILURE = Map copy not completed
147 */
148 suc_code
149 dump_map_to_dit(char *map_name, char *domain, bool_t init_containers)
150 {
151 char *myself = "dump_map_to_dit";
152 DBM *dbm;
153 datum key;
154 datum value;
155 char *map_path; /* Qualified map name */
156 int entry_count;
157 int next_print;
158
159 printf("Copying map \"%s\", domain \"%s\", to LDAP.\n",
160 map_name, domain);
161
162 /* Create the NIS container */
163 if (SUCCESS != make_nis_container(map_name, domain, init_containers)) {
164 if (init_containers)
165 logmsg(MSG_NOTIMECHECK, LOG_ERR,
166 "Could not make container for %s %s",
167 map_name, domain);
168 else
169 logmsg(MSG_NOTIMECHECK, LOG_ERR,
170 "Problem detected with container for %s %s",
171 map_name, domain);
172
173 return (FAILURE);
174 }
175
176 /* Make up fully qualified map name */
177 map_path = (char *)am(myself, strlen(domain) + strlen(map_name) +
178 ypdbpath_sz + 3);
179 if (NULL == map_path) {
180 logmsg(MSG_NOMEM, LOG_ERR,
181 "Could not alloc memory for %s %s", map_name, domain);
182 return (FAILURE);
183 }
184 strcpy(map_path, ypdbpath);
185 add_separator(map_path);
186 strcat(map_path, domain);
187 add_separator(map_path);
188 strcat(map_path, map_name);
189
190 /* Open the DBM file. Use real dbm call */
191 dbm = dbm_open(map_path, O_RDONLY, 0644);
192
193 /* Finished with full name */
194 sfree(map_path);
195
196 if (NULL == dbm) {
197 /*
198 * This map probably didn't exist. No problem, user may be
199 * going to populate container using LDAP.
200 */
201 return (SUCCESS);
202 }
203
204 /*
205 * N2L has no lock for old style maps. No problem ypserv -i is the
206 * only thing that accesses them.
207 */
208
209 /* For all entries in file */
210 for (key = dbm_firstkey(dbm), next_print = PRINT_FREQ, entry_count = 1;
211 NULL != key.dptr; key = dbm_nextkey(dbm), entry_count ++) {
212
213 /* Don't write zero length keys */
214 if (0 == key.dsize) {
215 logmsg(MSG_NOTIMECHECK, LOG_INFO,
216 "Zero length key ignored in %s %s", map_name, domain);
217 continue;
218 }
219
220 /* Don't write 'special' nis entries */
221 if (is_special_key(&key))
222 continue;
223
224 /* Get entry */
225 value = dbm_fetch(dbm, key);
226
227 /* Copy entry to DIT */
228 if (SUCCESS != write_to_dit(map_name, domain, key, value,
229 TRUE, TRUE))
230 /* Syslog will have already been done */
231 break;
232
233 /* If necessary print a progress report */
234 if (entry_count >= next_print) {
235 printf("%d entries processed.\n", entry_count);
236 next_print *= 2;
237 }
238 }
239
240 dbm_close(dbm);
241
242 return (SUCCESS);
243 }
244
245 /*
246 * FUNCTION : dump_dit_to_maps()
247 *
248 * DESCRIPTION: Dumps the contents of the DIT into the NEW STYLE NIS maps. If
249 * the maps, or their TTL files do not exist creates them.
250 *
251 * Since we are now treating the DIT as authoritative details of
252 * which domains and maps exist are gathered from the DIT.
253 *
254 * GIVEN : Nothing
255 *
256 * RETURNS : Success code
257 */
258 suc_code
259 dump_dit_to_maps()
260 {
261 char **dom_list;
262 int dom_count;
263 char *dom_path;
264 char **map_list;
265 int i, j;
266 char *myself = "dump_dit_to_maps";
267
268 /* For all domain objects in DIT */
269 dom_count = get_mapping_domain_list(&dom_list);
270
271 if (0 == dom_count) {
272 /* No problem, maybe no domains */
273 return (SUCCESS);
274 }
275
276 /* Dump all domains in list */
277 for (i = 0; i < dom_count; i++) {
278
279 /* If necessary create domain directory */
280 dom_path = (char *)am(myself, ypdbpath_sz +
281 strlen(dom_list[i]) + 2);
282 if (NULL == dom_path) {
283 return (FAILURE);
284 }
285
286 strcpy(dom_path, ypdbpath);
287 strcat(dom_path, "/");
288 strcat(dom_path, dom_list[i]);
289
290 if (0 != mkdir(dom_path, 0644)) {
291 /* If dir exists fine. Just use it */
292 if (EEXIST != errno) {
293 logmsg(MSG_NOTIMECHECK, LOG_ERR,
294 "Could not make create domain directory %s",
295 dom_path);
296 sfree(dom_path);
297 }
298 }
299
300 sfree(dom_path);
301
302 /* Get list of maps for this domain */
303 map_list = get_mapping_map_list(dom_list[i]);
304 if (NULL == map_list) {
305 /* No problem. Just no maps in this domain */
306 continue;
307 }
308
309 /* For all maps in domain */
310 for (j = 0; map_list[j] != NULL; j++) {
311 /* A normal map update will initialize it. */
312 if (FAILURE == dump_dit_to_map(map_list[j],
313 dom_list[i])) {
314 free_map_list(map_list);
315 return (FAILURE);
316 }
317
318 /* If we have a netgroup also generate netgroup.byxxx */
319 if (0 == strcmp(map_list[j], NETGROUP_MAP)) {
320 if (FAILURE == dump_dit_to_map(NETGROUP_BYHOST,
321 dom_list[i])) {
322 free_map_list(map_list);
323 return (FAILURE);
324 }
325 if (FAILURE == dump_dit_to_map(NETGROUP_BYUSER,
326 dom_list[i])) {
327 free_map_list(map_list);
328 return (FAILURE);
329 }
330 }
331 }
332 free_map_list(map_list);
333 }
334 return (SUCCESS);
335 }
336
337 /*
338 * FUNCTION : dump_dit_to_map()
339 *
340 * DESCRIPTION: Dumps the contents of the DIT into one NEW STYLE NIS map. If
341 * the map, or its TTL file does not exist creates them.
342 *
343 * This is the same operation as is carried out when updating a
344 * map that has timed out. As a result we can call the normal
345 * update function.
346 *
347 *
348 * GIVEN : Map name (unqualified)
349 * Domain name.
350 *
351 * RETURNS : SUCCESS = Map copy complete
352 * FAILURE = Problems
353 */
354 suc_code
355 dump_dit_to_map(char *map_name, char *domain)
356 {
357 char *myself = "dump_dit_to_map";
358 map_ctrl map;
359 char *map_path;
360
361 printf("Copying LDAP data to map \"%s\", domain \"%s\".\n",
362 map_name, domain);
363
364 /*
365 * To call update_map_from_dit() we need an initialized map_ctrl.
366 * The easiest way to get this is to generate a full path to the new
367 * map and then call map_ctrl_init().
368 */
369 map_path = (char *)am(myself, ypdbpath_sz + strlen(map_name) +
370 strlen(domain) + strlen(NTOL_PREFIX) + 3);
371 if (NULL == map_path)
372 return (FAILURE);
373
374 strcpy(map_path, ypdbpath);
375 add_separator(map_path);
376 strcat(map_path, domain);
377 add_separator(map_path);
378 strcat(map_path, NTOL_PREFIX);
379 strcat(map_path, map_name);
380
381 if (FAILURE == map_ctrl_init(&map, map_path)) {
382 sfree(map_path);
383 return (FAILURE);
384 }
385
386 sfree(map_path);
387
388 /*
389 * This is called before anything else is running so don't need to
390 * do normal update lock.
391 */
392 return (update_map_from_dit(&map, TRUE));
393 }
394
395 /*
396 * FUNCTION : add_seperator()
397 *
398 * DESCRIPTION: Adds a file separator to a string (which must already be big
399 * enough.)
400 *
401 * GIVEN : Pointer to the string
402 *
403 * RETURNS : Nothing
404 */
405 void
406 add_separator(char *str)
407 {
408 char *p;
409
410 p = str + strlen(str);
411 *p = SEP_CHAR;
412 *(p+1) = '\0';
413 }