/*
* 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);
}