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
setflabel(const char * path,m_label_t * label)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
zonecopy(m_label_t * src_win_sl,char * remote_dir,char * filename,char * local_dir,int transfer_mode)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
abspath(char * wd,const char * raw,char * canon)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 }
310