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 2006 Sun Microsystems, Inc.  All rights reserved.

    23  * Use is subject to license terms.

    24  */

    25 

    26 #pragma ident	"%Z%%M%	%I%	%E% SMI"

    27 

    28 /*

    29  *	Change the label of a file

    30  */

    31 

    32 #include <ctype.h>

    33 #include <locale.h>

    34 #include <stdio.h>

    35 #include <stdlib.h>

    36 #include <strings.h>

    37 #include <errno.h>

    38 

    39 #include <tsol/label.h>

    40 

    41 #include "labeld.h"

    42 #include <sys/tsol/label_macro.h>

    43 

    44 #include <sys/types.h>

    45 

    46 #include <zone.h>

    47 #include <sys/zone.h>

    48 #include <sys/param.h>

    49 #include <string.h>

    50 

    51 static int abspath(char *, const char *, char *);

    52 

    53 /*

    54  * setflabel(3TSOL) - set file label

    55  *

    56  * This is the library interface to the door call.

    57  */

    58 

    59 #define	clcall callp->param.acall.cargs.setfbcl_arg

    60 #define	clret callp->param.aret.rvals.setfbcl_ret

    61 /*

    62  *

    63  *	Exit	error = If error reported, the error indicator,

    64  *				-1, Unable to access label encodings file;

    65  *				 0, Invalid binary label passed;

    66  *				>0, Position after the first character in

    67  *				    string of error, 1 indicates entire string.

    68  *			Otherwise, unchanged.

    69  *

    70  *	Returns	0, If error.

    71  *		1, If successful.

    72  *

    73  *	Calls	__call_labeld(SETFLABEL)

    74  *

    75  */

    76 

    77 int

    78 setflabel(const char *path, m_label_t *label)

    79 {

    80 	labeld_data_t	call;

    81 	labeld_data_t	*callp = &call;

    82 	size_t	bufsize = sizeof (labeld_data_t);

    83 	size_t	datasize;

    84 	size_t	path_len;

    85 	static char	cwd[MAXPATHLEN];

    86 	char		canon[MAXPATHLEN];

    87 

    88 

    89 	/*

    90 	 * If path is relative and we haven't already determined the current

    91 	 * working directory, do so now.  Calculating the working directory

    92 	 * here lets us do the work once, instead of (potentially) repeatedly

    93 	 * in realpath().

    94 	 */

    95 	if (*path != '/' && cwd[0] == '\0') {

    96 		if (getcwd(cwd, MAXPATHLEN) == NULL) {

    97 			cwd[0] = '\0';

    98 			return (-1);

    99 		}

   100 	}

   101 	/*

   102 	 * Find an absolute pathname in the native file system name space that

   103 	 * corresponds to path, stuffing it into canon.

   104 	 */

   105 	if (abspath(cwd, path, canon) < 0)

   106 		return (-1);

   107 

   108 	path_len = strlen(canon) + 1;

   109 

   110 	datasize = CALL_SIZE(setfbcl_call_t, path_len - BUFSIZE);

   111 	datasize += 2; /* PAD */

   112 

   113 	if (datasize > bufsize) {

   114 		if ((callp = (labeld_data_t *)malloc(datasize)) == NULL) {

   115 			return (-1);

   116 		}

   117 		bufsize = datasize;

   118 	}

   119 

   120 	callp->callop = SETFLABEL;

   121 

   122 	clcall.sl = *label;

   123 	(void) strcpy(clcall.pathname, canon);

   124 

   125 	if (__call_labeld(&callp, &bufsize, &datasize) == SUCCESS) {

   126 		int err = callp->reterr;

   127 

   128 		if (callp != &call) {

   129 			/* free allocated buffer */

   130 			free(callp);

   131 		}

   132 		/*

   133 		 * reterr == 0, OK,

   134 		 * reterr < 0, invalid binary label,

   135 		 */

   136 		if (err == 0) {

   137 			if (clret.status > 0) {

   138 				errno = clret.status;

   139 				return (-1);

   140 			} else {

   141 				return (0);

   142 			}

   143 		} else if (err < 0) {

   144 			err = 0;

   145 		}

   146 		errno = ECONNREFUSED;

   147 		return (-1);

   148 	} else {

   149 		if (callp != &call) {

   150 			/* free allocated buffer */

   151 			free(callp);

   152 		}

   153 		/* server not present */

   154 		errno = ECONNREFUSED;

   155 		return (-1);

   156 	}

   157 }  /* setflabel */

   158 

   159 #undef	clcall

   160 #undef	clret

   161 

   162 #define	clcall callp->param.acall.cargs.zcopy_arg

   163 #define	clret callp->param.aret.rvals.zcopy_ret

   164 /*

   165  *

   166  *	Exit	status = result of zone copy request

   167  *				-1, Copy not confirmed

   168  *			Otherwise, unchanged.

   169  *

   170  *	Returns	0, If error.

   171  *		1, If successful.

   172  *

   173  *	Calls	__call_labeld(ZCOPY)

   174  *

   175  */

   176 int

   177 zonecopy(m_label_t *src_win_sl, char *remote_dir, char *filename,

   178     char *local_dir, int  transfer_mode)

   179 {

   180 	labeld_data_t	call;

   181 	labeld_data_t	*callp = &call;

   182 	size_t		bufsize = sizeof (labeld_data_t);

   183 	size_t		datasize;

   184 	size_t		strings;

   185 	size_t		remote_dir_len;

   186 	size_t		filename_len;

   187 	size_t		local_dir_len;

   188 	size_t		display_len;

   189 	char		*display;

   190 

   191 	remote_dir_len = strlen(remote_dir) + 1;

   192 	filename_len = strlen(filename) + 1;

   193 	local_dir_len = strlen(local_dir) + 1;

   194 

   195 	if ((display = getenv("DISPLAY")) == NULL)

   196 		display = "";

   197 	display_len = strlen(display) + 1;

   198 

   199 	strings = remote_dir_len + filename_len + local_dir_len + display_len;

   200 

   201 	datasize = CALL_SIZE(zcopy_call_t, strings - BUFSIZE);

   202 

   203 	datasize += 4; /* PAD */

   204 

   205 	if (datasize > bufsize) {

   206 		if ((callp = (labeld_data_t *)malloc(datasize)) == NULL) {

   207 			return (NULL);

   208 		}

   209 		bufsize = datasize;

   210 	}

   211 

   212 	strings = 0;

   213 	callp->callop = ZCOPY;

   214 

   215 	clcall.src_win_sl = *src_win_sl;

   216 	clcall.transfer_mode = transfer_mode;

   217 	clcall.remote_dir = strings;

   218 	strings += remote_dir_len;

   219 	clcall.filename = strings;

   220 	strings += filename_len;

   221 	clcall.local_dir = strings;

   222 	strings += local_dir_len;

   223 	clcall.display = strings;

   224 

   225 	(void) strcpy(&clcall.buf[clcall.remote_dir], remote_dir);

   226 	(void) strcpy(&clcall.buf[clcall.filename], filename);

   227 	(void) strcpy(&clcall.buf[clcall.local_dir], local_dir);

   228 	(void) strcpy(&clcall.buf[clcall.display], display);

   229 

   230 	if (__call_labeld(&callp, &bufsize, &datasize) == SUCCESS) {

   231 		int err = callp->reterr;

   232 

   233 		if (callp != &call) {

   234 			/* free allocated buffer */

   235 			free(callp);

   236 		}

   237 		/*

   238 		 * reterr == 0, OK,

   239 		 * reterr < 0, transer not confirmed

   240 		 */

   241 		if (err == 0) {

   242 			return (clret.status);

   243 		} else if (err < 0) {

   244 			err = 0;

   245 		}

   246 		return (PIPEMSG_CANCEL);

   247 	} else {

   248 		if (callp != &call) {

   249 			/* free allocated buffer */

   250 			free(callp);

   251 		}

   252 		/* server not present */

   253 		return (PIPEMSG_CANCEL);

   254 	}

   255 }

   256 

   257 /*

   258  * Convert the path given in raw to canonical, absolute, symlink-free

   259  * form, storing the result in the buffer named by canon, which must be

   260  * at least MAXPATHLEN bytes long.  If wd is non-NULL, assume that it

   261  * points to a path for the current working directory and use it instead

   262  * of invoking getcwd; accepting this value as an argument lets our caller

   263  * cache the value, so that realpath (called from this routine) doesn't have

   264  * to recalculate it each time it's given a relative pathname.

   265  *

   266  * Return 0 on success, -1 on failure.

   267  */

   268 int

   269 abspath(char *wd, const char *raw, char *canon)

   270 {

   271 	char		absbuf[MAXPATHLEN];

   272 

   273 	/*

   274 	 * Preliminary sanity check.

   275 	 */

   276 	if (raw == NULL || canon == NULL)

   277 		return (-1);

   278 

   279 	/*

   280 	 * If the path is relative, convert it to absolute form,

   281 	 * using wd if it's been supplied.

   282 	 */

   283 	if (raw[0] != '/') {

   284 		char	*limit = absbuf + sizeof (absbuf);

   285 		char	*d;

   286 

   287 		/* Fill in working directory. */

   288 		if (wd != NULL)

   289 			(void) strncpy(absbuf, wd, sizeof (absbuf));

   290 		else if (getcwd(absbuf, strlen(absbuf)) == NULL)

   291 			return (-1);

   292 

   293 		/* Add separating slash. */

   294 		d = absbuf + strlen(absbuf);

   295 		if (d < limit)

   296 			*d++ = '/';

   297 

   298 		/* Glue on the relative part of the path. */

   299 		while (d < limit && (*d++ = *raw++))

   300 			continue;

   301 

   302 		raw = absbuf;

   303 	}

   304 

   305 	/*

   306 	 * Call realpath to canonicalize and resolve symlinks.

   307 	 */

   308 	return (realpath(raw, canon) == NULL ? -1 : 0);

   309 }