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 (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
23 */
24
25
26 /*
27 * This module contains functions used for reading and writing the index file.
28 * setzoneent() opens the file. getzoneent() parses the file, doing the usual
29 * skipping of comment lines, etc., and using gettok() to deal with the ":"
30 * delimiters. endzoneent() closes the file. putzoneent() updates the file,
31 * adding, deleting or modifying lines, locking and unlocking appropriately.
32 */
33
34 #include <stdlib.h>
35 #include <string.h>
36 #include <errno.h>
37 #include <libzonecfg.h>
38 #include <unistd.h>
39 #include <fcntl.h>
40 #include <sys/stat.h>
41 #include <assert.h>
42 #include <uuid/uuid.h>
43 #include "zonecfg_impl.h"
44
45
46 #define _PATH_TMPFILE ZONE_CONFIG_ROOT "/zonecfg.XXXXXX"
47
48 /*
49 * gettok() is a helper function for parsing the index file, used to split
50 * the lines by their ":" delimiters. Note that an entry may contain a ":"
51 * inside double quotes; this should only affect the zonepath, as zone names
52 * do not allow such characters, and zone states do not have them either.
53 * Same with double-quotes themselves: they are not allowed in zone names,
54 * and do not occur in zone states, and in theory should never occur in a
55 * zonepath since zonecfg does not support a method for escaping them.
56 *
57 * It never returns NULL.
58 */
59
60 static char *
61 gettok(char **cpp)
62 {
63 char *cp = *cpp, *retv;
64 boolean_t quoted = B_FALSE;
65
66 if (cp == NULL)
67 return ("");
68 if (*cp == '"') {
69 quoted = B_TRUE;
70 cp++;
71 }
72 retv = cp;
73 if (quoted) {
74 while (*cp != '\0' && *cp != '"')
75 cp++;
76 if (*cp == '"')
77 *cp++ = '\0';
78 }
79 while (*cp != '\0' && *cp != ':')
80 cp++;
81 if (*cp == '\0') {
82 *cpp = NULL;
83 } else {
84 *cp++ = '\0';
85 *cpp = cp;
86 }
87 return (retv);
88 }
89
90 char *
91 getzoneent(FILE *cookie)
92 {
93 struct zoneent *ze;
94 char *name;
95
96 if ((ze = getzoneent_private(cookie)) == NULL)
97 return (NULL);
98 name = strdup(ze->zone_name);
99 free(ze);
100 return (name);
101 }
102
103 struct zoneent *
104 getzoneent_private(FILE *cookie)
105 {
106 char *cp, buf[MAX_INDEX_LEN], *p;
107 struct zoneent *ze;
108
109 if (cookie == NULL)
110 return (NULL);
111
112 if ((ze = malloc(sizeof (struct zoneent))) == NULL)
113 return (NULL);
114
115 for (;;) {
116 if (fgets(buf, sizeof (buf), cookie) == NULL) {
117 free(ze);
118 return (NULL);
119 }
120 if ((cp = strpbrk(buf, "\r\n")) == NULL) {
121 /* this represents a line that's too long */
122 continue;
123 }
124 *cp = '\0';
125 cp = buf;
126 if (*cp == '#') {
127 /* skip comment lines */
128 continue;
129 }
130 p = gettok(&cp);
131 if (*p == '\0' || strlen(p) >= ZONENAME_MAX) {
132 /*
133 * empty or very long zone names are not allowed
134 */
135 continue;
136 }
137 (void) strlcpy(ze->zone_name, p, ZONENAME_MAX);
138
139 p = gettok(&cp);
140 if (*p == '\0') {
141 /* state field should not be empty */
142 continue;
143 }
144 errno = 0;
145 if (strcmp(p, ZONE_STATE_STR_CONFIGURED) == 0) {
146 ze->zone_state = ZONE_STATE_CONFIGURED;
147 } else if (strcmp(p, ZONE_STATE_STR_INCOMPLETE) == 0) {
148 ze->zone_state = ZONE_STATE_INCOMPLETE;
149 } else if (strcmp(p, ZONE_STATE_STR_INSTALLED) == 0) {
150 ze->zone_state = ZONE_STATE_INSTALLED;
151 } else {
152 continue;
153 }
154
155 p = gettok(&cp);
156 if (strlen(p) >= MAXPATHLEN) {
157 /* very long paths are not allowed */
158 continue;
159 }
160 (void) strlcpy(ze->zone_path, p, MAXPATHLEN);
161
162 p = gettok(&cp);
163 if (uuid_parse(p, ze->zone_uuid) == -1)
164 uuid_clear(ze->zone_uuid);
165
166 break;
167 }
168
169 return (ze);
170 }
171
172 static boolean_t
173 get_index_path(char *path)
174 {
175 return (snprintf(path, MAXPATHLEN, "%s%s", zonecfg_root,
176 ZONE_INDEX_FILE) < MAXPATHLEN);
177 }
178
179 FILE *
180 setzoneent(void)
181 {
182 char path[MAXPATHLEN];
183
184 if (!get_index_path(path)) {
185 errno = EINVAL;
186 return (NULL);
187 }
188 return (fopen(path, "r"));
189 }
190
191 void
192 endzoneent(FILE *cookie)
193 {
194 if (cookie != NULL)
195 (void) fclose(cookie);
196 }
197
198 static int
199 lock_index_file(void)
200 {
201 int lock_fd;
202 struct flock lock;
203 char path[MAXPATHLEN];
204
205 if (snprintf(path, sizeof (path), "%s%s", zonecfg_root,
206 ZONE_INDEX_LOCK_DIR) >= sizeof (path))
207 return (-1);
208 if ((mkdir(path, S_IRWXU) == -1) && errno != EEXIST)
209 return (-1);
210 if (strlcat(path, ZONE_INDEX_LOCK_FILE, sizeof (path)) >=
211 sizeof (path))
212 return (-1);
213 lock_fd = open(path, O_CREAT|O_RDWR, 0644);
214 if (lock_fd == -1)
215 return (-1);
216
217 lock.l_type = F_WRLCK;
218 lock.l_whence = SEEK_SET;
219 lock.l_start = 0;
220 lock.l_len = 0;
221
222 if (fcntl(lock_fd, F_SETLKW, &lock) == -1) {
223 (void) close(lock_fd);
224 return (-1);
225 }
226
227 return (lock_fd);
228 }
229
230 static int
231 unlock_index_file(int lock_fd)
232 {
233 struct flock lock;
234
235 lock.l_type = F_UNLCK;
236 lock.l_whence = SEEK_SET;
237 lock.l_start = 0;
238 lock.l_len = 0;
239
240 if (fcntl(lock_fd, F_SETLK, &lock) == -1)
241 return (Z_UNLOCKING_FILE);
242
243 if (close(lock_fd) == -1)
244 return (Z_UNLOCKING_FILE);
245
246 return (Z_OK);
247 }
248
249 /*
250 * This function adds or removes a zone name et al. to the index file.
251 *
252 * If ze->zone_state is < 0, it means leave the
253 * existing value unchanged; this is only meaningful when operation ==
254 * PZE_MODIFY (i.e., it's bad on PZE_ADD and a no-op on PZE_REMOVE).
255 *
256 * A zero-length ze->zone_path means leave the existing value
257 * unchanged; this is only meaningful when operation == PZE_MODIFY
258 * (i.e., it's bad on PZE_ADD and a no-op on PZE_REMOVE).
259 *
260 * A zero-length ze->zone_newname means leave the existing name
261 * unchanged; otherwise the zone is renamed to zone_newname. This is
262 * only meaningful when operation == PZE_MODIFY.
263 *
264 * Locking and unlocking is done via the functions above.
265 * The file itself is not modified in place; rather, a copy is made which
266 * is modified, then the copy is atomically renamed back to the main file.
267 */
268 int
269 putzoneent(struct zoneent *ze, zoneent_op_t operation)
270 {
271 FILE *index_file, *tmp_file;
272 char *tmp_file_name, buf[MAX_INDEX_LEN];
273 int tmp_file_desc, lock_fd, err;
274 boolean_t exist, need_quotes;
275 char *cp;
276 char path[MAXPATHLEN];
277 char uuidstr[UUID_PRINTABLE_STRING_LENGTH];
278 size_t tlen, namelen;
279 const char *zone_name, *zone_state, *zone_path, *zone_uuid;
280
281 assert(ze != NULL);
282
283 /*
284 * Don't allow modification of Global Zone entry
285 * in index file
286 */
287 if ((operation == PZE_MODIFY) &&
288 (strcmp(ze->zone_name, GLOBAL_ZONENAME) == 0)) {
289 return (Z_OK);
290 }
291
292 if (operation == PZE_ADD &&
293 (ze->zone_state < 0 || strlen(ze->zone_path) == 0))
294 return (Z_INVAL);
295
296 if (operation != PZE_MODIFY && strlen(ze->zone_newname) != 0)
297 return (Z_INVAL);
298
299 if ((lock_fd = lock_index_file()) == -1)
300 return (Z_LOCKING_FILE);
301
302 /* using sizeof gives us room for the terminating NUL byte as well */
303 tlen = sizeof (_PATH_TMPFILE) + strlen(zonecfg_root);
304 tmp_file_name = malloc(tlen);
305 if (tmp_file_name == NULL) {
306 (void) unlock_index_file(lock_fd);
307 return (Z_NOMEM);
308 }
309 (void) snprintf(tmp_file_name, tlen, "%s%s", zonecfg_root,
310 _PATH_TMPFILE);
311
312 tmp_file_desc = mkstemp(tmp_file_name);
313 if (tmp_file_desc == -1) {
314 (void) unlink(tmp_file_name);
315 free(tmp_file_name);
316 (void) unlock_index_file(lock_fd);
317 return (Z_TEMP_FILE);
318 }
319 (void) fchmod(tmp_file_desc, ZONE_INDEX_MODE);
320 (void) fchown(tmp_file_desc, ZONE_INDEX_UID, ZONE_INDEX_GID);
321 if ((tmp_file = fdopen(tmp_file_desc, "w")) == NULL) {
322 (void) close(tmp_file_desc);
323 err = Z_MISC_FS;
324 goto error;
325 }
326 if (!get_index_path(path)) {
327 err = Z_MISC_FS;
328 goto error;
329 }
330 if ((index_file = fopen(path, "r")) == NULL) {
331 err = Z_MISC_FS;
332 goto error;
333 }
334
335 exist = B_FALSE;
336 zone_name = ze->zone_name;
337 namelen = strlen(zone_name);
338 for (;;) {
339 if (fgets(buf, sizeof (buf), index_file) == NULL) {
340 if (operation == PZE_ADD && !exist) {
341 zone_state = zone_state_str(ze->zone_state);
342 zone_path = ze->zone_path;
343 zone_uuid = "";
344 goto add_entry;
345 }
346 /*
347 * It's not considered an error to delete something
348 * that doesn't exist, but we can't modify a missing
349 * record.
350 */
351 if (operation == PZE_MODIFY && !exist) {
352 err = Z_UPDATING_INDEX;
353 goto error;
354 }
355 break;
356 }
357
358 if (buf[0] == '#') {
359 /* skip and preserve comment lines */
360 (void) fputs(buf, tmp_file);
361 continue;
362 }
363
364 if (strncmp(buf, zone_name, namelen) != 0 ||
365 buf[namelen] != ':') {
366 /* skip and preserve non-target lines */
367 (void) fputs(buf, tmp_file);
368 continue;
369 }
370
371 if ((cp = strpbrk(buf, "\r\n")) == NULL) {
372 /* this represents a line that's too long; delete */
373 continue;
374 }
375 *cp = '\0';
376
377 /*
378 * Skip over the zone name. Because we've already matched the
379 * target zone (above), we know for certain here that the zone
380 * name is present and correctly formed. No need to check.
381 */
382 cp = strchr(buf, ':') + 1;
383
384 zone_state = gettok(&cp);
385 if (*zone_state == '\0') {
386 /* state field should not be empty */
387 err = Z_UPDATING_INDEX;
388 goto error;
389 }
390 zone_path = gettok(&cp);
391 zone_uuid = gettok(&cp);
392
393 switch (operation) {
394 case PZE_ADD:
395 /* can't add same zone */
396 err = Z_UPDATING_INDEX;
397 goto error;
398
399 case PZE_MODIFY:
400 /*
401 * If the caller specified a new state for the zone,
402 * then use that. Otherwise, use the current state.
403 */
404 if (ze->zone_state >= 0) {
405 zone_state = zone_state_str(ze->zone_state);
406
407 /*
408 * If the caller is uninstalling this zone,
409 * then wipe out the uuid. The zone's contents
410 * are no longer known.
411 */
412 if (ze->zone_state < ZONE_STATE_INSTALLED)
413 zone_uuid = "";
414 }
415
416 /* If a new name is supplied, use it. */
417 if (ze->zone_newname[0] != '\0')
418 zone_name = ze->zone_newname;
419
420 if (ze->zone_path[0] != '\0')
421 zone_path = ze->zone_path;
422 break;
423
424 case PZE_REMOVE:
425 default:
426 continue;
427 }
428
429 add_entry:
430 /*
431 * If the entry in the file is in greater than configured
432 * state, then we must have a UUID. Make sure that we do.
433 * (Note that the file entry is only tokenized, not fully
434 * parsed, so we need to do a string comparison here.)
435 */
436 if (strcmp(zone_state, ZONE_STATE_STR_CONFIGURED) != 0 &&
437 *zone_uuid == '\0') {
438 if (uuid_is_null(ze->zone_uuid))
439 uuid_generate(ze->zone_uuid);
440 uuid_unparse(ze->zone_uuid, uuidstr);
441 zone_uuid = uuidstr;
442 }
443 /*
444 * We need to quote a path that contains a ":"; this should
445 * only affect the zonepath, as zone names do not allow such
446 * characters, and zone states do not have them either. Same
447 * with double-quotes themselves: they are not allowed in zone
448 * names, and do not occur in zone states, and in theory should
449 * never occur in a zonepath since zonecfg does not support a
450 * method for escaping them.
451 */
452 need_quotes = (strchr(zone_path, ':') != NULL);
453 (void) fprintf(tmp_file, "%s:%s:%s%s%s:%s\n", zone_name,
454 zone_state, need_quotes ? "\"" : "", zone_path,
455 need_quotes ? "\"" : "", zone_uuid);
456 exist = B_TRUE;
457 }
458
459 (void) fclose(index_file);
460 index_file = NULL;
461 if (fclose(tmp_file) != 0) {
462 tmp_file = NULL;
463 err = Z_MISC_FS;
464 goto error;
465 }
466 tmp_file = NULL;
467 if (rename(tmp_file_name, path) == -1) {
468 err = errno == EACCES ? Z_ACCES : Z_MISC_FS;
469 goto error;
470 }
471 free(tmp_file_name);
472 if (unlock_index_file(lock_fd) != Z_OK)
473 return (Z_UNLOCKING_FILE);
474 return (Z_OK);
475
476 error:
477 if (index_file != NULL)
478 (void) fclose(index_file);
479 if (tmp_file != NULL)
480 (void) fclose(tmp_file);
481 (void) unlink(tmp_file_name);
482 free(tmp_file_name);
483 (void) unlock_index_file(lock_fd);
484 return (err);
485 }