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 /*
23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 * Copyright 2015 Nexenta Systems, Inc. All rights reserved.
26 */
27
28 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
29 /* All Rights Reserved */
30
31
32 #include <stdio.h>
33 #include <sys/types.h>
34 #include <sys/stat.h>
35 #include <archives.h>
36 #include <errno.h>
37 #include <fcntl.h>
38 #include <limits.h>
39 #include <stdlib.h>
40 #include <unistd.h>
41 #include <string.h>
42 #include "pkglocale.h"
43 #include "pkglibmsgs.h"
44
45 /*
46 * Defines for cpio/compression checks.
47 */
48 #define BIT_MASK 0x1f
49 #define BLOCK_MASK 0x80
50
51 #define MASK_CK(x, y) (((x) & (y)) == (y))
52 #define ISCOMPCPIO ((unsigned char) cm.c_mag[0] == m_h[0] && \
53 (unsigned char) cm.c_mag[1] == m_h[1] && \
54 (MASK_CK((unsigned char) cm.c_mag[2], BLOCK_MASK) || \
55 MASK_CK((unsigned char) cm.c_mag[2], BIT_MASK)))
56
57 #define ISCPIO (cm.b_mag != CMN_BIN && \
58 (strcmp(cm.c_mag, CMS_ASC) == 0) && \
59 (strcmp(cm.c_mag, CMS_CHR) == 0) && \
60 (strcmp(cm.c_mag, CMS_CRC) == 0))
61
62 /* location of distributed file system types database */
63
64 #define REMOTE_FS_DBFILE "/etc/dfs/fstypes"
65
66 /* character array used to hold dfs types database contents */
67
68 static long numRemoteFstypes = -1;
69 static char **remoteFstypes = (char **)NULL;
70
71 /* forward declarations */
72
73 static void _InitRemoteFstypes(void);
74
75 int isFdRemote(int a_fd);
76 int isPathRemote(char *a_path);
77 int isFstypeRemote(char *a_fstype);
78 int isdir(char *path);
79 int isfile(char *dir, char *file);
80 int iscpio(char *path, int *iscomp);
81
82 /*
83 * Name: isdir
84 * Description: determine if specified path exists and is a directory
85 * Arguments: path - pointer to string representing the path to verify
86 * returns: 0 - directory exists
87 * 1 - directory does not exist or is not a directory
88 * NOTE: errno is set appropriately
89 */
90
91 int
92 isdir(char *path)
93 {
94 struct stat statbuf;
95
96 /* return error if path does not exist */
97
98 if (stat(path, &statbuf) != 0) {
99 return (1);
100 }
101
102 /* return error if path is not a directory */
103
104 if ((statbuf.st_mode & S_IFMT) != S_IFDIR) {
105 errno = ENOTDIR;
106 return (1);
107 }
108
109 return (0);
110 }
111
112 /*
113 * Name: isfile
114 * Description: determine if specified path exists and is a directory
115 * Arguments: dir - pointer to string representing the directory where
116 * the file is located
117 * == NULL - use "file" argument only
118 * file - pointer to string representing the file to verify
119 * Returns: 0 - success - file exists
120 * 1 - failure - file does not exist OR is not a file
121 * NOTE: errno is set appropriately
122 */
123
124 int
125 isfile(char *dir, char *file)
126 {
127 struct stat statbuf;
128 char path[PATH_MAX];
129
130 /* construct full path if directory specified */
131
132 if (dir) {
133 (void) snprintf(path, sizeof (path), "%s/%s", dir, file);
134 file = path;
135 }
136
137 /* return error if path does not exist */
138
139 if (stat(file, &statbuf) != 0) {
140 return (1);
141 }
142
143 /* return error if path is a directory */
144
145 if ((statbuf.st_mode & S_IFMT) == S_IFDIR) {
146 errno = EISDIR;
147 return (1);
148 }
149
150 /* return error if path is not a file */
151
152 if ((statbuf.st_mode & S_IFMT) != S_IFREG) {
153 errno = EINVAL;
154 return (1);
155 }
156
157 return (0);
158 }
159
160 int
161 iscpio(char *path, int *iscomp)
162 {
163 /*
164 * Compressed File Header.
165 */
166 unsigned char m_h[] = { "\037\235" }; /* 1F 9D */
167
168 static union {
169 short int b_mag;
170 char c_mag[CMS_LEN];
171 } cm;
172
173 struct stat statb;
174 int fd;
175
176
177 *iscomp = 0;
178
179 if ((fd = open(path, O_RDONLY, 0)) == -1) {
180 if (errno != ENOENT) {
181 perror("");
182 (void) fprintf(stderr, pkg_gt(ERR_ISCPIO_OPEN), path);
183 }
184 return (0);
185 } else {
186 if (fstat(fd, &statb) == -1) {
187 perror("");
188 (void) fprintf(stderr, pkg_gt(ERR_ISCPIO_FSTAT), path);
189 (void) close(fd);
190 return (0);
191 } else {
192 if (S_ISREG(statb.st_mode)) { /* Must be a file */
193 if (read(fd, cm.c_mag, sizeof (cm.c_mag)) !=
194 sizeof (cm.c_mag)) {
195 perror("");
196 (void) fprintf(stderr,
197 pkg_gt(ERR_ISCPIO_READ), path);
198 (void) close(fd);
199 return (0);
200 }
201 /*
202 * Try to determine if the file is a compressed
203 * file, if that fails, try to determine if it
204 * is a cpio archive, if that fails, then we
205 * fail!
206 */
207 if (ISCOMPCPIO) {
208 *iscomp = 1;
209 (void) close(fd);
210 return (1);
211 } else if (ISCPIO) {
212 (void) fprintf(stderr,
213 pkg_gt(ERR_ISCPIO_NOCPIO),
214 path);
215 (void) close(fd);
216 return (0);
217 }
218 (void) close(fd);
219 return (1);
220 } else {
221 (void) close(fd);
222 return (0);
223 }
224 }
225 }
226 }
227
228 /*
229 * Name: isPathRemote
230 * Description: determine if a path object is local or remote
231 * Arguments: a_path - [RO, *RO] - (char *)
232 * Pointer to string representing the path to check
233 * Returns: int
234 * 1 - the path is remote
235 * 0 - the path is local to this system
236 * -1 - cannot determine if path is remote or local
237 */
238
239 int
240 isPathRemote(char *a_path)
241 {
242 int r;
243 struct stat statbuf;
244
245 r = lstat(a_path, &statbuf);
246 if (r < 0) {
247 return (-1);
248 }
249
250 return (isFstypeRemote(statbuf.st_fstype));
251 }
252
253 /*
254 * Name: isFdRemote
255 * Description: determine if an open file is local or remote
256 * Arguments: a_fd - [RO, *RO] - (int)
257 * Integer representing open file to check
258 * Returns: int
259 * 1 - the path is remote
260 * 0 - the path is local to this system
261 * -1 - cannot determine if path is remote or local
262 */
263
264 int
265 isFdRemote(int a_fd)
266 {
267 int r;
268 struct stat statbuf;
269
270 r = fstat(a_fd, &statbuf);
271 if (r < 0) {
272 return (-1);
273 }
274
275 return (isFstypeRemote(statbuf.st_fstype));
276 }
277
278 /*
279 * Name: isFstypeRemote
280 * Description: determine if a file system type is remote (distributed)
281 * Arguments: a_fstype - [RO, *RO] - (char *)
282 * Pointer to string representing the file system type
283 * to check
284 * Returns: int
285 * 1 - the file system type is remote
286 * 0 - the file system type is local to this system
287 */
288
289 int
290 isFstypeRemote(char *a_fstype)
291 {
292 int i;
293
294 /* initialize the list if it is not yet initialized */
295
296 _InitRemoteFstypes();
297
298 /* scan the list looking for the specified type */
299
300 for (i = 0; i < numRemoteFstypes; i++) {
301 if (strcmp(remoteFstypes[i], a_fstype) == 0) {
302 return (1);
303 }
304 }
305
306 /* type not found in remote file system type list - is not remote */
307
308 return (0);
309 }
310
311 /*
312 * Name: _InitRemoteFstypes
313 * Description: initialize table of remote file system type names
314 * Arguments: none
315 * Returns: none
316 * Side Effects:
317 * - The global array "(char **)remoteFstypes" is set to the
318 * address of an array of string pointers, each of which represents
319 * a single remote file system type
320 * - The global variable "(long) numRemoteFstypes" is set to the total
321 * number of remote file system type strings (names) that are
322 * contained in the "remoteFstypes" global array.
323 * - numRemoteFstypes is initialized to "-1" before any attempt has been
324 * made to read the remote file system type name database.
325 */
326 static void
327 _InitRemoteFstypes(void)
328 {
329 FILE *fp;
330 char line_buf[LINE_MAX];
331
332 /* return if already initialized */
333
334 if (numRemoteFstypes > 0) {
335 return;
336 }
337
338 /* if list is uninitialized, start with zero */
339
340 if (numRemoteFstypes == -1) {
341 numRemoteFstypes = 0;
342 }
343
344 /* open the remote file system type database file */
345
346 if ((fp = fopen(REMOTE_FS_DBFILE, "r")) == NULL) {
347 /* no remote type database: use predefined remote types */
348 remoteFstypes = (char **)realloc(remoteFstypes,
349 sizeof (char *) * (numRemoteFstypes+2));
350 remoteFstypes[numRemoteFstypes++] = "nfs"; /* +1 */
351 remoteFstypes[numRemoteFstypes++] = "autofs"; /* +2 */
352 return;
353 }
354
355 /*
356 * Read the remote file system type database; from fstypes(4):
357 *
358 * fstypes resides in directory /etc/dfs and lists distributed file
359 * system utilities packages installed on the system. For each installed
360 * distributed file system type, there is a line that begins with the
361 * file system type name (for example, ``nfs''), followed by white space
362 * and descriptive text.
363 *
364 * Lines will look at lot like this:
365 *
366 * nfs NFS Utilities
367 * autofs AUTOFS Utilities
368 */
369
370 while (fgets(line_buf, sizeof (line_buf), fp) != NULL) {
371 char buf[LINE_MAX];
372 static char format[128] = {'\0'};
373
374 if (format[0] == '\0') {
375 /* create bounded format: %ns */
376 (void) snprintf(format, sizeof (format),
377 "%%%ds", sizeof (buf)-1);
378 }
379
380 (void) sscanf(line_buf, format, buf);
381
382 remoteFstypes = realloc(remoteFstypes,
383 sizeof (char *) * (numRemoteFstypes+1));
384 remoteFstypes[numRemoteFstypes++] = strdup(buf);
385 }
386
387 /* close database file and return */
388
389 (void) fclose(fp);
390 }