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