/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved. */ /* * Module: zones.c * Group: libinstzones * Description: Provide "zones" interface for install consolidation code * * Public Methods: * * _z_close_file_descriptors - close a file descriptor "a_fd" not in the * list "a_fds" * _z_echo - Output an interactive message if interaction is enabled * _z_echoDebug - Output a debugging message if debugging is enabled * _z_is_directory - determine if specified path exists and is a directory * _z_program_error - Output an error message to the appropriate destinations * _z_pluginCatchSigint - SIGINT/SIGHUP interrupt handler * _z_running_in_global_zone - Determine if this process is running in the * global zone * _z_zones_are_implemented - Determine if zones are supported by the * current system * _z_brands_are_implemented - determine if branded zones are implemented on * this system */ /* * System includes */ #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <fcntl.h> #include <ctype.h> #include <sys/types.h> #include <sys/param.h> #include <string.h> #include <strings.h> #include <sys/stat.h> #include <stdarg.h> #include <limits.h> #include <errno.h> #include <signal.h> #include <stropts.h> #include <libintl.h> #include <locale.h> #include <assert.h> #include <dlfcn.h> /* * local includes */ #include "instzones_lib.h" #include "zones_strings.h" /* * Private structures */ /* * these dynamic libraries are required in order to use the branded zones * functionality. If these libraries are not available at runtime, * then the zones we find are assumed to be native zones. */ #define BRAND1_LIBRARY "libbrand.so.1" #define BRAND_LIBRARY "libbrand.so" /* * Library Function Prototypes */ /* * Local Function Prototypes */ static void error_and_exit(int error_num); static void (*fatal_err_func)() = &error_and_exit; /* ----------------------- private functions -------------------------- */ /* * error_and_exit() * Abort routine. An exit code of '2' is used by all applications * to indicate a non-recoverable fatal error. * Parameters: * error_num - error index number: * ERR_MALLOC_FAIL * Return: * none * Status: * private */ static void error_and_exit(int error_num) { if (error_num == ERR_MALLOC_FAIL) (void) fprintf(stderr, "Allocation of memory failed\n"); else (void) fprintf(stderr, "ERROR: code %d\n", error_num); exit(2); } /* * ***************************************************************************** * global external (public) functions * ***************************************************************************** */ /* * Name: _z_close_file_descriptors * Description: close a file descriptor "a_fd" not in the list "a_fds" * This function is called from the fdwalk() library function. * If the file descriptor passed in is NOT in the list passed in, * the file is closed. * Arguments: a_fds - [RO, *RO] - (void *) * Pointer to list of file descriptors to keep open * a_fd - [RO, *RO] - (int) * File descriptor to check * Returns: int * 0 - success */ int _z_close_file_descriptors(void *a_fds, int a_fd) { int *fds; int i; /* do not close standard input, output, or error file descriptors */ if (a_fd == STDIN_FILENO || a_fd == STDOUT_FILENO || a_fd == STDERR_FILENO) { return (0); } /* if no file descriptor retention list, close this file */ if (a_fds == (void *)NULL) { (void) close(a_fd); return (0); } /* * retention list provided, skip this descriptor if its in the list */ fds = (int *)a_fds; for (i = 0; fds[i] != -1; i++) { if (fds[i] == a_fd) { return (0); } } /* this descriptor not in retention list - close this file */ (void) close(a_fd); return (0); } /* * Name: _z_echo * Synopsis: Output an interactive message if interaction is enabled * Description: Main method for outputting an interactive message; call to * output interactive message if interation has not been disabled * by a previous call to echoSetFlag(0). * Arguments: format - [RO, RO*] (char *) * printf-style format for debugging message to be output * VARG_LIST - [RO] (?) * arguments as appropriate to 'format' specified * Returns: void */ /*PRINTFLIKE1*/ void _z_echo(char *a_format, ...) { va_list ap; char message[MAX_MESSAGE_SIZE]; /* entry assertions */ assert(a_format != NULL); /* return if no progerr function registered */ if (_z_global_data._z_echo == NULL) { return; } /* capture message */ va_start(ap, a_format); (void) vsnprintf(message, sizeof (message), a_format, ap); va_end(ap); /* pass message to registered function */ (_z_global_data._z_echo)("%s", message); } /* * Name: _z_echoDebug * Synopsis: Output a debugging message if debugging is enabled * Description: Main method for outputting a debugging message; call to * output debugging message if debugging has been enabled * by a previous call to _z_echoDebugSetFlag(1). * Arguments: format - [RO, RO*] (char *) * printf-style format for debugging message to be output * VARG_LIST - [RO] (?) * arguments as appropriate to 'format' specified * Returns: void * NOTE: format of message will be: * # [ aaa bbb ccc ] message * where: aaa - process i.d. * bbb - zone i.d. * ccc - name of program * for example: * # [ 25685 0 pkgadd ] unable to get package list */ /*PRINTFLIKE1*/ void _z_echoDebug(char *a_format, ...) { va_list ap; char message[MAX_MESSAGE_SIZE]; /* entry assertions */ assert(a_format != NULL); /* return if no progerr function registered */ if (_z_global_data._z_echo_debug == NULL) { return; } /* capture message */ va_start(ap, a_format); (void) vsnprintf(message, sizeof (message), a_format, ap); va_end(ap); /* pass message to registered function */ (_z_global_data._z_echo_debug)("%s", message); } /* * Name: _z_is_directory * Description: determine if specified path exists and is a directory * Arguments: path - pointer to string representing the path to verify * returns: 0 - directory exists * 1 - directory does not exist or is not a directory * NOTE: errno is set appropriately */ int _z_is_directory(char *path) { struct stat statbuf; /* entry assertions */ assert(path != NULL); assert(*path != '\0'); /* return error if path does not exist */ if (stat(path, &statbuf) != 0) { return (1); } /* return error if path is not a directory */ if ((statbuf.st_mode & S_IFMT) != S_IFDIR) { errno = ENOTDIR; return (1); } /* path exists and is a directory */ return (0); } /* * Name: _z_pluginCatchSigint * Synopsis: SIGINT/SIGHUP interrupt handler * Description: Catch the "SIGINT" and "SIGHUP" signals: * -> increment _z_SigReceived global variable * -> propagate signal to "_z_ChildProcessId" if registered (!= -1) * Arguments: signo - [RO, *RO] - (int) * Signal number that was caught * Returns: void */ void _z_sig_trap(int a_signo) { /* bump signals received count */ _z_global_data._z_SigReceived++; /* if child process registered, propagate signal to child */ if (_z_global_data._z_ChildProcessId > 0) { (void) kill(_z_global_data._z_ChildProcessId, a_signo); } } /* * Name: _z_program_error * Description: Output an error message to the appropriate destinations * Arguments: format - [RO, RO*] (char *) * printf-style format for debugging message to be output * VARG_LIST - [RO] (?) * arguments as appropriate to 'format' specified * Returns: void * NOTE: format of message will be: * [aaa: ] ERROR: message * where: aaa - program name (if set) * message - results of format and arguments * for example: * ERROR: unable to get package list */ /*PRINTFLIKE1*/ void _z_program_error(char *a_format, ...) { va_list ap; char message[MAX_MESSAGE_SIZE]; /* entry assertions */ assert(a_format != NULL); /* return if no progerr function registered */ if (_z_global_data._z_progerr == NULL) { return; } /* capture message */ va_start(ap, a_format); (void) vsnprintf(message, sizeof (message), a_format, ap); va_end(ap); /* pass message to registered function */ (_z_global_data._z_progerr)(MSG_PROG_ERR, message); } /* * Name: _z_running_in_global_zone * Synopsis: Determine if this process is running in the global zone * Arguments: void * Returns: boolean_t * == B_TRUE - this process is running in the global zone * == B_FALSE - this process is running in a nonglobal zone */ boolean_t _z_running_in_global_zone(void) { zoneid_t zoneid = (zoneid_t)-1; /* * if zones are not implemented, there is no way to tell if zones * are supported or not - in this case, we can only be running in the * global zone (since non-global zones cannot exist) so return TRUE */ if (z_zones_are_implemented() == B_FALSE) { return (B_TRUE); } /* get the zone i.d. of the current zone */ zoneid = getzoneid(); /* return TRUE if this is the global zone i.d. */ if (zoneid == GLOBAL_ZONEID) { return (B_TRUE); } /* return FALSE - not in the global zone */ return (B_FALSE); } /* * Name: _z_zones_are_implemented * Synopsis: Determine if zones are supported by the current system * Arguments: void * Returns: boolean_t * == B_TRUE - zones are supported * == B_FALSE - zones are not supported */ boolean_t _z_zones_are_implemented(void) { void *libptr = NULL; /* locate zone cfg library */ libptr = dlopen(ZONECFG_LIBRARY, RTLD_NOW|RTLD_GLOBAL); if (libptr == (void *)NULL) { _z_echoDebug(DBG_LIBRARY_NOT_FOUND, ZONECFG_LIBRARY, dlerror()); libptr = dlopen(ZONECFG1_LIBRARY, RTLD_NOW|RTLD_GLOBAL); } /* return false if library not available */ if (libptr == (void *)NULL) { _z_echoDebug(DBG_LIBRARY_NOT_FOUND, ZONECFG1_LIBRARY, dlerror()); return (B_FALSE); } /* library available - close handle */ (void) dlclose(libptr); /* locate contract filesystem library */ libptr = dlopen(CONTRACT_LIBRARY, RTLD_NOW|RTLD_GLOBAL); if (libptr == (void *)NULL) { _z_echoDebug(DBG_LIBRARY_NOT_FOUND, CONTRACT_LIBRARY, dlerror()); libptr = dlopen(CONTRACT1_LIBRARY, RTLD_NOW|RTLD_GLOBAL); } /* return false if library not available */ if (libptr == (void *)NULL) { _z_echoDebug(DBG_LIBRARY_NOT_FOUND, CONTRACT1_LIBRARY, dlerror()); return (B_FALSE); } /* library available - close handle */ (void) dlclose(libptr); /* return success */ return (B_TRUE); } boolean_t _z_brands_are_implemented(void) { void *libptr; /* locate brand library */ libptr = dlopen(BRAND_LIBRARY, RTLD_NOW|RTLD_GLOBAL); if (libptr == NULL) { _z_echoDebug(DBG_LIBRARY_NOT_FOUND, BRAND_LIBRARY, dlerror()); libptr = dlopen(BRAND1_LIBRARY, RTLD_NOW|RTLD_GLOBAL); } /* return false if library not available */ if (libptr == NULL) { _z_echoDebug(DBG_LIBRARY_NOT_FOUND, BRAND1_LIBRARY, dlerror()); return (B_FALSE); } /* library available - close handle */ (void) dlclose(libptr); /* return success */ return (B_TRUE); } /* * z_calloc() * Allocate 'size' bytes from the heap using calloc() * Parameters: * size - number of bytes to allocate * Return: * NULL - calloc() failure * void * - pointer to allocated structure * Status: * public */ void * _z_calloc(size_t size) { void * tmp; if ((tmp = (void *) malloc(size)) == NULL) { fatal_err_func(ERR_MALLOC_FAIL); return (NULL); } (void) memset(tmp, 0, size); return (tmp); } /* * z_malloc() * Alloc 'size' bytes from heap using malloc() * Parameters: * size - number of bytes to malloc * Return: * NULL - malloc() failure * void * - pointer to allocated structure * Status: * public */ void * _z_malloc(size_t size) { void *tmp; if ((tmp = (void *) malloc(size)) == NULL) { fatal_err_func(ERR_MALLOC_FAIL); return (NULL); } else return (tmp); } /* * _z_realloc() * Calls realloc() with the specfied parameters. _z_realloc() * checks for realloc failures and adjusts the return value * automatically. * Parameters: * ptr - pointer to existing data block * size - number of bytes additional * Return: * NULL - realloc() failed * void * - pointer to realloc'd structured * Status: * public */ void * _z_realloc(void *ptr, size_t size) { void *tmp; if ((tmp = (void *)realloc(ptr, size)) == (void *)NULL) { fatal_err_func(ERR_MALLOC_FAIL); return ((void *)NULL); } else return (tmp); } /* * z_strdup() * Allocate space for the string from the heap, copy 'str' into it, * and return a pointer to it. * Parameters: * str - string to duplicate * Return: * NULL - duplication failed or 'str' was NULL * char * - pointer to newly allocated/initialized structure * Status: * public */ void * _z_strdup(char *str) { char *tmp; if (str == NULL) return ((char *)NULL); if ((tmp = strdup(str)) == NULL) { fatal_err_func(ERR_MALLOC_FAIL); return ((char *)NULL); } else return (tmp); }
